> This repository includes 50+ language translations which significantly increases the download size. To clone without translations, use sparse checkout:
In this lesson, you learned about the Responsible AI Toolbox, an "open-source, community-driven project designed to help data scientists analyze and improve AI systems." For this assignment, explore one of RAI Toolbox's [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) and share your findings in a paper or presentation.
In this lesson you learned about the Responsible AI Toolbox, an "open-source, community-driven project to help data scientists to analyze and improve AI systems." For this assignment, explore one of RAI Toolbox's [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/tabular/getting-started.ipynb) and report your findings in a paper or presentation.
| | A paper or PowerPoint presentation is provided discussing Fairlearn's systems, the notebook that was executed, and the conclusions derived from running it | A paper is provided without conclusions | No paper is provided |
| | A paper or powerpoint presentation is presented discussing Fairlearn's systems, the notebook that was run, and the conclusions drawn from running it | A paper is presented without conclusions | No paper is presented |
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we aim for accuracy, please note that automated translations may include errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is advised. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please be aware that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.
> ### [This lesson is available in R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introduction
Up to this point, you've explored what regression is using sample data from the pumpkin pricing dataset, which will be used throughout this lesson. You've also visualized the data using Matplotlib.
So far you have explored what regression is with sample data gathered from the pumpkin pricing dataset that we will use throughout this lesson. You have also visualized it using Matplotlib.
Now, you're ready to delve deeper into regression for machine learning. While visualization helps you understand the data, the true power of machine learning lies in_training models_. Models are trained on historical data to automatically capture data dependencies, enabling predictions for new data the model hasn't seen before.
Now you are ready to dive deeper into regression for ML. While visualization allows you to make sense of data, the real power of Machine Learning comes from_training models_. Models are trained on historic data to automatically capture data dependencies, and they allow you to predict outcomes for new data, which the model has not seem before.
In this lesson, you'll learn more about two types of regression: _basic linear regression_ and _polynomial regression_, along with some of the mathematics behind these techniques. These models will help us predict pumpkin prices based on various input data.
In this lesson, you will learn more about two types of regression: _basic linear regression_ and _polynomial regression_, along with some of the math underlying these techniques. Those models will allow us to predict pumpkin prices depending on different input data.
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 Click the image above for a short video overview of linear regression.
> Throughout this curriculum, we assume minimal math knowledge and aim to make it accessible for students from other fields. Look out for notes, 🧮 callouts, diagrams, and other tools to aid comprehension.
> Throughout this curriculum, we assume minimal knowledge of math, and seek to make it accessible for students coming from other fields, so watch for notes, 🧮 callouts, diagrams, and other learning tools to aid in comprehension.
### Prerequisite
By now, you should be familiar with the structure of the pumpkin dataset we're analyzing. This lesson's _notebook.ipynb_ file contains the preloaded and pre-cleaned data. In the file, pumpkin prices are displayed per bushel in a new data frame. Ensure you can run these notebooks in Visual Studio Code kernels.
You should be familiar by now with the structure of the pumpkin data that we are examining. You can find it preloaded and pre-cleaned in this lesson's _notebook.ipynb_ file. In the file, the pumpkin price is displayed per bushel in a new data frame. Make sure you can run these notebooks in kernels in Visual Studio Code.
### Preparation
As a reminder, you're loading this data to answer specific questions:
As a reminder, you are loading this data so as to ask questions of it.
- When is the best time to buy pumpkins?
- What price can I expect for a case of miniature pumpkins?
- Should I buy them in half-bushel baskets or 1 1/9 bushel boxes?
Let's continue exploring this data.
- What price can I expect of a case of miniature pumpkins?
- Should I buy them in half-bushel baskets or by the 1 1/9 bushel box?
Let's keep digging into this data.
In the previous lesson, you created a Pandas data frame and populated it with part of the original dataset, standardizing the pricing by the bushel. However, this only provided about 400 data points, mostly for the fall months.
In the previous lesson, you created a Pandas data frame and populated it with part of the original dataset, standardizing the pricing by the bushel. By doing that, however, you were only able to gather about 400 datapoints and only for the fall months.
Take a look at the data preloaded in this lesson's accompanying notebook. The data is preloaded, and an initial scatterplot is charted to show month data. Perhaps we can uncover more details by cleaning the data further.
Take a look at the data that we preloaded in this lesson's accompanying notebook. The data is preloaded and an initial scatterplot is charted to show month data. Maybe we can get a little more detail about the nature of the data by cleaning it more.
## A linear regression line
As you learned in Lesson 1, the goal of linear regression is to plot a line that:
As you learned in Lesson 1, the goal of a linear regression exercise is to be able to plot a line to:
- **Shows variable relationships**. Illustrates the relationship between variables.
- **Makes predictions**. Accurately predicts where a new data point would fall relative to the line.
- **Show variable relationships**. Show the relationship between variables
- **Make predictions**. Make accurate predictions on where a new datapoint would fall in relationship to that line.
It is typical of **Least-Squares Regression** to draw this type of line. The term "Least-Squares" refers to the process of minimizing the total error in our model. For every data point, we measure the vertical distance (called a residual) between the actual point and our regression line.
A **Least-Squares Regression** is typically used to draw this type of line. The term 'least-squares' refers to squaring and summing the distances of all data points from the regression line. Ideally, this sum is as small as possible, minimizing errors or `least-squares`.
We square these distances for two main reasons:
This approach models a line with the least cumulative distance from all data points. Squaring the terms ensures we're focused on magnitude rather than direction.
1. **Magnitude over Direction:** We want to treat an error of -5 the same as an error of +5. Squaring turns all values positive.
2. **Penalizing Outliers:** Squaring gives more weight to larger errors, forcing the line to stay closer to points that are far away.
We then add all these squared values together. Our goal is to find the specific line where this final sum is at its least (the smallest possible value)—hence the name "Least-Squares".
> **🧮 Show me the math**
>
> This line, called the _line of best fit_, can be expressed by [an equation](https://en.wikipedia.org/wiki/Simple_linear_regression):
> This line, called the _line of best fit_ can be expressed by [an equation](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` is the 'explanatory variable', and `Y` is the 'dependent variable'. The slope of the line is `b`, and `a` is the y-intercept, which represents the value of `Y` when `X = 0`.
> `X` is the 'explanatory variable'. `Y` is the 'dependent variable'. The slope of the line is `b` and `a` is the y-intercept, which refers to the value of `Y` when `X = 0`.
>
>
>
>
> First, calculate the slope `b`. Infographic by [Jen Looper](https://twitter.com/jenlooper)
>
> For example, in our pumpkin dataset's original question: "predict the price of a pumpkin per bushel by month," `X` would represent the price, and `Y` would represent the month of sale.
> In other words, and referring to our pumpkin data's original question: "predict the price of a pumpkin per bushel by month", `X` would refer to the price and `Y` would refer to the month of sale.
>
>
>
>
> Calculate the value of Y. If you're paying around $4, it must be April! Infographic by [Jen Looper](https://twitter.com/jenlooper)
>
> The math behind the line calculation demonstrates the slope, which depends on the intercept, or where `Y` is located when `X = 0`.
> The math that calculates the line must demonstrate the slope of the line, which is also dependent on the intercept, or where `Y` is situated when `X = 0`.
>
> You can explore the calculation method for these values on the [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) website. Also, check out [this Least-squares calculator](https://www.mathsisfun.com/data/least-squares-calculator.html) to see how the numbers affect the line.
> You can observe the method of calculation for these values on the [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) web site. Also visit [this Least-squares calculator](https://www.mathsisfun.com/data/least-squares-calculator.html) to watch how the numbers' values impact the line.
## Correlation
Another important term to understand is the **Correlation Coefficient** between given X and Y variables. Using a scatterplot, you can quickly visualize this coefficient. A plot with data points forming a neat line has high correlation, while a plot with scattered data points has low correlation.
One more term to understand is the **Correlation Coefficient** between given X and Y variables. Using a scatterplot, you can quickly visualize this coefficient. A plot with datapoints scattered in a neat line have high correlation, but a plot with datapoints scattered everywhere between X and Y have a low correlation.
A good linear regression model will have a high (closer to 1 than 0) Correlation Coefficient using the Least-Squares Regression method with a regression line.
A good linear regression model will be one that has a high (nearer to 1 than 0) Correlation Coefficient using the Least-Squares Regression method with a line of regression.
✅ Run the notebook accompanying this lesson and examine the Month-to-Price scatterplot. Does the data associating Month to Price for pumpkin sales appear to have high or low correlation based on your visual interpretation of the scatterplot? Does this change if you use a more detailed measure, such as *day of the year* (i.e., the number of days since the start of the year)?
✅ Run the notebook accompanying this lesson and look at the Month to Price scatterplot. Does the data associating Month to Price for pumpkin sales seem to have high or low correlation, according to your visual interpretation of the scatterplot? Does that change if you use more fine-grained measure instead of `Month`, eg. *day of the year* (i.e. number of days since the beginning of the year)?
In the code below, we assume the data has been cleaned and a data frame called `new_pumpkins` has been obtained, similar to the following:
In the code below, we will assume that we have cleaned up the data, and obtained a data frame called `new_pumpkins`, similar to the following:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
> The code to clean the data is available in [`notebook.ipynb`](../../../../2-Regression/3-Linear/notebook.ipynb). We performed the same cleaning steps as in the previous lesson and calculated the`DayOfYear` column using the following expression:
> The code to clean the data is available in [`notebook.ipynb`](notebook.ipynb). We have performed the same cleaning steps as in the previous lesson, and have calculated `DayOfYear` column using the following expression:
Now that you understand the math behind linear regression, let's create a regression model to predict which pumpkin package offers the best prices. This information could be useful for someone buying pumpkins for a holiday pumpkin patch to optimize their purchases.
Now that you have an understanding of the math behind linear regression, let's create a Regression model to see if we can predict which package of pumpkins will have the best pumpkin prices. Someone buying pumpkins for a holiday pumpkin patch might want this information to be able to optimize their purchases of pumpkin packages for the patch.
## Looking for Correlation
@ -104,22 +115,22 @@ Now that you understand the math behind linear regression, let's create a regres
> 🎥 Click the image above for a short video overview of correlation.
From the previous lesson, you've likely observed that the average price for different months looks like this:
From the previous lesson you have probably seen that the average price for different months looks like this:
<imgalt="Average price by month"src="../../../../translated_images/en/barchart.a833ea9194346d76.webp"width="50%"/>
This suggests there might be some correlation, and we can attempt to train a linear regression model to predict the relationship between `Month` and `Price`, or between `DayOfYear` and `Price`. Here's the scatterplot showing the latter relationship:
This suggests that there should be some correlation, and we can try training linear regression model to predict the relationship between `Month` and `Price`, or between `DayOfYear` and `Price`. Here is the scatter plot that shows the latter relationship:
<imgalt="Scatter plot of Price vs. Day of Year"src="../../../../translated_images/en/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
Let's check for correlation using the `corr` function:
Let's see if there is a correlation using the `corr` function:
The correlation appears to be quite small: -0.15 for `Month` and -0.17 for `DayOfYear`. However, there might be another significant relationship. It seems there are distinct price clusters corresponding to different pumpkin varieties. To confirm this hypothesis, let's plot each pumpkin category using a different color. By passing an `ax` parameter to the `scatter` plotting function, we can plot all points on the same graph:
It looks like the correlation is pretty small, -0.15 by `Month` and -0.17 by the `DayOfMonth`, but there could be another important relationship. It looks like there are different clusters of prices corresponding to different pumpkin varieties. To confirm this hypothesis, let's plot each pumpkin category using a different color. By passing an `ax` parameter to the `scatter` plotting function we can plot all points on the same graph:
```python
ax=None
@ -131,7 +142,7 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
<imgalt="Scatter plot of Price vs. Day of Year"src="../../../../translated_images/en/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
Our investigation suggests that variety has a greater impact on price than the actual selling date. This can be visualized with a bar graph:
Our investigation suggests that variety has more effect on the overall price than the actual selling date. We can see this with a bar graph:
<imgalt="Scatter plot of Price vs. Day of Year"src="../../../../translated_images/en/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
If we calculate the correlation between `Price` and `DayOfYear` using the `corr` function, we get approximately `-0.27`, indicating that training a predictive model is worthwhile.
If we now calculate the correlation between `Price` and `DayOfYear` using `corr` function, we will get something like `-0.27` - which means that training a predictive model makes sense.
> Before training a linear regression model, it's crucial to ensure the data is clean. Linear regression doesn't work well with missing values, so it's a good idea to remove any empty cells:
> Before training a linear regression model, it is important to make sure that our data is clean. Linear regression does not work well with missing values, thus it makes sense to get rid of all empty cells:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Another approach would be to fill empty values with the mean values from the corresponding column.
Another approach would be to fill those empty values with mean values from the corresponding column.
## Simple Linear Regression
@ -164,7 +175,7 @@ Another approach would be to fill empty values with the mean values from the cor
> 🎥 Click the image above for a short video overview of linear and polynomial regression.
To train our Linear Regression model, we'll use the **Scikit-learn** library.
To train our Linear Regression model, we will use the **Scikit-learn** library.
```python
from sklearn.linear_model import LinearRegression
@ -179,24 +190,24 @@ X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Note that we had to perform `reshape` on the input data for the Linear Regression package to interpret it correctly. Linear Regression expects a 2D-array as input, where each row corresponds to a vector of input features. Since we have only one input, we need an array with shape N×1, where N is the dataset size.
> Note that we had to perform `reshape` on the input data in order for the Linear Regression package to understand it correctly. Linear Regression expects a 2D-array as an input, where each row of the array corresponds to a vector of input features. In our case, since we have only one input - we need an array with shape N×1, where N is the dataset size.
Next, we split the data into training and testing datasets to validate our model after training:
Then, we need to split the data into train and test datasets, so that we can validate our model after training:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Finally, training the Linear Regression model requires just two lines of code. We define the `LinearRegression` object and fit it to our data using the `fit` method:
Finally, training the actual Linear Regression model takes only two lines of code. We define the `LinearRegression` object, and fit it to our data using the `fit` method:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
The `LinearRegression` object after fitting contains all the regression coefficients, accessible via the `.coef_` property. In our case, there's just one coefficient, which should be around `-0.017`. This indicates that prices tend to drop slightly over time, by about 2 cents per day. The intersection point of the regression with the Y-axis can be accessed using `lin_reg.intercept_`, which will be around `21` in our case, representing the price at the start of the year.
The `LinearRegression` object after `fit`-ting contains all the coefficients of the regression, which can be accessed using `.coef_` property. In our case, there is just one coefficient, which should be around `-0.017`. It means that prices seem to drop a bit with time, but not too much, around 2 cents per day. We can also access the intersection point of the regression with Y-axis using `lin_reg.intercept_` - it will be around `21` in our case, indicating the price at the beginning of the year.
To evaluate the model's accuracy, we can predict prices on the test dataset and measure how close the predictions are to the expected values. This can be done using the mean square error (MSE) metric, which calculates the mean of all squared differences between expected and predicted values.
To see how accurate our model is, we can predict prices on a test dataset, and then measure how close our predictions are to the expected values. This can be done using mean square error (MSE) metrics, which is the mean of all squared differences between expected and predicted value.
```python
pred = lin_reg.predict(X_test)
@ -204,15 +215,16 @@ pred = lin_reg.predict(X_test)
Our error seems to be around 2 points, which is ~17%. Not great. Another way to evaluate model quality is the **coefficient of determination**, which can be calculated like this:
Our error seems to be around 2 points, which is ~17%. Not too good. Another indicator of model quality is the **coefficient of determination**, which can be obtained like this:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
If the value is 0, it means the model doesn't consider the input data and acts as the *worst linear predictor*, which is simply the mean value of the result. A value of 1 means we can perfectly predict all expected outputs. In our case, the coefficient is around 0.06, which is quite low.
If the value is 0, it means that the model does not take input data into account, and acts as the *worst linear predictor*, which is simply a mean value of the result. The value of 1 means that we can perfectly predict all expected outputs. In our case, the coefficient is around 0.06, which is quite low.
We can also plot the test data along with the regression line to better understand how regression works in our case:
We can also plot the test data together with the regression line to better see how regression works in our case:
```python
plt.scatter(X_test,y_test)
@ -223,17 +235,17 @@ plt.plot(X_test,pred)
## Polynomial Regression
Another type of Linear Regression is Polynomial Regression. While sometimes there is a linear relationship between variables—like the larger the pumpkin's volume, the higher the price—other times these relationships can't be represented as a plane or straight line.
Another type of Linear Regression is Polynomial Regression. While sometimes there's a linear relationship between variables - the bigger the pumpkin in volume, the higher the price - sometimes these relationships can't be plotted as a plane or straight line.
✅ Here are [some more examples](https://online.stat.psu.edu/stat501/lesson/9/9.8) of data that could benefit from Polynomial Regression.
✅ Here are [some more examples](https://online.stat.psu.edu/stat501/lesson/9/9.8) of data that could use Polynomial Regression
Take another look at the relationship between Date and Price. Does this scatterplot seem like it should necessarily be analyzed with a straight line? Can't prices fluctuate? In this case, you can try polynomial regression.
Take another look at the relationship between Date and Price. Does this scatterplot seem like it should necessarily be analyzed by a straight line? Can't prices fluctuate? In this case, you can try polynomial regression.
✅ Polynomials are mathematical expressions that may include one or more variables and coefficients.
✅ Polynomials are mathematical expressions that might consist of one or more variables and coefficients
Polynomial regression creates a curved line to better fit nonlinear data. In our case, if we include a squared `DayOfYear` variable in the input data, we should be able to fit our data with a parabolic curve, which will have a minimum at a certain point in the year.
Polynomial regression creates a curved line to better fit nonlinear data. In our case, if we include a squared `DayOfYear` variable into input data, we should be able to fit our data with a parabolic curve, which will have a minimum at a certain point within the year.
Scikit-learn provides a useful [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) to combine different steps of data processing. A **pipeline** is a chain of **estimators**. In our case, we will create a pipeline that first adds polynomial features to our model and then trains the regression:
Scikit-learn includes a helpful [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) to combine different steps of data processing together. A **pipeline** is a chain of **estimators**. In our case, we will create a pipeline that first adds polynomial features to our model, and then trains the regression:
```python
from sklearn.preprocessing import PolynomialFeatures
Using `PolynomialFeatures(2)` means we will include all second-degree polynomials from the input data. In our case, this will just mean `DayOfYear`<sup>2</sup>, but with two input variables X and Y, this would add X<sup>2</sup>, XY, and Y<sup>2</sup>. We can also use higher-degree polynomials if needed.
Using `PolynomialFeatures(2)` means that we will include all second-degree polynomials from the input data. In our case it will just mean `DayOfYear`<sup>2</sup>, but given two input variables X and Y, this will add X<sup>2</sup>, XY and Y<sup>2</sup>. We may also use higher degree polynomials if we want.
Pipelines can be used in the same way as the original `LinearRegression` object, meaning we can `fit` the pipeline and then use `predict` to get prediction results. Below is the graph showing test data and the approximation curve:
Pipelines can be used in the same manner as the original `LinearRegression` object, i.e. we can `fit` the pipeline, and then use `predict` to get the prediction results. Here is the graph showing test data, and the approximation curve:
Using Polynomial Regression, we can achieve slightly lower MSE and higher determination, but not significantly. We need to consider other features!
Using Polynomial Regression, we can get slightly lower MSE and higher determination, but not significantly. We need to take into account other features!
> Notice that the lowest pumpkin prices occur around Halloween. Why do you think that is?
> You can see that the minimal pumpkin prices are observed somewhere around Halloween. How can you explain this?
🎃 Congratulations, you've just created a model that can help predict the price of pie pumpkins. You could repeat the same process for all pumpkin types, but that would be tedious. Let's now learn how to include pumpkin variety in our model!
🎃 Congratulations, you just created a model that can help predict the price of pie pumpkins. You can probably repeat the same procedure for all pumpkin types, but that would be tedious. Let's learn now how to take pumpkin variety into account in our model!
## Categorical Features
Ideally, we want to predict prices for different pumpkin varieties using the same model. However, the `Variety` column is different from columns like `Month` because it contains non-numeric values. Such columns are called **categorical**.
In the ideal world, we want to be able to predict prices for different pumpkin varieties using the same model. However, the `Variety` column is somewhat different from columns like `Month`, because it contains non-numeric values. Such columns are called **categorical**.
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 Click the image above for a short video overview of using categorical features.
Here’s how the average price depends on variety:
Here you can see how average price depends on variety:
<imgalt="Average price by variety"src="../../../../translated_images/en/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
To include variety in our model, we first need to convert it to numeric form, or **encode** it. There are several ways to do this:
To take variety into account, we first need to convert it to numeric form, or **encode** it. There are several way we can do it:
* Simple **numeric encoding**creates a table of different varieties and replaces the variety name with an index from that table. This isn't ideal for linear regression because the model treats the numeric index as a value and multiplies it by a coefficient. In our case, the relationship between the index number and the price is clearly non-linear, even if we carefully order the indices.
* **One-hot encoding**replaces the `Variety` column with multiple columns—one for each variety. Each column contains `1` if the corresponding row belongs to that variety, and `0` otherwise. This means linear regression will have one coefficient for each variety, representing the "starting price" (or "additional price") for that variety.
* Simple **numeric encoding**will build a table of different varieties, and then replace the variety name by an index in that table. This is not the best idea for linear regression, because linear regression takes the actual numeric value of the index, and adds it to the result, multiplying by some coefficient. In our case, the relationship between the index number and the price is clearly non-linear, even if we make sure that indices are ordered in some specific way.
* **One-hot encoding**will replace the `Variety` column by 4 different columns, one for each variety. Each column will contain `1` if the corresponding row is of a given variety, and `0` otherwise. This means that there will be four coefficients in linear regression, one for each pumpkin variety, responsible for "starting price" (or rather "additional price") for that particular variety.
The code below demonstrates how to one-hot encode a variety:
The code below shows how we can one-hot encode a variety:
```python
pd.get_dummies(new_pumpkins['Variety'])
@ -297,7 +309,7 @@ X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
The rest of the code is the same as what we used earlier to train Linear Regression. If you try it, you'll see that the mean squared error is about the same, but the coefficient of determination improves significantly (~77%). To make even more accurate predictions, we can include additional categorical features and numeric features like `Month` or `DayOfYear`. To combine all features into one large array, we can use `join`:
The rest of the code is the same as what we used above to train Linear Regression. If you try it, you will see that the mean squared error is about the same, but we get much higher coefficient of determination (~77%). To get even more accurate predictions, we can take more categorical features into account, as well as numeric features, such as `Month` or `DayOfYear`. To get one large array of features, we can use `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -307,11 +319,11 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
Here, we also include `City` and `Package` type, which results in an MSE of 2.84 (10%) and a determination coefficient of 0.94!
Here we also take into account `City` and `Package` type, which gives us MSE 2.84 (10%), and determination 0.94!
## Putting it all together
To create the best model, we can combine the one-hot encoded categorical data and numeric data from the previous example with Polynomial Regression. Here's the complete code for your reference:
To make the best model, we can use combined (one-hot encoded categorical + numeric) data from the above example together with Polynomial Regression. Here is the complete code for your convenience:
This should give us the best determination coefficient of nearly 97% and an MSE of 2.23 (~8% prediction error).
This should give us the best determination coefficient of almost 97%, and MSE=2.23 (~8% prediction error).
| Model | MSE | Determination |
|-------|-----|---------------|
@ -349,18 +361,18 @@ This should give us the best determination coefficient of nearly 97% and an MSE
| All features Linear | 2.84 (10.5%) | 0.94 |
| All features Polynomial | 2.23 (8.25%) | 0.97 |
🏆 Well done! You've created four Regression models in one lesson and improved the model quality to 97%. In the final section on Regression, you'll learn about Logistic Regression to classify categories.
🏆 Well done! You created four Regression models in one lesson, and improved the model quality to 97%. In the final section on Regression, you will learn about Logistic Regression to determine categories.
---
## 🚀Challenge
Experiment with different variables in this notebook to see how correlation affects model accuracy.
Test several different variables in this notebook to see how correlation corresponds to model accuracy.
In this lesson, we explored Linear Regression. There are other important types of Regression. Read about Stepwise, Ridge, Lasso, and ElasticNet techniques. A great resource to learn more is the [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).
In this lesson we learned about Linear Regression. There are other important types of Regression. Read about Stepwise, Ridge, Lasso and Elasticnet techniques. A good course to study to learn more is the [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Assignment
@ -368,5 +380,7 @@ In this lesson, we explored Linear Regression. There are other important types o
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please be aware that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.
In this second classification lesson, you will explore additional methods for classifying numeric data. You will also learn about the implications of choosing one classifier over another.
In this second classification lesson, you will explore more ways to classify numeric data. You will also learn about the ramifications for choosing one classifier over the other.
We assume that you have completed the previous lessons and have a cleaned dataset in your `data` folder named _cleaned_cuisines.csv_ in the root of this 4-lesson folder.
We assume that you have completed the previous lessons and have a cleaned dataset in your `data` folder called _cleaned_cuisines.csv_ in the root of this 4-lesson folder.
### Preparation
We have preloaded your _notebook.ipynb_ file with the cleaned dataset and divided it into X and y dataframes, ready for the model-building process.
We have loaded your _notebook.ipynb_ file with the cleaned dataset and have divided it into X and y dataframes, ready for the modelbuilding process.
## A classification map
Previously, you learned about the various options available for classifying data using Microsoft's cheat sheet. Scikit-learn provides a similar but more detailed cheat sheet that can help you further narrow down your choice of estimators (another term for classifiers):
Previously, you learned about the various options you have when classifying data using Microsoft's cheat sheet. Scikit-learn offers a similar, but more granular cheat sheet that can further help narrow down your estimators (another term for classifiers):
> Tip: [visit this map online](https://scikit-learn.org/stable/tutorial/machine_learning_map/) and click along the path to read documentation.
### The plan
This map is very useful once you have a clear understanding of your data, as you can follow its paths to make a decision:
This map is very helpful once you have a clear grasp of your data, as you can 'walk' along its paths to a decision:
- We have >50 samples
- We want to predict a category
- We have labeled data
- We have fewer than 100K samples
- ✨ We can choose a Linear SVC
- If that doesn't work, since we have numeric data:
- If that doesn't work, since we have numeric data
- We can try a ✨ KNeighbors Classifier
- If that doesn't work, try ✨ SVC and ✨ Ensemble Classifiers
This is a very helpful guide to follow.
This is a very helpful trail to follow.
## Exercise - split the data
Following this path, we should start by importing some libraries for use.
Following this path, we should start by importing some libraries to use.
1. Import the necessary libraries:
1. Import the needed libraries:
```python
from sklearn.neighbors import KNeighborsClassifier
@ -53,16 +53,16 @@ Following this path, we should start by importing some libraries for use.
Support-Vector Clustering (SVC) is part of the Support-Vector Machines family of ML techniques (learn more about these below). In this method, you can choose a 'kernel' to determine how to cluster the labels. The 'C' parameter refers to 'regularization,' which controls the influence of parameters. The kernel can be one of [several](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); here, we set it to 'linear' to ensure we use linear SVC. Probability defaults to 'false'; here, we set it to 'true' to gather probability estimates. We set the random state to '0' to shuffle the data and obtain probabilities.
Support-Vector clustering (SVC) is a child of the Support-Vector machines family of ML techniques (learn more about these below). In this method, you can choose a 'kernel' to decide how to cluster the labels. The 'C' parameter refers to 'regularization' which regulates the influence of parameters. The kernel can be one of [several](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); here we set it to 'linear' to ensure that we leverage linear SVC. Probability defaults to 'false'; here we set it to 'true' to gather probability estimates. We set the random state to '0' to shuffle the data to get probabilities.
### Exercise - apply a linear SVC
Start by creating an array of classifiers. You will add to this array progressively as we test.
Start by creating an array of classifiers. You will add progressively to this array as we test.
1. Start with a Linear SVC:
@ -88,7 +88,7 @@ Start by creating an array of classifiers. You will add to this array progressiv
print(classification_report(y_test,y_pred))
```
The result is quite good:
The result is pretty good:
```output
Accuracy (train) for Linear SVC: 78.6%
@ -107,11 +107,11 @@ Start by creating an array of classifiers. You will add to this array progressiv
## K-Neighbors classifier
K-Neighbors belongs to the "neighbors" family of ML methods, which can be used for both supervised and unsupervised learning. In this method, a predefined number of points is created, and data is grouped around these points so that generalized labels can be predicted for the data.
K-Neighbors is part of the "neighbors" family of ML methods, which can be used for both supervised and unsupervised learning. In this method, a predefined number of points is created and data are gathered around these points such that generalized labels can be predicted for the data.
### Exercise - apply the K-Neighbors classifier
The previous classifier performed well with the data, but perhaps we can achieve better accuracy. Try a K-Neighbors classifier.
The previous classifier was good, and worked well with the data, but maybe we can get better accuracy. Try a K-Neighbors classifier.
1. Add a line to your classifier array (add a comma after the Linear SVC item):
@ -119,7 +119,7 @@ The previous classifier performed well with the data, but perhaps we can achieve
'KNN classifier': KNeighborsClassifier(C),
```
The result is slightly worse:
The result is a little worse:
```output
Accuracy (train) for KNN classifier: 73.8%
@ -140,11 +140,11 @@ The previous classifier performed well with the data, but perhaps we can achieve
## Support Vector Classifier
Support-Vector Classifiers are part of the [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) family of ML methods used for classification and regression tasks. SVMs "map training examples to points in space" to maximize the distance between two categories. Subsequent data is mapped into this space so their category can be predicted.
Support-Vector classifiers are part of the [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) family of ML methods that are used for classification and regression tasks. SVMs "map training examples to points in space" to maximize the distance between two categories. Subsequent data is mapped into this space so their category can be predicted.
### Exercise - apply a Support Vector Classifier
Let's aim for slightly better accuracy with a Support Vector Classifier.
Let's try for a little better accuracy with a Support Vector Classifier.
1. Add a comma after the K-Neighbors item, and then add this line:
@ -173,14 +173,14 @@ Let's aim for slightly better accuracy with a Support Vector Classifier.
## Ensemble Classifiers
Let's follow the path to the very end, even though the previous test performed well. Let's try some 'Ensemble Classifiers,' specifically Random Forest and AdaBoost:
Let's follow the path to the very end, even though the previous test was quite good. Let's try some 'Ensemble Classifiers, specifically Random Forest and AdaBoost:
```python
'RFST': RandomForestClassifier(n_estimators=100),
'ADA': AdaBoostClassifier(n_estimators=100)
```
The result is excellent, especially for Random Forest:
The result is very good, especially for Random Forest:
✅ Learn about [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html)
This Machine Learning method "combines the predictions of several base estimators" to improve the model's quality. In our example, we used Random Trees and AdaBoost.
This method of Machine Learning "combines the predictions of several base estimators" to improve the model's quality. In our example, we used Random Trees and AdaBoost.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), an averaging method, builds a 'forest' of 'decision trees' infused with randomness to avoid overfitting. The n_estimators parameter specifies the number of trees.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), an averaging method, builds a 'forest' of 'decision trees' infused with randomness to avoid overfitting. The n_estimators parameter is set to the number of trees.
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) fits a classifier to a dataset and then fits copies of that classifier to the same dataset. It focuses on the weights of incorrectly classified items and adjusts the fit for the next classifier to correct.
@ -222,13 +222,13 @@ This Machine Learning method "combines the predictions of several base estimator
## 🚀Challenge
Each of these techniques has numerous parameters that you can adjust. Research the default parameters for each one and consider how tweaking these parameters might affect the model's quality.
Each of these techniques has a large number of parameters that you can tweak. Research each one's default parameters and think about what tweaking these parameters would mean for the model's quality.
There is a lot of terminology in these lessons, so take a moment to review [this list](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) of useful terms!
There's a lot of jargon in these lessons, so take a minute to review [this list](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) of useful terminology!
## Assignment
@ -236,5 +236,7 @@ There is a lot of terminology in these lessons, so take a moment to review [this
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we aim for accuracy, please note that automated translations may include errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is advised. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please be aware that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.
"\n---\n\n**Disclaimer**: \nThis document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we aim for accuracy, please note that automated translations may include errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is advised. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Disclaimer**:\nThis document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please be aware that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
"\n---\n\n**Disclaimer**:\nThis document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we aim for accuracy, please note that automated translations may include errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is advised. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Disclaimer**:\nThis document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
> This repository includes 50+ language translations which significantly increases the download size. To clone without translations, use sparse checkout:
> **A note about languages**: These lessons are primarily written in Python, but many are also available in R. To complete an R lesson, go to the `/solution` folder and look for R lessons. They include an .rmd extension that represents an **R Markdown** file which can be simply defined as an embedding of `code chunks` (of R or other languages) and a `YAML header` (that guides how to format outputs such as PDF) in a `Markdown document`. As such, it serves as an exemplary authoring framework for data science since it allows you to combine your code, its output, and your thoughts by allowing you to write them down in Markdown. Moreover, R Markdown documents can be rendered to output formats such as PDF, HTML, or Word.
> **A note about quizzes**: All quizzes are contained in [Quiz App folder](../../quiz-app), for 52 total quizzes of three questions each. They are linked from within the lessons but the quiz app can be run locally; follow the instruction in the `quiz-app` folder to locally host or deploy to Azure.
- Review notebooks after each lesson for better understanding.
- Practice implementing algorithms on your own.
- Explore real-world datasets using learned concepts.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its original language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please be aware that automated translations may contain errors or inaccuracies. The original document in its native language should be considered the authoritative source. For critical information, professional human translation is recommended. We are not liable for any misunderstandings or misinterpretations arising from the use of this translation.
# Explora la Caja de Herramientas de IA Responsable
## Instrucciones
En esta lección aprendiste sobre el Toolbox de IA Responsable, un "proyecto de código abierto impulsado por la comunidad para ayudar a los científicos de datos a analizar y mejorar los sistemas de IA". Para esta tarea, explora uno de los [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) del Toolbox de IA Responsable y reporta tus hallazgos en un documento o presentación.
En esta lección aprendiste sobre la Caja de Herramientas de IA Responsable, un "proyecto de código abierto impulsado por la comunidad para ayudar a los científicos de datos a analizar y mejorar los sistemas de IA." Para esta tarea, explora uno de los [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/tabular/getting-started.ipynb) de RAI Toolbox y presenta tus hallazgos en un trabajo o presentación.
| | Se presenta un documento o una presentación en PowerPoint que discute los sistemas de Fairlearn, el notebook que se ejecutó y las conclusiones obtenidas al ejecutarlo | Se presenta un documento sin conclusiones | No se presenta ningún documento |
| | Se presenta un trabajo o presentación de PowerPoint que discute los sistemas de Fairlearn, el notebook que se ejecutó y las conclusiones obtenidas al ejecutarlo | Se presenta un trabajo sin conclusiones | No se presenta ningún trabajo |
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Aviso legal**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la exactitud, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de ningún malentendido o interpretación errónea derivada del uso de esta traducción.
# Construir un modelo de regresión usando Scikit-learn: cuatro formas de regresión
# Construir un modelo de regresión usando Scikit-learn: regresión de cuatro maneras
## Nota para principiantes
La regresión lineal se usa cuando queremos predecir un **valor numérico** (por ejemplo, precio de una casa, temperatura o ventas).
Funciona encontrando una línea recta que represente mejor la relación entre las características de entrada y la salida.
En esta lección, nos enfocamos en entender el concepto antes de explorar técnicas de regresión más avanzadas.
> Infografía por [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
> ### [¡Esta lección está disponible en R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introducción
### Introducción
Hasta ahora has explorado qué es la regresión con datos de muestra obtenidos del conjunto de datos de precios de calabazas que utilizaremos a lo largo de esta lección. También lo has visualizado utilizando Matplotlib.
Hasta ahora has explorado qué es la regresión con datos de ejemplo obtenidos del conjunto de datos de precios de calabazas que usaremos a lo largo de esta lección. También lo has visualizado usando Matplotlib.
Ahora estás listo para profundizar más en la regresión para ML. Mientras que la visualización te permite comprender los datos, el verdadero poder del aprendizaje automático proviene del _entrenamiento de modelos_. Los modelos se entrenan con datos históricos para capturar automáticamente las dependencias de los datos, y te permiten predecir resultados para nuevos datos que el modelo no ha visto antes.
Ahora estás listo para profundizar en regresión para ML. Mientras que la visualización te permite entender los datos, el verdadero poder del Aprendizaje Automático proviene de _entrenar modelos_. Los modelos se entrenan con datos históricos para capturar automáticamente las dependencias de los datos y permiten predecir resultados para datos nuevos, que el modelo no ha visto antes.
En esta lección, aprenderás más sobre dos tipos de regresión: _regresión lineal básica_ y _regresión polinómica_, junto con algunas de las matemáticas subyacentes a estas técnicas. Estos modelos nos permitirán predecir los precios de las calabazas dependiendo de diferentes datos de entrada.
En esta lección, aprenderás más sobre dos tipos de regresión: _regresión lineal básica_ y _regresión polinómica_, junto con algo de la matemática que subyace a estas técnicas. Estos modelos nos permitirán predecir los precios de las calabazas dependiendo de diferentes datos de entrada.
[](https://youtu.be/CRxFT8oTDMg "ML para principiantes - Entendiendo la regresión lineal")
> 🎥 Haz clic en la imagen de arriba para un breve video sobre la regresión lineal.
> 🎥 Haz clic en la imagen arriba para un video corto con una visión general de la regresión lineal.
> A lo largo de este plan de estudios, asumimos un conocimiento mínimo de matemáticas y buscamos hacerlo accesible para estudiantes provenientes de otros campos, así que presta atención a las notas, 🧮 llamados, diagramas y otras herramientas de aprendizaje para facilitar la comprensión.
> A lo largo de este currículo, asumimos un conocimiento mínimo de matemáticas y buscamos hacerlo accesible para estudiantes de otras áreas, así que presta atención a notas, 🧮 llamadas, diagramas y otras herramientas de aprendizaje que ayudan en la comprensión.
### Prerrequisitos
A estas alturas deberías estar familiarizado con la estructura de los datos de calabazas que estamos examinando. Puedes encontrarlos precargados y preprocesados en el archivo _notebook.ipynb_ de esta lección. En el archivo, el precio de las calabazas se muestra por bushel en un nuevo marco de datos. Asegúrate de poder ejecutar estos notebooks en kernels en Visual Studio Code.
Ya deberías estar familiarizado con la estructura de los datos de calabazas que estamos examinando. Puedes encontrarlos precargados y preprocesados en el archivo _notebook.ipynb_ de esta lección. En el archivo, el precio de la calabaza está mostrado por bushel en un nuevo dataframe. Asegúrate de poder ejecutar estos notebooks en kernels de Visual Studio Code.
### Preparación
Como recordatorio, estás cargando estos datos para hacer preguntas sobre ellos.
Como recordatorio, cargas estos datos para poder hacer preguntas sobre ellos.
- ¿Cuándo es el mejor momento para comprar calabazas?
- ¿Qué precio puedo esperar por un paquete de calabazas miniatura?
- ¿Cuándo es el mejor momento para comprar calabazas?
- ¿Qué precio puedo esperar para un paquete de calabazas pequeñas?
- ¿Debería comprarlas en cestas de medio bushel o en cajas de 1 1/9 bushel?
Sigamos investigando estos datos.
Sigamos indagando en estos datos.
En la lección anterior, creaste un marco de datos de Pandas y lo llenaste con parte del conjunto de datos original, estandarizando los precios por bushel. Sin embargo, al hacer eso, solo pudiste recopilar alrededor de 400 puntos de datos y solo para los meses de otoño.
En la lección anterior, creaste un dataframe de Pandas y lo llenaste con parte del conjunto de datos original, estandarizando el precio por bushel. Sin embargo, al hacer eso, solo pudiste obtener alrededor de 400 puntos de datos y solo para los meses de otoño.
Echa un vistazo a los datos que precargamos en el notebook que acompaña esta lección. Los datos están precargados y se ha trazado un gráfico de dispersión inicial para mostrar los datos por mes. Tal vez podamos obtener un poco más de detalle sobre la naturaleza de los datos limpiándolos más.
Mira los datos que precargamos en el notebook que acompaña esta lección. Los datos están precargados y se ha graficado un diagrama de dispersión inicial para mostrar los datos del mes. Quizá podamos obtener un poco más de detalle sobre la naturaleza de los datos limpiándolos más.
## Una línea de regresión lineal
Como aprendiste en la Lección 1, el objetivo de un ejercicio de regresión lineal es poder trazar una línea para:
- **Mostrar relaciones entre variables**. Mostrar la relación entre las variables.
- **Hacer predicciones**. Hacer predicciones precisas sobre dónde caería un nuevo punto de datos en relación con esa línea.
- **Mostrar relaciones entre variables**. Mostrar la relación entre variables.
- **Hacer predicciones**. Hacer predicciones precisas sobre dónde caerá un nuevo punto de datos en relación con esa línea.
Es típico de la **regresión por mínimos cuadrados** dibujar este tipo de línea. El término "mínimos cuadrados" se refiere al proceso de minimizar el error total en nuestro modelo. Para cada punto de datos, medimos la distancia vertical (llamada residual) entre el punto real y nuestra línea de regresión.
Elevamos al cuadrado estas distancias por dos razones principales:
Es típico de la **Regresión de Mínimos Cuadrados** trazar este tipo de línea. El término 'mínimos cuadrados' significa que todos los puntos de datos que rodean la línea de regresión se elevan al cuadrado y luego se suman. Idealmente, esa suma final es lo más pequeña posible, porque queremos un número bajo de errores, o `mínimos cuadrados`.
1. **Magnitud sobre dirección:** Queremos tratar un error de -5 igual que un error de +5. Al elevar al cuadrado todas las valores se vuelven positivos.
Hacemos esto porque queremos modelar una línea que tenga la menor distancia acumulada de todos nuestros puntos de datos. También elevamos los términos al cuadrado antes de sumarlos porque nos interesa su magnitud más que su dirección.
2. **Penalización de valores atípicos:** Elevar al cuadrado da más peso a errores grandes, forzando a la línea a mantenerse más cerca de puntos que están lejos.
> **🧮 Muéstrame las matemáticas**
Luego sumamos todos estos valores al cuadrado. Nuestro objetivo es encontrar la línea específica donde esta suma final sea la menor (el valor más pequeño posible), de ahí el nombre "mínimos cuadrados".
> **🧮 Muéstrame las matemáticas**
>
> Esta línea, llamada _línea de mejor ajuste_, puede expresarse mediante [una ecuación](https://en.wikipedia.org/wiki/Simple_linear_regression):
> Esta línea, llamada _línea de mejor ajuste_, puede expresarse con [una ecuación](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` es la 'variable explicativa'. `Y` es la 'variable dependiente'. La pendiente de la línea es `b` y `a` es la intersección con el eje Y, que se refiere al valor de `Y` cuando `X = 0`.
> `X` es la 'variable explicativa'. `Y` es la 'variable dependiente'. La pendiente de la línea es `b` y `a` es la intersección en y, que se refiere al valor de `Y` cuando `X = 0`.
>
>
>
>
> Primero, calcula la pendiente `b`. Infografía por [Jen Looper](https://twitter.com/jenlooper)
>
> En otras palabras, y refiriéndonos a la pregunta original de los datos de calabazas: "predecir el precio de una calabaza por bushel según el mes", `X` se referiría al precio y `Y`se referiría al mes de venta.
> En otras palabras, y refiriéndonos a la pregunta original de nuestros datos de calabazas: "predecir el precio de una calabaza por bushel según el mes", `X` se referiría al precio y `Y` al mes de venta.
>
>
>
>
> Calcula el valor de Y. Si estás pagando alrededor de $4, ¡debe ser abril! Infografía por [Jen Looper](https://twitter.com/jenlooper)
>
> Las matemáticas que calculan la línea deben demostrar la pendiente de la línea, que también depende de la intersección, o dónde se sitúa `Y` cuando `X = 0`.
> Las matemáticas que calculan la línea deben mostrar la pendiente de la línea, que también depende de la intersección, o dónde se sitúa `Y` cuando `X = 0`.
>
> Puedes observar el método de cálculo para estos valores en el sitio web [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). También visita [este calculador de mínimos cuadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver cómo los valores de los números afectan la línea.
> Puedes observar el método de cálculo para estos valores en el sitio web [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). También visita [este calculador de mínimos cuadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver cómo los valores de los números impactan la línea.
## Correlación
Otro término que debes entender es el **Coeficiente de Correlación** entre las variables X e Y dadas. Usando un gráfico de dispersión, puedes visualizar rápidamente este coeficiente. Un gráfico con puntos de datos dispersos en una línea ordenada tiene alta correlación, pero un gráfico con puntos de datos dispersos por todas partes entre X e Y tiene baja correlación.
Un término más que hay que entender es el **Coeficiente de Correlación** entre dos variables X y Y dadas. Usando un diagrama de dispersión, puedes visualizar rápidamente este coeficiente. Un gráfico con puntos de datos alineados en una línea ordenada tiene alta correlación, pero un gráfico con puntos dispersos por todo el plano entre X y Y tiene baja correlación.
Un buen modelo de regresión lineal será aquel que tenga un Coeficiente de Correlación alto (más cercano a 1 que a 0) utilizando el método de Regresión de Mínimos Cuadrados con una línea de regresión.
Un buen modelo de regresión lineal será aquel que tenga un alto coeficiente de correlación (más cercano a 1 que a 0) usando el método de regresión por mínimos cuadrados con una línea de regresión.
✅ Ejecuta el notebook que acompaña esta lección y observa el gráfico de dispersión de Mes a Precio. Según tu interpretación visual del gráfico de dispersión, ¿parece que los datos que asocian Mes con Precio para las ventas de calabazas tienen alta o baja correlación? ¿Cambia eso si usas una medida más detallada en lugar de `Mes`, por ejemplo, *día del año* (es decir, el número de días desde el inicio del año)?
✅ Ejecuta el notebook que acompaña esta lección y mira el diagrama de dispersión entre Mes y Precio. ¿Parece que hay una alta o baja correlación entre Mes y Precio para las ventas de calabazas, según tu interpretación visual del diagrama? ¿Cambia si usas una medida más detallada en vez de `Mes`, por ejemplo, *día del año* (es decir, número de días desde el inicio del año)?
En el código a continuación, asumiremos que hemos limpiado los datos y obtenido un marco de datos llamado `new_pumpkins`, similar al siguiente:
En el código a continuación, asumiremos que hemos limpiado los datos y obtenido un dataframe llamado `new_pumpkins`, similar al siguiente:
ID | Mes | DíaDelAño | Variedad | Ciudad | Paquete | Precio Bajo | Precio Alto | Precio
70 | 9 | 267 | TIPO PARA PASTEL | BALTIMORE | Cartones de 1 1/9 bushel | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | TIPO PARA PASTEL | BALTIMORE | Cartones de 1 1/9 bushel | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | TIPO PARA PASTEL | BALTIMORE | Cartones de 1 1/9 bushel | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | TIPO PARA PASTEL | BALTIMORE | Cartones de 1 1/9 bushel | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | TIPO PARA PASTEL | BALTIMORE | Cartones de 1 1/9 bushel | 15.0 | 15.0 | 13.636364
> El código para limpiar los datos está disponible en [`notebook.ipynb`](../../../../2-Regression/3-Linear/notebook.ipynb). Hemos realizado los mismos pasos de limpieza que en la lección anterior y hemos calculado la columna `DíaDelAño` utilizando la siguiente expresión:
> El código para limpiar los datos está disponible en [`notebook.ipynb`](notebook.ipynb). Hemos realizado los mismos pasos de limpieza que en la lección anterior, y hemos calculado la columna `DayOfYear` usando la siguiente expresión:
Ahora que tienes una comprensión de las matemáticas detrás de la regresión lineal, vamos a crear un modelo de Regresión para ver si podemos predecir qué paquete de calabazas tendrá los mejores precios. Alguien que compre calabazas para un huerto de calabazas festivo podría querer esta información para optimizar sus compras de paquetes de calabazas para el huerto.
Ahora que tienes una comprensión de las matemáticas detrás de la regresión lineal, vamos a crear un modelo de Regresión para ver si podemos predecir qué paquete de calabazas tendrá los mejores precios. Alguien que compre calabazas para un parche de calabazas en una fiesta podría querer esta información para optimizar sus compras de paquetes de calabazas para el parche.
## Buscando correlación
[](https://youtu.be/uoRq-lW2eQo "ML para principiantes - Buscando correlación: La clave para la regresión lineal")
> 🎥 Haz clic en la imagen de arriba para un breve video sobre la correlación.
> 🎥 Haz clic en la imagen arriba para un video corto con una visión general de la correlación.
De la lección anterior probablemente hayas visto que el precio promedio para diferentes meses se ve así:
Probablemente en la lección anterior viste que el precio promedio por diferentes meses se ve así:
<imgalt="Precio promedio por mes"src="../../../../translated_images/es/barchart.a833ea9194346d76.webp"width="50%"/>
Esto sugiere que debería haber alguna correlación, y podemos intentar entrenar un modelo de regresión lineal para predecir la relación entre `Mes` y `Precio`, o entre `DíaDelAño` y `Precio`. Aquí está el gráfico de dispersión que muestra esta última relación:
<imgalt="Gráfico de dispersión de Precio vs. Día del Año" src="../../../../translated_images/es/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
<imgalt="Diagrama de dispersión de Precio vs Día del Año" src="../../../../translated_images/es/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
Veamos si hay una correlación usando la función `corr`:
Vamos a ver si hay correlación usando la función `corr`:
Parece que la correlación es bastante pequeña, -0.15 por `Mes` y -0.17 por`DíaDelAño`, pero podría haber otra relación importante. Parece que hay diferentes grupos de precios que corresponden a diferentes variedades de calabazas. Para confirmar esta hipótesis, tracemos cada categoría de calabaza usando un color diferente. Al pasar un parámetro `ax` a la función de trazado de dispersión podemos trazar todos los puntos en el mismo gráfico:
Parece que la correlación es bastante baja, -0.15 por `Mes` y -0.17 por el`DíaDelAño`, pero podría haber otra relación importante. Parece que hay diferentes grupos de precios correspondientes a diferentes variedades de calabazas. Para confirmar esta hipótesis, grafiquemos cada categoría de calabaza usando colores diferentes. Pasando un parámetro `ax` a la función de gráfica `scatter`, podemos trazar todos los puntos en el mismo gráfico:
```python
ax=None
@ -128,7 +140,7 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
<imgalt="Gráfico de dispersión de Precio vs. Día del Año" src="../../../../translated_images/es/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
<imgalt="Diagrama de dispersión de Precio vs Día del Año" src="../../../../translated_images/es/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
Nuestra investigación sugiere que la variedad tiene más efecto en el precio general que la fecha de venta real. Podemos ver esto con un gráfico de barras:
<imgalt="Gráfico de dispersión de Precio vs. Día del Año" src="../../../../translated_images/es/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
<imgalt="Diagrama de dispersión de Precio vs Día del Año" src="../../../../translated_images/es/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
Si ahora calculamos la correlación entre `Precio` y `DíaDelAño` usando la función `corr`, obtendremos algo como `-0.27`, lo que significa que tiene sentido entrenar un modelo predictivo.
Si ahora calculamos la correlación entre `Precio` y `DíaDelAño` usando la función `corr`, obtendremos algo como `-0.27`– lo que significa que entrenar un modelo predictivo tiene sentido.
> Antes de entrenar un modelo de regresión lineal, es importante asegurarse de que nuestros datos estén limpios. La regresión lineal no funciona bien con valores faltantes, por lo que tiene sentido deshacerse de todas las celdas vacías:
> Antes de entrenar un modelo de regresión lineal, es importante asegurarse de que nuestros datos estén limpios. La regresión lineal no funciona bien con valores faltantes, por lo que tiene sentido eliminar todas las celdas vacías:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Otra opción sería llenar esos valores vacíos con valores promedio de la columna correspondiente.
Otra opción sería llenar esos valores vacíos con los valores promedio de la columna correspondiente.
## Regresión Lineal Simple
## Regresión lineal simple
[](https://youtu.be/e4c_UP2fSjg "ML para principiantes - Regresión Lineal y Polinómica usando Scikit-learn")
[](https://youtu.be/e4c_UP2fSjg "ML para principiantes - Regresión lineal y polinómica usando Scikit-learn")
> 🎥 Haz clic en la imagen de arriba para un breve video sobre regresión lineal y polinómica.
> 🎥 Haz clic en la imagen arriba para un video corto con una visión general de la regresión lineal y polinómica.
Para entrenar nuestro modelo de Regresión Lineal, utilizaremos la biblioteca **Scikit-learn**.
Para entrenar nuestro modelo de Regresión Lineal usaremos la biblioteca **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
@ -171,31 +183,31 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Comenzamos separando los valores de entrada (características) y la salida esperada (etiqueta) en matrices numpy separadas:
Comenzamos separando los valores de entrada (características) y la salida esperada (etiqueta) en arreglos numpy separados:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Nota que tuvimos que realizar un `reshape` en los datos de entrada para que el paquete de Regresión Lineal los entienda correctamente. La Regresión Lineal espera una matriz 2D como entrada, donde cada fila de la matriz corresponde a un vector de características de entrada. En nuestro caso, dado que solo tenemos una entrada, necesitamos una matriz con forma N×1, donde N es el tamaño del conjunto de datos.
> Ten en cuenta que tuvimos que realizar un `reshape` en los datos de entrada para que el paquete de Regresión Lineal lo entienda correctamente. Regresión Lineal espera un arreglo 2D como entrada, donde cada fila del arreglo corresponde a un vector de características de entrada. En nuestro caso, dado que tenemos solo una entrada, necesitamos un arreglo con forma N×1, donde N es el tamaño del conjunto de datos.
Luego, necesitamos dividir los datos en conjuntos de entrenamiento y prueba, para que podamos validar nuestro modelo después del entrenamiento:
Luego, necesitamos dividir los datos en conjuntos de entrenamiento y prueba, para poder validar nuestro modelo después del entrenamiento:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Finalmente, entrenar el modelo de Regresión Lineal real toma solo dos líneas de código. Definimos el objeto `LinearRegression` y lo ajustamos a nuestros datos usando el método `fit`:
Finalmente, entrenar el modelo actual de Regresión Lineal toma solo dos líneas de código. Definimos el objeto `LinearRegression` y lo ajustamos a nuestros datos usando el método `fit`:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
El objeto `LinearRegression` después de ajustarse contiene todos los coeficientes de la regresión, que se pueden acceder usando la propiedad `.coef_`. En nuestro caso, solo hay un coeficiente, que debería estar alrededor de `-0.017`. Esto significa que los precios parecen bajar un poco con el tiempo, pero no demasiado, alrededor de 2 centavos por día. También podemos acceder al punto de intersección de la regresión con el eje Y usando `lin_reg.intercept_`, que estará alrededor de `21` en nuestro caso, indicando el precio al comienzo del año.
El objeto `LinearRegression` después de ajustar (`fit`) contiene todos los coeficientes de la regresión, a los cuales se puede acceder mediante la propiedad `.coef_`. En nuestro caso, hay solo un coeficiente, que debería estar alrededor de `-0.017`. Esto significa que los precios parecen bajar un poco con el tiempo, pero no mucho, alrededor de 2 centavos por día. También podemos acceder al punto de intersección de la regresión con el eje Y usando `lin_reg.intercept_` — que estará alrededor de `21` en nuestro caso, indicando el precio al comienzo del año.
Para ver qué tan preciso es nuestro modelo, podemos predecir precios en un conjunto de datos de prueba y luego medir qué tan cerca están nuestras predicciones de los valores esperados. Esto se puede hacer usando la métrica de error cuadrático medio (MSE), que es el promedio de todas las diferencias al cuadrado entre el valor esperado y el predicho.
Para ver qué tan preciso es nuestro modelo, podemos predecir precios en un conjunto de datos de prueba, y luego medir qué tan cercanas están nuestras predicciones a los valores esperados. Esto se puede hacer usando la métrica del error cuadrático medio (MSE), que es la media de todas las diferencias cuadradas entre los valores esperados y predichos.
```python
pred = lin_reg.predict(X_test)
@ -203,13 +215,15 @@ pred = lin_reg.predict(X_test)
Nuestro error parece estar en torno a 2 puntos, lo que equivale a ~17%. No es muy bueno. Otro indicador de la calidad del modelo es el **coeficiente de determinación**, que se puede obtener de la siguiente manera:
Nuestro error parece estar alrededor de 2 puntos, lo que es ~17%. No muy bueno. Otro indicador de la calidad del modelo es el **coeficiente de determinación**, que se puede obtener así:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Si el valor es 0, significa que el modelo no toma en cuenta los datos de entrada y actúa como el *peor predictor lineal*, que simplemente es el valor promedio del resultado. Un valor de 1 significa que podemos predecir perfectamente todos los resultados esperados. En nuestro caso, el coeficiente está alrededor de 0.06, lo cual es bastante bajo.
Si el valor es 0, significa que el modelo no toma en cuenta los datos de entrada y actúa como el *peor predictor lineal*, que es simplemente el valor medio del resultado. El valor 1 significa que podemos predecir perfectamente todas las salidas esperadas. En nuestro caso, el coeficiente es alrededor de 0.06, que es bastante bajo.
También podemos graficar los datos de prueba junto con la línea de regresión para ver mejor cómo funciona la regresión en nuestro caso:
Otro tipo de Regresión Lineal es la Regresión Polinómica. Aunque a veces existe una relación lineal entre las variables - cuanto mayor es el volumen de la calabaza, mayor es el precio - en otras ocasiones estas relaciones no pueden representarse como un plano o una línea recta.
Otro tipo de Regresión Lineal es la Regresión Polinómica. Aunque a veces hay una relación lineal entre variables — mientras más grande el volumen de la calabaza, mayor el precio — a veces estas relaciones no pueden representarse como un plano o línea recta.
✅ Aquí hay [algunos ejemplos](https://online.stat.psu.edu/stat501/lesson/9/9.8) de datos que podrían usar Regresión Polinómica.
✅ Aquí hay [más ejemplos](https://online.stat.psu.edu/stat501/lesson/9/9.8) de datos que podrían utilizar Regresión Polinómica
Observa nuevamente la relación entre Fecha y Precio. ¿Este diagrama de dispersión parece que debería analizarse necesariamente con una línea recta? ¿No pueden fluctuar los precios? En este caso, puedes intentar con regresión polinómica.
Observa nuevamente la relación entre Fecha y Precio. ¿Parece que este diagrama de dispersión deba analizarse necesariamente con una línea recta? ¿No pueden fluctuar los precios? En este caso, puedes probar la regresión polinómica.
✅ Los polinomios son expresiones matemáticas que pueden consistir en una o más variables y coeficientes.
✅ Los polinomios son expresiones matemáticas que pueden consistir en una o más variables y coeficientes
La regresión polinómica crea una línea curva para ajustar mejor los datos no lineales. En nuestro caso, si incluimos una variable `DayOfYear`al cuadrado en los datos de entrada, deberíamos poder ajustar nuestros datos con una curva parabólica, que tendrá un mínimo en cierto punto del año.
La regresión polinómica crea una curva para ajustarse mejor a datos no lineales. En nuestro caso, si incluimos una variable cuadrática`DayOfYear` en los datos de entrada, deberíamos poder ajustar nuestros datos con una curva parabólica, que tendrá un mínimo en un cierto punto dentro del año.
Scikit-learn incluye una útil [API de pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes pasos de procesamiento de datos. Un **pipeline** es una cadena de **estimadores**. En nuestro caso, crearemos un pipeline que primero agrega características polinómicas a nuestro modelo y luego entrena la regresión:
Scikit-learn incluye una útil [API de pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes pasos del procesamiento de datos juntos. Un **pipeline** es una cadena de **estimadores**. En nuestro caso, crearemos un pipeline que primero agrega características polinómicas al modelo y luego entrena la regresión:
```python
from sklearn.preprocessing import PolynomialFeatures
Usar `PolynomialFeatures(2)` significa que incluiremos todos los polinomios de segundo grado de los datos de entrada. En nuestro caso, esto simplemente significará `DayOfYear`<sup>2</sup>, pero dado dos variables de entrada X e Y, esto agregará X<sup>2</sup>, XY y Y<sup>2</sup>. También podemos usar polinomios de mayor grado si lo deseamos.
Usar `PolynomialFeatures(2)` significa que incluiremos todos los polinomios de segundo grado a partir de los datos de entrada. En nuestro caso solo significará `DayOfYear`<sup>2</sup>, pero dado dos variables de entrada X y Y, esto agregará X<sup>2</sup>, XY y Y<sup>2</sup>. También podemos usar polinomios de grado superior si queremos.
Los pipelines pueden usarse de la misma manera que el objeto original `LinearRegression`, es decir, podemos usar `fit` en el pipeline y luego usar `predict` para obtener los resultados de predicción. Aquí está el gráfico que muestra los datos de prueba y la curva de aproximación:
Los pipelines pueden usarse de la misma manera que el objeto original `LinearRegression`, es decir, podemos ajustar (`fit`) el pipeline y luego usar `predict` para obtener los resultados de la predicción. Aquí está el gráfico que muestra los datos de prueba y la curva de aproximación:
Usando Regresión Polinómica, podemos obtener un MSE ligeramente más bajo y un coeficiente de determinación más alto, pero no significativamente. ¡Necesitamos tomar en cuenta otras características!
Usando Regresión Polinómica, podemos obtener un MSE ligeramente menor y un coeficiente de determinación más alto, pero no de forma significativa. ¡Necesitamos tener en cuenta otras características!
> Puedes observar que los precios mínimos de las calabazas se registran en algún momento cerca de Halloween. ¿Cómo puedes explicar esto?
> Puedes ver que los precios mínimos de las calabazas se observan alrededor de Halloween. ¿Cómo puedes explicar esto?
🎃 ¡Felicidades! Acabas de crear un modelo que puede ayudar a predecir el precio de las calabazas para pastel. Probablemente podrías repetir el mismo procedimiento para todos los tipos de calabazas, pero eso sería tedioso. ¡Ahora aprendamos cómo tomar en cuenta la variedad de calabazas en nuestro modelo!
🎃 ¡Felicidades, acabas de crear un modelo que puede ayudar a predecir el precio de las calabazas para pastel! Probablemente puedas repetir el mismo procedimiento para todos los tipos de calabaza, pero eso sería tedioso. ¡Ahora aprendamos cómo tener en cuenta la variedad de calabaza en nuestro modelo!
## Características Categóricas
En un mundo ideal, queremos poder predecir precios para diferentes variedades de calabazas usando el mismo modelo. Sin embargo, la columna `Variety` es algo diferente de columnas como `Month`, porque contiene valores no numéricos. Estas columnas se llaman **categóricas**.
En un mundo ideal, queremos poder predecir precios para diferentes variedades de calabaza usando el mismo modelo. Sin embargo, la columna `Variety` es algo diferente de columnas como `Month`, porque contiene valores no numéricos. Estas columnas se llaman **categóricas**.
[](https://youtu.be/DYGliioIAE0 "ML para principiantes - Predicciones con características categóricas usando Regresión Lineal")
> 🎥 Haz clic en la imagen de arriba para ver un breve video sobre el uso de características categóricas.
> 🎥 Haz clic en la imagen arriba para un breve video sobre el uso de características categóricas.
Aquí puedes ver cómo el precio promedio depende de la variedad:
Aquí puedes ver cómo depende el precio promedio de la variedad:
<imgalt="Precio promedio por variedad" src="../../../../translated_images/es/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
<imgalt="Average price by variety" src="../../../../translated_images/es/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
Para tomar en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias maneras de hacerlo:
Para tener en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias formas de hacerlo:
* La **codificación numérica simple** construirá una tabla de diferentes variedades y luego reemplazará el nombre de la variedad por un índice en esa tabla. Esta no es la mejor idea para la regresión lineal, porque la regresión lineal toma el valor numérico real del índice y lo agrega al resultado, multiplicándolo por algún coeficiente. En nuestro caso, la relación entre el número de índice y el precio claramente no es lineal, incluso si nos aseguramos de que los índices estén ordenados de alguna manera específica.
* La **codificación one-hot** reemplazará la columna `Variety` por 4 columnas diferentes, una para cada variedad. Cada columna contendrá `1` si la fila correspondiente es de una variedad dada, y `0` en caso contrario. Esto significa que habrá cuatro coeficientes en la regresión lineal, uno para cada variedad de calabaza, responsables del "precio inicial" (o más bien "precio adicional") para esa variedad en particular.
* La simple **codificación numérica** construirá una tabla de diferentes variedades y luego reemplazará el nombre de la variedad por un índice en esa tabla. Esto no es lo mejor para regresión lineal, porque la regresión lineal toma el valor numérico real del índice y lo agrega al resultado, multiplicado por algún coeficiente. En nuestro caso, la relación entre el número de índice y el precio es claramente no lineal, incluso si nos aseguramos de que los índices estén ordenados de alguna forma específica.
* La **codificación one-hot** reemplazará la columna `Variety` por 4 columnas diferentes, una para cada variedad. Cada columna contendrá `1` si la fila correspondiente es de esa variedad, y `0` de lo contrario. Esto significa que habrá cuatro coeficientes en la regresión lineal, uno para cada variedad de calabaza, responsables del "precio inicial" (o más bien "precio adicional") para esa variedad en particular.
El siguiente código muestra cómo podemos codificar una variedad usando one-hot:
El código a continuación muestra cómo codificar one-hot una variedad:
Para entrenar la regresión lineal usando la variedad codificada como one-hot en los datos de entrada, solo necesitamos inicializar correctamente los datos `X` y `y`:
Para entrenar la regresión lineal usando la variedad codificada one-hot como entrada, solo necesitamos inicializar datos `X` y `y` correctamente:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
El resto del código es el mismo que usamos anteriormente para entrenar la Regresión Lineal. Si lo pruebas, verás que el error cuadrático medio es aproximadamente el mismo, pero obtenemos un coeficiente de determinación mucho más alto (~77%). Para obtener predicciones aún más precisas, podemos tomar en cuenta más características categóricas, así como características numéricas, como `Month` o `DayOfYear`. Para obtener un gran conjunto de características, podemos usar `join`:
El resto del código es igual al que usamos antes para entrenar la Regresión Lineal. Si lo pruebas, verás que el error cuadrático medio es aproximadamente el mismo, pero obtenemos un coeficiente de determinación mucho más alto (~77%). Para obtener predicciones aún más precisas, podemos tener en cuenta más características categóricas, así como características numéricas, como `Month` o `DayOfYear`. Para obtener un gran arreglo de características, podemos usar `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -306,31 +320,31 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
Aquí también tomamos en cuenta `City` y el tipo de `Package`, lo que nos da un MSE de 2.84 (10%) y un coeficiente de determinación de 0.94.
Aquí también tomamos en cuenta `City` y tipo de `Package`, lo que nos da MSE de 2.84 (10%), y determinación de 0.94!
## Juntándolo todo
## Integrando todo junto
Para crear el mejor modelo, podemos usar datos combinados (categóricos codificados como one-hot + numéricos) del ejemplo anterior junto con Regresión Polinómica. Aquí está el código completo para tu conveniencia:
Para crear el mejor modelo, podemos usar datos combinados (categóricos codificados one-hot + numéricos) del ejemplo anterior junto con Regresión Polinómica. Aquí tienes el código completo para tu comodidad:
```python
# set up training data
# configurar datos de entrenamiento
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# make train-test split
# realizar la división de entrenamiento-prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Esto debería darnos el mejor coeficiente de determinación de casi 97% y un MSE=2.23 (~8% de error de predicción).
Esto debería darnos el mejor coeficiente de determinación de casi 97%, y MSE=2.23 (~8% de error de predicción).
| Modelo | MSE | Determinación |
|--------|-----|---------------|
|-------|-----|---------------|
| `DayOfYear` Lineal | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polinómico | 2.73 (17.0%) | 0.08 |
| `Variety` Lineal | 5.24 (19.7%) | 0.77 |
| Todas las características Lineal | 2.84 (10.5%) | 0.94 |
| Todas las características Polinómico | 2.23 (8.25%) | 0.97 |
🏆 ¡Bien hecho! Creaste cuatro modelos de Regresión en una sola lección y mejoraste la calidad del modelo al 97%. En la sección final sobre Regresión, aprenderás sobre Regresión Logística para determinar categorías.
🏆 ¡Bien hecho! Creaste cuatro modelos de Regresión en una lección, y mejoraste la calidad del modelo a 97%. En la sección final sobre Regresión, aprenderás sobre Regresión Logística para determinar categorías.
---
## 🚀Desafío
Prueba varias variables diferentes en este notebook para ver cómo la correlación corresponde a la precisión del modelo.
Prueba varias variables diferentes en este cuaderno para ver cómo la correlación corresponde a la precisión del modelo.
## [Cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario posterior a la clase](https://ff-quizzes.netlify.app/en/ml/)
## Revisión y Autoestudio
## Repaso y Autoestudio
En esta lección aprendimos sobre Regresión Lineal. Hay otros tipos importantes de Regresión. Lee sobre las técnicas Stepwise, Ridge, Lasso y Elasticnet. Un buen curso para estudiar y aprender más es el [curso de Stanford sobre Aprendizaje Estadístico](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).
En esta lección aprendimos sobre Regresión Lineal. Existen otros tipos importantes de Regresión. Lee sobre las técnicas Stepwise, Ridge, Lasso y Elasticnet. Un buen curso para profundizar es el [curso de Aprendizaje Estadístico de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Tarea
[Construye un Modelo](assignment.md)
[Construir un Modelo](assignment.md)
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Aviso Legal**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional realizada por humanos. No nos responsabilizamos por malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
En esta segunda lección de clasificación, explorarás más formas de clasificar datos numéricos. También aprenderás sobre las implicaciones de elegir un clasificador sobre otro.
En esta segunda lección de clasificación, explorarás más formas de clasificar datos numéricos. También aprenderás sobre las ramificaciones de elegir un clasificador sobre otro.
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
### Prerrequisitos
### Prerrequisito
Asumimos que has completado las lecciones anteriores y tienes un conjunto de datos limpio en tu carpeta `data` llamado _cleaned_cuisines.csv_ en la raíz de esta carpeta de 4 lecciones.
### Preparación
Hemos cargado tu archivo _notebook.ipynb_ con el conjunto de datos limpio y lo hemos dividido en los dataframes X e y, listos para el proceso de construcción del modelo.
Hemos cargado tu archivo _notebook.ipynb_ con el conjunto de datos limpio y lo hemos dividido en dataframes X e y, listos para el proceso de construcción del modelo.
## Un mapa de clasificación
Anteriormente, aprendiste sobre las diversas opciones que tienes al clasificar datos utilizando la hoja de referencia de Microsoft. Scikit-learn ofrece una hoja de referencia similar, pero más detallada, que puede ayudarte aún más a reducir tus estimadores (otro término para clasificadores):
Anteriormente, aprendiste sobre las distintas opciones que tienes al clasificar datos usando la hoja de referencia rápida de Microsoft. Scikit-learn ofrece una hoja de referencia similar, pero más detallada, que puede ayudarte aún más a delimitar tus estimadores (otro término para clasificadores):
> Consejo: [visita este mapa en línea](https://scikit-learn.org/stable/tutorial/machine_learning_map/) y haz clic en el camino para leer la documentación.
> Consejo: [visita este mapa en línea](https://scikit-learn.org/stable/tutorial/machine_learning_map/) y haz clic a lo largo del camino para leer la documentación.
### El plan
Este mapa es muy útil una vez que tienes una comprensión clara de tus datos, ya que puedes "caminar" por sus caminos hacia una decisión:
Este mapa es muy útil una vez que tienes una comprensión clara de tus datos, ya que puedes 'caminar' a lo largo de sus caminos hacia una decisión:
- Tenemos >50 muestras
- Queremos predecir una categoría
@ -29,8 +29,8 @@ Este mapa es muy útil una vez que tienes una comprensión clara de tus datos, y
- Tenemos menos de 100K muestras
- ✨ Podemos elegir un Linear SVC
- Si eso no funciona, dado que tenemos datos numéricos
- Podemos intentar un ✨ KNeighbors Classifier
- Si eso no funciona, probar ✨ SVC y ✨ Ensemble Classifiers
- Podemos probar un ✨ Clasificador KNeighbors
- Si eso no funciona, probar ✨ SVC y ✨ Clasificadores Ensemble
Este es un camino muy útil a seguir.
@ -50,31 +50,31 @@ Siguiendo este camino, deberíamos comenzar importando algunas bibliotecas para
El clustering de vectores de soporte (SVC) es un miembro de la familia de técnicas de ML de máquinas de vectores de soporte (aprende más sobre estas abajo). En este método, puedes elegir un 'kernel' para decidir cómo agrupar las etiquetas. El parámetro 'C' se refiere a la 'regularización', que regula la influencia de los parámetros. El kernel puede ser uno de [varios](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); aquí lo configuramos como 'linear' para asegurarnos de aprovechar el Linear SVC. La probabilidad por defecto es 'false'; aquí la configuramos como 'true' para obtener estimaciones de probabilidad. Configuramos el estado aleatorio en '0' para mezclar los datos y obtener probabilidades.
Support-Vector clustering (SVC) es una rama de la familia de técnicas de Máquinas de Vectores de Soporte (aprende más sobre estas más abajo). En este método, puedes elegir un 'kernel' para decidir cómo agrupar las etiquetas. El parámetro 'C' se refiere a la 'regularización' que regula la influencia de los parámetros. El kernel puede ser uno de [varios](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); aquí lo configuramos como 'linear' para garantizar que aprovechemos el Linear SVC. La probabilidad por defecto es 'false'; aquí lo configuramos a 'true' para obtener estimaciones de probabilidad. Establecemos el estado aleatorio a '0' para mezclar los datos y obtener probabilidades.
### Ejercicio - aplicar un Linear SVC
### Ejercicio - aplica un Linear SVC
Comienza creando un array de clasificadores. Irás añadiendo progresivamente a este array mientras probamos.
Comienza creando un array de clasificadores. Los agregarás progresivamente a este array conforme hagamos pruebas.
2. Entrena tu modelo usando el Linear SVC e imprime un informe:
2. Entrena tu modelo usando el Linear SVC e imprime un reporte:
```python
n_classifiers = len(classifiers)
@ -107,13 +107,13 @@ Comienza creando un array de clasificadores. Irás añadiendo progresivamente a
## Clasificador K-Neighbors
K-Neighbors es parte de la familia de métodos de ML "neighbors", que pueden ser utilizados tanto para aprendizaje supervisado como no supervisado. En este método, se crea un número predefinido de puntos y se recopilan datos alrededor de estos puntos para que se puedan predecir etiquetas generalizadas para los datos.
K-Neighbors es parte de la familia de métodos ML "vecinos", que pueden usarse tanto para aprendizaje supervisado como no supervisado. En este método, se crea un número predefinido de puntos y los datos se agrupan alrededor de estos puntos de manera que se puedan predecir etiquetas generalizadas para los datos.
### Ejercicio - aplicar el clasificador K-Neighbors
### Ejercicio - aplica el clasificador K-Neighbors
El clasificador anterior fue bueno y funcionó bien con los datos, pero tal vez podamos obtener mejor precisión. Prueba un clasificador K-Neighbors.
El clasificador previo fue bueno y funcionó bien con los datos, pero tal vez podamos obtener mejor precisión. Prueba un clasificador K-Neighbors.
1. Añade una línea a tu array de clasificadores (añade una coma después del elemento Linear SVC):
1. Agrega una línea a tu array de clasificadores (agrega una coma después del elemento Linear SVC):
```python
'KNN classifier': KNeighborsClassifier(C),
@ -138,15 +138,15 @@ El clasificador anterior fue bueno y funcionó bien con los datos, pero tal vez
✅ Aprende sobre [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
## Clasificador de vectores de soporte
## Clasificador Support Vector
Los clasificadores de vectores de soporte son parte de la familia de [máquinas de vectores de soporte](https://wikipedia.org/wiki/Support-vector_machine) de métodos de ML que se utilizan para tareas de clasificación y regresión. Las SVM "mapean ejemplos de entrenamiento a puntos en el espacio" para maximizar la distancia entre dos categorías. Los datos posteriores se mapean en este espacio para que se pueda predecir su categoría.
Los clasificadores Support-Vector son parte de la familia de métodos de [Máquinas de Vectores de Soporte](https://wikipedia.org/wiki/Support-vector_machine) que se usan para tareas de clasificación y regresión. Las SVM "mapean ejemplos de entrenamiento a puntos en el espacio" para maximizar la distancia entre dos categorías. Los datos posteriores se mapean en este espacio para que su categoría pueda ser predicha.
### Ejercicio - aplicar un clasificador de vectores de soporte
### Ejercicio - aplica un Clasificador Support Vector
Intentemos obtener una mejor precisión con un clasificador de vectores de soporte.
Intentemos obtener un poco mejor precisión con un clasificador Support Vector.
1. Añade una coma después del elemento K-Neighbors y luego añade esta línea:
1. Agrega una coma después del elemento K-Neighbors, y luego añade esta línea:
```python
'SVC': SVC(),
@ -169,11 +169,11 @@ Intentemos obtener una mejor precisión con un clasificador de vectores de sopor
weighted avg 0.84 0.83 0.83 1199
```
✅ Aprende sobre [vectores de soporte](https://scikit-learn.org/stable/modules/svm.html#svm)
✅ Aprende sobre [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)
## Clasificadores Ensemble
Sigamos el camino hasta el final, aunque la prueba anterior fue bastante buena. Probemos algunos clasificadores Ensemble, específicamente Random Forest y AdaBoost:
Sigamos el camino hasta el final, aunque la prueba previa fue bastante buena. Probemos algunos 'Clasificadores Ensemble', específicamente Random Forest y AdaBoost:
```python
'RFST': RandomForestClassifier(n_estimators=100),
@ -210,31 +210,33 @@ Accuracy (train) for ADA: 72.4%
weighted avg 0.73 0.72 0.72 1199
```
✅ Aprende sobre [clasificadores Ensemble](https://scikit-learn.org/stable/modules/ensemble.html)
✅ Aprende sobre [Clasificadores Ensemble](https://scikit-learn.org/stable/modules/ensemble.html)
Este método de aprendizaje automático "combina las predicciones de varios estimadores base" para mejorar la calidad del modelo. En nuestro ejemplo, utilizamos Random Trees y AdaBoost.
Este método de Aprendizaje Automático "combina las predicciones de varios estimadores base" para mejorar la calidad del modelo. En nuestro ejemplo, usamos Random Trees y AdaBoost.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), un método de promediación, construye un 'bosque' de 'árboles de decisión' infundidos con aleatoriedad para evitar el sobreajuste. El parámetro n_estimators se establece en el número de árboles.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), un método de promediado, construye un "bosque" de "árboles de decisión" infundidos con aleatoriedad para evitar sobreajuste. El parámetro n_estimators se ajusta al número de árboles.
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ajusta un clasificador a un conjunto de datos y luego ajusta copias de ese clasificador al mismo conjunto de datos. Se enfoca en los pesos de los elementos clasificados incorrectamente y ajusta el ajuste para el siguiente clasificador para corregir.
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ajusta un clasificador a un conjunto de datos y luego ajusta copias de ese clasificador al mismo conjunto. Se enfoca en los pesos de los ítems mal clasificados y ajusta el ajuste para el siguiente clasificador para corregir.
---
## 🚀Desafío
Cada una de estas técnicas tiene un gran número de parámetros que puedes ajustar. Investiga los parámetros predeterminados de cada una y piensa en lo que significaría ajustar estos parámetros para la calidad del modelo.
Cada una de estas técnicas tiene un gran número de parámetros que puedes modificar. Investiga los parámetros por defecto de cada uno y piensa qué significaría modificar estos parámetros para la calidad del modelo.
## [Cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
## Revisión y autoestudio
## Repaso y autoestudio
Hay mucho vocabulario técnico en estas lecciones, así que tómate un momento para revisar [esta lista](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) de terminología útil.
Hay mucha jerga en estas lecciones, así que tómate un minuto para repasar [esta lista](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) de terminología útil.
## Tarea
[Prueba de parámetros](assignment.md)
[Jugar con parámetros](assignment.md)
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional por humanos. No nos responsabilizamos por malentendidos o interpretaciones erróneas derivadas del uso de esta traducción.
"\n---\n\n**Descargo de responsabilidad**: \nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Aviso legal**:\nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la exactitud, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional humana. No nos responsabilizamos de malentendidos o interpretaciones erróneas derivados del uso de esta traducción.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
"\n---\n\n**Descargo de responsabilidad**: \nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Aviso Legal**:\nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables por malentendidos o interpretaciones erróneas derivadas del uso de esta traducción.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
[](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)
[](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)
[](https://GitHub.com/microsoft/ML-For-Beginners/issues/)
[](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)
[](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)
[](https://GitHub.com/microsoft/ML-For-Beginners/network/)
[](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
> Este repositorio incluye traducciones en más de 50 idiomas, lo que aumenta significativamente el tamaño de la descarga. Para clonar sin traducciones, usa sparse checkout:
> **¿Prefieres Clonar Localmente?**
>
> Este repositorio incluye traducciones en más de 50 idiomas lo que incrementa significativamente el tamaño de la descarga. Para clonar sin las traducciones, usa sparse checkout:
Tenemos una serie en Discord para aprender con IA en curso, obtén más información y únete en [Serie Aprende con IA](https://aka.ms/learnwithai/discord) del 18 al 30 de septiembre de 2025. Obtendrás consejos y trucos para usar GitHub Copilot en Ciencia de Datos.
Tenemos una serie en Discord para aprender con IA, aprende más y únete en [Learn with AI Series](https://aka.ms/learnwithai/discord) del 18 al 30 de septiembre de 2025. Recibirás consejos y trucos para usar GitHub Copilot en Ciencia de Datos.
# Aprendizaje Automático para Principiantes - Un Currículo
# Aprendizaje Automático para Principiantes - Un Currículum
> 🌍 Viaja por el mundo mientras exploramos el Aprendizaje Automático a través de las culturas mundiales 🌍
> 🌍 Viaja por el mundo mientras exploramos el Aprendizaje Automático a través de las culturas del mundo 🌍
Los Cloud Advocates de Microsoft se complacen en ofrecer un currículo de 12 semanas y 26 lecciones sobre **Aprendizaje Automático**. En este currículo, aprenderás sobre lo que a veces se llama **aprendizaje automático clásico**, usando principalmente Scikit-learn como biblioteca y evitando el aprendizaje profundo, que se cubre en nuestro [currículo de IA para principiantes](https://aka.ms/ai4beginners). También puedes combinar estas lecciones con nuestro [currículo de Ciencia de Datos para Principiantes](https://aka.ms/ds4beginners).
Los Cloud Advocates de Microsoft se complacen en ofrecer un currículum de 12 semanas, con 26 lecciones, todo sobre **Aprendizaje Automático**. En este currículum, aprenderás lo que a veces se denomina **aprendizaje automático clásico**, usando principalmente Scikit-learn como biblioteca y evitando el aprendizaje profundo, que se cubre en nuestro [currículo de AI para Principiantes](https://aka.ms/ai4beginners). También combina estas lecciones con nuestro ['currículo de Ciencia de Datos para Principiantes'](https://aka.ms/ds4beginners).
Viaja con nosotros alrededor del mundo mientras aplicamos estas técnicas clásicas a datos de muchas regiones. Cada lección incluye cuestionarios previos y posteriores, instrucciones escritas para completar la lección, una solución, una tarea y más. Nuestra pedagogía basada en proyectos te permite aprender mientras construyes, una forma comprobada para que las nuevas habilidades se afiancen.
Viaja con nosotros por todo el mundo mientras aplicamos estas técnicas clásicas a datos de diversas regiones. Cada lección incluye cuestionarios antes y después de la lección, instrucciones escritas para completarla, una solución, una tarea y más. Nuestra pedagogía basada en proyectos te permite aprender mientras construyes, una forma probada para que las nuevas habilidades perduren.
**✍️ Muchas gracias a nuestros autores** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu y Amy Boyd
**🎨 También agradecemos a nuestros ilustradores** Tomomi Imura, Dasani Madipalli y Jen Looper
**🙏 Agradecimientos especiales 🙏 a nuestros autores, revisores y colaboradores de contenido de Microsoft Student Ambassador**, en particular Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila y Snigdha Agarwal
**🙏 Agradecimientos especiales 🙏 a nuestros autores, revisores y colaboradores de contenido Microsoft Student Ambassadors**, en particular Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila y Snigdha Agarwal
**🤩 Gratitud extra a los Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi y Vidushi Gupta por nuestras lecciones en R!**
**🤩 Extra gratitud a los Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi y Vidushi Gupta por nuestras lecciones de R!**
# Comenzando
Sigue estos pasos:
1. **Bifurca el Repositorio**: Haz clic en el botón "Fork" en la esquina superior derecha de esta página.
1. **Haz un Fork del Repositorio**: Haz clic en el botón "Fork" en la esquina superior derecha de esta página.
2. **Clona el Repositorio**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
> [encuentra todos los recursos adicionales para este curso en nuestra colección de Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> 🔧 **¿Necesitas ayuda?** Consulta nuestra [Guía de Solución de Problemas](TROUBLESHOOTING.md) para solucionar problemas comunes de instalación, configuración y ejecución de lecciones.
> 🔧 **¿Necesitas ayuda?** Consulta nuestra [Guía de Solución de Problemas](TROUBLESHOOTING.md) para resolver problemas comunes con la instalación, configuración y ejecución de las lecciones.
**[Estudiantes](https://aka.ms/student-page)**, para usar este currículo, bifurquen todo el repositorio en su propia cuenta de GitHub y completen los ejercicios solos o en grupo:
- Empiecen con un cuestionario previo a la clase.
- Lean la lección y completen las actividades, haciendo pausas y reflexionando en cada verificación de conocimiento.
- Intenten crear los proyectos comprendiendo las lecciones en lugar de ejecutar el código solución; sin embargo ese código está disponible en las carpetas `/solution` en cada lección orientada a proyectos.
- Realicen el cuestionario posterior a la clase.
- Completen el desafío.
- Completen la tarea.
- Después de completar un grupo de lecciones, visiten el [Tablero de Discusión](https://github.com/microsoft/ML-For-Beginners/discussions) y "aprendan en voz alta" llenando la rúbrica PAT correspondiente. Un 'PAT' es una Herramienta de Evaluación de Progreso que completas para avanzar en tu aprendizaje. También puedes reaccionar a otros PAT para aprender juntos.
**[Estudiantes](https://aka.ms/student-page)**, para usar este currículum, realiza un fork completo del repositorio a tu cuenta de GitHub y completa los ejercicios solo o en grupo:
> Para estudios adicionales, recomendamos seguir estos módulos y rutas de aprendizaje de [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott).
- Comienza con el cuestionario previo a la lección.
- Lee la lección y completa las actividades, deteniéndote y reflexionando en cada comprobación de conocimiento.
- Intenta crear los proyectos comprendiendo las lecciones en lugar de ejecutar el código solución; sin embargo, dicho código está disponible en las carpetas `/solution` en cada lección orientada a proyectos.
- Realiza el cuestionario posterior a la lección.
- Completa el desafío.
- Completa la tarea.
- Después de completar un grupo de lecciones, visita el [Foro de Discusión](https://github.com/microsoft/ML-For-Beginners/discussions) y "aprende en voz alta" llenando la rúbrica PAT correspondiente. Un 'PAT' es una Herramienta de Evaluación de Progreso que completas para avanzar en tu aprendizaje. También puedes reaccionar a otros PAT para que aprendamos juntos.
**Docentes**, hemos [incluido algunas sugerencias](for-teachers.md) sobre cómo usar este currículo.
> Para mayor estudio, recomendamos seguir estos módulos y rutas de aprendizaje de [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott).
**Profesores**, hemos [incluido algunas sugerencias](for-teachers.md) sobre cómo usar este currículum.
---
## Videos explicativos
Algunas lecciones están disponibles en formato video corto. Puedes encontrarlos en línea en las lecciones, o en la [lista de reproducción ML for Beginners en el canal de Microsoft Developer en YouTube](https://aka.ms/ml-beginners-videos) haciendo clic en la imagen abajo.
Algunas lecciones están disponibles en formato de video corto. Puedes encontrar todos estos videos integrados en línea en las lecciones, o en la [lista de reproducción ML for Beginners en el canal de Microsoft Developer en YouTube](https://aka.ms/ml-beginners-videos) haciendo clic en la imagen a continuación.
[](https://aka.ms/ml-beginners-videos)
@ -96,64 +107,64 @@ Algunas lecciones están disponibles en formato video corto. Puedes encontrarlos
## Pedagogía
Hemos elegido dos principios pedagógicos al construir este currículo: asegurar que sea **práctico y basado en proyectos** y que incluya **cuestionarios frecuentes**. Además, este currículo tiene un **tema común** para darle cohesión.
Hemos elegido dos principios pedagógicos al construir este currículum: asegurar que sea práctico y **basado en proyectos** y que incluya **cuestionarios frecuentes**. Además, este currículum tiene un **tema común** que le da cohesión.
Al asegurar que el contenido se alinee con proyectos, el proceso es más atractivo para los estudiantes y se mejora la retención de conceptos. Además, un cuestionario de bajo riesgo antes de la clase enfoca al estudiante en aprender un tema, mientras que un segundo después asegura una retención mayor. Este currículo fue diseñado para ser flexible y divertido y puede tomarse en su totalidad o en parte. Los proyectos comienzan pequeños y se vuelven progresivamente más complejos hacia el final del ciclo de 12 semanas. Este currículo también incluye un posfacio sobre aplicaciones reales de ML, que puede usarse como crédito extra o como base para discusión.
Al asegurar que el contenido esté alineado con proyectos, el proceso es más atractivo para los estudiantes y la retención de conceptos se incrementa. Además, un cuestionario de bajo riesgo antes de la clase establece la intención del estudiante hacia el aprendizaje de un tema, mientras que un segundo cuestionario posterior a la clase asegura una retención adicional. Este currículum fue diseñado para ser flexible y divertido y puede tomarse completo o por partes. Los proyectos comienzan pequeños y se vuelven cada vez más complejos al final del ciclo de 12 semanas. Este currículum también incluye un posfacio sobre aplicaciones reales del ML, que puede utilizarse como crédito adicional o como base para discusión.
> Encuentra nuestras guías de [Código de Conducta](CODE_OF_CONDUCT.md), [Contribución](CONTRIBUTING.md), [Traducción](TRANSLATIONS.md) y [Solución de Problemas](TROUBLESHOOTING.md). ¡Esperamos tu retroalimentación constructiva!
> Encuentra nuestras guías de [Código de Conducta](CODE_OF_CONDUCT.md), [Contribuciones](CONTRIBUTING.md), [Traducción](TRANSLATIONS.md) y [Solución de Problemas](TROUBLESHOOTING.md). ¡Esperamos tus comentarios constructivos!
## Cada lección incluye
- sketchnote opcional
- video suplementario opcional
- video explicativo (solo algunas lecciones)
- video explicativo (solo en algunas lecciones)
- [cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
- lección escrita
- para lecciones basadas en proyectos, guías paso a paso para construir el proyecto
- verificaciones de conocimiento
- comprobaciones de conocimiento
- un desafío
- lectura complementaria
- lectura suplementaria
- tarea
- [cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
> **Una nota sobre los idiomas**: Estas lecciones están principalmente escritas en Python, pero muchas también están disponibles en R. Para completar una lección en R, ve a la carpeta `/solution` y busca las lecciones en R. Incluyen una extensión .rmd que representa un archivo **R Markdown**, definido simplemente como la integración de `fragmentos de código` (de R u otros lenguajes) y un `encabezado YAML` (que guía cómo formatear salidas como PDF) en un `documento Markdown`. Por lo tanto, sirve como un excelente marco de trabajo para autoría en ciencia de datos, ya que te permite combinar tu código, su salida y tus pensamientos escribiéndolos en Markdown. Además, los documentos R Markdown pueden renderizarse a formatos como PDF, HTML o Word.
> **Una nota sobre los cuestionarios**: Todos los cuestionarios están contenidos en la [carpeta Quiz App](../../quiz-app), con un total de 52 cuestionarios de tres preguntas cada uno. Están enlazados dentro de las lecciones, pero la aplicación de cuestionarios puede ejecutarse localmente; siga las instrucciones en la carpeta `quiz-app` para alojar localmente o desplegar en Azure.
| Número de lección | Tema | Agrupación de lecciones | Objetivos de aprendizaje | Lección enlazada | Autor |
| 01 | Introducción al aprendizaje automático | [Introducción](1-Introduction/README.md) | Aprender los conceptos básicos detrás del aprendizaje automático | [Lección](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | La historia del aprendizaje automático | [Introducción](1-Introduction/README.md) | Aprender la historia que subyace en este campo | [Lección](1-Introduction/2-history-of-ML/README.md) | Jen y Amy |
| 03 | Equidad y aprendizaje automático | [Introducción](1-Introduction/README.md) | ¿Cuáles son las cuestiones filosóficas importantes sobre equidad que los estudiantes deben considerar al construir y aplicar modelos ML? | [Lección](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Técnicas para el aprendizaje automático | [Introducción](1-Introduction/README.md) | ¿Qué técnicas usan los investigadores de ML para crear modelos de ML? | [Lección](1-Introduction/4-techniques-of-ML/README.md) | Chris y Jen |
| 05 | Introducción a la regresión | [Regresión](2-Regression/README.md) | Comenzar con Python y Scikit-learn para modelos de regresión | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Precios de calabazas en Norteamérica 🎃 | [Regresión](2-Regression/README.md) | Visualizar y limpiar datos en preparación para ML | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Precios de calabazas en Norteamérica 🎃 | [Regresión](2-Regression/README.md) | Construir modelos de regresión lineal y polinómica | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen y Dmitry • Eric Wanjau |
| 08 | Precios de calabazas en Norteamérica 🎃 | [Regresión](2-Regression/README.md) | Construir un modelo de regresión logística | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | Una aplicación web 🔌 | [Aplicación Web](3-Web-App/README.md) | Crear una aplicación web para usar tu modelo entrenado | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introducción a la clasificación | [Clasificación](4-Classification/README.md) | Limpiar, preparar y visualizar datos; introducción a la clasificación | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen y Cassie • Eric Wanjau |
| 11 | Deliciosas cocinas asiáticas e indias 🍜 | [Clasificación](4-Classification/README.md) | Introducción a los clasificadores | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen y Cassie • Eric Wanjau |
| 12 | Deliciosas cocinas asiáticas e indias 🍜 | [Clasificación](4-Classification/README.md) | Más clasificadores | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen y Cassie • Eric Wanjau |
| 13 | Deliciosas cocinas asiáticas e indias 🍜 | [Clasificación](4-Classification/README.md) | Crear una aplicación web recomendadora usando tu modelo | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introducción al agrupamiento | [Agrupamiento](5-Clustering/README.md) | Limpiar, preparar y visualizar datos; Introducción al agrupamiento | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Explorando gustos musicales nigerianos 🎧 | [Agrupamiento](5-Clustering/README.md) | Explorar el método de agrupamiento K-Means | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Introducción al procesamiento de lenguaje natural ☕️ | [Procesamiento de lenguaje natural](6-NLP/README.md) | Aprender los fundamentos de PLN construyendo un bot simple | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Tareas comunes de PLN ☕️ | [Procesamiento de lenguaje natural](6-NLP/README.md) | Profundizar el conocimiento en PLN comprendiendo las tareas comunes requeridas para tratar con estructuras de lenguaje | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Traducción y análisis de sentimiento ♥️ | [Procesamiento de lenguaje natural](6-NLP/README.md) | Traducción y análisis de sentimiento con Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Hoteles románticos de Europa ♥️ | [Procesamiento de lenguaje natural](6-NLP/README.md) | Análisis de sentimiento con reseñas de hoteles 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Hoteles románticos de Europa ♥️ | [Procesamiento de lenguaje natural](6-NLP/README.md) | Análisis de sentimiento con reseñas de hoteles 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introducción a la predicción de series temporales | [Series temporales](7-TimeSeries/README.md) | Introducción a la predicción de series temporales | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Consumo mundial de energía ⚡️ - predicción con ARIMA | [Series temporales](7-TimeSeries/README.md) | Predicción de series temporales con ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Consumo mundial de energía ⚡️ - predicción con SVR | [Series temporales](7-TimeSeries/README.md) | Predicción de series temporales con regresión de vectores de soporte | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introducción al aprendizaje por refuerzo | [Aprendizaje por refuerzo](8-Reinforcement/README.md) | Introducción al aprendizaje por refuerzo con Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Ayuda a Peter a evitar al lobo! 🐺 | [Aprendizaje por refuerzo](8-Reinforcement/README.md) | Aprendizaje por refuerzo con Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Epílogo | Escenarios y aplicaciones reales de ML | [ML en el mundo real](9-Real-World/README.md) | Aplicaciones interesantes y reveladoras del ML clásico | [Lección](9-Real-World/1-Applications/README.md) | Equipo |
| Epílogo | Depuración de modelos en ML usando el panel RAI | [ML en el mundo real](9-Real-World/README.md) | Depuración de modelos en aprendizaje automático utilizando componentes del panel Responsible AI | [Lección](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> **Una nota sobre los idiomas**: Estas lecciones están escritas principalmente en Python, pero muchas también están disponibles en R. Para completar una lección en R, vaya a la carpeta `/solution` y busque las lecciones en R. Incluyen una extensión .rmd que representa un archivo de **R Markdown**, que se puede definir simplemente como una incrustación de `fragmentos de código` (de R u otros idiomas) y un `encabezado YAML` (que guía cómo formatear salidas como PDF) en un `documento Markdown`. Como tal, sirve como un marco ejemplar de autoría para ciencia de datos, ya que permite combinar su código, su salida y sus pensamientos permitiéndole escribirlos en Markdown. Además, los documentos R Markdown pueden representarse en formatos de salida como PDF, HTML o Word.
> **Una nota sobre los cuestionarios**: Todos los cuestionarios se encuentran en la [carpeta de la aplicación de cuestionarios](../../quiz-app), con un total de 52 cuestionarios de tres preguntas cada uno. Están vinculados desde dentro de las lecciones, pero la aplicación de cuestionarios puede ejecutarse localmente; siga las instrucciones en la carpeta `quiz-app` para alojar localmente o desplegar en Azure.
| Número de lección | Tema | Agrupación de lección | Objetivos de aprendizaje | Lección vinculada | Autor |
| 01 | Introducción al aprendizaje automático | [Introduction](1-Introduction/README.md) | Aprender los conceptos básicos del aprendizaje automático | [Lesson](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | La historia del aprendizaje automático | [Introduction](1-Introduction/README.md) | Aprender la historia subyacentede este campo | [Lesson](1-Introduction/2-history-of-ML/README.md) | Jen y Amy |
| 03 | Equidad y aprendizaje automático | [Introduction](1-Introduction/README.md) | ¿Cuáles son las cuestiones filosóficas importantes sobre la equidad que los estudiantes deben considerar al construir y aplicar modelos de ML? | [Lesson](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Técnicas para el aprendizaje automático | [Introduction](1-Introduction/README.md) | ¿Qué técnicas usan los investigadores de ML para construir modelos de ML? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | Chris y Jen |
| 05 | Introducción a la regresión | [Regression](2-Regression/README.md) | Comenzar con Python y Scikit-learn para modelos de regresión| [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Precios de calabazas en Norteamérica 🎃 | [Regression](2-Regression/README.md) | Visualizar y limpiar datos en preparación para ML| [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Precios de calabazas en Norteamérica 🎃 | [Regression](2-Regression/README.md) | Construir modelos de regresión lineal y polinómica| [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen y Dmitry • Eric Wanjau |
| 08 | Precios de calabazas en Norteamérica 🎃 | [Regression](2-Regression/README.md) | Construir un modelo de regresión logística| [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | Una aplicación web 🔌 | [Web App](3-Web-App/README.md) | Construir una aplicación web para usar tu modelo entrenado | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introducción a la clasificación | [Classification](4-Classification/README.md) | Limpiar, preparar y visualizar tus datos; introducción a la clasificación | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen y Cassie • Eric Wanjau |
| 11 | Deliciosas cocinas asiáticas e indias 🍜 | [Classification](4-Classification/README.md) | Introducción a los clasificadores | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen y Cassie • Eric Wanjau |
| 12 | Deliciosas cocinas asiáticas e indias 🍜 | [Classification](4-Classification/README.md) | Más clasificadores | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen y Cassie • Eric Wanjau |
| 13 | Deliciosas cocinas asiáticas e indias 🍜 | [Classification](4-Classification/README.md) | Construir una aplicación web de recomendación usando tu modelo | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introducción al clustering | [Clustering](5-Clustering/README.md) | Limpiar, preparar y visualizar tus datos; Introducción al clustering | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Explorando gustos musicales nigerianos 🎧 | [Clustering](5-Clustering/README.md) | Explorar el método de clustering K-Means | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Introducción al procesamiento del lenguaje natural ☕️ | [Natural language processing](6-NLP/README.md) | Aprender lo básico sobre PLN construyendo un bot simple | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Tareas comunes de PLN ☕️ | [Natural language processing](6-NLP/README.md) | Profundizar tus conocimientos en PLN entendiendo tareas comunes requeridas al tratar con estructuras de lenguaje | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Traducción y análisis de sentimientos ♥️ | [Natural language processing](6-NLP/README.md) | Traducción y análisis de sentimientos con Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Hoteles románticos de Europa ♥️ | [Natural language processing](6-NLP/README.md) | Análisis de sentimientos con reseñas de hoteles 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Hoteles románticos de Europa ♥️ | [Natural language processing](6-NLP/README.md) | Análisis de sentimientos con reseñas de hoteles 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introducción a la predicción de series temporales | [Time series](7-TimeSeries/README.md) | Introducción a la predicción de series temporales | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Uso mundial de energía ⚡️ - predicción de series temporales con ARIMA | [Time series](7-TimeSeries/README.md) | Predicción de series temporales con ARIMA| [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Uso mundial de energía ⚡️ - predicción de series temporales con SVR | [Time series](7-TimeSeries/README.md) | Predicción de series temporales con regresor de vectores de soporte | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introducción al aprendizaje por refuerzo | [Reinforcement learning](8-Reinforcement/README.md) | Introducción al aprendizaje por refuerzo con Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | ¡Ayuda a Peter a evitar al lobo! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | Aprendizaje por refuerzo Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Posdata | Escenarios y aplicaciones de ML en el mundo real | [ML in the Wild](9-Real-World/README.md) | Aplicaciones interesantes y reveladoras en el mundo real del ML clásico | [Lesson](9-Real-World/1-Applications/README.md) | Equipo |
| Posdata | Depuración de modelos en ML usando el panel de control RAI | [ML in the Wild](9-Real-World/README.md) | Depuración de modelos en Aprendizaje Automático usando componentes del panel de control Responsible AI | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [encuentra todos los recursos adicionales para este curso en nuestra colección Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## Acceso sin conexión
Puedes ejecutar esta documentación sin conexión usando [Docsify](https://docsify.js.org/#/). Haz un fork de este repositorio, [instala Docsify](https://docsify.js.org/#/quickstart) en tu máquina local y luego, en la carpeta raíz de este repositorio, escribe `docsify serve`. El sitio web será servido en el puerto 3000 en tu localhost: `localhost:3000`.
Puedes ejecutar esta documentación sin conexión utilizando [Docsify](https://docsify.js.org/#/). Haz un fork de este repositorio, [instala Docsify](https://docsify.js.org/#/quickstart) en tu máquina local, y luego en la carpeta raíz de este repositorio, escribe `docsify serve`. El sitio web se servirá en el puerto 3000 en tu localhost: `localhost:3000`.
## PDFs
@ -171,11 +182,11 @@ Encuentra un pdf del plan de estudios con enlaces [aquí](https://microsoft.gith
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
---
### Azure / Edge / MCP / Agents
### Azure / Edge / MCP / Agentes
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
---
@ -187,7 +198,7 @@ Encuentra un pdf del plan de estudios con enlaces [aquí](https://microsoft.gith
---
### Aprendizaje Básico
### Aprendizaje Central
[](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
@ -199,24 +210,29 @@ Encuentra un pdf del plan de estudios con enlaces [aquí](https://microsoft.gith
---
### Serie Copilot
[](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst)
Si te quedas atascado o tienes alguna pregunta sobre cómo crear aplicaciones de IA. Únete a otros aprendices y desarrolladores experimentados en discusiones sobre MCP. Es una comunidad de apoyo donde se reciben preguntas con gusto y se comparte el conocimiento libremente.
Si te quedas atascado o tienes alguna pregunta sobre cómo crear aplicaciones de IA, únete a otros aprendices y desarrolladores experimentados en discusiones sobre MCP. Es una comunidad de apoyo donde las preguntas son bienvenidas y el conocimiento se comparte libremente.
[](https://aka.ms/foundry/forum)
- Revisa los cuadernos después de cada lección para una mejor comprensión.
- Practica implementando algoritmos por tu cuenta.
- Explora conjuntos de datos reales usando los conceptos aprendidos.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda la traducción profesional realizada por humanos. No nos hacemos responsables por malentendidos o interpretaciones erróneas derivadas del uso de esta traducción.
**Aviso Legal**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No nos hacemos responsables de malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
Dans cette leçon, vous avez découvert la boîte à outils IA responsable, un "projet open-source et communautaire visant à aider les data scientists à analyser et améliorer les systèmes d'IA." Pour cet exercice, explorez l'un des [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) de la boîte à outils RAI et présentez vos conclusions dans un document ou une présentation.
Dans cette leçon, vous avez découvert la boîte à outils Responsible AI, un « projet open-source, piloté par la communauté, pour aider les data scientists à analyser et améliorer les systèmes d'IA ». Pour ce devoir, explorez l'un des [cahiers](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/tabular/getting-started.ipynb) de RAI Toolbox et présentez vos conclusions dans un document écrit ou une présentation.
## Grille d'évaluation
| Critères | Exemplaire | Adéquat | À améliorer |
| -------- | ---------- | ------- | ----------- |
| | Un document ou une présentation PowerPoint est fourni, discutant des systèmes de Fairlearn, du notebook exécuté, et des conclusions tirées de son exécution | Un document est fourni sans conclusions | Aucun document n'est fourni |
| | Un document ou une présentation PowerPoint est présenté(e) discutant des systèmes de Fairlearn, du cahier exécuté, et des conclusions tirées de son exécution | Un document est présenté sans conclusions | Aucun document n'est présenté |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
Ce document a été traduit à l’aide du service de traduction automatisée [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour toute information critique, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d’interprétations erronées résultant de l’utilisation de cette traduction.
# Construire un modèle de régression avec Scikit-learn : quatre approches de régression
# Construire un modèle de régression avec Scikit-learn : quatre manières de faire la régression
## Note pour débutants
La régression linéaire est utilisée lorsque nous voulons prédire une **valeur numérique** (par exemple, le prix d'une maison, la température ou les ventes).
Elle fonctionne en trouvant une ligne droite qui représente au mieux la relation entre les caractéristiques d'entrée et la sortie.
Dans cette leçon, nous nous concentrons sur la compréhension du concept avant d'explorer des techniques de régression plus avancées.
> Infographie par [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Quiz avant le cours](https://ff-quizzes.netlify.app/en/ml/)
> ### [Cette leçon est disponible en R !](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introduction
Jusqu'à présent, vous avez exploré ce qu'est la régression avec des données d'exemple issues du jeu de données sur les prix des citrouilles que nous utiliserons tout au long de cette leçon. Vous l'avez également visualisée à l'aide de Matplotlib.
Jusqu'à présent, vous avez exploré ce qu'est la régression avec des données d'exemple issues du jeu de données sur les prix des citrouilles que nous utiliserons tout au long de cette leçon. Vous l'avez aussi visualisée avec Matplotlib.
Vous êtes maintenant prêt à approfondir la régression pour l'apprentissage automatique. Bien que la visualisation permette de donner du sens aux données, la véritable puissance de l'apprentissage automatique réside dans l'_entraînement des modèles_. Les modèles sont entraînés sur des données historiques pour capturer automatiquement les dépendances des données, et ils permettent de prédire les résultats pour de nouvelles données que le modèle n'a jamais vues auparavant.
Vous êtes maintenant prêt à plonger plus profondément dans la régression pour le ML. Alors que la visualisation vous permet de comprendre les données, la véritable puissance de l'apprentissage automatique vient de _l'entraînement des modèles_. Les modèles sont entraînés sur des données historiques pour capturer automatiquement les dépendances des données, et ils vous permettent de prédire les résultats pour de nouvelles données que le modèle n'a jamais vues auparavant.
Dans cette leçon, vous en apprendrez davantage sur deux types de régression : _la régression linéaire de base_ et _la régression polynomiale_, ainsi que sur certaines notions mathématiques sous-jacentes à ces techniques. Ces modèles nous permettront de prédire les prix des citrouilles en fonction de différentes données d'entrée.
Dans cette leçon, vous apprendrez davantage sur deux types de régression : la _régression linéaire basique_ et la _régression polynomiale_, ainsi que sur une partie des mathématiques sous-jacentes à ces techniques. Ces modèles nous permettront de prédire les prix des citrouilles en fonction de différentes données d'entrée.
[](https://youtu.be/CRxFT8oTDMg "ML pour débutants - Comprendre la régression linéaire")
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo d'introduction à la régression linéaire.
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo sur la régression linéaire.
> Tout au long de ce programme, nous supposons une connaissance minimale des mathématiques et cherchons à les rendre accessibles aux étudiants venant d'autres domaines. Soyez attentif aux notes, 🧮 aux encadrés, aux diagrammes et à d'autres outils d'apprentissage pour faciliter la compréhension.
> Tout au long de ce cursus, nous supposons des connaissances mathématiques minimales, et cherchons à les rendre accessibles aux étudiants venant d'autres domaines, donc faites attention aux notes, 🧮 encadrés, diagrammes et autres outils pédagogiques pour faciliter la compréhension.
### Prérequis
Vous devriez maintenant être familier avec la structure des données sur les citrouilles que nous examinons. Vous pouvez les trouver préchargées et pré-nettoyées dans le fichier _notebook.ipynb_ de cette leçon. Dans ce fichier, le prix des citrouilles est affiché par boisseau dans un nouveau cadre de données. Assurez-vous de pouvoir exécuter ces notebooks dans des kernels dans Visual Studio Code.
Vous devriez maintenant être familier avec la structure des données sur les citrouilles que nous examinons. Vous pouvez les trouver préchargées et pré-nettoyées dans le fichier _notebook.ipynb_ de cette leçon. Dans ce fichier, le prix des citrouilles est affiché par boisseau dans un nouveau dataframe. Assurez-vous de pouvoir exécuter ces notebooks dans les kernels de Visual Studio Code.
### Préparation
Pour rappel, vous chargez ces données afin de poser des questions à leur sujet.
Pour rappel, vous chargez ces données afin de pouvoir poser des questions à leur sujet.
- Quel est le meilleur moment pour acheter des citrouilles ?
- Quel prix puis-je attendre pour une caisse de citrouilles miniatures ?
- Dois-je les acheter en paniers d'un demi-boisseau ou en cartons de 1 1/9 boisseau ?
- Quel est le meilleur moment pour acheter des citrouilles ?
- Quel prix puis-je attendre pour un cas de mini-citrouilles ?
- Dois-je les acheter en paniers d’un demi-boisseau ou par boîte de 1 1/9 boisseau ?
Continuons à explorer ces données.
Dans la leçon précédente, vous avez créé un cadre de données Pandas et l'avez rempli avec une partie du jeu de données original, en standardisant les prix par boisseau. Cependant, en faisant cela, vous n'avez pu recueillir qu'environ 400 points de données et uniquement pour les mois d'automne.
Dans la leçon précédente, vous avez créé un dataframe Pandas et l'avez rempli avec une partie du jeu de données initial, en standardisant les prix par boisseau. Cependant, cela ne vous a permis de rassembler qu'environ 400 points de données et uniquement pour les mois d'automne.
Examinez les données que nous avons préchargées dans le notebook accompagnant cette leçon. Les données sont préchargées et un premier nuage de points est tracé pour montrer les données mensuelles. Peut-être pouvons-nous obtenir un peu plus de détails sur la nature des données en les nettoyant davantage.
Jetez un œil aux données que nous avons préchargées dans le notebook accompagnant cette leçon. Les données sont préchargées et un premier nuage de points est tracé pour montrer les données par mois. Peut-être pouvons-nous en apprendre un peu plus sur la nature des données en les nettoyant davantage.
## Une ligne de régression linéaire
Comme vous l'avez appris dans la leçon 1, l'objectif d'un exercice de régression linéaire est de pouvoir tracer une ligne pour :
Comme vous l'avez appris dans leçon 1, l'objectif d'un exercice de régression linéaire est de pouvoir tracer une ligne pour :
- **Montrer les relations entre variables**. Montrer la relation entre les variables
- **Faire des prédictions**. Faire des prédictions précises sur la position d'un nouveau point de données par rapport à cette ligne.
Il est typique de la **régression des moindres carrés** de tracer ce type de ligne. Le terme "moindres carrés" fait référence au processus de minimisation de l'erreur totale dans notre modèle. Pour chaque point de données, nous mesurons la distance verticale (appelée résidu) entre le point réel et notre ligne de régression.
- **Montrer les relations entre les variables**. Montrer la relation entre les variables
- **Faire des prédictions**. Faire des prédictions précises sur l'endroit où un nouveau point de données se situerait par rapport à cette ligne.
Il est typique de la **régression des moindres carrés** de tracer ce type de ligne. Le terme "moindres carrés" signifie que tous les points de données entourant la ligne de régression sont élevés au carré puis additionnés. Idéalement, cette somme finale est aussi petite que possible, car nous voulons un faible nombre d'erreurs, ou `moindres carrés`.
Nous élevons au carré ces distances pour deux raisons principales :
Nous procédons ainsi car nous voulons modéliser une ligne ayant la plus faible distance cumulée par rapport à tous nos points de données. Nous élevons également les termes au carré avant de les additionner, car nous nous intéressons à leur magnitude plutôt qu'à leur direction.
1. **Importance plus que direction :** Nous voulons traiter une erreur de -5 de la même façon qu'une erreur de +5. L'élévation au carré rend toutes les valeurs positives.
> **🧮 Montrez-moi les maths**
>
> Cette ligne, appelée _ligne de meilleure ajustement_, peut être exprimée par [une équation](https://en.wikipedia.org/wiki/Simple_linear_regression) :
>
2. **Pénaliser les valeurs aberrantes :** L'élévation au carré donne plus de poids aux erreurs plus grandes, forçant la ligne à rester plus proche des points éloignés.
Nous additionnons ensuite toutes ces valeurs au carré. Notre objectif est de trouver la ligne spécifique où cette somme finale est la plus petite possible — d'où le nom "moindres carrés".
> **🧮 Montrez-moi les mathématiques**
>
> Cette ligne, appelée _ligne de meilleur ajustement_, peut être exprimée par [une équation](https://en.wikipedia.org/wiki/Simple_linear_regression) :
>
> ```
> Y = a + bX
> ```
>
> `X` est la 'variable explicative'. `Y` est la 'variable dépendante'. La pente de la ligne est `b` et `a` est l'ordonnée à l'origine, qui fait référence à la valeur de `Y` lorsque `X = 0`.
> `X` est la « variable explicative ». `Y` est la « variable dépendante ». La pente de la ligne est `b` et `a` est l'ordonnée à l'origine, soit la valeur de `Y` lorsque `X = 0`.
>
>
>
>
> Tout d'abord, calculez la pente `b`. Infographie par [Jen Looper](https://twitter.com/jenlooper)
> Commencez par calculer la pente `b`. Infographie par [Jen Looper](https://twitter.com/jenlooper)
>
> En d'autres termes, et en se référant à la question originale sur les données des citrouilles : "prédire le prix d'une citrouille par boisseau selon le mois", `X` ferait référence au prix et `Y` au mois de vente.
> En d'autres termes, et en se référant à la question initiale de notre jeu de données sur la citrouille : « prédire le prix d’une citrouille par boisseau selon le mois », `X` ferait référence au prix et `Y` au mois de vente.
>
>
> Calculez la valeur de Y. Si vous payez environ 4 $, cela doit être en avril ! Infographie par [Jen Looper](https://twitter.com/jenlooper)
>
> Les calculs mathématiques de la ligne doivent démontrer la pente de la ligne, qui dépend également de l'ordonnée à l'origine, ou de la position de `Y` lorsque `X = 0`.
> La méthode mathématique qui calcule la ligne doit démontrer la pente de la ligne, qui dépend aussi de l'ordonnée à l'origine, ou de la position de `Y` lorsque `X = 0`.
>
> Vous pouvez observer la méthode de calcul de ces valeurs sur le site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Consultez également [ce calculateur de moindres carrés](https://www.mathsisfun.com/data/least-squares-calculator.html) pour voir comment les valeurs des nombres influencent la ligne.
> Vous pouvez observer la méthode de calcul de ces valeurs sur le site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Visitez aussi [ce calculateur des moindres carrés](https://www.mathsisfun.com/data/least-squares-calculator.html) pour voir comment les valeurs des nombres impactent la ligne.
## Corrélation
Un autre terme à comprendre est le **coefficient de corrélation** entre les variables X et Y données. À l'aide d'un nuage de points, vous pouvez rapidement visualiser ce coefficient. Un graphique avec des points de données alignés de manière ordonnée présente une forte corrélation, mais un graphique avec des points de données dispersés partout entre X et Y présente une faible corrélation.
Un terme supplémentaire à comprendre est le **coefficient de corrélation** entre les variables X et Y données. À l’aide d’un nuage de points, vous pouvez rapidement visualiser ce coefficient. Un graphique avec des points de données alignés proprement a une forte corrélation, tandis qu’un graphique avec des points dispersés partout entre X et Y a une faible corrélation.
Un bon modèle de régression linéaire sera celui qui présente un coefficient de corrélation élevé (plus proche de 1 que de 0) en utilisant la méthode de régression des moindres carrés avec une ligne de régression.
Un bon modèle de régression linéaire aura un coefficient de corrélation élevé (plus proche de 1 que de 0) utilisant la méthode de régression des moindres carrés avec une ligne de régression.
✅ Exécutez le notebook accompagnant cette leçon et examinez le nuage de points associant le mois au prix. Selon votre interprétation visuelle du nuage de points, les données associant le mois au prix des ventes de citrouilles semblent-elles présenter une corrélation élevée ou faible ? Cela change-t-il si vous utilisez une mesure plus fine, comme *le jour de l'année* (c'est-à-dire le nombre de jours depuis le début de l'année) ?
✅ Exécutez le notebook accompagnant cette leçon et examinez le nuage Month vs Price. Les données associant le mois au prix des citrouilles semblent-elles offrir une corrélation élevée ou faible, selon votre interprétation visuelle du scatterplot ? Est-ce que cela change si vous utilisez une mesure plus fine que `Month`, par ex. *jour de l'année* (nombre de jours depuis le début de l'année) ?
Dans le code ci-dessous, nous supposerons que nous avons nettoyé les données et obtenu un cadre de données appelé `new_pumpkins`, similaire à ce qui suit :
Dans le code ci-dessous, nous supposerons que nous avons nettoyé les données et obtenu un dataframe appelé `new_pumpkins`, similaire au tableau suivant :
ID | Mois | JourDeLAn | Variété | Ville | Emballage | Prix bas | Prix haut | Prix
> Le code pour nettoyer les données est disponible dans [`notebook.ipynb`](../../../../2-Regression/3-Linear/notebook.ipynb). Nous avons effectué les mêmes étapes de nettoyage que dans la leçon précédente et avons calculé la colonne `JourDeLAn` en utilisant l'expression suivante :
> Le code pour nettoyer les données est disponible dans [`notebook.ipynb`](notebook.ipynb). Nous avons effectué les mêmes étapes de nettoyage que dans la leçon précédente, et avons calculé la colonne `DayOfYear` avec l'expression suivante :
Maintenant que vous comprenez les mathématiques derrière la régression linéaire, créons un modèle de régression pour voir si nous pouvons prédire quel emballage de citrouilles aura les meilleurs prix. Quelqu'un achetant des citrouilles pour un champ de citrouilles de vacances pourrait vouloir cette information pour optimiser ses achats d'emballages de citrouilles pour le champ.
Maintenant que vous comprenez les mathématiques derrière la régression linéaire, créons un modèle de régression pour voir si nous pouvons prédire quel emballage de citrouilles aura les meilleurs prix. Quelqu’un achetant des citrouilles pour un patch de citrouilles de vacances pourrait vouloir cette information afin d’optimiser ses achats.
## Recherche de corrélation
## Recherche de Corrélation
[](https://youtu.be/uoRq-lW2eQo "ML pour débutants - Recherche de corrélation : la clé de la régression linéaire")
[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo sur la corrélation.
Dans la leçon précédente, vous avez probablement vu que le prix moyen pour différents mois ressemble à ceci :
D’après la leçon précédente, vous avez probablement vu que le prix moyen pour différents mois ressemble à ceci :
<imgalt="Prix moyen par mois" src="../../../../translated_images/fr/barchart.a833ea9194346d76.webp"width="50%"/>
<imgalt="Average price by month" src="../../../../translated_images/fr/barchart.a833ea9194346d76.webp"width="50%"/>
Cela suggère qu'il pourrait y avoir une certaine corrélation, et nous pouvons essayer d'entraîner un modèle de régression linéaire pour prédire la relation entre `Mois` et `Prix`, ou entre `JourDeLAn` et `Prix`. Voici le nuage de points qui montre cette dernière relation :
Cela suggère qu’il devrait y avoir une certaine corrélation, et nous pouvons essayer d’entraîner un modèle de régression linéaire pour prédire la relation entre `Month` et `Price`, ou entre `DayOfYear` et `Price`. Voici le graphique en nuage de points montrant cette dernière relation :
<imgalt="Nuage de points du prix vs jour de l'année" src="../../../../translated_images/fr/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/fr/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
Voyons s'il existe une corrélation en utilisant la fonction `corr` :
Voyons s’il y a une corrélation en utilisant la fonction `corr` :
Il semble que la corrélation soit assez faible, -0.15 par `Mois` et -0.17 par `JourDeLAn`, mais il pourrait y avoir une autre relation importante. Il semble qu'il existe différents groupes de prix correspondant à différentes variétés de citrouilles. Pour confirmer cette hypothèse, traçons chaque catégorie de citrouilles en utilisant une couleur différente. En passant un paramètre `ax` à la fonction de tracé de nuage de points, nous pouvons tracer tous les points sur le même graphique :
Il semble que la corrélation soit assez faible, -0.15 pour `Month` et -0.17 pour `DayOfMonth`, mais il pourrait y avoir une autre relation importante. Il semble qu’il existe différents clusters de prix correspondant à différentes variétés de citrouilles. Pour confirmer cette hypothèse, traçons chaque catégorie de citrouille avec une couleur différente. En passant un paramètre `ax` à la fonction `scatter`, nous pouvons afficher tous les points sur le même graphique :
```python
ax=None
@ -128,42 +140,42 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
<imgalt="Nuage de points du prix vs jour de l'année" src="../../../../translated_images/fr/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/fr/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
Notre enquête suggère que la variété a plus d'effet sur le prix global que la date de vente réelle. Nous pouvons le voir avec un graphique en barres :
Notre investigation suggère que la variété a plus d’effet sur le prix global que la date de vente réelle. Nous pouvons en voir un graphique en barres :
<imgalt="Nuage de points du prix vs jour de l'année" src="../../../../translated_images/fr/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/fr/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
Si nous calculons maintenant la corrélation entre `Prix` et `JourDeLAn` en utilisant la fonction `corr`, nous obtiendrons quelque chose comme `-0.27` - ce qui signifie qu'entraîner un modèle prédictif a du sens.
Si nous calculons maintenant la corrélation entre `Price` et `DayOfYear` avec la fonction `corr`, nous obtenons quelque chose comme `-0.27` — ce qui signifie que l’entraînement d’un modèle prédictif a du sens.
> Avant d'entraîner un modèle de régression linéaire, il est important de s'assurer que nos données sont propres. La régression linéaire ne fonctionne pas bien avec des valeurs manquantes, il est donc logique de se débarrasser de toutes les cellules vides :
> Avant d’entraîner un modèle de régression linéaire, il est important de s’assurer que nos données sont propres. La régression linéaire ne fonctionne pas bien avec des valeurs manquantes, il est donc judicieux d’éliminer toutes les cellules vides :
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Une autre approche consisterait à remplir ces valeurs manquantes avec les valeurs moyennes de la colonne correspondante.
Une autre approche consisterait à remplir ces valeurs vides avec la moyenne de la colonne correspondante.
## Régression linéaire simple
## Régression Linéaire Simple
[](https://youtu.be/e4c_UP2fSjg "ML pour débutants - Régression linéaire et polynomiale avec Scikit-learn")
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo sur la régression linéaire et polynomiale.
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo d'introduction à la régression linéaire et polynomiale.
Pour entraîner notre modèle de régression linéaire, nous utiliserons la bibliothèque **Scikit-learn**.
Pour entraîner notre modèle de régression linéaire, nous allons utiliser la bibliothèque **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
@ -171,31 +183,31 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Nous commençons par séparer les valeurs d'entrée (caractéristiques) et la sortie attendue (étiquette) en tableaux numpy distincts :
Nous commençons par séparer les valeurs d'entrée (features) et la sortie attendue (label) dans des tableaux numpy distincts :
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Notez que nous avons dû effectuer un `reshape` sur les données d'entrée afin que le package de régression linéaire les comprenne correctement. La régression linéaire attend un tableau 2D en entrée, où chaque ligne du tableau correspond à un vecteur de caractéristiques d'entrée. Dans notre cas, comme nous n'avons qu'une seule entrée, nous avons besoin d'un tableau de forme N×1, où N est la taille du jeu de données.
> Notez que nous avons dû effectuer un `reshape` sur les données d'entrée pour que le package de régression linéaire les comprenne correctement. La régression linéaire attend un tableau 2D en entrée, où chaque ligne du tableau correspond à un vecteur de caractéristiques d'entrée. Dans notre cas, puisque nous n’avons qu’une seule entrée, nous avons besoin d’un tableau avec pour forme N×1, où N est la taille du jeu de données.
Ensuite, nous devons diviser les données en ensembles d'entraînement et de test, afin de pouvoir valider notre modèle après l'entraînement :
Ensuite, il faut diviser les données en ensembles d’entraînement et de test, afin de pouvoir valider notre modèle après l'entraînement :
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Enfin, entraîner le modèle de régression linéaire réel ne prend que deux lignes de code. Nous définissons l'objet `LinearRegression` et l'ajustons à nos données en utilisant la méthode `fit` :
Enfin, l’entraînement du modèle de régression linéaire réel ne prend que deux lignes de code. Nous définissons l’objet `LinearRegression`, puis l’ajustons à nos données avec la méthode `fit` :
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
L'objet `LinearRegression` après l'ajustement contient tous les coefficients de la régression, qui peuvent être accessibles via la propriété `.coef_`. Dans notre cas, il n'y a qu'un seul coefficient, qui devrait être autour de `-0.017`. Cela signifie que les prix semblent baisser légèrement avec le temps, mais pas beaucoup, environ 2 centimes par jour. Nous pouvons également accéder au point d'intersection de la régression avec l'axe Y en utilisant `lin_reg.intercept_` - il sera autour de `21` dans notre cas, indiquant le prix au début de l'année.
L’objet `LinearRegression` après avoir été `fit` contient tous les coefficients de la régression, auxquels on peut accéder via la propriété `.coef_`. Dans notre cas, il n’y a qu’un seul coefficient, qui devrait être autour de `-0.017`. Cela signifie que les prix semblent diminuer un peu avec le temps, mais pas beaucoup, d’environ 2 centimes par jour. On peut également accéder au point d’intersection de la régression avec l’axe Y en utilisant `lin_reg.intercept_`– il sera d’environ `21` dans notre cas, indiquant le prix au début de l’année.
Pour voir à quel point notre modèle est précis, nous pouvons prédire les prix sur un ensemble de test, puis mesurer à quel point nos prédictions sont proches des valeurs attendues. Cela peut être fait en utilisant la métrique de l'erreur quadratique moyenne (MSE), qui est la moyenne de toutes les différences au carré entre la valeur attendue et la valeur prédite.
Pour voir à quel point notre modèle est précis, nous pouvons prédire les prix sur un ensemble de test, puis mesurer la proximité de nos prédictions par rapport aux valeurs attendues. Cela peut être fait à l’aide de la métrique de l’erreur quadratique moyenne (MSE), qui est la moyenne de toutes les différences au carré entre la valeur attendue et la valeur prédite.
```python
pred = lin_reg.predict(X_test)
@ -203,36 +215,38 @@ pred = lin_reg.predict(X_test)
Notre erreur semble se situer autour de 2 points, soit environ 17 %. Pas très bon. Un autre indicateur de la qualité du modèle est le **coefficient de détermination**, que l'on peut obtenir comme suit :
Notre erreur semble être d’environ 2 points, soit ~17%. Pas très bon. Un autre indicateur de qualité du modèle est le **coefficient de détermination**, qui peut être obtenu ainsi :
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Si la valeur est 0, cela signifie que le modèle ne prend pas en compte les données d'entrée et agit comme le *pire prédicteur linéaire*, qui est simplement une moyenne des résultats. Une valeur de 1 signifie que nous pouvons prédire parfaitement tous les résultats attendus. Dans notre cas, le coefficient est d'environ 0,06, ce qui est assez faible.
```
Nous pouvons également tracer les données de test avec la ligne de régression pour mieux comprendre comment la régression fonctionne dans notre cas :
Si la valeur est 0, cela signifie que le modèle ne prend pas en compte les données d’entrée et agit comme le *pire prédicteur linéaire*, qui est simplement une valeur moyenne du résultat. Une valeur de 1 signifie que nous pouvons prédire parfaitement toutes les sorties attendues. Dans notre cas, le coefficient est autour de 0.06, ce qui est assez bas.
Nous pouvons aussi tracer les données de test avec la ligne de régression pour mieux voir comment fonctionne la régression dans notre cas :
Un autre type de régression linéaire est la régression polynomiale. Bien qu'il existe parfois une relation linéaire entre les variables - plus le volume de la citrouille est grand, plus le prix est élevé - ces relations ne peuvent parfois pas être représentées par un plan ou une ligne droite.
Un autre type de régression linéaire est la régression polynomiale. Parfois, il existe une relation linéaire entre les variables — plus la citrouille est grosse en volume, plus le prix est élevé — mais parfois ces relations ne peuvent pas être représentées par un plan ou une ligne droite.
✅ Voici [quelques exemples supplémentaires](https://online.stat.psu.edu/stat501/lesson/9/9.8) de données qui pourraient utiliser la régression polynomiale.
✅ Voici [quelques autres exemples](https://online.stat.psu.edu/stat501/lesson/9/9.8) de données pouvant être analysées par régression polynomiale.
Regardez à nouveau la relation entre la date et le prix. Ce nuage de points semble-t-il devoir nécessairement être analysé par une ligne droite ? Les prix ne peuvent-ils pas fluctuer ? Dans ce cas, vous pouvez essayer la régression polynomiale.
Regardez de nouveau la relation entre Date et Prix. Ce nuage de points semble-t-il devoir nécessairement être analysé par une ligne droite ? Les prix ne peuvent-ils pas fluctuer ? Dans ce cas, vous pouvez essayer la régression polynomiale.
✅ Les polynômes sont des expressions mathématiques qui peuvent inclure une ou plusieurs variables et coefficients.
✅ Les polynômes sont des expressions mathématiques qui peuvent contenir une ou plusieurs variables et coefficients.
La régression polynomiale crée une courbe pour mieux ajuster les données non linéaires. Dans notre cas, si nous incluons une variable `DayOfYear` au carré dans les données d'entrée, nous devrions pouvoir ajuster nos données avec une courbe parabolique, qui aura un minimum à un certain moment de l'année.
La régression polynomiale crée une courbe pour mieux ajuster des données non linéaires. Dans notre cas, si nous incluons une variable au carré `DayOfYear` dans les données d'entrée, nous devrions pouvoir ajuster nos données avec une courbe parabolique, qui aura un minimum à un certain moment de l’année.
Scikit-learn inclut une API [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) utile pour combiner différentes étapes de traitement des données. Un **pipeline** est une chaîne d'**estimateurs**. Dans notre cas, nous allons créer un pipeline qui ajoute d'abord des caractéristiques polynomiales à notre modèle, puis entraîne la régression :
Scikit-learn inclut une API [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) utile pour combiner différentes étapes de traitement des données. Un **pipeline** est une chaîne d’**estimateurs**. Dans notre cas, nous allons créer un pipeline qui d’abord ajoute des caractéristiques polynomiales à notre modèle, puis entraîne la régression :
```python
from sklearn.preprocessing import PolynomialFeatures
@ -241,62 +255,62 @@ from sklearn.pipeline import make_pipeline
Utiliser `PolynomialFeatures(2)` signifie que nous inclurons tous les polynômes de degré 2 des données d'entrée. Dans notre cas, cela signifie simplement`DayOfYear`<sup>2</sup>, mais avec deux variables d'entrée X et Y, cela ajoutera X<sup>2</sup>, XY et Y<sup>2</sup>. Nous pouvons également utiliser des polynômes de degré supérieur si nous le souhaitons.
Utiliser `PolynomialFeatures(2)` signifie que nous inclurons tous les polynômes du second degré issus des données d’entrée. Dans notre cas, cela signifie juste`DayOfYear`<sup>2</sup>, mais avec deux variables d’entrée X et Y, cela ajouterait X<sup>2</sup>, XY et Y<sup>2</sup>. On peut aussi utiliser des polynômes de degré supérieur si on le souhaite.
Les pipelines peuvent être utilisés de la même manière que l'objet `LinearRegression` original, c'est-à-dire que nous pouvons `fit` le pipeline, puis utiliser `predict` pour obtenir les résultats de prédiction. Voici le graphique montrant les données de test et la courbe d'approximation :
Les pipelines peuvent être utilisés comme l’objet `LinearRegression` original, c’est-à-dire qu’on peut les `fit`, puis utiliser `predict` pour obtenir les résultats de la prédiction. Voici le graphique montrant les données de test et la courbe d’approximation :
Avec la régression polynomiale, nous pouvons obtenir un MSE légèrement inférieur et un coefficient de détermination plus élevé, mais pas de manière significative. Nous devons prendre en compte d'autres caractéristiques !
Avec la régression polynomiale, on peut obtenir une MSE un peu plus faible et un coefficient de détermination plus élevé, mais pas de manière significative. Il faut prendre en compte d’autres caractéristiques !
> Vous pouvez voir que les prix minimaux des citrouilles sont observés autour d'Halloween. Comment expliquez-vous cela ?
> Vous voyez que les prix minimaux des citrouilles sont observés quelque part autour d’Halloween. Comment pouvez-vous l’expliquer ?
🎃 Félicitations, vous venez de créer un modèle qui peut aider à prédire le prix des citrouilles pour tartes. Vous pouvez probablement répéter la même procédure pour tous les types de citrouilles, mais cela serait fastidieux. Apprenons maintenant à prendre en compte la variété des citrouilles dans notre modèle !
🎃 Félicitations, vous venez de créer un modèle qui peut aider à prédire le prix des citrouilles à tarte. Vous pouvez probablement refaire la même procédure pour tous les types de citrouilles, mais ce serait fastidieux. Apprenons maintenant comment prendre en compte la variété de citrouille dans notre modèle !
## Caractéristiques catégorielles
## Caractéristiques Catégorielles
Dans un monde idéal, nous voulons pouvoir prédire les prix pour différentes variétés de citrouilles en utilisant le même modèle. Cependant, la colonne `Variety` est quelque peu différente des colonnes comme `Month`, car elle contient des valeurs non numériques. Ces colonnes sont appelées **catégorielles**.
Dans un monde idéal, nous voulons pouvoir prédire les prix pour différentes variétés de citrouilles avec le même modèle. Cependant, la colonne `Variety` est quelque peu différente de colonnes comme `Month`, car elle contient des valeurs non numériques. Ces colonnes sont appelées **catégorielles**.
[](https://youtu.be/DYGliioIAE0 "ML pour débutants - Prédictions avec caractéristiques catégorielles et régression linéaire")
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo sur l'utilisation des caractéristiques catégorielles.
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo présentant l’utilisation des caractéristiques catégorielles.
Voici comment le prix moyen dépend de la variété :
Ici vous pouvez voir comment le prix moyen dépend de la variété :
<imgalt="Prix moyen par variété" src="../../../../translated_images/fr/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
<imgalt="Average price by variety" src="../../../../translated_images/fr/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
Pour prendre en compte la variété, nous devons d'abord la convertir en forme numérique, ou **l'encoder**. Il existe plusieurs façons de le faire :
Pour prendre la variété en compte, il faut d’abord la convertir en forme numérique, ou **l’encoder**. Plusieurs méthodes existent :
* Un simple **encodage numérique** construira une table des différentes variétés, puis remplacera le nom de la variété par un indice dans cette table. Ce n'est pas la meilleure idée pour la régression linéaire, car la régression linéaire prend la valeur numérique réelle de l'indice et l'ajoute au résultat, en la multipliant par un coefficient. Dans notre cas, la relation entre le numéro d'indice et le prix est clairement non linéaire, même si nous nous assurons que les indices sont ordonnés d'une manière spécifique.
* **L'encodage one-hot** remplacera la colonne `Variety` par 4 colonnes différentes, une pour chaque variété. Chaque colonne contiendra `1` si la ligne correspondante est d'une variété donnée, et `0` sinon. Cela signifie qu'il y aura quatre coefficients dans la régression linéaire, un pour chaque variété de citrouille, responsable du "prix de départ" (ou plutôt "prix supplémentaire") pour cette variété particulière.
* L’**encodage numérique simple** crée un tableau des différentes variétés, puis remplace le nom de la variété par un indice numérique dans ce tableau. Ce n’est pas la meilleure idée pour la régression linéaire, car cette dernière prend la valeur numérique réelle de l’indice et la multiplie par un coefficient. Dans notre cas, la relation entre le numéro d’indice et le prix est clairement non linéaire, même si on ordonne les indices d’une manière spécifique.
* L’**encodage one-hot** remplace la colonne `Variety` par 4 colonnes différentes, une pour chaque variété. Chaque colonne contiendra `1` si la ligne correspond à cette variété, et `0` sinon. Cela signifie qu’il y aura quatre coefficients dans la régression linéaire, un pour chaque variété de citrouille, responsables du "prix de départ" (ou plutôt du "prix additionnel") pour cette variété particulière.
Le code ci-dessous montre comment nous pouvons encoder une variété en one-hot :
Le code ci-dessous montre comment faire un encodage one-hot d’une variété :
```python
pd.get_dummies(new_pumpkins['Variety'])
```
```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
Pour entraîner une régression linéaire en utilisant la variété encodée en one-hot comme entrée, nous devons simplement initialiser correctement les données `X` et `y` :
Pour entraîner la régression linéaire avec la variété encodée en one-hot comme entrée, il suffit d’initialiser correctement les données `X` et `y` :
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
```
Le reste du code est le même que celui que nous avons utilisé ci-dessus pour entraîner la régression linéaire. Si vous essayez, vous verrez que l'erreur quadratique moyenne est à peu près la même, mais nous obtenons un coefficient de détermination beaucoup plus élevé (~77%). Pour obtenir des prédictions encore plus précises, nous pouvons prendre en compte davantage de caractéristiques catégorielles, ainsi que des caractéristiques numériques, comme `Month` ou `DayOfYear`. Pour obtenir un grand tableau de caractéristiques, nous pouvons utiliser `join` :
Le reste du code est le même que celui que nous avons utilisé précédemment pour entraîner la régression linéaire. Si vous essayez, vous verrez que l’erreur quadratique moyenne reste à peu près la même, mais on obtient un coefficient de détermination beaucoup plus élevé (~77%). Pour obtenir des prédictions encore plus précises, on peut prendre en compte davantage de caractéristiques catégorielles, ainsi que des caractéristiques numériques, comme `Month` ou `DayOfYear`. Pour avoir un grand tableau de caractéristiques combinées, on peut utiliser `join` :
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -304,63 +318,62 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
```
Ici, nous prenons également en compte `City` et le type de `Package`, ce qui nous donne un MSE de 2,84 (10 %) et un coefficient de détermination de 0,94 !
Ici, nous prenons aussi en compte la `City` et le type `Package`, ce qui donne une MSE de 2.84 (10%) et un coefficient de détermination de 0.94 !
## Tout rassembler
## Mettre tout ensemble
Pour créer le meilleur modèle, nous pouvons utiliser des données combinées (catégorielles encodées en one-hot + numériques) de l'exemple ci-dessus avec la régression polynomiale. Voici le code complet pour votre commodité :
Pour faire le meilleur modèle, nous pouvons utiliser les données combinées (catégorielles encodées one-hot + numériques) de l’exemple ci-dessus avec la régression polynomiale. Voici le code complet pour votre commodité :
```python
# set up training data
# configurer les données d'entraînement
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# make train-test split
# faire la séparation train-test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Cela devrait nous donner le meilleur coefficient de détermination, presque 97 %, et un MSE=2,23 (~8 % d'erreur de prédiction).
Cela devrait nous donner le meilleur coefficient de détermination de presque 97%, et une MSE de 2.23 (~8% d’erreur de prédiction).
| Modèle | MSE | Détermination |
|--------|-----|---------------|
| `DayOfYear` Linéaire | 2,77 (17,2 %) | 0,07 |
| `DayOfYear` Polynomial | 2,73 (17,0 %) | 0,08 |
| `Variety` Linéaire | 5,24 (19,7 %) | 0,77 |
| Toutes les caractéristiques Linéaire | 2,84 (10,5 %) | 0,94 |
| Toutes les caractéristiques Polynomial | 2,23 (8,25 %) | 0,97 |
| Modèle | MSE | Détermination |
|--------|-----|---------------|
| `DayOfYear` Linéaire | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynomiale | 2.73 (17.0%) | 0.08 |
| `Variety` Linéaire | 5.24 (19.7%) | 0.77 |
| Toutes caractéristiques Linéaire | 2.84 (10.5%) | 0.94 |
| Toutes caractéristiques Polynomiale | 2.23 (8.25%) | 0.97 |
🏆 Bien joué ! Vous avez créé quatre modèles de régression en une seule leçon et amélioré la qualité du modèle à 97%. Dans la section finale sur la régression, vous apprendrez la régression logistique pour déterminer des catégories.
🏆 Bravo ! Vous avez créé quatre modèles de régression en une leçon, et amélioré la qualité du modèle à 97%. Dans la section finale sur la régression, vous apprendrez la régression logistique pour déterminer des catégories.
---
## 🚀 Défi
## 🚀Défi
Testez plusieurs variables différentes dans ce notebook pour voir comment la corrélation correspond à la précision du modèle.
Testez plusieurs variables différentes dans ce carnet pour voir comment la corrélation correspond à la précision du modèle.
Dans cette leçon, nous avons appris la régression linéaire. Il existe d'autres types importants de régression. Lisez sur les techniques Stepwise, Ridge, Lasso et Elasticnet. Un bon cours pour approfondir est le [cours de Stanford sur l'apprentissage statistique](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).
Dans cette leçon, nous avons appris la régression linéaire. Il existe d’autres types importants de régression. Lisez sur les techniques Stepwise, Ridge, Lasso et Elasticnet. Un bon cours à suivre pour en apprendre davantage est le [cours d’apprentissage statistique de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Devoir
@ -368,5 +381,7 @@ Dans cette leçon, nous avons appris la régression linéaire. Il existe d'autre
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des imprécisions. Le document original dans sa langue d’origine doit être considéré comme la source faisant autorité. Pour les informations critiques, une traduction professionnelle réalisée par un humain est recommandée. Nous déclinons toute responsabilité en cas de malentendus ou de mauvaises interprétations résultant de l’utilisation de cette traduction.
Dans cette deuxième leçon sur la classification, vous allez explorer davantage de méthodes pour classifier des données numériques. Vous apprendrez également les implications du choix d'un classificateur plutôt qu'un autre.
Dans cette deuxième leçon de classification, vous allez explorer davantage de façons de classer des données numériques. Vous apprendrez également les conséquences du choix d’un classificateur plutôt qu’un autre.
## [Quiz avant la leçon](https://ff-quizzes.netlify.app/en/ml/)
Nous supposons que vous avez terminé les leçons précédentes et que vous disposez d'un jeu de données nettoyé dans votre dossier `data`, nommé _cleaned_cuisines.csv_, à la racine de ce dossier de 4 leçons.
Nous supposons que vous avez terminé les leçons précédentes et que vous disposez d’un jeu de données nettoyé dans votre dossier `data` appelé _cleaned_cuisines.csv_ à la racine de ce dossier de 4 leçons.
### Préparation
Nous avons chargé votre fichier _notebook.ipynb_ avec le jeu de données nettoyé et l'avons divisé en dataframes X et y, prêts pour le processus de construction du modèle.
Nous avons chargé votre fichier _notebook.ipynb_ avec le jeu de données nettoyé et l’avons divisé en dataframes X et y, prêts pour le processus de construction du modèle.
## Une carte de classification
Précédemment, vous avez appris les différentes options disponibles pour classifier des données en utilisant le guide de Microsoft. Scikit-learn propose un guide similaire, mais plus détaillé, qui peut vous aider à affiner davantage vos choix d'estimateurs (un autre terme pour classificateurs) :
Précédemment, vous avez appris les différentes options dont vous disposez pour classifier des données en utilisant la fiche de référence de Microsoft. Scikit-learn offre une fiche de référence similaire, mais plus détaillée qui peut aider à affiner encore plus vos estimateurs (un autre terme pour les classificateurs) :
> Conseil : [visitez cette carte en ligne](https://scikit-learn.org/stable/tutorial/machine_learning_map/) et explorez les chemins pour lire la documentation.
> Astuce : [visitez cette carte en ligne](https://scikit-learn.org/stable/tutorial/machine_learning_map/) et cliquez le long du chemin pour lire la documentation.
### Le plan
Cette carte est très utile une fois que vous avez une compréhension claire de vos données, car vous pouvez "suivre" ses chemins pour prendre une décision :
Cette carte est très utile une fois que vous avez une compréhension claire de vos données, car vous pouvez «parcourir» ses chemins jusqu’à une décision :
- Nous avons >50 échantillons
- Nous voulons prédire une catégorie
- Nous avons des données étiquetées
- Nous avons moins de 100K échantillons
- ✨ Nous pouvons choisir un Linear SVC
- Si cela ne fonctionne pas, étant donné que nous avons des données numériques :
- Si ça ne marche pas, comme nous avons des données numériques
- Nous pouvons essayer un ✨ KNeighbors Classifier
- Si cela ne fonctionne pas, essayer ✨ SVC et ✨ Ensemble Classifiers
- Si ça ne marche pas, essayer ✨ SVC et ✨ Ensemble Classifiers
C'est un chemin très utile à suivre.
C’est un chemin très utile à suivre.
## Exercice - diviser les données
En suivant ce chemin, nous devrions commencer par importer quelques bibliothèques nécessaires.
En suivant ce chemin, nous devrions commencer par importer quelques bibliothèques à utiliser.
1. Importez les bibliothèques nécessaires :
@ -50,31 +50,31 @@ En suivant ce chemin, nous devrions commencer par importer quelques bibliothèqu
import numpy as np
```
1. Divisez vos données d'entraînement et de test :
1. Divisez vos données d’entraînement et de test :
Le clustering par vecteurs de support (SVC) fait partie de la famille des machines à vecteurs de support (SVM) en apprentissage automatique (en savoir plus ci-dessous). Dans cette méthode, vous pouvez choisir un 'kernel' pour décider comment regrouper les étiquettes. Le paramètre 'C' fait référence à la 'régularisation', qui régule l'influence des paramètres. Le kernel peut être l'un des [plusieurs](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); ici, nous le définissons sur 'linear' pour garantir que nous utilisons Linear SVC. La probabilité est par défaut 'false'; ici, nous la définissons sur 'true' pour obtenir des estimations de probabilité. Nous définissons l'état aléatoire sur '0' pour mélanger les données et obtenir des probabilités.
Le support-vector clustering (SVC) appartient à la famille des machines à vecteurs de support (Support-Vector machines) en apprentissage automatique (apprenez-en plus ci-dessous). Dans cette méthode, vous pouvez choisir un 'kernel' pour décider comment regrouper les étiquettes. Le paramètre 'C' fait référence à la « régularisation » qui régule l’influence des paramètres. Le kernel peut être un des [plusieurs](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) ; ici nous l’avons fixé à 'linear' pour garantir l’utilisation du Linear SVC. La probabilité est par défaut à 'false' ; ici nous la mettons à 'true' pour recueillir des estimations de probabilité. Nous fixons l’état aléatoire à '0' pour mélanger les données et obtenir des probabilités.
### Exercice - appliquer un Linear SVC
Commencez par créer un tableau de classificateurs. Vous ajouterez progressivement à ce tableau au fur et à mesure des tests.
Commencez par créer un tableau de classificateurs. Vous ajouterez progressivement à ce tableau au fur et à mesure de nos tests.
2. Entraînez votre modèle en utilisant le Linear SVC et imprimez un rapport :
2. Entraînez votre modèle en utilisant le Linear SVC et affichez un rapport :
```python
n_classifiers = len(classifiers)
@ -107,13 +107,13 @@ Commencez par créer un tableau de classificateurs. Vous ajouterez progressiveme
## Classificateur K-Neighbors
K-Neighbors fait partie de la famille "neighbors" des méthodes d'apprentissage automatique, qui peuvent être utilisées pour l'apprentissage supervisé et non supervisé. Dans cette méthode, un nombre prédéfini de points est créé et les données sont regroupées autour de ces points afin que des étiquettes généralisées puissent être prédites pour les données.
K-Neighbors fait partie de la famille des méthodes ML « voisins » ("neighbors"), qui peuvent être utilisées pour l’apprentissage supervisé et non supervisé. Dans cette méthode, un nombre prédéfini de points est créé et les données sont regroupées autour de ces points de manière à prédire des étiquettes généralisées pour les données.
### Exercice - appliquer le classificateur K-Neighbors
Le classificateur précédent était bon et fonctionnait bien avec les données, mais peut-être pouvons-nous obtenir une meilleure précision. Essayez un classificateur K-Neighbors.
Le classificateur précédent était bon, et a bien fonctionné avec les données, mais peut-être pouvons-nous obtenir une meilleure précision. Essayez un classificateur K-Neighbors.
1. Ajoutez une ligne à votre tableau de classificateurs (ajoutez une virgule après l'élément Linear SVC) :
1. Ajoutez une ligne à votre tableau de classificateurs (ajoutez une virgule après l’élément Linear SVC) :
```python
'KNN classifier': KNeighborsClassifier(C),
@ -136,23 +136,23 @@ Le classificateur précédent était bon et fonctionnait bien avec les données,
weighted avg 0.76 0.74 0.74 1199
```
✅ En savoir plus sur [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
Les classificateurs à vecteurs de support font partie de la famille des [machines à vecteurs de support](https://wikipedia.org/wiki/Support-vector_machine) en apprentissage automatique, utilisées pour les tâches de classification et de régression. Les SVM "cartographient les exemples d'entraînement en points dans l'espace" pour maximiser la distance entre deux catégories. Les données suivantes sont cartographiées dans cet espace afin que leur catégorie puisse être prédite.
Les classificateurs Support-Vector font partie de la famille des [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) en apprentissage automatique, utilisés pour les tâches de classification et de régression. Les SVM « projettent les exemples d’apprentissage en points dans un espace » pour maximiser la distance entre deux catégories. Les données suivantes sont projetées dans cet espace afin que leur catégorie puisse être prédite.
### Exercice - appliquer un classificateur Support Vector
Essayons d'obtenir une meilleure précision avec un classificateur Support Vector.
Essayons d’obtenir une précision un peu meilleure avec un classificateur Support Vector.
1. Ajoutez une virgule après l'élément K-Neighbors, puis ajoutez cette ligne :
1. Ajoutez une virgule après l’élément K-Neighbors, puis ajoutez cette ligne :
```python
'SVC': SVC(),
```
Le résultat est très bon !
Le résultat est assez bon !
```output
Accuracy (train) for SVC: 83.2%
@ -169,18 +169,18 @@ Essayons d'obtenir une meilleure précision avec un classificateur Support Vecto
weighted avg 0.84 0.83 0.83 1199
```
✅ En savoir plus sur [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)
✅ Découvrez les [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)
## Classificateurs ensemblistes
## Classificateurs en ensemble
Suivons le chemin jusqu'au bout, même si le test précédent était très bon. Essayons quelques 'classificateurs ensemblistes', en particulier Random Forest et AdaBoost :
Suivons le chemin jusqu’au bout, même si le test précédent était assez bon. Essayons des « ensemble classifiers », spécifiquement Random Forest et AdaBoost :
```python
'RFST': RandomForestClassifier(n_estimators=100),
'ADA': AdaBoostClassifier(n_estimators=100)
```
Le résultat est excellent, surtout pour Random Forest :
Le résultat est très bon, surtout pour Random Forest :
```output
Accuracy (train) for RFST: 84.5%
@ -210,31 +210,33 @@ Accuracy (train) for ADA: 72.4%
weighted avg 0.73 0.72 0.72 1199
```
✅ En savoir plus sur [Classificateurs ensemblistes](https://scikit-learn.org/stable/modules/ensemble.html)
✅ Découvrez les [classificateurs en ensemble](https://scikit-learn.org/stable/modules/ensemble.html)
Cette méthode d'apprentissage automatique "combine les prédictions de plusieurs estimateurs de base" pour améliorer la qualité du modèle. Dans notre exemple, nous avons utilisé Random Trees et AdaBoost.
Cette méthode de Machine Learning « combine les prédictions de plusieurs estimateurs de base » pour améliorer la qualité du modèle. Dans notre exemple, nous avons utilisé Random Trees et AdaBoost.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), une méthode d'agrégation, construit une 'forêt' d'arbres de décision infusés de hasard pour éviter le surapprentissage. Le paramètre n_estimators est défini sur le nombre d'arbres.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), une méthode de moyennage, construit une « forêt » d’« arbres de décision » infusionnés de hasard pour éviter le surapprentissage. Le paramètre n_estimators est fixé au nombre d’arbres.
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ajuste un classificateur à un jeu de données, puis ajuste des copies de ce classificateur au même jeu de données. Il se concentre sur les poids des éléments mal classés et ajuste l'ajustement pour le prochain classificateur afin de corriger.
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ajuste un classificateur à un jeu de données, puis ajuste des copies de ce classificateur au même jeu de données. Il se concentre sur les poids des éléments mal classifiés et ajuste l’ajustement pour le classificateur suivant afin de corriger.
---
## 🚀Défi
Chacune de ces techniques possède un grand nombre de paramètres que vous pouvez ajuster. Faites des recherches sur les paramètres par défaut de chacune et réfléchissez à ce que l'ajustement de ces paramètres pourrait signifier pour la qualité du modèle.
Chacune de ces techniques possède un grand nombre de paramètres que vous pouvez modifier. Recherchez les paramètres par défaut de chacune et réfléchissez à ce que modifier ces paramètres signifierait pour la qualité du modèle.
## [Quiz après la leçon](https://ff-quizzes.netlify.app/en/ml/)
Il y a beaucoup de jargon dans ces leçons, alors prenez un moment pour consulter [cette liste](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) de terminologie utile !
Il y a beaucoup de jargon dans ces leçons, alors prenez un instant pour revoir [cette liste](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) de terminologie utile !
## Devoir
[Exploration des paramètres](assignment.md)
[Jeu avec les paramètres](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
Ce document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçons d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source autoritaire. Pour des informations critiques, une traduction humaine professionnelle est recommandée. Nous ne sommes pas responsables des malentendus ou erreurs d’interprétation résultant de l’utilisation de cette traduction.
"\n---\n\n**Avertissement** : \nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de faire appel à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Avertissement** : \nCe document a été traduit à l’aide du service de traduction IA [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des imprécisions. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou de mauvaises interprétations résultant de l’utilisation de cette traduction.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
"\n---\n\n**Avertissement** : \nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de faire appel à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Avertissement** : \nCe document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour les informations critiques, une traduction professionnelle réalisée par un humain est recommandée. Nous déclinons toute responsabilité pour tout malentendu ou mauvaise interprétation résultant de l’utilisation de cette traduction.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
> Ce dépôt inclut plus de 50 traductions linguistiques ce qui augmente significativement la taille du téléchargement. Pour cloner sans les traductions, utilisez le checkout sparse :
> **Vous préférez cloner localement ?**
>
> Ce dépôt comprend plus de 50 traductions en plusieurs langues, ce qui augmente considérablement la taille du téléchargement. Pour cloner sans les traductions, utilisez le sparse checkout :
Nous organisons une série Learn with AI sur Discord, apprenez-en plus et rejoignez-nous à [Learn with AI Series](https://aka.ms/learnwithai/discord) du 18 au 30 septembre 2025. Vous recevrez des astuces et conseils pour utiliser GitHub Copilot pour la Science des Données.
Nous avons une série Discord "apprendre avec l’IA" en cours, en savoir plus et rejoignez-nous sur [Série Apprendre avec l’IA](https://aka.ms/learnwithai/discord) du 18 au 30 septembre 2025. Vous y recevrez des astuces et conseils pour utiliser GitHub Copilot pour la Data Science.
# Apprentissage Automatique pour Débutants - Un Programme
# Apprentissage automatique pour débutants - Un cursus
> 🌍 Parcourez le monde en explorant l'Apprentissage Automatique à travers les cultures mondiales 🌍
> 🌍 Voyagez à travers le monde en explorant l’apprentissage automatique au travers des cultures mondiales 🌍
Les Cloud Advocates chez Microsoft sont heureux de proposer un programme de 12 semaines, 26 leçons, entièrement consacré à **l'Apprentissage Automatique**. Dans ce programme, vous apprendrez ce que l'on appelle parfois **l'apprentissage automatique classique**, en utilisant principalement Scikit-learn comme bibliothèque et en évitant l'apprentissage profond, qui est abordé dans notre [programme AI for Beginners](https://aka.ms/ai4beginners). Associez ces leçons à notre ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners), aussi !
Les Cloud Advocates chez Microsoft sont heureux de proposer un cursus de 12 semaines et 26 leçons entièrement dédié à **l’apprentissage automatique**. Dans ce cursus, vous découvrirez ce que l’on appelle parfois **l’apprentissage automatique classique**, utilisant principalement la bibliothèque Scikit-learn et évitant le deep learning, qui est couvert dans notre [cursus Intelligence Artificielle pour débutants](https://aka.ms/ai4beginners). Associez ces leçons avec notre ['Data Science pour débutants'](https://aka.ms/ds4beginners) également !
Voyagez avec nous autour du monde en appliquant ces techniques classiques sur des données de nombreuses régions. Chaque leçon inclut des quiz avant et après, des instructions écrites pour compléter la leçon, une solution, un devoir, et plus encore. Notre pédagogie basée sur des projets vous permet d'apprendre en construisant, une méthode éprouvée pour que les nouvelles compétences « collent ».
Voyagez avec nous autour du monde en appliquant ces techniques classiques à des données de différentes régions. Chaque leçon inclut des quiz pré- et post-leçon, des instructions écrites pour compléter la leçon, une solution, un défi, et plus encore. Notre pédagogie basée sur des projets vous permet d’apprendre en construisant, une méthode éprouvée pour que les nouvelles compétences « s’ancrent ».
**✍️ Remerciements chaleureux à nos auteurs** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu et Amy Boyd
**✍️ Un grand merci à nos auteurs** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu et Amy Boyd
**🎨 Merci également à nos illustrateurs** Tomomi Imura, Dasani Madipalli, et Jen Looper
**🙏 Remerciements particuliers 🙏 à nos auteurs, réviseurs et contributeurs du Microsoft Student Ambassador**, notamment Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, et Snigdha Agarwal
**🙏 Remerciements spéciaux 🙏 à nos auteurs, réviseurs et contributeurs étudiants Microsoft**, notamment Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, et Snigdha Agarwal
**🤩 Remerciements spéciaux aux Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi, et Vidushi Gupta pour nos leçons R !**
**🤩 Une gratitude particulière aux ambassadeurs étudiants Microsoft Eric Wanjau, Jasleen Sondhi et Vidushi Gupta pour nos leçons R !**
# Démarrage
# Premiers pas
Suivez ces étapes :
1. **Forkez le dépôt** : Cliquez sur le bouton « Fork » en haut à droite de cette page.
2. **Cloner le dépôt** : `git clone https://github.com/microsoft/ML-For-Beginners.git`
2. **Clonez le dépôt** :`git clone https://github.com/microsoft/ML-For-Beginners.git`
> [trouvez toutes les ressources supplémentaires pour ce cours dans notre collection Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> 🔧 **Besoin d’aide ?** Consultez notre [Guide de dépannage](TROUBLESHOOTING.md) pour des solutions aux problèmes courants d’installation, de configuration et d’exécution des leçons.
> 🔧 **Besoin d’aide ?** Consultez notre [Guide de dépannage](TROUBLESHOOTING.md) pour des solutions aux problèmes fréquents d’installation, de configuration et d’exécution des leçons.
**[Étudiants](https://aka.ms/student-page)**, pour utiliser ce programme, forkez le dépôt entier sur votre propre compte GitHub et réalisez les exercices seul ou en groupe :
**[Étudiants](https://aka.ms/student-page)**, pour utiliser ce cursus, forkez le dépôt complet vers votre propre compte GitHub et faites les exercices seuls ou en groupe :
- Commencez par un quiz pré-conférence.
- Lisez la leçon et complétez les activités, en faisant des pauses pour réfléchir à chaque contrôle de connaissance.
- Essayez de créer les projets en comprenant les leçons plutôt qu’en exécutant directement le code solution ; ce code est cependant disponible dans les dossiers `/solution` de chaque leçon orientée projet.
- Lisez la leçon puis réalisez les activités, en faisant des pauses et réflexions à chaque contrôle des connaissances.
- Essayez de créer les projets en comprenant les leçons, plutôt que d’exécuter directement le code de solution ; ce code est néanmoins disponible dans les dossiers `/solution` de chaque leçon orientée projet.
- Passez le quiz post-conférence.
- Réalisez le défi.
- Réalisez le devoir.
- Après avoir terminé un groupe de leçons, visitez le [Forum de discussion](https://github.com/microsoft/ML-For-Beginners/discussions) et « apprenez à voix haute » en remplissant la grille PAT appropriée. Un 'PAT' est un Outil d’Évaluation de Progrès que vous remplissez pour approfondir votre apprentissage. Vous pouvez également réagir aux autres PAT pour apprendre ensemble.
- Après avoir terminé un groupe de leçons, visitez le [Forum de discussion](https://github.com/microsoft/ML-For-Beginners/discussions) et « apprenez à voix haute » en remplissant la grille d’évaluation PAT appropriée. Un PAT est un outil d’évaluation des progrès que vous complétez pour approfondir votre apprentissage. Vous pouvez aussi réagir aux autres PAT pour apprendre ensemble.
> Pour aller plus loin, nous recommandons de suivre ces modules et parcours d’apprentissage [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott).
**Enseignants**, nous avons [inclus quelques suggestions](for-teachers.md) sur l’utilisation de ce programme.
**Enseignants**, nous avons [inclus quelques suggestions](for-teachers.md) pour utiliser ce cursus.
---
## Vidéos explicatives
Certaines leçons sont disponibles sous forme de vidéos courtes. Vous pouvez toutes les trouver en ligne dans les leçons ou sur la [playlist ML for Beginners sur la chaîne Microsoft Developer YouTube](https://aka.ms/ml-beginners-videos) en cliquant sur l’image ci-dessous.
Certaines leçons sont disponibles en format vidéo court. Vous pouvez toutes les trouver intégrées dans les leçons, ou sur la [playlist ML pour débutants de la chaîne Microsoft Developer YouTube](https://aka.ms/ml-beginners-videos) en cliquant sur l’image ci-dessous.
[](https://aka.ms/ml-beginners-videos)
[](https://aka.ms/ml-beginners-videos)
@ -97,90 +107,90 @@ Certaines leçons sont disponibles sous forme de vidéos courtes. Vous pouvez to
## Pédagogie
Nous avons choisi deux principes pédagogiques pour ce programme : garantir qu’il soit pratique **basé sur des projets** et qu’il inclue des **quiz fréquents**. De plus, ce programme a un **thème** commun pour lui donner cohérence.
Nous avons choisi deux principes pédagogiques pour construire ce cursus : garantir qu’il soit pratique et **basé sur des projets**, et qu’il inclue des **quiz fréquents**. De plus, ce cursus a un **thème commun** pour lui donner de la cohérence.
En assurant que le contenu s’aligne avec des projets, le processus devient plus engageant pour les étudiants et la rétention des concepts est augmentée. De plus, un quiz à enjeu faible avant le cours fixe l’intention d’apprentissage de l’étudiant, tandis qu’un second quiz après le cours assure une meilleure rétention. Ce programme est conçu pour être flexible et ludique, pouvant être suivi en totalité ou en partie. Les projets commencent petits et deviennent de plus en plus complexes à la fin du cycle de 12 semaines. Ce programme inclut également un post-scriptum sur des applications réelles du ML, utilisable comme crédit supplémentaire ou comme base de discussion.
En s’assurant que le contenu est aligné sur des projets, le processus devient plus engageant pour les étudiants et la rétention des concepts s’en trouve augmentée. De plus, un quiz à enjeu faible avant un cours fixe l’intention d’apprendre du participant, tandis qu’un second quiz après le cours permet de consolider les acquis. Ce cursus a été conçu pour être flexible et ludique, et peut être suivi en totalité ou en partie. Les projets commencent petits et deviennent de plus en plus complexes au fil du cycle de 12 semaines. Ce cursus inclut également un post-scriptum sur les applications réelles de l’apprentissage automatique, qui peut être utilisé pour un crédit supplémentaire ou comme base de discussion.
> Retrouvez notre [Code de conduite](CODE_OF_CONDUCT.md), [Contribuer](CONTRIBUTING.md), [Traduction](TRANSLATIONS.md) et [Dépannage](TROUBLESHOOTING.md). Vos retours constructifs sont les bienvenus !
## Chaque leçon inclut
- esquisse (sketchnote) optionnelle
- vidéo complémentaire optionnelle
- vidéo explicative (certaines leçons seulement)
- un sketchnote facultatif
- une vidéo complémentaire facultative
- une vidéo explicative (certaines leçons seulement)
> **Note sur les langues** : Ces leçons sont principalement écrites en Python, mais beaucoup sont aussi disponibles en R. Pour compléter une leçon en R, allez dans le dossier `/solution` et cherchez les leçons R. Elles incluent une extension .rmd qui représente un fichier **R Markdown**, simplement défini comme un mélange de `blocs de code` (en R ou autres langages) et un `en-tête YAML` (guidant le format de sortie comme PDF) dans un `document Markdown`. En tant que tel, c’est un cadre d’auteurs exemplaire pour la science des données puisqu’il vous permet de combiner votre code, ses résultats, et vos pensées en les écrivant en Markdown. De plus, les documents R Markdown peuvent être rendus dans des formats de sortie comme PDF, HTML ou Word.
> **Une note à propos des quiz** : Tous les quiz sont contenus dans le dossier [Quiz App folder](../../quiz-app), pour un total de 52 quiz de trois questions chacun. Ils sont liés depuis les leçons mais l’application quiz peut être exécutée localement ; suivez les instructions dans le dossier `quiz-app` pour héberger localement ou déployer sur Azure.
| Numéro de la leçon | Sujet | Regroupement de la leçon | Objectifs d’apprentissage | Leçon liée | Auteur |
| 01 | Introduction à l’apprentissage automatique | [Introduction](1-Introduction/README.md) | Apprenez les concepts de base derrière l’apprentissage automatique | [Leçon](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | L’histoire de l’apprentissage automatique | [Introduction](1-Introduction/README.md) | Apprenez l’histoire sous-jacente de ce domaine | [Leçon](1-Introduction/2-history-of-ML/README.md) | Jen et Amy |
| 03 | Équité et apprentissage automatique | [Introduction](1-Introduction/README.md) | Quelles sont les importantes questions philosophiques autour de l’équité que les étudiants doivent considérer lors de la construction et de l’application de modèles ML ? | [Leçon](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Techniques pour l’apprentissage automatique | [Introduction](1-Introduction/README.md) | Quelles techniques les chercheurs ML utilisent-ils pour construire des modèles ML ? | [Leçon](1-Introduction/4-techniques-of-ML/README.md) | Chris et Jen |
| 05 | Introduction à la régression | [Regression](2-Regression/README.md) | Démarrer avec Python et Scikit-learn pour les modèles de régression | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Prix des citrouilles en Amérique du Nord 🎃 | [Regression](2-Regression/README.md) | Visualiser et nettoyer les données en préparation pour l’apprentissage automatique | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Prix des citrouilles en Amérique du Nord 🎃 | [Regression](2-Regression/README.md) | Construire des modèles de régression linéaire et polynomiale | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen et Dmitry • Eric Wanjau |
| 08 | Prix des citrouilles en Amérique du Nord 🎃 | [Regression](2-Regression/README.md) | Construire un modèle de régression logistique | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | Une application web 🔌 | [Web App](3-Web-App/README.md) | Construire une application web pour utiliser votre modèle entraîné | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introduction à la classification | [Classification](4-Classification/README.md) | Nettoyer, préparer et visualiser vos données ; introduction à la classification | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen et Cassie • Eric Wanjau |
| 11 | Plats délicieux asiatiques et indiens 🍜 | [Classification](4-Classification/README.md) | Introduction aux classificateurs | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen et Cassie • Eric Wanjau |
| 12 | Plats délicieux asiatiques et indiens 🍜 | [Classification](4-Classification/README.md) | Plus de classificateurs | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen et Cassie • Eric Wanjau |
| 13 | Plats délicieux asiatiques et indiens 🍜 | [Classification](4-Classification/README.md) | Construire une application web de recommandation utilisant votre modèle | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduction au clustering | [Clustering](5-Clustering/README.md) | Nettoyer, préparer et visualiser vos données ; introduction au clustering | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Explorer les goûts musicaux nigérians 🎧 | [Clustering](5-Clustering/README.md) | Explorer la méthode de clustering K-Means | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Introduction au traitement du langage naturel ☕️ | [Natural language processing](6-NLP/README.md) | Apprenez les bases du NLP en construisant un simple bot | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Tâches courantes en NLP ☕️ | [Natural language processing](6-NLP/README.md) | Approfondissez vos connaissances NLP en comprenant les tâches courantes requises pour traiter les structures linguistiques | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Traduction et analyse de sentiment ♥️ | [Natural language processing](6-NLP/README.md) | Traduction et analyse de sentiment avec Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Hôtels romantiques en Europe ♥️ | [Natural language processing](6-NLP/README.md) | Analyse de sentiment avec des avis d’hôtel 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Hôtels romantiques en Europe ♥️ | [Natural language processing](6-NLP/README.md) | Analyse de sentiment avec des avis d’hôtel 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introduction à la prévision de séries temporelles | [Time series](7-TimeSeries/README.md) | Introduction à la prévision de séries temporelles | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Utilisation mondiale de l’énergie ⚡️ - prévision de séries temporelles avec ARIMA | [Time series](7-TimeSeries/README.md) | Prévision de séries temporelles avec ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Utilisation mondiale de l’énergie ⚡️ - prévision de séries temporelles avec SVR | [Time series](7-TimeSeries/README.md) | Prévision de séries temporelles avec Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introduction à l’apprentissage par renforcement | [Reinforcement learning](8-Reinforcement/README.md) | Introduction à l’apprentissage par renforcement avec Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Aider Peter à éviter le loup ! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | Environnement Gym pour apprentissage par renforcement | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Postface | Scénarios et applications ML en conditions réelles | [ML in the Wild](9-Real-World/README.md) | Applications intéressantes et révélatrices du ML classique en conditions réelles | [Leçon](9-Real-World/1-Applications/README.md) | Équipe |
| Postface | Débogage de modèle en ML avec le tableau de bord RAI | [ML in the Wild](9-Real-World/README.md) | Débogage de modèle en apprentissage automatique avec les composants du tableau de bord Responsible AI | [Leçon](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [trouvez toutes les ressources supplémentaires pour ce cours dans notre collection Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> **Une note sur les langues** : Ces leçons sont principalement écrites en Python, mais beaucoup sont aussi disponibles en R. Pour compléter une leçon en R, allez dans le dossier `/solution` et cherchez les leçons en R. Elles incluent une extension .rmd qui représente un fichier **R Markdown** pouvant être simplement défini comme une intégration de `blocs de code` (en R ou autres langages) et un `en-tête YAML` (qui guide comment formater les sorties telles que PDF) dans un `document Markdown`. Ainsi, il sert de cadre exemplaire pour la création de contenus en science des données car il permet de combiner votre code, ses sorties, et vos réflexions en vous permettant de les écrire en Markdown. De plus, les documents R Markdown peuvent être rendus dans des formats de sortie tels que PDF, HTML ou Word.
> **Une note sur les quiz** : Tous les quiz sont contenus dans le [dossier Quiz App](../../quiz-app), pour un total de 52 quiz composés chacun de trois questions. Ils sont liés depuis les leçons mais l'application de quiz peut être exécutée localement ; suivez les instructions du dossier `quiz-app` pour héberger localement ou déployer sur Azure.
| Numéro de leçon | Sujet | Regroupement des leçons | Objectifs d'apprentissage | Leçon liée | Auteur |
| 01 | Introduction à l'apprentissage automatique | [Introduction](1-Introduction/README.md) | Apprenez les concepts de base derrière l'apprentissage automatique | [Leçon](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | L'histoire de l'apprentissage automatique | [Introduction](1-Introduction/README.md) | Apprenez l'histoire sous-jacente de ce domaine | [Leçon](1-Introduction/2-history-of-ML/README.md) | Jen et Amy |
| 03 | Équité et apprentissage automatique | [Introduction](1-Introduction/README.md) | Quels sont les enjeux philosophiques importants autour de l'équité que les étudiants devraient considérer lors de la création et de l'application de modèles ML ? | [Leçon](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Techniques d'apprentissage automatique | [Introduction](1-Introduction/README.md) | Quelles techniques les chercheurs en ML utilisent-ils pour construire des modèles ML ? | [Leçon](1-Introduction/4-techniques-of-ML/README.md) | Chris et Jen |
| 05 | Introduction à la régression | [Régression](2-Regression/README.md) | Démarrez avec Python et Scikit-learn pour les modèles de régression | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Prix des citrouilles en Amérique du Nord 🎃 | [Régression](2-Regression/README.md) | Visualisez et nettoyez les données en préparation pour le ML | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Prix des citrouilles en Amérique du Nord 🎃 | [Régression](2-Regression/README.md) | Construisez des modèles de régression linéaire et polynomiale | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen et Dmitry • Eric Wanjau |
| 08 | Prix des citrouilles en Amérique du Nord 🎃 | [Régression](2-Regression/README.md) | Construisez un modèle de régression logistique | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | Une application web 🔌 | [Application Web](3-Web-App/README.md) | Construisez une application web pour utiliser votre modèle entraîné | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introduction à la classification | [Classification](4-Classification/README.md) | Nettoyez, préparez et visualisez vos données ; introduction à la classification | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen et Cassie • Eric Wanjau |
| 11 | Délicieuses cuisines asiatiques et indiennes 🍜 | [Classification](4-Classification/README.md) | Introduction aux classifieurs | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen et Cassie • Eric Wanjau |
| 12 | Délicieuses cuisines asiatiques et indiennes 🍜 | [Classification](4-Classification/README.md) | Plus de classifieurs | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen et Cassie • Eric Wanjau |
| 13 | Délicieuses cuisines asiatiques et indiennes 🍜 | [Classification](4-Classification/README.md) | Construisez une application web de recommandation en utilisant votre modèle | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduction au clustering | [Clustering](5-Clustering/README.md) | Nettoyez, préparez et visualisez vos données ; Introduction au clustering | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Exploration des goûts musicaux nigérians 🎧 | [Clustering](5-Clustering/README.md) | Explorez la méthode de clustering K-Means | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Introduction au traitement du langage naturel ☕️ | [Traitement du langage naturel](6-NLP/README.md) | Apprenez les bases du NLP en construisant un bot simple | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Tâches courantes en NLP ☕️ | [Traitement du langage naturel](6-NLP/README.md) | Approfondissez vos connaissances en NLP en comprenant les tâches courantes nécessaires pour traiter les structures linguistiques | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Traduction et analyse de sentiments ♥️ | [Traitement du langage naturel](6-NLP/README.md) | Traduction et analyse de sentiments avec Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Hôtels romantiques en Europe ♥️ | [Traitement du langage naturel](6-NLP/README.md) | Analyse de sentiments avec avis d’hôtels 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Hôtels romantiques en Europe ♥️ | [Traitement du langage naturel](6-NLP/README.md) | Analyse de sentiments avec avis d’hôtels 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introduction à la prévision des séries temporelles | [Séries temporelles](7-TimeSeries/README.md) | Introduction à la prévision des séries temporelles | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Consommation mondiale d’électricité ⚡️ - prévision avec ARIMA | [Séries temporelles](7-TimeSeries/README.md) | Prévision des séries temporelles avec ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Consommation mondiale d’électricité ⚡️ - prévision avec SVR | [Séries temporelles](7-TimeSeries/README.md) | Prévision des séries temporelles avec Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introduction à l’apprentissage par renforcement | [Apprentissage par renforcement](8-Reinforcement/README.md) | Introduction à l’apprentissage par renforcement avec Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Aidez Peter à éviter le loup! 🐺 | [Apprentissage par renforcement](8-Reinforcement/README.md) | Environnement Reinforcement Learning Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Post-scriptum | Scénarios et applications ML réels | [ML en milieu réel](9-Real-World/README.md) | Applications intéressantes et révélatrices du ML classique | [Leçon](9-Real-World/1-Applications/README.md) | Équipe |
| Post-scriptum | Débogage de modèles ML avec tableau de bord RAI | [ML en milieu réel](9-Real-World/README.md) | Débogage des modèles en apprentissage machine avec les composants du tableau de bord Responsible AI | [Leçon](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [trouvez toutes les ressources complémentaires pour ce cours dans notre collection Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## Accès hors ligne
Vous pouvez exécuter cette documentation hors ligne en utilisant [Docsify](https://docsify.js.org/#/). Forkez ce dépôt, [installez Docsify](https://docsify.js.org/#/quickstart) sur votre machine locale, puis dans le dossier racine de ce dépôt, tapez `docsify serve`. Le site sera servi sur le port 3000 de votre localhost : `localhost:3000`.
Vous pouvez utiliser cette documentation hors ligne en utilisant [Docsify](https://docsify.js.org/#/). Forkez ce dépôt, [installez Docsify](https://docsify.js.org/#/quickstart) sur votre machine locale, puis dans le dossier racine de ce dépôt, tapez `docsify serve`. Le site web sera servi sur le port 3000 de votre localhost : `localhost:3000`.
## PDFs
Trouvez un PDF du programme avec les liens [ici](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
Trouvez un pdf du programme avec les liens [ici](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
## 🎒 Autres cours
## 🎒 Autres cours
Notre équipe produit d’autres cours ! Découvrez :
<!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
---
### Azure / Edge / MCP / Agents
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### Série sur l’intelligence artificielle générative
### Série IA générative
[](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
Si vous êtes bloqué ou avez des questions sur la création d'applications IA, rejoignez d'autres apprenants et développeurs expérimentés pour des discussions sur MCP. C'est une communauté bienveillante où les questions sont les bienvenues et où la connaissance est partagée librement.
Si vous êtes bloqué ou avez des questions sur la création d’applications IA. Rejoignez d’autres apprenants et développeurs expérimentés pour discuter du MCP. C’est une communauté d’entraide où les questions sont les bienvenues et le savoir est partagé librement.
- Consultez les notebooks après chaque leçon pour une meilleure compréhension.
- Pratiquez la mise en œuvre des algorithmes par vous-même.
- Explorez des jeux de données réels en utilisant les concepts appris.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement**:
Ce document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour les informations critiques, il est recommandé de faire appel à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d’interprétations erronées résultant de l’utilisation de cette traduction.
**Avertissement**:
Ce document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous fassions de notre mieux pour assurer l’exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle effectuée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d’interprétations erronées résultant de l’utilisation de cette traduction.
localizeflow[bot]
2 months ago