diff --git a/translations/en/.co-op-translator.json b/translations/en/.co-op-translator.json
index 1d8cde2e3..beba21163 100644
--- a/translations/en/.co-op-translator.json
+++ b/translations/en/.co-op-translator.json
@@ -90,8 +90,8 @@
"language_code": "en"
},
"2-Regression/3-Linear/README.md": {
- "original_hash": "9a8359f1945bd3beccccb2b46592580e",
- "translation_date": "2026-02-28T08:15:37+00:00",
+ "original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
+ "translation_date": "2026-04-20T15:37:29+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "en"
},
@@ -168,8 +168,8 @@
"language_code": "en"
},
"4-Classification/2-Classifiers-1/README.md": {
- "original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
- "translation_date": "2025-09-06T10:55:54+00:00",
+ "original_hash": "cb761595e5b6c42b99bb81bd13683311",
+ "translation_date": "2026-04-20T15:38:27+00:00",
"source_file": "4-Classification/2-Classifiers-1/README.md",
"language_code": "en"
},
@@ -552,8 +552,8 @@
"language_code": "en"
},
"README.md": {
- "original_hash": "7fb48097f57e680b380cd9aae988d317",
- "translation_date": "2026-04-06T15:42:29+00:00",
+ "original_hash": "3e3a6c7e68e0afe7e2276ac046e4d7a0",
+ "translation_date": "2026-04-20T15:36:08+00:00",
"source_file": "README.md",
"language_code": "en"
},
diff --git a/translations/en/2-Regression/3-Linear/README.md b/translations/en/2-Regression/3-Linear/README.md
index 8e1212e23..db874423e 100644
--- a/translations/en/2-Regression/3-Linear/README.md
+++ b/translations/en/2-Regression/3-Linear/README.md
@@ -207,13 +207,13 @@ lin_reg.fit(X_train,y_train)
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 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.
+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 root mean square error (RMSE) metrics, which is the root of the mean of all squared differences between expected and predicted value.
```python
pred = lin_reg.predict(X_test)
-mse = np.sqrt(mean_squared_error(y_test,pred))
-print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+rmse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
```
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:
@@ -382,5 +382,5 @@ In this lesson we learned about Linear Regression. There are other important typ
**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 document has been translated using 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.
\ No newline at end of file
diff --git a/translations/en/4-Classification/2-Classifiers-1/README.md b/translations/en/4-Classification/2-Classifiers-1/README.md
index d514f9642..180e29aa8 100644
--- a/translations/en/4-Classification/2-Classifiers-1/README.md
+++ b/translations/en/4-Classification/2-Classifiers-1/README.md
@@ -1,17 +1,17 @@
# Cuisine classifiers 1
-In this lesson, you will use the dataset you saved from the previous lesson, which contains balanced and clean data about cuisines.
+In this lesson, you will use the dataset you saved from the last lesson full of balanced, clean data all about cuisines.
-You will use this dataset with various classifiers to _predict the national cuisine based on a set of ingredients_. Along the way, you'll learn more about how algorithms can be applied to classification tasks.
+You will use this dataset with a variety of classifiers to _predict a given national cuisine based on a group of ingredients_. While doing so, you'll learn more about some of the ways that algorithms can be leveraged for classification tasks.
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
# Preparation
-If you completed [Lesson 1](../1-Introduction/README.md), ensure that a _cleaned_cuisines.csv_ file exists in the root `/data` folder for these four lessons.
+Assuming you completed [Lesson 1](../1-Introduction/README.md), make sure that a _cleaned_cuisines.csv_ file exists in the root `/data` folder for these four lessons.
## Exercise - predict a national cuisine
-1. In this lesson's _notebook.ipynb_ folder, import the file along with the Pandas library:
+1. Working in this lesson's _notebook.ipynb_ folder, import that file along with the Pandas library:
```python
import pandas as pd
@@ -30,7 +30,7 @@ If you completed [Lesson 1](../1-Introduction/README.md), ensure that a _cleaned
| 4 | 4 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
-1. Next, import several additional libraries:
+1. Now, import several more libraries:
```python
from sklearn.linear_model import LogisticRegression
@@ -40,7 +40,7 @@ If you completed [Lesson 1](../1-Introduction/README.md), ensure that a _cleaned
import numpy as np
```
-1. Separate the X and y coordinates into two dataframes for training. Use `cuisine` as the labels dataframe:
+1. Divide the X and y coordinates into two dataframes for training. `cuisine` can be the labels dataframe:
```python
cuisines_label_df = cuisines_df['cuisine']
@@ -58,14 +58,14 @@ If you completed [Lesson 1](../1-Introduction/README.md), ensure that a _cleaned
Name: cuisine, dtype: object
```
-1. Drop the `Unnamed: 0` column and the `cuisine` column using `drop()`. Save the remaining data as trainable features:
+1. Drop that `Unnamed: 0` column and the `cuisine` column, calling `drop()`. Save the rest of the data as trainable features:
```python
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
cuisines_feature_df.head()
```
- Your features will look like this:
+ Your features look like this:
| | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | artemisia | artichoke | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| ---: | -----: | -------: | ----: | ---------: | ----: | -----------: | ------: | -------: | --------: | --------: | ---: | ------: | ----------: | ---------: | ----------------------: | ---: | ---: | ---: | ----: | -----: | -------: |
@@ -75,13 +75,13 @@ If you completed [Lesson 1](../1-Introduction/README.md), ensure that a _cleaned
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
-Now you're ready to train your model!
+Now you are ready to train your model!
## Choosing your classifier
-With your data clean and ready for training, it's time to decide which algorithm to use for the task.
+Now that your data is clean and ready for training, you have to decide which algorithm to use for the job.
-Scikit-learn categorizes classification under Supervised Learning, offering a wide range of classification methods. [The options](https://scikit-learn.org/stable/supervised_learning.html) can seem overwhelming at first glance. These methods include:
+Scikit-learn groups classification under Supervised Learning, and in that category you will find many ways to classify. [The variety](https://scikit-learn.org/stable/supervised_learning.html) is quite bewildering at first sight. The following methods all include classification techniques:
- Linear Models
- Support Vector Machines
@@ -92,58 +92,58 @@ Scikit-learn categorizes classification under Supervised Learning, offering a wi
- Ensemble methods (voting Classifier)
- Multiclass and multioutput algorithms (multiclass and multilabel classification, multiclass-multioutput classification)
-> You can also use [neural networks for classification](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), but that is beyond the scope of this lesson.
+> You can also use [neural networks to classify data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), but that is outside the scope of this lesson.
-### Which classifier should you choose?
+### What classifier to go with?
-So, how do you decide on a classifier? Often, testing several options and comparing results is a good approach. Scikit-learn provides a [side-by-side comparison](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) on a sample dataset, showcasing KNeighbors, SVC (two variations), GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB, and QuadraticDiscriminationAnalysis, with visualized results:
+So, which classifier should you choose? Often, running through several and looking for a good result is a way to test. Scikit-learn offers a [side-by-side comparison](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) on a created dataset, comparing KNeighbors, SVC two ways, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB and QuadraticDiscrinationAnalysis, showing the results visualized:
-
-> Plots generated from Scikit-learn's documentation
+
+> Plots generated on Scikit-learn's documentation
-> AutoML simplifies this process by running these comparisons in the cloud, helping you select the best algorithm for your data. Try it [here](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
+> AutoML solves this problem neatly by running these comparisons in the cloud, allowing you to choose the best algorithm for your data. Try it [here](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
-### A more informed approach
+### A better approach
-Instead of guessing, you can refer to this downloadable [ML Cheat Sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). For our multiclass problem, it suggests several options:
+A better way than wildly guessing, however, is to follow the ideas on this downloadable [ML Cheat sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Here, we discover that, for our multiclass problem, we have some choices:
-
+
> A section of Microsoft's Algorithm Cheat Sheet, detailing multiclass classification options
-✅ Download this cheat sheet, print it out, and keep it handy!
+✅ Download this cheat sheet, print it out, and hang it on your wall!
### Reasoning
-Let's evaluate different approaches based on our constraints:
+Let's see if we can reason our way through different approaches given the constraints we have:
-- **Neural networks are too resource-intensive**. Given our clean but small dataset and the fact that we're training locally in notebooks, neural networks are not ideal for this task.
-- **Avoid two-class classifiers**. Since this is not a binary classification problem, two-class classifiers like one-vs-all are not suitable.
-- **Decision tree or logistic regression could work**. Both decision trees and logistic regression are viable options for multiclass data.
-- **Multiclass Boosted Decision Trees are not suitable**. These are better for nonparametric tasks like ranking, which is not relevant here.
+- **Neural networks are too heavy**. Given our clean, but minimal dataset, and the fact that we are running training locally via notebooks, neural networks are too heavyweight for this task.
+- **No two-class classifier**. We do not use a two-class classifier, so that rules out one-vs-all.
+- **Decision tree or logistic regression could work**. A decision tree might work, or logistic regression for multiclass data.
+- **Multiclass Boosted Decision Trees solve a different problem**. The multiclass boosted decision tree is most suitable for nonparametric tasks, e.g. tasks designed to build rankings, so it is not useful for us.
### Using Scikit-learn
-We'll use Scikit-learn to analyze our data. Logistic regression in Scikit-learn offers several options. Check out the [parameters](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression) you can configure.
+We will be using Scikit-learn to analyze our data. However, there are many ways to use logistic regression in Scikit-learn. Take a look at the [parameters to pass](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
-Two key parameters to set are `multi_class` and `solver`. These determine the behavior and algorithm used for logistic regression. Not all solvers are compatible with all `multi_class` values.
+Essentially there are two important parameters - `multi_class` and `solver` - that we need to specify, when we ask Scikit-learn to perform a logistic regression. The `multi_class` value applies a certain behavior. The value of the solver is what algorithm to use. Not all solvers can be paired with all `multi_class` values.
-According to the documentation, for multiclass classification:
+According to the docs, in the multiclass case, the training algorithm:
-- **The one-vs-rest (OvR) scheme** is used if `multi_class` is set to `ovr`.
-- **Cross-entropy loss** is used if `multi_class` is set to `multinomial`. (The `multinomial` option is supported only by the ‘lbfgs’, ‘sag’, ‘saga’, and ‘newton-cg’ solvers.)
+- **Uses the one-vs-rest (OvR) scheme**, if the `multi_class` option is set to `ovr`
+- **Uses the cross-entropy loss**, if the `multi_class` option is set to `multinomial`. (Currently the `multinomial` option is supported only by the ‘lbfgs’, ‘sag’, ‘saga’ and ‘newton-cg’ solvers.)"
-> 🎓 The 'scheme' refers to how logistic regression handles multiclass classification. It can be 'ovr' (one-vs-rest) or 'multinomial'. These schemes adapt logistic regression, which is primarily designed for binary classification, to handle multiclass tasks. [source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
+> 🎓 The 'scheme' here can either be 'ovr' (one-vs-rest) or 'multinomial'. Since logistic regression is really designed to support binary classification, these schemes allow it to better handle multiclass classification tasks. [source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
-> 🎓 The 'solver' is the algorithm used to optimize the problem. [source](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
+> 🎓 The 'solver' is defined as "the algorithm to use in the optimization problem". [source](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
-Scikit-learn provides this table to explain how solvers handle different challenges based on data structures:
+Scikit-learn offers this table to explain how solvers handle different challenges presented by different kinds of data structures:
-
+
## Exercise - split the data
-Let's start with logistic regression for our first training attempt, as you recently learned about it in a previous lesson.
-Split your data into training and testing sets using `train_test_split()`:
+We can focus on logistic regression for our first training trial since you recently learned about the latter in a previous lesson.
+Split your data into training and testing groups by calling `train_test_split()`:
```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
@@ -151,9 +151,9 @@ X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisine
## Exercise - apply logistic regression
-Since this is a multiclass problem, you need to choose a _scheme_ and a _solver_. Use LogisticRegression with a multiclass setting and the **liblinear** solver for training.
+Since you are using the multiclass case, you need to choose what _scheme_ to use and what _solver_ to set. Use LogisticRegression with a multiclass setting and the **liblinear** solver to train.
-1. Create a logistic regression model with `multi_class` set to `ovr` and the solver set to `liblinear`:
+1. Create a logistic regression with multi_class set to `ovr` and the solver set to `liblinear`:
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
@@ -163,9 +163,11 @@ Since this is a multiclass problem, you need to choose a _scheme_ and a _solver_
print ("Accuracy is {}".format(accuracy))
```
- ✅ Try using a different solver like `lbfgs`, which is often the default option.
-> Note, use Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) function to flatten your data when needed.
-The accuracy is good at over **80%**!
+ ✅ Try a different solver like `lbfgs`, which is often set as default
+
+ > Note, use Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) function to flatten your data when needed.
+
+ The accuracy is good at over **80%**!
1. You can see this model in action by testing one row of data (#50):
@@ -181,9 +183,8 @@ The accuracy is good at over **80%**!
cuisine: indian
```
- ✅ Try a different row number and check the results.
-
-1. Digging deeper, you can check the accuracy of this prediction:
+ ✅ Try a different row number and check the results
+1. Digging deeper, you can check for the accuracy of this prediction:
```python
test= X_test.iloc[50].values.reshape(-1, 1).T
@@ -205,7 +206,7 @@ The accuracy is good at over **80%**!
| korean | 0.017277 |
| thai | 0.007634 |
- ✅ Can you explain why the model is quite confident this is an Indian cuisine?
+ ✅ Can you explain why the model is pretty sure this is an Indian cuisine?
1. Get more detail by printing a classification report, as you did in the regression lessons:
@@ -221,7 +222,7 @@ The accuracy is good at over **80%**!
| japanese | 0.70 | 0.75 | 0.72 | 220 |
| korean | 0.86 | 0.76 | 0.81 | 242 |
| thai | 0.79 | 0.85 | 0.82 | 254 |
- | accuracy | 0.80 | 1199 | | |
+ | accuracy | | | 0.80 | 1199 |
| macro avg | 0.80 | 0.80 | 0.80 | 1199 |
| weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
@@ -234,12 +235,13 @@ In this lesson, you used your cleaned data to build a machine learning model tha
## Review & Self Study
Dig a little more into the math behind logistic regression in [this lesson](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
-
## Assignment
[Study the solvers](assignment.md)
---
+
**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.
\ No newline at end of file
+This document has been translated using 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.
+
\ No newline at end of file
diff --git a/translations/en/README.md b/translations/en/README.md
index ed9008d87..08517de77 100644
--- a/translations/en/README.md
+++ b/translations/en/README.md
@@ -217,13 +217,24 @@ Our team produces other courses! Check out:
## Getting Help
-If you get stuck or have any questions about building AI apps. Join fellow learners and experienced developers in discussions about MCP. It's a supportive community where questions are welcome and knowledge is shared freely.
+If you get stuck or have questions while learning Machine Learning or building AI applications, don't worry — help is available.
-[](https://discord.gg/nTYy5BXMWG)
+You can join discussions with other learners and developers, ask questions, and share your ideas with the community.
+
+- Join the community to ask questions and learn with others
+- Discuss Machine Learning concepts and project ideas
+- Get guidance from experienced developers
+
+A supportive community is a great way to grow your skills and solve problems faster.
-If you have product feedback or errors while building visit:
+[Microsoft Foundry Discord Community](https://discord.gg/nTYy5BXMWG)
+
+If you encounter bugs, errors, or have suggestions for improvements, you can also open an **Issue** in this repository to report the problem.
+
+For product feedback or to search existing community posts, visit the Developer Forum:
[](https://aka.ms/foundry/forum)
+
## Additional Learning Tips
- Review notebooks after each lesson for better understanding.
@@ -233,6 +244,6 @@ If you have product feedback or errors while building visit:
---
-**Disclaimer**:
+**Disclaimer**:
This document has been translated using 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.
\ No newline at end of file
diff --git a/translations/es/.co-op-translator.json b/translations/es/.co-op-translator.json
index ca38e09d1..aac701b79 100644
--- a/translations/es/.co-op-translator.json
+++ b/translations/es/.co-op-translator.json
@@ -90,8 +90,8 @@
"language_code": "es"
},
"2-Regression/3-Linear/README.md": {
- "original_hash": "9a8359f1945bd3beccccb2b46592580e",
- "translation_date": "2026-02-28T08:20:58+00:00",
+ "original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
+ "translation_date": "2026-04-20T15:47:07+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "es"
},
@@ -168,8 +168,8 @@
"language_code": "es"
},
"4-Classification/2-Classifiers-1/README.md": {
- "original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
- "translation_date": "2025-09-04T22:23:06+00:00",
+ "original_hash": "cb761595e5b6c42b99bb81bd13683311",
+ "translation_date": "2026-04-20T15:48:08+00:00",
"source_file": "4-Classification/2-Classifiers-1/README.md",
"language_code": "es"
},
@@ -552,8 +552,8 @@
"language_code": "es"
},
"README.md": {
- "original_hash": "7fb48097f57e680b380cd9aae988d317",
- "translation_date": "2026-04-06T15:45:44+00:00",
+ "original_hash": "3e3a6c7e68e0afe7e2276ac046e4d7a0",
+ "translation_date": "2026-04-20T15:45:43+00:00",
"source_file": "README.md",
"language_code": "es"
},
diff --git a/translations/es/2-Regression/3-Linear/README.md b/translations/es/2-Regression/3-Linear/README.md
index 427229172..ff938ca16 100644
--- a/translations/es/2-Regression/3-Linear/README.md
+++ b/translations/es/2-Regression/3-Linear/README.md
@@ -1,136 +1,135 @@
-# Construir un modelo de regresión usando Scikit-learn: regresión de cuatro maneras
+# Construir un modelo de regresión usando Scikit-learn: regresión de cuatro formas
## 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.
+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 mejor representa 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/)
+## [Cuestionario previo a la clase](https://ff-quizzes.netlify.app/en/ml/)
-> ### [¡Esta lección está disponible en R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
+> ### [Esta lección está disponible en R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introducción
-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.
+Hasta ahora has explorado qué es la regresión con datos de muestra tomados 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 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.
+Ahora estás listo para profundizar en la 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 dependencias en 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 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.
+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 subyacente a estas técnicas. Estos modelos nos permitirán predecir precios de calabazas dependiendo de distintas entradas.
-[](https://youtu.be/CRxFT8oTDMg "ML para principiantes - Entendiendo la regresión lineal")
+[](https://youtu.be/CRxFT8oTDMg "ML para principiantes – Entendiendo la Regresión Lineal")
-> 🎥 Haz clic en la imagen arriba para un video corto con una visión general de la regresión lineal.
+> 🎥 Haz clic en la imagen de arriba para un video corto que presenta la regresión lineal.
-> 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.
+> A lo largo de este currículum, 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 ayudarán en la comprensión.
-### Prerrequisitos
+### Prerrequisito
-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.
+Ya deberías estar familiarizado con la estructura de los datos de calabazas que estamos examinando. Puedes encontrarlos precargados y pre-limpiados en el archivo _notebook.ipynb_ de esta lección. En el archivo, el precio de las calabazas se muestra por fanega en un nuevo dataframe. Asegúrate de poder ejecutar estos notebooks en kernels en Visual Studio Code.
### Preparación
-Como recordatorio, cargas estos datos para poder hacer preguntas sobre ellos.
+Como recordatorio, cargas estos datos para poder hacerles preguntas.
-- ¿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 indagando en estos datos.
+- ¿Cuál es el mejor momento para comprar calabazas?
+- ¿Qué precio puedo esperar de una caja de calabazas miniatura?
+- ¿Debería comprarlas en cestas de media fanega o por la caja de 1 1/9 fanegas?
+Sigamos investigando estos datos.
-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.
+En la lección anterior, creaste un dataframe de Pandas y lo llenaste con parte del conjunto original, estandarizando el precio por fanega. De esa forma, solo pudiste obtener alrededor de 400 puntos de datos y solo para los meses de otoño.
-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.
+Mira los datos que precargamos en el notebook que acompaña esta lección. Los datos están precargados y un diagrama de dispersión inicial se grafica para mostrar datos por mes. Tal vez 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:
+Como aprendiste en la Lección 1, el objetivo de un ejercicio de regresión lineal es poder graficar una línea para:
-- **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.
+- **Mostrar relaciones entre variables**. Mostrar la relación entre variables
+- **Hacer predicciones**. Hacer predicciones precisas sobre dónde caería 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.
+Es típico de la **Regresión de 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:
-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.
+1. **Magnitud sobre Dirección:** Queremos tratar un error de -5 igual que un error de +5. Elevar al cuadrado convierte todos los valores en positivos.
-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.
+2. **Penalizar valores atípicos:** Al elevar al cuadrado se da más peso a errores mayores, forzando a la línea a quedarse más cerca de puntos alejados.
-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".
+Luego sumamos todos estos valores al cuadrado. Nuestro objetivo es encontrar la línea específica donde esta suma final es la menor (el valor más pequeño posible), de ahí el nombre de "Mínimos Cuadrados".
-> **🧮 Muéstrame las matemáticas**
->
-> Esta línea, llamada _línea de mejor ajuste_, puede expresarse con [una ecuación](https://en.wikipedia.org/wiki/Simple_linear_regression):
->
+> **🧮 Muéstrame las matemáticas**
+>
+> 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 en 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)
+> Primero, se calcula la pendiente `b`. Infografía por [Jen Looper](https://twitter.com/jenlooper)
>
-> 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.
+> En otras palabras, y refiriéndonos a la pregunta original de nuestro dato de calabazas: "predecir el precio de una calabaza por fanega 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 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`.
+> 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 de 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 impactan la línea.
+> Puedes ver el método de cálculo para estos valores en el sitio [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 el valor de los números impacta la línea.
## 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 término más para entender es el **Coeficiente de Correlación** entre variables dadas X y Y. Usando un diagrama de dispersión, puedes visualizar rápidamente este coeficiente. Un gráfico con puntos dispersos en una línea ordenada tiene alta correlación, pero uno con puntos dispersos en todas partes entre X y Y tiene baja correlació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.
+Un buen modelo de regresión lineal será uno que tenga un Coeficiente de Correlación alto (más cercano a 1 que a 0) usando el método de Regresión de Mínimos Cuadrados con una línea de regresión.
-✅ 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)?
+✅ Ejecuta el notebook que acompaña esta lección y observa el diagrama de dispersión Mes a Precio. ¿Parece que la asociación entre Mes y Precio para las ventas de calabazas tiene alta o baja correlación, según tu interpretación visual del diagrama de dispersión? ¿Cambia eso si usas una medida más fina en lugar 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 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
+---|-----|-----------|----------|--------|---------|-------------|-------------|--------
+70 | 9 | 267 | TIPO PARA PAY | BALTIMORE | cajas de 1 1/9 fanegas | 15.0 | 15.0 | 13.636364
+71 | 9 | 267 | TIPO PARA PAY | BALTIMORE | cajas de 1 1/9 fanegas | 18.0 | 18.0 | 16.363636
+72 | 10 | 274 | TIPO PARA PAY | BALTIMORE | cajas de 1 1/9 fanegas | 18.0 | 18.0 | 16.363636
+73 | 10 | 274 | TIPO PARA PAY | BALTIMORE | cajas de 1 1/9 fanegas | 17.0 | 17.0 | 15.454545
+74 | 10 | 281 | TIPO PARA PAY | BALTIMORE | cajas de 1 1/9 fanegas | 15.0 | 15.0 | 13.636364
-> 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:
+> 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 calculamos la columna `DayOfYear` usando la siguiente expresión:
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
-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.
+Ahora que entiendes la matemática detrás de la regresión lineal, creemos un modelo de regresión para ver si podemos predecir qué paquete de calabazas tendrá los mejores precios. Alguien que compra calabazas para un huerto navideño podría querer esta información para optimizar sus compras.
-## Buscando correlación
+## Buscando Correlación
-[](https://youtu.be/uoRq-lW2eQo "ML para principiantes - Buscando correlación: La clave para la regresión lineal")
+[](https://youtu.be/uoRq-lW2eQo "ML para principiantes - Buscando Correlación: La Clave para la Regresión Lineal")
-> 🎥 Haz clic en la imagen arriba para un video corto con una visión general de la correlación.
+> 🎥 Haz clic en la imagen de arriba para un video corto que presenta la correlación.
-Probablemente en la lección anterior viste que el precio promedio por diferentes meses se ve así:
+En la lección anterior probablemente viste que el precio promedio por diferentes meses luce así:
-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:
+Esto sugiere que debería haber algo de 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 diagrama de dispersión que muestra esta última relación:
-Vamos a ver si hay correlación usando la función `corr`:
+Veamos si hay correlación usando la función `corr`:
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
-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:
+Parece que la correlación es bastante pequeña, -0.15 usando `Mes` y -0.17 usando `DíaDelMes`, pero podría haber otra relación importante. Parece que hay diferentes grupos de precios según las distintas variedades de calabaza. Para confirmar esta hipótesis, graficamos cada categoría de calabaza usando un color diferente. Pasando un parámetro `ax` a la función de graficar `scatter` podemos poner todos los puntos en el mismo gráfico:
```python
ax=None
@@ -142,7 +141,7 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
-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:
+Nuestra investigación sugiere que la variedad afecta más el precio final que la fecha de venta real. Podemos ver esto en un gráfico de barras:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
@@ -150,7 +149,7 @@ new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
-Vamos a enfocarnos por el momento solo en una variedad de calabaza, la 'tipo pastel', y ver qué efecto tiene la fecha sobre el precio:
+Enfoquémonos por ahora solo en una variedad de calabaza, el 'tipo para pay', y veamos qué efecto tiene la fecha en el precio:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
@@ -158,24 +157,24 @@ pie_pumpkins.plot.scatter('DayOfYear','Price')
```
-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.
+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 eliminar todas las celdas vacías:
+> Antes de entrenar un modelo de regresión lineal, es importante asegurarnos que los datos estén limpios. La regresión lineal no funciona bien con valores faltantes, por lo que conviene 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 los valores promedio de la columna correspondiente.
+Otra opción sería llenar esos valores vacíos con el valor medio 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 Polinomial usando Scikit-learn")
-> 🎥 Haz clic en la imagen arriba para un video corto con una visión general de la regresión lineal y polinómica.
+> 🎥 Haz clic en la imagen de arriba para un video corto que presenta la regresión lineal y polinomial.
-Para entrenar nuestro modelo de Regresión Lineal usaremos la biblioteca **Scikit-learn**.
+Para entrenar nuestro modelo de Regresión Lineal, usaremos la biblioteca **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
@@ -183,47 +182,46 @@ 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 arreglos numpy separados:
+Comenzamos separando los valores de entrada (características) y la salida esperada (etiqueta) en matrices numpy separadas:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
-> 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.
+> Nota que tuvimos que aplicar `reshape` a los datos de entrada para que el paquete de Regresión Lineal los entienda correctamente. La Regresión Lineal espera un array 2D como entrada, donde cada fila del array corresponde a un vector de características de entrada. En nuestro caso, dado que solo tenemos una entrada, necesitamos un array 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 poder 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 de entrenarlo:
```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 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`:
+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`:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
-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.
+El objeto `LinearRegression` después de ajustar (`fit`) contiene todos los coeficientes de la regresión, a los cuales se puede acceder usando 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 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_` - estará alrededor de `21` en nuestro caso, indicando el precio al inicio 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 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.
+Para ver qué tan preciso es nuestro modelo, podemos predecir los 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 de raíz del error cuadrático medio (RMSE), que es la raíz de la media de todas las diferencias al cuadrado entre el valor esperado y el predicho.
```python
pred = lin_reg.predict(X_test)
-mse = np.sqrt(mean_squared_error(y_test,pred))
-print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+rmse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
```
-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í:
+Nuestro error parece estar alrededor de 2 puntos, 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 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.
+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 promedio del resultado. El valor de 1 significa que podemos predecir perfectamente todos los valores esperados. En nuestro caso, el coeficiente es alrededor de 0.06, lo cual 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:
@@ -232,21 +230,21 @@ plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
-
+
## Regresión Polinómica
-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.
+Otro tipo de Regresión Lineal es la Regresión Polinómica. Aunque a veces existe una relación lineal entre variables - cuanto mayor es el volumen de la calabaza, mayor es el precio - a veces estas relaciones no pueden ser representadas por un plano o línea recta.
-✅ 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
+✅ Aquí hay [algunos ejemplos más](https://online.stat.psu.edu/stat501/lesson/9/9.8) de datos que podrían usar 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.
+Echa otro vistazo a la relación entre Fecha y Precio. ¿Parece este diagrama de dispersión que deba necesariamente analizarse con una línea recta? ¿No pueden los precios fluctuar? 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
-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.
+La regresión polinómica crea una curva para ajustar mejor 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.
-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:
+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 añade características polinómicas a nuestro modelo, y luego entrena la regresión:
```python
from sklearn.preprocessing import PolynomialFeatures
@@ -257,36 +255,36 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
-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`2, pero dado dos variables de entrada X y Y, esto agregará X2, XY y Y2. También podemos usar polinomios de grado superior si queremos.
+Usar `PolynomialFeatures(2)` significa que incluiremos todos los polinomios de segundo grado de los datos de entrada. En nuestro caso solo significa `DayOfYear`2, pero dado dos variables de entrada X y Y, esto agregaría X2, XY y Y2. 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 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:
+Los pipelines pueden usarse de la misma manera que el objeto original `LinearRegression`, es decir, podemos `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 menor y un coeficiente de determinación más alto, pero no de forma significativa. ¡Necesitamos tener en cuenta otras características!
+Usando Regresión Polinómica, podemos obtener un MSE ligeramente más bajo y una determinación más alta, pero no significativamente. ¡Necesitamos tomar en cuenta otras características!
-> Puedes ver que los precios mínimos de las calabazas se observan alrededor 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 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!
+🎃 ¡Felicidades, acabas de crear un modelo que puede ayudar a predecir el precio de las calabazas para pasteles! Probablemente puedas repetir el mismo procedimiento para todos los tipos de calabazas, pero eso sería tedioso. ¡Aprendamos ahora cómo tomar 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 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**.
+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. Tales columnas se llaman **categóricas**.
-[](https://youtu.be/DYGliioIAE0 "ML para principiantes - Predicciones con características categóricas usando Regresión Lineal")
+[](https://youtu.be/DYGliioIAE0 "ML para principiantes - Predicciones con características categóricas usando regresión lineal")
-> 🎥 Haz clic en la imagen arriba para un breve video sobre el uso de características categóricas.
+> 🎥 Haz clic en la imagen arriba para un breve video explicativo sobre el uso de características categóricas.
Aquí puedes ver cómo depende el precio promedio de la variedad:
-
+
-Para tener en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias formas de hacerlo:
+Para tomar en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias maneras de hacerlo:
-* 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.
+* La simple **codificación numérica** creará una tabla de diferentes variedades y reemplazará el nombre por un índice en esa tabla. Esto no es la mejor idea para regresión lineal, porque la regresión lineal toma el valor numérico real del índice y lo suma al resultado multiplicado por algún coeficiente. En nuestro caso, la relación entre el número del índice y el precio es claramente no lineal, incluso si aseguramos 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á un `1` si la fila correspondiente es de esa variedad, y `0` si no. Esto significa que habrá cuatro coeficientes en la regresión lineal, uno para cada variedad de calabaza, responsables por el "precio inicial" (o más bien "precio adicional") para esa variedad particular.
-El código a continuación muestra cómo codificar one-hot una variedad:
+El código a continuación muestra cómo podemos hacer codificación one-hot de una variedad:
```python
pd.get_dummies(new_pumpkins['Variety'])
@@ -303,14 +301,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
-Para entrenar la regresión lineal usando la variedad codificada one-hot como entrada, solo necesitamos inicializar datos `X` y `y` correctamente:
+Para entrenar la regresión lineal usando la variedad codificada one-hot como entrada, solo necesitamos inicializar los datos `X` y `y` correctamente:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
-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`:
+El resto del código es el mismo que usamos arriba para entrenar 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 una matriz grande de características, podemos usar `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@@ -320,31 +318,31 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
-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!
+Aquí también tomamos en cuenta `City` y tipo de `Package`, lo que nos da un MSE de 2.84 (10%) y una determinación de 0.94!
-## Integrando todo junto
+## Poniéndolo todo junto
-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:
+Para hacer el mejor modelo, podemos usar datos combinados (categóricos codificados one-hot + numéricos) del ejemplo anterior junto con Regresión Polinómica. Aquí está el código completo para tu conveniencia:
```python
-# configurar datos de entrenamiento
+# configurar los 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']
-# realizar la división de entrenamiento-prueba
+# hacer la división entrenamiento-prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-# configurar y entrenar la tubería
+# configurar y entrenar el pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
-# predecir resultados para datos de prueba
+# predecir resultados para los datos de prueba
pred = pipeline.predict(X_test)
-# calcular MSE y determinación
+# calcular el error cuadrático medio y la determinación
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
@@ -352,36 +350,36 @@ score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
-Esto debería darnos el mejor coeficiente de determinación de casi 97%, y 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 en la 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 |
+| Regresión Lineal con `DayOfYear` | 2.77 (17.2%) | 0.07 |
+| Regresión Polinómica con `DayOfYear` | 2.73 (17.0%) | 0.08 |
+| Regresión Lineal con `Variety` | 5.24 (19.7%) | 0.77 |
+| Regresión Lineal con todas las características | 2.84 (10.5%) | 0.94 |
+| Regresión Polinómica con todas las características | 2.23 (8.25%) | 0.97 |
-🏆 ¡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.
+🏆 ¡Buen trabajo! Creaste cuatro modelos de regresión en una 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.
---
## 🚀Desafío
-Prueba varias variables diferentes en este cuaderno 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 con la precisión del modelo.
-## [Cuestionario posterior a la clase](https://ff-quizzes.netlify.app/en/ml/)
+## [Cuestionario post-clase](https://ff-quizzes.netlify.app/en/ml/)
## Repaso y Autoestudio
-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)
+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 Aprendizaje Estadístico de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Tarea
-[Construir un Modelo](assignment.md)
+[Construye un modelo](assignment.md)
---
-**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.
+**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 una traducción profesional humana. No nos hacemos responsables de ningún malentendido o interpretación errónea que surja del uso de esta traducción.
\ No newline at end of file
diff --git a/translations/es/4-Classification/2-Classifiers-1/README.md b/translations/es/4-Classification/2-Classifiers-1/README.md
index 4ca93e70f..b4b6236de 100644
--- a/translations/es/4-Classification/2-Classifiers-1/README.md
+++ b/translations/es/4-Classification/2-Classifiers-1/README.md
@@ -1,13 +1,13 @@
# Clasificadores de cocina 1
-En esta lección, usarás el conjunto de datos que guardaste en la última lección, lleno de datos equilibrados y limpios sobre cocinas.
+En esta lección, usarás el conjunto de datos que guardaste de la lección anterior, lleno de datos equilibrados y limpios sobre cocinas.
-Utilizarás este conjunto de datos con una variedad de clasificadores para _predecir una cocina nacional dada un grupo de ingredientes_. Mientras lo haces, aprenderás más sobre algunas de las formas en que los algoritmos pueden ser aprovechados para tareas de clasificación.
+Usarás este conjunto de datos con una variedad de clasificadores para _predecir una cocina nacional dada en base a un grupo de ingredientes_. Mientras lo haces, aprenderás más sobre algunas de las formas en que se pueden aprovechar los algoritmos para tareas de clasificación.
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
# Preparación
-Asumiendo que completaste [Lección 1](../1-Introduction/README.md), asegúrate de que exista un archivo _cleaned_cuisines.csv_ en la carpeta raíz `/data` para estas cuatro lecciones.
+Asumiendo que completaste la [Lección 1](../1-Introduction/README.md), asegúrate de que el archivo _cleaned_cuisines.csv_ exista en la carpeta raíz `/data` para estas cuatro lecciones.
## Ejercicio - predecir una cocina nacional
@@ -40,7 +40,7 @@ Asumiendo que completaste [Lección 1](../1-Introduction/README.md), asegúrate
import numpy as np
```
-1. Divide las coordenadas X e y en dos dataframes para entrenamiento. `cuisine` puede ser el dataframe de etiquetas:
+1. Divide las coordenadas X y y en dos dataframes para entrenamiento. `cuisine` puede ser el dataframe de etiquetas:
```python
cuisines_label_df = cuisines_df['cuisine']
@@ -58,7 +58,7 @@ Asumiendo que completaste [Lección 1](../1-Introduction/README.md), asegúrate
Name: cuisine, dtype: object
```
-1. Elimina la columna `Unnamed: 0` y la columna `cuisine`, usando `drop()`. Guarda el resto de los datos como características entrenables:
+1. Elimina esa columna `Unnamed: 0` y la columna `cuisine` usando `drop()`. Guarda el resto de los datos como características para entrenar:
```python
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
@@ -79,70 +79,70 @@ Asumiendo que completaste [Lección 1](../1-Introduction/README.md), asegúrate
## Elegir tu clasificador
-Ahora que tus datos están limpios y listos para el entrenamiento, debes decidir qué algoritmo usar para la tarea.
+Ahora que tus datos están limpios y listos para el entrenamiento, tienes que decidir qué algoritmo usar para la tarea.
-Scikit-learn agrupa la clasificación bajo Aprendizaje Supervisado, y en esa categoría encontrarás muchas formas de clasificar. [La variedad](https://scikit-learn.org/stable/supervised_learning.html) puede ser bastante abrumadora a primera vista. Los siguientes métodos incluyen técnicas de clasificación:
+Scikit-learn agrupa la clasificación dentro del Aprendizaje Supervisado, y en esa categoría encontrarás muchas formas de clasificar. [La variedad](https://scikit-learn.org/stable/supervised_learning.html) es bastante abrumadora al principio. Los siguientes métodos incluyen técnicas de clasificación:
-- Modelos Lineales
-- Máquinas de Vectores de Soporte
-- Descenso de Gradiente Estocástico
-- Vecinos Más Cercanos
-- Procesos Gaussianos
-- Árboles de Decisión
-- Métodos de Ensamble (clasificador por votación)
-- Algoritmos multicategoría y multioutput (clasificación multicategoría y multilabel, clasificación multicategoría-multioutput)
+- Modelos lineales
+- Máquinas de vectores de soporte
+- Descenso por gradiente estocástico
+- Vecinos más cercanos
+- Procesos gaussianos
+- Árboles de decisión
+- Métodos de conjunto (voting Classifier)
+- Algoritmos multiclase y multioutput (clasificación multiclase y multilabel, clasificación multiclase-multioutput)
> También puedes usar [redes neuronales para clasificar datos](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), pero eso está fuera del alcance de esta lección.
### ¿Qué clasificador elegir?
-Entonces, ¿qué clasificador deberías elegir? A menudo, probar varios y buscar un buen resultado es una forma de evaluar. Scikit-learn ofrece una [comparación lado a lado](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) en un conjunto de datos creado, comparando KNeighbors, SVC de dos maneras, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB y QuadraticDiscriminationAnalysis, mostrando los resultados visualizados:
+Entonces, ¿qué clasificador deberías elegir? A menudo, probar varios y buscar un buen resultado es una forma de testear. Scikit-learn ofrece una [comparación lado a lado](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) en un conjunto de datos creado, comparando KNeighbors, SVC de dos maneras, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB y QuadraticDiscrinationAnalysis, mostrando los resultados visualizados:
-
+
> Gráficos generados en la documentación de Scikit-learn
-> AutoML resuelve este problema de manera eficiente al realizar estas comparaciones en la nube, permitiéndote elegir el mejor algoritmo para tus datos. Pruébalo [aquí](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
+> AutoML resuelve este problema de manera ordenada al ejecutar estas comparaciones en la nube, permitiéndote elegir el mejor algoritmo para tus datos. Pruébalo [aquí](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
-### Un enfoque mejor
+### Un mejor enfoque
-Una mejor manera que adivinar al azar, sin embargo, es seguir las ideas en esta descargable [hoja de trucos de ML](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Aquí, descubrimos que, para nuestro problema multicategoría, tenemos algunas opciones:
+Una mejor forma que adivinar al azar es seguir las ideas de esta descargable [hoja de trucos de ML](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Aquí, descubrimos que, para nuestro problema multiclase, tenemos algunas opciones:
-
-> Una sección de la Hoja de Trucos de Algoritmos de Microsoft, detallando opciones de clasificación multicategoría
+
+> Una sección de la Hoja de Trucos de Algoritmos de Microsoft, detallando opciones para clasificación multiclase
-✅ Descarga esta hoja de trucos, imprímela y cuélgala en tu pared.
+✅ ¡Descarga esta hoja de trucos, imprímela y cuélgala en tu pared!
### Razonamiento
-Veamos si podemos razonar sobre diferentes enfoques dados los límites que tenemos:
+Veamos si podemos razonar las diferentes opciones dadas las restricciones que tenemos:
-- **Las redes neuronales son demasiado pesadas**. Dado nuestro conjunto de datos limpio pero mínimo, y el hecho de que estamos ejecutando el entrenamiento localmente a través de notebooks, las redes neuronales son demasiado pesadas para esta tarea.
-- **No usamos clasificadores de dos clases**. No usamos un clasificador de dos clases, por lo que descartamos el enfoque uno-contra-todos.
-- **Un árbol de decisión o regresión logística podrían funcionar**. Un árbol de decisión podría funcionar, o regresión logística para datos multicategoría.
-- **Los árboles de decisión potenciados multicategoría resuelven un problema diferente**. El árbol de decisión potenciado multicategoría es más adecuado para tareas no paramétricas, por ejemplo, tareas diseñadas para construir rankings, por lo que no es útil para nosotros.
+- **Las redes neuronales son muy pesadas**. Dado nuestro conjunto de datos limpio, pero mínimo, y el hecho de que estamos entrenando localmente a través de notebooks, las redes neuronales son demasiado pesadas para esta tarea.
+- **No hay clasificador de dos clases**. No usamos un clasificador de dos clases, por lo que se descarta one-vs-all.
+- **Podría funcionar un árbol de decisión o regresión logística**. Un árbol de decisión podría funcionar, o una regresión logística para datos multiclase.
+- **Los árboles de decisión potenciados multiclase resuelven un problema diferente**. El árbol de decisión potenciado multiclase es más adecuado para tareas no paramétricas, por ejemplo, tareas diseñadas para construir rankings, por lo que no nos es útil.
-### Usando Scikit-learn
+### Usando Scikit-learn
-Usaremos Scikit-learn para analizar nuestros datos. Sin embargo, hay muchas formas de usar regresión logística en Scikit-learn. Echa un vistazo a los [parámetros que puedes pasar](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
+Usaremos Scikit-learn para analizar nuestros datos. Sin embargo, hay muchas formas de usar la regresión logística en Scikit-learn. Echa un vistazo a los [parámetros para pasar](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
-Esencialmente hay dos parámetros importantes - `multi_class` y `solver` - que necesitamos especificar cuando pedimos a Scikit-learn que realice una regresión logística. El valor de `multi_class` aplica un cierto comportamiento. El valor del solver es el algoritmo que se usará. No todos los solvers pueden ser emparejados con todos los valores de `multi_class`.
+Esencialmente hay dos parámetros importantes - `multi_class` y `solver` - que necesitamos especificar cuando pedimos a Scikit-learn que realice una regresión logística. El valor de `multi_class` aplica un comportamiento determinado. El valor del solver es el algoritmo a usar. No todos los solvers pueden combinarse con todos los valores `multi_class`.
-Según la documentación, en el caso multicategoría, el algoritmo de entrenamiento:
+Según la documentación, en el caso multiclase, el algoritmo de entrenamiento:
-- **Usa el esquema uno-contra-resto (OvR)**, si la opción `multi_class` está configurada como `ovr`.
-- **Usa la pérdida de entropía cruzada**, si la opción `multi_class` está configurada como `multinomial`. (Actualmente la opción `multinomial` solo es compatible con los solvers ‘lbfgs’, ‘sag’, ‘saga’ y ‘newton-cg’).
+- **Utiliza el esquema uno contra el resto (OvR)**, si la opción `multi_class` está configurada a `ovr`
+- **Utiliza la pérdida de entropía cruzada**, si la opción `multi_class` está configurada a `multinomial`. (Actualmente la opción `multinomial` es soportada únicamente por los solvers ‘lbfgs’, ‘sag’, ‘saga’ y ‘newton-cg’)."
-> 🎓 El 'esquema' aquí puede ser 'ovr' (uno-contra-resto) o 'multinomial'. Dado que la regresión logística está realmente diseñada para soportar clasificación binaria, estos esquemas le permiten manejar mejor tareas de clasificación multicategoría. [fuente](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
+> 🎓 El 'esquema' aquí puede ser 'ovr' (uno contra resto) o 'multinomial'. Dado que la regresión logística está realmente diseñada para soportar clasificación binaria, estos esquemas le permiten manejar mejor tareas de clasificación multiclase. [fuente](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 El 'solver' se define como "el algoritmo a usar en el problema de optimización". [fuente](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
-Scikit-learn ofrece esta tabla para explicar cómo los solvers manejan diferentes desafíos presentados por diferentes tipos de estructuras de datos:
+Scikit-learn ofrece esta tabla para explicar cómo los solvers manejan diferentes desafíos presentados por distintos tipos de estructuras de datos:
-
+
## Ejercicio - dividir los datos
-Podemos centrarnos en la regresión logística para nuestra primera prueba de entrenamiento, ya que recientemente aprendiste sobre esta en una lección anterior.
+Podemos concentrarnos en regresión logística para nuestra primera prueba de entrenamiento ya que recientemente aprendiste sobre ella en una lección anterior.
Divide tus datos en grupos de entrenamiento y prueba llamando a `train_test_split()`:
```python
@@ -151,9 +151,9 @@ X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisine
## Ejercicio - aplicar regresión logística
-Dado que estás usando el caso multicategoría, necesitas elegir qué _esquema_ usar y qué _solver_ configurar. Usa LogisticRegression con una configuración multicategoría y el solver **liblinear** para entrenar.
+Dado que estás usando el caso multiclase, necesitas elegir qué _esquema_ usar y qué _solver_ configurar. Usa LogisticRegression con ajuste multiclase y el solver **liblinear** para entrenar.
-1. Crea una regresión logística con multi_class configurado como `ovr` y el solver configurado como `liblinear`:
+1. Crea una regresión logística con multi_class configurado a `ovr` y el solver configurado a `liblinear`:
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
@@ -163,9 +163,11 @@ Dado que estás usando el caso multicategoría, necesitas elegir qué _esquema_
print ("Accuracy is {}".format(accuracy))
```
- ✅ Prueba un solver diferente como `lbfgs`, que a menudo se configura como predeterminado.
-> Nota, utiliza la función [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) de Pandas para aplanar tus datos cuando sea necesario.
-¡La precisión es buena, con más del **80%**!
+ ✅ Prueba un solver diferente como `lbfgs`, que a menudo se usa por defecto
+
+ > Nota, usa la función [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) de Pandas para aplanar tus datos cuando sea necesario.
+
+ ¡La precisión es buena, superior al **80%**!
1. Puedes ver este modelo en acción probando una fila de datos (#50):
@@ -181,9 +183,8 @@ Dado que estás usando el caso multicategoría, necesitas elegir qué _esquema_
cuisine: indian
```
- ✅ Prueba con un número de fila diferente y verifica los resultados.
-
-1. Profundizando más, puedes comprobar la precisión de esta predicción:
+ ✅ Prueba un número de fila diferente y revisa los resultados
+1. Profundizando más, puedes comprobar la exactitud de esta predicción:
```python
test= X_test.iloc[50].values.reshape(-1, 1).T
@@ -205,40 +206,42 @@ Dado que estás usando el caso multicategoría, necesitas elegir qué _esquema_
| korean | 0.017277 |
| thai | 0.007634 |
- ✅ ¿Puedes explicar por qué el modelo está bastante seguro de que se trata de una cocina india?
+ ✅ ¿Puedes explicar por qué el modelo está bastante seguro de que esta es una cocina india?
-1. Obtén más detalles imprimiendo un informe de clasificación, como hiciste en las lecciones de regresión:
+1. Obtén más detalle imprimiendo un informe de clasificación, como hiciste en las lecciones de regresión:
```python
y_pred = model.predict(X_test)
print(classification_report(y_test,y_pred))
```
- | | precisión | recall | f1-score | soporte |
+ | | precision | recall | f1-score | support |
| ------------ | --------- | ------ | -------- | ------- |
| chinese | 0.73 | 0.71 | 0.72 | 229 |
| indian | 0.91 | 0.93 | 0.92 | 254 |
| japanese | 0.70 | 0.75 | 0.72 | 220 |
| korean | 0.86 | 0.76 | 0.81 | 242 |
| thai | 0.79 | 0.85 | 0.82 | 254 |
- | exactitud | 0.80 | 1199 | | |
- | promedio macro | 0.80 | 0.80 | 0.80 | 1199 |
- | promedio ponderado | 0.80 | 0.80 | 0.80 | 1199 |
+ | accuracy | | | 0.80 | 1199 |
+ | macro avg | 0.80 | 0.80 | 0.80 | 1199 |
+ | weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
## 🚀Desafío
-En esta lección, utilizaste tus datos limpios para construir un modelo de aprendizaje automático que puede predecir una cocina nacional basada en una serie de ingredientes. Tómate un tiempo para leer las muchas opciones que Scikit-learn ofrece para clasificar datos. Profundiza en el concepto de 'solver' para entender qué sucede detrás de escena.
+En esta lección, usaste tus datos limpios para construir un modelo de aprendizaje automático que puede predecir una cocina nacional basada en una serie de ingredientes. Tómate un tiempo para leer las muchas opciones que Scikit-learn ofrece para clasificar datos. Profundiza en el concepto de 'solver' para entender qué sucede tras bambalinas.
## [Cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
-## Revisión y autoestudio
+## Revisión y estudio independiente
-Investiga un poco más sobre las matemáticas detrás de la regresión logística en [esta lección](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
+Profundiza un poco más en las matemáticas detrás de la regresión logística en [esta lección](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Tarea
[Estudia los solvers](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). 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.
\ No newline at end of file
+Este documento ha sido traducido utilizando el servicio de traducción AI [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 responsabilizamos por malentendidos o interpretaciones erróneas que surjan del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/README.md b/translations/es/README.md
index b67fc4bec..6479e98f0 100644
--- a/translations/es/README.md
+++ b/translations/es/README.md
@@ -10,14 +10,14 @@
### 🌐 Soporte multilingüe
-#### Soportado via GitHub Action (Automatizado y siempre actualizado)
+#### Soportado mediante GitHub Action (Automatizado y siempre actualizado)
-[Árabe](../ar/README.md) | [Bengalí](../bn/README.md) | [Búlgaro](../bg/README.md) | [Birmano (Myanmar)](../my/README.md) | [Chino (Simplificado)](../zh-CN/README.md) | [Chino (Tradicional, Hong Kong)](../zh-HK/README.md) | [Chino (Tradicional, Macao)](../zh-MO/README.md) | [Chino (Tradicional, Taiwán)](../zh-TW/README.md) | [Croata](../hr/README.md) | [Checo](../cs/README.md) | [Danés](../da/README.md) | [Holandés](../nl/README.md) | [Estonio](../et/README.md) | [Finlandés](../fi/README.md) | [Francés](../fr/README.md) | [Alemán](../de/README.md) | [Griego](../el/README.md) | [Hebreo](../he/README.md) | [Hindi](../hi/README.md) | [Húngaro](../hu/README.md) | [Indonesio](../id/README.md) | [Italiano](../it/README.md) | [Japonés](../ja/README.md) | [Kannada](../kn/README.md) | [Jemer](../km/README.md) | [Coreano](../ko/README.md) | [Lituano](../lt/README.md) | [Malayo](../ms/README.md) | [Malayalam](../ml/README.md) | [Maratí](../mr/README.md) | [Nepalí](../ne/README.md) | [Pidgin Nigeriano](../pcm/README.md) | [Noruego](../no/README.md) | [Persa (Farsi)](../fa/README.md) | [Polaco](../pl/README.md) | [Portugués (Brasil)](../pt-BR/README.md) | [Portugués (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Rumano](../ro/README.md) | [Ruso](../ru/README.md) | [Serbio (Cirílico)](../sr/README.md) | [Eslovaco](../sk/README.md) | [Esloveno](../sl/README.md) | [Español](./README.md) | [Swahili](../sw/README.md) | [Sueco](../sv/README.md) | [Tagalo (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugú](../te/README.md) | [Tailandés](../th/README.md) | [Turco](../tr/README.md) | [Ucraniano](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamita](../vi/README.md)
+[Árabe](../ar/README.md) | [Bengalí](../bn/README.md) | [Búlgaro](../bg/README.md) | [Birmano (Myanmar)](../my/README.md) | [Chino (simplificado)](../zh-CN/README.md) | [Chino (tradicional, Hong Kong)](../zh-HK/README.md) | [Chino (tradicional, Macao)](../zh-MO/README.md) | [Chino (tradicional, Taiwán)](../zh-TW/README.md) | [Croata](../hr/README.md) | [Checo](../cs/README.md) | [Danés](../da/README.md) | [Holandés](../nl/README.md) | [Estonio](../et/README.md) | [Finlandés](../fi/README.md) | [Francés](../fr/README.md) | [Alemán](../de/README.md) | [Griego](../el/README.md) | [Hebreo](../he/README.md) | [Hindi](../hi/README.md) | [Húngaro](../hu/README.md) | [Indonesio](../id/README.md) | [Italiano](../it/README.md) | [Japonés](../ja/README.md) | [Kannada](../kn/README.md) | [Jemer](../km/README.md) | [Coreano](../ko/README.md) | [Lituano](../lt/README.md) | [Malayo](../ms/README.md) | [Malayalam](../ml/README.md) | [Maratí](../mr/README.md) | [Nepalí](../ne/README.md) | [Pidgin nigeriano](../pcm/README.md) | [Noruego](../no/README.md) | [Persa (Farsi)](../fa/README.md) | [Polaco](../pl/README.md) | [Portugués (Brasil)](../pt-BR/README.md) | [Portugués (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Rumano](../ro/README.md) | [Ruso](../ru/README.md) | [Serbio (cirílico)](../sr/README.md) | [Eslovaco](../sk/README.md) | [Esloveno](../sl/README.md) | [Español](./README.md) | [Suajili](../sw/README.md) | [Sueco](../sv/README.md) | [Tagalo (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](../te/README.md) | [Tailandés](../th/README.md) | [Turco](../tr/README.md) | [Ucraniano](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamita](../vi/README.md)
> **¿Prefieres clonar localmente?**
>
-> Este repositorio incluye más de 50 traducciones de idiomas lo que aumenta significativamente el tamaño de la descarga. Para clonar sin las traducciones, use sparse checkout:
+> Este repositorio incluye más de 50 traducciones de idiomas que aumentan significativamente el tamaño de la descarga. Para clonar sin traducciones, usa sparse checkout:
>
> **Bash / macOS / Linux:**
> ```bash
@@ -33,64 +33,65 @@
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
-> Esto te da todo lo que necesitas para completar el curso con una descarga mucho más rápida.
+> Esto te proporciona todo lo necesario para completar el curso con una descarga mucho más rápida.
#### Únete a nuestra comunidad
[](https://discord.gg/nTYy5BXMWG)
-Tenemos una serie en Discord para aprender con IA en curso, aprende más 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 para Ciencia de Datos.
+Tenemos una serie en Discord para aprender con IA, conoce más y únete en [Learn with AI Series](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.
-# Aprendizaje Automático para Principiantes - Un Currículo
+# Aprendizaje automático para principiantes - Un plan de estudios
> 🌍 Viaja alrededor del mundo mientras exploramos el Aprendizaje Automático mediante culturas del mundo 🌍
-Los Cloud Advocates en Microsoft se complacen en ofrecer un currículo de 12 semanas, con 26 lecciones, todo sobre **Aprendizaje Automático**. En este currículo, aprenderás sobre lo que a veces se llama **aprendizaje automático clásico**, utilizando 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 combina 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 plan de estudios de 12 semanas con 26 lecciones sobre **Aprendizaje Automático**. En este plan, aprenderás sobre lo que a veces se llama **aprendizaje automático clásico**, usando principalmente la biblioteca Scikit-learn y evitando el aprendizaje profundo, que se cubre en nuestro [plan de estudios AI para principiantes](https://aka.ms/ai4beginners). ¡Combina estas lecciones con nuestro [plan de estudios 'Ciencia de datos para principiantes'](https://aka.ms/ds4beginners) también!
-Viaja con nosotros alrededor del mundo mientras aplicamos estas técnicas clásicas a datos de muchas áreas del mundo. Cada lección incluye pruebas antes y después de la lección, 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 manera comprobada para que nuevas habilidades se fijen.
+Viaja con nosotros alrededor del mundo mientras aplicamos estas técnicas clásicas a datos de muchas regiones del mundo. 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.
**✍️ 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
-**🎨 Gracias también a nuestros ilustradores** Tomomi Imura, Dasani Madipalli y Jen Looper
+**🎨 Gracias también a nuestras ilustradoras** Tomomi Imura, Dasani Madipalli y Jen Looper
-**🙏 Agradecimientos especiales 🙏 a nuestros autores, revisores y contribuidores de contenido Embajadores Estudiantiles de Microsoft**, en especial a 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 Estudiantes Embajadores de Microsoft**, notablemente Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila y Snigdha Agarwal
-**🤩 Agradecimiento extra a los Embajadores Estudiantiles de Microsoft Eric Wanjau, Jasleen Sondhi y Vidushi Gupta por nuestras lecciones de R!**
+**🤩 Gratitud extra a los Estudiantes Embajadores de Microsoft Eric Wanjau, Jasleen Sondhi y Vidushi Gupta por nuestras lecciones en R!**
# Comenzando
Sigue estos pasos:
-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`
+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)
+> [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 soluciones a problemas comunes con la 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, haz un fork de todo el repositorio a tu propia cuenta de GitHub y completa los ejercicios por tu cuenta o en grupo:
-- Comienza con un quiz previo a la lección.
-- Lee la lección y completa las actividades, deteniéndote y reflexionando en cada chequeo de conocimiento.
-- Intenta crear los proyectos comprendiendo las lecciones más que ejecutando el código de la solución; sin embargo, ese código está disponible en las carpetas `/solution` en cada lección orientada a proyectos.
-- Realiza el quiz después de la lección.
+**[Estudiantes](https://aka.ms/student-page)**, para usar este plan de estudios, haz fork del repositorio completo a tu propia cuenta de GitHub y completa los ejercicios por tu cuenta o en grupo:
+
+- Comienza con un cuestionario previo a la lección.
+- Lee la lección y completa las actividades, pausando y reflexionando en cada chequeo de conocimiento.
+- Intenta crear los proyectos comprendiendo las lecciones en lugar de solo ejecutar el código solución; ten en cuenta que el código está disponible en las carpetas `/solution` en cada lección orientada a proyecto.
+- 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 es una rúbrica que llenas para avanzar en tu aprendizaje. También puedes reaccionar a otras PAT para que aprendamos juntos.
+- Después de completar un grupo de lecciones, visita el [Tablero de discusiones](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 del progreso que completas para avanzar en tu aprendizaje. También puedes reaccionar a otras PAT para aprender juntos.
> 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).
-**Profesores**, hemos [incluido algunas sugerencias](for-teachers.md) sobre cómo usar este currículo.
+**Profesores**, hemos [incluido algunas sugerencias](for-teachers.md) sobre cómo usar este plan de estudios.
---
## Videos explicativos
-Algunas lecciones están disponibles como videos de formato corto. Puedes encontrarlos en línea dentro de las lecciones, o en la [lista de reproducción ML para principiantes en el canal de Microsoft Developer en YouTube](https://aka.ms/ml-beginners-videos) haciendo clic en la imagen a continuación.
+Algunas lecciones están disponibles en formato de video corto. Puedes encontrarlos en línea en las lecciones o en la [lista de reproducción ML for Beginners en el canal Microsoft Developer de YouTube](https://aka.ms/ml-beginners-videos) haciendo clic en la imagen a continuación.
-[](https://aka.ms/ml-beginners-videos)
+[](https://aka.ms/ml-beginners-videos)
---
@@ -100,79 +101,79 @@ Algunas lecciones están disponibles como videos de formato corto. Puedes encont
**Gif por** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
-> 🎥 ¡Haz clic en la imagen de arriba para ver un video sobre el proyecto y las personas que lo crearon!
+> 🎥 Haz clic en la imagen superior para ver un video sobre el proyecto y las personas que lo crearon!
---
## Pedagogía
-Hemos elegido dos principios pedagógicos al construir este currículo: asegurar que sea **basado en proyectos** y que incluya **quizzes frecuentes**. Además, este currículo tiene un **tema** común para darle cohesión.
+Hemos elegido dos principios pedagógicos para construir este plan de estudios: garantizar que sea práctico **basado en proyectos** y que incluya **cuestionarios frecuentes**. Además, este plan tiene un **tema** común para darle cohesión.
-Al asegurar que el contenido esté alineado con proyectos, el proceso se vuelve más atractivo para los estudiantes y la retención de conceptos se incrementa. Además, un quiz de bajo riesgo antes de una clase fija la intención del estudiante hacia el aprendizaje de un tema, mientras que un segundo quiz posterior asegura mayor retención. Este currículo fue diseñado para ser flexible y divertido y puede ser tomado en su totalidad o en parte. Los proyectos comienzan pequeños y se vuelven cada vez más complejos al final del ciclo de 12 semanas. Este currículo también incluye un postscriptum sobre aplicaciones reales del aprendizaje automático, que puede usarse como crédito extra o como base para discusión.
+Al asegurar que el contenido esté alineado con proyectos, el proceso se vuelve más atractivo para los estudiantes y la retención de conceptos aumentará. Además, un cuestionario de bajo riesgo antes de clase establece la intención del estudiante hacia el aprendizaje de un tema, mientras que un segundo cuestionario posterior asegura mayor retención. Este plan fue diseñado para ser flexible y divertido y puede ser tomado en su totalidad o en partes. Los proyectos comienzan pequeños y se vuelven cada vez más complejos hacia el final del ciclo de 12 semanas. También incluye un posfacio sobre aplicaciones reales de ML, que puede usarse como crédito adicional o como base para discusión.
-> Encuentra nuestro [Código de Conducta](CODE_OF_CONDUCT.md), [Contribuir](CONTRIBUTING.md), [Traducciones](..), y [Solución de Problemas](TROUBLESHOOTING.md). ¡Agradecemos tus comentarios constructivos!
+> Encuentra nuestro [Código de conducta](CODE_OF_CONDUCT.md), [Contribuciones](CONTRIBUTING.md), [Traducciones](..) y [Solución de problemas](TROUBLESHOOTING.md). ¡Esperamos tus comentarios constructivos!
## Cada lección incluye
-- esquemático opcional
-- video complementario opcional
+- sketchnote opcional
+- video suplementario opcional
- video explicativo (solo algunas lecciones)
-- [quiz de calentamiento previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
+- [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
- chequeos de conocimiento
-- un reto
+- un desafío
- lectura suplementaria
- tarea
-- [quiz posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
-> **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, ve a la carpeta `/solution` y busca las lecciones en R. Incluyen una extensión .rmd que representa un archivo de **R Markdown**, que puede definirse simplemente como una incorporación de `fragmentos de código` (de R u otros lenguajes) y un `encabezado YAML` (que guía cómo formatear la salida como PDF) en un `documento Markdown`. Como tal, sirve como un marco ejemplar para la creación de contenidos en ciencia de datos, ya que permite combinar tu código, su salida y tus pensamientos permitiéndote escribirlos en Markdown. Además, los documentos R Markdown pueden ser renderizados a formatos de salida como PDF, HTML o Word.
-
-> **Una nota sobre los cuestionarios**: Todos los cuestionarios se encuentran en la [carpeta Quiz App](../../quiz-app), con un total de 52 cuestionarios de tres preguntas cada uno. Están vinculados dentro de las lecciones, pero la aplicación de cuestionarios se puede ejecutar localmente; sigue las instrucciones en la carpeta `quiz-app` para alojarla localmente o desplegarla en Azure.
-
-| Número de Lección | Tema | Agrupación de la Lección | Objetivos de Aprendizaje | Lección vinculada | Autor |
-| :---------------: | :-------------------------------------------------: | :----------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------: |
-| 01 | Introducción al aprendizaje automático | [Introducción](1-Introduction/README.md) | Aprende 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) | Aprende la historia que sustenta 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 los importantes temas filosóficos sobre la equidad que los estudiantes deben considerar al crear y aplicar modelos de 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 construir 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) | Comienza 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) | Visualiza y limpia 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) | Construye 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) | Construye 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) | Construye 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) | Limpia, prepara y visualiza 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 | Cocina deliciosa asiática e india 🍜 | [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 | Cocina deliciosa asiática e india 🍜 | [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 | Cocina deliciosa asiática e india 🍜 | [Clasificación](4-Classification/README.md) | Construye una aplicación web recomendadora usando tu modelo | [Python](4-Classification/4-Applied/README.md) | Jen |
-| 14 | Introducción al clustering | [Clustering](5-Clustering/README.md) | Limpia, prepara y visualiza 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) | Explora el método K-Means para clustering | [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) | Aprende lo básico sobre 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) | Profundiza tus conocimientos de 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 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 | ⚡️ Uso mundial de energía ⚡️ - predicción de series temporales con ARIMA | [Series temporales](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 | [Series temporales](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 | [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 de ML en el mundo real | [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 con el panel de RAI | [ML en el mundo real](9-Real-World/README.md) | Depuración de modelos en machine learning usando componentes del panel Responsible AI | [Lección](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)
+- [cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
+> **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 **R Markdown** que puede definirse simplemente como la incrustación de `fragmentos de código` (de R u otros lenguajes) y un `encabezado YAML` (que guía cómo formatear las salidas como PDF) en un `documento Markdown`. Como tal, sirve como un marco ejemplar de escritura para ciencia de datos ya que le permite combinar su código, su salida y sus pensamientos permitiéndole escribirlos en Markdown. Además, los documentos R Markdown pueden renderizarse a formatos de salida 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 vinculados desde dentro de las lecciones, pero la app de cuestionarios se puede ejecutar localmente; siga las instrucciones en la carpeta `quiz-app` para alojar o desplegar localmente en Azure.
+
+| Número de lección | Tema | Agrupación de lecciones | Objetivos de aprendizaje | Lección vinculada | 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 subyacente de este campo | [Lección](1-Introduction/2-history-of-ML/README.md) | Jen y Amy |
+| 03 | Justicia y aprendizaje automático | [Introducción](1-Introduction/README.md) | ¿Cuáles son las importantes cuestiones filosóficas sobre la justicia que los estudiantes deben considerar al construir y aplicar modelos de 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 construir 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 de América del Norte 🎃 | [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 de América del Norte 🎃 | [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 de América del Norte 🎃 | [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) | Construir una aplicación web para usar su 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 sus 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 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) | Construir una aplicación web recomendadora usando su modelo | [Python](4-Classification/4-Applied/README.md) | Jen |
+| 14 | Introducción a la agrupación | [Agrupación](5-Clustering/README.md) | Limpiar, preparar y visualizar sus datos; introducción a la agrupación | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
+| 15 | Explorando gustos musicales en Nigeria 🎧 | [Agrupación](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 conceptos básicos sobre PLN construyendo un bot simple | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
+| 17 | Tareas comunes en PLN ☕️ | [Procesamiento de lenguaje natural](6-NLP/README.md) | Profundizar en su conocimiento de PLN entendiendo las tareas comunes requeridas al tratar con estructuras del lenguaje | [Python](6-NLP/2-Tasks/README.md) | Stephen |
+| 18 | Traducción y análisis de sentimientos ♥️ | [Procesamiento de lenguaje natural](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 en Europa ♥️ | [Procesamiento de lenguaje natural](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 en Europa ♥️ | [Procesamiento de lenguaje natural](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 de tiempo | [Series de tiempo](7-TimeSeries/README.md) | Introducción a la predicción de series de tiempo | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
+| 22 | ⚡️ Uso mundial de energía ⚡️ - predicción de series de tiempo con ARIMA | [Series de tiempo](7-TimeSeries/README.md) | Predicción de series de tiempo con ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
+| 23 | ⚡️ Uso mundial de energía ⚡️ - predicción de series de tiempo con SVR | [Series de tiempo](7-TimeSeries/README.md) | Predicción de series de tiempo con regresor 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 Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
+| Posdata | Escenarios y aplicaciones reales de ML | [ML en la naturaleza](9-Real-World/README.md) | Aplicaciones interesantes y reveladoras del aprendizaje automático clásico | [Lección](9-Real-World/1-Applications/README.md) | Equipo |
+| Posdata | Depuración de modelos de ML usando el panel RAI | [ML en la naturaleza](9-Real-World/README.md) | Depuración de modelos en aprendizaje automático usando componentes del panel Responsible AI | [Lección](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
+
+> [encuentre 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)
## 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 repo, escribe `docsify serve`. El sitio web se servirá en el puerto 3000 de tu localhost: `localhost:3000`.
+Puede ejecutar esta documentación sin conexión usando [Docsify](https://docsify.js.org/#/). Haga un fork de este repositorio, [instale Docsify](https://docsify.js.org/#/quickstart) en su máquina local, y luego en la carpeta raíz de este repositorio, escriba `docsify serve`. El sitio web será servido en el puerto 3000 en su localhost: `localhost:3000`.
## PDFs
-Encuentra un pdf del plan de estudios con enlaces [aquí](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
+Encuentre un pdf del plan de estudios con enlaces [aquí](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
-## 🎒 Otros Cursos
+## 🎒 Otros cursos
-¡Nuestro equipo produce otros cursos! Echa un vistazo:
+¡Nuestro equipo produce otros cursos! Eche un vistazo:
### LangChain
@@ -184,54 +185,65 @@ Encuentra un pdf del plan de estudios con enlaces [aquí](https://microsoft.gith
### 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)
---
### Serie de IA Generativa
-[](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
-[-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
-[-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
-[-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
+[](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
+[-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
+[-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
+[-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
---
### Aprendizaje Básico
-[](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)
-[](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
-[](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
-[](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
-[](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
+[](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)
+[](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
+[](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
+[](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
+[](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### Serie Copilot
-[](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)
-[](https://github.com/microsoft/CopilotAdventures?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)
+[](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst)
## Obtener ayuda
-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.
+Si te quedas atascado o tienes preguntas mientras aprendes Machine Learning o construyes aplicaciones de IA, no te preocupes — hay ayuda disponible.
-[](https://discord.gg/nTYy5BXMWG)
+Puedes unirte a discusiones con otros aprendices y desarrolladores, hacer preguntas y compartir tus ideas con la comunidad.
+
+- Únete a la comunidad para hacer preguntas y aprender con otros
+- Discute conceptos de Machine Learning e ideas de proyectos
+- Obtén orientación de desarrolladores experimentados
+
+Una comunidad solidaria es una excelente manera de mejorar tus habilidades y resolver problemas más rápido.
-Si tienes sugerencias sobre el producto o errores mientras creas, visita:
+[Microsoft Foundry Discord Community](https://discord.gg/nTYy5BXMWG)
+
+Si encuentras errores, fallos, o tienes sugerencias para mejoras, también puedes abrir un **Issue** en este repositorio para informar del problema.
+
+Para enviar comentarios sobre el producto o buscar publicaciones existentes en la comunidad, visita el Foro de Desarrolladores:
[](https://aka.ms/foundry/forum)
-## Consejos adicionales de aprendizaje
+
+## Consejos adicionales para el aprendizaje
- Revisa los notebooks después de cada lección para una mejor comprensión.
- Practica implementando algoritmos por tu cuenta.
-- Explora conjuntos de datos del mundo real utilizando los conceptos aprendidos.
+- Explora conjuntos de datos del mundo real usando los conceptos aprendidos.
---
-**Aviso Legal**:
-Este documento ha sido traducido utilizando el servicio de traducción AI [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 humana. No nos responsabilizamos por malentendidos o interpretaciones erróneas derivadas del uso de esta traducción.
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción AI [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 una traducción profesional realizada por humanos. No nos hacemos responsables de ningún malentendido o interpretación errónea que surja del uso de esta traducción.
\ No newline at end of file
diff --git a/translations/fr/.co-op-translator.json b/translations/fr/.co-op-translator.json
index 8efeb60ab..441aa76fc 100644
--- a/translations/fr/.co-op-translator.json
+++ b/translations/fr/.co-op-translator.json
@@ -90,8 +90,8 @@
"language_code": "fr"
},
"2-Regression/3-Linear/README.md": {
- "original_hash": "9a8359f1945bd3beccccb2b46592580e",
- "translation_date": "2026-02-28T08:18:18+00:00",
+ "original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
+ "translation_date": "2026-04-20T15:42:23+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "fr"
},
@@ -168,8 +168,8 @@
"language_code": "fr"
},
"4-Classification/2-Classifiers-1/README.md": {
- "original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
- "translation_date": "2025-09-04T23:02:16+00:00",
+ "original_hash": "cb761595e5b6c42b99bb81bd13683311",
+ "translation_date": "2026-04-20T15:43:33+00:00",
"source_file": "4-Classification/2-Classifiers-1/README.md",
"language_code": "fr"
},
@@ -552,8 +552,8 @@
"language_code": "fr"
},
"README.md": {
- "original_hash": "7fb48097f57e680b380cd9aae988d317",
- "translation_date": "2026-04-06T15:44:09+00:00",
+ "original_hash": "3e3a6c7e68e0afe7e2276ac046e4d7a0",
+ "translation_date": "2026-04-20T15:40:36+00:00",
"source_file": "README.md",
"language_code": "fr"
},
diff --git a/translations/fr/2-Regression/3-Linear/README.md b/translations/fr/2-Regression/3-Linear/README.md
index 059ba4ecc..52b33162b 100644
--- a/translations/fr/2-Regression/3-Linear/README.md
+++ b/translations/fr/2-Regression/3-Linear/README.md
@@ -1,136 +1,136 @@
-# Construire un modèle de régression avec Scikit-learn : quatre manières de faire la régression
+# Construire un modèle de régression avec Scikit-learn : régression de quatre manières
## 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.
+Elle fonctionne en trouvant une 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 pré-conférence](https://ff-quizzes.netlify.app/en/ml/)
+## [Quiz pré-lecture](https://ff-quizzes.netlify.app/en/ml/)
> ### [Cette leçon est disponible en R !](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
-### Introduction
+### 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 aussi visualisée avec Matplotlib.
+Jusqu'à présent, vous avez exploré ce qu'est la régression avec des données d'exemple issues du dataset de prix de citrouilles que nous utiliserons tout au long de cette leçon. Vous l'avez également visualisé avec Matplotlib.
-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.
+Vous êtes maintenant prêt à approfondir la régression en Machine Learning. Alors que la visualisation permet de donner du sens aux données, la véritable puissance du Machine Learning provient de _l'entraînement des modèles_. Les modèles sont entraînés sur des données historiques afin de capturer automatiquement les dépendances dans les 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.
-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.
+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 quelques 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.
-[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
+[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
-> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo sur la régression linéaire.
+> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo introductive sur la régression linéaire.
-> 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.
+> Tout au long de ce parcours, nous partons du principe d’une connaissance mathématique minimale, et cherchons à la rendre accessible aux étudiants venant d’autres domaines, donc surveillez les 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 dataframe. Assurez-vous de pouvoir exécuter ces notebooks dans les kernels de Visual Studio Code.
+Vous devriez maintenant connaître la structure des données des citrouilles que nous examinons. Vous les trouverez 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 des kernels de Visual Studio Code.
### Préparation
-Pour rappel, vous chargez ces données afin de pouvoir poser des questions à leur sujet.
+Pour rappel, vous chargez ces données afin de pouvoir leur poser des questions.
-- 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.
+- Quel est le meilleur moment pour acheter des citrouilles ?
+- Quel prix puis-je attendre pour une caisse de mini citrouilles ?
+- Dois-je les acheter en paniers de demi-boisseau ou par cartons de 1 1/9 boisseau ?
+Continuons à creuser ces données.
-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.
+Dans la leçon précédente, vous avez créé un DataFrame Pandas et l'avez rempli avec une partie du dataset original, en standardisant les prix par boisseau. Ce faisant, vous avez cependant rassemblé environ 400 points de données uniquement pour les mois d'automne.
-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.
+Jetez un coup d'œ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 une première représentation en nuage de points est affichée pour montrer les données par mois. Peut-être pouvons-nous obtenir plus de détails sur la nature des données en les nettoyant davantage.
-## Une ligne de régression linéaire
+## Une droite de régression linéaire
-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 :
+Comme vous l'avez appris dans la Leçon 1, le but d'un exercice de régression linéaire est de pouvoir tracer une droite 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.
+- **Faire des prédictions**. Faire des prédictions précises sur la position d’un nouveau point de données par rapport à cette droite.
-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.
+Il est typique que la **Régression des moindres carrés** dessine ce type de droite. 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 droite de régression.
-Nous élevons au carré ces distances pour deux raisons principales :
+Nous mettons au carré ces distances pour deux raisons principales :
-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.
+1. **Magnitude plutôt que direction :** Nous voulons traiter une erreur de -5 de la même manière qu’une erreur de +5. La mise au carré rend toutes les valeurs positives.
-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.
+2. **Pénaliser les valeurs extrêmes :** Mettre au carré donne plus de poids aux erreurs importantes, ce qui force la droite à 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".
+Nous ajoutons ensuite toutes ces valeurs mises au carré. Notre objectif est de trouver la droite spécifique pour laquelle cette somme finale est la plus faible (plus petite valeur 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) :
->
+> **🧮 Montrez-moi les mathématiques**
+>
+> Cette droite, appelée _droite d'ajustement_, peut s'exprimer 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, soit la valeur de `Y` lorsque `X = 0`.
+> `X` est la « variable explicative ». `Y` est la « variable dépendante ». La pente de la droite est `b` et `a` est l'ordonnée à l'origine, qui correspond à la valeur de `Y` quand `X = 0`.
>
->
+>
>
-> Commencez par calculer la pente `b`. Infographie par [Jen Looper](https://twitter.com/jenlooper)
+> D'abord, calculez la pente `b`. Infographie par [Jen Looper](https://twitter.com/jenlooper)
>
-> 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.
+> En d’autres termes, et en se référant à la question originale de nos données sur les citrouilles : "prédire le prix d’une citrouille par boisseau selon le mois", `X` se réfèrerait 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)
+> Calculez la valeur de Y. Si vous payez environ 4 $, cela doit être avril ! Infographie par [Jen Looper](https://twitter.com/jenlooper)
>
-> 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`.
+> Les mathématiques qui calculent la droite doivent montrer la pente de la droite, qui dépend aussi de l’ordonnée à l'origine, ou 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). 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.
+> 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 également [ce calculateur de moindres carrés](https://www.mathsisfun.com/data/least-squares-calculator.html) pour voir comment les valeurs numériques influencent la droite.
## 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 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 les points de données alignés de façon nette possède une corrélation élevée, mais 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 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.
+Un bon modèle de régression linéaire est celui qui a un coefficient de corrélation élevé (plus proche de 1 que de 0) utilisant la méthode des moindres carrés avec une droite de régression.
-✅ 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) ?
+✅ Exécutez le notebook accompagnant cette leçon et regardez le nuage de points du mois par rapport au prix. Les données associant le mois au prix pour les ventes de citrouilles semblent-elles avoir une corrélation élevée ou faible selon votre interprétation visuelle du nuage de points ? Cela change-t-il si vous utilisez une mesure plus fine au lieu de `Month`, par ex. *le jour de l’année* (c’est-à-dire le nombre de jours écoulés 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 dataframe appelé `new_pumpkins`, similaire au tableau suivant :
+Dans le code ci-dessous, nous supposons que nous avons nettoyé les données et obtenu un DataFrame appelé `new_pumpkins`, similaire à ce qui suit :
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|-------
-70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 boisseau cartons | 15.0 | 15.0 | 13.636364
-71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 boisseau cartons | 18.0 | 18.0 | 16.363636
-72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 boisseau cartons | 18.0 | 18.0 | 16.363636
-73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 boisseau cartons | 17.0 | 17.0 | 15.454545
-74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 boisseau cartons | 15.0 | 15.0 | 13.636364
+70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
+71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
+72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
+73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
+74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
-> 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 :
+> 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` en utilisant l'expression suivante :
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
-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.
+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 à l'occasion des fêtes voudrait peut-être cette information pour optimiser ses achats.
-## Recherche de Corrélation
+## Recherche de corrélation
-[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
+[](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.
+> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo introductive sur la corrélation.
D’après la leçon précédente, vous avez probablement vu que le prix moyen pour différents mois ressemble à ceci :
-
+
-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 :
+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 nuage de points qui montre cette dernière relation :
-
+
-Voyons s’il y a une corrélation en utilisant la fonction `corr` :
+Voyons s’il existe une corrélation en utilisant la fonction `corr` :
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
-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 :
+Il semble que la corrélation soit plutôt faible, -0.15 pour `Month` et -0.17 pour `DayOfMonth`, mais il pourrait y avoir une autre relation importante. Il semble y avoir 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 avec une couleur différente. En passant un paramètre `ax` à la fonction de tracé `scatter`, nous pouvons représenter tous les points sur le même graphique :
```python
ax=None
@@ -140,42 +140,42 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
-
+
-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 :
+Notre investigation suggère que la variété a plus d’effet sur le prix global que la date réelle de vente. Nous pouvons le voir avec un graphique en barres :
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
-
+
-Concentrons-nous pour le moment sur une seule variété de citrouille, le « type tarte » (pie type), et voyons quel effet la date a sur le prix :
+Concentrons-nous pour l’instant sur une seule variété de citrouille, le type « pie », et voyons l’effet de la date sur le prix :
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
-
+
-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.
+Si nous calculons maintenant la corrélation entre `Price` et `DayOfYear` avec la fonction `corr`, nous obtiendrons environ `-0.27` — ce qui signifie que l’entraînement d’un modèle prédictif est pertinent.
-> 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 :
+> 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 de supprimer toutes les cellules vides :
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
-Une autre approche consisterait à remplir ces valeurs vides avec la moyenne de la colonne correspondante.
+Une autre approche serait de remplir ces valeurs vides avec la moyenne des valeurs de la colonne correspondante.
-## Régression Linéaire Simple
+## Régression linéaire simple
-[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using 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 d'introduction à la régression linéaire et polynomiale.
+> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo introductive sur la régression linéaire et polynomiale.
-Pour entraîner notre modèle de régression linéaire, nous allons utiliser la bibliothèque **Scikit-learn**.
+Pour entraîner notre modèle de régression linéaire, nous utiliserons la bibliothèque **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
@@ -190,42 +190,41 @@ 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 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.
+> 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, comme nous avons une seule entrée, nous avons besoin d’un tableau de forme N×1, où N est la taille du dataset.
-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 :
+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 :
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
-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` :
+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`, et l'appliquons à nos données avec la méthode `fit` :
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
-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.
+L'objet `LinearRegression` après avoir été ajusté (`fit`) contient tous les coefficients de la régression, 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 trop, d'environ 2 centimes par jour. Nous pouvons également accéder au point d'intersection de la régression avec l'axe des ordonnées en utilisant `lin_reg.intercept_` - il sera autour de `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 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.
+Pour voir la précision de notre modèle, nous pouvons prédire les prix sur un ensemble de test, puis mesurer la proximité de nos prédictions avec les valeurs attendues. Cela peut être fait en utilisant la métrique de l'erreur quadratique moyenne (RMSE), qui est la racine de 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)
-mse = np.sqrt(mean_squared_error(y_test,pred))
-print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+rmse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
```
-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 :
+Notre erreur semble être autour de 2 points, ce qui est 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 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 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 faible.
-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 :
+Nous pouvons aussi tracer les données de test avec la droite de régression pour mieux voir comment la régression fonctionne dans notre cas :
```python
plt.scatter(X_test,y_test)
@@ -234,19 +233,19 @@ plt.plot(X_test,pred)
-## Régression Polynômiale
+## Régression Polynomiale
-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.
+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 la citrouille est volumineuse, plus son prix est élevé - parfois ces relations ne peuvent pas être représentées par un plan ou une droite.
-✅ 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.
+✅ Voici [quelques autres exemples](https://online.stat.psu.edu/stat501/lesson/9/9.8) de données pouvant utiliser 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.
+Regardez à nouveau la relation entre Date et Prix. Ce nuage de points semble-t-il nécessairement devoir être analysé par une 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 contenir une ou plusieurs variables et coefficients.
+✅ Les polynômes sont des expressions mathématiques qui peuvent comporter une ou plusieurs variables et coefficients.
-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.
+La régression polynomiale crée une courbe pour mieux ajuster des données non linéaires. Dans notre cas, si nous ajoutons 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 point 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 d’abord ajoute des caractéristiques polynomiales à notre modèle, puis entraîne la régression :
+Scikit-learn inclut une API pratique de [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) pour combiner différentes étapes du 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 :
```python
from sklearn.preprocessing import PolynomialFeatures
@@ -257,36 +256,36 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
-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`2, mais avec deux variables d’entrée X et Y, cela ajouterait X2, XY et Y2. On peut aussi utiliser des polynômes de degré supérieur si on le souhaite.
+Utiliser `PolynomialFeatures(2)` signifie que nous inclurons tous les polynômes de degré 2 issus des données d'entrée. Dans notre cas cela veut dire simplement `DayOfYear`2, mais pour deux variables d'entrée X et Y, cela ajouterait X2, XY et Y2. On peut aussi utiliser des polynômes de degré plus élevé si on le souhaite.
-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 :
+Les pipelines peuvent être utilisés de la même manière que l'objet `LinearRegression` d'origine, c'est-à-dire que nous pouvons `fit` le pipeline, 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, 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 !
+Avec la régression polynomiale, nous pouvons obtenir un MSE légèrement plus faible et une détermination plus élevée, mais pas de manière significative. Nous devons prendre en compte d'autres caractéristiques !
-> Vous voyez que les prix minimaux des citrouilles sont observés quelque part autour d’Halloween. Comment pouvez-vous l’expliquer ?
+> Vous pouvez voir que les prix minimaux des citrouilles sont observés vers Halloween. Comment expliquer cela ?
-🎃 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 !
+🎃 Félicitations, vous venez de créer un modèle qui peut aider à prédire le prix des citrouilles pour tarte. 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 !
-## Caractéristiques Catégorielles
+## Caractéristiques Catégoriques
-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**.
+Dans un monde idéal, nous souhaitons pouvoir prédire les prix pour différentes variétés de citrouilles avec le même modèle. Cependant, la colonne `Variety` est un peu différente des colonnes comme `Month`, car elle contient des valeurs non numériques. Ces colonnes s'appellent **catégoriques**.
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
-> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo présentant 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égoriques.
-Ici vous pouvez voir comment le prix moyen dépend de la variété :
+Ici, vous pouvez voir comment le prix moyen dépend de la variété :
-Pour prendre la variété en compte, il faut d’abord la convertir en forme numérique, ou **l’encoder**. Plusieurs méthodes existent :
+Pour prendre la variété en compte, il faut d'abord la convertir en forme numérique, c'est-à-dire **l'encoder**. Plusieurs méthodes existent :
-* 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.
+* Un simple **encodage numérique** va construire un tableau des différentes variétés, puis remplacer le nom de la variété par un indice dans ce tableau. 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 cet indice et l’ajoute au résultat, multipliée par un coefficient. Or 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 certaine manière.
+* **L'encodage one-hot** remplace la colonne `Variety` par 4 colonnes différentes, une pour chaque variété. Chaque colonne contient `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, correspondant au « prix de départ » (ou plutôt « prix supplémentaire ») pour cette variété particulière.
-Le code ci-dessous montre comment faire un encodage one-hot d’une variété :
+Le code ci-dessous montre comment appliquer un encodage one-hot à une variété :
```python
pd.get_dummies(new_pumpkins['Variety'])
@@ -303,14 +302,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
-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` :
+Pour entraîner une régression linéaire en utilisant la variété encodée 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é 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` :
+Le reste du code est identique à ce 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 que le coefficient de détermination est beaucoup plus élevé (~77 %). Pour obtenir des prédictions encore plus précises, on peut prendre en compte plus de caractéristiques catégoriques ainsi que des caractéristiques numériques, telles que `Month` ou `DayOfYear`. Pour obtenir un grand tableau de caractéristiques, on peut utiliser la fonction `join` :
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@@ -320,21 +319,21 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
-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 !
+Ici, nous prenons aussi en compte `City` et le type de `Package`, ce qui nous donne un MSE de 2.84 (10 %) et une détermination de 0.94 !
-## Mettre tout ensemble
+## Tout mettre ensemble
-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é :
+Pour créer le meilleur modèle, nous pouvons utiliser les données combinées (catégoriques encodées en one-hot + numériques) de l'exemple précédent, avec la régression polynomiale. Voici le code complet pour votre commodité :
```python
-# configurer les données d'entraînement
+# préparer 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']
-# faire la séparation train-test
+# effectuer 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)
# configurer et entraîner le pipeline
@@ -352,28 +351,28 @@ score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
-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).
+Cela devrait nous donner le meilleur coefficient de détermination à presque 97 %, et un 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` 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 |
+|-------|-----|---------------|
+| Linéaire `DayOfYear` | 2.77 (17,2 %) | 0.07 |
+| Polynomial `DayOfYear` | 2.73 (17,0 %) | 0.08 |
+| Linéaire `Variety` | 5.24 (19,7 %) | 0.77 |
+| Toutes caractéristiques Linéaire | 2.84 (10,5 %) | 0.94 |
+| Toutes caractéristiques Polynomial | 2.23 (8,25 %) | 0.97 |
-🏆 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.
+🏆 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 carnet pour voir comment la corrélation correspond à la précision du modèle.
+Testez plusieurs variables différentes dans ce notebook pour voir comment la corrélation correspond à la précision du modèle.
## [Quiz post-cours](https://ff-quizzes.netlify.app/en/ml/)
-## Révision & Auto-apprentissage
+## Revue & Auto-Étude
-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)
+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
@@ -382,6 +381,6 @@ Dans cette leçon, nous avons appris la régression linéaire. Il existe d’aut
---
-**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.
+**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 cruciales, une traduction professionnelle humaine est recommandée. Nous ne pouvons être tenus responsables des malentendus ou erreurs d'interprétation résultant de l'utilisation de cette traduction.
\ No newline at end of file
diff --git a/translations/fr/4-Classification/2-Classifiers-1/README.md b/translations/fr/4-Classification/2-Classifiers-1/README.md
index 6ca323d94..97b24e5c7 100644
--- a/translations/fr/4-Classification/2-Classifiers-1/README.md
+++ b/translations/fr/4-Classification/2-Classifiers-1/README.md
@@ -1,13 +1,13 @@
# Classificateurs de cuisine 1
-Dans cette leçon, vous utiliserez le jeu de données que vous avez sauvegardé lors de la dernière leçon, rempli de données équilibrées et nettoyées sur les cuisines.
+Dans cette leçon, vous allez utiliser l'ensemble de données que vous avez sauvegardé lors de la dernière leçon, rempli de données équilibrées et propres sur les cuisines.
-Vous utiliserez ce jeu de données avec une variété de classificateurs pour _prédire une cuisine nationale donnée en fonction d'un groupe d'ingrédients_. En le faisant, vous en apprendrez davantage sur certaines des façons dont les algorithmes peuvent être utilisés pour des tâches de classification.
+Vous utiliserez cet ensemble de données avec une variété de classificateurs pour _prédire une cuisine nationale donnée à partir d'un groupe d'ingrédients_. En le faisant, vous en apprendrez davantage sur certaines des façons dont les algorithmes peuvent être exploités pour des tâches de classification.
-## [Quiz avant la leçon](https://ff-quizzes.netlify.app/en/ml/)
+## [Quiz pré-conférence](https://ff-quizzes.netlify.app/en/ml/)
# Préparation
-En supposant que vous avez terminé [Leçon 1](../1-Introduction/README.md), assurez-vous qu'un fichier _cleaned_cuisines.csv_ existe dans le dossier racine `/data` pour ces quatre leçons.
+En supposant que vous avez terminé la [Leçon 1](../1-Introduction/README.md), assurez-vous qu'un fichier _cleaned_cuisines.csv_ existe dans le dossier racine `/data` pour ces quatre leçons.
## Exercice - prédire une cuisine nationale
@@ -30,7 +30,7 @@ En supposant que vous avez terminé [Leçon 1](../1-Introduction/README.md), ass
| 4 | 4 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
-1. Ensuite, importez plusieurs autres bibliothèques :
+1. Maintenant, importez plusieurs autres bibliothèques :
```python
from sklearn.linear_model import LogisticRegression
@@ -40,7 +40,7 @@ En supposant que vous avez terminé [Leçon 1](../1-Introduction/README.md), ass
import numpy as np
```
-1. Divisez les coordonnées X et y en deux dataframes pour l'entraînement. `cuisine` peut être le dataframe des étiquettes :
+1. Divisez les coordonnées X et y en deux dataframes pour l'entraînement. `cuisine` peut être le dataframe des labels :
```python
cuisines_label_df = cuisines_df['cuisine']
@@ -58,7 +58,7 @@ En supposant que vous avez terminé [Leçon 1](../1-Introduction/README.md), ass
Name: cuisine, dtype: object
```
-1. Supprimez la colonne `Unnamed: 0` et la colonne `cuisine` en appelant `drop()`. Sauvegardez le reste des données comme caractéristiques entraînables :
+1. Supprimez la colonne `Unnamed: 0` et la colonne `cuisine` en utilisant `drop()`. Enregistrez le reste des données comme des caractéristiques entraînables :
```python
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
@@ -79,9 +79,9 @@ Vous êtes maintenant prêt à entraîner votre modèle !
## Choisir votre classificateur
-Maintenant que vos données sont nettoyées et prêtes pour l'entraînement, vous devez décider quel algorithme utiliser pour la tâche.
+Maintenant que vos données sont propres et prêtes à être entraînées, vous devez décider quel algorithme utiliser pour le travail.
-Scikit-learn regroupe la classification sous l'apprentissage supervisé, et dans cette catégorie, vous trouverez de nombreuses façons de classifier. [La variété](https://scikit-learn.org/stable/supervised_learning.html) peut sembler déroutante au premier abord. Les méthodes suivantes incluent toutes des techniques de classification :
+Scikit-learn regroupe la classification sous l'apprentissage supervisé, et dans cette catégorie vous trouverez plusieurs façons de classifier. [La variété](https://scikit-learn.org/stable/supervised_learning.html) est assez déroutante au premier abord. Les méthodes suivantes incluent toutes des techniques de classification :
- Modèles linéaires
- Machines à vecteurs de support
@@ -89,60 +89,60 @@ Scikit-learn regroupe la classification sous l'apprentissage supervisé, et dans
- Plus proches voisins
- Processus gaussiens
- Arbres de décision
-- Méthodes d'ensemble (classificateur par vote)
-- Algorithmes multiclasses et multi-sorties (classification multiclasses et multi-étiquettes, classification multiclasses-multi-sorties)
+- Méthodes d'ensemble (voting Classifier)
+- Algorithmes multi-classes et multi-sorties (classification multi-classes et multi-label, classification multi-classes multi-sortie)
-> Vous pouvez également utiliser [les réseaux neuronaux pour classifier des données](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), mais cela dépasse le cadre de cette leçon.
+> Vous pouvez également utiliser [les réseaux neuronaux pour classifier des données](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), mais cela sort du cadre de cette leçon.
### Quel classificateur choisir ?
-Alors, quel classificateur devriez-vous choisir ? Souvent, tester plusieurs et chercher un bon résultat est une façon de procéder. Scikit-learn propose une [comparaison côte à côte](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) sur un jeu de données créé, comparant KNeighbors, SVC de deux manières, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB et QuadraticDiscriminationAnalysis, montrant les résultats visualisés :
+Alors, quel classificateur devriez-vous choisir ? Souvent, tester plusieurs et chercher un bon résultat est un moyen d'expérimenter. Scikit-learn propose une [comparaison côte à côte](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) sur un ensemble de données créé, comparant KNeighbors, SVC de deux façons, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB et QuadraticDiscrinationAnalysis, montrant les résultats visualisés :
-
-> Graphiques générés à partir de la documentation de Scikit-learn
+
+> Graphiques générés dans la documentation de Scikit-learn
-> AutoML résout ce problème de manière élégante en exécutant ces comparaisons dans le cloud, vous permettant de choisir le meilleur algorithme pour vos données. Essayez-le [ici](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
+> AutoML résout ce problème élégamment en exécutant ces comparaisons dans le cloud, vous permettant de choisir le meilleur algorithme pour vos données. Essayez-le [ici](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
### Une meilleure approche
-Une meilleure façon que de deviner au hasard est de suivre les idées de cette [fiche pratique ML téléchargeable](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Ici, nous découvrons que, pour notre problème multiclasses, nous avons quelques choix :
+Une meilleure façon que de deviner au hasard est de suivre les idées sur cette [fiche mémo ML](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott) téléchargeable. Ici, nous découvrons que, pour notre problème multiclasses, nous avons plusieurs choix :
-
-> Une section de la fiche pratique des algorithmes de Microsoft, détaillant les options de classification multiclasses
+
+> Une section de la Fiche Mémo algorithmes de Microsoft, détaillant les options de classification multiclasses
-✅ Téléchargez cette fiche pratique, imprimez-la et accrochez-la à votre mur !
+✅ Téléchargez cette fiche mémo, imprimez-la et accrochez-la sur votre mur !
### Raisonnement
-Voyons si nous pouvons raisonner sur les différentes approches données les contraintes que nous avons :
+Voyons si nous pouvons raisonner différentes approches compte tenu des contraintes que nous avons :
-- **Les réseaux neuronaux sont trop lourds**. Étant donné notre jeu de données propre mais minimal, et le fait que nous exécutons l'entraînement localement via des notebooks, les réseaux neuronaux sont trop lourds pour cette tâche.
-- **Pas de classificateur à deux classes**. Nous n'utilisons pas de classificateur à deux classes, ce qui exclut le one-vs-all.
-- **Un arbre de décision ou une régression logistique pourraient fonctionner**. Un arbre de décision pourrait fonctionner, ou une régression logistique pour des données multiclasses.
-- **Les arbres de décision boostés multiclasses résolvent un problème différent**. L'arbre de décision boosté multiclasses est le plus adapté aux tâches non paramétriques, par exemple les tâches conçues pour établir des classements, donc il n'est pas utile pour nous.
+- **Les réseaux neuronaux sont trop lourds**. Étant donné notre ensemble de données propre, mais minimal, et le fait que nous exécutons l'entraînement localement via des notebooks, les réseaux neuronaux sont trop lourds pour cette tâche.
+- **Pas de classificateur binaire**. Nous n'utilisons pas de classificateur binaire, ce qui exclut la méthode one-vs-all.
+- **Un arbre de décision ou la régression logistique pourraient fonctionner**. Un arbre de décision pourrait fonctionner, ou la régression logistique pour des données multiclasses.
+- **Les arbres de décision Boostés multiclasses résolvent un problème différent**. L'arbre de décision boosté multiclasses convient surtout aux tâches non paramétriques, par exemple celles destinées à construire des classements, donc il ne nous est pas utile.
-### Utiliser Scikit-learn
+### Utiliser Scikit-learn
-Nous utiliserons Scikit-learn pour analyser nos données. Cependant, il existe de nombreuses façons d'utiliser la régression logistique dans Scikit-learn. Consultez les [paramètres à passer](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
+Nous utiliserons Scikit-learn pour analyser nos données. Cependant, il existe plusieurs façons d'utiliser la régression logistique dans Scikit-learn. Jetez un œil aux [paramètres à passer](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
-Essentiellement, il y a deux paramètres importants - `multi_class` et `solver` - que nous devons spécifier lorsque nous demandons à Scikit-learn d'effectuer une régression logistique. La valeur de `multi_class` applique un certain comportement. La valeur du solver détermine quel algorithme utiliser. Tous les solveurs ne peuvent pas être associés à toutes les valeurs de `multi_class`.
+Essentiellement, il y a deux paramètres importants - `multi_class` et `solver` - que nous devons spécifier lorsque nous demandons à Scikit-learn d'effectuer une régression logistique. La valeur `multi_class` applique un certain comportement. La valeur du solver est l'algorithme à utiliser. Tous les solveurs ne peuvent pas être associés à toutes les valeurs `multi_class`.
Selon la documentation, dans le cas multiclasses, l'algorithme d'entraînement :
- **Utilise le schéma one-vs-rest (OvR)**, si l'option `multi_class` est définie sur `ovr`
-- **Utilise la perte d'entropie croisée**, si l'option `multi_class` est définie sur `multinomial`. (Actuellement, l'option `multinomial` est prise en charge uniquement par les solveurs ‘lbfgs’, ‘sag’, ‘saga’ et ‘newton-cg’.)
+- **Utilise la perte par entropie croisée**, si l'option `multi_class` est définie sur `multinomial`. (Actuellement, l'option `multinomial` est supportée uniquement par les solveurs ‘lbfgs’, ‘sag’, ‘saga’ et ‘newton-cg’)."
-> 🎓 Le 'schéma' ici peut être 'ovr' (one-vs-rest) ou 'multinomial'. Étant donné que la régression logistique est vraiment conçue pour prendre en charge la classification binaire, ces schémas lui permettent de mieux gérer les tâches de classification multiclasses. [source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
+> 🎓 Le 'schéma' ici peut être soit 'ovr' (one-vs-rest) soit 'multinomial'. Puisque la régression logistique est vraiment conçue pour prendre en charge la classification binaire, ces schémas lui permettent de mieux gérer les tâches de classification multiclasses. [source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 Le 'solver' est défini comme "l'algorithme à utiliser dans le problème d'optimisation". [source](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
-Scikit-learn propose ce tableau pour expliquer comment les solveurs gèrent les différents défis présentés par les différentes structures de données :
+Scikit-learn propose ce tableau pour expliquer comment les solveurs gèrent différents défis présentés par différents types de structures de données :
-
+
-## Exercice - diviser les données
+## Exercice - fractionner les données
-Nous pouvons nous concentrer sur la régression logistique pour notre premier essai d'entraînement, puisque vous avez récemment appris à ce sujet dans une leçon précédente.
+Nous pouvons nous concentrer sur la régression logistique pour notre premier essai d'entraînement puisque vous avez récemment appris le sujet dans une leçon précédente.
Divisez vos données en groupes d'entraînement et de test en appelant `train_test_split()` :
```python
@@ -151,9 +151,9 @@ X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisine
## Exercice - appliquer la régression logistique
-Étant donné que vous utilisez le cas multiclasses, vous devez choisir quel _schéma_ utiliser et quel _solver_ définir. Utilisez LogisticRegression avec un paramètre multiclasses et le solveur **liblinear** pour entraîner.
+Puisque vous utilisez le cas multiclasses, vous devez choisir quel _schéma_ utiliser et quel _solveur_ définir. Utilisez LogisticRegression avec une configuration multiclasses et le solveur **liblinear** pour entraîner.
-1. Créez une régression logistique avec `multi_class` défini sur `ovr` et le solveur défini sur `liblinear` :
+1. Créez une régression logistique avec multi_class défini sur `ovr` et le solveur défini sur `liblinear` :
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
@@ -164,10 +164,12 @@ X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisine
```
✅ Essayez un solveur différent comme `lbfgs`, qui est souvent défini par défaut
-> Remarque, utilisez la fonction Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) pour aplatir vos données lorsque nécessaire.
-L'exactitude est bonne à plus de **80 %** !
-1. Vous pouvez voir ce modèle en action en testant une ligne de données (#50) :
+ > Notez que vous utilisez la fonction Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) pour aplatir vos données lorsque c'est nécessaire.
+
+ La précision est bonne, à plus de **80 %** !
+
+1. Vous pouvez voir ce modèle en action en testant une ligne de données (n°50) :
```python
print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
@@ -181,9 +183,8 @@ L'exactitude est bonne à plus de **80 %** !
cuisine: indian
```
- ✅ Essayez un autre numéro de ligne et vérifiez les résultats.
-
-1. En approfondissant, vous pouvez vérifier la précision de cette prédiction :
+ ✅ Essayez un numéro de ligne différent et vérifiez les résultats
+1. En creusant davantage, vous pouvez vérifier l'exactitude de cette prédiction :
```python
test= X_test.iloc[50].values.reshape(-1, 1).T
@@ -195,7 +196,7 @@ L'exactitude est bonne à plus de **80 %** !
topPrediction.head()
```
- Le résultat est affiché - la cuisine indienne est sa meilleure estimation, avec une bonne probabilité :
+ Le résultat est imprimé - la cuisine indienne est sa meilleure hypothèse, avec une bonne probabilité :
| | 0 |
| -------: | -------: |
@@ -207,38 +208,40 @@ L'exactitude est bonne à plus de **80 %** !
✅ Pouvez-vous expliquer pourquoi le modèle est assez sûr qu'il s'agit d'une cuisine indienne ?
-1. Obtenez plus de détails en affichant un rapport de classification, comme vous l'avez fait dans les leçons sur la régression :
+1. Obtenez plus de détails en imprimant un rapport de classification, comme vous l'avez fait dans les leçons de régression :
```python
y_pred = model.predict(X_test)
print(classification_report(y_test,y_pred))
```
- | | précision | rappel | f1-score | support |
+ | | precision | rappel | f1-score | support |
| ------------ | --------- | ------ | -------- | ------- |
| chinese | 0.73 | 0.71 | 0.72 | 229 |
| indian | 0.91 | 0.93 | 0.92 | 254 |
| japanese | 0.70 | 0.75 | 0.72 | 220 |
| korean | 0.86 | 0.76 | 0.81 | 242 |
| thai | 0.79 | 0.85 | 0.82 | 254 |
- | exactitude | 0.80 | 1199 | | |
- | moyenne macro| 0.80 | 0.80 | 0.80 | 1199 |
- | moyenne pondérée | 0.80 | 0.80 | 0.80 | 1199 |
+ | accuracy | | | 0.80 | 1199 |
+ | macro avg | 0.80 | 0.80 | 0.80 | 1199 |
+ | weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
## 🚀Défi
-Dans cette leçon, vous avez utilisé vos données nettoyées pour construire un modèle d'apprentissage automatique capable de prédire une cuisine nationale à partir d'une série d'ingrédients. Prenez le temps de parcourir les nombreuses options que Scikit-learn propose pour classifier les données. Approfondissez le concept de 'solver' pour comprendre ce qui se passe en coulisses.
+Dans cette leçon, vous avez utilisé vos données nettoyées pour construire un modèle d'apprentissage automatique capable de prédire une cuisine nationale à partir d'une série d'ingrédients. Prenez le temps de lire les nombreuses options que Scikit-learn propose pour classifier les données. Approfondissez le concept de 'solver' pour comprendre ce qui se passe en coulisses.
-## [Quiz post-cours](https://ff-quizzes.netlify.app/en/ml/)
+## [Quiz post-conférence](https://ff-quizzes.netlify.app/en/ml/)
-## Révision & Auto-apprentissage
+## Revue & Auto-apprentissage
-Approfondissez un peu plus les mathématiques derrière la régression logistique dans [cette leçon](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
+Approfondissez un peu les mathématiques derrière la régression logistique dans [cette leçon](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Devoir
[Étudiez les solveurs](assignment.md)
---
+
**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.
\ No newline at end of file
+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 natale 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 ne sommes pas responsables des malentendus ou des mauvaises interprétations résultant de l’utilisation de cette traduction.
+
\ No newline at end of file
diff --git a/translations/fr/README.md b/translations/fr/README.md
index 972473a35..5db01c26c 100644
--- a/translations/fr/README.md
+++ b/translations/fr/README.md
@@ -8,16 +8,16 @@
[](https://GitHub.com/microsoft/ML-For-Beginners/network/)
[](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
-### 🌐 Support Multilingue
+### 🌐 Support multilingue
-#### Pris en charge via GitHub Action (Automatisé & Toujours à Jour)
+#### Pris en charge via GitHub Action (Automatisé & Toujours à jour)
-[Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh-CN/README.md) | [Chinese (Traditional, Hong Kong)](../zh-HK/README.md) | [Chinese (Traditional, Macau)](../zh-MO/README.md) | [Chinese (Traditional, Taiwan)](../zh-TW/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](./README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](../kn/README.md) | [Khmer](../km/README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](../ml/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../pt-BR/README.md) | [Portuguese (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](../te/README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md)
+[Arabe](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgare](../bg/README.md) | [Birmane (Myanmar)](../my/README.md) | [Chinois (simplifié)](../zh-CN/README.md) | [Chinois (traditionnel, Hong Kong)](../zh-HK/README.md) | [Chinois (traditionnel, Macao)](../zh-MO/README.md) | [Chinois (traditionnel, Taïwan)](../zh-TW/README.md) | [Croate](../hr/README.md) | [Tchèque](../cs/README.md) | [Danois](../da/README.md) | [Néerlandais](../nl/README.md) | [Estonien](../et/README.md) | [Finnois](../fi/README.md) | [Français](./README.md) | [Allemand](../de/README.md) | [Grec](../el/README.md) | [Hébreu](../he/README.md) | [Hindi](../hi/README.md) | [Hongrois](../hu/README.md) | [Indonésien](../id/README.md) | [Italien](../it/README.md) | [Japonais](../ja/README.md) | [Kannada](../kn/README.md) | [Khmer](../km/README.md) | [Coréen](../ko/README.md) | [Lituanien](../lt/README.md) | [Malais](../ms/README.md) | [Malayalam](../ml/README.md) | [Marathi](../mr/README.md) | [Népalais](../ne/README.md) | [Pidgin nigérian](../pcm/README.md) | [Norvégien](../no/README.md) | [Persan (Farsi)](../fa/README.md) | [Polonais](../pl/README.md) | [Portugais (Brésil)](../pt-BR/README.md) | [Portugais (Portugal)](../pt-PT/README.md) | [Pendjabi (Gurmukhi)](../pa/README.md) | [Roumain](../ro/README.md) | [Russe](../ru/README.md) | [Serbe (cyrillique)](../sr/README.md) | [Slovaque](../sk/README.md) | [Slovène](../sl/README.md) | [Espagnol](../es/README.md) | [Swahili](../sw/README.md) | [Suédois](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamoul](../ta/README.md) | [Télougou](../te/README.md) | [Thaï](../th/README.md) | [Turc](../tr/README.md) | [Ukrainien](../uk/README.md) | [Ourdou](../ur/README.md) | [Vietnamien](../vi/README.md)
> **Vous préférez cloner localement ?**
>
-> Ce dépôt inclut plus de 50 traductions de langues, ce qui augmente considérablement la taille de téléchargement. Pour cloner sans les traductions, utilisez le sparse checkout :
+> Ce dépôt comprend plus de 50 traductions de langues, ce qui augmente considérablement la taille du téléchargement. Pour cloner sans les traductions, utilisez le sparse checkout :
>
> **Bash / macOS / Linux :**
> ```bash
@@ -33,205 +33,217 @@
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
-> Cela vous donne tout ce dont vous avez besoin pour compléter le cours avec un téléchargement beaucoup plus rapide.
+> Cela vous donne tout ce dont vous avez besoin pour suivre le cours avec un téléchargement beaucoup plus rapide.
#### Rejoignez notre communauté
[](https://discord.gg/nTYy5BXMWG)
-Nous avons une série Discord apprendre avec l’IA en cours, 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 continue "Apprendre avec l’IA" sur Discord, apprenez-en plus et rejoignez-nous sur [Learn with AI Series](https://aka.ms/learnwithai/discord) du 18 au 30 septembre 2025. Vous découvrirez des astuces pour utiliser GitHub Copilot pour la science des données.
-
+
-# Apprentissage Automatique pour Débutants - Un Plan de Cours
+# Apprentissage automatique pour débutants - Un programme
-> 🌍 Voyagez autour du monde tout en explorant l’apprentissage automatique à travers les cultures du monde 🌍
+> 🌍 Parcourez le monde en découvrant l’apprentissage automatique à travers les cultures mondiales 🌍
-Les Cloud Advocates de Microsoft ont le plaisir d’offrir un cursus de 12 semaines, 26 leçons, entièrement dédié à **l’apprentissage automatique**. Dans ce programme, vous apprendrez ce que l’on appelle parfois le **machine learning classique**, en utilisant principalement Scikit-learn comme bibliothèque, et en évitant le deep learning, qui est couvert dans notre cours [IA pour débutants](https://aka.ms/ai4beginners). Associez ces leçons avec notre [cours « Science des données pour débutants »](https://aka.ms/ds4beginners) également !
+Les Cloud Advocates de 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 la bibliothèque Scikit-learn et en évitant l’apprentissage profond, qui est abordé dans notre [programme IA pour débutants](https://aka.ms/ai4beginners). Associez ces leçons à notre [programme ‘Science des données pour débutants’](https://aka.ms/ds4beginners) également !
-Voyagez avec nous autour du monde en appliquant ces techniques classiques à des données provenant de nombreuses régions. Chaque leçon inclut des quiz pré- et post-leçon, des instructions écrites pour réaliser 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 s’ancrent durablement.
+Voyagez avec nous autour du monde en appliquant ces techniques classiques à des données de nombreux pays et régions. Chaque leçon comprend des quiz avant et après la leçon, des instructions écrites pour réaliser 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 ancrer les nouvelles compétences.
**✍️ 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 particuliers 🙏 à nos ambassadeurs étudiants Microsoft auteurs, relecteurs et contributeurs de contenu**, notamment Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, et Snigdha Agarwal
-**🤩 Une gratitude supplémentaire aux Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi et Vidushi Gupta pour nos leçons R !**
+**🤩 Gratitude supplémentaire aux ambassadeurs étudiants Microsoft Eric Wanjau, Jasleen Sondhi, et Vidushi Gupta pour nos leçons de R !**
-# Commencer
+# Pour commencer
Suivez ces étapes :
-1. **Forkez le dépôt** : Cliquez sur le bouton "Fork" en haut à droite de cette page.
-2. **Clonez le dépôt** : `git clone https://github.com/microsoft/ML-For-Beginners.git`
+1. **Faites un fork du dépôt** : Cliquez sur le bouton « Fork » en haut à droite de cette page.
+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)
+> [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)
+
+> 🔧 **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 courants d’installation, configuration et exécution des leçons.
-**[Étudiants](https://aka.ms/student-page)**, pour utiliser ce cursus, forkez l’intégralité du dépôt sur votre propre compte GitHub et complétez les exercices seul ou en groupe :
+**[Étudiants](https://aka.ms/student-page)**, pour utiliser ce programme, faites un fork complet du dépôt sur votre propre compte GitHub et réalisez les exercices seul ou en groupe :
- Commencez par un quiz avant la leçon.
-- Lisez la leçon et réalisez les activités, marquez des pauses pour réfléchir à chaque contrôle des connaissances.
-- Essayez de créer les projets en comprenant les leçons plutôt qu’en exécutant directement le code solution ; néanmoins ce code est disponible dans les dossiers `/solution` de chaque leçon axée projet.
-- Passez le quiz post-lecture.
-- Réalisez le défi.
-- Effectuez 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 des progrès que vous remplissez pour approfondir votre apprentissage. Vous pouvez également réagir aux autres PAT afin que nous puissions apprendre ensemble.
+- Lisez la leçon et complétez les activités, en vous arrêtant pour réfléchir à chaque point de contrôle des connaissances.
+- Essayez de créer les projets en comprenant les leçons plutôt qu’en exécutant directement le code de la solution ; ce code est toutefois disponible dans les dossiers `/solution` de chaque leçon orientée projet.
+- Faites le quiz après la leçon.
+- Réalisez le challenge.
+- Faites le devoir.
+- Après avoir terminé un groupe de leçons, consultez le [forum de discussion](https://github.com/microsoft/ML-For-Beginners/discussions) et « apprenez à haute voix » en remplissant la grille PAT correspondante. Un 'PAT' est un Outil d’évaluation des progrès que vous complétez pour approfondir votre apprentissage. Vous pouvez aussi réagir à d’autres PAT afin que nous puissions 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 cursus.
+**Enseignants**, nous avons [inclus quelques suggestions](for-teachers.md) pour utiliser ce programme.
---
## Vidéos explicatives
-Certaines leçons sont disponibles en vidéo courte. Vous pouvez toutes les trouver dans les leçons elles-mêmes, ou sur la [playlist ML for Beginners de la chaîne Microsoft Developer YouTube](https://aka.ms/ml-beginners-videos) en cliquant sur l’image ci-dessous.
+Certaines leçons sont disponibles sous forme de vidéos courtes. Vous pouvez toutes les trouver intégrées dans les leçons, ou sur la [playlist ML for Beginners sur la chaîne YouTube Microsoft Developer](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)
---
## Rencontrez l’équipe
-[](https://youtu.be/Tj1XWrDSYJU)
+[](https://youtu.be/Tj1XWrDSYJU)
**Gif par** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
-> 🎥 Cliquez sur l’image ci-dessus pour une vidéo sur le projet et les personnes qui l'ont créé !
+> 🎥 Cliquez sur l’image ci-dessus pour une vidéo sur le projet et les personnes qui l’ont créé !
---
## Pédagogie
-Nous avons choisi deux principes pédagogiques lors de la construction de ce cursus : garantir qu’il soit pratique **basé sur des projets** et qu’il inclue des **quiz fréquents**. De plus, ce cursus possède un **thème commun** pour lui donner de la cohérence.
+Nous avons choisi deux principes pédagogiques en construisant ce programme : garantir qu’il soit **axé sur des projets pratiques** et qu’il inclue des **quiz fréquents**. De plus, ce programme a un **thème commun** pour lui donner une cohésion.
-En permettant que le contenu soit aligné sur des projets, le processus devient plus engageant pour les étudiants et la rétention des concepts est améliorée. De plus, un quiz à enjeux faibles avant une classe fixe l’intention d’apprentissage de l’étudiant, tandis qu’un second quiz en fin de cours assure une meilleure mémorisation. Ce cursus a été conçu pour être flexible et amusant, et peut être suivi en totalité ou partiellement. Les projets commencent petits et deviennent de plus en plus complexes à la fin de ce cycle de 12 semaines. Ce programme inclut également un post-scriptum sur les applications réelles du ML, que l’on peut utiliser comme points bonus ou base de discussion.
+En alignant le contenu sur des projets, le processus devient plus engageant pour les étudiants et la rétention des concepts est augmentée. De plus, un quiz à faible enjeu avant la classe oriente l’attention de l’étudiant vers l’apprentissage d’un sujet, tandis qu’un second quiz après la classe assure une rétention plus approfondie. Ce programme 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 jusqu’à la fin du cycle de 12 semaines. Ce programme comprend aussi un post-scriptum sur les applications réelles de l’apprentissage automatique, qui peut servir de crédit supplémentaire ou de base pour discussion.
-> Retrouvez notre [Code de conduite](CODE_OF_CONDUCT.md), [Contribuer](CONTRIBUTING.md), [Traductions](..), et [Dépannage](TROUBLESHOOTING.md). Nous accueillons vos retours constructifs !
+> Trouvez nos directives [Code de conduite](CODE_OF_CONDUCT.md), [Contribution](CONTRIBUTING.md), [Traductions](..), et [Dépannage](TROUBLESHOOTING.md). Nous accueillons vos retours constructifs !
## Chaque leçon comprend
-- sketchnote optionnel
-- vidéo supplémentaire optionnelle
-- vidéo tutorielle (certaines leçons uniquement)
-- [quiz d’échauffement pré-lecture](https://ff-quizzes.netlify.app/en/ml/)
+- sketchnote optionnelle
+- vidéo complémentaire optionnelle
+- vidéo explicative (certaines leçons seulement)
+- [quiz d’échauffement avant la leçon](https://ff-quizzes.netlify.app/en/ml/)
- leçon écrite
-- pour les leçons basées sur un projet, guide étape par étape pour construire le projet
-- contrôles des connaissances
-- un défi
+- pour les leçons basées sur des projets, guides pas à pas pour construire le projet
+- points de vérification des connaissances
+- un challenge
- lecture complémentaire
- devoir
-- [quiz post-leçon](https://ff-quizzes.netlify.app/en/ml/)
-> **Une note sur les langues** : Ces leçons sont principalement écrites en Python, mais beaucoup sont également disponibles en R. Pour compléter une leçon en R, rendez-vous dans le dossier `/solution` et cherchez les leçons en R. Elles incluent une extension .rmd qui représente un fichier **R Markdown**, qui peut être simplement défini comme une intégration de `blocs de code` (en R ou d'autres langages) et un `en-tête YAML` (qui guide la mise en forme des sorties telles que PDF) dans un `document Markdown`. En tant que tel, il sert de cadre exemplaire d’écriture pour la science des données car il vous permet de combiner votre code, ses résultats, et vos réflexions en vous autorisant à 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 dans le dossier `quiz-app` pour héberger ou déployer localement sur Azure.
-
-| Numéro de la leçon | Sujet | Groupement de la leçon | Objectifs d'apprentissage | Leçon liée | Auteur |
-| :-----------------: | :-------------------------------------------------------------: | :---------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :-----------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------: |
-| 01 | Introduction à l'apprentissage machine | [Introduction](1-Introduction/README.md) | Apprenez les concepts de base derrière l'apprentissage machine | [Leçon](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
-| 02 | L’historique de l'apprentissage machine | [Introduction](1-Introduction/README.md) | Découvrez l'histoire sous-jacente de ce domaine | [Leçon](1-Introduction/2-history-of-ML/README.md) | Jen et Amy |
-| 03 | L’équité et l'apprentissage machine | [Introduction](1-Introduction/README.md) | Quels sont les enjeux philosophiques importants autour de l’équité à considérer lors de la construction et l’application de modèles ML ? | [Leçon](1-Introduction/3-fairness/README.md) | Tomomi |
-| 04 | Techniques d'apprentissage machine | [Introduction](1-Introduction/README.md) | Quelles techniques les chercheurs en apprentissage machine utilisent-ils pour construire leurs 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) | Commencez 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) | Visualisez et nettoyez les données en préparation pour l’apprentissage machine | [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) | 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 🎃 | [Regression](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 🔌 | [Web App](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 | Cuisines délicieuses asiatiques et indiennes 🍜 | [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 | Cuisines délicieuses asiatiques et indiennes 🍜 | [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 | Cuisines délicieuses 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 ☕️ | [Natural language processing](6-NLP/README.md) | Apprenez les bases du TAL en construisant un bot simple | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
-| 17 | Tâches courantes en TAL ☕️ | [Natural language processing](6-NLP/README.md) | Approfondissez vos connaissances sur le TAL en comprenant les tâches courantes nécessaires à la manipulation des 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 d’Europe ♥️ | [Natural language processing](6-NLP/README.md) | Analyse des sentiments avec les avis d’hôtel 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
-| 20 | Hôtels romantiques d’Europe ♥️ | [Natural language processing](6-NLP/README.md) | Analyse des sentiments avec les 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’électricité ⚡️ - prévision temporelle 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’électricité ⚡️ - prévision temporelle 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 | Aidez Peter à éviter le loup ! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | Apprentissage par renforcement Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
-| Postscriptum | Scénarios et applications ML réels | [ML in the Wild](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 |
-| Postscriptum | Débogage de modèles ML avec le tableau de bord RAI | [ML in the Wild](9-Real-World/README.md) | Débogage de 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 |
+- [quiz après la leçon](https://ff-quizzes.netlify.app/en/ml/)
+> **Une note à propos des langues** : Ces leçons sont principalement écrites en Python, mais beaucoup sont également 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** qui peut ê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 la mise en forme des sorties telles que PDF) dans un `document Markdown`. En tant que tel, cela sert de cadre d’écriture exemplaire pour la science des données puisqu’il vous permet de combiner votre code, sa sortie et vos pensées 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 à propos des quiz** : Tous les quiz sont contenus dans le [dossier Quiz App](../../quiz-app), pour un total de 52 quiz avec trois questions chacun. Ils sont liés depuis les leçons mais l’application de 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 leçon | Sujet | Regroupement des leçons | Objectifs d’apprentissage | Leçon liée | Auteur |
+| :-------------: | :------------------------------------------------------------: | :----------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
+| 01 | Introduction à l’apprentissage machine | [Introduction](1-Introduction/README.md) | Apprenez les concepts de base derrière l’apprentissage machine | [Leçon](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
+| 02 | L’histoire de l’apprentissage machine | [Introduction](1-Introduction/README.md) | Apprenez l’histoire sous-jacente à ce domaine | [Leçon](1-Introduction/2-history-of-ML/README.md) | Jen et Amy |
+| 03 | Équité et apprentissage machine | [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 pour l’apprentissage machine | [Introduction](1-Introduction/README.md) | Quelles techniques les chercheurs en ML utilisent-ils pour créer 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) | Commencez 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 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 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 | Délicieuses cuisines asiatiques et indiennes 🍜 | [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 | Délicieuses cuisines asiatiques et indiennes 🍜 | [Classification](4-Classification/README.md) | Construisez 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) | 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 simple bot | [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 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 ♥️ | [Traitement du langage naturel](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 d’Europe ♥️ | [Traitement du langage naturel](6-NLP/README.md) | Analyse de sentiment avec des avis d’hôtels 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
+| 20 | Hôtels romantiques d’Europe ♥️ | [Traitement du langage naturel](6-NLP/README.md) | Analyse de sentiment avec des 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 | ⚡️ Utilisation mondiale de l’énergie ⚡️ - prévision des séries temporelles 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 | ⚡️ Utilisation mondiale de l’énergie ⚡️ - prévision des séries temporelles 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) | Gym pour apprentissage par renforcement | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
+| Postface | Scénarios et applications réels de ML | [ML in the Wild](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 |
+| 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 machine avec 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)
## Accès hors ligne
-Vous pouvez consulter 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`.
+Vous pouvez consulter cette documentation hors ligne en utilisant [Docsify](https://docsify.js.org/#/). Clonez 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 sur votre localhost : `localhost:3000`.
## PDFs
-Trouvez un PDF du programme avec 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 :
+Notre équipe produit d’autres cours ! Découvrez :
### 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 IA Générative
-[](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
-[-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
-[-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
-[-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
+### Série Intelligence Artificielle Générative
+[](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
+[-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
+[-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
+[-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
---
### Apprentissage Fondamental
-[](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)
-[](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
-[](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
-[](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
-[](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
+[](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)
+[](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
+[](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
+[](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
+[](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### Série Copilot
-[](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)
-[](https://github.com/microsoft/CopilotAdventures?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)
+[](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst)
-## Obtenir de l’aide
+## Obtenir de l'aide
-Si vous êtes bloqué ou si vous avez des questions concernant la création d’applications IA. Rejoignez d’autres apprenants et développeurs expérimentés dans des discussions sur MCP. C’est une communauté solidaire où les questions sont les bienvenues et le partage de connaissance est libre.
+Si vous êtes bloqué ou avez des questions pendant l'apprentissage du Machine Learning ou la création d'applications d'IA, ne vous inquiétez pas — de l'aide est disponible.
-[](https://discord.gg/nTYy5BXMWG)
+Vous pouvez rejoindre les discussions avec d'autres apprenants et développeurs, poser des questions, et partager vos idées avec la communauté.
+
+- Rejoignez la communauté pour poser des questions et apprendre avec d'autres
+- Discutez des concepts de Machine Learning et des idées de projets
+- Obtenez des conseils de développeurs expérimentés
-Si vous avez des retours produit ou rencontrez des erreurs lors du développement, visitez :
+Une communauté de soutien est un excellent moyen de développer vos compétences et résoudre les problèmes plus rapidement.
+
+[Microsoft Foundry Discord Community](https://discord.gg/nTYy5BXMWG)
+
+Si vous rencontrez des bugs, erreurs ou avez des suggestions d'amélioration, vous pouvez aussi ouvrir un **Issue** dans ce dépôt pour signaler le problème.
+
+Pour des retours sur le produit ou pour rechercher dans les messages existants, visitez le Forum des développeurs :
[](https://aka.ms/foundry/forum)
-## Conseils supplémentaires pour l’apprentissage
-- Revoir les notebooks après chaque leçon pour une meilleure compréhension.
-- Pratiquer l’implémentation des algorithmes par vous-même.
-- Explorer des ensembles de données réels en utilisant les concepts appris.
+## Conseils supplémentaires pour apprendre
+
+- Passez en revue les notebooks après chaque leçon pour mieux comprendre.
+- Pratiquez la mise en œuvre des algorithmes par vous-même.
+- Explorez des jeux de données réels en utilisant les concepts appris.
---
**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 efforçons 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 foi. Pour les informations critiques, une traduction professionnelle humaine est recommandée. Nous ne sommes pas responsables des malentendus ou des erreurs d’interprétation 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 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 native doit être considéré comme la source faisant autorité. Pour les informations critiques, une traduction professionnelle humaine est recommandée. Nous ne sommes pas responsables des malentendus ou des mauvaises interprétations résultant de l'utilisation de cette traduction.
\ No newline at end of file