diff --git a/translations/en/.co-op-translator.json b/translations/en/.co-op-translator.json
index beba21163..70182f876 100644
--- a/translations/en/.co-op-translator.json
+++ b/translations/en/.co-op-translator.json
@@ -36,8 +36,8 @@
"language_code": "en"
},
"1-Introduction/4-techniques-of-ML/README.md": {
- "original_hash": "9d91f3af3758fdd4569fb410575995ef",
- "translation_date": "2025-09-06T10:53:40+00:00",
+ "original_hash": "84b1715a6be62ef1697351dcc5d7b567",
+ "translation_date": "2026-04-26T18:31:56+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
"language_code": "en"
},
@@ -90,8 +90,8 @@
"language_code": "en"
},
"2-Regression/3-Linear/README.md": {
- "original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
- "translation_date": "2026-04-20T15:37:29+00:00",
+ "original_hash": "8b776e731c35b171d316d01d0e7b1369",
+ "translation_date": "2026-04-26T18:31:36+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "en"
},
@@ -107,6 +107,12 @@
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
"language_code": "en"
},
+ "2-Regression/3-Linear/solution/notebook.ipynb": {
+ "original_hash": "6781223ffbe8cfdaa38d0200f08e1288",
+ "translation_date": "2026-04-26T18:29:38+00:00",
+ "source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
+ "language_code": "en"
+ },
"2-Regression/4-Logistic/README.md": {
"original_hash": "abf86d845c84330bce205a46b382ec88",
"translation_date": "2025-09-06T10:46:08+00:00",
@@ -210,8 +216,8 @@
"language_code": "en"
},
"4-Classification/3-Classifiers-2/solution/notebook.ipynb": {
- "original_hash": "70f41fe4fd4253adb44cd9d291406e4f",
- "translation_date": "2026-02-28T08:12:54+00:00",
+ "original_hash": "382c1f542f31fcc58137ce6d14751413",
+ "translation_date": "2026-04-26T18:29:45+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "en"
},
diff --git a/translations/en/1-Introduction/4-techniques-of-ML/README.md b/translations/en/1-Introduction/4-techniques-of-ML/README.md
index c040b3f37..47d8ed385 100644
--- a/translations/en/1-Introduction/4-techniques-of-ML/README.md
+++ b/translations/en/1-Introduction/4-techniques-of-ML/README.md
@@ -1,117 +1,117 @@
# Techniques of Machine Learning
-The process of creating, using, and maintaining machine learning models and the data they rely on is quite different from many other development workflows. In this lesson, we will break down the process and outline the key techniques you need to understand. You will:
+The process of building, using, and maintaining machine learning models and the data they use is a very different process from many other development workflows. In this lesson, we will demystify the process, and outline the main techniques you need to know. You will:
-- Gain a high-level understanding of the processes behind machine learning.
-- Explore foundational concepts such as 'models,' 'predictions,' and 'training data.'
+- Understand the processes underpinning machine learning at a high level.
+- Explore base concepts such as 'models', 'predictions', and 'training data'.
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
[](https://youtu.be/4NGM0U2ZSHU "ML for beginners - Techniques of Machine Learning")
-> 🎥 Click the image above for a short video walkthrough of this lesson.
+> 🎥 Click the image above for a short video working through this lesson.
## Introduction
-At a high level, the process of creating machine learning (ML) systems involves several steps:
+On a high level, the craft of creating machine learning (ML) processes is comprised of a number of steps:
-1. **Define the question**. Most ML processes begin with a question that cannot be answered using a simple conditional program or rules-based system. These questions often focus on making predictions based on a dataset.
-2. **Collect and prepare data**. To answer your question, you need data. The quality and sometimes the quantity of your data will determine how well you can address your initial question. Visualizing data is an important part of this phase. This phase also includes splitting the data into training and testing sets to build a model.
-3. **Select a training method**. Depending on your question and the nature of your data, you need to choose how to train a model to best represent your data and make accurate predictions. This step often requires specific expertise and a significant amount of experimentation.
-4. **Train the model**. Using your training data, you'll apply various algorithms to train a model to recognize patterns in the data. The model may use internal weights that can be adjusted to prioritize certain parts of the data over others to improve its performance.
-5. **Evaluate the model**. You use unseen data (your testing data) from your dataset to assess how well the model performs.
-6. **Tune parameters**. Based on the model's performance, you can repeat the process using different parameters or variables that control the behavior of the algorithms used to train the model.
-7. **Make predictions**. Use new inputs to test the model's accuracy.
+1. **Decide on the question**. Most ML processes start by asking a question that cannot be answered by a simple conditional program or rules-based engine. These questions often revolve around predictions based on a collection of data.
+2. **Collect and prepare data**. To be able to answer your question, you need data. The quality and, sometimes, quantity of your data will determine how well you can answer your initial question. Visualizing data is an important aspect of this phase. This phase also includes splitting the data into a training and testing group to build a model.
+3. **Choose a training method**. Depending on your question and the nature of your data, you need to choose how you want to train a model to best reflect your data and make accurate predictions against it. This is the part of your ML process that requires specific expertise and, often, a considerable amount of experimentation.
+4. **Train the model**. Using your training data, you'll use various algorithms to train a model to recognize patterns in the data. The model might leverage internal weights that can be adjusted to privilege certain parts of the data over others to build a better model.
+5. **Evaluate the model**. You use never before seen data (your testing data) from your collected set to see how the model is performing.
+6. **Parameter tuning**. Based on the performance of your model, you can redo the process using different parameters, or variables, that control the behavior of the algorithms used to train the model.
+7. **Predict**. Use new inputs to test the accuracy of your model.
## What question to ask
-Computers excel at uncovering hidden patterns in data. This capability is particularly useful for researchers who have questions about a specific domain that cannot be easily answered by creating a rules-based system. For example, in an actuarial task, a data scientist might create handcrafted rules to analyze the mortality rates of smokers versus non-smokers.
+Computers are particularly skilled at discovering hidden patterns in data. This utility is very helpful for researchers who have questions about a given domain that cannot be easily answered by creating a conditionally-based rules engine. Given an actuarial task, for example, a data scientist might be able to construct handcrafted rules around the mortality of smokers vs non-smokers.
-However, when many other variables are introduced, an ML model might be more effective at predicting future mortality rates based on past health data. A more optimistic example could involve predicting the weather for April in a specific location using data such as latitude, longitude, climate change, proximity to the ocean, jet stream patterns, and more.
+When many other variables are brought into the equation, however, a ML model might prove more efficient to predict future mortality rates based on past health history. A more cheerful example might be making weather predictions for the month of April in a given location based on data that includes latitude, longitude, climate change, proximity to the ocean, patterns of the jet stream, and more.
-✅ This [slide deck](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) on weather models provides a historical perspective on using ML for weather analysis.
+✅ This [slide deck](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) on weather models offers a historical perspective for using ML in weather analysis.
## Pre-building tasks
-Before you start building your model, there are several tasks you need to complete. To test your question and form a hypothesis based on the model's predictions, you need to identify and configure several elements.
+Before starting to build your model, there are several tasks you need to complete. To test your question and form a hypothesis based on a model's predictions, you need to identify and configure several elements.
### Data
-To answer your question with confidence, you need a sufficient amount of data of the right type. At this stage, you need to:
+To be able to answer your question with any kind of certainty, you need a good amount of data of the right type. There are two things you need to do at this point:
-- **Collect data**. Referencing the previous lesson on fairness in data analysis, collect your data carefully. Be mindful of its sources, any inherent biases, and document its origin.
-- **Prepare data**. Data preparation involves several steps. You may need to combine and normalize data from different sources. You can enhance the quality and quantity of your data through methods like converting strings to numbers (as seen in [Clustering](../../5-Clustering/1-Visualize/README.md)). You might also generate new data based on the original (as seen in [Classification](../../4-Classification/1-Introduction/README.md)). You can clean and edit the data (as we will do before the [Web App](../../3-Web-App/README.md) lesson). Additionally, you may need to randomize and shuffle the data depending on your training techniques.
+- **Collect data**. Keeping in mind the previous lesson on fairness in data analysis, collect your data with care. Be aware of the sources of this data, any inherent biases it might have, and document its origin.
+- **Prepare data**. There are several steps in the data preparation process. You might need to collate data and normalize it if it comes from diverse sources. You can improve the data's quality and quantity through various methods such as converting strings to numbers (as we do in [Clustering](../../5-Clustering/1-Visualize/README.md)). You might also generate new data, based on the original (as we do in [Classification](../../4-Classification/1-Introduction/README.md)). You can clean and edit the data (as we will prior to the [Web App](../../3-Web-App/README.md) lesson). Finally, you might also need to randomize it and shuffle it, depending on your training techniques.
-✅ After collecting and processing your data, take a moment to evaluate whether its structure will allow you to address your intended question. Sometimes, the data may not perform well for your specific task, as we discover in our [Clustering](../../5-Clustering/1-Visualize/README.md) lessons!
+✅ After collecting and processing your data, take a moment to see if its shape will allow you to address your intended question. It may be that the data will not perform well in your given task, as we discover in our [Clustering](../../5-Clustering/1-Visualize/README.md) lessons!
### Features and Target
-A [feature](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) is a measurable property of your data. In many datasets, it is represented as a column heading like 'date,' 'size,' or 'color.' Feature variables, often represented as `X` in code, are the input variables used to train the model.
+A [feature](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) is a measurable property of your data. In many datasets it is expressed as a column heading like 'date' 'size' or 'color'. Your feature variable, usually represented as `X` in code, represents the input variable which will be used to train a model.
-A target is what you are trying to predict. Targets, usually represented as `y` in code, are the answers to the questions you are asking of your data: In December, what **color** pumpkins will be cheapest? In San Francisco, which neighborhoods will have the best real estate **prices**? Sometimes, the target is also referred to as the label attribute.
+A target is a thing you are trying to predict. Target, usually represented as `y` in code, represents the answer to the question you are trying to ask of your data: in December, what **color** pumpkins will be cheapest? in San Francisco, what neighborhoods will have the best real estate **price**? Sometimes target is also referred to as a label attribute.
### Selecting your feature variable
-🎓 **Feature Selection and Feature Extraction** How do you decide which variables to use when building a model? You will likely go through a process of feature selection or feature extraction to identify the best variables for the most effective model. These processes differ: "Feature extraction creates new features from functions of the original features, whereas feature selection returns a subset of the features." ([source](https://wikipedia.org/wiki/Feature_selection))
+🎓 **Feature Selection and Feature Extraction** How do you know which variable to choose when building a model? You'll probably go through a process of feature selection or feature extraction to choose the right variables for the most performant model. They're not the same thing, however: "Feature extraction creates new features from functions of the original features, whereas feature selection returns a subset of the features." ([source](https://wikipedia.org/wiki/Feature_selection))
### Visualize your data
-Visualization is a powerful tool in a data scientist's toolkit. Libraries like Seaborn or MatPlotLib allow you to represent your data visually, which can help uncover hidden correlations that you can leverage. Visualizations can also reveal bias or imbalances in your data (as seen in [Classification](../../4-Classification/2-Classifiers-1/README.md)).
+An important aspect of the data scientist's toolkit is the power to visualize data using several excellent libraries such as Seaborn or MatPlotLib. Representing your data visually might allow you to uncover hidden correlations that you can leverage. Your visualizations might also help you to uncover bias or unbalanced data (as we discover in [Classification](../../4-Classification/2-Classifiers-1/README.md)).
### Split your dataset
-Before training, you need to divide your dataset into two or more parts of unequal size that still represent the data well.
+Prior to training, you need to split your dataset into two or more parts of unequal size that still represent the data well.
-- **Training**. This portion of the dataset is used to train your model. It typically constitutes the majority of the original dataset.
-- **Testing**. A test dataset is an independent subset of the original data used to validate the model's performance.
-- **Validating**. A validation set is a smaller independent subset used to fine-tune the model's hyperparameters or architecture to improve its performance. Depending on the size of your data and the question you are addressing, you may not need to create this third set (as noted in [Time Series Forecasting](../../7-TimeSeries/1-Introduction/README.md)).
+- **Training**. This part of the dataset is fit to your model to train it. This set constitutes the majority of the original dataset.
+- **Testing**. A test dataset is an independent group of data, often gathered from the original data, that you use to confirm the performance of the built model.
+- **Validating**. A validation set is a smaller independent group of examples that you use to tune the model's hyperparameters, or architecture, to improve the model. Depending on your data's size and the question you are asking, you might not need to build this third set (as we note in [Time Series Forecasting](../../7-TimeSeries/1-Introduction/README.md)).
## Building a model
-Using your training data, your goal is to build a model—a statistical representation of your data—using various algorithms to **train** it. Training a model exposes it to data, enabling it to identify patterns, validate them, and accept or reject them.
+Using your training data, your goal is to build a model, or a statistical representation of your data, using various algorithms to **train** it. Training a model exposes it to data and allows it to make assumptions about perceived patterns it discovers, validates, and accepts or rejects.
### Decide on a training method
-Depending on your question and the nature of your data, you will select a method to train the model. By exploring [Scikit-learn's documentation](https://scikit-learn.org/stable/user_guide.html)—which we use in this course—you can examine various ways to train a model. Depending on your experience, you may need to try multiple methods to build the best model. Data scientists often evaluate a model's performance by testing it with unseen data, checking for accuracy, bias, and other issues, and selecting the most suitable training method for the task.
+Depending on your question and the nature of your data, you will choose a method to train it. Stepping through [Scikit-learn's documentation](https://scikit-learn.org/stable/user_guide.html) - which we use in this course - you can explore many ways to train a model. Depending on your experience, you might have to try several different methods to build the best model. You are likely to go through a process whereby data scientists evaluate the performance of a model by feeding it unseen data, checking for accuracy, bias, and other quality-degrading issues, and selecting the most appropriate training method for the task at hand.
### Train a model
-With your training data, you are ready to 'fit' it to create a model. In many ML libraries, you will encounter the code 'model.fit'—this is where you input your feature variable as an array of values (usually 'X') and a target variable (usually 'y').
+Armed with your training data, you are ready to 'fit' it to create a model. You will notice that in many ML libraries you will find the code 'model.fit' - it is at this time that you send in your feature variable as an array of values (usually 'X') and a target variable (usually 'y').
### Evaluate the model
-Once the training process is complete (it may require many iterations, or 'epochs,' to train a large model), you can evaluate the model's quality using test data to measure its performance. This test data is a subset of the original data that the model has not previously analyzed. You can generate a table of metrics to assess the model's quality.
+Once the training process is complete (it can take many iterations, or 'epochs', to train a large model), you will be able to evaluate the model's quality by using test data to gauge its performance. This data is a subset of the original data that the model has not previously analyzed. You can print out a table of metrics about your model's quality.
🎓 **Model fitting**
-In machine learning, model fitting refers to how accurately the model's underlying function analyzes data it has not encountered before.
+In the context of machine learning, model fitting refers to the accuracy of the model's underlying function as it attempts to analyze data with which it is not familiar.
-🎓 **Underfitting** and **overfitting** are common issues that reduce a model's quality. An underfit model fails to analyze both its training data and unseen data accurately. An overfit model performs too well on training data because it has learned the data's details and noise excessively. Both scenarios lead to poor predictions.
+🎓 **Underfitting** and **overfitting** are common problems that degrade the quality of the model, as the model fits either not well enough or too well. This causes the model to make predictions either too closely aligned or too loosely aligned with its training data. An overfit model predicts training data too well because it has learned the data's details and noise too well. An underfit model is not accurate as it can neither accurately analyze its training data nor data it has not yet 'seen'.
-
+
> Infographic by [Jen Looper](https://twitter.com/jenlooper)
## Parameter tuning
-After initial training, evaluate the model's quality and consider improving it by adjusting its 'hyperparameters.' Learn more about this process [in the documentation](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
+Once your initial training is complete, observe the quality of the model and consider improving it by tweaking its 'hyperparameters'. Read more about the process [in the documentation](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
## Prediction
-This is the stage where you use entirely new data to test your model's accuracy. In an applied ML setting, such as building web applications for production, this process might involve gathering user input (e.g., a button press) to set a variable and send it to the model for inference or evaluation.
+This is the moment where you can use completely new data to test your model's accuracy. In an 'applied' ML setting, where you are building web assets to use the model in production, this process might involve gathering user input (a button press, for example) to set a variable and send it to the model for inference, or evaluation.
-In these lessons, you will learn how to prepare, build, test, evaluate, and predict—covering all the steps of a data scientist and more as you progress toward becoming a 'full stack' ML engineer.
+In these lessons, you will discover how to use these steps to prepare, build, test, evaluate, and predict - all the gestures of a data scientist and more, as you progress in your journey to become a 'full stack' ML engineer.
---
## 🚀Challenge
-Create a flow chart illustrating the steps of an ML practitioner. Where do you see yourself in this process right now? Where do you anticipate challenges? What seems straightforward to you?
+Draw a flow chart reflecting the steps of a ML practitioner. Where do you see yourself right now in the process? Where do you predict you will find difficulty? What seems easy to you?
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Review & Self Study
-Search online for interviews with data scientists discussing their daily work. Here is [one](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
+Search online for interviews with data scientists who discuss their daily work. Here is [one](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
## Assignment
@@ -119,5 +119,7 @@ Search online for interviews with data scientists discussing their daily work. H
---
-**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
+
+**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/en/2-Regression/3-Linear/README.md b/translations/en/2-Regression/3-Linear/README.md
index db874423e..28be7c4c1 100644
--- a/translations/en/2-Regression/3-Linear/README.md
+++ b/translations/en/2-Regression/3-Linear/README.md
@@ -2,11 +2,11 @@
## Beginner Note
-Linear regression is used when we want to predict a **numerical value** (for example, house price, temperature, or sales).
+Linear regression is used when we want to predict a **numerical value** (for example, house price, temperature, or sales).
It works by finding a straight line that best represents the relationship between input features and the output.
-In this lesson, we focus on understanding the concept before exploring more advanced regression techniques.
-
+In this lesson, we focus on understanding the concept before exploring more advanced regression techniques.
+
> Infographic by [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
@@ -130,7 +130,7 @@ print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
-It looks like the correlation is pretty small, -0.15 by `Month` and -0.17 by the `DayOfMonth`, but there could be another important relationship. It looks like there are different clusters of prices corresponding to different pumpkin varieties. To confirm this hypothesis, let's plot each pumpkin category using a different color. By passing an `ax` parameter to the `scatter` plotting function we can plot all points on the same graph:
+It looks like the correlation is pretty small, -0.15 by `Month` and -0.17 by the `DayOfYear`, but there could be another important relationship. It looks like there are different clusters of prices corresponding to different pumpkin varieties. To confirm this hypothesis, let's plot each pumpkin category using a different color. By passing an `ax` parameter to the `scatter` plotting function we can plot all points on the same graph:
```python
ax=None
@@ -258,11 +258,33 @@ pipeline.fit(X_train,y_train)
Using `PolynomialFeatures(2)` means that we will include all second-degree polynomials from the input data. In our case it will just mean `DayOfYear`2, but given two input variables X and Y, this will add X2, XY and Y2. We may also use higher degree polynomials if we want.
-Pipelines can be used in the same manner as the original `LinearRegression` object, i.e. we can `fit` the pipeline, and then use `predict` to get the prediction results. Here is the graph showing test data, and the approximation curve:
+Pipelines can be used in the same manner as the original `LinearRegression` object, i.e. we can `fit` the pipeline, and then use `predict` to get the prediction results:
+
+```python
+pred = pipeline.predict(X_test)
+
+rmse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
+
+score = pipeline.score(X_train,y_train)
+print('Model determination: ', score)
+```
+
+To plot the smooth approximation curve, we use `np.linspace` to create a uniform range of input values, rather than plotting directly on the unordered test data (which would produce a zigzag line):
+
+```python
+X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
+y_range = pipeline.predict(X_range)
+
+plt.scatter(X_test, y_test)
+plt.plot(X_range, y_range)
+```
+
+Here is the graph showing test data, and the approximation curve:
-Using Polynomial Regression, we can get slightly lower MSE and higher determination, but not significantly. We need to take into account other features!
+Using Polynomial Regression, we can get slightly lower RMSE and higher determination, but not significantly. We need to take into account other features!
> You can see that the minimal pumpkin prices are observed somewhere around Halloween. How can you explain this?
@@ -319,7 +341,7 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
-Here we also take into account `City` and `Package` type, which gives us MSE 2.84 (10%), and determination 0.94!
+Here we also take into account `City` and `Package` type, which gives us RMSE 2.84 (10.5%), and determination 0.94!
## Putting it all together
@@ -343,17 +365,17 @@ pipeline.fit(X_train,y_train)
# predict results for test data
pred = pipeline.predict(X_test)
-# calculate MSE and determination
-mse = np.sqrt(mean_squared_error(y_test,pred))
-print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+# calculate RMSE and determination
+rmse = mean_squared_error(y_test, pred, squared=False)
+print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
-This should give us the best determination coefficient of almost 97%, and MSE=2.23 (~8% prediction error).
+This should give us the best determination coefficient of almost 97%, and RMSE=2.23 (~8% prediction error).
-| Model | MSE | Determination |
+| Model | RMSE | Determination |
|-------|-----|---------------|
| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynomial | 2.73 (17.0%) | 0.08 |
diff --git a/translations/en/2-Regression/3-Linear/solution/notebook.ipynb b/translations/en/2-Regression/3-Linear/solution/notebook.ipynb
index 0bdfe23d1..7d4dbcf7f 100644
--- a/translations/en/2-Regression/3-Linear/solution/notebook.ipynb
+++ b/translations/en/2-Regression/3-Linear/solution/notebook.ipynb
@@ -6,12 +6,12 @@
"source": [
"## Linear and Polynomial Regression for Pumpkin Pricing - Lesson 3\n",
"\n",
- "Load the necessary libraries and dataset. Transform the data into a dataframe containing a subset of the information:\n",
+ "Load up required libraries and dataset. Convert the data to a dataframe containing a subset of the data: \n",
"\n",
- "- Only include pumpkins priced by the bushel\n",
- "- Convert the date into a month\n",
- "- Calculate the price as the average of the high and low prices\n",
- "- Adjust the price to reflect the cost per bushel quantity\n"
+ "- Only get pumpkins priced by the bushel\n",
+ "- Convert the date to a month\n",
+ "- Calculate the price to be an average of high and low prices\n",
+ "- Convert the price to reflect the pricing by bushel quantity\n"
]
},
{
@@ -377,7 +377,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "A scatterplot reminds us that we only have month data from August through December. We probably need more data to be able to draw conclusions in a linear fashion.\n"
+ "A scatterplot reminds us that we only have data from August through December. We probably need more data to be able to draw conclusions in a linear fashion.\n"
]
},
{
@@ -447,7 +447,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Let's see if there is correlation:\n"
+ ]
},
{
"cell_type": "code",
@@ -535,7 +537,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "For the time being, let's concentrate only on one variety - **pie type**.\n"
+ ]
},
{
"cell_type": "code",
@@ -720,9 +724,9 @@
"source": [
"### Polynomial Regression\n",
"\n",
- "Sometimes the relationship between features and outcomes is naturally non-linear. For instance, pumpkin prices might be high in winter (months=1,2), drop during summer (months=5-7), and then rise again. Linear regression cannot accurately capture this pattern.\n",
+ "Sometimes the relationship between features and the outcomes is inherently non-linear. For example, pumpkin prices might be high in winter (months=1,2), then drop over summer (months=5-7), and then rise again. Linear regression is unable to find this relationship accurately.\n",
"\n",
- "In such cases, we can consider adding additional features. A straightforward approach is to use polynomials derived from the input features, leading to **polynomial regression**. In Scikit Learn, polynomial features can be automatically pre-computed using pipelines:\n"
+ "In this case, we may consider adding extra features. A simple way is to use polynomials of the input features, which would result in **polynomial regression**. In Scikit Learn, we can automatically pre-compute polynomial features using pipelines: \n"
]
},
{
@@ -777,8 +781,11 @@
"score = pipeline.score(X_train,y_train)\n",
"print('Model determination: ', score)\n",
"\n",
- "plt.scatter(X_test,y_test)\n",
- "plt.plot(sorted(X_test),pipeline.predict(sorted(X_test)))"
+ "X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)\n",
+ "y_range = pipeline.predict(X_range)\n",
+ "\n",
+ "plt.scatter(X_test, y_test)\n",
+ "plt.plot(X_range, y_range)"
]
},
{
@@ -787,12 +794,12 @@
"source": [
"### Encoding varieties\n",
"\n",
- "In an ideal scenario, we want to predict prices for different pumpkin varieties using the same model. To account for variety, we first need to convert it into numeric form, or **encode** it. There are several ways to do this:\n",
+ "In the ideal world, we want to be able to predict prices for different pumpkin varieties using the same model. To take variety into account, we first need to convert it to numeric form, or **encode**. There are several ways we can do it:\n",
"\n",
- "* Simple numeric encoding creates a table of different varieties and replaces the variety name with an index from that table. However, this approach is not ideal for linear regression because linear regression interprets the numeric value of the index, and the numeric value likely does not have a meaningful correlation with the price.\n",
- "* One-hot encoding replaces the `Variety` column with 4 separate columns, one for each variety. Each column will contain a 1 if the corresponding row matches the given variety, and a 0 otherwise.\n",
+ "* Simple numeric encoding that will build a table of different varieties, and then replace variety name by an index in that table. This is not the best idea for linear regression, because linear regression takes the numeric value of the index into account, and the numeric value is likely not to correlate numerically with the price.\n",
+ "* One-hot encoding, which will replace `Variety` column by 4 different columns, one for each variety, that will contain 1 if the corresponding row is of given variety, and 0 otherwise.\n",
"\n",
- "The code below demonstrates how to one-hot encode a variety:\n"
+ "The code below shows how we can can one-hot encode a variety:\n"
]
},
{
@@ -940,9 +947,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Linear Regression on Variety\n",
+ "### Linear Regression on Variety \n",
"\n",
- "We will now use the same code as above, but instead of `DayOfYear`, we will use our one-hot-encoded variety as input:\n"
+ "We will now use the same code as above, but instead of `DayOfYear` we will use our one-hot-encoded variety as input:\n"
]
},
{
@@ -1023,7 +1030,7 @@
"source": [
"### Polynomial Regression\n",
"\n",
- "Polynomial regression can also be applied to categorical features that have been one-hot-encoded. The process for training polynomial regression would essentially remain the same as described earlier.\n"
+ "Polynomial regression can also be used with categorical features that are one-hot-encoded. The code to train polynomial regression would essentially be the same as we have seen above.\n"
]
},
{
@@ -1070,7 +1077,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n---\n\n**Disclaimer**: \nThis document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we aim for accuracy, please note that automated translations may include errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is advised. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.\n"
+ "---\n\n\n**Disclaimer**:\nThis 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.\n\n"
]
}
],
@@ -1100,13 +1107,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
- "orig_nbformat": 2,
- "coopTranslator": {
- "original_hash": "d77bd89ae7e79780c68c58bab91f13f8",
- "translation_date": "2025-09-06T15:28:18+00:00",
- "source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
- "language_code": "en"
- }
+ "orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2
diff --git a/translations/en/4-Classification/3-Classifiers-2/solution/notebook.ipynb b/translations/en/4-Classification/3-Classifiers-2/solution/notebook.ipynb
index bf03eede7..7aedd23c7 100644
--- a/translations/en/4-Classification/3-Classifiers-2/solution/notebook.ipynb
+++ b/translations/en/4-Classification/3-Classifiers-2/solution/notebook.ipynb
@@ -7,46 +7,23 @@
"cell_type": "markdown",
"metadata": {}
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Dataset Overview\n",
+ "This dataset contains individual samples (for example, recipes) labeled by cuisine.\n",
+ "Each row corresponds to a single sample/record, and the columns represent ingredients or other attributes used for classification, including the `cuisine` label.\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
- "outputs": [
- {
- "output_type": "execute_result",
- "data": {
- "text/plain": [
- " Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
- "0 0 indian 0 0 0 0 0 \n",
- "1 1 indian 1 0 0 0 0 \n",
- "2 2 indian 0 0 0 0 0 \n",
- "3 3 indian 0 0 0 0 0 \n",
- "4 4 indian 0 0 0 0 0 \n",
- "\n",
- " apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
- "0 0 0 0 ... 0 0 0 \n",
- "1 0 0 0 ... 0 0 0 \n",
- "2 0 0 0 ... 0 0 0 \n",
- "3 0 0 0 ... 0 0 0 \n",
- "4 0 0 0 ... 0 0 0 \n",
- "\n",
- " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
- "0 0 0 0 0 0 0 0 \n",
- "1 0 0 0 0 0 0 0 \n",
- "2 0 0 0 0 0 0 0 \n",
- "3 0 0 0 0 0 0 0 \n",
- "4 0 0 0 0 0 1 0 \n",
- "\n",
- "[5 rows x 382 columns]"
- ],
- "text/html": "\n\n
\n \n \n | \n Unnamed: 0 | \n cuisine | \n almond | \n angelica | \n anise | \n anise_seed | \n apple | \n apple_brandy | \n apricot | \n armagnac | \n ... | \n whiskey | \n white_bread | \n white_wine | \n whole_grain_wheat_flour | \n wine | \n wood | \n yam | \n yeast | \n yogurt | \n zucchini | \n
\n \n \n \n | 0 | \n 0 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 1 | \n 1 | \n indian | \n 1 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 2 | \n 2 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 3 | \n 3 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 4 | \n 4 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 1 | \n 0 | \n
\n \n
\n
5 rows × 382 columns
\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:
+Esto sugiere que debería existir cierta 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:
-
+
Veamos si hay correlación usando la función `corr`:
@@ -129,7 +129,7 @@ print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
-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:
+Parece que la correlación es bastante pequeña, -0.15 para `Mes` y -0.17 para `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 un color diferente. Pasando el parámetro `ax` a la función de grafico `scatter` podemos graficar todos los puntos en el mismo gráfico:
```python
ax=None
@@ -139,42 +139,42 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
-
+
-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:
+Nuestra investigación sugiere que la variedad tiene más efecto sobre el precio total que la fecha real de venta. Podemos ver esto con un gráfico de barras:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
-
+
-Enfoquémonos por ahora solo en una variedad de calabaza, el 'tipo para pay', y veamos qué efecto tiene la fecha en el precio:
+Centrémonos por el momento en una variedad de calabaza, el 'tipo pastel', y veamos qué efecto tiene la fecha en el precio:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
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 tiene sentido entrenar un modelo predictivo.
-> 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:
+> Antes de entrenar un modelo de regresión lineal, es importante asegurarse de que nuestros datos estén limpios. La regresión lineal no funciona bien con valores faltantes, por lo que tiene sentido eliminar todas las celdas vacías:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
-Otra opción sería llenar esos valores vacíos con el valor medio de la columna correspondiente.
+Otra opción sería llenar esos valores vacíos con valores promedio de la columna correspondiente.
-## Regresión Lineal Simple
+## Regresión lineal simple
-[](https://youtu.be/e4c_UP2fSjg "ML para principiantes - Regresión Lineal y Polinomial usando Scikit-learn")
+[](https://youtu.be/e4c_UP2fSjg "ML para principiantes - Regresión lineal y polinómica usando Scikit-learn")
-> 🎥 Haz clic en la imagen de arriba para un video corto que presenta la regresión lineal y polinomial.
+> 🎥 Haz clic en la imagen de arriba para un breve video introductorio sobre regresión lineal y polinómica.
-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
@@ -182,31 +182,31 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
-Comenzamos separando los valores de entrada (características) y la salida esperada (etiqueta) en matrices numpy separadas:
+Comenzamos separando los valores de entrada (características) y la salida esperada (etiqueta) en arreglos numpy separados:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
-> Nota que tuvimos que 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.
+> Ten en cuenta que tuvimos que aplicar `reshape` a los datos de entrada para que el paquete de regresión lineal lo entienda correctamente. La 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, como solo tenemos una entrada, necesitamos un arreglo con forma N×1, donde N es el tamaño del conjunto de datos.
-Luego, necesitamos dividir los datos en conjuntos de entrenamiento y prueba, para poder validar nuestro modelo después de entrenarlo:
+Luego, necesitamos dividir los datos en conjuntos de entrenamiento y prueba para poder validar nuestro modelo después del entrenamiento:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
-Finalmente, entrenar el modelo de Regresión Lineal real toma solo dos líneas de código. Definimos el objeto `LinearRegression`, y lo ajustamos a nuestros datos usando el método `fit`:
+Finalmente, entrenar el modelo real de regresión lineal toma solo dos líneas de código. Definimos el objeto `LinearRegression` y lo ajustamos a nuestros datos usando el método `fit`:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
-El objeto `LinearRegression` después de 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.
+El objeto `LinearRegression` después de haber hecho `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 disminuir un poco con el tiempo, pero no demasiado, alrededor de 2 centavos por día. También podemos acceder al punto de intersección de la regresión con el eje Y usando `lin_reg.intercept_` — que estará alrededor de `21` en nuestro caso, indicando el precio al inicio del año.
-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.
+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 puede hacerse utilizando la métrica root mean square error (RMSE), que es la raíz de la media de todas las diferencias al cuadrado entre los valores esperados y predichos.
```python
pred = lin_reg.predict(X_test)
@@ -215,13 +215,13 @@ 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, 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 es muy bueno. Otro indicador de la calidad del modelo es el **coeficiente de determinación**, que puede obtenerse 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 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.
+Si el valor es 0, significa que el modelo no tiene en cuenta los datos de entrada y actúa como el *peor predictor lineal*, que es simplemente el valor promedio del resultado. Un valor de 1 significa que podemos predecir perfectamente todas las salidas esperadas. 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,19 +232,19 @@ plt.plot(X_test,pred)
-## Regresión Polinómica
+## Regresión polinómica
-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.
+Otro tipo de Regresión Lineal es la Regresión Polinómica. Aunque a veces existe una relación lineal entre variables — cuanto mayor el volumen de la calabaza, mayor el precio — a veces estas relaciones no pueden representarse como un plano o línea recta.
✅ Aquí hay [algunos ejemplos más](https://online.stat.psu.edu/stat501/lesson/9/9.8) de datos que podrían usar 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.
+Observa de nuevo la relación entre Fecha y Precio. ¿Parece que este diagrama de dispersión deba necesariamente analizarse con una línea recta? ¿No pueden fluctuar los precios? En este caso, puedes probar regresión polinómica.
-✅ Los polinomios son expresiones matemáticas que pueden consistir en una o más variables y coeficientes
+✅ Los polinomios son expresiones matemáticas que pueden consistir de una o más variables y coeficientes.
-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.
+La regresión polinómica crea una curva para ajustarse mejor a 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 dentro del año.
-Scikit-learn incluye una útil [API de pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes pasos de procesamiento de datos. Un **pipeline** es una cadena de **estimadores**. En nuestro caso, crearemos un pipeline que primero añade características polinómicas a nuestro modelo, y luego entrena la regresión:
+Scikit-learn incluye una útil [API de pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes pasos 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
@@ -255,36 +255,58 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
-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.
+Usar `PolynomialFeatures(2)` significa que incluiremos todos los polinomios de segundo grado de los datos de entrada. En nuestro caso solo significará `DayOfYear`2, pero dado que tengamos dos variables de entrada X y Y, se añadirá 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 `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 se pueden usar de la misma manera que el objeto original `LinearRegression`, es decir, podemos hacerle `fit` al pipeline y luego usar `predict` para obtener los resultados de la predicción:
+
+```python
+pred = pipeline.predict(X_test)
+
+rmse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
+
+score = pipeline.score(X_train,y_train)
+print('Model determination: ', score)
+```
+
+Para graficar la curva de aproximación suave, usamos `np.linspace` para crear un rango uniforme de valores de entrada, en lugar de graficar directamente los datos de prueba desordenados (lo que produciría una línea zigzagueante):
+
+```python
+X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
+y_range = pipeline.predict(X_range)
+
+plt.scatter(X_test, y_test)
+plt.plot(X_range, y_range)
+```
+
+Aquí está el gráfico que muestra los datos de prueba y la curva de aproximación:
-Usando Regresión Polinómica, podemos obtener un MSE ligeramente más bajo y una determinación más alta, pero no significativamente. ¡Necesitamos tomar en cuenta otras características!
+Usando Regresión Polinómica, podemos obtener un RMSE un poco más bajo y un coeficiente de determinación más alto, pero no significativamente. ¡Necesitamos tener 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 podrías explicar esto?
-🎃 ¡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!
+🎃 ¡Felicidades, acabas de crear un modelo que puede predecir el precio de calabazas para pastel! Probablemente puedas repetir el mismo procedimiento para todos los tipos de calabaza, pero eso sería tedioso. ¡Aprendamos ahora cómo tener en cuenta la variedad de calabaza en nuestro modelo!
-## Características Categóricas
+## 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. 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 y regresión lineal")
-> 🎥 Haz clic en la imagen arriba para un breve video explicativo sobre el uso de características categóricas.
+> 🎥 Haz clic en la imagen arriba para un breve video sobre el uso de características categóricas.
-Aquí puedes ver cómo depende el precio promedio de la variedad:
+Aquí puedes ver cómo el precio promedio depende de la variedad:
-Para tomar en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias maneras de hacerlo:
+Para tener en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias formas de hacerlo:
-* La 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.
+* 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 la mejor idea para regresión lineal, porque la regresión lineal toma el valor numérico real del índice y lo añade 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 nos aseguramos de que los índices estén ordenados de cierta manera.
+* 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` en caso contrario. Esto significa que habrá cuatro coeficientes en la regresión lineal, uno para cada variedad de calabaza, responsable del "precio base" (o más bien "precio adicional") para esa variedad en particular.
-El código a continuación muestra cómo podemos hacer codificación one-hot de una variedad:
+El código abajo muestra cómo podemos codificar one-hot una variedad:
```python
pd.get_dummies(new_pumpkins['Variety'])
@@ -308,7 +330,7 @@ X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
-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`:
+El resto del código es el mismo que usamos arriba para entrenar la Regresión Lineal. Si lo pruebas, verás que el error cuadrático medio es similar, pero obtenemos un coeficiente de determinación mucho mayor (~77%). Para obtener predicciones aún más precisas, podemos tener en cuenta más características categóricas, así como características numéricas, como `Month` o `DayOfYear`. Para obtener un gran arreglo de características, podemos usar `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@@ -318,60 +340,60 @@ 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 un MSE de 2.84 (10%) y una determinación de 0.94!
+Aquí también tomamos en cuenta `City` y tipo de `Package`, lo que nos da un RMSE 2.84 (10.5%) y un coeficiente de determinación de 0.94.
-## Poniéndolo todo junto
+## Juntándolo todo
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 los datos de entrenamiento
+# preparar 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']
-# hacer la división entrenamiento-prueba
+# hacer división de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-# configurar y entrenar el pipeline
+# configurar y entrenar la tubería
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# predecir resultados para los datos de prueba
pred = pipeline.predict(X_test)
-# 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}%)')
+# calcular RMSE y determinación
+rmse = mean_squared_error(y_test, pred, squared=False)
+print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')
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 en la predicción).
+Esto debería darnos el mejor coeficiente de determinación de casi 97% y RMSE=2.23 (~8% de error de predicción).
-| Modelo | MSE | Determinación |
+| Modelo | RMSE | Determinación |
|-------|-----|---------------|
-| 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 |
+| Lineal con `DayOfYear` | 2.77 (17.2%) | 0.07 |
+| Polinómica con `DayOfYear` | 2.73 (17.0%) | 0.08 |
+| Lineal con `Variety` | 5.24 (19.7%) | 0.77 |
+| Lineal con todas las características | 2.84 (10.5%) | 0.94 |
+| Polinómica con todas las características | 2.23 (8.25%) | 0.97 |
-🏆 ¡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.
+🏆 ¡Muy bien! Creaste cuatro modelos de regresión en una lección y mejoraste la calidad del modelo a 97%. En la sección final sobre regresión, aprenderás sobre regresión logística para determinar categorías.
---
## 🚀Desafío
-Prueba varias variables diferentes en este cuaderno para ver cómo la correlación corresponde con la precisión del modelo.
+Prueba con varias variables diferentes en este cuaderno para ver cómo la correlación se corresponde con la precisión del modelo.
-## [Cuestionario post-clase](https://ff-quizzes.netlify.app/en/ml/)
+## [Cuestionario posterior a la clase](https://ff-quizzes.netlify.app/en/ml/)
## Repaso y Autoestudio
-En esta lección aprendimos sobre Regresión Lineal. Hay otros tipos importantes de regresión. Lee sobre las técnicas Stepwise, Ridge, Lasso y Elasticnet. Un buen curso para estudiar y aprender más es el [curso de 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
@@ -381,5 +403,5 @@ En esta lección aprendimos sobre Regresión Lineal. Hay otros tipos importantes
**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.
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la exactitud, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos responsabilizamos por 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/2-Regression/3-Linear/solution/notebook.ipynb b/translations/es/2-Regression/3-Linear/solution/notebook.ipynb
index 3af720ddf..cd5f5a411 100644
--- a/translations/es/2-Regression/3-Linear/solution/notebook.ipynb
+++ b/translations/es/2-Regression/3-Linear/solution/notebook.ipynb
@@ -4,14 +4,14 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## Regresión Lineal y Polinómica para la Fijación de Precios de Calabazas - Lección 3\n",
+ "## Regresión Lineal y Polinómica para el Precio de Calabazas - Lección 3\n",
"\n",
- "Carga las bibliotecas necesarias y el conjunto de datos. Convierte los datos en un dataframe que contenga un subconjunto de los datos:\n",
+ "Carga las librerías y el conjunto de datos requeridos. Convierte los datos a un dataframe que contenga un subconjunto de los datos:\n",
"\n",
- "- Obtén únicamente las calabazas con precios por fanega\n",
- "- Convierte la fecha en un mes\n",
- "- Calcula el precio como un promedio entre los precios altos y bajos\n",
- "- Convierte el precio para que refleje la fijación de precios por cantidad de fanegas\n"
+ "- Obtener solo las calabazas con precio por fanega\n",
+ "- Convertir la fecha a un mes\n",
+ "- Calcular el precio como un promedio de los precios alto y bajo\n",
+ "- Convertir el precio para reflejar el precio por cantidad de fanegas\n"
]
},
{
@@ -377,7 +377,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Un diagrama de dispersión nos recuerda que solo tenemos datos mensuales desde agosto hasta diciembre. Probablemente necesitemos más datos para poder sacar conclusiones de manera lineal.\n"
+ "Un diagrama de dispersión nos recuerda que solo tenemos datos mensuales de agosto a diciembre. Probablemente necesitemos más datos para poder sacar conclusiones de manera lineal.\n"
]
},
{
@@ -447,7 +447,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Veamos si hay correlación:\n"
+ ]
},
{
"cell_type": "code",
@@ -472,7 +474,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Parece que la correlación es bastante pequeña, pero hay alguna otra relación más importante, porque los puntos de precio en el gráfico anterior parecen tener varios grupos distintos. Hagamos un gráfico que muestre las diferentes variedades de calabaza:\n"
+ "Parece que la correlación es bastante pequeña, pero hay alguna otra relación más importante, porque los puntos de precio en el gráfico anterior parecen tener varios grupos distintos. Hagamos un gráfico que muestre diferentes variedades de calabaza:\n"
]
},
{
@@ -535,7 +537,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Por el momento, concentrémonos solo en una variedad: **tipo de tarta**.\n"
+ ]
},
{
"cell_type": "code",
@@ -582,7 +586,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Regresión Lineal\n",
+ "### Regresión lineal\n",
"\n",
"Usaremos Scikit Learn para entrenar un modelo de regresión lineal:\n"
]
@@ -688,7 +692,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Podemos usar el modelo entrenado para predecir el precio:\n"
+ ]
},
{
"cell_type": "code",
@@ -718,9 +724,9 @@
"source": [
"### Regresión Polinómica\n",
"\n",
- "A veces, la relación entre las características y los resultados es inherentemente no lineal. Por ejemplo, los precios de las calabazas podrían ser altos en invierno (meses=1,2), luego bajar en verano (meses=5-7) y después subir nuevamente. La regresión lineal no puede capturar esta relación con precisión.\n",
+ "A veces la relación entre las características y los resultados es inherentemente no lineal. Por ejemplo, los precios de las calabazas pueden ser altos en invierno (meses=1,2), luego caer durante el verano (meses=5-7) y después subir nuevamente. La regresión lineal no puede encontrar esta relación con precisión.\n",
"\n",
- "En este caso, podríamos considerar agregar características adicionales. Una forma sencilla es usar polinomios a partir de las características de entrada, lo que daría lugar a la **regresión polinómica**. En Scikit Learn, podemos precomputar automáticamente las características polinómicas utilizando pipelines:\n"
+ "En este caso, podemos considerar añadir características extra. Una forma sencilla es usar polinomios a partir de las características de entrada, lo que resultaría en una **regresión polinómica**. En Scikit Learn, podemos pre-calcular automáticamente características polinómicas usando pipelines: \n"
]
},
{
@@ -775,22 +781,25 @@
"score = pipeline.score(X_train,y_train)\n",
"print('Model determination: ', score)\n",
"\n",
- "plt.scatter(X_test,y_test)\n",
- "plt.plot(sorted(X_test),pipeline.predict(sorted(X_test)))"
+ "X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)\n",
+ "y_range = pipeline.predict(X_range)\n",
+ "\n",
+ "plt.scatter(X_test, y_test)\n",
+ "plt.plot(X_range, y_range)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Codificación de variedades\n",
+ "### Variedades de codificación\n",
"\n",
- "En un mundo ideal, queremos poder predecir los precios de diferentes variedades de calabazas utilizando el mismo modelo. Para tener en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias maneras de hacerlo:\n",
+ "En un mundo ideal, queremos poder predecir precios para diferentes variedades de calabaza usando el mismo modelo. Para tener en cuenta la variedad, primero necesitamos convertirla a forma numérica, o **codificarla**. Hay varias formas de hacerlo:\n",
"\n",
- "* Codificación numérica simple que construirá una tabla de diferentes variedades y luego reemplazará el nombre de la variedad por un índice en esa tabla. Esta no es la mejor idea para la regresión lineal, porque la regresión lineal toma en cuenta el valor numérico del índice, y es probable que el valor numérico no se correlacione numéricamente con el precio.\n",
- "* Codificación one-hot, que reemplazará la columna `Variety` por 4 columnas diferentes, una para cada variedad, que contendrán 1 si la fila correspondiente es de la variedad dada, y 0 en caso contrario.\n",
+ "* Codificación numérica simple que construirá una tabla de diferentes variedades, y luego reemplazará el nombre de la variedad por un índice en esa tabla. Esta no es la mejor idea para regresión lineal, porque la regresión lineal toma en cuenta el valor numérico del índice, y es probable que el valor numérico no se correlacione numéricamente con el precio.\n",
+ "* Codificación one-hot, que reemplazará la columna `Variety` por 4 columnas diferentes, una para cada variedad, que contendrá 1 si la fila correspondiente es de dicha variedad, y 0 en caso contrario.\n",
"\n",
- "El siguiente código muestra cómo podemos codificar una variedad utilizando one-hot:\n"
+ "El código a continuación muestra cómo podemos codificar una variedad con one-hot:\n"
]
},
{
@@ -938,9 +947,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Regresión Lineal en Variedad\n",
+ "### Regresión lineal sobre la variedad\n",
"\n",
- "Ahora usaremos el mismo código que antes, pero en lugar de `DayOfYear` utilizaremos nuestra variedad codificada en formato one-hot como entrada:\n"
+ "Ahora usaremos el mismo código que arriba, pero en lugar de `DayOfYear` usaremos nuestra variedad codificada en one-hot como entrada:\n"
]
},
{
@@ -1019,9 +1028,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Regresión Polinómica\n",
+ "### Regresión polinómica\n",
"\n",
- "La regresión polinómica también se puede utilizar con características categóricas que están codificadas en formato one-hot. El código para entrenar una regresión polinómica sería esencialmente el mismo que hemos visto anteriormente.\n"
+ "La regresión polinómica también se puede utilizar con características categóricas que están codificadas en one-hot. El código para entrenar la regresión polinómica sería esencialmente el mismo que hemos visto arriba.\n"
]
},
{
@@ -1068,7 +1077,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n---\n\n**Descargo de responsabilidad**: \nEste documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por 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.\n"
+ "---\n\n\n**Descargo de responsabilidad**: \nEste 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 humana. No somos responsables por ningún malentendido o interpretación errónea que surja del uso de esta traducción.\n\n"
]
}
],
@@ -1098,13 +1107,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
- "orig_nbformat": 2,
- "coopTranslator": {
- "original_hash": "d77bd89ae7e79780c68c58bab91f13f8",
- "translation_date": "2025-09-04T01:03:48+00:00",
- "source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
- "language_code": "es"
- }
+ "orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2
diff --git a/translations/es/4-Classification/3-Classifiers-2/solution/notebook.ipynb b/translations/es/4-Classification/3-Classifiers-2/solution/notebook.ipynb
index a0a5282cc..82acc9b4f 100644
--- a/translations/es/4-Classification/3-Classifiers-2/solution/notebook.ipynb
+++ b/translations/es/4-Classification/3-Classifiers-2/solution/notebook.ipynb
@@ -2,51 +2,28 @@
"cells": [
{
"source": [
- "# Construir Más Modelos de Clasificación\n"
+ "# Construir más modelos de clasificación\n"
],
"cell_type": "markdown",
"metadata": {}
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Descripción general del conjunto de datos\n",
+ "Este conjunto de datos contiene muestras individuales (por ejemplo, recetas) etiquetadas por tipo de cocina.\n",
+ "Cada fila corresponde a una única muestra/registro, y las columnas representan ingredientes u otros atributos utilizados para la clasificación, incluyendo la etiqueta `cuisine`.\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
- "outputs": [
- {
- "output_type": "execute_result",
- "data": {
- "text/plain": [
- " Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
- "0 0 indian 0 0 0 0 0 \n",
- "1 1 indian 1 0 0 0 0 \n",
- "2 2 indian 0 0 0 0 0 \n",
- "3 3 indian 0 0 0 0 0 \n",
- "4 4 indian 0 0 0 0 0 \n",
- "\n",
- " apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
- "0 0 0 0 ... 0 0 0 \n",
- "1 0 0 0 ... 0 0 0 \n",
- "2 0 0 0 ... 0 0 0 \n",
- "3 0 0 0 ... 0 0 0 \n",
- "4 0 0 0 ... 0 0 0 \n",
- "\n",
- " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
- "0 0 0 0 0 0 0 0 \n",
- "1 0 0 0 0 0 0 0 \n",
- "2 0 0 0 0 0 0 0 \n",
- "3 0 0 0 0 0 0 0 \n",
- "4 0 0 0 0 0 1 0 \n",
- "\n",
- "[5 rows x 382 columns]"
- ],
- "text/html": "\n\n
\n \n \n | \n Unnamed: 0 | \n cuisine | \n almond | \n angelica | \n anise | \n anise_seed | \n apple | \n apple_brandy | \n apricot | \n armagnac | \n ... | \n whiskey | \n white_bread | \n white_wine | \n whole_grain_wheat_flour | \n wine | \n wood | \n yam | \n yeast | \n yogurt | \n zucchini | \n
\n \n \n \n | 0 | \n 0 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 1 | \n 1 | \n indian | \n 1 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 2 | \n 2 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 3 | \n 3 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 4 | \n 4 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 1 | \n 0 | \n
\n \n
\n
5 rows × 382 columns
\n
-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 :
+Cela suggère qu'il y a une 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 montrant cette dernière relation :
-
+
-Voyons s’il existe une corrélation en utilisant la fonction `corr` :
+Voyons s'il existe une corrélation avec 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 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 :
+La corrélation semble assez faible, -0,15 selon `Month` et -0,17 selon `DayOfYear`, 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 tracer 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 réelle de vente. Nous pouvons le voir avec un graphique en barres :
+Notre enquête suggère que la variété influence davantage le prix global que la date de vente. Nous pouvons le voir avec un graphique à barres :
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
-
+
-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 :
+Concentrons-nous pour le moment sur une seule variété de citrouilles, le 'pie type', 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 obtiendrons environ `-0.27` — ce qui signifie que l’entraînement d’un modèle prédictif est pertinent.
+En calculant la corrélation entre `Price` et `DayOfYear` avec la fonction `corr`, on obtient environ `-0.27` — ce qui indique qu'entraîner un modèle prédictif a du sens.
-> Avant d’entraîner un modèle de régression linéaire, il est important de s’assurer que nos données sont propres. La régression linéaire ne fonctionne pas bien avec des valeurs manquantes, il est donc judicieux de supprimer 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 logique de supprimer toutes les cellules vides :
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
-Une autre approche serait de remplir ces valeurs vides avec la moyenne des valeurs de la colonne correspondante.
+Une autre approche serait de remplir ces valeurs manquantes avec la moyenne de la colonne correspondante.
## 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 pour débutants - Régression linéaire et polynomiale avec Scikit-learn")
-> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo introductive sur la régression linéaire et polynomiale.
+> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo de présentation de la régression linéaire et polynomiale.
-Pour entraîner notre modèle de régression linéaire, nous utiliserons la bibliothèque **Scikit-learn**.
+Pour entraîner notre modèle de régression linéaire, nous allons utiliser la bibliothèque **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
@@ -183,31 +183,31 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
-Nous commençons par séparer les valeurs d'entrée (features) et la sortie attendue (label) dans des tableaux numpy distincts :
+Nous commençons par séparer les valeurs d'entrée (caractéristiques) et la sortie attendue (étiquette) en tableaux numpy distincts :
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
-> Notez que nous avons dû effectuer un `reshape` sur les données d'entrée 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.
+> Notez que nous avons dû appliquer un `reshape` aux 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 correspond à un vecteur de caractéristiques. Dans notre cas, n'ayant qu'une seule entrée, nous avons besoin d'un tableau de forme N×1, où N est la taille du jeu de données.
-Ensuite, nous devons diviser les données en ensembles d'entraînement et de test, afin de pouvoir valider notre modèle après l’entraînement :
+Ensuite, 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`, et l'appliquons à nos données avec la méthode `fit` :
+Enfin, l'entraînement du modèle de régression linéaire effectif ne prend que deux lignes de code. Nous définissons l'objet `LinearRegression`, puis l'ajustons à nos données avec la méthode `fit` :
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
-L'objet `LinearRegression` après 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.
+L'objet `LinearRegression` après l'entraînement (`fit`) contient tous les coefficients de la régression, auxquels on peut accéder grâce à 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 un peu 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 Y en utilisant `lin_reg.intercept_` - il sera d'environ `21` dans notre cas, indiquant le prix au début de l'année.
-Pour voir 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.
+Pour voir à quel point notre modèle est précis, nous pouvons prédire les prix sur un jeu de données de test, puis mesurer à quel point nos prédictions sont proches des valeurs attendues. Cela peut être fait en utilisant la métrique de l'erreur quadratique moyenne (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)
@@ -216,15 +216,15 @@ 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 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 :
+Notre erreur semble être autour de 2 points, ce qui représente environ 17 %. Pas très bon. Un autre indicateur de la qualité du modèle est le **coefficient de détermination**, qui peut être obtenu comme ceci :
```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 la moyenne des résultats. La valeur de 1 signifie que nous pouvons parfaitement prédire toutes les sorties attendues. Dans notre cas, le coefficient est d'environ 0,06, ce qui est assez faible.
-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 :
+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 :
```python
plt.scatter(X_test,y_test)
@@ -235,17 +235,17 @@ plt.plot(X_test,pred)
## Régression Polynomiale
-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.
+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 volumineuse, plus son prix est élevé - mais 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 utiliser la régression polynomiale.
+✅ Voici [quelques exemples supplémentaires](https://online.stat.psu.edu/stat501/lesson/9/9.8) de données qui pourraient bénéficier d'une 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.
+Regardez à nouveau la relation entre la Date et le Prix. Est-ce que ce nuage de points semble devoir être nécessairement 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 comporter une ou plusieurs variables et coefficients.
+✅ Les polynômes sont des expressions mathématiques qui peuvent contenir une ou plusieurs variables et coefficients.
-La régression polynomiale crée une courbe pour mieux ajuster 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.
+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 `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 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 :
+Scikit-learn inclut une API [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) utile pour combiner différentes étapes de traitement des données. Un **pipeline** est une chaîne d'**estimateurs**. Dans notre cas, nous allons créer un pipeline qui ajoute d'abord des caractéristiques polynomiales à notre modèle, puis entraîne la régression :
```python
from sklearn.preprocessing import PolynomialFeatures
@@ -256,36 +256,58 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
-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.
+Utiliser `PolynomialFeatures(2)` signifie que nous incluons tous les polynômes de degré 2 issus des données d’entrée. Dans notre cas cela signifie juste `DayOfYear`2, mais avec deux variables X et Y, cela ajouterait X2, XY et Y2. On peut aussi utiliser des polynômes de degré supérieur si on le souhaite.
+
+Les pipelines peuvent être utilisés de la même manière que l'objet `LinearRegression` d'origine, c’est-à-dire que nous pouvons `fit` le pipeline, puis utiliser `predict` pour obtenir les résultats de la prédiction :
+
+```python
+pred = pipeline.predict(X_test)
+
+rmse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
+
+score = pipeline.score(X_train,y_train)
+print('Model determination: ', score)
+```
+
+Pour tracer la courbe d'approximation lisse, nous utilisons `np.linspace` pour créer une plage uniforme de valeurs d'entrée, plutôt que de tracer directement sur des données de test non ordonnées (ce qui produirait une ligne en zigzag) :
+
+```python
+X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
+y_range = pipeline.predict(X_range)
+
+plt.scatter(X_test, y_test)
+plt.plot(X_range, y_range)
+```
-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 :
+Voici le graphique montrant les données de test ainsi que la courbe d'approximation :
-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 !
+Avec la régression polynomiale, on obtient un RMSE légèrement plus bas et un coefficient de détermination plus élevé, mais pas de manière significative. Il faut prendre en compte d’autres caractéristiques !
-> Vous pouvez voir que les prix minimaux des citrouilles sont observés vers Halloween. Comment expliquer cela ?
+> Vous pouvez voir que les prix minimums des citrouilles sont observés autour d'Halloween. Comment pouvez-vous expliquer cela ?
-🎃 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 !
+🎃 Félicitations, vous venez de créer un modèle qui peut aider à prédire le prix des citrouilles à pâtisserie. Vous pouvez probablement répéter la même procédure pour tous les types de citrouilles, mais ce serait fastidieux. Apprenons maintenant comment prendre en compte la variété de citrouille dans notre modèle !
-## Caractéristiques Catégoriques
+## Caractéristiques 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**.
+Dans un monde idéal, nous voulons pouvoir prédire les prix pour différentes variétés de citrouilles en utilisant le même modèle. Cependant, la colonne `Variety` est quelque peu différente des colonnes comme `Month`, car elle contient des valeurs non numériques. Ces colonnes sont appelées **caté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égoriques.
+> 🎥 Cliquez sur l’image ci-dessus pour une courte vidéo présentant l’utilisation des caractéristiques catégorielles.
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, c'est-à-dire **l'encoder**. Plusieurs méthodes existent :
+Pour prendre la variété en compte, il faut d’abord la convertir en forme numérique, ou **l’encoder**. Il y a plusieurs façons de faire :
-* 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.
+* Un simple **encodage numérique** construira un tableau des différentes variétés, puis remplacera le nom de la variété par un indice dans ce tableau. Ce n’est pas une bonne idée pour la régression linéaire, car la régression linéaire prend la valeur numérique réelle de l’indice et l’ajoute au résultat en la multipliant par un coefficient. Dans notre cas, la relation entre le numéro d’indice et le prix est clairement non linéaire, même si nous nous assurons que les indices sont ordonnés d’une certaine façon spécifique.
+* L’**encodage one-hot** remplacera la colonne `Variety` par 4 colonnes différentes, une pour chaque variété. Chaque colonne contiendra `1` si la ligne correspondante est de 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, responsable du "prix de départ" (ou plutôt "prix supplémentaire") pour cette variété particulière.
-Le code ci-dessous montre comment appliquer un encodage one-hot à une variété :
+Le code suivant montre comment encoder une variété en one-hot :
```python
pd.get_dummies(new_pumpkins['Variety'])
@@ -302,14 +324,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
-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` :
+Pour entraîner la régression linéaire en utilisant la variété codée en one-hot comme entrée, il suffit d’initialiser correctement les données `X` et `y` :
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
-Le reste du code est 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` :
+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 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, nous pouvons prendre en compte d’autres caractéristiques catégorielles, ainsi que des caractéristiques numériques, telles que `Month` ou `DayOfYear`. Pour obtenir un grand tableau de caractéristiques, on peut utiliser `join` :
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@@ -319,68 +341,68 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
-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 !
+Ici, nous prenons également en compte `City` et le type de `Package`, ce qui nous donne un RMSE de 2.84 (10.5 %) et un coefficient de détermination de 0.94 !
-## Tout mettre ensemble
+## Tout regrouper
-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é :
+Pour faire 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
-# préparer les données d'entraînement
+# configurer les données d'entraînement
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
-# effectuer la séparation train-test
+# faire la séparation train-test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-# configurer et entraîner le pipeline
+# configurer et entraîner la pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# prédire les résultats pour les données de test
pred = pipeline.predict(X_test)
-# calculer la MSE et le coefficient de détermination
-mse = np.sqrt(mean_squared_error(y_test,pred))
-print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+# calculer la RMSE et la détermination
+rmse = mean_squared_error(y_test, pred, squared=False)
+print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
-Cela devrait nous donner le meilleur coefficient de détermination à presque 97 %, et un MSE de 2.23 (~8 % d’erreur de prédiction).
+Cela devrait nous donner le meilleur coefficient de détermination d’environ 97 %, et un RMSE=2.23 (~8 % d’erreur de prédiction).
-| Modèle | MSE | Détermination |
+| Modèle | RMSE | Détermination |
|-------|-----|---------------|
-| 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 |
+| Linéaire `DayOfYear` | 2.77 (17.2 %) | 0.07 |
+| Polynômiale `DayOfYear` | 2.73 (17.0 %) | 0.08 |
+| Linéaire `Variety` | 5.24 (19.7 %) | 0.77 |
+| Linéaire toutes caractéristiques | 2.84 (10.5 %) | 0.94 |
+| Polynômiale toutes caractéristiques | 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é de 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
-Testez plusieurs variables différentes dans ce notebook pour voir comment la corrélation correspond à la précision du modèle.
+Testez plusieurs variables différentes dans ce carnet pour voir comment la corrélation correspond à la précision du modèle.
## [Quiz post-cours](https://ff-quizzes.netlify.app/en/ml/)
-## Revue & Auto-Étude
+## Revue & Autoapprentissage
-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 à étudier pour en apprendre davantage est le [cours de Stanford sur l'apprentissage statistique](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Devoir
-[Construisez un modèle](assignment.md)
+[Construire un modèle](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 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.
+Ce document a été traduit à l’aide du service de traduction automatisée [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, une traduction professionnelle humaine est recommandée. Nous ne saurions être tenus responsables des malentendus ou des interprétations erronées résultant de l’utilisation de cette traduction.
\ No newline at end of file
diff --git a/translations/fr/2-Regression/3-Linear/solution/notebook.ipynb b/translations/fr/2-Regression/3-Linear/solution/notebook.ipynb
index a84894dc7..2beb80ac7 100644
--- a/translations/fr/2-Regression/3-Linear/solution/notebook.ipynb
+++ b/translations/fr/2-Regression/3-Linear/solution/notebook.ipynb
@@ -6,12 +6,12 @@
"source": [
"## Régression linéaire et polynomiale pour la tarification des citrouilles - Leçon 3\n",
"\n",
- "Chargez les bibliothèques nécessaires et le jeu de données. Convertissez les données en un dataframe contenant un sous-ensemble des données :\n",
+ "Chargez les bibliothèques et le jeu de données requis. Convertissez les données en un dataframe contenant un sous-ensemble des données :\n",
"\n",
- "- Ne sélectionnez que les citrouilles dont le prix est indiqué par boisseau\n",
- "- Convertissez la date en mois\n",
- "- Calculez le prix comme une moyenne des prix élevés et bas\n",
- "- Convertissez le prix pour qu'il reflète la tarification par quantité de boisseaux\n"
+ "- Ne prendre que les citrouilles tarifées au boisseau\n",
+ "- Convertir la date en mois\n",
+ "- Calculer le prix comme une moyenne des prix haut et bas\n",
+ "- Convertir le prix pour refléter la tarification par quantité de boisseaux\n"
]
},
{
@@ -377,7 +377,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Un nuage de points nous rappelle que nous n'avons des données mensuelles que d'août à décembre. Nous avons probablement besoin de plus de données pour pouvoir tirer des conclusions de manière linéaire.\n"
+ "Un nuage de points nous rappelle que nous n'avons des données que de août à décembre. Nous avons probablement besoin de plus de données pour pouvoir tirer des conclusions de manière linéaire.\n"
]
},
{
@@ -447,7 +447,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Voyons s'il y a une corrélation :\n"
+ ]
},
{
"cell_type": "code",
@@ -472,7 +474,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Il semble que la corrélation soit assez faible, mais il existe une autre relation plus importante - car les points de prix dans le graphique ci-dessus semblent former plusieurs groupes distincts. Faisons un graphique qui montrera différentes variétés de citrouilles :\n"
+ "On dirait que la corrélation est assez faible, mais il existe une autre relation plus importante - car les points de prix dans le graphique ci-dessus semblent avoir plusieurs clusters distincts. Faisons un graphique qui montrera différentes variétés de citrouilles :\n"
]
},
{
@@ -535,7 +537,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Pour le moment, concentrons-nous uniquement sur une variété - **type de tarte**.\n"
+ ]
},
{
"cell_type": "code",
@@ -582,7 +586,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Régression Linéaire\n",
+ "### Régression linéaire\n",
"\n",
"Nous allons utiliser Scikit Learn pour entraîner un modèle de régression linéaire :\n"
]
@@ -662,7 +666,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "La pente de la ligne peut être déterminée à partir des coefficients de régression linéaire :\n"
+ "La pente de la droite peut être déterminée à partir des coefficients de régression linéaire :\n"
]
},
{
@@ -688,7 +692,9 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": []
+ "source": [
+ "Nous pouvons utiliser le modèle entraîné pour prédire le prix :\n"
+ ]
},
{
"cell_type": "code",
@@ -718,9 +724,9 @@
"source": [
"### Régression polynomiale\n",
"\n",
- "Parfois, la relation entre les caractéristiques et les résultats est intrinsèquement non linéaire. Par exemple, les prix des citrouilles peuvent être élevés en hiver (mois=1,2), puis baisser en été (mois=5-7), avant de remonter. La régression linéaire ne peut pas identifier cette relation avec précision.\n",
+ "Parfois, la relation entre les caractéristiques et les résultats est intrinsèquement non linéaire. Par exemple, les prix des citrouilles peuvent être élevés en hiver (mois=1,2), puis baisser en été (mois=5-7), puis remonter à nouveau. La régression linéaire est incapable de trouver cette relation avec précision.\n",
"\n",
- "Dans ce cas, nous pouvons envisager d'ajouter des caractéristiques supplémentaires. Une méthode simple consiste à utiliser des polynômes à partir des caractéristiques d'entrée, ce qui aboutirait à une **régression polynomiale**. Dans Scikit Learn, nous pouvons pré-calculer automatiquement les caractéristiques polynomiales en utilisant des pipelines :\n"
+ "Dans ce cas, nous pouvons envisager d'ajouter des caractéristiques supplémentaires. Une façon simple est d'utiliser des polynômes des caractéristiques d'entrée, ce qui entraînerait une **régression polynomiale**. Dans Scikit Learn, nous pouvons pré-calculer automatiquement les caractéristiques polynomiales à l'aide de pipelines : \n"
]
},
{
@@ -775,20 +781,23 @@
"score = pipeline.score(X_train,y_train)\n",
"print('Model determination: ', score)\n",
"\n",
- "plt.scatter(X_test,y_test)\n",
- "plt.plot(sorted(X_test),pipeline.predict(sorted(X_test)))"
+ "X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)\n",
+ "y_range = pipeline.predict(X_range)\n",
+ "\n",
+ "plt.scatter(X_test, y_test)\n",
+ "plt.plot(X_range, y_range)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Encodage des variétés\n",
+ "### Variétés d'encodage\n",
"\n",
- "Dans un monde idéal, nous voudrions pouvoir prédire les prix de différentes variétés de citrouilles en utilisant le même modèle. Pour prendre en compte la variété, nous devons d'abord la convertir en une forme numérique, ou **encoder**. Il existe plusieurs façons de le faire :\n",
+ "Dans un monde idéal, nous voulons pouvoir prédire les prix pour différentes variétés de citrouille en utilisant le même modèle. Pour prendre en compte la variété, nous devons d'abord la convertir en forme numérique, ou **encoder**. Il existe plusieurs façons de le faire :\n",
"\n",
- "* Un encodage numérique simple qui construit une table des différentes variétés, puis remplace le nom de la variété par un indice dans cette table. Ce n'est pas la meilleure idée pour une régression linéaire, car la régression linéaire prend en compte la valeur numérique de l'indice, et cette valeur numérique n'est probablement pas corrélée de manière significative avec le prix.\n",
- "* Un encodage one-hot, qui remplacera la colonne `Variety` par 4 colonnes différentes, une pour chaque variété, contenant 1 si la ligne correspondante est de la variété donnée, et 0 sinon.\n",
+ "* Encodage numérique simple qui construira un tableau des différentes variétés, puis remplacera 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 en compte la valeur numérique de l'indice, et cette valeur numérique ne sera probablement pas corrélée numériquement avec le prix.\n",
+ "* Encodage one-hot, qui remplacera la colonne `Variety` par 4 colonnes différentes, une pour chaque variété, qui contiendra 1 si la ligne correspondante est de la variété donnée, et 0 sinon.\n",
"\n",
"Le code ci-dessous montre comment nous pouvons encoder une variété en one-hot :\n"
]
@@ -938,9 +947,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Régression linéaire sur les variétés\n",
+ "### Régression linéaire sur la variété\n",
"\n",
- "Nous allons maintenant utiliser le même code que précédemment, mais au lieu de `DayOfYear`, nous utiliserons notre variété encodée en one-hot comme entrée :\n"
+ "Nous allons maintenant utiliser le même code que ci-dessus, mais au lieu de `DayOfYear`, nous utiliserons notre variété encodée en one-hot comme entrée :\n"
]
},
{
@@ -988,7 +997,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Nous pouvons également essayer d'utiliser d'autres fonctionnalités de la même manière, et de les combiner avec des fonctionnalités numériques, telles que `Month` ou `DayOfYear` :\n"
+ "Nous pouvons également essayer d'utiliser d'autres fonctionnalités de la même manière, et les combiner avec des fonctionnalités numériques, telles que `Month` ou `DayOfYear` :\n"
]
},
{
@@ -1021,7 +1030,7 @@
"source": [
"### Régression polynomiale\n",
"\n",
- "La régression polynomiale peut également être utilisée avec des caractéristiques catégorielles qui sont encodées en one-hot. Le code pour entraîner une régression polynomiale serait essentiellement le même que celui que nous avons vu précédemment.\n"
+ "La régression polynomiale peut également être utilisée avec des variables catégorielles encodées en one-hot. Le code pour entraîner une régression polynomiale serait essentiellement le même que celui que nous avons vu ci-dessus.\n"
]
},
{
@@ -1068,7 +1077,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n---\n\n**Avertissement** : \nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de faire appel à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.\n"
+ "---\n\n\n**Avis de non-responsabilité** : \nCe document a été traduit à l’aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant foi. Pour les informations critiques, une traduction professionnelle humaine est recommandée. Nous n’assumons aucune responsabilité pour tout malentendu ou mauvaise interprétation résultant de l’utilisation de cette traduction.\n\n"
]
}
],
@@ -1098,13 +1107,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
- "orig_nbformat": 2,
- "coopTranslator": {
- "original_hash": "d77bd89ae7e79780c68c58bab91f13f8",
- "translation_date": "2025-09-04T01:02:38+00:00",
- "source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
- "language_code": "fr"
- }
+ "orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2
diff --git a/translations/fr/4-Classification/3-Classifiers-2/solution/notebook.ipynb b/translations/fr/4-Classification/3-Classifiers-2/solution/notebook.ipynb
index 2cc7f778e..6012e0be1 100644
--- a/translations/fr/4-Classification/3-Classifiers-2/solution/notebook.ipynb
+++ b/translations/fr/4-Classification/3-Classifiers-2/solution/notebook.ipynb
@@ -2,51 +2,28 @@
"cells": [
{
"source": [
- "# Construire Plus de Modèles de Classification\n"
+ "# Construire plus de modèles de classification\n"
],
"cell_type": "markdown",
"metadata": {}
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Vue d'ensemble du jeu de données\n",
+ "Ce jeu de données contient des échantillons individuels (par exemple, des recettes) étiquetés par type de cuisine.\n",
+ "Chaque ligne correspond à un échantillon/enregistrement unique, et les colonnes représentent les ingrédients ou d'autres attributs utilisés pour la classification, y compris l'étiquette `cuisine`.\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
- "outputs": [
- {
- "output_type": "execute_result",
- "data": {
- "text/plain": [
- " Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
- "0 0 indian 0 0 0 0 0 \n",
- "1 1 indian 1 0 0 0 0 \n",
- "2 2 indian 0 0 0 0 0 \n",
- "3 3 indian 0 0 0 0 0 \n",
- "4 4 indian 0 0 0 0 0 \n",
- "\n",
- " apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
- "0 0 0 0 ... 0 0 0 \n",
- "1 0 0 0 ... 0 0 0 \n",
- "2 0 0 0 ... 0 0 0 \n",
- "3 0 0 0 ... 0 0 0 \n",
- "4 0 0 0 ... 0 0 0 \n",
- "\n",
- " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
- "0 0 0 0 0 0 0 0 \n",
- "1 0 0 0 0 0 0 0 \n",
- "2 0 0 0 0 0 0 0 \n",
- "3 0 0 0 0 0 0 0 \n",
- "4 0 0 0 0 0 1 0 \n",
- "\n",
- "[5 rows x 382 columns]"
- ],
- "text/html": "\n\n
\n \n \n | \n Unnamed: 0 | \n cuisine | \n almond | \n angelica | \n anise | \n anise_seed | \n apple | \n apple_brandy | \n apricot | \n armagnac | \n ... | \n whiskey | \n white_bread | \n white_wine | \n whole_grain_wheat_flour | \n wine | \n wood | \n yam | \n yeast | \n yogurt | \n zucchini | \n
\n \n \n \n | 0 | \n 0 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 1 | \n 1 | \n indian | \n 1 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 2 | \n 2 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 3 | \n 3 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n
\n \n | 4 | \n 4 | \n indian | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n ... | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 0 | \n 1 | \n 0 | \n
\n \n
\n
5 rows × 382 columns
\n