Implémentation d’un GLM :

1. Understand your data:

1. Data Collection Review:
where the data came from:
who collected it:
what methodologies were used:
what definitions were applied:
the discrepancies and alignment in data collection methodology:

2. Descriptive Statistics:
central tendency:
dispersion:
shape of a dataset’s distribution:
Functions in Python such as `describe()` in pandas can provide quick insights into your
numerical variables - count, mean, standard deviation, minimum and maximum values, and
the quartiles.

3. Data Structure and Types:

Table latex
Categorical:
 Region one hot encoding
 Cover- one hot encoding
 Type of vehicle

Time related:

 Occurencia
 Desde / Hasta -> Possibility to create new data to use as quantitative data

Quantitative:

 Monto/Reserva -> Possibility to use tsfresh

 Vehicle year buy date
 Feature engineering:
o Price
o Hp/wgt ratio

Sujet de liaison via R des différentes bases :

4. Data Distribution:
Visualize your data to understand their distributions. Histograms, box plots, and density
plots are useful for continuous variables. For categorical variables, consider bar plots. Check
for skewness and kurtosis in your variables.

5. Missing Values:
 Check your data for missing values. Depending on how much data you're missing, you might
decide to impute the missing values or drop the rows or columns that contain them.
Visualizations like missingno matrix can help in understanding the missingness pattern.

6. Outliers:
Detect outliers in your data. Outliers might be errors, but they can also be valuable pieces
of information. Boxplots and scatter plots can help you visually identify outliers.

7. Relationships Between Variables:

Try to understand relationships and correlations between your different variables. Scatter
plots, pair plots, or correlation matrices can be useful for this. Remember that correlation
does not imply causation.

8. Temporal Patterns (if applicable):

- Possibilité d’utiliser le module tsfresh
If your data is time-series data, look at how your data changes over time. Line plots are a
good tool for this.

9. Feature Engineering Possibilities:

 Specific scraping : As you're exploring your data, start thinking about possible feature
engineering opportunities. Feature engineering is the process of creating new features or
modifying existing features to improve your machine learning model's performance.

10. Document Findings:

Document everything you find during this process, as it could be helpful later on during the
preprocessing, modeling, and interpretation stages.

Remember, the goal of this stage is to become a subject matter expert on your dataset. The
better you understand your data, the better equipped you'll be to build an effective model.

2. Preprocess your data: (2h)

1. Handle Missing Values:

The first step in preprocessing should be handling missing values, as many algorithms do not
handle them well. Here are a few strategies:

- Imputation: Replace missing values with statistical measures such as mean, median or
mode.
- Prediction: Use a machine learning algorithm to predict missing values. This could be a
simple model like linear regression for continuous data or logistic regression for categorical
data.
- Deletion: If only a few rows contain missing values, and if those rows aren’t crucial, they can
be deleted. However, be careful, as this can lead to bias if the missing data is not missing
completely at random.

2. Encode Categorical Variables:

Many machine learning models require the input data to be numerical. If your data contains
categorical variables, you'll need to encode them as numbers. Here are two common
methods:

- One-Hot Encoding: This method creates new columns indicating the presence (or absence)
of each possible value in the original data.
- Label Encoding: This method converts each value in a column to a number. Useful for
ordinal data where the order matters.

3. Handle Outliers:

Depending on the context and the specific algorithms you want to use, you might want to
handle outliers in your data. Outliers can skew statistical measures and data distributions,
leading to misleading results.

- Winsorization: This method limits the extreme values in the data to reduce the impact of
spurious outliers. However, it doesn’t entirely eliminate the impact of these extreme values.
- Trimming: This completely removes the data outliers from the dataset, but it could lead to
losing valuable information in the case that those outliers were genuine observations and not
errors.

4. Scale Numerical Variables:

Many machine learning algorithms perform better when numerical input variables are scaled
to a standard range. This includes algorithms that use a weighted sum of the input, like linear
regression, and algorithms that use distance measures, like k-nearest neighbors.

- Normalization / Min-Max Scaling: This method scales and shifts the features so that they
range from zero to one.
- Standardization / Z-Score Normalization: This method standardizes features by removing
the mean and scaling to unit variance.

5. Feature Engineering:

Creating new informative features can often help improve the performance of machine
learning models. This could involve arithmetic combinations of features, grouping sparse
classes in categorical features, creating interaction features, etc.

6. Splitting the Data:

Finally, you should split your data into a training set and a test set. The training set is used to
train the model, while the test set is used to evaluate the model's performance on unseen
data.

7. Apply Transformations:
 Certain machine learning algorithms might assume that your data follows a normal
distribution. If your data is heavily skewed, applying a transformation like a logarithm or
square root can help.

Each of these steps may or may not be necessary depending on your data and the specific
algorithms you're planning to use. The best approach is to understand your data and use this
understanding to guide your preprocessing decisions.

3. Choose the appropriate GLM family: Inverse gaussian

Generalized Linear Models (GLMs) offer a flexible generalization of ordinary linear regression
models, allowing for response variables that have error distribution models other than a
normal distribution. The GLM generalizes linear regression by allowing the linear model to be
related to the response variable via a link function.

Choosing the appropriate GLM family is crucial to a successful model. Here are some
common GLM families and their applications:

1. Gaussian: This family should be chosen when your response variable is normally
distributed. It's used for regression problems where the output is a real value (like the cost of
a house).

2. Binomial: This family should be chosen when your response variable is binary. It's often
used for classification problems where the output is either 0 or 1.

3. Poisson: This family should be chosen when your response variable is a count (i.e., non-
negative integers). It assumes that the mean and variance of your response variable are the
same.

4. Negative Binomial: This family is an alternative to the Poisson family when the variance of
your response variable is larger than the mean (i.e., overdispersion).

5. Gamma: This family should be chosen when your response variable is continuous and non-
negative, and the reciprocal of the variance is linearly related to the mean. It's often used
when modeling time till some event or when modeling amounts.

4. Train your model: (30min)

Here's how you might implement a GLM in Python using the `statsmodels` library, which
offers more statistical insights compared to the `sklearn`:

```python
import statsmodels.api as sm

# add constant to your data if necessary

X_train = sm.add_constant(X_train)
 # create a model (example with binomial family for a logistic regression case)
model = sm.GLM(y_train, X_train, family=sm.families.Binomial())

# train the model

model_results = model.fit()
```

5. Evaluate your model:

After training your model, it's important to evaluate its performance to understand how well
it's doing. Here's how you can do that for your Generalized Linear Model (GLM):

1. Calculate error metrics:

There are many error metrics you could use, but here are a few that are commonly used for
regression problems:

- Mean Absolute Error (MAE): This is the average absolute difference between the predicted
and actual values.

- Root Mean Square Error (RMSE): This is the square root of the average of the squared
differences between the predicted and actual values. It can be more sensitive to large errors
compared to MAE because it squares the differences.

- R-squared : This represents the proportion of variance in the dependent variable that can
be explained by the independent variables. The higher the R-squared, the better the model
fits your data.

- Adjusted R-squared: This is similar to R-squared but takes the number of predictors into
account. It's particularly useful when comparing models with different numbers of predictors.

2. Plot residuals:

Residual plots can be very useful for understanding your model's performance. The residuals
are the differences between the actual and predicted values. Ideally, you'd want your
residuals to be randomly scattered around zero.

3. Check assumptions:

GLMs make several assumptions (e.g., about the distribution of the residuals). It's important
to check these assumptions because if they're violated, your model's predictions could be
unreliable.

You can check the normality of the residuals by using a Q-Q plot and the homoscedasticity by
using a scale-location plot:
 Remember, evaluating your model isn't just about getting good numbers. It's also about
understanding your model's weaknesses, validating its assumptions, and gaining insights to
help improve it.

6. Feature Selection:
Feature selection is a critical process in machine learning, which involves selecting the most
useful features (input variables) to use in modeling. Effective feature selection can result in
simpler, more interpretable models that perform better on unseen data.

Here are some methods that can be used for feature selection with a Generalized Linear
Model (GLM):

1. Univariate Selection:
One common method for univariate selection is the chi-squared test. This test is used to
determine if there's a significant association between two categorical variables. For numerical
variables, you might use a correlation coefficient (like Pearson's) or a simple linear regression.

2. Recursive Feature Elimination (RFE):

RFE is a greedy optimization algorithm that aims to find the best performing feature subset. It
repeatedly creates models and keeps aside the best or the worst performing feature at each
iteration. It constructs the next model with the left features until all the features are
exhausted. Then it ranks the features based on the order of their elimination.

3. Regularization methods (L1/Lasso and L2/Ridge):

Regularization methods introduce additional constraints into the optimization of a predictive
algorithm (like a GLM) that bias the model toward lower complexity (fewer coefficients).

Both L1 (Lasso) and L2 (Ridge) work by penalizing the magnitude of the coefficients of
features and at the same time minimizing the error between the predicted and actual
observations. The key difference is that Lasso shrinks the less important feature’s coefficient
to zero, effectively excluding some features. Ridge regression, on the other hand, doesn't
exclude them but it does reduce their impact.

4. Feature Importance from Tree-based models:

Tree-based models like decision trees, random forests, and gradient boosting can be used to
rank features by importance, which can be used for feature selection.

```python
from sklearn.linear_model import LassoCV

# Define model with Lasso (L1) regularization

lasso = LassoCV()

Remember that feature selection methods are not one-size-fits-all. Depending on the dataset
and the problem at hand, different methods might yield better results. As such, it's worth
trying different methods and combinations of methods to find what works best.

7. Check for model assumptions: (1h)

 When using Generalized Linear Models (GLMs), there are some key assumptions that need to
be satisfied for the model to provide reliable and interpretable results. Here's a rundown of
those assumptions and how you can check them:

1. Linear relationship:

GLMs assume that there's a linear relationship between the predictors and the response
variable. If you're dealing with a single predictor, you can check this assumption by plotting
the predictor against the response and checking if the data appears to follow a linear trend.

If you're dealing with multiple predictors, it's more challenging to check this assumption, but
one approach is to look at the residuals (the differences between the observed and predicted
responses) against the predicted responses. If there's a clear pattern in the residuals (like a
curve), it might suggest that the relationship is not linear.

2. Independence of errors:

The residuals should be independent, which means that the residuals for one observation
shouldn't predict the residuals for another. This assumption can be tricky to test, but if your
data is a time series or has some sort of grouping, you should be particularly careful about it.
A Durbin-Watson test can be used to check for autocorrelation in the residuals.

3. Homoscedasticity:

The variance of the residuals should be constant. This means that the spread of the residuals
should be about the same across all levels of the predictors. This can be checked with a
scatter plot of residuals vs predicted values as well. If the plot shows a funnel shape, it
suggests that the model suffers from heteroscedasticity.

4. Distribution of errors:

For a GLM, you assume that the response follows a certain distribution (e.g., normal,
binomial, Poisson, etc.) and that the residuals should therefore also follow this distribution.
This can be checked with a Q-Q plot (quantile-quantile plot). The points in this plot should
roughly follow a straight line if the assumption holds.

Checking these assumptions can give you a lot of insight into your model and can guide you
in refining your model if necessary. If the assumptions are not met, you might need to
consider data transformations, adding interaction terms, or using a different type of model.

8. Tune your model: (2h)

Tuning a model involves optimizing its parameters to improve performance. In the case of a
Generalized Linear Model (GLM), this might involve tuning the regularization parameter if you're
using a GLM with L1 or L2 regularization.
For models like Random Forests or Gradient Boosting, there are many more parameters that can be
tuned, such as the number of trees, maximum depth of trees, minimum number of samples per leaf,
and learning rate (for Gradient Boosting).

1. Decide on a tuning method:

The two most common methods for tuning are grid search and random search.

- Grid Search: involves specifying a subset of the hyperparameter space as a grid, and then trying out
every single combination of parameters in the grid.

- Random Search: involves specifying a distribution for each hyperparameter, and then randomly
sampling parameters from these distributions.

Random search can often find good parameters faster than grid search, but there's a chance it might
miss the optimal parameters if you're unlucky with the random sampling.

2. Specify a performance metric:

You'll need a performance metric to decide which set of parameters is best. The choice of metric will
depend on your problem. For a regression task like predicting insurance claims, common metrics are
Mean Absolute Error (MAE), Root Mean Squared Error (RMSE), or R-squared.

4. Validate the tuning:

After finding the best parameters according to your tuning, re-train your model on the entire training
set using these parameters, and evaluate its performance on the test set.

Remember, you should only use your test set once, after all tuning and model selection has been
done, to get an unbiased estimate of your model's performance on new, unseen data.

Remember, achieving great results often depends on understanding your data well and feature
engineering more than on tweaking algorithm parameters. Also, a strong understanding of the
problem domain can help guide your feature selection and engineering efforts, improving the
performance of your model.

Enlever les $ et les 2023

Encoder les indices de regions et les couvertures

Price range à revoir