[en,fr,es] chore(i18n): sync translations

Sync translations with latest source changes.
Languages: English [en], French [fr], Spanish [es]
update-translations
localizeflow[bot] 1 month ago
parent 2b680fd003
commit f0cdcbc2fa

@ -101,6 +101,12 @@
"source_file": "8-Reinforcement/2-Gym/images/cartpole.png",
"language_code": "en"
},
"catplot.e73fc35fdf96242b.webp": {
"original_hash": "90cd4782a2f9b40dec8218b224b29c1c",
"translation_date": "2026-07-13T23:33:54+00:00",
"source_file": "2-Regression/2-Data/images/catplot.png",
"language_code": "en"
},
"centroid.097fde836cf6c918.webp": {
"original_hash": "c8f866ed446563d8e59087f1bca1f97d",
"translation_date": "2026-01-16T07:51:28+00:00",
@ -383,6 +389,12 @@
"source_file": "2-Regression/3-Linear/images/heatmap.png",
"language_code": "en"
},
"heatmap.bd98dce43b404c57.webp": {
"original_hash": "7f2f2fbd993018bc01346e1eb8ae692e",
"translation_date": "2026-07-13T23:34:07+00:00",
"source_file": "2-Regression/2-Data/images/heatmap.png",
"language_code": "en"
},
"hierarchical.bf59403aa43c8c47.webp": {
"original_hash": "50b9bc3298659c463ae76564ca645b12",
"translation_date": "2026-01-16T07:51:11+00:00",
@ -473,6 +485,12 @@
"source_file": "2-Regression/3-Linear/images/linear.png",
"language_code": "en"
},
"lineplot.f9034ba47b1e30ee.webp": {
"original_hash": "b3959c0ed0f02f668009c76b95c4ebbb",
"translation_date": "2026-07-13T23:34:14+00:00",
"source_file": "2-Regression/2-Data/images/lineplot.png",
"language_code": "en"
},
"lobe.2fa0806408ef9923.webp": {
"original_hash": "e6ec71dbe350aef39135dbf88bc89163",
"translation_date": "2026-01-16T07:48:44+00:00",
@ -743,6 +761,12 @@
"source_file": "2-Regression/3-Linear/images/recipes.png",
"language_code": "en"
},
"relplot.a03837d8f0329cec.webp": {
"original_hash": "4733544cb1c2e58e987087283e66b4a5",
"translation_date": "2026-07-13T23:33:59+00:00",
"source_file": "2-Regression/2-Data/images/relplot.png",
"language_code": "en"
},
"scaled.91897dfbaa26ca4a.webp": {
"original_hash": "789c70fafe6f6dd6e377a90b66e7d740",
"translation_date": "2026-01-16T08:00:06+00:00",

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 7.4 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.4 KiB

@ -101,6 +101,12 @@
"source_file": "8-Reinforcement/2-Gym/images/cartpole.png",
"language_code": "es"
},
"catplot.e73fc35fdf96242b.webp": {
"original_hash": "90cd4782a2f9b40dec8218b224b29c1c",
"translation_date": "2026-07-13T23:33:57+00:00",
"source_file": "2-Regression/2-Data/images/catplot.png",
"language_code": "es"
},
"centroid.097fde836cf6c918.webp": {
"original_hash": "c8f866ed446563d8e59087f1bca1f97d",
"translation_date": "2026-01-16T07:51:34+00:00",
@ -383,6 +389,12 @@
"source_file": "2-Regression/3-Linear/images/heatmap.png",
"language_code": "es"
},
"heatmap.bd98dce43b404c57.webp": {
"original_hash": "7f2f2fbd993018bc01346e1eb8ae692e",
"translation_date": "2026-07-13T23:34:12+00:00",
"source_file": "2-Regression/2-Data/images/heatmap.png",
"language_code": "es"
},
"hierarchical.bf59403aa43c8c47.webp": {
"original_hash": "50b9bc3298659c463ae76564ca645b12",
"translation_date": "2026-01-16T07:51:19+00:00",
@ -473,6 +485,12 @@
"source_file": "2-Regression/3-Linear/images/linear.png",
"language_code": "es"
},
"lineplot.f9034ba47b1e30ee.webp": {
"original_hash": "b3959c0ed0f02f668009c76b95c4ebbb",
"translation_date": "2026-07-13T23:34:17+00:00",
"source_file": "2-Regression/2-Data/images/lineplot.png",
"language_code": "es"
},
"lobe.2fa0806408ef9923.webp": {
"original_hash": "e6ec71dbe350aef39135dbf88bc89163",
"translation_date": "2026-01-16T07:48:58+00:00",
@ -743,6 +761,12 @@
"source_file": "2-Regression/3-Linear/images/recipes.png",
"language_code": "es"
},
"relplot.a03837d8f0329cec.webp": {
"original_hash": "4733544cb1c2e58e987087283e66b4a5",
"translation_date": "2026-07-13T23:34:04+00:00",
"source_file": "2-Regression/2-Data/images/relplot.png",
"language_code": "es"
},
"scaled.91897dfbaa26ca4a.webp": {
"original_hash": "789c70fafe6f6dd6e377a90b66e7d740",
"translation_date": "2026-01-16T08:00:08+00:00",

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 7.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.4 KiB

@ -101,6 +101,12 @@
"source_file": "8-Reinforcement/2-Gym/images/cartpole.png",
"language_code": "fr"
},
"catplot.e73fc35fdf96242b.webp": {
"original_hash": "90cd4782a2f9b40dec8218b224b29c1c",
"translation_date": "2026-07-13T23:33:55+00:00",
"source_file": "2-Regression/2-Data/images/catplot.png",
"language_code": "fr"
},
"centroid.097fde836cf6c918.webp": {
"original_hash": "c8f866ed446563d8e59087f1bca1f97d",
"translation_date": "2026-01-16T07:51:32+00:00",
@ -383,6 +389,12 @@
"source_file": "2-Regression/3-Linear/images/heatmap.png",
"language_code": "fr"
},
"heatmap.bd98dce43b404c57.webp": {
"original_hash": "7f2f2fbd993018bc01346e1eb8ae692e",
"translation_date": "2026-07-13T23:34:10+00:00",
"source_file": "2-Regression/2-Data/images/heatmap.png",
"language_code": "fr"
},
"hierarchical.bf59403aa43c8c47.webp": {
"original_hash": "50b9bc3298659c463ae76564ca645b12",
"translation_date": "2026-01-16T07:51:15+00:00",
@ -473,6 +485,12 @@
"source_file": "2-Regression/3-Linear/images/linear.png",
"language_code": "fr"
},
"lineplot.f9034ba47b1e30ee.webp": {
"original_hash": "b3959c0ed0f02f668009c76b95c4ebbb",
"translation_date": "2026-07-13T23:34:16+00:00",
"source_file": "2-Regression/2-Data/images/lineplot.png",
"language_code": "fr"
},
"lobe.2fa0806408ef9923.webp": {
"original_hash": "e6ec71dbe350aef39135dbf88bc89163",
"translation_date": "2026-01-16T07:48:51+00:00",
@ -743,6 +761,12 @@
"source_file": "2-Regression/3-Linear/images/recipes.png",
"language_code": "fr"
},
"relplot.a03837d8f0329cec.webp": {
"original_hash": "4733544cb1c2e58e987087283e66b4a5",
"translation_date": "2026-07-13T23:34:02+00:00",
"source_file": "2-Regression/2-Data/images/relplot.png",
"language_code": "fr"
},
"scaled.91897dfbaa26ca4a.webp": {
"original_hash": "789c70fafe6f6dd6e377a90b66e7d740",
"translation_date": "2026-01-16T08:00:07+00:00",

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.5 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 7.1 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.4 KiB

@ -24,8 +24,8 @@
"language_code": "en"
},
"1-Introduction/3-fairness/README.md": {
"original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
"translation_date": "2025-09-06T10:53:05+00:00",
"original_hash": "0f00d72169a0d37eecfd16d71e01700a",
"translation_date": "2026-07-13T23:20:31+00:00",
"source_file": "1-Introduction/3-fairness/README.md",
"language_code": "en"
},
@ -54,8 +54,8 @@
"language_code": "en"
},
"2-Regression/1-Tools/README.md": {
"original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
"translation_date": "2025-09-06T10:46:54+00:00",
"original_hash": "0b8635427b582d03ea4ab7089b93e505",
"translation_date": "2026-07-13T23:17:54+00:00",
"source_file": "2-Regression/1-Tools/README.md",
"language_code": "en"
},
@ -72,8 +72,8 @@
"language_code": "en"
},
"2-Regression/2-Data/README.md": {
"original_hash": "7c077988328ebfe33b24d07945f16eca",
"translation_date": "2025-09-06T10:47:29+00:00",
"original_hash": "a58b2c4d16c6b122643391745ac15af6",
"translation_date": "2026-07-13T23:18:34+00:00",
"source_file": "2-Regression/2-Data/README.md",
"language_code": "en"
},
@ -89,6 +89,12 @@
"source_file": "2-Regression/2-Data/solution/Julia/README.md",
"language_code": "en"
},
"2-Regression/2-Data/solution/notebook.ipynb": {
"original_hash": "96b95f8cf473481f2f371de8156f1571",
"translation_date": "2026-07-13T23:15:00+00:00",
"source_file": "2-Regression/2-Data/solution/notebook.ipynb",
"language_code": "en"
},
"2-Regression/3-Linear/README.md": {
"original_hash": "8b776e731c35b171d316d01d0e7b1369",
"translation_date": "2026-04-26T18:31:36+00:00",
@ -457,7 +463,7 @@
},
"8-Reinforcement/1-QLearning/README.md": {
"original_hash": "911efd5e595089000cb3c16fce1beab8",
"translation_date": "2025-09-06T10:59:08+00:00",
"translation_date": "2026-07-13T23:19:14+00:00",
"source_file": "8-Reinforcement/1-QLearning/README.md",
"language_code": "en"
},
@ -481,7 +487,7 @@
},
"8-Reinforcement/2-Gym/README.md": {
"original_hash": "107d5bb29da8a562e7ae72262d251a75",
"translation_date": "2025-09-06T10:59:45+00:00",
"translation_date": "2026-07-13T23:19:55+00:00",
"source_file": "8-Reinforcement/2-Gym/README.md",
"language_code": "en"
},
@ -601,7 +607,7 @@
},
"sketchnotes/LICENSE.md": {
"original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
"translation_date": "2025-09-06T10:58:18+00:00",
"translation_date": "2026-07-13T23:17:21+00:00",
"source_file": "sketchnotes/LICENSE.md",
"language_code": "en"
},

@ -1,28 +1,28 @@
# Building Machine Learning solutions with responsible AI
![Summary of responsible AI in Machine Learning in a sketchnote](../../../../sketchnotes/ml-fairness.png)
![Summary of responsible AI in Machine Learning in a sketchnote](../../../../translated_images/en/ml-fairness.ef296ebec6afc98a.webp)
> Sketchnote by [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Introduction
In this curriculum, you will begin to explore how machine learning is shaping and influencing our daily lives. Today, systems and models play a role in decision-making processes such as healthcare diagnoses, loan approvals, or fraud detection. It is crucial that these models perform well and deliver trustworthy outcomes. Like any software application, AI systems can fail to meet expectations or produce undesirable results. This is why it is essential to understand and explain the behavior of AI models.
In this curriculum, you will start to discover how machine learning can and is impacting our everyday lives. Even now, systems and models are involved in daily decision-making tasks, such as health care diagnoses, loan approvals or detecting fraud. So, it is important that these models work well to provide outcomes that are trustworthy. Just as any software application, AI systems are going to miss expectations or have an undesirable outcome. That is why it is essential to be about to understand and explain the behavior of an AI model.
Consider what might happen if the data used to build these models lacks representation of certain demographics, such as race, gender, political views, or religion, or if it disproportionately represents some groups. What if the models output favors one demographic over another? What are the consequences for the application? Furthermore, what happens when the model causes harm? Who is accountable for the behavior of AI systems? These are some of the questions we will explore in this curriculum.
Imagine what can happen when the data you are using to build these models lacks certain demographics, such as race, gender, political view, religion, or disproportionally represents such demographics. What about when the models output is interpreted to favor some demographic? What is the consequence for the application? In addition, what happens when the model has an adverse outcome and is harmful to people? Who is accountable for the AI systems behavior? These are some questions we will explore in this curriculum.
In this lesson, you will:
In this lesson, you will:
- Learn about the importance of fairness in machine learning and the harms related to unfairness.
- Understand the practice of exploring outliers and unusual scenarios to ensure reliability and safety.
- Recognize the need to design inclusive systems that empower everyone.
- Explore the importance of protecting privacy and security for both data and individuals.
- Understand the value of a transparent approach to explain AI model behavior.
- Appreciate how accountability is key to building trust in AI systems.
- Raise your awareness of the importance of fairness in machine learning and fairness-related harms.
- Become familiar with the practice of exploring outliers and unusual scenarios to ensure reliability and safety
- Gain understanding on the need to empower everyone by designing inclusive systems
- Explore how vital it is to protect privacy and security of data and people
- See the importance of having a glass box approach to explain the behavior of AI models
- Be mindful of how accountability is essential to build trust in AI systems
## Prerequisite
Before starting, please complete the "Responsible AI Principles" Learn Path and watch the video below on the topic:
As a prerequisite, please take the "Responsible AI Principles" Learn Path and watch the video below on the topic:
Learn more about Responsible AI by following this [Learning Path](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
@ -32,124 +32,128 @@ Learn more about Responsible AI by following this [Learning Path](https://docs.m
## Fairness
AI systems should treat everyone fairly and avoid disadvantaging similar groups of people. For example, when AI systems provide recommendations for medical treatment, loan applications, or employment, they should offer the same guidance to individuals with similar symptoms, financial situations, or qualifications. As humans, we all carry biases that influence our decisions and actions. These biases can also appear in the data used to train AI systems, sometimes unintentionally. It can be challenging to recognize when bias is being introduced into data.
AI systems should treat everyone fairly and avoid affecting similar groups of people in different ways. For example, when AI systems provide guidance on medical treatment, loan applications, or employment, they should make the same recommendations to everyone with similar symptoms, financial circumstances, or professional qualifications. Each of us as humans carries around inherited biases that affect our decisions and actions. These biases can be evident in the data that we use to train AI systems. Such manipulation can sometimes happen unintentionally. It is often difficult to consciously know when you are introducing bias in data.
**“Unfairness”** refers to negative impacts, or “harms,” experienced by a group of people, such as those defined by race, gender, age, or disability. The main types of fairness-related harms include:
**“Unfairness”** encompasses negative impacts, or “harms”, for a group of people, such as those defined in terms of race, gender, age, or disability status. The main fairness-related harms can be classified as:
- **Allocation**: Favoring one gender, ethnicity, or group over another.
- **Quality of service**: Training data for a specific scenario while ignoring the complexity of real-world situations, leading to poor performance. For example, a soap dispenser that fails to detect people with dark skin. [Reference](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **Denigration**: Unfairly criticizing or labeling someone or something. For instance, an image labeling system that mislabeled dark-skinned individuals as gorillas.
- **Over- or under-representation**: When a group is absent or underrepresented in a profession, and systems perpetuate this imbalance.
- **Stereotyping**: Associating a group with predefined attributes. For example, a language translation system between English and Turkish may produce errors due to gender-based stereotypes.
- **Allocation**, if a gender or ethnicity for example is favored over another.
- **Quality of service**. If you train the data for one specific scenario but reality is much more complex, it leads to a poor performing service. For instance, a hand soap dispenser that could not seem to be able to sense people with dark skin. [Reference](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **Denigration**. To unfairly criticize and label something or someone. For example, an image labeling technology infamously mislabeled images of dark-skinned people as gorillas.
- **Over- or under- representation**. The idea is that a certain group is not seen in a certain profession, and any service or function that keeps promoting that is contributing to harm.
- **Stereotyping**. Associating a given group with pre-assigned attributes. For example, a language translation system betweem English and Turkish may have inaccuraces due to words with stereotypical associations to gender.
![translation to Turkish](../../../../1-Introduction/3-fairness/images/gender-bias-translate-en-tr.png)
![translation to Turkish](../../../../translated_images/en/gender-bias-translate-en-tr.f185fd8822c2d437.webp)
> translation to Turkish
![translation back to English](../../../../1-Introduction/3-fairness/images/gender-bias-translate-tr-en.png)
![translation back to English](../../../../translated_images/en/gender-bias-translate-tr-en.4eee7e3cecb8c70e.webp)
> translation back to English
When designing and testing AI systems, it is essential to ensure that AI is fair and does not make biased or discriminatory decisions—just as humans are prohibited from doing. Achieving fairness in AI and machine learning is a complex sociotechnical challenge.
When designing and testing AI systems, we need to ensure that AI is fair and not programmed to make biased or discriminatory decisions, which human beings are also prohibited from making. Guaranteeing fairness in AI and machine learning remains a complex sociotechnical challenge.
### Reliability and safety
To build trust, AI systems must be reliable, safe, and consistent under both normal and unexpected conditions. It is important to understand how AI systems behave in various situations, especially outliers. When developing AI solutions, significant attention must be given to handling a wide range of scenarios the system might encounter. For example, a self-driving car must prioritize peoples safety. The AI powering the car must account for scenarios like nighttime driving, thunderstorms, blizzards, children running into the street, pets, road construction, and more. The reliability and safety of an AI system reflect the level of foresight and preparation by the data scientist or AI developer during design and testing.
To build trust, AI systems need to be reliable, safe, and consistent under normal and unexpected conditions. It is important to know how AI systems will behavior in a variety of situations, especially when they are outliers. When building AI solutions, there needs to be a substantial amount of focus on how to handle a wide variety of circumstances that the AI solutions would encounter. For example, a self-driving car needs to put people's safety as a top priority. As a result, the AI powering the car need to consider all the possible scenarios that the car could come across such as night, thunderstorms or blizzards, kids running across the street, pets, road constructions etc. How well an AI system can handle a wild range of conditions reliably and safely reflects the level of anticipation the data scientist or AI developer considered during the design or testing of the system.
> [🎥 Click here for a video: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
> [🎥 Click the here for a video: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
### Inclusiveness
AI systems should be designed to engage and empower everyone. Data scientists and AI developers must identify and address potential barriers in the system that could unintentionally exclude people. For example, there are 1 billion people with disabilities worldwide. Advances in AI can help them access information and opportunities more easily in their daily lives. Addressing barriers creates opportunities to innovate and develop AI products that provide better experiences for everyone.
AI systems should be designed to engage and empower everyone. When designing and implementing AI systems data scientists and AI developers identify and address potential barriers in the system that could unintentionally exclude people. For example, there are 1 billion people with disabilities around the world. With the advancement of AI, they can access a wide range of information and opportunities more easily in their daily lives. By addressing the barriers, it creates opportunities to innovate and develop AI products with better experiences that benefit everyone.
> [🎥 Click here for a video: inclusiveness in AI](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
> [🎥 Click the here for a video: inclusiveness in AI](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
### Security and privacy
### Security and privacy
AI systems must be safe and respect peoples privacy. People are less likely to trust systems that put their privacy, information, or lives at risk. When training machine learning models, data is essential for producing accurate results. However, the origin and integrity of the data must be considered. For example, was the data user-submitted or publicly available? Additionally, AI systems must protect confidential information and resist attacks. As AI becomes more widespread, safeguarding privacy and securing personal and business information are increasingly critical and complex. Privacy and data security require special attention because AI systems rely on data to make accurate predictions and decisions.
AI systems should be safe and respect peoples privacy. People have less trust in systems that put their privacy, information, or lives at risk. When training machine learning models, we rely on data to produce the best results. In doing so, the origin of the data and integrity must be considered. For example, was the data user submitted or publicly available? Next, while working with the data, it is crucial to develop AI systems that can protect confidential information and resist attacks. As AI becomes more prevalent, protecting privacy and securing important personal and business information is becoming more critical and complex. Privacy and data security issues require especially close attention for AI because access to data is essential for AI systems to make accurate and informed predictions and decisions about people.
> [🎥 Click here for a video: security in AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
> [🎥 Click the here for a video: security in AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- The industry has made significant progress in privacy and security, driven by regulations like GDPR (General Data Protection Regulation).
- However, AI systems face a tension between the need for personal data to improve effectiveness and the need to protect privacy.
- Just as the internet brought new security challenges, AI has led to a rise in security issues.
- At the same time, AI is being used to enhance security, such as in modern antivirus scanners powered by AI heuristics.
- Data science processes must align with the latest privacy and security practices.
- As an industry we have made significant advancements in Privacy & security, fueled significantly by regulations like the GDPR (General Data Protection Regulation).
- Yet with AI systems we must acknowledge the tension between the need for more personal data to make systems more personal and effective and privacy.
- Just like with the birth of connected computers with the internet, we are also seeing a huge uptick in the number of security issues related to AI.
- At the same time, we have seen AI being used to improve security. As an example, most modern anti-virus scanners are driven by AI heuristics today.
- We need to ensure that our Data Science processes blend harmoniously with the latest privacy and security practices.
### Transparency
AI systems should be understandable. Transparency involves explaining the behavior of AI systems and their components. Stakeholders need to understand how and why AI systems function to identify potential performance issues, safety and privacy concerns, biases, exclusionary practices, or unintended outcomes. Those who use AI systems should also be transparent about when, why, and how they deploy them, as well as the systems limitations. For example, if a bank uses AI for lending decisions, it is important to examine the outcomes and understand which data influences the systems recommendations. Governments are beginning to regulate AI across industries, so data scientists and organizations must ensure their systems meet regulatory requirements, especially in cases of undesirable outcomes.
### Transparency
AI systems should be understandable. A crucial part of transparency is explaining the behavior of AI systems and their components. Improving the understanding of AI systems requires that stakeholders comprehend how and why they function so that they can identify potential performance issues, safety and privacy concerns, biases, exclusionary practices, or unintended outcomes. We also believe that those who use AI systems should be honest and forthcoming about when, why, and how they choose to deploy them. As well as the limitations of the systems they use. For example, if a bank uses an AI system to support its consumer lending decisions, it is important to examine the outcomes and understand which data influences the systems recommendations. Governments are starting to regulate AI across industries, so data scientists and organizations must explain if an AI system meets regulatory requirements, especially when there is an undesirable outcome.
> [🎥 Click here for a video: transparency in AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
> [🎥 Click the here for a video: transparency in AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- AI systems are complex, making it difficult to understand how they work and interpret their results.
- This lack of understanding affects how systems are managed, operationalized, and documented.
- More importantly, it impacts the decisions made based on the systems results.
- Because AI systems are so complex, it is hard to understand how they work and interpret the results.
- This lack of understanding affects the way these systems are managed, operationalized, and documented.
- This lack of understanding more importantly affects the decisions made using the results these systems produce.
### Accountability
### Accountability
The people who design and deploy AI systems must be accountable for how their systems operate. The need for accountability is particularly crucial with sensitive use technologies like facial recognition. Recently, there has been a growing demand for facial recognition technology, especially from law enforcement organizations who see the potential of the technology in uses like finding missing children. However, these technologies could potentially be used by a government to put their citizens fundamental freedoms at risk by, for example, enabling continuous surveillance of specific individuals. Hence, data scientists and organizations need to be responsible for how their AI system impacts individuals or society.
The people who design and deploy AI systems must be accountable for their operation. Accountability is especially critical for sensitive technologies like facial recognition. For example, law enforcement agencies may use facial recognition to find missing children, but the same technology could enable governments to infringe on citizens freedoms through continuous surveillance. Data scientists and organizations must take responsibility for how their AI systems impact individuals and society.
[![Leading AI Researcher Warns of Mass Surveillance Through Facial Recognition](../../../../translated_images/en/accountability.41d8c0f4b85b6231.webp)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Microsoft's Approach to Responsible AI")
[![Leading AI Researcher Warns of Mass Surveillance Through Facial Recognition](../../../../1-Introduction/3-fairness/images/accountability.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Microsoft's Approach to Responsible AI")
> 🎥 Click the image above for a video: Warnings of Mass Surveillance Through Facial Recognition
> 🎥 Click the image above for a video: Warnings of Mass Surveillance Through Facial Recognition
Ultimately one of the biggest questions for our generation, as the first generation that is bringing AI to society, is how to ensure that computers will remain accountable to people and how to ensure that the people that design computers remain accountable to everyone else.
One of the most significant questions for our generation, as the first to bring AI to society, is how to ensure that computers remain accountable to people and that the people designing these systems remain accountable to everyone else.
## Impact assessment
## Impact assessment
Before training a machine learning model, it is important to conduct an impact assessmet to understand the purpose of the AI system; what the intended use is; where it will be deployed; and who will be interacting with the system. These are helpful for reviewer(s) or testers evaluating the system to know what factors to take into consideration when identifying potential risks and expected consequences.
Before training a machine learning model, it is important to conduct an impact assessment to understand the purpose of the AI system, its intended use, where it will be deployed, and who will interact with it. This helps reviewers or testers identify potential risks and expected consequences.
The following are areas of focus when conducting an impact assessment:
Key areas to focus on during an impact assessment include:
* **Adverse impact on individuals**. Being aware of any restriction or requirements, unsupported use or any known limitations hindering the system's performance is vital to ensure that the system is not used in a way that could cause harm to individuals.
* **Data requirements**. Gaining an understanding of how and where the system will use data enables reviewers to explore any data requirements you would need to be mindful of (e.g., GDPR or HIPAA data regulations). In addition, examine whether the source or quantity of data is substantial for training.
* **Summary of impact**. Gather a list of potential harms that could arise from using the system. Throughout the ML lifecycle, review if the issues identified are mitigated or addressed.
* **Applicable goals** for each of the six core principles. Assess if the goals from each of the principles are met and if there are any gaps.
- **Adverse impact on individuals**: Be aware of any restrictions, requirements, unsupported uses, or known limitations that could hinder the systems performance and cause harm.
- **Data requirements**: Understand how and where the system will use data to identify any regulatory requirements (e.g., GDPR or HIPAA) and ensure the data source and quantity are sufficient for training.
- **Summary of impact**: Identify potential harms that could arise from using the system and review whether these issues are addressed throughout the ML lifecycle.
- **Applicable goals** for each of the six core principles: Assess whether the goals of each principle are met and identify any gaps.
## Debugging with responsible AI
## Debugging with responsible AI
Debugging an AI system is similar to debugging a software application—it involves identifying and resolving issues. Many factors can cause a model to perform unexpectedly or irresponsibly. Traditional model performance metrics, which are often quantitative aggregates, are insufficient for analyzing how a model violates responsible AI principles. Additionally, machine learning models are often black boxes, making it difficult to understand their outcomes or explain their mistakes. Later in this course, we will learn how to use the Responsible AI dashboard to debug AI systems. This dashboard provides a comprehensive tool for data scientists and AI developers to:
Similar to debugging a software application, debugging an AI system is a necessary process of identifying and resolving issues in the system. There are many factors that would affect a model not performing as expected or responsibly. Most traditional model performance metrics are quantitative aggregates of a model's performance, which are not sufficient to analyze how a model violates the responsible AI principles. Furthermore, a machine learning model is a black box that makes it difficult to understand what drives its outcome or provide explanation when it makes a mistake. Later in this course, we will learn how to use the Responsible AI dashboard to help debug AI systems. The dashboard provides a holistic tool for data scientists and AI developers to perform:
- **Perform error analysis**: Identify error distributions that affect fairness or reliability.
- **Review the model overview**: Discover disparities in the models performance across data cohorts.
- **Analyze data**: Understand data distribution and identify potential biases that could impact fairness, inclusiveness, and reliability.
- **Interpret the model**: Understand what influences the models predictions, which is essential for transparency and accountability.
* **Error analysis**. To identify the error distribution of the model that can affect the system's fairness or reliability.
* **Model overview**. To discover where there are disparities in the model's performance across data cohorts.
* **Data analysis**. To understand the data distribution and identify any potential bias in the data that could lead to fairness, inclusiveness, and reliability issues.
* **Model interpretability**. To understand what affects or influences the model's predictions. This helps in explaining the model's behavior, which is important for transparency and accountability.
## 🚀 Challenge
To prevent harms from being introduced in the first place, we should:
## 🚀 Challenge
To prevent harms from being introduced in the first place, we should:
- Ensure diversity in the backgrounds and perspectives of the people working on AI systems.
- Invest in datasets that reflect the diversity of society.
- Develop better methods throughout the machine learning lifecycle to detect and address responsible AI issues.
- have a diversity of backgrounds and perspectives among the people working on systems
- invest in datasets that reflect the diversity of our society
- develop better methods throughout the machine learning lifecycle for detecting and correcting responible AI when it occurs
Think about real-life scenarios where a models lack of trustworthiness is evident during development or use. What else should we consider?
Think about real-life scenarios where a model's untrustworthiness is evident in model-building and usage. What else should we consider?
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Review & Self Study
## Review & Self Study
In this lesson, you have learned the basics of fairness and unfairness in machine learning.
Watch this workshop to explore the topics in more detail:
In this lesson, you have learned some basics of the concepts of fairness and unfairness in machine learning.
Watch this workshop to dive deeper into the topics:
- In pursuit of responsible AI: Applying principles in practice by Besmira Nushi, Mehrnoosh Sameki, and Amit Sharma
- In pursuit of responsible AI: Bringing principles to practice by Besmira Nushi, Mehrnoosh Sameki and Amit Sharma
[![Responsible AI Toolbox: An open-source framework for building responsible AI](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: An open-source framework for building responsible AI")
> 🎥 Click the image above to watch the video: RAI Toolbox: An open-source framework for building responsible AI by Besmira Nushi, Mehrnoosh Sameki, and Amit Sharma
> 🎥 Click the image above for a video: RAI Toolbox: An open-source framework for building responsible AI by Besmira Nushi, Mehrnoosh Sameki, and Amit Sharma
Additionally, check out:
Also, read:
- Microsofts RAI resource center: [Responsible AI Resources Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Microsofts RAI resource center: [Responsible AI Resources Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Microsofts FATE research group: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
- Microsofts FATE research group: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
RAI Toolbox:
RAI Toolbox:
- [Responsible AI Toolbox GitHub repository](https://github.com/microsoft/responsible-ai-toolbox)
Learn about Azure Machine Learning's tools for ensuring fairness:
Read about Azure Machine Learning's tools to ensure fairness:
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
## Assignment
@ -157,5 +161,7 @@ Learn about Azure Machine Learning's tools for ensuring fairness:
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using 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.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,6 +1,6 @@
# Get started with Python and Scikit-learn for regression models
![Summary of regressions in a sketchnote](../../../../sketchnotes/ml-regression.png)
![Summary of regressions in a sketchnote](../../../../translated_images/en/ml-regression.4e4f70e3b3ed446e.webp)
> Sketchnote by [Tomomi Imura](https://www.twitter.com/girlie_mac)
@ -10,109 +10,110 @@
## Introduction
In these four lessons, you will learn how to build regression models. We'll discuss their purpose shortly. But before diving in, ensure you have the necessary tools set up to begin!
In these four lessons, you will discover how to build regression models. We will discuss what these are for shortly. But before you do anything, make sure you have the right tools in place to start the process!
In this lesson, you will:
In this lesson, you will learn how to:
- Set up your computer for local machine learning tasks.
- Work with Jupyter notebooks.
- Install and use Scikit-learn.
- Explore linear regression through a hands-on exercise.
- Configure your computer for local machine learning tasks.
- Work with Jupyter Notebooks.
- Use Scikit-learn, including installation.
- Explore linear regression with a hands-on exercise.
## Installations and configurations
[![ML for beginners - Setup your tools ready to build Machine Learning models](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML for beginners -Setup your tools ready to build Machine Learning models")
> 🎥 Click the image above for a short video on configuring your computer for ML.
> 🎥 Click the image above for a short video working through configuring your computer for ML.
1. **Install Python**. Ensure that [Python](https://www.python.org/downloads/) is installed on your computer. Python is essential for many data science and machine learning tasks. Most systems already have Python installed. You can also use [Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) to simplify the setup process.
1. **Install Python**. Ensure that [Python](https://www.python.org/downloads/) is installed on your computer. You will use Python for many data science and machine learning tasks. Most computer systems already include a Python installation. There are useful [Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) available as well, to ease the setup for some users.
Some Python tasks require specific versions of the software. To manage this, it's helpful to work within a [virtual environment](https://docs.python.org/3/library/venv.html).
Some usages of Python, however, require one version of the software, whereas others require a different version. For this reason, it's useful to work within a [virtual environment](https://docs.python.org/3/library/venv.html).
2. **Install Visual Studio Code**. Make sure Visual Studio Code is installed on your computer. Follow these instructions to [install Visual Studio Code](https://code.visualstudio.com/) for the basic setup. Since you'll use Python in Visual Studio Code during this course, you might want to review how to [configure Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) for Python development.
2. **Install Visual Studio Code**. Make sure you have Visual Studio Code installed on your computer. Follow these instructions to [install Visual Studio Code](https://code.visualstudio.com/) for the basic installation. You are going to use Python in Visual Studio Code in this course, so you might want to brush up on how to [configure Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) for Python development.
> Familiarize yourself with Python by exploring this collection of [Learn modules](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
> Get comfortable with Python by working through this collection of [Learn modules](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
>
> [![Setup Python with Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Setup Python with Visual Studio Code")
>
> 🎥 Click the image above for a video on using Python within VS Code.
> 🎥 Click the image above for a video: using Python within VS Code.
3. **Install Scikit-learn** by following [these instructions](https://scikit-learn.org/stable/install.html). Since Python 3 is required, using a virtual environment is recommended. If you're installing this library on an M1 Mac, refer to the special instructions on the linked page.
3. **Install Scikit-learn**, by following [these instructions](https://scikit-learn.org/stable/install.html). Since you need to ensure that you use Python 3, it's recommended that you use a virtual environment. Note, if you are installing this library on a M1 Mac, there are special instructions on the page linked above.
4. **Install Jupyter Notebook**. You'll need to [install the Jupyter package](https://pypi.org/project/jupyter/).
1. **Install Jupyter Notebook**. You will need to [install the Jupyter package](https://pypi.org/project/jupyter/).
## Your ML authoring environment
You'll use **notebooks** to develop Python code and create machine learning models. Notebooks are a popular tool for data scientists, identifiable by their `.ipynb` extension.
You are going to use **notebooks** to develop your Python code and create machine learning models. This type of file is a common tool for data scientists, and they can be identified by their suffix or extension `.ipynb`.
Notebooks provide an interactive environment where developers can code, add notes, and write documentation alongside their code—ideal for experimental or research-oriented projects.
Notebooks are an interactive environment that allow the developer to both code and add notes and write documentation around the code which is quite helpful for experimental or research-oriented projects.
[![ML for beginners - Set up Jupyter Notebooks to start building regression models](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML for beginners - Set up Jupyter Notebooks to start building regression models")
> 🎥 Click the image above for a short video on setting up Jupyter Notebooks.
> 🎥 Click the image above for a short video working through this exercise.
### Exercise - work with a notebook
In this folder, you'll find the file _notebook.ipynb_.
In this folder, you will find the file _notebook.ipynb_.
1. Open _notebook.ipynb_ in Visual Studio Code.
A Jupyter server will start with Python 3+. You'll find areas of the notebook containing `run` sections of code. You can execute a code block by clicking the play button icon.
A Jupyter server will start with Python 3+ started. You will find areas of the notebook that can be `run`, pieces of code. You can run a code block, by selecting the icon that looks like a play button.
2. Select the `md` icon and add some markdown with the text **# Welcome to your notebook**.
1. Select the `md` icon and add a bit of markdown, and the following text **# Welcome to your notebook**.
Next, add some Python code.
3. Type **print('hello notebook')** in the code block.
4. Click the arrow to run the code.
1. Type **print('hello notebook')** in the code block.
1. Select the arrow to run the code.
You should see the printed output:
You should see the printed statement:
```output
hello notebook
```
![VS Code with a notebook open](../../../../2-Regression/1-Tools/images/notebook.jpg)
![VS Code with a notebook open](../../../../translated_images/en/notebook.4a3ee31f396b8832.webp)
You can intersperse your code with comments to document the notebook.
You can interleaf your code with comments to self-document the notebook.
Reflect on how a web developer's working environment differs from that of a data scientist.
Think for a minute how different a web developer's working environment is versus that of a data scientist.
## Up and running with Scikit-learn
Now that Python is set up locally and you're comfortable with Jupyter notebooks, let's get familiar with Scikit-learn (pronounced `sci` as in `science`). Scikit-learn offers an [extensive API](https://scikit-learn.org/stable/modules/classes.html#api-ref) for performing ML tasks.
Now that Python is set up in your local environment, and you are comfortable with Jupyter Notebooks, let's get equally comfortable with Scikit-learn (pronounce it `sci` as in `science`). Scikit-learn provides an [extensive API](https://scikit-learn.org/stable/modules/classes.html#api-ref) to help you perform ML tasks.
According to its [website](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection and evaluation, and many other utilities."
According to their [website](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection and evaluation, and many other utilities."
In this course, you'll use Scikit-learn and other tools to build machine learning models for 'traditional machine learning' tasks. Neural networks and deep learning are excluded, as they are covered in our upcoming 'AI for Beginners' curriculum.
In this course, you will use Scikit-learn and other tools to build machine learning models to perform what we call 'traditional machine learning' tasks. We have deliberately avoided neural networks and deep learning, as they are better covered in our forthcoming 'AI for Beginners' curriculum.
Scikit-learn simplifies model building and evaluation. It primarily focuses on numeric data and includes several ready-made datasets for learning. It also provides pre-built models for experimentation. Let's explore how to load prepackaged data and use a built-in estimator to create your first ML model with Scikit-learn.
Scikit-learn makes it straightforward to build models and evaluate them for use. It is primarily focused on using numeric data and contains several ready-made datasets for use as learning tools. It also includes pre-built models for students to try. Let's explore the process of loading prepackaged data and using a built in estimator first ML model with Scikit-learn with some basic data.
## Exercise - your first Scikit-learn notebook
> This tutorial was inspired by the [linear regression example](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) on Scikit-learn's website.
> This tutorial was inspired by the [linear regression example](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) on Scikit-learn's web site.
[![ML for beginners - Your First Linear Regression Project in Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML for beginners - Your First Linear Regression Project in Python")
> 🎥 Click the image above for a short video on this exercise.
> 🎥 Click the image above for a short video working through this exercise.
In the _notebook.ipynb_ file associated with this lesson, clear all cells by clicking the 'trash can' icon.
In the _notebook.ipynb_ file associated to this lesson, clear out all the cells by pressing the 'trash can' icon.
In this section, you'll work with a small diabetes dataset built into Scikit-learn for learning purposes. Imagine testing a treatment for diabetic patients. Machine learning models can help identify which patients might respond better to the treatment based on variable combinations. Even a basic regression model, when visualized, can reveal insights about variables that could guide clinical trials.
In this section, you will work with a small dataset about diabetes that is built into Scikit-learn for learning purposes. Imagine that you wanted to test a treatment for diabetic patients. Machine Learning models might help you determine which patients would respond better to the treatment, based on combinations of variables. Even a very basic regression model, when visualized, might show information about variables that would help you organize your theoretical clinical trials.
✅ There are various regression methods, and your choice depends on the question you're trying to answer. For example, if you want to predict someone's probable height based on their age, you'd use linear regression to find a **numeric value**. If you're determining whether a cuisine is vegan, you'd use logistic regression for a **category assignment**. Think about questions you could ask of data and which method would be most suitable.
✅ There are many types of regression methods, and which one you pick depends on the answer you're looking for. If you want to predict the probable height for a person of a given age, you'd use linear regression, as you're seeking a **numeric value**. If you're interested in discovering whether a type of cuisine should be considered vegan or not, you're looking for a **category assignment** so you would use logistic regression. You'll learn more about logistic regression later. Think a bit about some questions you can ask of data, and which of these methods would be more appropriate.
Let's begin.
Let's get started on this task.
### Import libraries
For this task, we'll import the following libraries:
For this task we will import some libraries:
- **matplotlib**: A useful [graphing tool](https://matplotlib.org/) for creating visualizations.
- **numpy**: [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) is a library for handling numeric data in Python.
- **sklearn**: The [Scikit-learn](https://scikit-learn.org/stable/user_guide.html) library.
- **matplotlib**. It's a useful [graphing tool](https://matplotlib.org/) and we will use it to create a line plot.
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) is a useful library for handling numeric data in Python.
- **sklearn**. This is the [Scikit-learn](https://scikit-learn.org/stable/user_guide.html) library.
Import the libraries you'll need for this task.
Import some libraries to help with your tasks.
1. Add imports by typing the following code:
@ -122,26 +123,26 @@ Import the libraries you'll need for this task.
from sklearn import datasets, linear_model, model_selection
```
Here, you're importing `matplotlib`, `numpy`, and `datasets`, `linear_model`, and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
Above you are importing `matplotlib`, `numpy` and you are importing `datasets`, `linear_model` and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
### The diabetes dataset
The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) contains 442 samples of diabetes-related data with 10 feature variables, including:
The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) includes 442 samples of data around diabetes, with 10 feature variables, some of which include:
- age: age in years
- bmi: body mass index
- bp: average blood pressure
- s1 tc: T-Cells (a type of white blood cells)
✅ This dataset includes 'sex' as a feature variable, which is significant in diabetes research. Many medical datasets use binary classifications like this. Consider how such categorizations might exclude certain populations from treatments.
✅ This dataset includes the concept of 'sex' as a feature variable important to research around diabetes. Many medical datasets include this type of binary classification. Think a bit about how categorizations such as this might exclude certain parts of a population from treatments.
Now, load the X and y data.
Now, load up the X and y data.
> 🎓 Remember, this is supervised learning, so we need a labeled 'y' target.
> 🎓 Remember, this is supervised learning, and we need a named 'y' target.
In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` ensures `X` is a data matrix and `y` is the regression target.
In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` signals that `X` will be a data matrix, and `y` will be the regression target.
1. Add print commands to display the shape of the data matrix and its first element:
1. Add some print commands to show the shape of the data matrix and its first element:
```python
X, y = datasets.load_diabetes(return_X_y=True)
@ -149,9 +150,9 @@ In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The
print(X[0])
```
The response is a tuple. You're assigning the first two values of the tuple to `X` and `y`. Learn more [about tuples](https://wikipedia.org/wiki/Tuple).
What you are getting back as a response, is a tuple. What you are doing is to assign the two first values of the tuple to `X` and `y` respectively. Learn more [about tuples](https://wikipedia.org/wiki/Tuple).
You'll see the data has 442 items shaped into arrays of 10 elements:
You can see that this data has 442 items shaped in arrays of 10 elements:
```text
(442, 10)
@ -159,39 +160,39 @@ In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
Reflect on the relationship between the data and the regression target. Linear regression predicts relationships between feature X and target variable y. Can you find the [target](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for the diabetes dataset in the documentation? What does this dataset demonstrate, given the target?
Think a bit about the relationship between the data and the regression target. Linear regression predicts relationships between feature X and target variable y. Can you find the [target](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for the diabetes dataset in the documentation? What is this dataset demonstrating, given that target?
2. Select a portion of the dataset to plot by choosing the 3rd column. Use the `:` operator to select all rows, and then select the 3rd column using the index (2). Reshape the data into a 2D array for plotting using `reshape(n_rows, n_columns)`. If one parameter is -1, the corresponding dimension is calculated automatically.
2. Next, select a portion of this dataset to plot by selecting the 3rd column of the dataset. You can do this by using the `:` operator to select all rows, and then selecting the 3rd column using the index (2). You can also reshape the data to be a 2D array - as required for plotting - by using `reshape(n_rows, n_columns)`. If one of the parameter is -1, the corresponding dimension is calculated automatically.
```python
X = X[:, 2]
X = X.reshape((-1,1))
```
Print the data at any time to check its shape.
At any time, print out the data to check its shape.
3. With the data ready for plotting, use a machine to determine a logical split between the numbers in the dataset. Split both the data (X) and the target (y) into test and training sets. Scikit-learn provides a simple way to do this; you can split your test data at a specific point.
3. Now that you have data ready to be plotted, you can see if a machine can help determine a logical split between the numbers in this dataset. To do this, you need to split both the data (X) and the target (y) into test and training sets. Scikit-learn has a straightforward way to do this; you can split your test data at a given point.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. Train your model! Load the linear regression model and train it with your X and y training sets using `model.fit()`:
4. Now you are ready to train your model! Load up the linear regression model and train it with your X and y training sets using `model.fit()`:
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
`model.fit()` is a function you'll encounter in many ML libraries like TensorFlow.
`model.fit()` is a function you'll see in many ML libraries such as TensorFlow
5. Create a prediction using test data with the `predict()` function. This will help draw the line between data groups.
5. Then, create a prediction using test data, using the function `predict()`. This will be used to draw the line between data groups
```python
y_pred = model.predict(X_test)
```
6. Finally, visualize the data using Matplotlib. Create a scatterplot of all the X and y test data, and use the prediction to draw a line that best separates the data groups.
6. Now it's time to show the data in a plot. Matplotlib is a very useful tool for this task. Create a scatterplot of all the X and y test data, and use the prediction to draw a line in the most appropriate place, between the model's data groupings.
```python
plt.scatter(X_test, y_test, color='black')
@ -202,23 +203,24 @@ In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The
plt.show()
```
![a scatterplot showing datapoints around diabetes](../../../../2-Regression/1-Tools/images/scatterplot.png)
✅ Think about what's happening here. A straight line is passing through many small data points, but what is its purpose? Can you see how this line can help predict where a new, unseen data point might align with the plot's y-axis? Try to describe the practical application of this model in your own words.
![a scatterplot showing datapoints around diabetes](../../../../translated_images/en/scatterplot.ad8b356bcbb33be6.webp)
Congratulations, you've built your first linear regression model, made a prediction with it, and visualized it in a plot!
✅ Think a bit about what's going on here. A straight line is running through many small dots of data, but what is it doing exactly? Can you see how you should be able to use this line to predict where a new, unseen data point should fit in relationship to the plot's y axis? Try to put into words the practical use of this model.
Congratulations, you built your first linear regression model, created a prediction with it, and displayed it in a plot!
---
## 🚀Challenge
Plot a different variable from this dataset. Hint: modify this line: `X = X[:,2]`. Considering the target of this dataset, what insights can you gain about the progression of diabetes as a disease?
Plot a different variable from this dataset. Hint: edit this line: `X = X[:,2]`. Given this dataset's target, what are you able to discover about the progression of diabetes as a disease?
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Review & Self Study
In this tutorial, you worked with simple linear regression, rather than univariate or multiple linear regression. Take some time to read about the differences between these methods, or watch [this video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
In this tutorial, you worked with simple linear regression, rather than univariate or multiple linear regression. Read a little about the differences between these methods, or take a look at [this video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
Learn more about the concept of regression and reflect on the types of questions this technique can help answer. Consider taking [this tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) to deepen your understanding.
Read more about the concept of regression and think about what kinds of questions can be answered by this technique. Take this [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) to deepen your understanding.
## Assignment
@ -226,5 +228,7 @@ Learn more about the concept of regression and reflect on the types of questions
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using 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.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,6 +1,6 @@
# Build a regression model using Scikit-learn: prepare and visualize data
![Data visualization infographic](../../../../2-Regression/2-Data/images/data-visualization.png)
![Data visualization infographic](../../../../translated_images/en/data-visualization.54e56dded7c1a804.webp)
Infographic by [Dasani Madipalli](https://twitter.com/dasani_decoded)
@ -10,51 +10,51 @@ Infographic by [Dasani Madipalli](https://twitter.com/dasani_decoded)
## Introduction
Now that you have the tools needed to start building machine learning models with Scikit-learn, you're ready to begin asking questions of your data. When working with data and applying ML solutions, it's crucial to know how to ask the right questions to unlock the full potential of your dataset.
Now that you are set up with the tools you need to start tackling machine learning model building with Scikit-learn, you are ready to start asking questions of your data. As you work with data and apply ML solutions, it's very important to understand how to ask the right question to properly unlock the potentials of your dataset.
In this lesson, you will learn:
- How to prepare your data for model building.
- How to prepare your data for model-building.
- How to use Matplotlib for data visualization.
- How to use Seaborn for more expressive data visualization.
## Asking the right question of your data
The type of question you want answered will determine the ML algorithms you use. The quality of the answer you get will largely depend on the nature of your data.
The question you need answered will determine what type of ML algorithms you will leverage. And the quality of the answer you get back will be heavily dependent on the nature of your data.
Take a look at the [data](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) provided for this lesson. You can open this .csv file in VS Code. A quick glance reveals blanks, a mix of strings and numeric data, and a peculiar column called 'Package' with values like 'sacks', 'bins', and others. The data is, frankly, a bit messy.
Take a look at the [data](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) provided for this lesson. You can open this .csv file in VS Code. A quick skim immediately shows that there are blanks and a mix of strings and numeric data. There's also a strange column called 'Package' where the data is a mix between 'sacks', 'bins' and other values. The data, in fact, is a bit of a mess.
[![ML for beginners - How to Analyze and Clean a Dataset](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML for beginners - How to Analyze and Clean a Dataset")
> 🎥 Click the image above for a short video on preparing the data for this lesson.
> 🎥 Click the image above for a short video working through preparing the data for this lesson.
It's rare to receive a dataset that's completely ready for building a machine learning model. In this lesson, you'll learn how to prepare a raw dataset using standard Python libraries. You'll also explore techniques for visualizing the data.
In fact, it is not very common to be gifted a dataset that is completely ready to use to create a ML model out of the box. In this lesson, you will learn how to prepare a raw dataset using standard Python libraries. You will also learn various techniques to visualize the data.
## Case study: 'the pumpkin market'
In this folder, you'll find a .csv file in the root `data` folder called [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv), which contains 1757 rows of data about the pumpkin market, grouped by city. This raw data was extracted from the [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) provided by the United States Department of Agriculture.
In this folder you will find a .csv file in the root `data` folder called [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) which includes 1757 lines of data about the market for pumpkins, sorted into groupings by city. This is raw data extracted from the [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distributed by the United States Department of Agriculture.
### Preparing data
This data is in the public domain and can be downloaded in separate files for each city from the USDA website. To simplify things, we've combined all the city data into one spreadsheet, so the data has already been partially prepared. Next, let's examine the data more closely.
This data is in the public domain. It can be downloaded in many separate files, per city, from the USDA web site. To avoid too many separate files, we have concatenated all the city data into one spreadsheet, thus we have already _prepared_ the data a bit. Next, let's take a closer look at the data.
### The pumpkin data - early conclusions
What do you notice about this data? As mentioned earlier, there's a mix of strings, numbers, blanks, and odd values that need to be understood.
What question can you ask of this data using a regression technique? For example: "Predict the price of a pumpkin for sale during a given month." Looking at the data again, you'll need to make some adjustments to structure it properly for this task.
What do you notice about this data? You already saw that there is a mix of strings, numbers, blanks and strange values that you need to make sense of.
What question can you ask of this data, using a Regression technique? What about "Predict the price of a pumpkin for sale during a given month". Looking again at the data, there are some changes you need to make to create the data structure necessary for the task.
## Exercise - analyze the pumpkin data
Let's use [Pandas](https://pandas.pydata.org/) (short for `Python Data Analysis`), a powerful tool for shaping data, to analyze and prepare the pumpkin data.
Let's use [Pandas](https://pandas.pydata.org/), (the name stands for `Python Data Analysis`) a tool very useful for shaping data, to analyze and prepare this pumpkin data.
### First, check for missing dates
Start by checking for missing dates:
You will first need to take steps to check for missing dates:
1. Convert the dates to a month format (these are US dates, so the format is `MM/DD/YYYY`).
2. Extract the month into a new column.
2. Extract the month to a new column.
Open the _notebook.ipynb_ file in Visual Studio Code and import the spreadsheet into a new Pandas dataframe.
Open the _notebook.ipynb_ file in Visual Studio Code and import the spreadsheet in to a new Pandas dataframe.
1. Use the `head()` function to view the first five rows.
@ -66,15 +66,15 @@ Open the _notebook.ipynb_ file in Visual Studio Code and import the spreadsheet
✅ What function would you use to view the last five rows?
1. Check for missing data in the current dataframe:
1. Check if there is missing data in the current dataframe:
```python
pumpkins.isnull().sum()
```
There is missing data, but it might not affect the task at hand.
There is missing data, but maybe it won't matter for the task at hand.
1. To simplify your dataframe, select only the columns you need using the `loc` function. This function extracts rows (first parameter) and columns (second parameter) from the original dataframe. The `:` expression below means "all rows."
1. To make your dataframe easier to work with, select only the columns you need, using the `loc` function which extracts from the original dataframe a group of rows (passed as first parameter) and columns (passed as second parameter). The expression `:` in the case below means "all rows".
```python
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
@ -83,9 +83,9 @@ Open the _notebook.ipynb_ file in Visual Studio Code and import the spreadsheet
### Second, determine average price of pumpkin
Think about how to calculate the average price of a pumpkin in a given month. Which columns would you use for this task? Hint: you'll need three columns.
Think about how to determine the average price of a pumpkin in a given month. What columns would you pick for this task? Hint: you'll need 3 columns.
Solution: Take the average of the `Low Price` and `High Price` columns to populate a new `Price` column, and convert the `Date` column to show only the month. Fortunately, based on the earlier check, there is no missing data for dates or prices.
Solution: take the average of the `Low Price` and `High Price` columns to populate the new Price column, and convert the Date column to only show the month. Fortunately, according to the check above, there is no missing data for dates or prices.
1. To calculate the average, add the following code:
@ -98,21 +98,21 @@ Solution: Take the average of the `Low Price` and `High Price` columns to popula
✅ Feel free to print any data you'd like to check using `print(month)`.
2. Copy your converted data into a new Pandas dataframe:
2. Now, copy your converted data into a fresh Pandas dataframe:
```python
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
Printing your dataframe will show a clean, organized dataset ready for building your regression model.
Printing out your dataframe will show you a clean, tidy dataset on which you can build your new regression model.
### But wait! There's something odd here
Looking at the `Package` column, pumpkins are sold in various configurations. Some are sold in '1 1/9 bushel' measures, others in '1/2 bushel' measures, some per pumpkin, some per pound, and some in large boxes of varying sizes.
If you look at the `Package` column, pumpkins are sold in many different configurations. Some are sold in '1 1/9 bushel' measures, and some in '1/2 bushel' measures, some per pumpkin, some per pound, and some in big boxes with varying widths.
> Pumpkins seem very hard to weigh consistently
Examining the original data, anything with `Unit of Sale` equal to 'EACH' or 'PER BIN' also has the `Package` type listed as per inch, per bin, or 'each'. Pumpkins are difficult to weigh consistently, so let's filter the data to include only pumpkins with the string 'bushel' in their `Package` column.
Digging into the original data, it's interesting that anything with `Unit of Sale` equalling 'EACH' or 'PER BIN' also have the `Package` type per inch, per bin, or 'each'. Pumpkins seem to be very hard to weigh consistently, so let's filter them by selecting only pumpkins with the string 'bushel' in their `Package` column.
1. Add a filter at the top of the file, under the initial .csv import:
@ -120,11 +120,11 @@ Examining the original data, anything with `Unit of Sale` equal to 'EACH' or 'PE
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
If you print the data now, you'll see only the 415 rows containing pumpkins sold by the bushel.
If you print the data now, you can see that you are only getting the 415 or so rows of data containing pumpkins by the bushel.
### But wait! There's one more thing to do
Did you notice that the bushel amount varies per row? You'll need to normalize the pricing to show the price per bushel. Perform some calculations to standardize it.
Did you notice that the bushel amount varies per row? You need to normalize the pricing so that you show the pricing per bushel, so do some math to standardize it.
1. Add these lines after the block creating the new_pumpkins dataframe:
@ -134,29 +134,29 @@ Did you notice that the bushel amount varies per row? You'll need to normalize t
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ According to [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), a bushel's weight depends on the type of produce, as it's a volume measurement. "A bushel of tomatoes, for example, is supposed to weigh 56 pounds... Leaves and greens take up more space with less weight, so a bushel of spinach is only 20 pounds." It's all quite complex! For simplicity, let's price by the bushel without converting to pounds. This study of bushels highlights the importance of understanding your data!
✅ According to [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), a bushel's weight depends on the type of produce, as it's a volume measurement. "A bushel of tomatoes, for example, is supposed to weigh 56 pounds... Leaves and greens take up more space with less weight, so a bushel of spinach is only 20 pounds." It's all pretty complicated! Let's not bother with making a bushel-to-pound conversion, and instead price by the bushel. All this study of bushels of pumpkins, however, goes to show how very important it is to understand the nature of your data!
Now, you can analyze pricing per unit based on bushel measurements. If you print the data again, you'll see it's standardized.
Now, you can analyze the pricing per unit based on their bushel measurement. If you print out the data one more time, you can see how it's standardized.
✅ Did you notice that pumpkins sold by the half-bushel are very expensive? Can you figure out why? Hint: Smaller pumpkins are pricier than larger ones, likely because more of them fit into a bushel, leaving less unused space compared to one large hollow pumpkin.
✅ Did you notice that pumpkins sold by the half-bushel are very expensive? Can you figure out why? Hint: little pumpkins are way pricier than big ones, probably because there are so many more of them per bushel, given the unused space taken by one big hollow pie pumpkin.
## Visualization Strategies
A data scientist's role often involves demonstrating the quality and characteristics of the data they're working with. This is done by creating visualizations—plots, graphs, and charts—that reveal relationships and gaps that might otherwise be hard to identify.
Part of the data scientist's role is to demonstrate the quality and nature of the data they are working with. To do this, they often create interesting visualizations, or plots, graphs, and charts, showing different aspects of data. In this way, they are able to visually show relationships and gaps that are otherwise hard to uncover.
[![ML for beginners - How to Visualize Data with Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML for beginners - How to Visualize Data with Matplotlib")
> 🎥 Click the image above for a short video on visualizing the data for this lesson.
> 🎥 Click the image above for a short video working through visualizing the data for this lesson.
Visualizations can also help determine the most suitable machine learning technique for the data. For example, a scatterplot that follows a line suggests the data is a good candidate for linear regression.
Visualizations can also help determine the machine learning technique most appropriate for the data. A scatterplot that seems to follow a line, for example, indicates that the data is a good candidate for a linear regression exercise.
One data visualization library that works well in Jupyter notebooks is [Matplotlib](https://matplotlib.org/) (introduced in the previous lesson).
One data visualization library that works well in Jupyter notebooks is [Matplotlib](https://matplotlib.org/) (which you also saw in the previous lesson).
> Gain more experience with data visualization in [these tutorials](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
> Get more experience with data visualization in [these tutorials](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
## Exercise - experiment with Matplotlib
Try creating some basic plots to display the new dataframe you just created. What insights can a simple line plot provide?
Try to create some basic plots to display the new dataframe you just created. What would a basic line plot show?
1. Import Matplotlib at the top of the file, under the Pandas import:
@ -174,15 +174,15 @@ Try creating some basic plots to display the new dataframe you just created. Wha
plt.show()
```
![A scatterplot showing price to month relationship](../../../../2-Regression/2-Data/images/scatterplot.png)
![A scatterplot showing price to month relationship](../../../../translated_images/en/scatterplot.b6868f44cbd2051c.webp)
Is this plot useful? Does anything about it surprise you?
Is this a useful plot? Does anything about it surprise you?
It's not particularly useful, as it simply displays the data as a spread of points for each month.
It's not particularly useful as all it does is display in your data as a spread of points in a given month.
### Make it useful
To create more meaningful charts, you often need to group the data. Let's try creating a plot where the y-axis shows the months and the data demonstrates the distribution.
To get charts to display useful data, you usually need to group the data somehow. Let's try creating a plot where the y axis shows the months and the data demonstrates the distribution of data.
1. Add a cell to create a grouped bar chart:
@ -191,21 +191,96 @@ To create more meaningful charts, you often need to group the data. Let's try cr
plt.ylabel("Pumpkin Price")
```
![A bar chart showing price to month relationship](../../../../2-Regression/2-Data/images/barchart.png)
![A bar chart showing price to month relationship](../../../../translated_images/en/barchart.a833ea9194346d76.webp)
This is a more useful data visualization! It seems to indicate that the highest price for pumpkins occurs in September and October. Does that meet your expectation? Why or why not?
## Exercise - experiment with Seaborn
Matplotlib is powerful, but it can take a lot of code to produce a polished chart. [Seaborn](https://seaborn.pydata.org/) is a library built _on top of_ Matplotlib that is designed for statistical data visualization. It works directly with Pandas dataframes, applies attractive default styles, and lets you create informative plots with far less code. Because Seaborn returns Matplotlib objects, you can still use everything you already know about Matplotlib to fine-tune the result.
> If you don't already have Seaborn installed, install it with `pip install seaborn`.
1. Import Seaborn at the top of the notebook, under the other imports. It is conventionally imported as `sns`:
```python
import seaborn as sns
```
### Scatter plots to show relationships
A big part of exploring data before building a model is looking for _relationships_ between variables. A [scatter plot](https://en.wikipedia.org/wiki/Scatter_plot) is one of the best tools for this: if the points seem to follow a line, the two variables may be correlated, which is a good sign that a linear regression model could work.
1. Recreate the price-to-month scatter plot from before, this time using Seaborn's [`relplot()`](https://seaborn.pydata.org/generated/seaborn.relplot.html) (relational plot), which works directly with your dataframe columns:
```python
sns.relplot(x="Price", y="Month", data=new_pumpkins)
```
![A Seaborn scatterplot showing price to month relationship](../../../../translated_images/en/relplot.a03837d8f0329cec.webp)
Notice how you pass the _column names_ and the dataframe, and Seaborn takes care of the axis labels for you.
2. You can switch to a line plot by passing `kind="line"`. Seaborn even draws a shaded band showing the confidence interval around the line:
```python
sns.relplot(x="Price", y="Month", kind="line", data=new_pumpkins)
```
![A Seaborn line plot showing price to month relationship](../../../../translated_images/en/lineplot.f9034ba47b1e30ee.webp)
This particular data is quite noisy, so a line plot isn't the clearest choice here — but it shows how easily you can change chart types in Seaborn.
### Bar charts to show distributions
Earlier you grouped the data by hand to create a bar chart with Matplotlib. Seaborn's [`catplot()`](https://seaborn.pydata.org/generated/seaborn.catplot.html) (categorical plot) can do the grouping and aggregation for you. By default `kind="bar"` shows the mean of each category along with a black line indicating the confidence interval.
1. Create a bar chart of average price per month:
```python
sns.catplot(x="Month", y="Price", data=new_pumpkins, kind="bar")
```
![A Seaborn bar chart showing the price distribution per month](../../../../translated_images/en/catplot.e73fc35fdf96242b.webp)
This confirms what you saw with Matplotlib — prices peak around September and October — but Seaborn also visualizes how much the price _varies_ within each month.
### Heatmaps to show correlations
Scatter plots compare two variables at a time. When you have several numeric columns, a [heatmap](https://en.wikipedia.org/wiki/Heat_map) lets you view the strength of the relationship between _every_ pair of columns at once. This is a common way to spot which features are most correlated before choosing what to feed into a model (and the same kind of chart is later used to display confusion matrices in classification).
1. Build a correlation matrix with Pandas, then draw it with Seaborn's [`heatmap()`](https://seaborn.pydata.org/generated/seaborn.heatmap.html). The `annot=True` option prints the correlation values on each cell:
```python
correlations = new_pumpkins[['Month', 'Low Price', 'High Price', 'Price']].corr()
sns.heatmap(correlations, annot=True, cmap="coolwarm")
```
![A Seaborn heatmap showing correlations between the numeric columns](../../../../translated_images/en/heatmap.bd98dce43b404c57.webp)
Values close to `1` (or `-1`) mean the columns are strongly _linearly_ correlated. Notice how `Low Price` and `High Price` are almost perfectly correlated. `Month`, on the other hand, shows only a weak linear correlation with price — even though the bar chart above revealed a clear seasonal peak in September and October. That's an important lesson: the correlation coefficient only measures _straight-line_ relationships, so it can miss seasonal or otherwise non-linear patterns. ✅ Why is it useful to look at both a heatmap *and* charts like the bar chart before deciding which columns to use?
### Matplotlib or Seaborn?
Both libraries are worth knowing:
- **Matplotlib** gives you fine-grained control over every element of a chart and is the foundation almost every other Python plotting library builds on.
- **Seaborn** provides higher-level functions and attractive defaults for statistical charts, works directly with dataframes, and is often quicker for exploratory data analysis.
This visualization is more useful! It suggests that pumpkin prices peak in September and October. Does this match your expectations? Why or why not?
A common workflow is to reach for Seaborn to explore your data quickly, then drop down to Matplotlib when you need to customize the details.
---
## 🚀Challenge
Explore the different types of visualizations offered by Matplotlib. Which types are most suitable for regression problems?
Explore the different types of visualization that Matplotlib and Seaborn offer. Which types are most appropriate for regression problems?
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Review & Self Study
Investigate the various ways to visualize data. Make a list of available libraries and note which are best for specific tasks, such as 2D vs. 3D visualizations. What do you discover?
Take a look at the many ways to visualize data. Make a list of the various libraries available and note which are best for given types of tasks, for example 2D visualizations vs. 3D visualizations. What do you discover?
## Assignment
@ -213,5 +288,7 @@ Investigate the various ways to visualize data. Make a list of available librari
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using 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.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -222,6 +222,7 @@
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"pumpkins = pd.read_csv('../../data/US-pumpkins.csv')\n",
"\n",
"pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]\n",
@ -385,18 +386,78 @@
"plt.ylabel(\"Pumpkin Price\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Visualizing with Seaborn\n",
"\n",
"[Seaborn](https://seaborn.pydata.org/) is built on top of Matplotlib and works directly with dataframes, making it quick to create attractive statistical plots with very little code.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Scatter plots to show relationships\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.relplot(x=\"Price\", y=\"Month\", data=new_pumpkins)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.relplot(x=\"Price\", y=\"Month\", kind=\"line\", data=new_pumpkins)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Bar charts to show distributions\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.catplot(x=\"Month\", y=\"Price\", data=new_pumpkins, kind=\"bar\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Heatmaps to show correlations\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
"source": [
"correlations = new_pumpkins[['Month', 'Low Price', 'High Price', 'Price']].corr()\n",
"sns.heatmap(correlations, annot=True, cmap=\"coolwarm\")"
]
},
{
"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<!-- CO-OP TRANSLATOR DISCLAIMER START -->\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<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -426,13 +487,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "95726f0b8283628d5356a4f8eb8b4b76",
"translation_date": "2025-09-06T15:31:50+00:00",
"source_file": "2-Regression/2-Data/solution/notebook.ipynb",
"language_code": "en"
}
"orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2

@ -1,20 +1,268 @@
## Visualizing the Learned Policy
# Introduction to Reinforcement Learning and Q-Learning
After running the learning algorithm, we can visualize the Q-Table to see the learned policy. The arrows (or circles) in each cell will indicate the preferred direction of movement based on the Q-Table values. This visualization helps us understand how the agent has learned to navigate the environment.
![Summary of reinforcement in machine learning in a sketchnote](../../../../translated_images/en/ml-reinforcement.94024374d63348db.webp)
> Sketchnote by [Tomomi Imura](https://www.twitter.com/girlie_mac)
For example, the updated Q-Table might look like this:
Reinforcement learning involves three important concepts: the agent, some states, and a set of actions per state. By executing an action in a specified state, the agent is given a reward. Again imagine the computer game Super Mario. You are Mario, you are in a game level, standing next to a cliff edge. Above you is a coin. You being Mario, in a game level, at a specific position ... that's your state. Moving one step to the right (an action) will take you over the edge, and that would give you a low numerical score. However, pressing the jump button would let you score a point and you would stay alive. That's a positive outcome and that should award you a positive numerical score.
![Peter's Learned Policy](../../../../8-Reinforcement/1-QLearning/images/learned_policy.png)
By using reinforcement learning and a simulator (the game), you can learn how to play the game to maximize the reward which is staying alive and scoring as many points as possible.
In this visualization:
- The arrows point in the direction of the action with the highest Q-Table value for each state.
- The agent is more likely to follow these directions to reach the apple while avoiding the wolf and other obstacles.
[![Intro to Reinforcement Learning](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo)
## Testing the Learned Policy
> 🎥 Click the image above to hear Dmitry discuss Reinforcement Learning
Once the Q-Table is trained, we can test the learned policy by letting the agent navigate the environment using the Q-Table values. Instead of randomly choosing actions, the agent will now select the action with the highest Q-Table value at each state.
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
Run the following code to test the learned policy: (code block 9)
## Prerequisites and Setup
In this lesson, we will be experimenting with some code in Python. You should be able to run the Jupyter Notebook code from this lesson, either on your computer or somewhere in the cloud.
You can open [the lesson notebook](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) and walk through this lesson to build.
> **Note:** If you are opening this code from the cloud, you also need to fetch the [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py) file, which is used in the notebook code. Add it to the same directory as the notebook.
## Introduction
In this lesson, we will explore the world of **[Peter and the Wolf](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)**, inspired by a musical fairy tale by a Russian composer, [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). We will use **Reinforcement Learning** to let Peter explore his environment, collect tasty apples and avoid meeting the wolf.
**Reinforcement Learning** (RL) is a learning technique that allows us to learn an optimal behavior of an **agent** in some **environment** by running many experiments. An agent in this environment should have some **goal**, defined by a **reward function**.
## The environment
For simplicity, let's consider Peter's world to be a square board of size `width` x `height`, like this:
![Peter's Environment](../../../../translated_images/en/environment.40ba3cb66256c93f.webp)
Each cell in this board can either be:
* **ground**, on which Peter and other creatures can walk.
* **water**, on which you obviously cannot walk.
* a **tree** or **grass**, a place where you can rest.
* an **apple**, which represents something Peter would be glad to find in order to feed himself.
* a **wolf**, which is dangerous and should be avoided.
There is a separate Python module, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), which contains the code to work with this environment. Because this code is not important for understanding our concepts, we will import the module and use it to create the sample board (code block 1):
```python
from rlboard import *
width, height = 8,8
m = Board(width,height)
m.randomize(seed=13)
m.plot()
```
This code should print a picture of the environment similar to the one above.
## Actions and policy
In our example, Peter's goal would be able to find an apple, while avoiding the wolf and other obstacles. To do this, he can essentially walk around until he finds an apple.
Therefore, at any position, he can choose between one of the following actions: up, down, left and right.
We will define those actions as a dictionary, and map them to pairs of corresponding coordinate changes. For example, moving right (`R`) would correspond to a pair `(1,0)`. (code block 2):
```python
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
action_idx = { a : i for i,a in enumerate(actions.keys()) }
```
To sum up, the strategy and goal of this scenario are as follows:
- **The strategy**, of our agent (Peter) is defined by a so-called **policy**. A policy is a function that returns the action at any given state. In our case, the state of the problem is represented by the board, including the current position of the player.
- **The goal**, of reinforcement learning is to eventually learn a good policy that will allow us to solve the problem efficiently. However, as a baseline, let's consider the simplest policy called **random walk**.
## Random walk
Let's first solve our problem by implementing a random walk strategy. With random walk, we will randomly choose the next action from the allowed actions, until we reach the apple (code block 3).
1. Implement the random walk with the below code:
```python
def random_policy(m):
return random.choice(list(actions))
def walk(m,policy,start_position=None):
n = 0 # number of steps
# set initial position
if start_position:
m.human = start_position
else:
m.random_start()
while True:
if m.at() == Board.Cell.apple:
return n # success!
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
return -1 # eaten by wolf or drowned
while True:
a = actions[policy(m)]
new_pos = m.move_pos(m.human,a)
if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
m.move(a) # do the actual move
break
n+=1
walk(m,random_policy)
```
The call to `walk` should return the length of the corresponding path, which can vary from one run to another.
1. Run the walk experiment a number of times (say, 100), and print the resulting statistics (code block 4):
```python
def print_statistics(policy):
s,w,n = 0,0,0
for _ in range(100):
z = walk(m,policy)
if z<0:
w+=1
else:
s += z
n += 1
print(f"Average path length = {s/n}, eaten by wolf: {w} times")
print_statistics(random_policy)
```
Note that the average length of a path is around 30-40 steps, which is quite a lot, given the fact that the average distance to the nearest apple is around 5-6 steps.
You can also see what Peter's movement looks like during the random walk:
![Peter's Random Walk](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)
## Reward function
To make our policy more intelligent, we need to understand which moves are "better" than others. To do this, we need to define our goal.
The goal can be defined in terms of a **reward function**, which will return some score value for each state. The higher the number, the better the reward function. (code block 5)
```python
move_reward = -0.1
goal_reward = 10
end_reward = -10
def reward(m,pos=None):
pos = pos or m.human
if not m.is_valid(pos):
return end_reward
x = m.at(pos)
if x==Board.Cell.water or x == Board.Cell.wolf:
return end_reward
if x==Board.Cell.apple:
return goal_reward
return move_reward
```
An interesting thing about reward functions is that in most cases, *we are only given a substantial reward at the end of the game*. This means that our algorithm should somehow remember "good" steps that lead to a positive reward at the end, and increase their importance. Similarly, all moves that lead to bad results should be discouraged.
## Q-Learning
An algorithm that we will discuss here is called **Q-Learning**. In this algorithm, the policy is defined by a function (or a data structure) called a **Q-Table**. It records the "goodness" of each of the actions in a given state.
It is called a Q-Table because it is often convenient to represent it as a table, or multi-dimensional array. Since our board has dimensions `width` x `height`, we can represent the Q-Table using a numpy array with shape `width` x `height` x `len(actions)`: (code block 6)
```python
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
```
Notice that we initialize all the values of the Q-Table with an equal value, in our case - 0.25. This corresponds to the "random walk" policy, because all moves in each state are equally good. We can pass the Q-Table to the `plot` function in order to visualize the table on the board: `m.plot(Q)`.
![Peter's Environment](../../../../translated_images/en/env_init.04e8f26d2d60089e.webp)
In the center of each cell there is an "arrow" that indicates the preferred direction of movement. Since all directions are equal, a dot is displayed.
Now we need to run the simulation, explore our environment, and learn a better distribution of Q-Table values, which will allow us to find the path to the apple much faster.
## Essence of Q-Learning: Bellman Equation
Once we start moving, each action will have a corresponding reward, i.e. we can theoretically select the next action based on the highest immediate reward. However, in most states, the move will not achieve our goal of reaching the apple, and thus we cannot immediately decide which direction is better.
> Remember that it is not the immediate result that matters, but rather the final result, which we will obtain at the end of the simulation.
In order to account for this delayed reward, we need to use the principles of **[dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming)**, which allow us to think about out problem recursively.
Suppose we are now at the state *s*, and we want to move to the next state *s'*. By doing so, we will receive the immediate reward *r(s,a)*, defined by the reward function, plus some future reward. If we suppose that our Q-Table correctly reflects the "attractiveness" of each action, then at state *s'* we will chose an action *a* that corresponds to maximum value of *Q(s',a')*. Thus, the best possible future reward we could get at state *s* will be defined as `max`<sub>a'</sub>*Q(s',a')* (maximum here is computed over all possible actions *a'* at state *s'*).
This gives the **Bellman formula** for calculating the value of the Q-Table at state *s*, given action *a*:
<img src="../../../../translated_images/en/bellman-equation.7c0c4c722e5a6b7c.webp"/>
Here γ is the so-called **discount factor** that determines to which extent you should prefer the current reward over the future reward and vice versa.
## Learning Algorithm
Given the equation above, we can now write pseudo-code for our learning algorithm:
* Initialize Q-Table Q with equal numbers for all states and actions
* Set learning rate α ← 1
* Repeat simulation many times
1. Start at random position
1. Repeat
1. Select an action *a* at state *s*
2. Execute action by moving to a new state *s'*
3. If we encounter end-of-game condition, or total reward is too small - exit simulation
4. Compute reward *r* at the new state
5. Update Q-Function according to Bellman equation: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
6. *s* ← *s'*
7. Update the total reward and decrease α.
## Exploit vs. explore
In the algorithm above, we did not specify how exactly we should choose an action at step 2.1. If we are choosing the action randomly, we will randomly **explore** the environment, and we are quite likely to die often as well as explore areas where we would not normally go. An alternative approach would be to **exploit** the Q-Table values that we already know, and thus to choose the best action (with higher Q-Table value) at state *s*. This, however, will prevent us from exploring other states, and it's likely we might not find the optimal solution.
Thus, the best approach is to strike a balance between exploration and exploitation. This can be done by choosing the action at state *s* with probabilities proportional to values in the Q-Table. In the beginning, when Q-Table values are all the same, it would correspond to a random selection, but as we learn more about our environment, we would be more likely to follow the optimal route while allowing the agent to choose the unexplored path once in a while.
## Python implementation
We are now ready to implement the learning algorithm. Before we do that, we also need some function that will convert arbitrary numbers in the Q-Table into a vector of probabilities for corresponding actions.
1. Create a function `probs()`:
```python
def probs(v,eps=1e-4):
v = v-v.min()+eps
v = v/v.sum()
return v
```
We add a few `eps` to the original vector in order to avoid division by 0 in the initial case, when all components of the vector are identical.
Run them learning algorithm through 5000 experiments, also called **epochs**: (code block 8)
```python
for epoch in range(5000):
# Pick initial point
m.random_start()
# Start travelling
n=0
cum_reward = 0
while True:
x,y = m.human
v = probs(Q[x,y])
a = random.choices(list(actions),weights=v)[0]
dpos = actions[a]
m.move(dpos,check_correctness=False) # we allow player to move outside the board, which terminates episode
r = reward(m)
cum_reward += r
if r==end_reward or cum_reward < -1000:
lpath.append(n)
break
alpha = np.exp(-n / 10e5)
gamma = 0.5
ai = action_idx[a]
Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max())
n+=1
```
After executing this algorithm, the Q-Table should be updated with values that define the attractiveness of different actions at each step. We can try to visualize the Q-Table by plotting a vector at each cell that will point in the desired direction of movement. For simplicity, we draw a small circle instead of an arrow head.
<img src="../../../../translated_images/en/learned.ed28bcd8484b5287.webp"/>
## Checking the policy
Since the Q-Table lists the "attractiveness" of each action at each state, it is quite easy to use it to define the efficient navigation in our world. In the simplest case, we can select the action corresponding to the highest Q-Table value: (code block 9)
```python
def qpolicy_strict(m):
@ -26,57 +274,55 @@ def qpolicy_strict(m):
walk(m,qpolicy_strict)
```
This code will simulate the agent's movement based on the learned policy. You can observe how efficiently the agent reaches the apple compared to the random walk strategy.
## Results and Observations
> If you try the code above several times, you may notice that sometimes it "hangs", and you need to press the STOP button in the notebook to interrupt it. This happens because there could be situations when two states "point" to each other in terms of optimal Q-Value, in which case the agents ends up moving between those states indefinitely.
After training the agent using Q-Learning:
- The agent should be able to reach the apple in significantly fewer steps compared to the random walk strategy.
- The learned policy will guide the agent to avoid the wolf and other obstacles while maximizing the reward.
## 🚀Challenge
You can also visualize the agent's movement during the test run:
> **Task 1:** Modify the `walk` function to limit the maximum length of path by a certain number of steps (say, 100), and watch the code above return this value from time to time.
![Peter's Learned Movement](../../../../8-Reinforcement/1-QLearning/images/learned_movement.gif)
> **Task 2:** Modify the `walk` function so that it does not go back to the places where it has already been previously. This will prevent `walk` from looping, however, the agent can still end up being "trapped" in a location from which it is unable to escape.
Notice how the agent's movements are more purposeful and efficient compared to the random walk.
## Navigation
## Summary
A better navigation policy would be the one that we used during training, which combines exploitation and exploration. In this policy, we will select each action with a certain probability, proportional to the values in the Q-Table. This strategy may still result in the agent returning back to a position it has already explored, but, as you can see from the code below, it results in a very short average path to the desired location (remember that `print_statistics` runs the simulation 100 times): (code block 10)
In this lesson, we explored the basics of reinforcement learning and implemented the Q-Learning algorithm to train an agent to navigate an environment. Here's what we covered:
- The concepts of states, actions, rewards, and policies in reinforcement learning.
- How to define a reward function to guide the agent's learning process.
- The Bellman equation and its role in updating the Q-Table.
- The balance between exploration and exploitation during training.
- How to implement and visualize the Q-Learning algorithm in Python.
```python
def qpolicy(m):
x,y = m.human
v = probs(Q[x,y])
a = random.choices(list(actions),weights=v)[0]
return a
By the end of this lesson, you should have a solid understanding of how reinforcement learning works and how Q-Learning can be used to solve problems in a simulated environment.
print_statistics(qpolicy)
```
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
After running this code, you should get a much smaller average path length than before, in the range of 3-6.
## Assignment
## Investigating the learning process
1. Modify the reward function to include penalties for stepping into water or grass. How does this affect the agent's learning process and the resulting policy?
2. Experiment with different values of the discount factor (γ) and learning rate (α). How do these parameters influence the agent's behavior and the speed of learning?
3. Create a new environment with a different layout (e.g., more obstacles, multiple apples, or multiple wolves). Train the agent in this new environment and observe how it adapts.
As we have mentioned, the learning process is a balance between exploration and exploration of gained knowledge about the structure of problem space. We have seen that the results of learning (the ability to help an agent to find a short path to the goal) has improved, but it is also interesting to observe how the average path length behaves during the learning process:
By completing these assignments, you'll gain a deeper understanding of how to fine-tune reinforcement learning algorithms and apply them to various scenarios.
<img src="../../../../translated_images/en/lpathlen1.0534784add58d4eb.webp"/>
The learnings can be summarized as:
- **Average path length increases**. Initially, the average path length increases. This is likely because, when we know nothing about the environment, the agent is prone to getting stuck in unfavorable states, such as water or encountering a wolf. As the agent gathers more knowledge and begins to use it, it can explore the environment for longer periods, but it still doesn't have a clear understanding of where the apples are located.
- **Average path length increases**. What we see here is that at first, the average path length increases. This is probably due to the fact that when we know nothing about the environment, we are likely to get trapped in bad states, water or wolf. As we learn more and start using this knowledge, we can explore the environment for longer, but we still do not know where the apples are very well.
- **Path length decreases as we learn more**. Once the agent has learned enough, it becomes easier to achieve the goal, and the path length starts to decrease. However, since the agent is still exploring, it occasionally deviates from the optimal path to investigate new possibilities, which can make the path longer than necessary.
- **Path length decrease, as we learn more**. Once we learn enough, it becomes easier for the agent to achieve the goal, and the path length starts to decrease. However, we are still open to exploration, so we often diverge away from the best path, and explore new options, making the path longer than optimal.
- **Abrupt length increase**. Another observation from the graph is that, at some point, the path length increases abruptly. This highlights the stochastic nature of the process, where the Q-Table coefficients can be "spoiled" by being overwritten with new values. Ideally, this should be minimized by reducing the learning rate (e.g., toward the end of training, adjusting Q-Table values by only small amounts).
- **Length increase abruptly**. What we also observe on this graph is that at some point, the length increased abruptly. This indicates the stochastic nature of the process, and that we can at some point "spoil" the Q-Table coefficients by overwriting them with new values. This ideally should be minimized by decreasing learning rate (for example, towards the end of training, we only adjust Q-Table values by a small value).
Overall, its important to note that the success and quality of the learning process depend heavily on parameters such as the learning rate, learning rate decay, and discount factor. These are often referred to as **hyperparameters**, to distinguish them from **parameters**, which are optimized during training (e.g., Q-Table coefficients). The process of finding the best hyperparameter values is called **hyperparameter optimization**, which is a topic worthy of its own discussion.
Overall, it is important to remember that the success and quality of the learning process significantly depends on parameters, such as learning rate, learning rate decay, and discount factor. Those are often called **hyperparameters**, to distinguish them from **parameters**, which we optimize during training (for example, Q-Table coefficients). The process of finding the best hyperparameter values is called **hyperparameter optimization**, and it deserves a separate topic.
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Assignment
## Assignment
[A More Realistic World](assignment.md)
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**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.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,14 +1,34 @@
# CartPole Skating
The problem we have been solving in the previous lesson might seem like a toy problem, not really applicable for real life scenarios. This is not the case, because many real world problems also share this scenario - including playing Chess or Go. They are similar, because we also have a board with given rules and a **discrete state**.
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
## Introduction
In this lesson we will apply the same principles of Q-Learning to a problem with **continuous state**, i.e. a state that is given by one or more real numbers. We will deal with the following problem:
> **Problem**: If Peter wants to escape from the wolf, he needs to be able to move faster. We will see how Peter can learn to skate, in particular, to keep balance, using Q-Learning.
![The great escape!](../../../../translated_images/en/escape.18862db9930337e3.webp)
> Peter and his friends get creative to escape the wolf! Image by [Jen Looper](https://twitter.com/jenlooper)
We will use a simplified version of balancing known as a **CartPole** problem. In the cartpole world, we have a horizontal slider that can move left or right, and the goal is to balance a vertical pole on top of the slider.
<img alt="a cartpole" src="../../../../translated_images/en/cartpole.b5609cc0494a14f7.webp" width="200"/>
## Prerequisites
In this lesson, we will use a library called **OpenAI Gym** to simulate different **environments**. You can run the code for this lesson locally (e.g., using Visual Studio Code), in which case the simulation will open in a new window. If you're running the code online, you may need to make some adjustments, as described [here](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
In this lesson, we will be using a library called **OpenAI Gym** to simulate different **environments**. You can run this lesson's code locally (eg. from Visual Studio Code), in which case the simulation will open in a new window. When running the code online, you may need to make some tweaks to the code, as described [here](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
## OpenAI Gym
In the previous lesson, the rules of the game and the state were defined by the `Board` class that we created ourselves. Here, we will use a specialized **simulation environment** to simulate the physics of the balancing pole. One of the most popular simulation environments for training reinforcement learning algorithms is called [Gym](https://gym.openai.com/), maintained by [OpenAI](https://openai.com/). Using Gym, we can create various **environments**, ranging from cartpole simulations to Atari games.
In the previous lesson, the rules of the game and the state were given by the `Board` class which we defined ourselves. Here we will use a special **simulation environment**, which will simulate the physics behind the balancing pole. One of the most popular simulation environments for training reinforcement learning algorithms is called a [Gym](https://gym.openai.com/), which is maintained by [OpenAI](https://openai.com/). By using this gym we can create difference **environments** from a cartpole simulation to Atari games.
> **Note**: You can explore other environments available in OpenAI Gym [here](https://gym.openai.com/envs/#classic_control).
> **Note**: You can see other environments available from OpenAI Gym [here](https://gym.openai.com/envs/#classic_control).
First, let's install Gym and import the required libraries (code block 1):
First, let's install the gym and import required libraries (code block 1):
```python
import sys
@ -20,15 +40,15 @@ import numpy as np
import random
```
## Exercise - Initialize a CartPole Environment
## Exercise - initialize a cartpole environment
To work on the cartpole balancing problem, we need to initialize the corresponding environment. Each environment is associated with:
To work with a cartpole balancing problem, we need to initialize corresponding environment. Each environment is associated with an:
- **Observation space**, which defines the structure of the information we receive from the environment. For the cartpole problem, we receive the position of the pole, velocity, and other values.
- **Observation space** that defines the structure of information that we receive from the environment. For cartpole problem, we receive position of the pole, velocity and some other values.
- **Action space**, which defines the possible actions. In this case, the action space is discrete and consists of two actions: **left** and **right**. (code block 2)
- **Action space** that defines possible actions. In our case the action space is discrete, and consists of two actions - **left** and **right**. (code block 2)
1. To initialize the environment, type the following code:
1. To initialize, type the following code:
```python
env = gym.make("CartPole-v1")
@ -37,11 +57,11 @@ To work on the cartpole balancing problem, we need to initialize the correspondi
print(env.action_space.sample())
```
To understand how the environment works, let's run a short simulation for 100 steps. At each step, we provide an action to be taken—here, we randomly select an action from `action_space`.
To see how the environment works, let's run a short simulation for 100 steps. At each step, we provide one of the actions to be taken - in this simulation we just randomly select an action from `action_space`.
1. Run the code below and observe the results.
1. Run the code below and see what it leads to.
It's recommended to run this code on a local Python installation! (code block 3)
Remember that it is preferred to run this code on local Python installation! (code block 3)
```python
env.reset()
@ -52,11 +72,11 @@ To understand how the environment works, let's run a short simulation for 100 st
env.close()
```
You should see something similar to this image:
You should be seeing something similar to this image:
![non-balancing cartpole](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)
1. During the simulation, we need to gather observations to decide on the next action. The `step` function returns the current observations, a reward value, and a flag (`done`) indicating whether the simulation should continue or stop: (code block 4)
1. During simulation, we need to get observations in order to decide how to act. In fact, the step function returns current observations, a reward function, and the done flag that indicates whether it makes sense to continue the simulation or not: (code block 4)
```python
env.reset()
@ -69,7 +89,7 @@ To understand how the environment works, let's run a short simulation for 100 st
env.close()
```
You will see output similar to this in the notebook:
You will end up seeing something like this in the notebook output:
```text
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0
@ -82,36 +102,36 @@ To understand how the environment works, let's run a short simulation for 100 st
[ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0
```
The observation vector returned at each step contains the following values:
- Position of the cart
- Velocity of the cart
- Angle of the pole
- Rotation rate of the pole
The observation vector that is returned at each step of the simulation contains the following values:
- Position of cart
- Velocity of cart
- Angle of pole
- Rotation rate of pole
1. Retrieve the minimum and maximum values of these numbers: (code block 5)
1. Get min and max value of those numbers: (code block 5)
```python
print(env.observation_space.low)
print(env.observation_space.high)
```
You may also notice that the reward value at each simulation step is always 1. This is because the goal is to survive as long as possible, i.e., to keep the pole reasonably vertical for the longest time.
✅ The CartPole simulation is considered solved if we achieve an average reward of 195 over 100 consecutive trials.
You may also notice that reward value on each simulation step is always 1. This is because our goal is to survive as long as possible, i.e. keep the pole to a reasonably vertical position for the longest period of time.
## State Discretization
✅ In fact, the CartPole simulation is considered solved if we manage to get the average reward of 195 over 100 consecutive trials.
In Q-Learning, we need to build a Q-Table that defines the actions for each state. To do this, the state must be **discrete**, meaning it should consist of a finite number of discrete values. Therefore, we need to **discretize** our observations, mapping them to a finite set of states.
## State discretization
There are a few ways to achieve this:
In Q-Learning, we need to build Q-Table that defines what to do at each state. To be able to do this, we need state to be **discrete**, more precisely, it should contain finite number of discrete values. Thus, we need somehow to **discretize** our observations, mapping them to a finite set of states.
- **Divide into bins**: If we know the range of a value, we can divide it into a number of **bins** and replace the value with the bin number it belongs to. This can be done using the numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html) method. This approach gives precise control over the state size, as it depends on the number of bins chosen for discretization.
There are a few ways we can do this:
✅ Alternatively, we can use linear interpolation to map values to a finite interval (e.g., from -20 to 20) and then convert them to integers by rounding. This approach offers less control over the state size, especially if the exact ranges of input values are unknown. For example, in our case, 2 out of 4 values lack upper/lower bounds, which could result in an infinite number of states.
- **Divide into bins**. If we know the interval of a certain value, we can divide this interval into a number of **bins**, and then replace the value by the bin number that it belongs to. This can be done using the numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html) method. In this case, we will precisely know the state size, because it will depend on the number of bins we select for digitalization.
✅ We can use linear interpolation to bring values to some finite interval (say, from -20 to 20), and then convert numbers to integers by rounding them. This gives us a bit less control on the size of the state, especially if we do not know the exact ranges of input values. For example, in our case 2 out of 4 values do not have upper/lower bounds on their values, which may result in the infinite number of states.
In this example, we'll use the second approach. As you'll notice later, despite undefined upper/lower bounds, these values rarely exceed certain finite intervals, making states with extreme values very rare.
In our example, we will go with the second approach. As you may notice later, despite undefined upper/lower bounds, those value rarely take values outside of certain finite intervals, thus those states with extreme values will be very rare.
1. Here's a function that takes the observation from our model and produces a tuple of 4 integer values: (code block 6)
1. Here is the function that will take the observation from our model and produce a tuple of 4 integer values: (code block 6)
```python
def discretize(x):
@ -134,9 +154,9 @@ In this example, we'll use the second approach. As you'll notice later, despite
return tuple(np.digitize(x[i],bins[i]) for i in range(4))
```
1. Now, run a short simulation and observe the discrete environment values. Feel free to try both `discretize` and `discretize_bins` to see if there's a difference.
1. Let's now run a short simulation and observe those discrete environment values. Feel free to try both `discretize` and `discretize_bins` and see if there is a difference.
`discretize_bins` returns the bin number, which is 0-based. For input values around 0, it returns the middle bin number (10). In `discretize`, we didn't constrain the output range, allowing negative values, so 0 corresponds directly to 0. (code block 8)
discretize_bins returns the bin number, which is 0-based. Thus for values of input variable around 0 it returns the number from the middle of the interval (10). In discretize, we did not care about the range of output values, allowing them to be negative, thus the state values are not shifted, and 0 corresponds to 0. (code block 8)
```python
env.reset()
@ -150,15 +170,15 @@ In this example, we'll use the second approach. As you'll notice later, despite
env.close()
```
✅ Uncomment the line starting with `env.render` if you want to visualize the environment's execution. Otherwise, you can run it in the background for faster execution. We'll use this "invisible" execution during the Q-Learning process.
✅ Uncomment the line starting with env.render if you want to see how the environment executes. Otherwise you can execute it in the background, which is faster. We will use this "invisible" execution during our Q-Learning process.
## The Q-Table Structure
## The Q-Table structure
In the previous lesson, the state was a simple pair of numbers ranging from 0 to 8, making it convenient to represent the Q-Table as a numpy tensor with a shape of 8x8x2. If we use bin discretization, the size of our state vector is also known, so we can use a similar approach and represent the state as an array with a shape of 20x20x10x10x2 (where 2 corresponds to the action space dimension, and the first dimensions represent the number of bins chosen for each parameter in the observation space).
In our previous lesson, the state was a simple pair of numbers from 0 to 8, and thus it was convenient to represent Q-Table by a numpy tensor with a shape of 8x8x2. If we use bins discretization, the size of our state vector is also known, so we can use the same approach and represent state by an array of shape 20x20x10x10x2 (here 2 is the dimension of action space, and first dimensions correspond to the number of bins we have selected to use for each of the parameters in observation space).
However, sometimes the precise dimensions of the observation space are unknown. In the case of the `discretize` function, we can't guarantee that the state will remain within certain limits, as some original values are unbounded. Therefore, we'll use a slightly different approach and represent the Q-Table as a dictionary.
However, sometimes precise dimensions of the observation space are not known. In case of the `discretize` function, we may never be sure that our state stays within certain limits, because some of the original values are not bound. Thus, we will use a slightly different approach and represent Q-Table by a dictionary.
1. Use the pair *(state, action)* as the dictionary key, with the corresponding Q-Table entry value as the value. (code block 9)
1. Use the pair *(state,action)* as the dictionary key, and the value would correspond to Q-Table entry value. (code block 9)
```python
Q = {}
@ -168,13 +188,13 @@ However, sometimes the precise dimensions of the observation space are unknown.
return [Q.get((state,a),0) for a in actions]
```
Here, we also define a function `qvalues()` that returns a list of Q-Table values for a given state corresponding to all possible actions. If the entry isn't present in the Q-Table, it defaults to 0.
Here we also define a function `qvalues()`, which returns a list of Q-Table values for a given state that corresponds to all possible actions. If the entry is not present in the Q-Table, we will return 0 as the default.
## Let's Start Q-Learning
## Let's start Q-Learning
Now it's time to teach Peter how to balance!
Now we are ready to teach Peter to balance!
1. First, set some hyperparameters: (code block 10)
1. First, let's set some hyperparameters: (code block 10)
```python
# hyperparameters
@ -183,22 +203,23 @@ Now it's time to teach Peter how to balance!
epsilon = 0.90
```
Here:
- `alpha` is the **learning rate**, which determines how much we adjust the current Q-Table values at each step. In the previous lesson, we started with 1 and gradually decreased `alpha` during training. In this example, we'll keep it constant for simplicity, but you can experiment with adjusting `alpha` later.
- `gamma` is the **discount factor**, which indicates how much we prioritize future rewards over immediate rewards.
- `epsilon` is the **exploration/exploitation factor**, which decides whether to favor exploration or exploitation. In our algorithm, we'll select the next action based on Q-Table values in `epsilon` percent of cases, and choose a random action in the remaining cases. This helps explore areas of the search space that haven't been visited yet.
Here, `alpha` is the **learning rate** that defines to which extent we should adjust the current values of Q-Table at each step. In the previous lesson we started with 1, and then decreased `alpha` to lower values during training. In this example we will keep it constant just for simplicity, and you can experiment with adjusting `alpha` values later.
`gamma` is the **discount factor** that shows to which extent we should prioritize future reward over current reward.
✅ In terms of balancing, choosing a random action (exploration) acts like a random push in the wrong direction, forcing the pole to learn how to recover balance from these "mistakes."
`epsilon` is the **exploration/exploitation factor** that determines whether we should prefer exploration to exploitation or vice versa. In our algorithm, we will in `epsilon` percent of the cases select the next action according to Q-Table values, and in the remaining number of cases we will execute a random action. This will allow us to explore areas of the search space that we have never seen before.
### Improve the Algorithm
✅ In terms of balancing - choosing random action (exploration) would act as a random punch in the wrong direction, and the pole would have to learn how to recover the balance from those "mistakes"
We can make two improvements to the algorithm from the previous lesson:
### Improve the algorithm
- **Calculate average cumulative reward** over multiple simulations. We'll print progress every 5000 iterations and average the cumulative reward over that period. If we achieve more than 195 points, we can consider the problem solved, exceeding the required quality.
We can also make two improvements to our algorithm from the previous lesson:
- **Calculate average cumulative reward**, over a number of simulations. We will print the progress each 5000 iterations, and we will average out our cumulative reward over that period of time. It means that if we get more than 195 point - we can consider the problem solved, with even higher quality than required.
- **Track maximum average cumulative reward**, `Qmax`, and store the Q-Table corresponding to that result. During training, you'll notice that the average cumulative reward sometimes drops, so we want to preserve the Q-Table values corresponding to the best model observed.
- **Calculate maximum average cumulative result**, `Qmax`, and we will store the Q-Table corresponding to that result. When you run the training you will notice that sometimes the average cumulative result starts to drop, and we want to keep the values of Q-Table that correspond to the best model observed during training.
1. Collect all cumulative rewards from each simulation in the `rewards` vector for later plotting. (code block 11)
1. Collect all cumulative rewards at each simulation at `rewards` vector for further plotting. (code block 11)
```python
def probs(v,eps=1e-4):
@ -217,11 +238,11 @@ We can make two improvements to the algorithm from the previous lesson:
while not done:
s = discretize(obs)
if random.random()<epsilon:
# exploitation - chose the action according to Q-Table probabilities
# exploitation - choose the action according to Q-Table probabilities
v = probs(np.array(qvalues(s)))
a = random.choices(actions,weights=v)[0]
else:
# exploration - randomly chose the action
# exploration - randomly choose the action
a = np.random.randint(env.action_space.n)
obs, rew, done, info = env.step(a)
@ -239,25 +260,25 @@ We can make two improvements to the algorithm from the previous lesson:
cum_rewards=[]
```
What you'll notice from the results:
What you may notice from those results:
- **Close to the goal**: We're very close to achieving the goal of 195 cumulative rewards over 100+ consecutive runs, or we may have already achieved it! Even if the numbers are slightly lower, we can't be certain because we're averaging over 5000 runs, while the formal criteria require only 100 runs.
- **Close to our goal**. We are very close to achieving the goal of getting 195 cumulative rewards over 100+ consecutive runs of the simulation, or we may have actually achieved it! Even if we get smaller numbers, we still do not know, because we average over 5000 runs, and only 100 runs is required in the formal criteria.
- **Reward drops**: Sometimes the reward starts to drop, indicating that we might overwrite well-learned Q-Table values with worse ones.
- **Reward starts to drop**. Sometimes the reward start to drop, which means that we can "destroy" already learnt values in the Q-Table with the ones that make the situation worse.
This observation becomes clearer when we plot the training progress.
This observation is more clearly visible if we plot training progress.
## Plotting Training Progress
During training, we collected cumulative reward values at each iteration in the `rewards` vector. Here's how it looks when plotted against the iteration number:
During training, we have collected the cumulative reward value at each of the iterations into `rewards` vector. Here is how it looks when we plot it against the iteration number:
```python
plt.plot(rewards)
```
![raw progress](../../../../8-Reinforcement/2-Gym/images/train_progress_raw.png)
![raw progress](../../../../translated_images/en/train_progress_raw.2adfdf2daea09c59.webp)
This graph doesn't provide much insight due to the stochastic nature of the training process, which causes session lengths to vary significantly. To make the graph more meaningful, we can calculate the **running average** over a series of experiments, say 100. This can be done conveniently using `np.convolve`: (code block 12)
From this graph, it is not possible to tell anything, because due to the nature of stochastic training process the length of training sessions varies greatly. To make more sense of this graph, we can calculate the **running average** over a series of experiments, let's say 100. This can be done conveniently using `np.convolve`: (code block 12)
```python
def running_average(x,window):
@ -266,21 +287,24 @@ def running_average(x,window):
plt.plot(running_average(rewards,100))
```
![training progress](../../../../8-Reinforcement/2-Gym/images/train_progress_runav.png)
![training progress](../../../../translated_images/en/train_progress_runav.c71694a8fa9ab359.webp)
## Varying hyperparameters
To make learning more stable, it makes sense to adjust some of our hyperparameters during training. In particular:
- **For learning rate**, `alpha`, we may start with values close to 1, and then keep decreasing the parameter. With time, we will be getting good probability values in the Q-Table, and thus we should be adjusting them slightly, and not overwriting completely with new values.
## Adjusting Hyperparameters
- **Increase epsilon**. We may want to increase the `epsilon` slowly, in order to explore less and exploit more. It probably makes sense to start with lower value of `epsilon`, and move up to almost 1.
To make learning more stable, we can adjust some hyperparameters during training. Specifically:
> **Task 1**: Play with hyperparameter values and see if you can achieve higher cumulative reward. Are you getting above 195?
- **Learning rate (`alpha`)**: Start with values close to 1 and gradually decrease it. Over time, as the Q-Table values become more reliable, adjustments should be smaller to avoid overwriting good values completely.
- **Exploration factor (`epsilon`)**: Gradually increase `epsilon` to explore less and exploit more. It might be better to start with a lower `epsilon` value and increase it to nearly 1 over time.
> **Task 1**: Experiment with the hyperparameter values and see if you can achieve a higher cumulative reward. Are you reaching above 195?
> **Task 2**: To formally solve the problem, you need to achieve an average reward of 195 across 100 consecutive runs. Track this during training to ensure the problem is officially solved!
> **Task 2**: To formally solve the problem, you need to get 195 average reward across 100 consecutive runs. Measure that during training and make sure that you have formally solved the problem!
## Seeing the result in action
Its fascinating to observe how the trained model performs. Lets run the simulation and use the same action selection strategy as during training, sampling based on the probability distribution in the Q-Table: (code block 13)
It would be interesting to actually see how the trained model behaves. Let's run the simulation and follow the same action selection strategy as during training, sampling according to the probability distribution in Q-Table: (code block 13)
```python
obs = env.reset()
@ -294,7 +318,7 @@ while not done:
env.close()
```
You should see something similar to this:
You should see something like this:
![a balancing cartpole](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif)
@ -302,9 +326,9 @@ You should see something similar to this:
## 🚀Challenge
> **Task 3**: In this example, we used the final version of the Q-Table, which might not be the optimal one. Remember, we saved the best-performing Q-Table in the `Qbest` variable! Try running the same example using the best-performing Q-Table by copying `Qbest` into `Q` and observe if theres any noticeable difference.
> **Task 3**: Here, we were using the final copy of Q-Table, which may not be the best one. Remember that we have stored the best-performing Q-Table into `Qbest` variable! Try the same example with the best-performing Q-Table by copying `Qbest` over to `Q` and see if you notice the difference.
> **Task 4**: In this example, we didnt always select the best action at each step but instead sampled actions based on the corresponding probability distribution. Would it be better to always choose the best action—the one with the highest Q-Table value? This can be achieved using the `np.argmax` function to identify the action number with the highest Q-Table value. Implement this strategy and check if it improves the balancing performance.
> **Task 4**: Here we were not selecting the best action on each step, but rather sampling with corresponding probability distribution. Would it make more sense to always select the best action, with the highest Q-Table value? This can be done by using `np.argmax` function to find out the action number corresponding to higher Q-Table value. Implement this strategy and see if it improves the balancing.
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
@ -313,11 +337,13 @@ You should see something similar to this:
## Conclusion
Weve now learned how to train agents to achieve strong results simply by providing them with a reward function that defines the desired state of the game and allowing them to intelligently explore the search space. We successfully applied the Q-Learning algorithm in both discrete and continuous environments, though with discrete actions.
We have now learned how to train agents to achieve good results just by providing them a reward function that defines the desired state of the game, and by giving them an opportunity to intelligently explore the search space. We have successfully applied the Q-Learning algorithm in the cases of discrete and continuous environments, but with discrete actions.
Its also crucial to study scenarios where the action space is continuous and the observation space is more complex, such as an image from an Atari game screen. In such cases, more advanced machine learning techniques, like neural networks, are often required to achieve good results. These advanced topics will be covered in our upcoming, more advanced AI course.
It's important to also study situations where action state is also continuous, and when observation space is much more complex, such as the image from the Atari game screen. In those problems we often need to use more powerful machine learning techniques, such as neural networks, in order to achieve good results. Those more advanced topics are the subject of our forthcoming more advanced AI course.
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using 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.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,113 +1,436 @@
Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and
Attribution-ShareAlike 4.0 International
=======================================================================
Creative Commons Corporation ("Creative Commons") is not a law firm and
does not provide legal services or legal advice. Distribution of
Creative Commons public licenses does not create a lawyer-client or
other relationship. Creative Commons makes its licenses and related
information available on an "as-is" basis. Creative Commons gives no
warranties regarding its licenses, any material licensed under their
terms and conditions, or any related information. Creative Commons
disclaims all liability for damages resulting from their use to the
fullest extent possible.
Using Creative Commons Public Licenses
Creative Commons public licenses provide a standard set of terms and
conditions that creators and other rights holders may use to share
original works of authorship and other material subject to copyright
and certain other rights specified in the public license below. The
following considerations are for informational purposes only, are not
exhaustive, and do not form part of our licenses.
Considerations for licensors: Our public licenses are
intended for use by those authorized to give the public
permission to use material in ways otherwise restricted by
copyright and certain other rights. Our licenses are
irrevocable. Licensors should read and understand the terms
and conditions of the license they choose before applying it.
Licensors should also secure all rights necessary before
applying our licenses so that the public can reuse the
material as expected. Licensors should clearly mark any
material not subject to the license. This includes other CC-
licensed material, or material used under an exception or
limitation to copyright. More considerations for licensors:
wiki.creativecommons.org/Considerations_for_licensors
Considerations for the public: By using one of our public
licenses, a licensor grants the public permission to use the
licensed material under specified terms and conditions. If
the licensor's permission is not necessary for any reason--for
example, because of any applicable exception or limitation to
copyright--then that use is not regulated by the license. Our
licenses grant only permissions under copyright and certain
other rights that a licensor has authority to grant. Use of
the licensed material may still be restricted for other
reasons, including because others have copyright or other
rights in the material. A licensor may make special requests,
such as asking that all changes be marked or described.
Although not required by our licenses, you are encouraged to
respect those requests where reasonable. More_considerations
for the public:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
Creative Commons Attribution-ShareAlike 4.0 International Public
License
By exercising the Licensed Rights (defined below), You accept and agree
to be bound by the terms and conditions of this Creative Commons
Attribution-ShareAlike 4.0 International Public License ("Public
License"). To the extent this Public License may be interpreted as a
contract, You are granted the Licensed Rights in consideration of Your
acceptance of these terms and conditions, and the Licensor grants You
such rights in consideration of benefits the Licensor receives from
making the Licensed Material available under these terms and
conditions.
Section 1 -- Definitions.
a. Adapted Material means material subject to Copyright and Similar
Rights that is derived from or based upon the Licensed Material
and in which the Licensed Material is translated, altered,
arranged, transformed, or otherwise modified in a manner requiring
permission under the Copyright and Similar Rights held by the
Licensor. For purposes of this Public License, where the Licensed
Material is a musical work, performance, or sound recording,
Adapted Material is always produced where the Licensed Material is
synched in timed relation with a moving image.
b. Adapter's License means the license You apply to Your Copyright
and Similar Rights in Your contributions to Adapted Material in
accordance with the terms and conditions of this Public License.
c. BY-SA Compatible License means a license listed at
creativecommons.org/compatiblelicenses, approved by Creative
Commons as essentially the equivalent of this Public License.
d. Copyright and Similar Rights means copyright and/or similar rights
closely related to copyright including, without limitation,
performance, broadcast, sound recording, and Sui Generis Database
Rights, without regard to how the rights are labeled or
categorized. For purposes of this Public License, the rights
specified in Section 2(b)(1)-(2) are not Copyright and Similar
Rights.
e. Effective Technological Measures means those measures that, in the
absence of proper authority, may not be circumvented under laws
fulfilling obligations under Article 11 of the WIPO Copyright
Treaty adopted on December 20, 1996, and/or similar international
agreements.
f. Exceptions and Limitations means fair use, fair dealing, and/or
any other exception or limitation to Copyright and Similar Rights
that applies to Your use of the Licensed Material.
g. License Elements means the license attributes listed in the name
of a Creative Commons Public License. The License Elements of this
Public License are Attribution and ShareAlike.
h. Licensed Material means the artistic or literary work, database,
or other material to which the Licensor applied this Public
License.
i. Licensed Rights means the rights granted to You subject to the
terms and conditions of this Public License, which are limited to
all Copyright and Similar Rights that apply to Your use of the
Licensed Material and that the Licensor has authority to license.
j. Licensor means the individual(s) or entity(ies) granting rights
under this Public License.
k. Share means to provide material to the public by any means or
process that requires permission under the Licensed Rights, such
as reproduction, public display, public performance, distribution,
dissemination, communication, or importation, and to make material
available to the public including in ways that members of the
public may access the material from a place and at a time
individually chosen by them.
l. Sui Generis Database Rights means rights other than copyright
resulting from Directive 96/9/EC of the European Parliament and of
the Council of 11 March 1996 on the legal protection of databases,
as amended and/or succeeded, as well as other essentially
equivalent rights anywhere in the world.
m. You means the individual or entity exercising the Licensed Rights
under this Public License. Your has a corresponding meaning.
Section 2 -- Scope.
a. License grant.
1. Subject to the terms and conditions of this Public License,
the Licensor hereby grants You a worldwide, royalty-free,
non-sublicensable, non-exclusive, irrevocable license to
exercise the Licensed Rights in the Licensed Material to:
a. reproduce and Share the Licensed Material, in whole or
in part; and
b. produce, reproduce, and Share Adapted Material.
2. Exceptions and Limitations. For the avoidance of doubt, where
Exceptions and Limitations apply to Your use, this Public
License does not apply, and You do not need to comply with
its terms and conditions.
3. Term. The term of this Public License is specified in Section
6(a).
4. Media and formats; technical modifications allowed. The
Licensor authorizes You to exercise the Licensed Rights in
all media and formats whether now known or hereafter created,
and to make technical modifications necessary to do so. The
Licensor waives and/or agrees not to assert any right or
authority to forbid You from making technical modifications
necessary to exercise the Licensed Rights, including
technical modifications necessary to circumvent Effective
Technological Measures. For purposes of this Public License,
simply making modifications authorized by this Section 2(a)
(4) never produces Adapted Material.
5. Downstream recipients.
a. Offer from the Licensor -- Licensed Material. Every
recipient of the Licensed Material automatically
receives an offer from the Licensor to exercise the
Licensed Rights under the terms and conditions of this
Public License.
b. Additional offer from the Licensor -- Adapted Material.
Every recipient of Adapted Material from You
automatically receives an offer from the Licensor to
exercise the Licensed Rights in the Adapted Material
under the conditions of the Adapter's License You apply.
c. No downstream restrictions. You may not offer or impose
any additional or different terms or conditions on, or
apply any Effective Technological Measures to, the
Licensed Material if doing so restricts exercise of the
Licensed Rights by any recipient of the Licensed
Material.
c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.
6. No endorsement. Nothing in this Public License constitutes or
may be construed as permission to assert or imply that You
are, or that Your use of the Licensed Material is, connected
with, or sponsored, endorsed, or granted official status by,
the Licensor or others designated to receive attribution as
provided in Section 3(a)(1)(A)(i).
For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.
b. Other rights.
1. Moral rights, such as the right of integrity, are not
licensed under this Public License, nor are publicity,
privacy, and/or other similar personality rights; however, to
the extent possible, the Licensor waives and/or agrees not to
assert any such rights held by the Licensor to the limited
extent necessary to allow You to exercise the Licensed
Rights, but not otherwise.
Section 5 -- Disclaimer of Warranties and Limitation of Liability.
2. Patent and trademark rights are not licensed under this
Public License.
a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not discoverable.
3. To the extent possible, the Licensor waives any right to
collect royalties from You for the exercise of the Licensed
Rights, whether directly or through a collecting society
under any voluntary or waivable statutory or compulsory
licensing scheme. In all other cases the Licensor expressly
reserves any right to collect such royalties.
b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages.
c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.
Section 3 -- License Conditions.
Your exercise of the Licensed Rights is expressly made subject to the
following conditions.
Section 6 -- Term and Termination.
a. Attribution.
a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, Your rights under this Public License terminate automatically.
1. If You Share the Licensed Material (including in modified
form), You must:
b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:
a. retain the following if it is supplied by the Licensor
with the Licensed Material:
1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or
i. identification of the creator(s) of the Licensed
Material and any others designated to receive
attribution, in any reasonable manner requested by
the Licensor (including by pseudonym if
designated);
2. upon express reinstatement by the Licensor.
ii. a copyright notice;
c. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.
iii. a notice that refers to this Public License;
d. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.
iv. a notice that refers to the disclaimer of
warranties;
e. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.
v. a URI or hyperlink to the Licensed Material to the
extent reasonably practicable;
b. indicate if You modified the Licensed Material and
retain an indication of any previous modifications; and
c. indicate the Licensed Material is licensed under this
Public License, and include the text of, or the URI or
hyperlink to, this Public License.
Section 7 -- Other Terms and Conditions.
2. You may satisfy the conditions in Section 3(a)(1) in any
reasonable manner based on the medium, means, and context in
which You Share the Licensed Material. For example, it may be
reasonable to satisfy the conditions by providing a URI or
hyperlink to a resource that includes the required
information.
a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.
3. If requested by the Licensor, You must remove any of the
information required by Section 3(a)(1)(A) to the extent
reasonably practicable.
b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated in this Public License are separate from and independent of the terms and conditions of this Public License.
b. ShareAlike.
In addition to the conditions in Section 3(a), if You Share
Adapted Material You produce, the following conditions also apply.
Section 8 -- Interpretation.
1. The Adapter's License You apply must be a Creative Commons
license with the same License Elements, this version or
later, or a BY-SA Compatible License.
a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.
2. You must include the text of, or the URI or hyperlink to, the
Adapter's License You apply. You may satisfy this condition
in any reasonable manner based on the medium, means, and
context in which You Share Adapted Material.
b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.
3. You may not offer or impose any additional or different terms
or conditions on, or apply any Effective Technological
Measures to, Adapted Material that restrict exercise of the
rights granted under the Adapter's License You apply.
c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.
d. Nothing in this Public License constitutes or may be interpreted as a limitation or waiver of any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.
Rights, then the database in which you hold Sui Generis Database Rights (but not its individual contents) is considered Adapted Material,
Section 4 -- Sui Generis Database Rights.
including for the purposes of Section 3(b); and
c. You must comply with the conditions in Section 3(a) if you share all or a substantial portion of the contents of the database.
Where the Licensed Rights include Sui Generis Database Rights that
apply to Your use of the Licensed Material:
For clarity, this Section 4 supplements and does not replace your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.
a. for the avoidance of doubt, Section 2(a)(1) grants You the right
to extract, reuse, reproduce, and Share all or a substantial
portion of the contents of the database;
---
b. if You include all or a substantial portion of the database
contents in a database in which You have Sui Generis Database
Rights, then the database in which You have Sui Generis Database
Rights (but not its individual contents) is Adapted Material,
**Section 5 -- Disclaimer of Warranties and Limitation of Liability**
including for purposes of Section 3(b); and
a. UNLESS OTHERWISE AGREED SEPARATELY BY THE LICENSOR, TO THE EXTENT POSSIBLE, THE LICENSOR PROVIDES THE LICENSED MATERIAL "AS IS" AND "AS AVAILABLE," AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND REGARDING THE LICENSED MATERIAL, WHETHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE. THIS INCLUDES, BUT IS NOT LIMITED TO, WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT FULLY OR PARTIALLY PERMITTED, THIS DISCLAIMER MAY NOT APPLY TO YOU.
c. You must comply with the conditions in Section 3(a) if You Share
all or a substantial portion of the contents of the database.
b. TO THE EXTENT POSSIBLE, UNDER NO CIRCUMSTANCES WILL THE LICENSOR BE LIABLE TO YOU UNDER ANY LEGAL THEORY (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, COSTS, EXPENSES, OR DAMAGES ARISING FROM THIS PUBLIC LICENSE OR USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR DAMAGES. WHERE LIMITATIONS OF LIABILITY ARE NOT FULLY OR PARTIALLY PERMITTED, THIS LIMITATION MAY NOT APPLY TO YOU.
For the avoidance of doubt, this Section 4 supplements and does not
replace Your obligations under this Public License where the Licensed
Rights include other Copyright and Similar Rights.
c. The disclaimer of warranties and limitation of liability outlined above shall be interpreted in a way that, to the extent possible, most closely resembles an absolute disclaimer and waiver of all liability.
---
Section 5 -- Disclaimer of Warranties and Limitation of Liability.
**Section 6 -- Term and Termination**
a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
a. This Public License remains in effect for the duration of the Copyright and Similar Rights licensed here. However, if you fail to comply with this Public License, your rights under this Public License terminate automatically.
b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
b. If your right to use the Licensed Material is terminated under Section 6(a), it may be reinstated:
c. The disclaimer of warranties and limitation of liability provided
above shall be interpreted in a manner that, to the extent
possible, most closely approximates an absolute disclaimer and
waiver of all liability.
1. Automatically as of the date the violation is remedied, provided it is remedied within 30 days of your discovery of the violation; or
2. Upon explicit reinstatement by the Licensor.
For clarity, this Section 6(b) does not affect any rights the Licensor may have to seek remedies for your violations of this Public License.
Section 6 -- Term and Termination.
c. For clarity, the Licensor may also offer the Licensed Material under separate terms or conditions or cease distributing the Licensed Material at any time; however, doing so does not terminate this Public License.
a. This Public License applies for the term of the Copyright and
Similar Rights licensed here. However, if You fail to comply with
this Public License, then Your rights under this Public License
terminate automatically.
d. Sections 1, 5, 6, 7, and 8 remain in effect even after termination of this Public License.
b. Where Your right to use the Licensed Material has terminated under
Section 6(a), it reinstates:
---
1. automatically as of the date the violation is cured, provided
it is cured within 30 days of Your discovery of the
violation; or
**Section 7 -- Other Terms and Conditions**
2. upon express reinstatement by the Licensor.
a. The Licensor is not bound by any additional or different terms or conditions communicated by you unless explicitly agreed upon.
For the avoidance of doubt, this Section 6(b) does not affect any
right the Licensor may have to seek remedies for Your violations
of this Public License.
b. Any arrangements, understandings, or agreements regarding the Licensed Material that are not stated here are separate from and independent of the terms and conditions of this Public License.
c. For the avoidance of doubt, the Licensor may also offer the
Licensed Material under separate terms or conditions or stop
distributing the Licensed Material at any time; however, doing so
will not terminate this Public License.
---
d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
License.
**Section 8 -- Interpretation**
a. For clarity, this Public License does not, and should not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.
Section 7 -- Other Terms and Conditions.
b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically adjusted to the minimum extent necessary to make it enforceable. If the provision cannot be adjusted, it shall be removed from this Public License without affecting the enforceability of the remaining terms and conditions.
a. The Licensor shall not be bound by any additional or different
terms or conditions communicated by You unless expressly agreed.
c. No term or condition of this Public License will be waived, and no failure to comply will be consented to unless explicitly agreed upon by the Licensor.
b. Any arrangements, understandings, or agreements regarding the
Licensed Material not stated herein are separate from and
independent of the terms and conditions of this Public License.
d. Nothing in this Public License constitutes or may be interpreted as a limitation on, or waiver of, any privileges and immunities that apply to the Licensor or you, including those arising from the legal processes of any jurisdiction or authority.
---
Section 8 -- Interpretation.
a. For the avoidance of doubt, this Public License does not, and
shall not be interpreted to, reduce, limit, restrict, or impose
conditions on any use of the Licensed Material that could lawfully
be made without permission under this Public License.
b. To the extent possible, if any provision of this Public License is
deemed unenforceable, it shall be automatically reformed to the
minimum extent necessary to make it enforceable. If the provision
cannot be reformed, it shall be severed from this Public License
without affecting the enforceability of the remaining terms and
conditions.
c. No term or condition of this Public License will be waived and no
failure to comply consented to unless expressly agreed to by the
Licensor.
d. Nothing in this Public License constitutes or may be interpreted
as a limitation upon, or waiver of, any privileges and immunities
that apply to the Licensor or You, including from the legal
processes of any jurisdiction or authority.
=======================================================================
Creative Commons is not a party to its public licenses. However, Creative Commons may choose to apply one of its public licenses to material it publishes, and in such cases, it will be considered the “Licensor.” The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark "Creative Commons" or any other trademark or logo of Creative Commons without prior written consent, including, but not limited to, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning the use of licensed material. For clarity, this paragraph is not part of the public licenses.
Creative Commons is not a party to its public
licenses. Notwithstanding, Creative Commons may elect to apply one of
its public licenses to material it publishes and in those instances
will be considered the “Licensor.” The text of the Creative Commons
public licenses is dedicated to the public domain under the CC0 Public
Domain Dedication. Except for the limited purpose of indicating that
material is shared under a Creative Commons public license or as
otherwise permitted by the Creative Commons policies published at
creativecommons.org/policies, Creative Commons does not authorize the
use of the trademark "Creative Commons" or any other trademark or logo
of Creative Commons without its prior written consent including,
without limitation, in connection with any unauthorized modifications
to any of its public licenses or any other arrangements,
understandings, or agreements concerning use of licensed material. For
the avoidance of doubt, this paragraph does not form part of the
public licenses.
Creative Commons can be contacted at creativecommons.org.
Creative Commons may be contacted at creativecommons.org.
---
**Disclaimer**:
This document has been translated using the AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). While we strive for accuracy, please note that automated translations may contain errors or inaccuracies. The original document in its native language should be regarded as the authoritative source. For critical information, professional human translation is recommended. We are not responsible for any misunderstandings or misinterpretations resulting from the use of this translation.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
This document has been translated using 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.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -24,8 +24,8 @@
"language_code": "es"
},
"1-Introduction/3-fairness/README.md": {
"original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
"translation_date": "2025-09-04T22:20:36+00:00",
"original_hash": "0f00d72169a0d37eecfd16d71e01700a",
"translation_date": "2026-07-13T23:33:45+00:00",
"source_file": "1-Introduction/3-fairness/README.md",
"language_code": "es"
},
@ -54,8 +54,8 @@
"language_code": "es"
},
"2-Regression/1-Tools/README.md": {
"original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
"translation_date": "2025-09-04T22:13:49+00:00",
"original_hash": "0b8635427b582d03ea4ab7089b93e505",
"translation_date": "2026-07-13T23:31:13+00:00",
"source_file": "2-Regression/1-Tools/README.md",
"language_code": "es"
},
@ -72,8 +72,8 @@
"language_code": "es"
},
"2-Regression/2-Data/README.md": {
"original_hash": "7c077988328ebfe33b24d07945f16eca",
"translation_date": "2025-09-04T22:14:22+00:00",
"original_hash": "a58b2c4d16c6b122643391745ac15af6",
"translation_date": "2026-07-13T23:32:06+00:00",
"source_file": "2-Regression/2-Data/README.md",
"language_code": "es"
},
@ -89,6 +89,12 @@
"source_file": "2-Regression/2-Data/solution/Julia/README.md",
"language_code": "es"
},
"2-Regression/2-Data/solution/notebook.ipynb": {
"original_hash": "96b95f8cf473481f2f371de8156f1571",
"translation_date": "2026-07-13T23:15:20+00:00",
"source_file": "2-Regression/2-Data/solution/notebook.ipynb",
"language_code": "es"
},
"2-Regression/3-Linear/README.md": {
"original_hash": "8b776e731c35b171d316d01d0e7b1369",
"translation_date": "2026-04-26T18:34:21+00:00",
@ -457,7 +463,7 @@
},
"8-Reinforcement/1-QLearning/README.md": {
"original_hash": "911efd5e595089000cb3c16fce1beab8",
"translation_date": "2025-09-04T22:25:29+00:00",
"translation_date": "2026-07-13T23:33:04+00:00",
"source_file": "8-Reinforcement/1-QLearning/README.md",
"language_code": "es"
},
@ -581,6 +587,19 @@
"source_file": "TROUBLESHOOTING.md",
"language_code": "es"
},
"__translation_failures__": {
"sketchnotes/LICENSE.md": {
"original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
"source_file": "sketchnotes/LICENSE.md",
"language_code": "es",
"failure_date": "2026-07-13T23:30:23+00:00",
"status": "failed",
"error_type": "TranslationIncompleteError",
"error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.",
"translator_version": "0.20.0",
"failure_policy_version": 1
}
},
"docs/_sidebar.md": {
"original_hash": "68dd06c685f6ce840e0acfa313352e7c",
"translation_date": "2025-09-03T23:13:58+00:00",

@ -1,161 +1,167 @@
# Construyendo soluciones de aprendizaje automático con IA responsable
![Resumen de IA responsable en aprendizaje automático en un sketchnote](../../../../sketchnotes/ml-fairness.png)
# Construyendo soluciones de Machine Learning con IA responsable
![Resumen de IA responsable en Machine Learning en un sketchnote](../../../../translated_images/es/ml-fairness.ef296ebec6afc98a.webp)
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario previo a la clase](https://ff-quizzes.netlify.app/en/ml/)
## Introducción
En este currículo, comenzarás a descubrir cómo el aprendizaje automático puede y está impactando nuestras vidas cotidianas. Incluso ahora, los sistemas y modelos están involucrados en tareas de toma de decisiones diarias, como diagnósticos médicos, aprobaciones de préstamos o detección de fraudes. Por lo tanto, es importante que estos modelos funcionen bien para proporcionar resultados confiables. Al igual que cualquier aplicación de software, los sistemas de IA pueden no cumplir con las expectativas o tener un resultado indeseable. Es por eso que es esencial poder entender y explicar el comportamiento de un modelo de IA.
En este currículo, comenzarás a descubrir cómo el aprendizaje automático puede y está impactando nuestra vida diaria. Incluso ahora, los sistemas y modelos participan en tareas diarias de toma de decisiones, como diagnósticos médicos, aprobación de préstamos o detección de fraudes. Por lo tanto, es importante que estos modelos funcionen bien para proporcionar resultados confiables. Al igual que cualquier aplicación de software, los sistemas de IA pueden no cumplir con las expectativas o tener un resultado no deseado. Por eso es esencial poder entender y explicar el comportamiento de un modelo de IA.
Imagina lo que puede suceder cuando los datos que utilizas para construir estos modelos carecen de ciertos grupos demográficos, como raza, género, visión política, religión, o representan desproporcionadamente dichos grupos. ¿Qué pasa cuando la salida del modelo se interpreta para favorecer a algún grupo demográfico? ¿Cuál es la consecuencia para la aplicación? Además, ¿qué sucede cuando el modelo tiene un resultado adverso y es perjudicial para las personas? ¿Quién es responsable del comportamiento de los sistemas de IA? Estas son algunas preguntas que exploraremos en este currículo.
Imagina qué puede pasar cuando los datos que usas para construir estos modelos carecen de ciertos grupos demográficos, como raza, género, opinión política, religión, o representan de manera desproporcionada dichos grupos demográficos. ¿Qué pasa cuando la salida del modelo se interpreta para favorecer a algún grupo demográfico? ¿Cuál es la consecuencia para la aplicación? Además, ¿qué ocurre cuando el modelo tiene un resultado adverso y es perjudicial para las personas? ¿Quién es responsable del comportamiento del sistema de IA? Estas son algunas preguntas que exploraremos en este currículo.
En esta lección, aprenderás a:
En esta lección, :
- Concienciarte sobre la importancia de la equidad en el aprendizaje automático y los daños relacionados con la falta de equidad.
- Familiarizarte con la práctica de explorar valores atípicos y escenarios inusuales para garantizar confiabilidad y seguridad.
- Comprender la necesidad de empoderar a todos mediante el diseño de sistemas inclusivos.
- Explorar lo vital que es proteger la privacidad y seguridad de los datos y las personas.
- Ver la importancia de tener un enfoque de caja de cristal para explicar el comportamiento de los modelos de IA.
- Ser consciente de cómo la responsabilidad es esencial para generar confianza en los sistemas de IA.
- Tomarás conciencia sobre la importancia de la equidad en el aprendizaje automático y los daños relacionados con la equidad.
- Te familiarizarás con la práctica de explorar valores atípicos y escenarios inusuales para asegurar la fiabilidad y seguridad.
- Entenderás la necesidad de empoderar a todos mediante el diseño de sistemas inclusivos.
- Explorarás lo vital que es proteger la privacidad y la seguridad de los datos y las personas.
- Verás la importancia de tener un enfoque de caja transparente para explicar el comportamiento de los modelos de IA.
- Serás consciente de cómo la responsabilidad es esencial para construir confianza en los sistemas de IA.
## Prerrequisito
## Requisito previo
Como prerrequisito, toma el "Camino de Aprendizaje de Principios de IA Responsable" y mira el siguiente video sobre el tema:
Como requisito previo, realiza el "Camino de aprendizaje de Principios de IA Responsable" y mira el video a continuación sobre el tema:
Aprende más sobre IA Responsable siguiendo este [Camino de Aprendizaje](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
Aprende más sobre IA Responsable siguiendo este [Camino de aprendizaje](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
[![Enfoque de Microsoft hacia la IA Responsable](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Enfoque de Microsoft hacia la IA Responsable")
[![Enfoque de Microsoft sobre IA Responsable](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Enfoque de Microsoft sobre IA Responsable")
> 🎥 Haz clic en la imagen de arriba para ver el video: Enfoque de Microsoft hacia la IA Responsable
> 🎥 Haz clic en la imagen de arriba para un video: Enfoque de Microsoft sobre IA Responsable
## Equidad
Los sistemas de IA deben tratar a todos de manera justa y evitar afectar a grupos similares de personas de diferentes maneras. Por ejemplo, cuando los sistemas de IA proporcionan orientación sobre tratamientos médicos, solicitudes de préstamos o empleo, deben hacer las mismas recomendaciones a todos con síntomas similares, circunstancias financieras o calificaciones profesionales. Cada uno de nosotros, como humanos, lleva consigo sesgos heredados que afectan nuestras decisiones y acciones. Estos sesgos pueden ser evidentes en los datos que usamos para entrenar sistemas de IA. A veces, esta manipulación ocurre de manera no intencional. A menudo es difícil saber conscientemente cuándo estás introduciendo sesgos en los datos.
Los sistemas de IA deben tratar a todos con equidad y evitar afectar de manera diferente a grupos similares de personas. Por ejemplo, cuando los sistemas de IA brindan orientación sobre tratamiento médico, solicitudes de préstamos o empleo, deberían hacer las mismas recomendaciones a todos con síntomas, circunstancias financieras o calificaciones profesionales similares. Cada uno de nosotros, como humanos, lleva inherentes sesgos que afectan nuestras decisiones y acciones. Estos sesgos pueden estar presentes en los datos que usamos para entrenar sistemas de IA. Tal manipulación a veces ocurre sin intención. A menudo es difícil saber conscientemente cuándo estás introduciendo un sesgo en los datos.
**“Injusticia”** abarca impactos negativos, o “daños”, para un grupo de personas, como aquellos definidos en términos de raza, género, edad o estado de discapacidad. Los principales daños relacionados con la equidad pueden clasificarse como:
**"Injusticia"** abarca impactos negativos, o "daños", para un grupo de personas, como aquellos definidos en términos de raza, género, edad o condición de discapacidad. Los principales daños relacionados con la equidad pueden clasificarse como:
- **Asignación**, si, por ejemplo, se favorece un género o etnia sobre otro.
- **Calidad del servicio**. Si entrenas los datos para un escenario específico pero la realidad es mucho más compleja, esto lleva a un servicio de bajo rendimiento. Por ejemplo, un dispensador de jabón que no parece ser capaz de detectar personas con piel oscura. [Referencia](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **Denigración**. Criticar y etiquetar algo o alguien de manera injusta. Por ejemplo, una tecnología de etiquetado de imágenes etiquetó erróneamente imágenes de personas de piel oscura como gorilas.
- **Sobre- o sub-representación**. La idea de que un cierto grupo no se ve en una determinada profesión, y cualquier servicio o función que siga promoviendo eso está contribuyendo al daño.
- **Estereotipos**. Asociar un grupo dado con atributos preasignados. Por ejemplo, un sistema de traducción entre inglés y turco puede tener inexactitudes debido a palabras con asociaciones estereotípicas de género.
- **Asignación**, si por ejemplo se favorece un género o etnia sobre otro.
- **Calidad del servicio**. Si entrenas los datos para un escenario específico pero la realidad es mucho más compleja, lleva a un servicio de bajo rendimiento. Por ejemplo, un dispensador de jabón que no podía detectar personas con piel oscura. [Referencia](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **Denigración**. Criticar y etiquetar injustamente algo o a alguien. Por ejemplo, una tecnología de etiquetado de imágenes que etiquetó erróneamente imágenes de personas de piel oscura como gorilas.
- **Sobre o sub-representación**. La idea es que un cierto grupo no se vea en una profesión determinada, y cualquier servicio o función que siga promoviendo eso contribuye al daño.
- **Estereotipos**. Asociar a un grupo dado atributos preasignados. Por ejemplo, un sistema de traducción entre inglés y turco puede tener inexactitudes debido a palabras con asociaciones estereotipadas de género.
![traducción al turco](../../../../1-Introduction/3-fairness/images/gender-bias-translate-en-tr.png)
![traducción al turco](../../../../translated_images/es/gender-bias-translate-en-tr.f185fd8822c2d437.webp)
> traducción al turco
![traducción de vuelta al inglés](../../../../1-Introduction/3-fairness/images/gender-bias-translate-tr-en.png)
![traducción de vuelta al inglés](../../../../translated_images/es/gender-bias-translate-tr-en.4eee7e3cecb8c70e.webp)
> traducción de vuelta al inglés
Al diseñar y probar sistemas de IA, debemos asegurarnos de que la IA sea justa y no esté programada para tomar decisiones sesgadas o discriminatorias, las cuales también están prohibidas para los seres humanos. Garantizar la equidad en la IA y el aprendizaje automático sigue siendo un desafío sociotécnico complejo.
Al diseñar y probar sistemas de IA, debemos asegurar que la IA sea justa y no esté programada para tomar decisiones sesgadas o discriminatorias, decisión que también está prohibida a los humanos. Garantizar la equidad en IA y aprendizaje automático sigue siendo un desafío sociotécnico complejo.
### Confiabilidad y seguridad
### Fiabilidad y seguridad
Para generar confianza, los sistemas de IA deben ser confiables, seguros y consistentes bajo condiciones normales e inesperadas. Es importante saber cómo se comportarán los sistemas de IA en una variedad de situaciones, especialmente cuando son valores atípicos. Al construir soluciones de IA, se necesita un enfoque sustancial en cómo manejar una amplia variedad de circunstancias que las soluciones de IA podrían encontrar. Por ejemplo, un automóvil autónomo debe priorizar la seguridad de las personas. Como resultado, la IA que impulsa el automóvil debe considerar todos los posibles escenarios que el automóvil podría enfrentar, como la noche, tormentas eléctricas o ventiscas, niños cruzando la calle, mascotas, construcciones en la carretera, etc. Qué tan bien un sistema de IA puede manejar una amplia gama de condiciones de manera confiable y segura refleja el nivel de anticipación que el científico de datos o desarrollador de IA consideró durante el diseño o prueba del sistema.
Para generar confianza, los sistemas de IA deben ser fiables, seguros y consistentes en condiciones normales e inesperadas. Es importante saber cómo se comportarán los sistemas de IA en diversas situaciones, especialmente cuando son casos extremos. Al construir soluciones de IA, se debe poner un enfoque sustancial en cómo manejar una amplia variedad de circunstancias que las soluciones de IA puedan encontrar. Por ejemplo, un auto autónomo debe priorizar la seguridad de las personas. Por eso, la IA que impulsa el auto debe considerar todos los posibles escenarios que el auto podría encontrar, como la noche, tormentas eléctricas o granizadas, niños cruzando la calle, mascotas, construcciones en la vía, etc. Qué tan bien puede un sistema de IA manejar un rango amplio de condiciones de manera confiable y segura refleja el nivel de anticipación que el científico de datos o desarrollador de IA consideró durante el diseño o pruebas del sistema.
> [🎥 Haz clic aquí para ver un video: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
> [🎥 Haz clic aquí para un video: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
### Inclusión
Los sistemas de IA deben diseñarse para involucrar y empoderar a todos. Al diseñar e implementar sistemas de IA, los científicos de datos y desarrolladores de IA identifican y abordan posibles barreras en el sistema que podrían excluir a las personas de manera no intencional. Por ejemplo, hay 1,000 millones de personas con discapacidades en todo el mundo. Con el avance de la IA, pueden acceder a una amplia gama de información y oportunidades más fácilmente en su vida diaria. Al abordar las barreras, se crean oportunidades para innovar y desarrollar productos de IA con mejores experiencias que beneficien a todos.
Los sistemas de IA deben diseñarse para involucrar y empoderar a todos. Al diseñar e implementar sistemas de IA, los científicos de datos y desarrolladores de IA identifican y abordan posibles barreras en el sistema que podrían excluir a personas sin intención. Por ejemplo, hay 1 mil millones de personas con discapacidades en el mundo. Con el avance de la IA, pueden acceder más fácilmente a una amplia gama de información y oportunidades en su vida diaria. Al abordar las barreras, se crean oportunidades para innovar y desarrollar productos de IA con mejores experiencias que benefician a todos.
> [🎥 Haz clic aquí para ver un video: inclusión en IA](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
> [🎥 Haz clic aquí para un video: inclusión en IA](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
### Seguridad y privacidad
Los sistemas de IA deben ser seguros y respetar la privacidad de las personas. Las personas tienen menos confianza en sistemas que ponen en riesgo su privacidad, información o vidas. Al entrenar modelos de aprendizaje automático, dependemos de los datos para producir los mejores resultados. Al hacerlo, se debe considerar el origen de los datos y su integridad. Por ejemplo, ¿los datos fueron enviados por el usuario o estaban disponibles públicamente? Luego, al trabajar con los datos, es crucial desarrollar sistemas de IA que puedan proteger información confidencial y resistir ataques. A medida que la IA se vuelve más prevalente, proteger la privacidad y asegurar información personal y empresarial importante se está volviendo más crítico y complejo. Los problemas de privacidad y seguridad de los datos requieren especial atención en la IA porque el acceso a los datos es esencial para que los sistemas de IA hagan predicciones y decisiones precisas e informadas sobre las personas.
Los sistemas de IA deben ser seguros y respetar la privacidad de las personas. La gente confía menos en sistemas que ponen en riesgo su privacidad, información o vidas. Al entrenar modelos de aprendizaje automático, confiamos en los datos para producir los mejores resultados. Al hacerlo, se debe considerar el origen y la integridad de los datos. Por ejemplo, ¿fueron los datos enviados por usuarios o están disponibles públicamente? Además, al trabajar con los datos, es crucial desarrollar sistemas de IA que puedan proteger información confidencial y resistir ataques. Conforme la IA se vuelve más prevalente, proteger la privacidad y asegurar información personal y empresarial importante se vuelve más crítico y complejo. Los temas de privacidad y seguridad de datos requieren especial atención en IA porque el acceso a los datos es esencial para que los sistemas de IA hagan predicciones y decisiones precisas e informadas sobre las personas.
> [🎥 Haz clic aquí para ver un video: seguridad en IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
> [🎥 Haz clic aquí para un video: seguridad en IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- Como industria, hemos logrado avances significativos en privacidad y seguridad, impulsados significativamente por regulaciones como el GDPR (Reglamento General de Protección de Datos).
- Sin embargo, con los sistemas de IA debemos reconocer la tensión entre la necesidad de más datos personales para hacer los sistemas más efectivos y la privacidad.
- Al igual que con el nacimiento de las computadoras conectadas a internet, también estamos viendo un gran aumento en el número de problemas de seguridad relacionados con la IA.
- Al mismo tiempo, hemos visto que la IA se utiliza para mejorar la seguridad. Por ejemplo, la mayoría de los escáneres antivirus modernos están impulsados por heurísticas de IA.
- Necesitamos asegurarnos de que nuestros procesos de Ciencia de Datos se integren armoniosamente con las últimas prácticas de privacidad y seguridad.
- Como industria hemos avanzado significativamente en privacidad y seguridad, impulsados en gran medida por regulaciones como el GDPR (Reglamento General de Protección de Datos).
- Sin embargo, con los sistemas de IA debemos reconocer la tensión entre la necesidad de más datos personales para hacer los sistemas más personales y efectivos y la privacidad.
- Al igual que con el nacimiento de computadoras conectadas con internet, también estamos viendo un gran aumento en los problemas de seguridad relacionados con la IA.
- Al mismo tiempo, hemos visto que la IA se usa para mejorar la seguridad. Por ejemplo, la mayoría de los escáneres antivirus modernos hoy en día cuentan con heurísticas de IA.
- Debemos asegurar que nuestros procesos de Ciencia de Datos se integren armoniosamente con las últimas prácticas de privacidad y seguridad.
### Transparencia
Los sistemas de IA deben ser comprensibles. Una parte crucial de la transparencia es explicar el comportamiento de los sistemas de IA y sus componentes. Mejorar la comprensión de los sistemas de IA requiere que las partes interesadas comprendan cómo y por qué funcionan para que puedan identificar posibles problemas de rendimiento, preocupaciones de seguridad y privacidad, sesgos, prácticas excluyentes o resultados no deseados. También creemos que quienes usan sistemas de IA deben ser honestos y transparentes sobre cuándo, por qué y cómo eligen implementarlos, así como las limitaciones de los sistemas que utilizan. Por ejemplo, si un banco utiliza un sistema de IA para apoyar sus decisiones de préstamos al consumidor, es importante examinar los resultados y entender qué datos influyen en las recomendaciones del sistema. Los gobiernos están comenzando a regular la IA en diversas industrias, por lo que los científicos de datos y las organizaciones deben explicar si un sistema de IA cumple con los requisitos regulatorios, especialmente cuando hay un resultado no deseado.
### Transparencia
Los sistemas de IA deben ser comprensibles. Parte crucial de la transparencia es explicar el comportamiento de los sistemas de IA y sus componentes. Mejorar la comprensión de los sistemas de IA requiere que las partes interesadas comprendan cómo y por qué funcionan para que puedan identificar problemas potenciales de desempeño, preocupaciones de seguridad y privacidad, sesgos, prácticas excluyentes o resultados no intencionados. También creemos que quienes usan sistemas de IA deben ser honestos y transparentes sobre cuándo, por qué y cómo eligen desplegarlos, así como sus limitaciones. Por ejemplo, si un banco usa un sistema de IA para soportar decisiones de préstamos a consumidores, es importante examinar los resultados y entender qué datos influyen en las recomendaciones del sistema. Los gobiernos están empezando a regular la IA en diferentes industrias, por lo tanto los científicos de datos y organizaciones deben explicar si un sistema de IA cumple con los requerimientos regulatorios, especialmente si hay un resultado no deseado.
> [🎥 Haz clic aquí para ver un video: transparencia en IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
> [🎥 Haz clic aquí para un video: transparencia en IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- Debido a que los sistemas de IA son tan complejos, es difícil entender cómo funcionan e interpretar los resultados.
- Esta falta de comprensión afecta la forma en que se gestionan, operacionalizan y documentan estos sistemas.
- Más importante aún, esta falta de comprensión afecta las decisiones tomadas utilizando los resultados que producen estos sistemas.
- Debido a que los sistemas de IA son muy complejos, es difícil entender cómo funcionan e interpretar los resultados.
- Esta falta de comprensión afecta la manera en que estos sistemas son gestionados, operativizados y documentados.
- Lo más importante, esta falta de comprensión afecta las decisiones tomadas usando los resultados que estos sistemas producen.
### Responsabilidad
Las personas que diseñan y despliegan sistemas de IA deben ser responsables de cómo operan sus sistemas. La necesidad de responsabilidad es especialmente crucial con tecnologías sensibles como el reconocimiento facial. Recientemente, ha habido una creciente demanda de tecnología de reconocimiento facial, especialmente de organizaciones de aplicación de la ley que ven el potencial en usos como localizar niños desaparecidos. Sin embargo, estas tecnologías podrían ser usadas por un gobierno para poner en riesgo las libertades fundamentales de sus ciudadanos, por ejemplo, habilitando vigilancia continua de individuos específicos. Por lo tanto, los científicos de datos y organizaciones deben ser responsables de cómo su sistema de IA impacta a los individuos o la sociedad.
Las personas que diseñan y despliegan sistemas de IA deben ser responsables de cómo operan sus sistemas. La necesidad de responsabilidad es particularmente crucial con tecnologías de uso sensible como el reconocimiento facial. Recientemente, ha habido una creciente demanda de tecnología de reconocimiento facial, especialmente por parte de organizaciones de aplicación de la ley que ven el potencial de la tecnología en usos como encontrar niños desaparecidos. Sin embargo, estas tecnologías podrían ser utilizadas por un gobierno para poner en riesgo las libertades fundamentales de sus ciudadanos, por ejemplo, habilitando la vigilancia continua de individuos específicos. Por lo tanto, los científicos de datos y las organizaciones deben ser responsables de cómo su sistema de IA impacta a las personas o la sociedad.
[![Investigador líder en IA advierte sobre vigilancia masiva mediante reconocimiento facial](../../../../translated_images/es/accountability.41d8c0f4b85b6231.webp)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Enfoque de Microsoft sobre IA Responsable")
[![Investigador líder en IA advierte sobre vigilancia masiva a través del reconocimiento facial](../../../../1-Introduction/3-fairness/images/accountability.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Enfoque de Microsoft hacia la IA Responsable")
> 🎥 Haz clic en la imagen de arriba para un video: Advertencias sobre vigilancia masiva mediante reconocimiento facial
> 🎥 Haz clic en la imagen de arriba para ver el video: Advertencias sobre vigilancia masiva a través del reconocimiento facial
En última instancia, una de las mayores preguntas para nuestra generación, como la primera generación que está llevando la IA a la sociedad, es cómo garantizar que las computadoras sigan siendo responsables ante las personas y cómo garantizar que las personas que diseñan computadoras sean responsables ante todos los demás.
En última instancia, una de las mayores preguntas para nuestra generación, como la primera generación que está trayendo IA a la sociedad, es cómo asegurar que las computadoras permanezcan responsables ante las personas y cómo asegurar que quienes diseñan las computadoras sigan siendo responsables ante todos los demás.
## Evaluación de impacto
Antes de entrenar un modelo de aprendizaje automático, es importante realizar una evaluación de impacto para entender el propósito del sistema de IA; cuál es el uso previsto; dónde se desplegará; y quién interactuará con el sistema. Esto es útil para los revisores o evaluadores del sistema para saber qué factores considerar al identificar riesgos potenciales y consecuencias esperadas.
Antes de entrenar un modelo de aprendizaje automático, es importante realizar una evaluación de impacto para entender el propósito del sistema de IA; cuál es el uso previsto; dónde será desplegado; y quién interactuará con el sistema. Esto es útil para revisores o evaluadores del sistema para saber qué factores considerar al identificar riesgos potenciales y consecuencias esperadas.
Las siguientes son áreas de enfoque al realizar una evaluación de impacto:
* **Impacto adverso en individuos**. Ser consciente de cualquier restricción o requisito, uso no compatible o cualquier limitación conocida que obstaculice el rendimiento del sistema es vital para garantizar que el sistema no se utilice de manera que pueda causar daño a las personas.
* **Requisitos de datos**. Comprender cómo y dónde el sistema utilizará datos permite a los revisores explorar cualquier requisito de datos que debas tener en cuenta (por ejemplo, regulaciones de datos como GDPR o HIPAA). Además, examina si la fuente o cantidad de datos es suficiente para el entrenamiento.
* **Resumen del impacto**. Reúne una lista de posibles daños que podrían surgir del uso del sistema. A lo largo del ciclo de vida del aprendizaje automático, revisa si los problemas identificados se han mitigado o abordado.
* **Metas aplicables** para cada uno de los seis principios fundamentales. Evalúa si las metas de cada principio se cumplen y si hay alguna brecha.
* **Impacto adverso en individuos**. Ser consciente de cualquier restricción o requisito, uso no soportado o cualquier limitación conocida que impida el desempeño del sistema es vital para asegurar que el sistema no se use de manera que pueda causar daño a las personas.
* **Requisitos de datos**. Entender cómo y dónde el sistema usará los datos permite a los revisores explorar cualquier requisito de datos que se deba considerar (por ejemplo, regulaciones de datos GDPR o HIPAA). Además, examina si la fuente o cantidad de datos es suficiente para el entrenamiento.
* **Resumen de impacto**. Recopila una lista de posibles daños que podrían surgir del uso del sistema. A lo largo del ciclo de vida de ML, revisa si los problemas identificados se mitigan o abordan.
* **Objetivos aplicables** para cada uno de los seis principios fundamentales. Evalúa si se cumplen los objetivos de cada principio y si existen brechas.
## Depuración con IA responsable
Al igual que depurar una aplicación de software, depurar un sistema de IA es un proceso necesario para identificar y resolver problemas en el sistema. Hay muchos factores que pueden afectar que un modelo no funcione como se espera o de manera responsable. La mayoría de las métricas tradicionales de rendimiento de modelos son agregados cuantitativos del rendimiento de un modelo, lo cual no es suficiente para analizar cómo un modelo viola los principios de IA responsable. Además, un modelo de aprendizaje automático es una caja negra que dificulta entender qué impulsa su resultado o proporcionar explicaciones cuando comete un error. Más adelante en este curso, aprenderemos cómo usar el panel de IA Responsable para ayudar a depurar sistemas de IA. El panel proporciona una herramienta integral para que los científicos de datos y desarrolladores de IA realicen:
Similar a depurar una aplicación de software, depurar un sistema de IA es un proceso necesario para identificar y resolver problemas en el sistema. Hay muchos factores que afectarían que un modelo no rinda como se espera o de manera responsable. La mayoría de métricas tradicionales de desempeño de modelos son agregados cuantitativos del rendimiento del modelo, que no son suficientes para analizar cómo un modelo viola los principios de IA responsable. Además, un modelo de aprendizaje automático es una caja negra que dificulta entender qué impulsa su resultado o dar explicación cuando comete un error. Más adelante en este curso aprenderemos a usar el panel de IA Responsable para ayudar a depurar sistemas de IA. El panel proporciona una herramienta holística para que científicos de datos y desarrolladores de IA realicen:
* **Análisis de errores**. Para identificar la distribución de errores del modelo que puede afectar la equidad o confiabilidad del sistema.
* **Visión general del modelo**. Para descubrir dónde hay disparidades en el rendimiento del modelo entre cohortes de datos.
* **Análisis de datos**. Para entender la distribución de datos e identificar cualquier sesgo potencial en los datos que podría generar problemas de equidad, inclusión y confiabilidad.
* **Interpretabilidad del modelo**. Para entender qué afecta o influye en las predicciones del modelo. Esto ayuda a explicar el comportamiento del modelo, lo cual es importante para la transparencia y la responsabilidad.
* **Análisis de errores**. Para identificar la distribución de errores del modelo que pueden afectar la equidad o fiabilidad del sistema.
* **Resumen del modelo**. Para descubrir dónde hay disparidades en el desempeño del modelo a través de cohortes de datos.
* **Análisis de datos**. Para entender la distribución de datos e identificar posibles sesgos en los datos que podrían causar problemas de equidad, inclusión y fiabilidad.
* **Interpretabilidad del modelo**. Para entender qué afecta o influye en las predicciones del modelo. Esto ayuda a explicar el comportamiento del modelo, importante para la transparencia y responsabilidad.
## 🚀 Desafío
Para prevenir daños desde el principio, deberíamos:
## 🚀 Desafío
Para prevenir que se introduzcan daños en primer lugar, deberíamos:
- contar con diversidad de antecedentes y perspectivas entre las personas que trabajan en los sistemas
- tener diversidad de orígenes y perspectivas entre las personas que trabajan en sistemas
- invertir en conjuntos de datos que reflejen la diversidad de nuestra sociedad
- desarrollar mejores métodos a lo largo del ciclo de vida del aprendizaje automático para detectar y corregir problemas de IA responsable cuando ocurran
- desarrollar mejores métodos a lo largo del ciclo de vida del aprendizaje automático para detectar y corregir IA responsable cuando ocurra
Piensa en escenarios de la vida real donde la falta de confianza en un modelo sea evidente en su construcción y uso. ¿Qué más deberíamos considerar?
Piensa en escenarios de la vida real donde la falta de confiabilidad de un modelo es evidente en la construcción y uso del modelo. ¿Qué más deberíamos considerar?
## [Cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario posterior a la clase](https://ff-quizzes.netlify.app/en/ml/)
## Revisión y autoestudio
En esta lección, has aprendido algunos conceptos básicos sobre la equidad y la falta de equidad en el aprendizaje automático.
Mira este taller para profundizar en los temas:
En esta lección, has aprendido algunos conceptos básicos sobre la equidad y la inequidad en el aprendizaje automático.
Mira este taller para profundizar en los temas:
- En busca de una IA responsable: Llevando los principios a la práctica por Besmira Nushi, Mehrnoosh Sameki y Amit Sharma
- En búsqueda de una IA responsable: Llevar los principios a la práctica por Besmira Nushi, Mehrnoosh Sameki y Amit Sharma
[![Responsible AI Toolbox: Un marco de código abierto para construir IA responsable](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: Un marco de código abierto para construir IA responsable")
[![Caja de herramientas de IA Responsable: Un marco de código abierto para construir IA responsable](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "Caja de herramientas RAI: Un marco de código abierto para construir IA responsable")
> 🎥 Haz clic en la imagen de arriba para ver el video: RAI Toolbox: Un marco de código abierto para construir IA responsable por Besmira Nushi, Mehrnoosh Sameki y Amit Sharma
> 🎥 Haz clic en la imagen de arriba para ver el video: Caja de herramientas RAI: Un marco de código abierto para construir IA responsable por Besmira Nushi, Mehrnoosh Sameki y Amit Sharma
Además, lee:
También, lee:
- Centro de recursos de RAI de Microsoft: [Responsible AI Resources Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Centro de recursos RAI de Microsoft: [Recursos de IA Responsable Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Grupo de investigación FATE de Microsoft: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
- Grupo de investigación FATE de Microsoft: [FATE: Equidad, Responsabilidad, Transparencia y Ética en IA - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
RAI Toolbox:
Caja de herramientas RAI:
- [Repositorio de GitHub de Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox)
- [Repositorio GitHub de la Caja de herramientas de IA Responsable](https://github.com/microsoft/responsible-ai-toolbox)
Lee sobre las herramientas de Azure Machine Learning para garantizar la equidad:
Lee sobre las herramientas de Azure Machine Learning para asegurar la equidad:
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
## Tarea
[Explora RAI Toolbox](assignment.md)
[Explora Caja de herramientas RAI](assignment.md)
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**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 automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,120 +1,121 @@
# Comienza con Python y Scikit-learn para modelos de regresión
![Resumen de regresiones en un sketchnote](../../../../sketchnotes/ml-regression.png)
![Resumen de regresiones en una sketchnote](../../../../translated_images/es/ml-regression.4e4f70e3b3ed446e.webp)
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
> Sketchnote de [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario previo a la clase](https://ff-quizzes.netlify.app/en/ml/)
> ### [¡Esta lección está disponible en R!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
## Introducción
En estas cuatro lecciones, descubrirás cómo construir modelos de regresión. Hablaremos sobre para qué sirven en breve. Pero antes de hacer nada, ¡asegúrate de tener las herramientas adecuadas para comenzar el proceso!
En estas cuatro lecciones, descubrirás cómo construir modelos de regresión. Hablaremos de para qué sirven en breve. Pero antes de hacer cualquier cosa, asegúrate de tener las herramientas correctas para comenzar el proceso.
En esta lección, aprenderás a:
- Configurar tu computadora para tareas locales de aprendizaje automático.
- Trabajar con Jupyter notebooks.
- Usar Scikit-learn, incluyendo su instalación.
- Trabajar con Jupyter Notebooks.
- Usar Scikit-learn, incluida la instalación.
- Explorar la regresión lineal con un ejercicio práctico.
## Instalaciones y configuraciones
[![ML para principiantes - Configura tus herramientas para construir modelos de aprendizaje automático](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML para principiantes - Configura tus herramientas para construir modelos de aprendizaje automático")
[![ML para principiantes - Prepara tus herramientas listas para construir modelos de Machine Learning](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML para principiantes - Prepara tus herramientas listas para construir modelos de Machine Learning")
> 🎥 Haz clic en la imagen de arriba para ver un video corto sobre cómo configurar tu computadora para ML.
> 🎥 Haz clic en la imagen de arriba para un video corto mostrando cómo configurar tu computadora para ML.
1. **Instalar Python**. Asegúrate de que [Python](https://www.python.org/downloads/) esté instalado en tu computadora. Usarás Python para muchas tareas de ciencia de datos y aprendizaje automático. La mayoría de los sistemas informáticos ya incluyen una instalación de Python. También hay disponibles [Paquetes de Codificación de Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) útiles para facilitar la configuración a algunos usuarios.
1. **Instala Python**. Asegúrate de que [Python](https://www.python.org/downloads/) esté instalado en tu computadora. Usarás Python para muchas tareas de ciencia de datos y aprendizaje automático. La mayoría de los sistemas ya incluyen una instalación de Python. También hay útiles [Paquetes de Codificación Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) disponibles para facilitar la configuración a algunos usuarios.
Sin embargo, algunos usos de Python requieren una versión específica del software, mientras que otros requieren una versión diferente. Por esta razón, es útil trabajar dentro de un [entorno virtual](https://docs.python.org/3/library/venv.html).
Sin embargo, algunos usos de Python requieren una versión del software, mientras que otros requieren una diferente. Por esto, es útil trabajar dentro de un [entorno virtual](https://docs.python.org/3/library/venv.html).
2. **Instalar Visual Studio Code**. Asegúrate de tener Visual Studio Code instalado en tu computadora. Sigue estas instrucciones para [instalar Visual Studio Code](https://code.visualstudio.com/) para la instalación básica. Vas a usar Python en Visual Studio Code en este curso, por lo que podrías querer repasar cómo [configurar Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) para el desarrollo en Python.
2. **Instala Visual Studio Code**. Asegúrate de tener instalado Visual Studio Code en tu computadora. Sigue estas instrucciones para [instalar Visual Studio Code](https://code.visualstudio.com/) para la instalación básica. Vas a usar Python en Visual Studio Code en este curso, por lo que quizás quieras repasar cómo [configurar Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) para desarrollo en Python.
> Familiarízate con Python trabajando en esta colección de [módulos de aprendizaje](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
> Familiarízate con Python trabajando estos [módulos de aprendizaje](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
>
> [![Configura Python con Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Configura Python con Visual Studio Code")
>
> 🎥 Haz clic en la imagen de arriba para ver un video: usando Python dentro de VS Code.
> 🎥 Haz clic en la imagen de arriba para un video: usando Python dentro de VS Code.
3. **Instalar Scikit-learn**, siguiendo [estas instrucciones](https://scikit-learn.org/stable/install.html). Dado que necesitas asegurarte de usar Python 3, se recomienda que utilices un entorno virtual. Nota: si estás instalando esta biblioteca en una Mac M1, hay instrucciones especiales en la página enlazada arriba.
3. **Instala Scikit-learn**, siguiendo [estas instrucciones](https://scikit-learn.org/stable/install.html). Como necesitas asegurarte de usar Python 3, se recomienda usar un entorno virtual. Nota que si instalas esta biblioteca en un Mac M1, hay instrucciones especiales en la página enlazada arriba.
4. **Instalar Jupyter Notebook**. Necesitarás [instalar el paquete Jupyter](https://pypi.org/project/jupyter/).
1. **Instala Jupyter Notebook**. Necesitarás [instalar el paquete Jupyter](https://pypi.org/project/jupyter/).
## Tu entorno de autoría de ML
## Tu entorno de autoría ML
Vas a usar **notebooks** para desarrollar tu código en Python y crear modelos de aprendizaje automático. Este tipo de archivo es una herramienta común para los científicos de datos y se identifican por su sufijo o extensión `.ipynb`.
Usarás **notebooks** para desarrollar tu código Python y crear modelos de aprendizaje automático. Este tipo de archivo es una herramienta común para científicos de datos, y se identifica por su sufijo o extensión `.ipynb`.
Los notebooks son un entorno interactivo que permite al desarrollador tanto codificar como agregar notas y escribir documentación alrededor del código, lo cual es bastante útil para proyectos experimentales o de investigación.
Los notebooks son un entorno interactivo que permite al desarrollador tanto codificar como añadir notas y escribir documentación alrededor del código, lo que es muy útil para proyectos experimentales o de investigación.
[![ML para principiantes - Configura Jupyter Notebooks para comenzar a construir modelos de regresión](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML para principiantes - Configura Jupyter Notebooks para comenzar a construir modelos de regresión")
> 🎥 Haz clic en la imagen de arriba para ver un video corto sobre este ejercicio.
> 🎥 Haz clic en la imagen de arriba para un video corto realizando este ejercicio.
### Ejercicio - trabajar con un notebook
### Ejercicio - trabaja con un notebook
En esta carpeta, encontrarás el archivo _notebook.ipynb_.
1. Abre _notebook.ipynb_ en Visual Studio Code.
Se iniciará un servidor Jupyter con Python 3+. Encontrarás áreas del notebook que pueden ser `ejecutadas`, piezas de código. Puedes ejecutar un bloque de código seleccionando el ícono que parece un botón de reproducción.
Se iniciará un servidor Jupyter con Python 3+ activo. Encontrarás áreas del notebook que pueden `ejecutarse`, fragmentos de código. Puedes ejecutar un bloque de código seleccionando el icono que parece un botón de reproducir.
2. Selecciona el ícono `md` y agrega un poco de markdown, y el siguiente texto **# Bienvenido a tu notebook**.
1. Selecciona el icono `md` y añade un poco de markdown, y el siguiente texto **# Bienvenido a tu notebook**.
Luego, agrega algo de código en Python.
Luego, añade un poco de código Python.
3. Escribe **print('hello notebook')** en el bloque de código.
4. Selecciona la flecha para ejecutar el código.
1. Escribe **print('hola notebook')** en el bloque de código.
1. Selecciona la flecha para ejecutar el código.
Deberías ver la declaración impresa:
Deberías ver la instrucción impresa:
```output
hello notebook
```
![VS Code con un notebook abierto](../../../../2-Regression/1-Tools/images/notebook.jpg)
![VS Code con un notebook abierto](../../../../translated_images/es/notebook.4a3ee31f396b8832.webp)
Puedes intercalar tu código con comentarios para auto-documentar el notebook.
✅ Piensa por un momento en cómo es diferente el entorno de trabajo de un desarrollador web en comparación con el de un científico de datos.
✅ Piensa por un minuto cuán diferente es el entorno de trabajo de un desarrollador web en comparación con el de un científico de datos.
## Puesta en marcha con Scikit-learn
## En marcha con Scikit-learn
Ahora que Python está configurado en tu entorno local y te sientes cómodo con los notebooks de Jupyter, vamos a familiarizarnos con Scikit-learn (se pronuncia `sci` como en `science`). Scikit-learn proporciona una [API extensa](https://scikit-learn.org/stable/modules/classes.html#api-ref) para ayudarte a realizar tareas de ML.
Ahora que Python está configurado en tu entorno local y estás cómodo con Jupyter Notebooks, vamos a familiarizarnos también con Scikit-learn (pronúncialo `sci` como en `science`). Scikit-learn proporciona una [API extensa](https://scikit-learn.org/stable/modules/classes.html#api-ref) para ayudarte a realizar tareas de ML.
Según su [sitio web](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn es una biblioteca de aprendizaje automático de código abierto que admite aprendizaje supervisado y no supervisado. También proporciona varias herramientas para ajuste de modelos, preprocesamiento de datos, selección y evaluación de modelos, y muchas otras utilidades."
Según su [sitio web](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn es una biblioteca de aprendizaje automático de código abierto que soporta aprendizaje supervisado y no supervisado. También provee varias herramientas para ajuste de modelos, preprocesamiento de datos, selección y evaluación de modelos, y muchas otras utilidades."
En este curso, usarás Scikit-learn y otras herramientas para construir modelos de aprendizaje automático para realizar lo que llamamos tareas de 'aprendizaje automático tradicional'. Hemos evitado deliberadamente redes neuronales y aprendizaje profundo, ya que están mejor cubiertos en nuestro próximo currículo 'AI para Principiantes'.
En este curso usarás Scikit-learn y otras herramientas para construir modelos de aprendizaje automático para realizar lo que llamamos tareas tradicionales de aprendizaje automático. Hemos evitado intencionadamente redes neuronales y aprendizaje profundo, ya que se cubren mejor en nuestro próximo plan curricular 'IA para principiantes'.
Scikit-learn hace que sea sencillo construir modelos y evaluarlos para su uso. Se centra principalmente en el uso de datos numéricos y contiene varios conjuntos de datos listos para usar como herramientas de aprendizaje. También incluye modelos preconstruidos para que los estudiantes los prueben. Vamos a explorar el proceso de cargar datos preempaquetados y usar un estimador para el primer modelo de ML con Scikit-learn con algunos datos básicos.
Scikit-learn facilita construir modelos y evaluarlos para uso. Se centra principalmente en datos numéricos y contiene varios conjuntos de datos listos para usar como herramientas de aprendizaje. También incluye modelos preconstruidos para que los estudiantes prueben. Exploremos primero el proceso de cargar datos preempaquetados y usar un estimador incorporado para el primer modelo ML con Scikit-learn con datos básicos.
## Ejercicio - tu primer notebook con Scikit-learn
> Este tutorial fue inspirado por el [ejemplo de regresión lineal](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) en el sitio web de Scikit-learn.
[![ML para principiantes - Tu primer proyecto de regresión lineal en Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML para principiantes - Tu primer proyecto de regresión lineal en Python")
> 🎥 Haz clic en la imagen de arriba para ver un video corto sobre este ejercicio.
[![ML para principiantes - Tu Primer Proyecto de Regresión Lineal en Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML para principiantes - Tu Primer Proyecto de Regresión Lineal en Python")
En el archivo _notebook.ipynb_ asociado a esta lección, elimina todas las celdas presionando el ícono de 'papelera'.
> 🎥 Haz clic en la imagen de arriba para un video corto realizando este ejercicio.
En esta sección, trabajarás con un pequeño conjunto de datos sobre diabetes que está integrado en Scikit-learn para propósitos de aprendizaje. Imagina que quisieras probar un tratamiento para pacientes diabéticos. Los modelos de aprendizaje automático podrían ayudarte a determinar qué pacientes responderían mejor al tratamiento, basándote en combinaciones de variables. Incluso un modelo de regresión muy básico, cuando se visualiza, podría mostrar información sobre variables que te ayudarían a organizar tus ensayos clínicos teóricos.
En el archivo _notebook.ipynb_ asociado a esta lección, limpia todas las celdas presionando el icono de 'papelera'.
✅ Hay muchos tipos de métodos de regresión, y cuál elijas depende de la respuesta que estés buscando. Si quieres predecir la altura probable de una persona dada su edad, usarías regresión lineal, ya que estás buscando un **valor numérico**. Si estás interesado en descubrir si un tipo de cocina debería considerarse vegana o no, estás buscando una **asignación de categoría**, por lo que usarías regresión logística. Aprenderás más sobre regresión logística más adelante. Piensa un poco en algunas preguntas que puedes hacer a los datos y cuál de estos métodos sería más apropiado.
En esta sección, trabajarás con un pequeño conjunto de datos sobre diabetes que está incorporado en Scikit-learn para fines de aprendizaje. Imagina que quieres probar un tratamiento para pacientes diabéticos. Los modelos de aprendizaje automático pueden ayudarte a determinar qué pacientes responderían mejor al tratamiento, basándose en combinaciones de variables. Incluso un modelo básico de regresión, cuando se visualiza, puede mostrar información sobre variables que te ayudarían a organizar tus ensayos clínicos teóricos.
✅ Hay muchos tipos de métodos de regresión y cuál eliges depende de la respuesta que buscas. Si quieres predecir la altura probable para una persona de cierta edad, usarías regresión lineal, ya que buscas un **valor numérico**. Si te interesa descubrir si un tipo de cocina debe considerarse vegana o no, buscas una **asignación de categoría**, por lo que usarías regresión logística. Aprenderás más sobre regresión logística más adelante. Piensa un poco en algunas preguntas que puedes hacer sobre datos y cuál de estos métodos sería más apropiado.
Vamos a comenzar con esta tarea.
### Importar bibliotecas
Para esta tarea, importaremos algunas bibliotecas:
Para esta tarea importaremos algunas bibliotecas:
- **matplotlib**. Es una herramienta útil para [graficar](https://matplotlib.org/) y la usaremos para crear un gráfico de líneas.
- **matplotlib**. Es una [herramienta de gráficos](https://matplotlib.org/) útil que usaremos para crear un gráfico de líneas.
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) es una biblioteca útil para manejar datos numéricos en Python.
- **sklearn**. Esta es la biblioteca [Scikit-learn](https://scikit-learn.org/stable/user_guide.html).
Importa algunas bibliotecas para ayudarte con tus tareas.
1. Agrega las importaciones escribiendo el siguiente código:
1. Añade las importaciones escribiendo el siguiente código:
```python
import matplotlib.pyplot as plt
@ -122,26 +123,26 @@ Importa algunas bibliotecas para ayudarte con tus tareas.
from sklearn import datasets, linear_model, model_selection
```
Arriba estás importando `matplotlib`, `numpy` y estás importando `datasets`, `linear_model` y `model_selection` de `sklearn`. `model_selection` se usa para dividir datos en conjuntos de entrenamiento y prueba.
Más arriba estás importando `matplotlib`, `numpy` y estás importando `datasets`, `linear_model` y `model_selection` de `sklearn`. `model_selection` se usa para dividir los datos en conjuntos de entrenamiento y prueba.
### El conjunto de datos de diabetes
El [conjunto de datos de diabetes](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) integrado incluye 442 muestras de datos sobre diabetes, con 10 variables de características, algunas de las cuales incluyen:
El [conjunto de datos diabetes](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) incorporado incluye 442 muestras de datos sobre diabetes, con 10 variables características, algunas de las cuales incluyen:
- age: edad en años
- bmi: índice de masa corporal
- bp: presión arterial promedio
- s1 tc: células T (un tipo de glóbulos blancos)
- edad: edad en años
- imc: índice de masa corporal
- presión arterial: presión arterial promedio
- s1 tc: Células T (un tipo de glóbulos blancos)
✅ Este conjunto de datos incluye el concepto de 'sexo' como una variable de característica importante para la investigación sobre diabetes. Muchos conjuntos de datos médicos incluyen este tipo de clasificación binaria. Piensa un poco en cómo categorizaciones como esta podrían excluir a ciertas partes de la población de los tratamientos.
✅ Este conjunto de datos incluye el concepto de 'sexo' como variable característica importante para la investigación sobre diabetes. Muchos conjuntos de datos médicos incluyen este tipo de clasificación binaria. Piensa un poco en cómo categorizaciones así podrían excluir a ciertas partes de una población de tratamientos.
Ahora, carga los datos X e y.
Ahora, carga los datos X y y.
> 🎓 Recuerda, esto es aprendizaje supervisado, y necesitamos un objetivo 'y' nombrado.
> 🎓 Recuerda, este es aprendizaje supervisado, y necesitamos un objetivo llamado 'y'.
En una nueva celda de código, carga el conjunto de datos de diabetes llamando a `load_diabetes()`. El parámetro `return_X_y=True` indica que `X` será una matriz de datos y `y` será el objetivo de regresión.
En una nueva celda de código, carga el conjunto de datos diabetes llamando a `load_diabetes()`. El parámetro `return_X_y=True` señala que `X` será una matriz de datos, y `y` será el objetivo de regresión.
1. Agrega algunos comandos de impresión para mostrar la forma de la matriz de datos y su primer elemento:
1. Añade algunos comandos print para mostrar la forma de la matriz de datos y su primer elemento:
```python
X, y = datasets.load_diabetes(return_X_y=True)
@ -149,9 +150,9 @@ En una nueva celda de código, carga el conjunto de datos de diabetes llamando a
print(X[0])
```
Lo que estás obteniendo como respuesta es una tupla. Lo que estás haciendo es asignar los dos primeros valores de la tupla a `X` e `y` respectivamente. Aprende más [sobre tuplas](https://wikipedia.org/wiki/Tuple).
Lo que recibes como respuesta es una tupla. Lo que haces es asignar los dos primeros valores de la tupla a `X` y `y` respectivamente. Aprende más [sobre tuplas](https://wikipedia.org/wiki/Tuple).
Puedes ver que estos datos tienen 442 elementos organizados en matrices de 10 elementos:
Puedes ver que estos datos tienen 442 ítems con forma de arrays de 10 elementos:
```text
(442, 10)
@ -159,9 +160,9 @@ En una nueva celda de código, carga el conjunto de datos de diabetes llamando a
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
✅ Piensa un poco sobre la relación entre los datos y el objetivo de regresión. La regresión lineal predice relaciones entre la característica X y la variable objetivo y. ¿Puedes encontrar el [objetivo](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) para el conjunto de datos de diabetes en la documentación? ¿Qué está demostrando este conjunto de datos, dado ese objetivo?
✅ Piensa un poco sobre la relación entre los datos y el objetivo de regresión. La regresión lineal predice relaciones entre la característica X y la variable objetivo y. ¿Puedes encontrar el [objetivo](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) para el conjunto de datos de diabetes en la documentación? ¿Qué está demostrando este conjunto de datos dado ese objetivo?
2. A continuación, selecciona una porción de este conjunto de datos para graficar seleccionando la tercera columna del conjunto de datos. Puedes hacerlo usando el operador `:` para seleccionar todas las filas y luego seleccionando la tercera columna usando el índice (2). También puedes cambiar la forma de los datos para que sean una matriz 2D, como se requiere para graficar, usando `reshape(n_rows, n_columns)`. Si uno de los parámetros es -1, la dimensión correspondiente se calcula automáticamente.
2. Luego, selecciona una parte de este conjunto de datos para graficar seleccionando la tercera columna del conjunto. Puedes hacerlo usando el operador `:` para seleccionar todas las filas, y luego seleccionando la tercera columna usando el índice (2). También puedes remodelar los datos para que sean un array 2D — como se requiere para la gráfica — usando `reshape(n_filas, n_columnas)`. Si uno de los parámetros es -1, la dimensión correspondiente se calcula automáticamente.
```python
X = X[:, 2]
@ -170,28 +171,28 @@ En una nueva celda de código, carga el conjunto de datos de diabetes llamando a
✅ En cualquier momento, imprime los datos para verificar su forma.
3. Ahora que tienes los datos listos para ser graficados, puedes ver si una máquina puede ayudar a determinar una división lógica entre los números en este conjunto de datos. Para hacer esto, necesitas dividir tanto los datos (X) como el objetivo (y) en conjuntos de prueba y entrenamiento. Scikit-learn tiene una forma sencilla de hacer esto; puedes dividir tus datos de prueba en un punto dado.
3. Ahora que tienes datos listos para graficar, puedes ver si una máquina puede ayudar a determinar una división lógica entre los números en este conjunto de datos. Para ello, necesitas dividir tanto los datos (X) como el objetivo (y) en conjuntos de prueba y entrenamiento. Scikit-learn tiene una forma sencilla de hacerlo; puedes dividir tus datos de prueba en un punto dado.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. ¡Ahora estás listo para entrenar tu modelo! Carga el modelo de regresión lineal y entrénalo con tus conjuntos de entrenamiento X e y usando `model.fit()`:
4. ¡Ahora estás listo para entrenar tu modelo! Carga el modelo de regresión lineal y entrénalo con tus conjuntos de entrenamiento X y y usando `model.fit()`:
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
`model.fit()` es una función que verás en muchas bibliotecas de ML como TensorFlow.
`model.fit()` es una función que verás en muchas bibliotecas de ML como TensorFlow
5. Luego, crea una predicción usando datos de prueba, utilizando la función `predict()`. Esto se usará para dibujar la línea entre los grupos de datos.
5. Luego, crea una predicción usando los datos de prueba, usando la función `predict()`. Esto se usará para trazar la línea entre los grupos de datos.
```python
y_pred = model.predict(X_test)
```
6. Ahora es momento de mostrar los datos en un gráfico. Matplotlib es una herramienta muy útil para esta tarea. Crea un gráfico de dispersión de todos los datos de prueba X e y, y usa la predicción para dibujar una línea en el lugar más apropiado, entre los grupos de datos del modelo.
6. Ahora es momento de mostrar los datos en una gráfica. Matplotlib es una herramienta muy útil para esta tarea. Crea un diagrama de dispersión de todos los datos de prueba X e y, y usa la predicción para dibujar una línea en el lugar más apropiado, entre los grupos de datos del modelo.
```python
plt.scatter(X_test, y_test, color='black')
@ -202,23 +203,24 @@ En una nueva celda de código, carga el conjunto de datos de diabetes llamando a
plt.show()
```
![un gráfico de dispersión mostrando puntos de datos sobre diabetes](../../../../2-Regression/1-Tools/images/scatterplot.png)
✅ Piensa un poco en lo que está sucediendo aquí. Una línea recta está atravesando muchos pequeños puntos de datos, pero ¿qué está haciendo exactamente? ¿Puedes ver cómo deberías poder usar esta línea para predecir dónde debería encajar un nuevo punto de datos no visto en relación con el eje y del gráfico? Intenta poner en palabras el uso práctico de este modelo.
![un diagrama de dispersión mostrando puntos de datos sobre diabetes](../../../../translated_images/es/scatterplot.ad8b356bcbb33be6.webp)
¡Felicidades! Has construido tu primer modelo de regresión lineal, creado una predicción con él y la has mostrado en un gráfico.
✅ Piensa un poco sobre lo que está pasando aquí. Una línea recta atraviesa muchos pequeños puntos de datos, pero ¿qué está haciendo exactamente? ¿Puedes ver cómo deberías poder usar esta línea para predecir dónde debería encajar un nuevo punto de datos no visto en relación con el eje y del gráfico? Trata de poner en palabras el uso práctico de este modelo.
¡Felicidades, construiste tu primer modelo de regresión lineal, creaste una predicción con él y la mostraste en un gráfico!
---
## 🚀Desafío
Grafica una variable diferente de este conjunto de datos. Pista: edita esta línea: `X = X[:,2]`. Dado el objetivo de este conjunto de datos, ¿qué puedes descubrir sobre la progresión de la diabetes como enfermedad?
## [Cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario posterior a la conferencia](https://ff-quizzes.netlify.app/en/ml/)
## Revisión y Autoestudio
En este tutorial, trabajaste con regresión lineal simple, en lugar de regresión univariante o múltiple. Lee un poco sobre las diferencias entre estos métodos, o echa un vistazo a [este video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
En este tutorial, trabajaste con regresión lineal simple, en lugar de regresión lineal univariante o múltiple. Lee un poco sobre las diferencias entre estos métodos, o mira [este video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
Lee más sobre el concepto de regresión y piensa en qué tipo de preguntas pueden responderse con esta técnica. Toma este [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) para profundizar tu comprensión.
Lee más sobre el concepto de regresión y piensa en qué tipos de preguntas pueden responderse con esta técnica. Toma este [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) para profundizar tu comprensión.
## Tarea
@ -226,5 +228,7 @@ Lee más sobre el concepto de regresión y piensa en qué tipo de preguntas pued
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**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 automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,60 +1,60 @@
# Construir un modelo de regresión usando Scikit-learn: preparar y visualizar datos
# Construye un modelo de regresión usando Scikit-learn: prepara y visualiza datos
![Infografía de visualización de datos](../../../../2-Regression/2-Data/images/data-visualization.png)
![Infografía de visualización de datos](../../../../translated_images/es/data-visualization.54e56dded7c1a804.webp)
Infografía por [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario antes de la lección](https://ff-quizzes.netlify.app/en/ml/)
> ### [¡Esta lección está disponible en R!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
## Introducción
Ahora que tienes las herramientas necesarias para comenzar a construir modelos de aprendizaje automático con Scikit-learn, estás listo para empezar a formular preguntas sobre tus datos. Al trabajar con datos y aplicar soluciones de ML, es muy importante saber cómo hacer la pregunta correcta para desbloquear adecuadamente el potencial de tu conjunto de datos.
Ahora que tienes configuradas las herramientas que necesitas para comenzar a abordar la construcción de modelos de aprendizaje automático con Scikit-learn, estás listo para empezar a hacer preguntas a tus datos. Al trabajar con datos y aplicar soluciones de ML, es muy importante entender cómo hacer la pregunta correcta para desbloquear adecuadamente el potencial de tu conjunto de datos.
En esta lección, aprenderás:
- Cómo preparar tus datos para construir modelos.
- Cómo usar Matplotlib para la visualización de datos.
- Cómo usar Seaborn para una visualización de datos más expresiva.
## Hacer la pregunta correcta sobre tus datos
## Hacer la pregunta correcta a tus datos
La pregunta que necesitas responder determinará qué tipo de algoritmos de ML utilizarás. Y la calidad de la respuesta que obtengas dependerá en gran medida de la naturaleza de tus datos.
La pregunta que necesitas responder determinará qué tipo de algoritmos de ML utilizarás. Y la calidad de la respuesta que recibas dependerá en gran medida de la naturaleza de tus datos.
Echa un vistazo a los [datos](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) proporcionados para esta lección. Puedes abrir este archivo .csv en VS Code. Una revisión rápida muestra que hay espacios en blanco y una mezcla de datos de tipo cadena y numéricos. También hay una columna extraña llamada 'Package' donde los datos son una mezcla entre 'sacks', 'bins' y otros valores. De hecho, los datos están un poco desordenados.
Observa el [conjunto de datos](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) proporcionado para esta lección. Puedes abrir este archivo .csv en VS Code. Una revisión rápida muestra inmediatamente que hay espacios en blanco y una mezcla de datos de texto y numéricos. También hay una columna extraña llamada 'Package' donde los datos son una mezcla entre 'sacks', 'bins' y otros valores. De hecho, los datos están un poco desordenados.
[![ML para principiantes - Cómo analizar y limpiar un conjunto de datos](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML para principiantes - Cómo analizar y limpiar un conjunto de datos")
> 🎥 Haz clic en la imagen de arriba para ver un breve video sobre cómo preparar los datos para esta lección.
> 🎥 Haz clic en la imagen de arriba para un video breve que muestra cómo preparar los datos para esta lección.
De hecho, no es muy común recibir un conjunto de datos completamente listo para usar y crear un modelo de ML directamente. En esta lección, aprenderás cómo preparar un conjunto de datos sin procesar utilizando bibliotecas estándar de Python. También aprenderás varias técnicas para visualizar los datos.
De hecho, no es muy común recibir un conjunto de datos completamente listo para usar y crear un modelo de ML directamente. En esta lección, aprenderás cómo preparar un conjunto de datos sin procesar usando bibliotecas estándar de Python. También aprenderás varias técnicas para visualizar los datos.
## Caso de estudio: 'el mercado de calabazas'
## Estudio de caso: 'el mercado de calabazas'
En esta carpeta encontrarás un archivo .csv en la carpeta raíz `data` llamado [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv), que incluye 1757 líneas de datos sobre el mercado de calabazas, agrupados por ciudad. Estos son datos sin procesar extraídos de los [Informes estándar de mercados terminales de cultivos especiales](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuidos por el Departamento de Agricultura de los Estados Unidos.
En esta carpeta encontrarás un archivo .csv en la carpeta raíz `data` llamado [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) que incluye 1757 líneas de datos sobre el mercado de calabazas, agrupados por ciudad. Estos son datos sin procesar extraídos de los [Informes estándar de mercados terminales de cultivos especializados](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuidos por el Departamento de Agricultura de los Estados Unidos.
### Preparar los datos
### Preparando datos
Estos datos son de dominio público. Se pueden descargar en muchos archivos separados, por ciudad, desde el sitio web del USDA. Para evitar demasiados archivos separados, hemos concatenado todos los datos de las ciudades en una sola hoja de cálculo, por lo que ya hemos _preparado_ un poco los datos. Ahora, echemos un vistazo más de cerca a los datos.
### Los datos de calabazas - primeras conclusiones
### Los datos de calabazas - conclusiones iniciales
¿Qué notas sobre estos datos? Ya viste que hay una mezcla de cadenas, números, espacios en blanco y valores extraños que necesitas interpretar.
¿Qué notas sobre estos datos? Ya viste que hay una mezcla de cadenas, números, espacios en blanco y valores extraños que necesitas comprender.
¿Qué pregunta puedes hacer sobre estos datos utilizando una técnica de regresión? ¿Qué tal "Predecir el precio de una calabaza en venta durante un mes determinado"? Mirando nuevamente los datos, hay algunos cambios que necesitas hacer para crear la estructura de datos necesaria para esta tarea.
¿Qué pregunta puedes hacerle a estos datos usando una técnica de Regresión? ¿Qué tal "Predecir el precio de una calabaza a la venta durante un mes dado"? Mirando nuevamente los datos, hay algunos cambios que necesitas hacer para crear la estructura de datos necesaria para la tarea.
## Ejercicio - analiza los datos de calabazas
## Ejercicio - analizar los datos de calabazas
Usemos [Pandas](https://pandas.pydata.org/), (el nombre significa `Python Data Analysis`), una herramienta muy útil para dar forma a los datos, para analizar y preparar estos datos de calabazas.
Usemos [Pandas](https://pandas.pydata.org/) (el nombre significa `Python Data Analysis`), una herramienta muy útil para dar forma a los datos, para analizar y preparar estos datos de calabazas.
### Primero, verifica fechas faltantes
### Primero, verifica si faltan fechas
Primero necesitarás hacer pasos para verificar si faltan fechas:
Primero necesitarás tomar medidas para verificar si faltan fechas:
1. Convertir las fechas a formato de mes (estas son fechas de EE.UU., así que el formato es `MM/DD/YYYY`).
2. Extraer el mes a una nueva columna.
1. Convierte las fechas al formato de mes (estas son fechas de EE. UU., por lo que el formato es `MM/DD/YYYY`).
2. Extrae el mes a una nueva columna.
Abre el archivo _notebook.ipynb_ en Visual Studio Code e importa la hoja de cálculo en un nuevo dataframe de Pandas.
Abre el archivo _notebook.ipynb_ en Visual Studio Code y importa la hoja de cálculo en un nuevo dataframe de Pandas.
1. Usa la función `head()` para ver las primeras cinco filas.
@ -66,28 +66,28 @@ Abre el archivo _notebook.ipynb_ en Visual Studio Code e importa la hoja de cál
✅ ¿Qué función usarías para ver las últimas cinco filas?
1. Verifica si hay datos faltantes en el dataframe actual:
1. Revisa si hay datos faltantes en el dataframe actual:
```python
pumpkins.isnull().sum()
```
Hay datos faltantes, pero tal vez no importen para la tarea en cuestión.
Hay datos faltantes, pero quizá no importen para la tarea en cuestión.
1. Para que tu dataframe sea más fácil de trabajar, selecciona solo las columnas que necesitas, usando la función `loc`, que extrae del dataframe original un grupo de filas (pasadas como primer parámetro) y columnas (pasadas como segundo parámetro). La expresión `:` en el caso siguiente significa "todas las filas".
1. Para que tu dataframe sea más fácil de manejar, selecciona solo las columnas que necesitas, usando la función `loc` que extrae del dataframe original un grupo de filas (pasado como primer parámetro) y columnas (pasado como segundo parámetro). La expresión `:` en el caso siguiente significa "todas las filas".
```python
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
pumpkins = pumpkins.loc[:, columns_to_select]
```
### Segundo, determina el precio promedio de las calabazas
### Segundo, determina el precio promedio de la calabaza
Piensa en cómo determinar el precio promedio de una calabaza en un mes determinado. ¿Qué columnas elegirías para esta tarea? Pista: necesitarás 3 columnas.
Piensa cómo determinar el precio promedio de una calabaza en un mes dado. ¿Qué columnas escogerías para esta tarea? Pista: necesitarás 3 columnas.
Solución: toma el promedio de las columnas `Low Price` y `High Price` para llenar la nueva columna Price, y convierte la columna Date para que solo muestre el mes. Afortunadamente, según la verificación anterior, no hay datos faltantes para fechas o precios.
Solución: toma el promedio de las columnas `Low Price` y `High Price` para llenar la nueva columna Price, y convierte la columna Date para mostrar solo el mes. Afortunadamente, según la revisión anterior, no hay datos faltantes para fechas o precios.
1. Para calcular el promedio, agrega el siguiente código:
1. Para calcular el promedio, añade el siguiente código:
```python
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
@ -96,37 +96,37 @@ Solución: toma el promedio de las columnas `Low Price` y `High Price` para llen
```
✅ Siéntete libre de imprimir cualquier dato que desees verificar usando `print(month)`.
✅ Si quieres, puedes imprimir cualquier dato que desees verificar usando `print(month)`.
2. Ahora, copia tus datos convertidos en un nuevo dataframe de Pandas:
2. Ahora, copia tus datos convertidos a un nuevo dataframe de Pandas:
```python
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
Al imprimir tu dataframe, verás un conjunto de datos limpio y ordenado sobre el cual puedes construir tu nuevo modelo de regresión.
Imprimir tu dataframe te mostrará un conjunto de datos limpio y ordenado sobre el que puedes construir tu nuevo modelo de regresión.
### Pero espera, ¡hay algo extraño aquí!
### ¡Pero espera! Hay algo extraño aquí
Si miras la columna `Package`, las calabazas se venden en muchas configuraciones diferentes. Algunas se venden en medidas de '1 1/9 bushel', otras en '1/2 bushel', algunas por calabaza, otras por libra, y algunas en grandes cajas con anchos variables.
Si miras la columna `Package`, las calabazas se venden en muchas configuraciones diferentes. Algunas se venden en medidas de '1 1/9 bushel', otras en '1/2 bushel', algunas por calabaza, otras por libra, y algunas en cajas grandes de diferentes tamaños.
> Parece que las calabazas son muy difíciles de pesar de manera consistente.
> Las calabazas parecen muy difíciles de pesar de manera consistente
Al profundizar en los datos originales, es interesante notar que cualquier cosa con `Unit of Sale` igual a 'EACH' o 'PER BIN' también tiene el tipo `Package` por pulgada, por bin, o 'each'. Parece que las calabazas son muy difíciles de pesar de manera consistente, así que filtremos seleccionando solo las calabazas con la cadena 'bushel' en su columna `Package`.
Al profundizar en los datos originales, es interesante que cualquier cosa con `Unit of Sale` igual a 'EACH' o 'PER BIN' también tenga el tipo `Package` por pulgada, por contenedor o 'cada uno'. Las calabazas parecen ser muy difíciles de pesar consistentemente, así que filtremos solo las calabazas que tengan la cadena 'bushel' en su columna `Package`.
1. Agrega un filtro en la parte superior del archivo, debajo de la importación inicial del .csv:
1. Añade un filtro al principio del archivo, bajo la importación inicial del .csv:
```python
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
Si imprimes los datos ahora, puedes ver que solo estás obteniendo las aproximadamente 415 filas de datos que contienen calabazas por bushel.
Si imprimes los datos ahora, verás que solo estás obteniendo alrededor de 415 filas de datos que contienen calabazas por bushel.
### Pero espera, ¡hay una cosa más por hacer!
### ¡Pero espera! Hay una cosa más que hacer
¿Notaste que la cantidad de bushel varía por fila? Necesitas normalizar los precios para mostrar el precio por bushel, así que haz algunos cálculos para estandarizarlo.
¿Notaste que la cantidad de bushel varía por fila? Necesitas normalizar los precios para que muestren el precio por bushel, así que haz algunos cálculos para estandarizarlo.
1. Agrega estas líneas después del bloque que crea el dataframe new_pumpkins:
1. Añade estas líneas después del bloque que crea el nuevo dataframe new_pumpkins:
```python
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
@ -134,38 +134,38 @@ Al profundizar en los datos originales, es interesante notar que cualquier cosa
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ Según [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), el peso de un bushel depende del tipo de producto, ya que es una medida de volumen. "Un bushel de tomates, por ejemplo, se supone que pesa 56 libras... Las hojas y los vegetales ocupan más espacio con menos peso, por lo que un bushel de espinacas pesa solo 20 libras". ¡Es todo bastante complicado! No nos molestemos en hacer una conversión de bushel a libra, y en su lugar fijemos el precio por bushel. Todo este estudio sobre bushels de calabazas, sin embargo, demuestra lo importante que es entender la naturaleza de tus datos.
✅ Según [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), el peso de un bushel depende del tipo de producto, ya que es una medida de volumen. "Un bushel de tomates, por ejemplo, debe pesar 56 libras... Las hojas y verduras ocupan más espacio con menos peso, así que un bushel de espinacas pesa solo 20 libras." ¡Todo es bastante complicado! No nos molestaremos en hacer una conversión de bushel a libra, sino que valoraremos por bushel. ¡Todo este estudio sobre bushels de calabazas demuestra lo importante que es entender la naturaleza de tus datos!
Ahora puedes analizar el precio por unidad basado en su medida de bushel. Si imprimes los datos una vez más, puedes ver cómo se han estandarizado.
Ahora, puedes analizar los precios por unidad basados en su medida de bushel. Si imprimes los datos una vez más, puedes ver cómo están estandarizados.
✅ ¿Notaste que las calabazas vendidas por medio bushel son muy caras? ¿Puedes averiguar por qué? Pista: las calabazas pequeñas son mucho más caras que las grandes, probablemente porque hay muchas más por bushel, dado el espacio no utilizado que ocupa una calabaza grande y hueca para pastel.
✅ ¿Notaste que las calabazas vendidas por medio bushel son muy caras? ¿Puedes descubrir por qué? Pista: las calabazas pequeñas son mucho más caras que las grandes, probablemente porque hay muchas más por bushel, dado el espacio no usado que ocupa una calabaza grande hueca para pasteles.
## Estrategias de visualización
Parte del rol del científico de datos es demostrar la calidad y naturaleza de los datos con los que están trabajando. Para hacerlo, a menudo crean visualizaciones interesantes, como gráficos, diagramas y tablas, que muestran diferentes aspectos de los datos. De esta manera, pueden mostrar visualmente relaciones y brechas que de otro modo serían difíciles de descubrir.
Parte del rol del científico de datos es demostrar la calidad y naturaleza de los datos con los que están trabajando. Para ello, frecuentemente crean visualizaciones interesantes, o gráficos, diagramas y tablas que muestran diferentes aspectos de los datos. De este modo, pueden mostrar visualmente relaciones y vacíos que de otro modo serían difíciles de descubrir.
[![ML para principiantes - Cómo visualizar datos con Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML para principiantes - Cómo visualizar datos con Matplotlib")
> 🎥 Haz clic en la imagen de arriba para ver un breve video sobre cómo visualizar los datos para esta lección.
> 🎥 Haz clic en la imagen arriba para un video corto que muestra cómo visualizar los datos para esta lección.
Las visualizaciones también pueden ayudar a determinar la técnica de aprendizaje automático más adecuada para los datos. Un gráfico de dispersión que parece seguir una línea, por ejemplo, indica que los datos son buenos candidatos para un ejercicio de regresión lineal.
Las visualizaciones también pueden ayudar a determinar la técnica de aprendizaje automático más apropiada para los datos. Un diagrama de dispersión que parece seguir una línea, por ejemplo, indica que los datos son buenos candidatos para un ejercicio de regresión lineal.
Una biblioteca de visualización de datos que funciona bien en Jupyter notebooks es [Matplotlib](https://matplotlib.org/) (que también viste en la lección anterior).
Una biblioteca de visualización de datos que funciona bien en notebooks de Jupyter es [Matplotlib](https://matplotlib.org/) (que también viste en la lección anterior).
> Obtén más experiencia con la visualización de datos en [estos tutoriales](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
> Obtén más experiencia con visualización de datos en [estos tutoriales](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
## Ejercicio - experimentar con Matplotlib
## Ejercicio - experimenta con Matplotlib
Intenta crear algunos gráficos básicos para mostrar el nuevo dataframe que acabas de crear. ¿Qué mostraría un gráfico de líneas básico?
1. Importa Matplotlib en la parte superior del archivo, debajo de la importación de Pandas:
1. Importa Matplotlib al principio del archivo, bajo la importación de Pandas:
```python
import matplotlib.pyplot as plt
```
1. Vuelve a ejecutar todo el notebook para actualizar.
1. En la parte inferior del notebook, agrega una celda para graficar los datos como un cuadro:
1. Vuelve a ejecutar todo el notebook para refrescar.
1. Al final del notebook, añade una celda para graficar los datos como un boxplot:
```python
price = new_pumpkins.Price
@ -174,44 +174,121 @@ Intenta crear algunos gráficos básicos para mostrar el nuevo dataframe que aca
plt.show()
```
![Un gráfico de dispersión que muestra la relación entre precio y mes](../../../../2-Regression/2-Data/images/scatterplot.png)
![Un diagrama de dispersión que muestra la relación precio a mes](../../../../translated_images/es/scatterplot.b6868f44cbd2051c.webp)
¿Es este un gráfico útil? ¿Hay algo que te sorprenda?
¿Es este un gráfico útil? ¿Te sorprende algo en él?
No es particularmente útil, ya que solo muestra tus datos como una dispersión de puntos en un mes determinado.
No es particularmente útil ya que solo muestra tus datos como una dispersión de puntos en un mes dado.
### Hazlo útil
Para que los gráficos muestren datos útiles, generalmente necesitas agrupar los datos de alguna manera. Intentemos crear un gráfico donde el eje y muestre los meses y los datos demuestren la distribución de los mismos.
Para que los gráficos muestren datos útiles, usualmente necesitas agrupar los datos de alguna manera. Intentemos crear un gráfico donde el eje y muestre los meses y los datos demuestren la distribución de datos.
1. Agrega una celda para crear un gráfico de barras agrupado:
1. Añade una celda para crear un gráfico de barras agrupadas:
```python
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
plt.ylabel("Pumpkin Price")
```
![Un gráfico de barras que muestra la relación entre precio y mes](../../../../2-Regression/2-Data/images/barchart.png)
![Un gráfico de barras mostrando la relación precio a mes](../../../../translated_images/es/barchart.a833ea9194346d76.webp)
¡Esta es una visualización de datos más útil! Parece indicar que el precio más alto de las calabazas ocurre en septiembre y octubre. ¿Cumple esto tus expectativas? ¿Por qué o por qué no?
## Ejercicio - experimenta con Seaborn
Matplotlib es poderoso, pero puede requerir mucho código para producir un gráfico pulido. [Seaborn](https://seaborn.pydata.org/) es una biblioteca construida _sobre_ Matplotlib diseñada para visualización estadística de datos. Trabaja directamente con dataframes de Pandas, aplica estilos predeterminados atractivos y permite crear gráficos informativos con mucho menos código. Dado que Seaborn devuelve objetos de Matplotlib, aún puedes usar todo lo que ya sabes de Matplotlib para afinar el resultado.
> Si aún no tienes Seaborn instalado, instálalo con `pip install seaborn`.
1. Importa Seaborn al inicio del notebook, bajo las otras importaciones. Convencionalmente se importa como `sns`:
```python
import seaborn as sns
```
### Diagramas de dispersión para mostrar relaciones
Una gran parte de explorar datos antes de construir un modelo es buscar _relaciones_ entre variables. Un [diagrama de dispersión](https://en.wikipedia.org/wiki/Scatter_plot) es una de las mejores herramientas para esto: si los puntos parecen seguir una línea, las dos variables podrían estar correlacionadas, lo que es una buena señal de que un modelo de regresión lineal podría funcionar.
1. Reproduce el diagrama de dispersión precio a mes de antes, esta vez usando [`relplot()`](https://seaborn.pydata.org/generated/seaborn.relplot.html) de Seaborn (gráfico relacional), que funciona directamente con las columnas de tu dataframe:
```python
sns.relplot(x="Price", y="Month", data=new_pumpkins)
```
![Un diagrama de dispersión de Seaborn mostrando la relación precio a mes](../../../../translated_images/es/relplot.a03837d8f0329cec.webp)
Observa cómo pasas los _nombres de las columnas_ y el dataframe, y Seaborn se encarga de las etiquetas de los ejes por ti.
2. Puedes cambiar a un gráfico de líneas pasando `kind="line"`. Seaborn incluso dibuja una banda sombreada mostrando el intervalo de confianza alrededor de la línea:
```python
sns.relplot(x="Price", y="Month", kind="line", data=new_pumpkins)
```
![Un gráfico de líneas de Seaborn mostrando la relación precio a mes](../../../../translated_images/es/lineplot.f9034ba47b1e30ee.webp)
Estos datos son bastante ruidosos, así que un gráfico de líneas no es la opción más clara aquí — pero muestra qué tan fácil es cambiar tipos de gráficos en Seaborn.
### Gráficos de barras para mostrar distribuciones
Anteriormente agrupaste los datos a mano para crear un gráfico de barras con Matplotlib. El [`catplot()`](https://seaborn.pydata.org/generated/seaborn.catplot.html) de Seaborn (gráfico categórico) puede hacer la agrupación y agregación por ti. Por defecto, `kind="bar"` muestra la media de cada categoría junto con una línea negra que indica el intervalo de confianza.
1. Crea un gráfico de barras del precio promedio por mes:
```python
sns.catplot(x="Month", y="Price", data=new_pumpkins, kind="bar")
```
![Un gráfico de barras de Seaborn que muestra la distribución de precios por mes](../../../../translated_images/es/catplot.e73fc35fdf96242b.webp)
Esto confirma lo que viste con Matplotlib: los precios alcanzan su punto máximo alrededor de septiembre y octubre, pero Seaborn también visualiza cuánto _varía_ el precio dentro de cada mes.
### Mapas de calor para mostrar correlaciones
Los gráficos de dispersión comparan dos variables a la vez. Cuando tienes varias columnas numéricas, un [mapa de calor](https://es.wikipedia.org/wiki/Mapa_de_calor) te permite ver la fuerza de la relación entre _cada_ par de columnas al mismo tiempo. Esta es una manera común de identificar qué características están más correlacionadas antes de elegir qué alimentar en un modelo (y el mismo tipo de gráfico se usa después para mostrar matrices de confusión en clasificación).
1. Construye una matriz de correlación con Pandas y luego dibújala con el [`heatmap()`](https://seaborn.pydata.org/generated/seaborn.heatmap.html) de Seaborn. La opción `annot=True` imprime los valores de correlación en cada celda:
```python
correlations = new_pumpkins[['Month', 'Low Price', 'High Price', 'Price']].corr()
sns.heatmap(correlations, annot=True, cmap="coolwarm")
```
![Un mapa de calor de Seaborn mostrando correlaciones entre las columnas numéricas](../../../../translated_images/es/heatmap.bd98dce43b404c57.webp)
Valores cercanos a `1` (o `-1`) significan que las columnas están fuertemente correlacionadas _linealmente_. Observa cómo `Low Price` y `High Price` están casi perfectamente correlacionados. `Month`, en cambio, muestra solo una débil correlación lineal con el precio, aunque el gráfico de barras arriba reveló un pico estacional claro en septiembre y octubre. Esa es una lección importante: el coeficiente de correlación solo mide relaciones _lineales_, por lo que puede perder patrones estacionales o no lineales. ✅ ¿Por qué es útil mirar tanto un mapa de calor *como* gráficos como el de barras antes de decidir qué columnas usar?
### ¿Matplotlib o Seaborn?
Ambas bibliotecas vale la pena conocer:
- **Matplotlib** te da un control detallado sobre cada elemento de un gráfico y es la base sobre la que se construyen casi todas las otras bibliotecas de visualización en Python.
- **Seaborn** proporciona funciones de mayor nivel y valores predeterminados atractivos para gráficos estadísticos, trabaja directamente con dataframes y es a menudo más rápido para el análisis exploratorio de datos.
¡Este es un gráfico de datos más útil! Parece indicar que el precio más alto de las calabazas ocurre en septiembre y octubre. ¿Cumple con tus expectativas? ¿Por qué o por qué no?
Un flujo de trabajo común es usar Seaborn para explorar tus datos rápidamente y luego recurrir a Matplotlib cuando necesitas personalizar detalles.
---
## 🚀Desafío
Explora los diferentes tipos de visualización que ofrece Matplotlib. ¿Qué tipos son más apropiados para problemas de regresión?
Explora los diferentes tipos de visualización que ofrecen Matplotlib y Seaborn. ¿Qué tipos son más apropiados para problemas de regresión?
## [Cuestionario posterior a la lección](https://ff-quizzes.netlify.app/en/ml/)
## Revisión y autoestudio
## Repaso y estudio autónomo
Echa un vistazo a las muchas formas de visualizar datos. Haz una lista de las diversas bibliotecas disponibles y anota cuáles son mejores para ciertos tipos de tareas, por ejemplo, visualizaciones en 2D frente a visualizaciones en 3D. ¿Qué descubres?
Echa un vistazo a las muchas formas de visualizar datos. Haz una lista de las diversas bibliotecas disponibles y anota cuáles son mejores para determinados tipos de tareas, por ejemplo visualizaciones 2D versus visualizaciones 3D. ¿Qué descubres?
## Tarea
[Explorar visualización](assignment.md)
[Explorando la visualización](assignment.md)
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por lograr precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse como la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**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 automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -3,7 +3,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"## Regresión Lineal para Calabazas - Lección 2\n"
]
},
{
"cell_type": "code",
@ -220,6 +222,7 @@
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"pumpkins = pd.read_csv('../../data/US-pumpkins.csv')\n",
"\n",
"pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]\n",
@ -383,18 +386,78 @@
"plt.ylabel(\"Pumpkin Price\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Visualizando con Seaborn\n",
"\n",
"[Seaborn](https://seaborn.pydata.org/) está construido sobre Matplotlib y trabaja directamente con dataframes, lo que permite crear rápidamente gráficos estadísticos atractivos con muy poco código.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Diagramas de dispersión para mostrar relaciones\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.relplot(x=\"Price\", y=\"Month\", data=new_pumpkins)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.relplot(x=\"Price\", y=\"Month\", kind=\"line\", data=new_pumpkins)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Gráficos de barras para mostrar distribuciones\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
"source": [
"sns.catplot(x=\"Month\", y=\"Price\", data=new_pumpkins, kind=\"bar\")"
]
},
{
"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"
"### Mapas de calor para mostrar correlaciones\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"correlations = new_pumpkins[['Month', 'Low Price', 'High Price', 'Price']].corr()\n",
"sns.heatmap(correlations, annot=True, cmap=\"coolwarm\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\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). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -424,13 +487,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "95726f0b8283628d5356a4f8eb8b4b76",
"translation_date": "2025-09-04T01:36:43+00:00",
"source_file": "2-Regression/2-Data/solution/notebook.ipynb",
"language_code": "es"
}
"orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2

@ -1,11 +1,11 @@
# Introducción al Aprendizaje por Refuerzo y Q-Learning
![Resumen del refuerzo en el aprendizaje automático en un sketchnote](../../../../sketchnotes/ml-reinforcement.png)
![Resumen del refuerzo en el aprendizaje automático en una sketchnote](../../../../translated_images/es/ml-reinforcement.94024374d63348db.webp)
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
El aprendizaje por refuerzo implica tres conceptos importantes: el agente, algunos estados y un conjunto de acciones por estado. Al ejecutar una acción en un estado específico, el agente recibe una recompensa. Imagina nuevamente el videojuego Super Mario. Tú eres Mario, estás en un nivel del juego, parado junto al borde de un acantilado. Sobre ti hay una moneda. Tú, siendo Mario, en un nivel del juego, en una posición específica... ese es tu estado. Moverte un paso hacia la derecha (una acción) te llevará al borde y te dará una puntuación numérica baja. Sin embargo, presionar el botón de salto te permitirá ganar un punto y seguir vivo. Ese es un resultado positivo y debería otorgarte una puntuación numérica positiva.
El aprendizaje por refuerzo involucra tres conceptos importantes: el agente, algunos estados y un conjunto de acciones por estado. Al ejecutar una acción en un estado especificado, el agente recibe una recompensa. Imagina nuevamente el videojuego Super Mario. Eres Mario, estás en un nivel de juego, de pie junto al borde de un acantilado. Encima de ti hay una moneda. Tú siendo Mario, en un nivel de juego, en una posición específica... ese es tu estado. Mover un paso a la derecha (una acción) te llevaría al borde, y eso te daría una puntuación numérica baja. Sin embargo, presionar el botón de salto te permitiría anotar un punto y seguirías vivo. Ese es un resultado positivo y debería premiarte con una puntuación numérica positiva.
Usando aprendizaje por refuerzo y un simulador (el juego), puedes aprender a jugar para maximizar la recompensa, que es permanecer vivo y obtener la mayor cantidad de puntos posible.
Usando el aprendizaje por refuerzo y un simulador (el juego), puedes aprender cómo jugar para maximizar la recompensa, que es mantenerse vivo y anotar tantos puntos como sea posible.
[![Introducción al Aprendizaje por Refuerzo](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo)
@ -13,35 +13,35 @@ Usando aprendizaje por refuerzo y un simulador (el juego), puedes aprender a jug
## [Cuestionario previo a la lección](https://ff-quizzes.netlify.app/en/ml/)
## Prerrequisitos y Configuración
## Requisitos previos y configuración
En esta lección, experimentaremos con algo de código en Python. Deberías poder ejecutar el código del Jupyter Notebook de esta lección, ya sea en tu computadora o en la nube.
En esta lección, experimentaremos con algo de código en Python. Deberías poder ejecutar el código del Jupyter Notebook de esta lección, ya sea en tu computadora o en algún lugar en la nube.
Puedes abrir [el notebook de la lección](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) y seguir esta lección para construir.
Puedes abrir [el cuaderno de la lección](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) y seguir esta lección para construir.
> **Nota:** Si estás abriendo este código desde la nube, también necesitas obtener el archivo [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), que se utiliza en el código del notebook. Agrégalo al mismo directorio que el notebook.
> **Nota:** Si abres este código desde la nube, también debes obtener el archivo [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), que se usa en el código del cuaderno. Agrégalo al mismo directorio que el cuaderno.
## Introducción
En esta lección, exploraremos el mundo de **[Pedro y el Lobo](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)**, inspirado en un cuento musical de hadas de un compositor ruso, [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Usaremos **Aprendizaje por Refuerzo** para permitir que Pedro explore su entorno, recoja manzanas deliciosas y evite encontrarse con el lobo.
En esta lección, exploraremos el mundo de **[Pedro y el Lobo](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)**, inspirado en un cuento musical de un compositor ruso, [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Usaremos el **Aprendizaje por Refuerzo** para dejar que Pedro explore su entorno, recolecte manzanas sabrosas y evite encontrarse con el lobo.
El **Aprendizaje por Refuerzo** (RL) es una técnica de aprendizaje que nos permite aprender un comportamiento óptimo de un **agente** en algún **entorno** realizando muchos experimentos. Un agente en este entorno debe tener algún **objetivo**, definido por una **función de recompensa**.
El **Aprendizaje por Refuerzo** (RL) es una técnica de aprendizaje que nos permite aprender un comportamiento óptimo de un **agente** en algún **entorno** ejecutando muchos experimentos. Un agente en este entorno debe tener algún **objetivo**, definido por una **función de recompensa**.
## El entorno
Para simplificar, consideremos el mundo de Pedro como un tablero cuadrado de tamaño `ancho` x `alto`, como este:
Para simplificar, consideremos que el mundo de Pedro es un tablero cuadrado de tamaño `width` x `height`, así:
![Entorno de Pedro](../../../../8-Reinforcement/1-QLearning/images/environment.png)
![Entorno de Pedro](../../../../translated_images/es/environment.40ba3cb66256c93f.webp)
Cada celda en este tablero puede ser:
Cada celda de este tablero puede ser:
* **suelo**, sobre el cual Pedro y otras criaturas pueden caminar.
* **tierra**, sobre la cual Pedro y otras criaturas pueden caminar.
* **agua**, sobre la cual obviamente no puedes caminar.
* un **árbol** o **hierba**, un lugar donde puedes descansar.
* una **manzana**, que representa algo que Pedro estaría encantado de encontrar para alimentarse.
* un **árbol** o **césped**, un lugar donde puedes descansar.
* una **manzana**, que representa algo que Pedro estaría feliz de encontrar para alimentarse.
* un **lobo**, que es peligroso y debe evitarse.
Hay un módulo de Python separado, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), que contiene el código para trabajar con este entorno. Dado que este código no es importante para entender nuestros conceptos, importaremos el módulo y lo usaremos para crear el tablero de muestra (bloque de código 1):
Hay un módulo Python separado, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), que contiene el código para trabajar con este entorno. Debido a que este código no es importante para entender nuestros conceptos, importaremos el módulo y lo usaremos para crear el tablero de ejemplo (bloque de código 1):
```python
from rlboard import *
@ -56,11 +56,11 @@ Este código debería imprimir una imagen del entorno similar a la anterior.
## Acciones y política
En nuestro ejemplo, el objetivo de Pedro sería encontrar una manzana, mientras evita al lobo y otros obstáculos. Para lograr esto, esencialmente puede caminar por el tablero hasta encontrar una manzana.
En nuestro ejemplo, el objetivo de Pedro sería poder encontrar una manzana, evitando al lobo y otros obstáculos. Para ello, básicamente puede caminar hasta encontrar una manzana.
Por lo tanto, en cualquier posición, puede elegir entre una de las siguientes acciones: arriba, abajo, izquierda y derecha.
Por lo tanto, en cualquier posición puede elegir entre una de las siguientes acciones: arriba, abajo, izquierda y derecha.
Definiremos esas acciones como un diccionario y las mapearemos a pares de cambios de coordenadas correspondientes. Por ejemplo, moverse a la derecha (`R`) correspondería a un par `(1,0)`. (bloque de código 2):
Definiremos estas acciones como un diccionario y las asignaremos a pares de cambios de coordenadas correspondientes. Por ejemplo, moverse a la derecha (`R`) correspondería al par `(1,0)`. (bloque de código 2):
```python
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
@ -69,46 +69,46 @@ action_idx = { a : i for i,a in enumerate(actions.keys()) }
En resumen, la estrategia y el objetivo de este escenario son los siguientes:
- **La estrategia** de nuestro agente (Pedro) está definida por una llamada **política**. Una política es una función que devuelve la acción en cualquier estado dado. En nuestro caso, el estado del problema está representado por el tablero, incluida la posición actual del jugador.
- **La estrategia**, de nuestro agente (Pedro) está definida por una llamada **política**. Una política es una función que devuelve la acción en cualquier estado dado. En nuestro caso, el estado del problema está representado por el tablero, incluidas las posiciones actuales del jugador.
- **El objetivo** del aprendizaje por refuerzo es eventualmente aprender una buena política que nos permita resolver el problema de manera eficiente. Sin embargo, como línea base, consideremos la política más simple llamada **camino aleatorio**.
- **El objetivo**, del aprendizaje por refuerzo es eventualmente aprender una buena política que nos permita resolver el problema eficientemente. Sin embargo, como referencia, consideremos la política más simple llamada **camino aleatorio**.
## Camino aleatorio
Primero resolvamos nuestro problema implementando una estrategia de camino aleatorio. Con el camino aleatorio, elegiremos aleatoriamente la siguiente acción de las acciones permitidas, hasta que lleguemos a la manzana (bloque de código 3).
Primero resolvamos nuestro problema implementando una estrategia de camino aleatorio. Con el camino aleatorio, elegiremos aleatoriamente la próxima acción entre las permitidas hasta que lleguemos a la manzana (bloque de código 3).
1. Implementa el camino aleatorio con el siguiente código:
1. Implementa el camino aleatorio con el código a continuación:
```python
def random_policy(m):
return random.choice(list(actions))
def walk(m,policy,start_position=None):
n = 0 # number of steps
# set initial position
n = 0 # número de pasos
# establecer posición inicial
if start_position:
m.human = start_position
else:
m.random_start()
while True:
if m.at() == Board.Cell.apple:
return n # success!
return n # ¡éxito!
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
return -1 # eaten by wolf or drowned
return -1 # comido por el lobo o ahogado
while True:
a = actions[policy(m)]
new_pos = m.move_pos(m.human,a)
if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
m.move(a) # do the actual move
m.move(a) # realizar el movimiento real
break
n+=1
walk(m,random_policy)
```
La llamada a `walk` debería devolver la longitud del camino correspondiente, que puede variar de una ejecución a otra.
La llamada a `walk` debería devolver la longitud del camino correspondiente, que puede variar de una ejecución a otra.
1. Ejecuta el experimento de camino varias veces (digamos, 100) y muestra las estadísticas resultantes (bloque de código 4):
1. Ejecuta el experimento de camino aleatorio varias veces (digamos, 100) y muestra las estadísticas resultantes (bloque de código 4):
```python
def print_statistics(policy):
@ -125,15 +125,15 @@ Primero resolvamos nuestro problema implementando una estrategia de camino aleat
print_statistics(random_policy)
```
Nota que la longitud promedio de un camino es de alrededor de 30-40 pasos, lo cual es bastante, dado que la distancia promedio a la manzana más cercana es de alrededor de 5-6 pasos.
Ten en cuenta que la longitud promedio de un camino es de aproximadamente 30-40 pasos, que es bastante, dado que la distancia promedio a la manzana más cercana es de unos 5-6 pasos.
También puedes ver cómo se mueve Pedro durante el camino aleatorio:
También puedes ver cómo se ve el movimiento de Pedro durante el camino aleatorio:
![Camino aleatorio de Pedro](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)
![Camino Aleatorio de Pedro](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)
## Función de recompensa
Para hacer nuestra política más inteligente, necesitamos entender qué movimientos son "mejores" que otros. Para hacer esto, necesitamos definir nuestro objetivo.
Para hacer nuestra política más inteligente, necesitamos entender qué movimientos son "mejores" que otros. Para ello, necesitamos definir nuestro objetivo.
El objetivo puede definirse en términos de una **función de recompensa**, que devolverá algún valor de puntuación para cada estado. Cuanto mayor sea el número, mejor será la función de recompensa. (bloque de código 5)
@ -154,39 +154,115 @@ def reward(m,pos=None):
return move_reward
```
Lo interesante de las funciones de recompensa es que en la mayoría de los casos, *solo se nos da una recompensa sustancial al final del juego*. Esto significa que nuestro algoritmo debería recordar los pasos "buenos" que conducen a una recompensa positiva al final y aumentar su importancia. De manera similar, todos los movimientos que conducen a malos resultados deberían desalentarse.
Algo interesante sobre las funciones de recompensa es que en la mayoría de los casos, *solo se nos da una recompensa sustancial al final del juego*. Esto significa que nuestro algoritmo debería de alguna manera recordar los "buenos" pasos que llevan a una recompensa positiva al final y aumentar su importancia. De manera similar, todos los movimientos que llevan a malos resultados deberían ser desalentados.
## Q-Learning
El algoritmo que discutiremos aquí se llama **Q-Learning**. En este algoritmo, la política está definida por una función (o una estructura de datos) llamada **Q-Table**. Registra la "bondad" de cada una de las acciones en un estado dado.
Un algoritmo que discutiremos aquí se llama **Q-Learning**. En este algoritmo, la política está definida por una función (o una estructura de datos) llamada **Q-Table**. Esta registra la "bondad" de cada una de las acciones en un estado dado.
Se llama Q-Table porque a menudo es conveniente representarla como una tabla o un arreglo multidimensional. Dado que nuestro tablero tiene dimensiones `ancho` x `alto`, podemos representar la Q-Table usando un arreglo numpy con forma `ancho` x `alto` x `len(actions)`: (bloque de código 6)
Se llama Q-Table porque a menudo es conveniente representarla como una tabla o un arreglo multidimensional. Dado que nuestro tablero tiene dimensiones `width` x `height`, podemos representar la Q-Table usando un arreglo numpy con forma `width` x `height` x `len(actions)`: (bloque de código 6)
```python
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
```
Nota que inicializamos todos los valores de la Q-Table con un valor igual, en nuestro caso - 0.25. Esto corresponde a la política de "camino aleatorio", porque todos los movimientos en cada estado son igualmente buenos. Podemos pasar la Q-Table a la función `plot` para visualizar la tabla en el tablero: `m.plot(Q)`.
Observa que inicializamos todos los valores de la Q-Table con un valor igual, en nuestro caso - 0.25. Esto corresponde a la política de "camino aleatorio", porque todos los movimientos en cada estado son igualmente buenos. Podemos pasar la Q-Table a la función `plot` para visualizar la tabla en el tablero: `m.plot(Q)`.
![Entorno de Pedro](../../../../8-Reinforcement/1-QLearning/images/env_init.png)
![Entorno de Pedro](../../../../translated_images/es/env_init.04e8f26d2d60089e.webp)
En el centro de cada celda hay una "flecha" que indica la dirección preferida de movimiento. Dado que todas las direcciones son iguales, se muestra un punto.
En el centro de cada celda hay una "flecha" que indica la dirección preferida del movimiento. Como todas las direcciones son iguales, se muestra un punto.
Ahora necesitamos ejecutar la simulación, explorar nuestro entorno y aprender una mejor distribución de valores de la Q-Table, lo que nos permitirá encontrar el camino hacia la manzana mucho más rápido.
Ahora necesitamos ejecutar la simulación, explorar nuestro entorno y aprender una mejor distribución de los valores de la Q-Table, que nos permitirá encontrar el camino a la manzana mucho más rápido.
## Esencia del Q-Learning: Ecuación de Bellman
Una vez que comenzamos a movernos, cada acción tendrá una recompensa correspondiente, es decir, teóricamente podemos seleccionar la siguiente acción basada en la recompensa inmediata más alta. Sin embargo, en la mayoría de los estados, el movimiento no logrará nuestro objetivo de alcanzar la manzana, y por lo tanto no podemos decidir inmediatamente qué dirección es mejor.
Una vez que empezamos a movernos, cada acción tendrá una recompensa correspondiente, es decir, teóricamente podemos seleccionar la próxima acción basada en la recompensa inmediata más alta. Sin embargo, en la mayoría de los estados, el movimiento no logrará nuestro objetivo de alcanzar la manzana, y por lo tanto no podemos decidir inmediatamente qué dirección es mejor.
> Recuerda que no importa el resultado inmediato, sino el resultado final, que obtendremos al final de la simulación.
Para tener en cuenta esta recompensa diferida, necesitamos usar los principios de la **[programación dinámica](https://en.wikipedia.org/wiki/Dynamic_programming)**, que nos permiten pensar en nuestro problema de manera recursiva.
Para tener en cuenta esta recompensa retardada, necesitamos usar los principios de la **[programación dinámica](https://en.wikipedia.org/wiki/Dynamic_programming)**, que nos permiten pensar en nuestro problema recursivamente.
Supongamos que ahora estamos en el estado *s*, y queremos movernos al siguiente estado *s'*. Al hacerlo, recibiremos la recompensa inmediata *r(s,a)*, definida por la función de recompensa, más alguna recompensa futura. Si suponemos que nuestra Q-Table refleja correctamente la "atractividad" de cada acción, entonces en el estado *s'* elegiremos una acción *a'* que corresponda al valor máximo de *Q(s',a')*. Así, la mejor recompensa futura posible que podríamos obtener en el estado *s* se definirá como `max`
Supongamos que ahora estamos en el estado *s*, y queremos movernos al siguiente estado *s'*. Al hacerlo, recibiremos la recompensa inmediata *r(s,a)*, definida por la función de recompensa, más alguna recompensa futura. Si suponemos que nuestra Q-Table refleja correctamente la "atractividad" de cada acción, entonces en el estado *s'* escogeremos una acción *a* que corresponda al valor máximo de *Q(s',a')*. Por lo tanto, la mejor recompensa futura posible que podríamos obtener en el estado *s* estará definida como `max`<sub>a'</sub>*Q(s',a')* (el máximo aquí se calcula sobre todas las acciones posibles *a'* en el estado *s'*).
## Comprobando la política
Esto da la **fórmula de Bellman** para calcular el valor de la Q-Table en el estado *s*, dada la acción *a*:
Dado que la Q-Table enumera la "atractividad" de cada acción en cada estado, es bastante fácil usarla para definir la navegación eficiente en nuestro mundo. En el caso más simple, podemos seleccionar la acción correspondiente al valor más alto de la Q-Table: (bloque de código 9)
<img src="../../../../translated_images/es/bellman-equation.7c0c4c722e5a6b7c.webp"/>
Aquí γ es el llamado **factor de descuento** que determina hasta qué punto deberías preferir la recompensa actual sobre la futura y viceversa.
## Algoritmo de aprendizaje
Dada la ecuación anterior, ahora podemos escribir un pseudo-código para nuestro algoritmo de aprendizaje:
* Inicializar Q-Table Q con números iguales para todos los estados y acciones
* Establecer tasa de aprendizaje α ← 1
* Repetir la simulación muchas veces
1. Comenzar en posición aleatoria
1. Repetir
1. Seleccionar una acción *a* en el estado *s*
2. Ejecutar la acción moviéndose a un nuevo estado *s'*
3. Si encontramos la condición de fin del juego, o la recompensa total es muy baja - salir de la simulación
4. Calcular la recompensa *r* en el nuevo estado
5. Actualizar la función Q según la ecuación de Bellman: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
6. *s* ← *s'*
7. Actualizar la recompensa total y disminuir α.
## Explotar vs. explorar
En el algoritmo anterior, no especificamos exactamente cómo deberíamos elegir una acción en el paso 2.1. Si elegimos la acción aleatoriamente, estaremos **explorando** aleatoriamente el entorno, y es bastante probable que muramos a menudo, así como también exploraremos áreas a las que normalmente no iríamos. Un enfoque alternativo sería **explotar** los valores de la Q-Table que ya conocemos y así elegir la mejor acción (con el valor más alto en la Q-Table) en el estado *s*. Esto, sin embargo, nos impedirá explorar otros estados y es probable que no encontremos la solución óptima.
Por lo tanto, el mejor enfoque es encontrar un equilibrio entre exploración y explotación. Esto se puede lograr eligiendo la acción en el estado *s* con probabilidades proporcionales a los valores en la Q-Table. Al principio, cuando los valores de la Q-Table son todos iguales, esto corresponderá a una selección aleatoria, pero a medida que aprendamos más sobre nuestro entorno, será más probable que sigamos la ruta óptima mientras permitimos que el agente elija el camino inexplorado de vez en cuando.
## Implementación en Python
Ahora estamos listos para implementar el algoritmo de aprendizaje. Antes de hacerlo, también necesitamos una función que convierta números arbitrarios en la Q-Table en un vector de probabilidades para las acciones correspondientes.
1. Crea una función `probs()`:
```python
def probs(v,eps=1e-4):
v = v-v.min()+eps
v = v/v.sum()
return v
```
Añadimos un poco de `eps` al vector original para evitar la división por 0 en el caso inicial, cuando todos los componentes del vector son idénticos.
Ejecuta el algoritmo de aprendizaje a través de 5000 experimentos, también llamados **épocas**: (bloque de código 8)
```python
for epoch in range(5000):
# Elegir punto inicial
m.random_start()
# Comenzar a viajar
n=0
cum_reward = 0
while True:
x,y = m.human
v = probs(Q[x,y])
a = random.choices(list(actions),weights=v)[0]
dpos = actions[a]
m.move(dpos,check_correctness=False) # permitimos que el jugador se mueva fuera del tablero, lo que termina el episodio
r = reward(m)
cum_reward += r
if r==end_reward or cum_reward < -1000:
lpath.append(n)
break
alpha = np.exp(-n / 10e5)
gamma = 0.5
ai = action_idx[a]
Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max())
n+=1
```
Después de ejecutar este algoritmo, la Q-Table debería actualizarse con valores que definen la atractividad de diferentes acciones en cada paso. Podemos intentar visualizar la Q-Table plotteando un vector en cada celda que apunte en la dirección deseada de movimiento. Por simplicidad, dibujamos un pequeño círculo en lugar de una punta de flecha.
<img src="../../../../translated_images/es/learned.ed28bcd8484b5287.webp"/>
## Verificación de la política
Dado que la Q-Table lista la "atractividad" de cada acción en cada estado, es bastante fácil usarla para definir una navegación eficiente en nuestro mundo. En el caso más simple, podemos seleccionar la acción correspondiente al valor más alto de la Q-Table: (bloque de código 9)
```python
def qpolicy_strict(m):
@ -198,17 +274,18 @@ def qpolicy_strict(m):
walk(m,qpolicy_strict)
```
> Si pruebas el código anterior varias veces, puede que notes que a veces se "queda colgado" y necesitas presionar el botón STOP en el notebook para interrumpirlo. Esto ocurre porque podría haber situaciones en las que dos estados "apuntan" el uno al otro en términos de valor óptimo de Q-Value, en cuyo caso el agente termina moviéndose entre esos estados indefinidamente.
> Si pruebas el código anterior varias veces, puedes notar que a veces se "cuelga" y necesitas presionar el botón DETENER en el cuaderno para interrumpirlo. Esto ocurre porque podrían existir situaciones en las que dos estados se "apuntan" entre sí en términos del valor Q óptimo, en cuyo caso el agente termina moviéndose entre esos estados indefinidamente.
## 🚀Desafío
> **Tarea 1:** Modifica la función `walk` para limitar la longitud máxima del camino a un cierto número de pasos (por ejemplo, 100), y observa cómo el código anterior devuelve este valor de vez en cuando.
> **Tarea 1:** Modifica la función `walk` para limitar la longitud máxima del camino a cierto número de pasos (por ejemplo, 100), y observa cómo el código anterior devuelve este valor de vez en cuando.
> **Tarea 2:** Modifica la función `walk` para que no regrese a los lugares donde ya ha estado previamente. Esto evitará que `walk` entre en bucles, sin embargo, el agente aún puede terminar "atrapado" en una ubicación de la que no puede escapar.
> **Tarea 2:** Modifica la función `walk` para que no regrese a lugares donde ya ha estado anteriormente. Esto evitará que `walk` haga bucles, sin embargo, el agente aún puede quedar "atrapado" en un lugar del que no pueda escapar.
## Navegación
Una política de navegación mejor sería la que usamos durante el entrenamiento, que combina explotación y exploración. En esta política, seleccionaremos cada acción con cierta probabilidad, proporcional a los valores en la Q-Table. Esta estrategia aún puede hacer que el agente regrese a una posición que ya ha explorado, pero, como puedes ver en el código a continuación, resulta en un camino promedio muy corto hacia la ubicación deseada (recuerda que `print_statistics` ejecuta la simulación 100 veces): (bloque de código 10)
Una mejor política de navegación sería la que usamos durante el entrenamiento, que combina explotación y exploración. En esta política, seleccionaremos cada acción con cierta probabilidad, proporcional a los valores en la tabla Q. Esta estrategia aún puede resultar en que el agente regrese a una posición que ya ha explorado, pero, como puedes ver en el código a continuación, resulta en un camino promedio muy corto hasta la ubicación deseada (recuerda que `print_statistics` ejecuta la simulación 100 veces): (bloque de código 10)
```python
def qpolicy(m):
@ -220,28 +297,32 @@ def qpolicy(m):
print_statistics(qpolicy)
```
Después de ejecutar este código, deberías obtener una longitud promedio de camino mucho más pequeña que antes, en el rango de 3-6.
Después de ejecutar este código, deberías obtener una longitud promedio de camino mucho menor que antes, en el rango de 3-6.
## Investigando el proceso de aprendizaje
Como hemos mencionado, el proceso de aprendizaje es un equilibrio entre la exploración y la explotación del conocimiento adquirido sobre la estructura del espacio del problema. Hemos visto que los resultados del aprendizaje (la capacidad de ayudar a un agente a encontrar un camino corto hacia el objetivo) han mejorado, pero también es interesante observar cómo se comporta la longitud promedio del camino durante el proceso de aprendizaje:
Como hemos mencionado, el proceso de aprendizaje es un equilibrio entre la exploración y la explotación del conocimiento adquirido sobre la estructura del espacio del problema. Hemos visto que los resultados del aprendizaje (la habilidad para ayudar a un agente a encontrar un camino corto hasta la meta) han mejorado, pero también es interesante observar cómo se comporta la longitud promedio del camino durante el proceso de aprendizaje:
<img src="../../../../translated_images/es/lpathlen1.0534784add58d4eb.webp"/>
## Los aprendizajes pueden resumirse como:
Se pueden resumir las enseñanzas como:
- **La longitud promedio del camino aumenta**. Lo que vemos aquí es que al principio, la longitud promedio del camino aumenta. Esto probablemente se debe al hecho de que cuando no sabemos nada sobre el entorno, es probable que quedemos atrapados en estados desfavorables, como agua o lobos. A medida que aprendemos más y comenzamos a usar este conocimiento, podemos explorar el entorno por más tiempo, pero aún no sabemos muy bien dónde están las manzanas.
- **La longitud promedio del camino aumenta**. Lo que vemos aquí es que al principio, la longitud promedio del camino aumenta. Probablemente se deba a que cuando no sabemos nada sobre el entorno, es probable que quedemos atrapados en estados malos, como agua o lobo. A medida que aprendemos más y comenzamos a usar este conocimiento, podemos explorar el entorno por más tiempo, pero todavía no sabemos muy bien dónde están las manzanas.
- **La longitud del camino disminuye a medida que aprendemos más**. Una vez que aprendemos lo suficiente, se vuelve más fácil para el agente alcanzar el objetivo, y la longitud del camino comienza a disminuir. Sin embargo, aún estamos abiertos a la exploración, por lo que a menudo nos desviamos del mejor camino y exploramos nuevas opciones, haciendo que el camino sea más largo de lo óptimo.
- **La longitud del camino disminuye a medida que aprendemos más**. Una vez que aprendemos lo suficiente, se vuelve más fácil para el agente lograr la meta, y la longitud del camino comienza a disminuir. Sin embargo, todavía estamos abiertos a la exploración, por lo que a menudo nos desviamos del mejor camino y exploramos nuevas opciones, haciendo que el camino sea más largo que el óptimo.
- **La longitud aumenta abruptamente**. Lo que también observamos en este gráfico es que en algún momento, la longitud aumentó abruptamente. Esto indica la naturaleza estocástica del proceso, y que en algún momento podemos "estropear" los coeficientes de la Q-Table sobrescribiéndolos con nuevos valores. Esto idealmente debería minimizarse disminuyendo la tasa de aprendizaje (por ejemplo, hacia el final del entrenamiento, solo ajustamos los valores de la Q-Table por un pequeño valor).
- **La longitud aumenta abruptamente**. Lo que también observamos en este gráfico es que en algún punto, la longitud aumentó abruptamente. Esto indica la naturaleza estocástica del proceso, y que en algún momento podemos "estropear" los coeficientes de la tabla Q sobrescribiéndolos con nuevos valores. Idealmente, esto debería minimizarse disminuyendo la tasa de aprendizaje (por ejemplo, hacia el final del entrenamiento, solo ajustamos los valores de la tabla Q por un valor pequeño).
En general, es importante recordar que el éxito y la calidad del proceso de aprendizaje dependen significativamente de parámetros como la tasa de aprendizaje, la disminución de la tasa de aprendizaje y el factor de descuento. A menudo se les llama **hiperparámetros**, para distinguirlos de los **parámetros**, que optimizamos durante el entrenamiento (por ejemplo, los coeficientes de la Q-Table). El proceso de encontrar los mejores valores de hiperparámetros se llama **optimización de hiperparámetros**, y merece un tema aparte.
En general, es importante recordar que el éxito y la calidad del proceso de aprendizaje dependen significativamente de parámetros, tales como la tasa de aprendizaje, la disminución de la tasa de aprendizaje y el factor de descuento. Estos a menudo se llaman **hiperparámetros**, para distinguirlos de los **parámetros**, que optimizamos durante el entrenamiento (por ejemplo, los coeficientes de la tabla Q). El proceso de encontrar los mejores valores para los hiperparámetros se llama **optimización de hiperparámetros**, y merece un tema aparte.
## [Cuestionario post-clase](https://ff-quizzes.netlify.app/en/ml/)
## [Cuestionario posterior a la conferencia](https://ff-quizzes.netlify.app/en/ml/)
## Tarea
[Un Mundo Más Realista](assignment.md)
## Tarea
[Un mundo más realista](assignment.md)
---
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Si bien nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Descargo de responsabilidad**:
Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -24,8 +24,8 @@
"language_code": "fr"
},
"1-Introduction/3-fairness/README.md": {
"original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
"translation_date": "2025-09-04T22:59:38+00:00",
"original_hash": "0f00d72169a0d37eecfd16d71e01700a",
"translation_date": "2026-07-13T23:27:21+00:00",
"source_file": "1-Introduction/3-fairness/README.md",
"language_code": "fr"
},
@ -54,8 +54,8 @@
"language_code": "fr"
},
"2-Regression/1-Tools/README.md": {
"original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
"translation_date": "2025-09-04T22:53:45+00:00",
"original_hash": "0b8635427b582d03ea4ab7089b93e505",
"translation_date": "2026-07-13T23:23:57+00:00",
"source_file": "2-Regression/1-Tools/README.md",
"language_code": "fr"
},
@ -72,8 +72,8 @@
"language_code": "fr"
},
"2-Regression/2-Data/README.md": {
"original_hash": "7c077988328ebfe33b24d07945f16eca",
"translation_date": "2025-09-04T22:54:23+00:00",
"original_hash": "a58b2c4d16c6b122643391745ac15af6",
"translation_date": "2026-07-13T23:24:59+00:00",
"source_file": "2-Regression/2-Data/README.md",
"language_code": "fr"
},
@ -89,6 +89,12 @@
"source_file": "2-Regression/2-Data/solution/Julia/README.md",
"language_code": "fr"
},
"2-Regression/2-Data/solution/notebook.ipynb": {
"original_hash": "96b95f8cf473481f2f371de8156f1571",
"translation_date": "2026-07-13T23:15:10+00:00",
"source_file": "2-Regression/2-Data/solution/notebook.ipynb",
"language_code": "fr"
},
"2-Regression/3-Linear/README.md": {
"original_hash": "8b776e731c35b171d316d01d0e7b1369",
"translation_date": "2026-04-26T18:32:56+00:00",
@ -457,7 +463,7 @@
},
"8-Reinforcement/1-QLearning/README.md": {
"original_hash": "911efd5e595089000cb3c16fce1beab8",
"translation_date": "2025-09-04T23:05:02+00:00",
"translation_date": "2026-07-13T23:25:49+00:00",
"source_file": "8-Reinforcement/1-QLearning/README.md",
"language_code": "fr"
},
@ -481,7 +487,7 @@
},
"8-Reinforcement/2-Gym/README.md": {
"original_hash": "107d5bb29da8a562e7ae72262d251a75",
"translation_date": "2025-09-04T23:05:38+00:00",
"translation_date": "2026-07-13T23:26:38+00:00",
"source_file": "8-Reinforcement/2-Gym/README.md",
"language_code": "fr"
},
@ -581,6 +587,19 @@
"source_file": "TROUBLESHOOTING.md",
"language_code": "fr"
},
"__translation_failures__": {
"sketchnotes/LICENSE.md": {
"original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
"source_file": "sketchnotes/LICENSE.md",
"language_code": "fr",
"failure_date": "2026-07-13T23:23:19+00:00",
"status": "failed",
"error_type": "TranslationIncompleteError",
"error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.",
"translator_version": "0.20.0",
"failure_policy_version": 1
}
},
"docs/_sidebar.md": {
"original_hash": "68dd06c685f6ce840e0acfa313352e7c",
"translation_date": "2025-09-03T23:13:30+00:00",

@ -1,161 +1,167 @@
# Construire des solutions de Machine Learning avec une IA responsable
![Résumé de l'IA responsable dans le Machine Learning sous forme de sketchnote](../../../../sketchnotes/ml-fairness.png)
# Construire des solutions dapprentissage automatique avec une IA responsable
![Résumé de l'IA responsable dans l'apprentissage automatique sous forme de sketchnote](../../../../translated_images/fr/ml-fairness.ef296ebec6afc98a.webp)
> Sketchnote par [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Quiz avant le cours](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz avant la leçon](https://ff-quizzes.netlify.app/en/ml/)
## Introduction
Dans ce programme, vous commencerez à découvrir comment le machine learning influence et impacte nos vies quotidiennes. Aujourd'hui, des systèmes et modèles participent à des tâches de prise de décision quotidienne, comme les diagnostics médicaux, les approbations de prêts ou la détection de fraudes. Il est donc crucial que ces modèles fonctionnent correctement pour fournir des résultats fiables. Comme tout logiciel, les systèmes d'IA peuvent ne pas répondre aux attentes ou produire des résultats indésirables. C'est pourquoi il est essentiel de comprendre et d'expliquer le comportement d'un modèle d'IA.
Dans ce programme, vous commencerez à découvrir comment lapprentissage automatique peut et impacte nos vies quotidiennes. Même à lheure actuelle, des systèmes et modèles interviennent dans les tâches décisionnelles quotidiennes, telles que les diagnostics médicaux, les approbations de prêts ou la détection de fraudes. Il est donc important que ces modèles fonctionnent bien pour fournir des résultats dignes de confiance. Comme toute application logicielle, les systèmes dIA peuvent ne pas répondre aux attentes ou produire un résultat indésirable. Cest pourquoi il est essentiel de pouvoir comprendre et expliquer le comportement dun modèle dIA.
Imaginez ce qui peut arriver lorsque les données utilisées pour construire ces modèles manquent de représentations de certains groupes démographiques, comme la race, le genre, les opinions politiques ou la religion, ou lorsqu'elles surreprésentent certains groupes. Que se passe-t-il lorsque les résultats du modèle favorisent un groupe démographique particulier ? Quelles sont les conséquences pour l'application ? De plus, que se passe-t-il lorsque le modèle produit un résultat négatif et nuit aux personnes ? Qui est responsable du comportement des systèmes d'IA ? Ce sont quelques-unes des questions que nous explorerons dans ce programme.
Imaginez ce qui peut arriver lorsque les données utilisées pour construire ces modèles manquent certains groupes démographiques, tels que la race, le genre, les opinions politiques, la religion, ou représentent de façon disproportionnée ces groupes démographiques. Que se passe-t-il lorsque le résultat du modèle est interprété comme favorisant un groupe démographique ? Quelle est la conséquence pour lapplication ? De plus, que se passe-t-il lorsque le modèle produit un résultat défavorable et nuit aux personnes ? Qui est responsable du comportement des systèmes dIA ? Ce sont quelques-unes des questions que nous explorerons dans ce programme.
Dans cette leçon, vous allez :
- Prendre conscience de l'importance de l'équité dans le machine learning et des préjudices liés à l'injustice.
- Vous familiariser avec la pratique d'exploration des cas atypiques et des scénarios inhabituels pour garantir fiabilité et sécurité.
- Comprendre la nécessité de concevoir des systèmes inclusifs pour autonomiser tout le monde.
- Explorer l'importance de protéger la vie privée et la sécurité des données et des individus.
- Découvrir l'importance d'une approche transparente pour expliquer le comportement des modèles d'IA.
- Être attentif à l'importance de la responsabilité pour instaurer la confiance dans les systèmes d'IA.
- Prendre conscience de limportance de léquité dans lapprentissage automatique et des préjudices liés à léquité.
- Vous familiariser avec la pratique dexplorer les valeurs aberrantes et les scénarios inhabituels pour assurer la fiabilité et la sécurité.
- Comprendre la nécessité dautonomiser tout le monde en concevant des systèmes inclusifs.
- Explorer combien il est vital de protéger la vie privée et la sécurité des données et des personnes.
- Voir limportance dadopter une approche « boîte transparente » pour expliquer le comportement des modèles dIA.
- Être conscient de limportance de la responsabilité pour construire la confiance dans les systèmes dIA.
## Prérequis
En guise de prérequis, veuillez suivre le parcours d'apprentissage "Principes de l'IA responsable" et regarder la vidéo ci-dessous sur le sujet :
En préalable, veuillez suivre le parcours dapprentissage « Principes de lIA responsable » et visionner la vidéo ci-dessous sur le sujet :
Apprenez-en davantage sur l'IA responsable en suivant ce [parcours d'apprentissage](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
En savoir plus sur lIA responsable en suivant ce [Parcours dapprentissage](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
[![Approche de Microsoft sur l'IA responsable](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Approche de Microsoft sur l'IA responsable")
[![Approche de Microsoft pour une IA responsable](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Approche de Microsoft pour une IA responsable")
> 🎥 Cliquez sur l'image ci-dessus pour une vidéo : Approche de Microsoft sur l'IA responsable
> 🎥 Cliquez sur limage ci-dessus pour une vidéo : Approche de Microsoft pour une IA responsable
## Équité
Les systèmes d'IA doivent traiter tout le monde de manière équitable et éviter d'affecter différemment des groupes similaires. Par exemple, lorsque les systèmes d'IA fournissent des recommandations sur les traitements médicaux, les demandes de prêt ou l'emploi, ils doivent faire les mêmes recommandations à tous ceux qui présentent des symptômes, des circonstances financières ou des qualifications professionnelles similaires. Chacun de nous, en tant qu'humain, porte des biais hérités qui influencent nos décisions et actions. Ces biais peuvent se refléter dans les données utilisées pour entraîner les systèmes d'IA. Ces manipulations peuvent parfois se produire involontairement. Il est souvent difficile de savoir consciemment quand on introduit des biais dans les données.
Les systèmes dIA doivent traiter tout le monde équitablement et éviter daffecter différemment des groupes de personnes similaires. Par exemple, lorsque les systèmes dIA fournissent des recommandations sur un traitement médical, des demandes de prêt ou un emploi, ils doivent faire les mêmes recommandations à tous ceux qui présentent des symptômes similaires, des circonstances financières semblables ou des qualifications professionnelles équivalentes. Chacun de nous porte des biais hérités qui influencent nos décisions et actions. Ces biais peuvent être présents dans les données utilisées pour entraîner les systèmes dIA. Cette manipulation peut parfois se produire involontairement. Il est souvent difficile de savoir consciemment quand on introduit un biais dans les données.
**L'“injustice”** englobe les impacts négatifs, ou “préjudices”, pour un groupe de personnes, comme ceux définis en termes de race, genre, âge ou statut de handicap. Les principaux préjudices liés à l'équité peuvent être classés comme suit :
**« Injustice »** englobe les impacts négatifs, ou « préjudices », subis par un groupe de personnes, par exemple définis en fonction de la race, du genre, de lâge ou du statut de handicap. Les principaux préjudices liés à léquité peuvent être classés comme suit :
- **Allocation**, lorsque, par exemple, un genre ou une ethnie est favorisé par rapport à un autre.
- **Qualité du service**. Si vous entraînez les données pour un scénario spécifique alors que la réalité est bien plus complexe, cela conduit à un service de mauvaise qualité. Par exemple, un distributeur de savon qui ne semble pas détecter les personnes à la peau foncée. [Référence](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **Dénigrement**. Critiquer ou étiqueter injustement quelque chose ou quelqu'un. Par exemple, une technologie de reconnaissance d'images a tristement mal identifié des images de personnes à la peau foncée comme des gorilles.
- **Sur- ou sous-représentation**. L'idée qu'un certain groupe n'est pas représenté dans une profession donnée, et tout service ou fonction qui continue de promouvoir cela contribue au préjudice.
- **Stéréotypage**. Associer un groupe donné à des attributs préassignés. Par exemple, un système de traduction entre l'anglais et le turc peut présenter des inexactitudes dues à des associations stéréotypées liées au genre.
- **Répartition**, si un genre ou une origine ethnique, par exemple, est favorisé par rapport à un autre.
- **Qualité du service**. Si vous entraînez les données pour un scénario précis mais que la réalité est beaucoup plus complexe, cela conduit à un service de mauvaise qualité. Par exemple, un distributeur de savon qui ne semble pas capable de détecter les personnes à la peau foncée. [Référence](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **Dénigrement**. Critiquer et étiqueter injustement quelque chose ou quelquun. Par exemple, une technologie détiquetage dimages a tristement célèbrement mal étiqueté des images de personnes à la peau foncée comme des gorilles.
- **Sur- ou sous-représentation**. Lidée est quun certain groupe nest pas visible dans une certaine profession, et tout service ou fonction qui continue à promouvoir cela contribue à causer un préjudice.
- **Stéréotypage**. Associer un groupe donné à des attributs préassignés. Par exemple, un système de traduction linguistique entre langlais et le turc peut avoir des inexactitudes dues à des mots associés à des stéréotypes de genre.
![traduction en turc](../../../../1-Introduction/3-fairness/images/gender-bias-translate-en-tr.png)
> traduction en turc
![traduction vers le turc](../../../../translated_images/fr/gender-bias-translate-en-tr.f185fd8822c2d437.webp)
> traduction vers le turc
![traduction en anglais](../../../../1-Introduction/3-fairness/images/gender-bias-translate-tr-en.png)
> traduction en anglais
![traduction retour en anglais](../../../../translated_images/fr/gender-bias-translate-tr-en.4eee7e3cecb8c70e.webp)
> traduction retour en anglais
Lors de la conception et des tests des systèmes d'IA, nous devons nous assurer que l'IA est équitable et qu'elle n'est pas programmée pour prendre des décisions biaisées ou discriminatoires, que les êtres humains sont également interdits de prendre. Garantir l'équité dans l'IA et le machine learning reste un défi sociotechnique complexe.
Lors de la conception et des tests des systèmes dIA, nous devons nous assurer que lIA est équitable et ne soit pas programmée pour prendre des décisions biaisées ou discriminatoires, ce que les êtres humains sont également interdits de faire. Garantir léquité dans lIA et lapprentissage automatique reste un défi sociotechnique complexe.
### Fiabilité et sécurité
Pour instaurer la confiance, les systèmes d'IA doivent être fiables, sûrs et cohérents dans des conditions normales et inattendues. Il est important de savoir comment les systèmes d'IA se comporteront dans une variété de situations, en particulier lorsqu'il s'agit de cas atypiques. Lors de la création de solutions d'IA, il est nécessaire de se concentrer sur la manière de gérer une grande variété de circonstances que les solutions d'IA pourraient rencontrer. Par exemple, une voiture autonome doit donner la priorité à la sécurité des personnes. En conséquence, l'IA qui alimente la voiture doit prendre en compte tous les scénarios possibles que la voiture pourrait rencontrer, comme la nuit, les orages ou les tempêtes de neige, les enfants traversant la rue, les animaux domestiques, les travaux routiers, etc. La capacité d'un système d'IA à gérer de manière fiable et sûre une large gamme de conditions reflète le niveau d'anticipation que le data scientist ou le développeur d'IA a pris en compte lors de la conception ou des tests du système.
Pour instaurer la confiance, les systèmes dIA doivent être fiables, sûrs et cohérents dans des conditions normales et inattendues. Il est important de savoir comment les systèmes dIA se comporteront dans différentes situations, en particulier lorsquil sagit déléments atypiques. Lors de la création de solutions dIA, il faut accorder une attention substantielle à la manière de gérer une grande variété de circonstances que la solution dIA pourrait rencontrer. Par exemple, une voiture autonome doit faire de la sécurité des personnes une priorité absolue. Par conséquent, lIA qui alimente la voiture doit considérer tous les scénarios possibles que la voiture pourrait rencontrer, comme la nuit, les orages, les tempêtes de neige, les enfants traversant la rue, les animaux domestiques, les travaux routiers, etc. La capacité dun système dIA à gérer une grande diversité de conditions avec fiabilité et sécurité reflète le niveau danticipation du data scientist ou du développeur dIA lors de la conception ou des tests du système.
> [🎥 Cliquez ici pour une vidéo : ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
### Inclusion
Les systèmes d'IA doivent être conçus pour engager et autonomiser tout le monde. Lors de la conception et de la mise en œuvre des systèmes d'IA, les data scientists et les développeurs d'IA identifient et abordent les obstacles potentiels dans le système qui pourraient exclure involontairement des personnes. Par exemple, il y a 1 milliard de personnes handicapées dans le monde. Avec les avancées de l'IA, elles peuvent accéder plus facilement à une large gamme d'informations et d'opportunités dans leur vie quotidienne. En abordant ces obstacles, cela crée des opportunités d'innover et de développer des produits d'IA avec de meilleures expériences qui profitent à tout le monde.
Les systèmes dIA doivent être conçus pour engager et autonomiser tout le monde. Lors de la conception et de la mise en œuvre des systèmes dIA, les data scientists et développeurs identifient et traitent les obstacles potentiels dans le système qui pourraient exclure involontairement des personnes. Par exemple, il y a 1 milliard de personnes en situation de handicap dans le monde. Avec lavancement de lIA, elles peuvent accéder plus facilement à une grande variété dinformations et dopportunités dans leur vie quotidienne. En levant ces obstacles, cela crée des opportunités dinnover et de développer des produits dIA avec de meilleures expériences qui bénéficient à tous.
> [🎥 Cliquez ici pour une vidéo : inclusion dans l'IA](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
> [🎥 Cliquez ici pour une vidéo : inclusion dans lIA](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
### Sécurité et confidentialité
### Sécurité et vie privée
Les systèmes d'IA doivent être sûrs et respecter la vie privée des individus. Les gens ont moins confiance dans les systèmes qui mettent leur vie privée, leurs informations ou leur sécurité en danger. Lors de l'entraînement des modèles de machine learning, nous nous appuyons sur les données pour produire les meilleurs résultats. Ce faisant, l'origine des données et leur intégrité doivent être prises en compte. Par exemple, les données ont-elles été soumises par les utilisateurs ou sont-elles disponibles publiquement ? Ensuite, en travaillant avec les données, il est crucial de développer des systèmes d'IA capables de protéger les informations confidentielles et de résister aux attaques. À mesure que l'IA devient plus répandue, protéger la vie privée et sécuriser les informations personnelles et professionnelles importantes devient de plus en plus critique et complexe. Les questions de confidentialité et de sécurité des données nécessitent une attention particulière pour l'IA, car l'accès aux données est essentiel pour que les systèmes d'IA fassent des prédictions et des décisions précises et éclairées sur les individus.
Les systèmes dIA doivent être sûrs et respecter la vie privée des personnes. Les gens ont moins confiance dans les systèmes qui mettent leur vie privée, leurs informations ou leur vie en danger. Lors de lentraînement de modèles dapprentissage automatique, nous nous appuyons sur des données pour produire les meilleurs résultats. Ce faisant, lorigine des données et leur intégrité doivent être prises en compte. Par exemple, les données ont-elles été fournies par lutilisateur ou sont-elles disponibles publiquement ? Ensuite, lors du travail avec les données, il est crucial de développer des systèmes dIA capables de protéger les informations confidentielles et de résister aux attaques. À mesure que lIA devient plus courante, protéger la vie privée et sécuriser les informations personnelles et professionnelles importantes devient de plus en plus critique et complexe. Les problèmes de vie privée et de sécurité des données requièrent une attention particulière en IA car laccès aux données est essentiel pour que les systèmes dIA fassent des prédictions et des décisions précises et éclairées sur les personnes.
> [🎥 Cliquez ici pour une vidéo : sécurité dans l'IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
> [🎥 Cliquez ici pour une vidéo : sécurité dans lIA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- En tant qu'industrie, nous avons réalisé des avancées significatives en matière de confidentialité et de sécurité, largement alimentées par des réglementations comme le RGPD (Règlement Général sur la Protection des Données).
- Cependant, avec les systèmes d'IA, nous devons reconnaître la tension entre le besoin de données personnelles pour rendre les systèmes plus efficaces et la protection de la vie privée.
- Tout comme avec la naissance des ordinateurs connectés à Internet, nous observons également une augmentation significative des problèmes de sécurité liés à l'IA.
- En même temps, nous avons vu l'IA être utilisée pour améliorer la sécurité. Par exemple, la plupart des scanners antivirus modernes sont aujourd'hui alimentés par des heuristiques d'IA.
- Nous devons nous assurer que nos processus de Data Science s'harmonisent avec les dernières pratiques en matière de confidentialité et de sécurité.
- En tant quindustrie, nous avons réalisé des avancées significatives en matière de vie privée et de sécurité, largement stimulées par des réglementations comme le RGPD (Règlement général sur la protection des données).
- Pourtant, avec les systèmes dIA, nous devons reconnaître la tension entre le besoin de plus de données personnelles pour rendre les systèmes plus personnels et efficaces et la vie privée.
- Comme avec la naissance des ordinateurs connectés à Internet, nous observons aussi une forte augmentation du nombre de problèmes de sécurité liés à lIA.
- En même temps, nous avons vu lIA utilisée pour améliorer la sécurité. Par exemple, la plupart des scanners antivirus modernes sont aujourdhui alimentés par des heuristiques dIA.
- Nous devons veiller à ce que nos processus de science des données sharmonisent avec les dernières pratiques en matière de vie privée et de sécurité.
### Transparence
Les systèmes d'IA doivent être compréhensibles. Une partie essentielle de la transparence consiste à expliquer le comportement des systèmes d'IA et de leurs composants. Améliorer la compréhension des systèmes d'IA nécessite que les parties prenantes comprennent comment et pourquoi ils fonctionnent afin qu'elles puissent identifier les problèmes de performance potentiels, les préoccupations en matière de sécurité et de confidentialité, les biais, les pratiques d'exclusion ou les résultats involontaires. Nous pensons également que ceux qui utilisent les systèmes d'IA doivent être honnêtes et transparents sur le moment, les raisons et la manière dont ils choisissent de les déployer, ainsi que sur les limites des systèmes qu'ils utilisent. Par exemple, si une banque utilise un système d'IA pour soutenir ses décisions de prêt aux consommateurs, il est important d'examiner les résultats et de comprendre quelles données influencent les recommandations du système. Les gouvernements commencent à réglementer l'IA dans divers secteurs, donc les data scientists et les organisations doivent expliquer si un système d'IA répond aux exigences réglementaires, en particulier lorsqu'il y a un résultat indésirable.
### Transparence
Les systèmes dIA doivent être compréhensibles. Une partie cruciale de la transparence est dexpliquer le comportement des systèmes dIA et de leurs composants. Améliorer la compréhension des systèmes dIA exige que les parties prenantes comprennent comment et pourquoi ils fonctionnent afin de pouvoir identifier les problèmes potentiels de performance, les préoccupations en matière de sécurité et de vie privée, les biais, les pratiques exclusionnaires ou les résultats inattendus. Nous pensons également que ceux qui utilisent les systèmes dIA devraient être honnêtes et transparents sur le moment, la raison et la manière dont ils choisissent de les déployer, ainsi que sur les limites des systèmes quils utilisent. Par exemple, si une banque utilise un système dIA pour soutenir ses décisions de prêt à la consommation, il est important dexaminer les résultats et de comprendre quelles données influencent les recommandations du système. Les gouvernements commencent à réglementer lIA dans tous les secteurs, donc les data scientists et les organisations doivent expliquer si un système dIA respecte les exigences réglementaires, notamment en cas de résultat indésirable.
> [🎥 Cliquez ici pour une vidéo : transparence dans l'IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
> [🎥 Cliquez ici pour une vidéo : transparence dans lIA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- Parce que les systèmes d'IA sont si complexes, il est difficile de comprendre leur fonctionnement et d'interpréter les résultats.
- Ce manque de compréhension affecte la manière dont ces systèmes sont gérés, opérationnalisés et documentés.
- Ce manque de compréhension affecte surtout les décisions prises en utilisant les résultats produits par ces systèmes.
- Parce que les systèmes dIA sont si complexes, il est difficile de comprendre leur fonctionnement et dinterpréter les résultats.
- Cette incompréhension impacte la manière dont ces systèmes sont gérés, opérationnalisés et documentés.
- Cette incompréhension affecte surtout les décisions prises à partir des résultats produits par ces systèmes.
### Responsabilité
Les personnes qui conçoivent et déploient les systèmes dIA doivent être responsables de leur fonctionnement. Le besoin de responsabilité est particulièrement crucial avec des technologies dusage sensible comme la reconnaissance faciale. Récemment, il y a eu une demande croissante pour la reconnaissance faciale, notamment de la part des forces de lordre qui voient le potentiel de la technologie pour des usages tels que la recherche denfants disparus. Cependant, ces technologies pourraient potentiellement être utilisées par un gouvernement pour mettre en danger les libertés fondamentales de ses citoyens en permettant, par exemple, la surveillance continue de certains individus. Ainsi, les data scientists et les organisations doivent être responsables de limpact de leurs systèmes dIA sur les individus ou la société.
Les personnes qui conçoivent et déploient des systèmes d'IA doivent être responsables de leur fonctionnement. La nécessité de responsabilité est particulièrement cruciale avec les technologies sensibles comme la reconnaissance faciale. Récemment, la demande pour la technologie de reconnaissance faciale a augmenté, notamment de la part des organisations de maintien de l'ordre qui voient le potentiel de cette technologie pour des usages comme retrouver des enfants disparus. Cependant, ces technologies pourraient être utilisées par un gouvernement pour mettre en danger les libertés fondamentales de ses citoyens, par exemple en permettant une surveillance continue de certains individus. Ainsi, les data scientists et les organisations doivent être responsables de l'impact de leur système d'IA sur les individus ou la société.
[![Chercheur principal en IA met en garde contre la surveillance de masse via la reconnaissance faciale](../../../../translated_images/fr/accountability.41d8c0f4b85b6231.webp)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Approche de Microsoft pour une IA responsable")
[![Un chercheur en IA met en garde contre la surveillance de masse via la reconnaissance faciale](../../../../1-Introduction/3-fairness/images/accountability.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Approche de Microsoft sur l'IA responsable")
> 🎥 Cliquez sur limage ci-dessus pour une vidéo : Avertissements sur la surveillance de masse via la reconnaissance faciale
> 🎥 Cliquez sur l'image ci-dessus pour une vidéo : Mises en garde contre la surveillance de masse via la reconnaissance faciale
En fin de compte, l'une des plus grandes questions pour notre génération, en tant que première génération à introduire lIA dans la société, est de savoir comment garantir que les ordinateurs resteront responsables envers les personnes et comment garantir que les personnes qui conçoivent les ordinateurs restent responsables envers tout le monde.
En fin de compte, l'une des plus grandes questions pour notre génération, en tant que première génération à introduire l'IA dans la société, est de savoir comment garantir que les ordinateurs resteront responsables envers les humains et comment s'assurer que les personnes qui conçoivent les ordinateurs restent responsables envers tout le monde.
## Évaluation dimpact
## Évaluation de l'impact
Avant dentraîner un modèle dapprentissage automatique, il est important de réaliser une évaluation dimpact pour comprendre le but du système dIA ; son usage prévu ; où il sera déployé ; et qui interagira avec le système. Cela aide les évaluateurs ou testeurs à savoir quels facteurs prendre en compte pour identifier les risques potentiels et les conséquences attendues.
Avant d'entraîner un modèle de machine learning, il est important de réaliser une évaluation de l'impact pour comprendre l'objectif du système d'IA, son utilisation prévue, son lieu de déploiement et les personnes qui interagiront avec le système. Ces éléments sont utiles pour les examinateurs ou testeurs qui évaluent le système afin de savoir quels facteurs prendre en compte pour identifier les risques potentiels et les conséquences attendues.
Les domaines dintérêt lors de lévaluation dimpact sont :
Les domaines suivants sont à examiner lors de l'évaluation de l'impact :
* **Impact négatif sur les individus**. Être conscient de toute restriction ou exigence, utilisation non supportée ou toute limite connue entravant la performance du système est vital pour sassurer que le système ne soit pas utilisé dune manière susceptible de nuire aux individus.
* **Exigences en matière de données**. Comprendre comment et où le système utilisera les données permet aux évaluateurs dexplorer toutes les exigences en matière de données à respecter (par exemple, RGPD ou HIPAA). En outre, vérifier si la source ou la quantité de données est suffisante pour lentraînement.
* **Résumé de limpact**. Recueillir une liste des préjudices potentiels qui pourraient découler de lutilisation du système. Tout au long du cycle de vie de lIA, vérifier si les problèmes identifiés sont atténués ou traités.
* **Objectifs applicables** pour chacun des six principes fondamentaux. Évaluer si les objectifs de chaque principe sont atteints et sil existe des lacunes.
* **Impact négatif sur les individus**. Être conscient de toute restriction ou exigence, utilisation non prise en charge ou toute limitation connue entravant les performances du système est essentiel pour garantir que le système n'est pas utilisé d'une manière qui pourrait nuire aux individus.
* **Exigences en matière de données**. Comprendre comment et où le système utilisera les données permet aux examinateurs d'explorer les exigences en matière de données dont vous devez tenir compte (par exemple, les réglementations RGPD ou HIPAA). En outre, examinez si la source ou la quantité de données est suffisante pour l'entraînement.
* **Résumé de l'impact**. Rassemblez une liste des préjudices potentiels qui pourraient découler de l'utilisation du système. Tout au long du cycle de vie du ML, vérifiez si les problèmes identifiés sont atténués ou résolus.
* **Objectifs applicables** pour chacun des six principes fondamentaux. Évaluez si les objectifs de chaque principe sont atteints et s'il existe des lacunes.
## Débogage avec une IA responsable
Tout comme le débogage d'une application logicielle, le débogage d'un système d'IA est un processus nécessaire pour identifier et résoudre les problèmes dans le système. De nombreux facteurs peuvent affecter les performances d'un modèle et l'empêcher d'agir de manière responsable. La plupart des métriques traditionnelles de performance des modèles sont des agrégats quantitatifs des performances d'un modèle, ce qui n'est pas suffisant pour analyser comment un modèle viole les principes de l'IA responsable. De plus, un modèle de machine learning est une boîte noire, ce qui rend difficile de comprendre ce qui motive ses résultats ou d'expliquer ses erreurs. Plus tard dans ce cours, nous apprendrons à utiliser le tableau de bord de l'IA responsable pour aider à déboguer les systèmes d'IA. Ce tableau de bord fournit un outil holistique pour les data scientists et les développeurs d'IA afin de réaliser :
Comme pour le débogage dune application logicielle, déboguer un système dIA est un processus nécessaire pour identifier et résoudre les problèmes du système. De nombreux facteurs peuvent affecter la performance dun modèle qui ne répond pas aux attentes ou nest pas responsable. La plupart des métriques classiques de performance des modèles sont des agrégats quantitatifs de la performance dun modèle, ce qui nest pas suffisant pour analyser comment un modèle viole les principes dIA responsable. Par ailleurs, un modèle dapprentissage automatique est une boîte noire qui rend difficile la compréhension des facteurs influençant son résultat ou lexplication dune erreur. Plus tard dans ce cours, nous apprendrons à utiliser le tableau de bord Responsible AI pour aider à déboguer les systèmes dIA. Le tableau de bord offre un outil holistique pour les data scientists et développeurs dIA afin deffectuer :
* **Analyse des erreurs**. Identifier la distribution des erreurs du modèle qui peut affecter l'équité ou la fiabilité du système.
* **Vue d'ensemble du modèle**. Découvrir où il existe des disparités dans les performances du modèle à travers les cohortes de données.
* **Analyse des données**. Comprendre la distribution des données et identifier tout biais potentiel dans les données pouvant entraîner des problèmes d'équité, d'inclusion et de fiabilité.
* **Interprétabilité du modèle**. Comprendre ce qui affecte ou influence les prédictions du modèle. Cela aide à expliquer le comportement du modèle, ce qui est important pour la transparence et la responsabilité.
* **Analyse des erreurs**. Identifier la distribution des erreurs du modèle qui peuvent affecter léquité ou la fiabilité du système.
* **Vue densemble du modèle**. Découvrir où il existe des disparités dans la performance du modèle selon les cohortes de données.
* **Analyse des données**. Comprendre la répartition des données et identifier tout biais potentiel dans les données susceptible de causer des problèmes déquité, dinclusion et de fiabilité.
* **Interprétabilité du modèle**. Comprendre ce qui influence ou impacte les prédictions du modèle. Cela aide à expliquer le comportement du modèle, ce qui est important pour la transparence et la responsabilité.
## 🚀 Défi
Pour éviter que des préjudices ne soient introduits dès le départ, nous devrions :
## 🚀 Défi
Pour prévenir lapparition de préjudices dès le départ, nous devrions :
- avoir une diversité de parcours et de perspectives parmi les personnes travaillant sur les systèmes
- investir dans des ensembles de données qui reflètent la diversité de notre société
- développer de meilleures méthodes tout au long du cycle de vie du machine learning pour détecter et corriger les problèmes liés à l'IA responsable lorsqu'ils surviennent
- investir dans des jeux de données reflétant la diversité de notre société
- développer de meilleures méthodes tout au long du cycle de vie de lapprentissage automatique pour détecter et corriger les cas dIA responsable lorsque cela se produit
Réfléchissez à des scénarios réels où le manque de fiabilité d'un modèle est évident dans sa création et son utilisation. Que devrions-nous considérer d'autre ?
Pensez à des scénarios réels où le manque de fiabilité dun modèle est évident lors de la construction et de lutilisation du modèle. Que devrions-nous dautre prendre en compte ?
## [Quiz après le cours](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz après la leçon](https://ff-quizzes.netlify.app/en/ml/)
## Révision et étude personnelle
## Revue & auto-étude
Dans cette leçon, vous avez appris les bases des concepts d'équité et d'injustice dans le machine learning.
Regardez cet atelier pour approfondir les sujets abordés :
Dans cette leçon, vous avez appris quelques notions de base sur les concepts déquité et dinéquité en apprentissage automatique.
Regardez cet atelier pour approfondir les sujets :
- À la recherche d'une IA responsable : Mettre les principes en pratique par Besmira Nushi, Mehrnoosh Sameki et Amit Sharma
- À la poursuite dune IA responsable : Mettre les principes en pratique par Besmira Nushi, Mehrnoosh Sameki et Amit Sharma
[![Responsible AI Toolbox : Un cadre open-source pour construire une IA responsable](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox : Un cadre open-source pour construire une IA responsable")
[![Responsible AI Toolbox: An open-source framework for building responsible AI](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: An open-source framework for building responsible AI")
> 🎥 Cliquez sur l'image ci-dessus pour une vidéo : RAI Toolbox : Un cadre open-source pour construire une IA responsable par Besmira Nushi, Mehrnoosh Sameki et Amit Sharma
> 🎥 Cliquez sur limage ci-dessus pour une vidéo : RAI Toolbox : Un cadre open-source pour construire une IA responsable par Besmira Nushi, Mehrnoosh Sameki et Amit Sharma
À lire également :
Lisez aussi :
- Centre de ressources RAI de Microsoft : [Ressources sur l'IA responsable Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Centre de ressources IA responsable de Microsoft : [Responsible AI Resources Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Groupe de recherche FATE de Microsoft : [FATE : Équité, Responsabilité, Transparence et Éthique dans l'IA - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
- Groupe de recherche FATE de Microsoft : [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
RAI Toolbox :
Boîte à outils RAI :
- [Dépôt GitHub de Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox)
- [Dépôt GitHub de la Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox)
Découvrez les outils d'Azure Machine Learning pour garantir l'équité :
Lisez sur les outils dAzure Machine Learning pour garantir léquité :
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
## Devoir
## Exercice
[Explorez RAI Toolbox](assignment.md)
[Explorez la Responsible AI Toolbox](assignment.md)
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,106 +1,107 @@
# Commencez avec Python et Scikit-learn pour les modèles de régression
![Résumé des régressions dans une sketchnote](../../../../sketchnotes/ml-regression.png)
![Résumé des régressions dans un sketchnote](../../../../translated_images/fr/ml-regression.4e4f70e3b3ed446e.webp)
> Sketchnote par [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Quiz avant le cours](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz avant la leçon](https://ff-quizzes.netlify.app/en/ml/)
> ### [Cette leçon est disponible en R !](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
## Introduction
Dans ces quatre leçons, vous allez découvrir comment construire des modèles de régression. Nous discuterons bientôt de leur utilité. Mais avant de commencer, assurez-vous d'avoir les bons outils en place pour démarrer le processus !
Dans ces quatre leçons, vous allez découvrir comment construire des modèles de régression. Nous discuterons brièvement de leur utilité. Mais avant de faire quoi que ce soit, assurez-vous d'avoir les bons outils en place pour commencer le processus !
Dans cette leçon, vous apprendrez à :
- Configurer votre ordinateur pour des tâches locales d'apprentissage automatique.
- Travailler avec les notebooks Jupyter.
- Utiliser Scikit-learn, y compris son installation.
- Configurer votre ordinateur pour des tâches d'apprentissage automatique local.
- Travailler avec Jupyter Notebooks.
- Utiliser Scikit-learn, y compris l'installation.
- Explorer la régression linéaire avec un exercice pratique.
## Installations et configurations
[![ML pour débutants - Configurez vos outils pour créer des modèles d'apprentissage automatique](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML pour débutants - Configurez vos outils pour créer des modèles d'apprentissage automatique")
[![ML pour débutants - Préparez vos outils pour construire des modèles d'apprentissage automatique](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML pour débutants - Préparez vos outils pour construire des modèles d'apprentissage automatique")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant comment configurer votre ordinateur pour l'apprentissage automatique.
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant la configuration de votre ordinateur pour le ML.
1. **Installez Python**. Assurez-vous que [Python](https://www.python.org/downloads/) est installé sur votre ordinateur. Vous utiliserez Python pour de nombreuses tâches de science des données et d'apprentissage automatique. La plupart des systèmes informatiques incluent déjà une installation de Python. Il existe également des [packs de codage Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) utiles pour simplifier la configuration pour certains utilisateurs.
1. **Installez Python**. Assurez-vous que [Python](https://www.python.org/downloads/) est installé sur votre ordinateur. Vous utiliserez Python pour de nombreuses tâches de science des données et d'apprentissage automatique. La plupart des systèmes informatiques incluent déjà une installation de Python. Il existe aussi des [packs de codage Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) utiles pour faciliter la configuration pour certains utilisateurs.
Certaines utilisations de Python nécessitent une version spécifique du logiciel, tandis que d'autres en nécessitent une différente. Pour cette raison, il est utile de travailler dans un [environnement virtuel](https://docs.python.org/3/library/venv.html).
Certaines utilisations de Python nécessitent cependant une version du logiciel, tandis que d'autres en requièrent une différente. Pour cette raison, il est utile de travailler dans un [environnement virtuel](https://docs.python.org/3/library/venv.html).
2. **Installez Visual Studio Code**. Assurez-vous que Visual Studio Code est installé sur votre ordinateur. Suivez ces instructions pour [installer Visual Studio Code](https://code.visualstudio.com/) pour une installation de base. Vous allez utiliser Python dans Visual Studio Code dans ce cours, alors vous pourriez vouloir vous familiariser avec la [configuration de Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) pour le développement Python.
2. **Installez Visual Studio Code**. Assurez-vous d'avoir Visual Studio Code installé sur votre ordinateur. Suivez ces instructions pour [installer Visual Studio Code](https://code.visualstudio.com/) pour l'installation de base. Vous allez utiliser Python dans Visual Studio Code dans ce cours, donc vous voudrez peut-être vous familiariser avec la façon de [configurer Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) pour le développement Python.
> Familiarisez-vous avec Python en parcourant cette collection de [modules d'apprentissage](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
>
> [![Configurer Python avec Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Configurer Python avec Visual Studio Code")
> [![Configurez Python avec Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Configurez Python avec Visual Studio Code")
>
> 🎥 Cliquez sur l'image ci-dessus pour une vidéo : utiliser Python dans VS Code.
3. **Installez Scikit-learn**, en suivant [ces instructions](https://scikit-learn.org/stable/install.html). Étant donné que vous devez utiliser Python 3, il est recommandé d'utiliser un environnement virtuel. Notez que si vous installez cette bibliothèque sur un Mac M1, il existe des instructions spéciales sur la page liée ci-dessus.
3. **Installez Scikit-learn**, en suivant [ces instructions](https://scikit-learn.org/stable/install.html). Comme vous devez vous assurer d'utiliser Python 3, il est recommandé d'utiliser un environnement virtuel. Notez, si vous installez cette bibliothèque sur un Mac M1, des instructions spéciales sont disponibles sur la page liée ci-dessus.
4. **Installez Jupyter Notebook**. Vous devrez [installer le package Jupyter](https://pypi.org/project/jupyter/).
1. **Installez Jupyter Notebook**. Vous devrez [installer le package Jupyter](https://pypi.org/project/jupyter/).
## Votre environnement d'écriture ML
Vous allez utiliser des **notebooks** pour développer votre code Python et créer des modèles d'apprentissage automatique. Ce type de fichier est un outil courant pour les data scientists, et ils peuvent être identifiés par leur suffixe ou extension `.ipynb`.
Vous allez utiliser des **notebooks** pour développer votre code Python et créer des modèles d'apprentissage automatique. Ce type de fichier est un outil courant pour les data scientists, et il se reconnaît par son suffixe ou extension `.ipynb`.
Les notebooks sont un environnement interactif qui permet au développeur de coder, d'ajouter des notes et de rédiger de la documentation autour du code, ce qui est très utile pour les projets expérimentaux ou orientés recherche.
Les notebooks sont un environnement interactif qui permet au développeur de coder tout en ajoutant des notes et en rédigeant de la documentation autour du code, ce qui est très utile pour les projets expérimentaux ou de recherche.
[![ML pour débutants - Configurez Jupyter Notebooks pour commencer à créer des modèles de régression](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML pour débutants - Configurez Jupyter Notebooks pour commencer à créer des modèles de régression")
[![ML pour débutants - Configurez Jupyter Notebooks pour commencer à construire des modèles de régression](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML pour débutants - Configurez Jupyter Notebooks pour commencer à construire des modèles de régression")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant cet exercice.
### Exercice - travailler avec un notebook
### Exercice - travaillez avec un notebook
Dans ce dossier, vous trouverez le fichier _notebook.ipynb_.
1. Ouvrez _notebook.ipynb_ dans Visual Studio Code.
Un serveur Jupyter démarrera avec Python 3+. Vous trouverez des zones du notebook qui peuvent être `exécutées`, des morceaux de code. Vous pouvez exécuter un bloc de code en sélectionnant l'icône qui ressemble à un bouton de lecture.
Un serveur Jupyter va démarrer avec Python 3+ lancé. Vous trouverez des zones du notebook qui peuvent être `exécutées`, des morceaux de code. Vous pouvez exécuter un bloc de code en sélectionnant l'icône qui ressemble à un bouton de lecture.
2. Sélectionnez l'icône `md` et ajoutez un peu de markdown, ainsi que le texte suivant **# Bienvenue dans votre notebook**.
1. Sélectionnez l'icône `md` et ajoutez un peu de markdown, ainsi que le texte suivant : **# Bienvenue dans votre notebook**.
Ensuite, ajoutez du code Python.
Ensuite, ajoutez un peu de code Python.
3. Tapez **print('hello notebook')** dans le bloc de code.
4. Sélectionnez la flèche pour exécuter le code.
1. Tapez **print('hello notebook')** dans le bloc de code.
1. Sélectionnez la flèche pour exécuter le code.
Vous devriez voir l'instruction imprimée :
Vous devriez voir la ligne imprimée :
```output
hello notebook
```
![VS Code avec un notebook ouvert](../../../../2-Regression/1-Tools/images/notebook.jpg)
![VS Code avec un notebook ouvert](../../../../translated_images/fr/notebook.4a3ee31f396b8832.webp)
Vous pouvez intercaler votre code avec des commentaires pour auto-documenter le notebook.
Vous pouvez alterner votre code avec des commentaires pour auto-documenter le notebook.
✅ Réfléchissez un instant à la différence entre l'environnement de travail d'un développeur web et celui d'un data scientist.
✅ Réfléchissez un instant à quel point l'environnement de travail d'un développeur web est différent de celui d'un data scientist.
## Prise en main avec Scikit-learn
## Prise en main de Scikit-learn
Maintenant que Python est configuré dans votre environnement local et que vous êtes à l'aise avec les notebooks Jupyter, familiarisons-nous avec Scikit-learn (prononcez-le `sci` comme dans `science`). Scikit-learn fournit une [API étendue](https://scikit-learn.org/stable/modules/classes.html#api-ref) pour vous aider à effectuer des tâches d'apprentissage automatique.
Maintenant que Python est configuré dans votre environnement local, et que vous êtes à l'aise avec Jupyter Notebooks, familiarisons-nous de la même façon avec Scikit-learn (prononcez `sci` comme dans `science`). Scikit-learn fournit une [API étendue](https://scikit-learn.org/stable/modules/classes.html#api-ref) pour vous aider à réaliser des tâches de ML.
Selon leur [site web](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn est une bibliothèque d'apprentissage automatique open source qui prend en charge l'apprentissage supervisé et non supervisé. Elle fournit également divers outils pour l'ajustement de modèles, le prétraitement des données, la sélection et l'évaluation de modèles, ainsi que de nombreuses autres utilités."
Selon leur [site web](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn est une bibliothèque open source d'apprentissage automatique qui prend en charge l'apprentissage supervisé et non supervisé. Elle fournit également divers outils pour l'ajustement de modèles, le prétraitement des données, la sélection et l'évaluation de modèles, ainsi que de nombreuses autres utilités."
Dans ce cours, vous utiliserez Scikit-learn et d'autres outils pour construire des modèles d'apprentissage automatique afin d'effectuer ce que nous appelons des tâches d'apprentissage automatique "traditionnel". Nous avons délibérément évité les réseaux neuronaux et l'apprentissage profond, car ils sont mieux couverts dans notre prochain programme "IA pour débutants".
Dans ce cours, vous utiliserez Scikit-learn et d'autres outils pour construire des modèles d'apprentissage automatique pour effectuer ce que nous appelons des tâches de "machine learning traditionnel". Nous avons délibérément évité les réseaux neuronaux et l'apprentissage profond, car ils sont mieux abordés dans notre futur programme "IA pour débutants".
Scikit-learn simplifie la construction de modèles et leur évaluation pour une utilisation. Il est principalement axé sur l'utilisation de données numériques et contient plusieurs ensembles de données prêts à l'emploi pour servir d'outils d'apprentissage. Il inclut également des modèles préconstruits que les étudiants peuvent essayer. Explorons le processus de chargement de données préemballées et utilisons un estimateur intégré pour créer un premier modèle ML avec Scikit-learn à l'aide de données de base.
Scikit-learn facilite la construction et l'évaluation des modèles pour une utilisation pratique. Il se concentre principalement sur l'utilisation de données numériques et contient plusieurs ensembles de données préconçus pour servir d'outils d'apprentissage. Il inclut aussi des modèles préconstruits pour que les étudiants puissent les essayer. Explorons d'abord le processus de chargement des données préemballées et l'utilisation d'un estimateur intégré pour un premier modèle ML avec Scikit-learn et des données basiques.
## Exercice - votre premier notebook Scikit-learn
> Ce tutoriel a été inspiré par l'[exemple de régression linéaire](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) sur le site web de Scikit-learn.
> Ce tutoriel s'inspire de l'[exemple de régression linéaire](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) sur le site de Scikit-learn.
[![ML pour débutants - Votre premier projet de régression linéaire en Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML pour débutants - Votre premier projet de régression linéaire en Python")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant cet exercice.
Dans le fichier _notebook.ipynb_ associé à cette leçon, supprimez toutes les cellules en appuyant sur l'icône de la "poubelle".
Dans le fichier _notebook.ipynb_ associé à cette leçon, videz toutes les cellules en appuyant sur l'icône de la 'poubelle'.
Dans cette section, vous travaillerez avec un petit ensemble de données sur le diabète intégré à Scikit-learn à des fins d'apprentissage. Imaginez que vous vouliez tester un traitement pour les patients diabétiques. Les modèles d'apprentissage automatique pourraient vous aider à déterminer quels patients répondraient mieux au traitement, en fonction de combinaisons de variables. Même un modèle de régression très basique, lorsqu'il est visualisé, pourrait montrer des informations sur les variables qui vous aideraient à organiser vos essais cliniques théoriques.
Dans cette section, vous allez travailler avec un petit ensemble de données sur le diabète intégré à Scikit-learn à des fins d'apprentissage. Imaginez que vous vouliez tester un traitement pour des patients diabétiques. Les modèles d'apprentissage automatique pourraient vous aider à déterminer quels patients répondraient mieux au traitement, en fonction de combinaisons de variables. Même un modèle de régression très basique, une fois visualisé, pourrait montrer des informations sur les variables qui vous aideraient à organiser vos essais cliniques théoriques.
✅ Il existe de nombreux types de méthodes de régression, et le choix dépend de la réponse que vous recherchez. Si vous voulez prédire la taille probable d'une personne en fonction de son âge, vous utiliseriez une régression linéaire, car vous cherchez une **valeur numérique**. Si vous êtes intéressé par la découverte de si un type de cuisine doit être considéré comme végétalien ou non, vous cherchez une **attribution de catégorie**, donc vous utiliseriez une régression logistique. Vous en apprendrez davantage sur la régression logistique plus tard. Réfléchissez un peu à des questions que vous pourriez poser aux données, et à laquelle de ces méthodes serait la plus appropriée.
✅ Il existe de nombreux types de méthodes de régression, et celle que vous choisissez dépend de la réponse que vous cherchez. Si vous voulez prédire la taille probable d'une personne à un âge donné, vous utiliserez la régression linéaire, car vous cherchez une **valeur numérique**. Si vous vous intéressez à savoir si un type de cuisine doit être considéré comme végan ou non, vous recherchez une **attribution de catégorie**, donc vous utiliseriez la régression logistique. Vous en apprendrez davantage sur la régression logistique plus tard. Réfléchissez un peu à quelques questions que vous pouvez poser aux données, et à laquelle de ces méthodes serait la plus appropriée.
Commençons cette tâche.
@ -108,11 +109,11 @@ Commençons cette tâche.
Pour cette tâche, nous allons importer quelques bibliothèques :
- **matplotlib**. C'est un [outil de graphisme](https://matplotlib.org/) utile que nous utiliserons pour créer un graphique linéaire.
- **matplotlib**. C'est un [outil de graphique](https://matplotlib.org/) utile que nous utiliserons pour créer un graphique en ligne.
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) est une bibliothèque utile pour manipuler des données numériques en Python.
- **sklearn**. C'est la bibliothèque [Scikit-learn](https://scikit-learn.org/stable/user_guide.html).
Importez quelques bibliothèques pour vous aider dans vos tâches.
Importez quelques bibliothèques pour aider dans vos tâches.
1. Ajoutez les imports en tapant le code suivant :
@ -122,24 +123,24 @@ Importez quelques bibliothèques pour vous aider dans vos tâches.
from sklearn import datasets, linear_model, model_selection
```
Ci-dessus, vous importez `matplotlib`, `numpy` et vous importez `datasets`, `linear_model` et `model_selection` de `sklearn`. `model_selection` est utilisé pour diviser les données en ensembles d'entraînement et de test.
Ci-dessus, vous importez `matplotlib`, `numpy` et vous importez `datasets`, `linear_model` et `model_selection` de `sklearn`. `model_selection` est utilisé pour séparer les données en ensembles d'entraînement et de test.
### L'ensemble de données sur le diabète
### Le jeu de données sur le diabète
L'[ensemble de données sur le diabète](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) intégré comprend 442 échantillons de données sur le diabète, avec 10 variables de caractéristiques, dont certaines incluent :
Le [jeu de données diabète intégré](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) comprend 442 échantillons de données autour du diabète, avec 10 variables de caractéristiques, dont certaines incluent :
- age : âge en années
- âge : âge en années
- bmi : indice de masse corporelle
- bp : pression artérielle moyenne
- bp : pression sanguine moyenne
- s1 tc : cellules T (un type de globules blancs)
✅ Cet ensemble de données inclut le concept de "sexe" comme variable de caractéristique importante pour la recherche sur le diabète. De nombreux ensembles de données médicaux incluent ce type de classification binaire. Réfléchissez un peu à la manière dont des catégorisations comme celle-ci pourraient exclure certaines parties de la population des traitements.
✅ Ce jeu de données comprend la notion de 'sexe' comme variable caractéristique importante pour la recherche autour du diabète. Beaucoup de jeux de données médicales incluent ce type de classification binaire. Réfléchissez un peu à la façon dont ce type de catégorisation pourrait exclure certaines parties d'une population des traitements.
Maintenant, chargez les données X et y.
> 🎓 Rappelez-vous, il s'agit d'apprentissage supervisé, et nous avons besoin d'une cible nommée 'y'.
> 🎓 Rappelez-vous, il s'agit d'un apprentissage supervisé, et nous avons besoin d'une cible nommée 'y'.
Dans une nouvelle cellule de code, chargez l'ensemble de données sur le diabète en appelant `load_diabetes()`. L'entrée `return_X_y=True` indique que `X` sera une matrice de données, et `y` sera la cible de régression.
Dans une nouvelle cellule de code, chargez le jeu de données diabète en appelant `load_diabetes()`. L'entrée `return_X_y=True` signifie que `X` sera une matrice de données, et que `y` sera la cible de la régression.
1. Ajoutez quelques commandes print pour afficher la forme de la matrice de données et son premier élément :
@ -149,9 +150,9 @@ Dans une nouvelle cellule de code, chargez l'ensemble de données sur le diabèt
print(X[0])
```
Ce que vous obtenez en réponse est un tuple. Ce que vous faites est d'attribuer les deux premières valeurs du tuple à `X` et `y` respectivement. Apprenez-en davantage [sur les tuples](https://wikipedia.org/wiki/Tuple).
Ce que vous obtenez en réponse est un tuple. Ce que vous faites, c'est attribuer les deux premières valeurs du tuple à `X` et `y` respectivement. Apprenez-en plus [sur les tuples](https://wikipedia.org/wiki/Tuple).
Vous pouvez voir que ces données contiennent 442 éléments organisés en tableaux de 10 éléments :
Vous pouvez voir que ces données ont 442 items formés en tableaux de 10 éléments :
```text
(442, 10)
@ -159,39 +160,39 @@ Dans une nouvelle cellule de code, chargez l'ensemble de données sur le diabèt
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
✅ Réfléchissez un peu à la relation entre les données et la cible de régression. La régression linéaire prédit les relations entre la caractéristique X et la variable cible y. Pouvez-vous trouver la [cible](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) pour l'ensemble de données sur le diabète dans la documentation ? Que démontre cet ensemble de données, étant donné la cible ?
✅ Réfléchissez un peu à la relation entre les données et la cible de régression. La régression linéaire prédit les relations entre la caractéristique X et la variable cible y. Pouvez-vous trouver la [cible](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) pour le jeu de données diabète dans la documentation ? Que démontre ce jeu de données, étant donné cette cible ?
2. Ensuite, sélectionnez une partie de cet ensemble de données à tracer en sélectionnant la 3ème colonne de l'ensemble de données. Vous pouvez le faire en utilisant l'opérateur `:` pour sélectionner toutes les lignes, puis en sélectionnant la 3ème colonne en utilisant l'index (2). Vous pouvez également remodeler les données pour qu'elles soient un tableau 2D - comme requis pour le tracé - en utilisant `reshape(n_rows, n_columns)`. Si l'un des paramètres est -1, la dimension correspondante est calculée automatiquement.
2. Ensuite, sélectionnez une portion de ce jeu de données à tracer en sélectionnant la 3e colonne du jeu de données. Vous pouvez le faire en utilisant l'opérateur `:` pour sélectionner toutes les lignes, puis en sélectionnant la 3e colonne en utilisant l'index (2). Vous pouvez aussi remodeler les données pour qu'elles soient un tableau 2D - comme requis pour le tracé - en utilisant `reshape(n_rows, n_columns)`. Si un des paramètres est -1, la dimension correspondante est calculée automatiquement.
```python
X = X[:, 2]
X = X.reshape((-1,1))
```
✅ À tout moment, imprimez les données pour vérifier leur forme.
✅ À tout moment, affichez les données pour vérifier leur forme.
3. Maintenant que vous avez des données prêtes à être tracées, vous pouvez voir si une machine peut aider à déterminer une séparation logique entre les nombres dans cet ensemble de données. Pour ce faire, vous devez diviser à la fois les données (X) et la cible (y) en ensembles de test et d'entraînement. Scikit-learn propose une méthode simple pour cela ; vous pouvez diviser vos données de test à un point donné.
3. Maintenant que vous avez des données prêtes à être tracées, vous pouvez voir si une machine peut aider à déterminer une séparation logique parmi les nombres de ce dataset. Pour ce faire, vous devez diviser à la fois les données (X) et la cible (y) en ensembles de test et d'entraînement. Scikit-learn offre un moyen simple de faire cela ; vous pouvez diviser vos données de test à un point donné.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. Vous êtes maintenant prêt à entraîner votre modèle ! Chargez le modèle de régression linéaire et entraînez-le avec vos ensembles d'entraînement X et y en utilisant `model.fit()` :
4. Maintenant vous êtes prêt à entraîner votre modèle ! Chargez le modèle de régression linéaire et entraînez-le avec vos ensembles d'entraînement X et y en utilisant `model.fit()` :
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
`model.fit()` est une fonction que vous verrez dans de nombreuses bibliothèques ML comme TensorFlow.
`model.fit()` est une fonction que vous verrez dans de nombreuses bibliothèques ML telles que TensorFlow
5. Ensuite, créez une prédiction en utilisant les données de test, avec la fonction `predict()`. Cela sera utilisé pour tracer la ligne entre les groupes de données.
5. Puis, créez une prédiction en utilisant les données de test, avec la fonction `predict()`. Cela sera utilisé pour tracer la ligne entre les groupes de données
```python
y_pred = model.predict(X_test)
```
6. Il est maintenant temps de montrer les données dans un graphique. Matplotlib est un outil très utile pour cette tâche. Créez un nuage de points de toutes les données de test X et y, et utilisez la prédiction pour tracer une ligne à l'endroit le plus approprié, entre les regroupements de données du modèle.
6. Il est maintenant temps d'afficher les données dans un graphique. Matplotlib est un outil très utile pour cette tâche. Créez un nuage de points de toutes les données de test X et y, et utilisez la prédiction pour tracer une ligne à l'endroit le plus approprié, entre les groupes de données du modèle.
```python
plt.scatter(X_test, y_test, color='black')
@ -202,22 +203,24 @@ Dans une nouvelle cellule de code, chargez l'ensemble de données sur le diabèt
plt.show()
```
![un nuage de points montrant des données sur le diabète](../../../../2-Regression/1-Tools/images/scatterplot.png)
✅ Réfléchissez un peu à ce qui se passe ici. Une ligne droite traverse de nombreux petits points de données, mais que fait-elle exactement ? Pouvez-vous voir comment cette ligne pourrait vous permettre de prédire où un nouveau point de données, encore inconnu, devrait se situer par rapport à l'axe y du graphique ? Essayez de mettre en mots l'utilité pratique de ce modèle.
![Un nuage de points montrant des données autour du diabète](../../../../translated_images/fr/scatterplot.ad8b356bcbb33be6.webp)
✅ Réfléchissez un peu à ce qui se passe ici. Une ligne droite traverse de nombreux petits points de données, mais que fait-elle exactement ? Pouvez-vous voir comment vous devriez pouvoir utiliser cette ligne pour prédire où un nouveau point de données non vu devrait se situer par rapport à l'axe y du graphique ? Essayez de mettre en mots l'utilisation pratique de ce modèle.
Félicitations, vous avez construit votre premier modèle de régression linéaire, créé une prédiction avec celui-ci, et l'avez affichée dans un graphique !
Félicitations, vous avez construit votre premier modèle de régression linéaire, créé une prédiction avec celui-ci, et l'avez affiché dans un graphique !
---
## 🚀Défi
Tracez une autre variable de ce jeu de données. Indice : modifiez cette ligne : `X = X[:,2]`. Étant donné la cible de ce jeu de données, que pouvez-vous découvrir sur la progression du diabète en tant que maladie ?
## [Quiz post-cours](https://ff-quizzes.netlify.app/en/ml/)
Tracez une variable différente de ce jeu de données. Astuce : modifiez cette ligne : `X = X[:,2]`. Étant donné la cible de ce jeu de données, que pouvez-vous découvrir sur la progression du diabète en tant que maladie ?
## [Quiz post-conférence](https://ff-quizzes.netlify.app/en/ml/)
## Révision & Étude personnelle
## Revue & Auto-apprentissage
Dans ce tutoriel, vous avez travaillé avec la régression linéaire simple, plutôt qu'avec la régression univariée ou multiple. Lisez un peu sur les différences entre ces méthodes, ou regardez [cette vidéo](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
Dans ce tutoriel, vous avez travaillé avec une régression linéaire simple, plutôt quavec une régression univariée ou multiple. Lisez un peu sur les différences entre ces méthodes, ou jetez un œil à [cette vidéo](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
Lisez davantage sur le concept de régression et réfléchissez aux types de questions qui peuvent être résolues grâce à cette technique. Suivez [ce tutoriel](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) pour approfondir votre compréhension.
Lisez davantage à propos du concept de régression et réfléchissez aux types de questions auxquelles cette technique peut répondre. Suivez ce [tutoriel](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) pour approfondir votre compréhension.
## Devoir
@ -225,5 +228,7 @@ Lisez davantage sur le concept de régression et réfléchissez aux types de que
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,62 +1,62 @@
# Construire un modèle de régression avec Scikit-learn : préparer et visualiser les données
![Infographie sur la visualisation des données](../../../../2-Regression/2-Data/images/data-visualization.png)
![Infographie de visualisation des données](../../../../translated_images/fr/data-visualization.54e56dded7c1a804.webp)
Infographie par [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Quiz avant le cours](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz avant la leçon](https://ff-quizzes.netlify.app/en/ml/)
> ### [Cette leçon est disponible en R !](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
## Introduction
Maintenant que vous êtes équipé des outils nécessaires pour commencer à construire des modèles d'apprentissage automatique avec Scikit-learn, vous êtes prêt à poser des questions à vos données. Lorsque vous travaillez avec des données et appliquez des solutions d'apprentissage automatique, il est essentiel de savoir poser les bonnes questions pour exploiter pleinement le potentiel de votre ensemble de données.
Maintenant que vous avez configuré les outils dont vous avez besoin pour commencer à construire des modèles d'apprentissage automatique avec Scikit-learn, vous êtes prêt à commencer à poser des questions sur vos données. Lorsqu'on travaille avec des données et qu'on applique des solutions ML, il est très important de savoir poser la bonne question pour bien exploiter le potentiel de votre jeu de données.
Dans cette leçon, vous apprendrez :
- Comment préparer vos données pour la construction de modèles.
- Comment utiliser Matplotlib pour la visualisation des données.
- Comment préparer vos données pour la construction de modèle.
- Comment utiliser Matplotlib pour la visualisation de données.
- Comment utiliser Seaborn pour une visualisation des données plus expressive.
## Poser les bonnes questions à vos données
## Poser la bonne question à vos données
La question que vous souhaitez résoudre déterminera le type d'algorithmes d'apprentissage automatique que vous utiliserez. La qualité de la réponse que vous obtiendrez dépendra fortement de la nature de vos données.
La question à laquelle vous avez besoin de répondre déterminera le type d'algorithmes ML que vous utiliserez. Et la qualité de la réponse dépendra fortement de la nature de vos données.
Examinez les [données](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) fournies pour cette leçon. Vous pouvez ouvrir ce fichier .csv dans VS Code. Un rapide coup d'œil montre immédiatement qu'il y a des valeurs manquantes et un mélange de chaînes de caractères et de données numériques. Il y a aussi une colonne étrange appelée 'Package' où les données sont un mélange de 'sacks', 'bins' et d'autres valeurs. Les données, en fait, sont un peu désordonnées.
Jetez un œil aux [données](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) fournies pour cette leçon. Vous pouvez ouvrir ce fichier .csv dans VS Code. Un coup d'œil rapide montre immédiatement qu'il y a des blancs et un mélange de chaînes et de données numériques. Il y a aussi une colonne étrange appelée 'Package' où les données sont un mélange entre 'sacs', 'bacs' et d'autres valeurs. Les données, en fait, sont un peu désordonnées.
[![ML pour débutants - Comment analyser et nettoyer un ensemble de données](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML pour débutants - Comment analyser et nettoyer un ensemble de données")
[![ML pour débutants - Comment analyser et nettoyer un jeu de données](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML pour débutants - Comment analyser et nettoyer un jeu de données")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant comment préparer les données pour cette leçon.
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant la préparation des données pour cette leçon.
En réalité, il est rare de recevoir un ensemble de données entièrement prêt à être utilisé pour créer un modèle d'apprentissage automatique. Dans cette leçon, vous apprendrez à préparer un ensemble de données brut en utilisant des bibliothèques Python standard. Vous apprendrez également différentes techniques pour visualiser les données.
En fait, il est rare qu'on vous donne un jeu de données prêt à l'emploi pour créer un modèle ML directement. Dans cette leçon, vous apprendrez comment préparer un jeu de données brut en utilisant des bibliothèques Python standards. Vous apprendrez également différentes techniques pour visualiser les données.
## Étude de cas : "le marché des citrouilles"
## Étude de cas : 'le marché de la citrouille'
Dans ce dossier, vous trouverez un fichier .csv dans le dossier racine `data` appelé [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) qui contient 1757 lignes de données sur le marché des citrouilles, triées par ville. Ce sont des données brutes extraites des [Rapports standards des marchés terminaux des cultures spécialisées](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribués par le Département de l'Agriculture des États-Unis.
Dans ce dossier, vous trouverez un fichier .csv dans le dossier racine `data` appelé [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) qui comprend 1757 lignes de données sur le marché des citrouilles, triées par ville. Il sagit de données brutes extraites des [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribués par le Département de l'Agriculture des États-Unis.
### Préparer les données
### Préparation des données
Ces données sont dans le domaine public. Elles peuvent être téléchargées en plusieurs fichiers distincts, par ville, depuis le site web de l'USDA. Pour éviter trop de fichiers séparés, nous avons concaténé toutes les données des villes en une seule feuille de calcul, ce qui signifie que nous avons déjà _préparé_ un peu les données. Ensuite, examinons de plus près ces données.
Ces données sont dans le domaine public. Elles peuvent être téléchargées dans de nombreux fichiers séparés, par ville, sur le site web de l'USDA. Pour éviter trop de fichiers distincts, nous avons concaténé toutes les données des villes en une seule feuille de calcul, ainsi nous avons déjà un peu _préparé_ les données. Ensuite, examinons de plus près les données.
### Les données sur les citrouilles - premières conclusions
### Les données de la citrouille - premières conclusions
Que remarquez-vous à propos de ces données ? Vous avez déjà vu qu'il y a un mélange de chaînes de caractères, de nombres, de valeurs manquantes et de valeurs étranges qu'il faut interpréter.
Que remarquez-vous à propos de ces données ? Vous avez déjà vu qu'il y a un mélange de chaînes, de nombres, de blancs et de valeurs étranges dont vous devez comprendre la signification.
Quelle question pouvez-vous poser à ces données en utilisant une technique de régression ? Que diriez-vous de "Prédire le prix d'une citrouille en vente pendant un mois donné". En regardant à nouveau les données, il y a des modifications à apporter pour créer la structure de données nécessaire à cette tâche.
Quelle question pouvez-vous poser à ces données, en utilisant une technique de régression ? Que diriez-vous de "Prédire le prix d'une citrouille à la vente durant un mois donné". En regardant de nouveau les données, il y a quelques modifications à apporter pour créer la structure de données nécessaire à cette tâche.
## Exercice - analyser les données de la citrouille
## Exercice - analyser les données sur les citrouilles
Utilisons [Pandas](https://pandas.pydata.org/) (le nom signifie `Python Data Analysis`), un outil très utile pour structurer les données, afin d'analyser et de préparer ces données de citrouille.
Utilisons [Pandas](https://pandas.pydata.org/), (le nom signifie `Python Data Analysis`) un outil très utile pour façonner les données, afin d'analyser et de préparer ces données sur les citrouilles.
### D'abord, vérifier les dates manquantes
### Premièrement, vérifier les dates manquantes
Vous devrez d'abord prendre des mesures pour vérifier les dates manquantes :
Vous devez d'abord prendre des mesures pour vérifier les dates manquantes :
1. Convertir les dates au format mois (ce sont des dates américaines, donc le format est `MM/DD/YYYY`).
2. Extraire le mois dans une nouvelle colonne.
Ouvrez le fichier _notebook.ipynb_ dans Visual Studio Code et importez la feuille de calcul dans un nouveau dataframe Pandas.
1. Utilisez la fonction `head()` pour afficher les cinq premières lignes.
1. Utilisez la fonction `head()` pour voir les cinq premières lignes.
```python
import pandas as pd
@ -64,7 +64,7 @@ Ouvrez le fichier _notebook.ipynb_ dans Visual Studio Code et importez la feuill
pumpkins.head()
```
✅ Quelle fonction utiliseriez-vous pour afficher les cinq dernières lignes ?
✅ Quelle fonction utiliseriez-vous pour voir les cinq dernières lignes ?
1. Vérifiez s'il y a des données manquantes dans le dataframe actuel :
@ -72,20 +72,20 @@ Ouvrez le fichier _notebook.ipynb_ dans Visual Studio Code et importez la feuill
pumpkins.isnull().sum()
```
Il y a des données manquantes, mais peut-être que cela n'aura pas d'importance pour la tâche à accomplir.
Il y a des données manquantes, mais peut-être que cela ne posera pas de problème pour la tâche.
1. Pour rendre votre dataframe plus facile à manipuler, sélectionnez uniquement les colonnes nécessaires en utilisant la fonction `loc`, qui extrait du dataframe original un groupe de lignes (passé en premier paramètre) et de colonnes (passé en second paramètre). L'expression `:` dans le cas ci-dessous signifie "toutes les lignes".
1. Pour rendre votre dataframe plus facile à manipuler, sélectionnez uniquement les colonnes nécessaires, en utilisant la fonction `loc` qui extrait du dataframe original un groupe de lignes (passées en premier paramètre) et de colonnes (passées en second paramètre). L'expression `:` signifie "toutes les lignes" dans ce cas.
```python
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
pumpkins = pumpkins.loc[:, columns_to_select]
```
### Deuxièmement, déterminer le prix moyen des citrouilles
### Secondement, déterminer le prix moyen de la citrouille
Réfléchissez à la manière de déterminer le prix moyen d'une citrouille pour un mois donné. Quelles colonnes choisiriez-vous pour cette tâche ? Indice : vous aurez besoin de 3 colonnes.
Solution : prenez la moyenne des colonnes `Low Price` et `High Price` pour remplir la nouvelle colonne Price, et convertissez la colonne Date pour n'afficher que le mois. Heureusement, selon la vérification ci-dessus, il n'y a pas de données manquantes pour les dates ou les prix.
Solution : prenez la moyenne des colonnes `Low Price` et `High Price` pour remplir la nouvelle colonne Prix, et convertissez la colonne Date pour n'afficher que le mois. Heureusement, selon la vérification ci-dessus, il n'y a pas de données manquantes pour les dates ou les prix.
1. Pour calculer la moyenne, ajoutez le code suivant :
@ -96,7 +96,7 @@ Solution : prenez la moyenne des colonnes `Low Price` et `High Price` pour rempl
```
✅ N'hésitez pas à imprimer les données que vous souhaitez vérifier en utilisant `print(month)`.
✅ N'hésitez pas à afficher les données avec `print(month)` pour vérifier.
2. Maintenant, copiez vos données converties dans un nouveau dataframe Pandas :
@ -104,29 +104,29 @@ Solution : prenez la moyenne des colonnes `Low Price` et `High Price` pour rempl
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
En imprimant votre dataframe, vous verrez un ensemble de données propre et ordonné sur lequel vous pourrez construire votre nouveau modèle de régression.
Afficher votre dataframe vous montrera un jeu de données propre et rangé sur lequel vous pouvez construire votre nouveau modèle de régression.
### Mais attendez ! Il y a quelque chose d'étrange ici
Si vous regardez la colonne `Package`, les citrouilles sont vendues dans de nombreuses configurations différentes. Certaines sont vendues en mesures de '1 1/9 bushel', d'autres en '1/2 bushel', certaines par citrouille, certaines par livre, et d'autres dans de grandes boîtes de tailles variées.
Si vous regardez la colonne `Package`, les citrouilles sont vendues sous différentes configurations. Certaines sont vendues en mesures '1 1/9 boisseau', d'autres en '1/2 boisseau', certaines à l'unité, d'autres à la livre, et certaines dans de grosses boîtes de largeur variable.
> Les citrouilles semblent très difficiles à peser de manière cohérente
> Les citrouilles semblent très difficiles à peser de manière uniforme
En examinant les données originales, il est intéressant de noter que tout ce qui a `Unit of Sale` égal à 'EACH' ou 'PER BIN' a également le type `Package` par pouce, par bin, ou 'each'. Les citrouilles semblent être très difficiles à peser de manière cohérente, alors filtrons-les en sélectionnant uniquement les citrouilles avec le mot 'bushel' dans leur colonne `Package`.
En creusant les données initiales, il est intéressant de noter que tout ce qui a `Unit of Sale` égale à 'EACH' ou 'PER BIN' possède aussi un type `Package` par pouce, par bac, ou 'chacun'. Les citrouilles semblent très difficiles à peser de façon cohérente, donc filtrons-les en sélectionnant uniquement celles avec la chaîne 'bushel' dans leur colonne `Package`.
1. Ajoutez un filtre en haut du fichier, sous l'importation initiale du fichier .csv :
1. Ajoutez un filtre en haut du fichier, sous l'import initial du fichier .csv :
```python
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
Si vous imprimez les données maintenant, vous verrez que vous obtenez uniquement les 415 lignes de données contenant des citrouilles par bushel.
Si vous affichez les données maintenant, vous verrez que vous ne récupérez que les 415 lignes environ contenant des citrouilles vendues au boisseau.
### Mais attendez ! Il y a encore une chose à faire
Avez-vous remarqué que la quantité de bushel varie selon les lignes ? Vous devez normaliser les prix pour afficher les prix par bushel, alors faites quelques calculs pour les standardiser.
Avez-vous remarqué que la quantité par boisseau varie selon la ligne ? Vous devez normaliser les prix afin d'afficher le prix par boisseau, donc faites quelques calculs pour l'uniformiser.
1. Ajoutez ces lignes après le bloc créant le dataframe new_pumpkins :
1. Ajoutez ces lignes après le bloc de création du dataframe new_pumpkins :
```python
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
@ -134,37 +134,37 @@ Avez-vous remarqué que la quantité de bushel varie selon les lignes ? Vous dev
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ Selon [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), le poids d'un bushel dépend du type de produit, car c'est une mesure de volume. "Un bushel de tomates, par exemple, est censé peser 56 livres... Les feuilles et les légumes verts prennent plus de place avec moins de poids, donc un bushel d'épinards ne pèse que 20 livres." Tout cela est assez compliqué ! Ne nous embêtons pas à faire une conversion bushel-livre, et affichons plutôt les prix par bushel. Toute cette étude des bushels de citrouilles montre cependant à quel point il est important de comprendre la nature de vos données !
✅ Selon [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), le poids d'un boisseau dépend du type de produit, car c'est une mesure de volume. « Un boisseau de tomates, par exemple, est censé peser 56 livres... Les feuilles et les verdure occupent plus d'espace avec moins de poids, donc un boisseau d'épinards ne fait que 20 livres. » C'est assez compliqué ! Ne nous embêtons pas avec la conversion boisseau-livre, mais tarifons plutôt à l'unité de boisseau. Toute cette étude des boisseaux de citrouilles montre cependant combien il est important de comprendre la nature de vos données !
Maintenant, vous pouvez analyser les prix par unité en fonction de leur mesure en bushel. Si vous imprimez les données une fois de plus, vous verrez comment elles sont standardisées.
Vous pouvez maintenant analyser les prix par unité selon leur mesure en boisseaux. Si vous affichez les données une nouvelle fois, vous verrez comment elles sont standardisées.
✅ Avez-vous remarqué que les citrouilles vendues par demi-bushel sont très chères ? Pouvez-vous comprendre pourquoi ? Indice : les petites citrouilles sont beaucoup plus chères que les grandes, probablement parce qu'il y en a beaucoup plus par bushel, étant donné l'espace inutilisé occupé par une grande citrouille creuse pour tarte.
✅ Avez-vous remarqué que les citrouilles vendues par demi-boisseau sont très chères ? Pouvez-vous deviner pourquoi ? Indice : les petites citrouilles sont bien plus chères que les grosses, probablement parce qu'il y en a beaucoup plus par boisseau, compte tenu de l'espace inutilisé pris par une grosse citrouille creuse pour tarte.
## Stratégies de visualisation
Une partie du rôle du data scientist est de démontrer la qualité et la nature des données avec lesquelles il travaille. Pour ce faire, il crée souvent des visualisations intéressantes, comme des graphiques, des diagrammes et des courbes, montrant différents aspects des données. De cette manière, il peut montrer visuellement des relations et des lacunes qui seraient autrement difficiles à découvrir.
Une partie du rôle du data scientist est de démontrer la qualité et la nature des données avec lesquelles il travaille. Pour ce faire, ils créent souvent des visualisations intéressantes, ou des graphiques, diagrammes et tableaux, montrant différents aspects des données. De cette façon, ils peuvent montrer visuellement des relations et des lacunes difficiles à découvrir autrement.
[![ML pour débutants - Comment visualiser les données avec Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML pour débutants - Comment visualiser les données avec Matplotlib")
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant comment visualiser les données pour cette leçon.
> 🎥 Cliquez sur l'image ci-dessus pour une courte vidéo expliquant la visualisation des données de cette leçon.
Les visualisations peuvent également aider à déterminer la technique d'apprentissage automatique la plus appropriée pour les données. Un nuage de points qui semble suivre une ligne, par exemple, indique que les données sont un bon candidat pour un exercice de régression linéaire.
Les visualisations peuvent aussi aider à déterminer la technique d'apprentissage machine la plus appropriée aux données. Un graphique de dispersion qui semble suivre une ligne, par exemple, indique que les données sont de bons candidats pour un exercice de régression linéaire.
Une bibliothèque de visualisation de données qui fonctionne bien dans les notebooks Jupyter est [Matplotlib](https://matplotlib.org/) (que vous avez également vue dans la leçon précédente).
> Obtenez plus d'expérience avec la visualisation des données dans [ces tutoriels](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
## Exercice - expérimenter avec Matplotlib
## Exercice - expérimentez avec Matplotlib
Essayez de créer des graphiques simples pour afficher le nouveau dataframe que vous venez de créer. Que montrerait un graphique linéaire de base ?
Essayez de créer des graphiques de base pour afficher le nouveau dataframe que vous venez de créer. Que montrerait un graphique linéaire de base ?
1. Importez Matplotlib en haut du fichier, sous l'importation de Pandas :
1. Importez Matplotlib en haut du fichier, sous l'import de Pandas :
```python
import matplotlib.pyplot as plt
```
1. Relancez tout le notebook pour actualiser.
1. Relancez l'intégralité du notebook pour le rafraîchir.
1. En bas du notebook, ajoutez une cellule pour tracer les données sous forme de boîte :
```python
@ -174,44 +174,121 @@ Essayez de créer des graphiques simples pour afficher le nouveau dataframe que
plt.show()
```
![Un nuage de points montrant la relation entre le prix et le mois](../../../../2-Regression/2-Data/images/scatterplot.png)
![Un graphique de dispersion montrant la relation prix-mois](../../../../translated_images/fr/scatterplot.b6868f44cbd2051c.webp)
Ce graphique est-il utile ? Y a-t-il quelque chose qui vous surprend ?
Est-ce un graphique utile ? Y a-t-il quelque chose qui vous surprend ?
Ce n'est pas particulièrement utile car tout ce qu'il fait est d'afficher vos données sous forme de points répartis dans un mois donné.
Ce nest pas particulièrement utile car tout ce quil fait est dafficher vos données étalées en une série de points pour un mois donné.
### Rendez-le utile
Pour obtenir des graphiques affichant des données utiles, vous devez généralement regrouper les données d'une manière ou d'une autre. Essayons de créer un graphique où l'axe y montre les mois et les données démontrent la distribution des données.
Pour que les graphiques affichent des données utiles, vous devez généralement grouper les données d'une manière ou d'une autre. Essayons de créer un graphique où laxe y montre les mois et les données illustrent la distribution.
1. Ajoutez une cellule pour créer un graphique en barres groupées :
1. Ajoutez une cellule pour créer un histogramme groupé :
```python
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
plt.ylabel("Pumpkin Price")
```
![Un graphique en barres montrant la relation entre le prix et le mois](../../../../2-Regression/2-Data/images/barchart.png)
![Un histogramme montrant la relation prix-mois](../../../../translated_images/fr/barchart.a833ea9194346d76.webp)
Cest une visualisation de données bien plus utile ! Elle semble indiquer que le prix le plus élevé pour les citrouilles a lieu en septembre et en octobre. Est-ce conforme à vos attentes ? Pourquoi ou pourquoi pas ?
## Exercice - expérimentez avec Seaborn
Matplotlib est puissant, mais il peut nécessiter beaucoup de code pour produire un graphique soigné. [Seaborn](https://seaborn.pydata.org/) est une bibliothèque construite _au-dessus de_ Matplotlib qui est conçue pour la visualisation statistique des données. Elle fonctionne directement avec les dataframes Pandas, applique des styles attractifs par défaut, et vous permet de créer des graphiques informatifs avec beaucoup moins de code. Parce que Seaborn retourne des objets Matplotlib, vous pouvez toujours utiliser tout ce que vous savez déjà sur Matplotlib pour affiner le résultat.
> Si vous navez pas encore Seaborn installé, installez-le avec `pip install seaborn`.
1. Importez Seaborn en haut du notebook, sous les autres imports. Par convention, il est importé sous le nom `sns` :
```python
import seaborn as sns
```
### Graphiques de dispersion pour montrer les relations
Une grande partie de lexploration des données avant de construire un modèle consiste à rechercher des _relations_ entre les variables. Un [nuage de points](https://en.wikipedia.org/wiki/Scatter_plot) est lun des meilleurs outils pour cela : si les points semblent suivre une ligne, il se peut que les deux variables soient corrélées, ce qui est un bon signe quun modèle de régression linéaire pourrait fonctionner.
1. Reproduisez le graphique de dispersion prix-mois vu plus tôt, cette fois en utilisant [`relplot()`](https://seaborn.pydata.org/generated/seaborn.relplot.html) de Seaborn (graphique relationnel), qui travaille directement avec les colonnes de votre dataframe :
```python
sns.relplot(x="Price", y="Month", data=new_pumpkins)
```
![Un nuage de points Seaborn montrant la relation prix-mois](../../../../translated_images/fr/relplot.a03837d8f0329cec.webp)
Remarquez comment vous passez les _noms des colonnes_ et le dataframe, et Seaborn s'occupe des étiquettes des axes pour vous.
2. Vous pouvez passer à un graphique linéaire en passant `kind="line"`. Seaborn trace même une bande ombrée montrant l'intervalle de confiance autour de la ligne :
```python
sns.relplot(x="Price", y="Month", kind="line", data=new_pumpkins)
```
![Un graphique linéaire Seaborn montrant la relation prix-mois](../../../../translated_images/fr/lineplot.f9034ba47b1e30ee.webp)
Ces données sont assez bruyantes, donc un graphique linéaire n'est pas le choix le plus clair ici — mais cela montre à quel point il est facile de changer le type de graphique dans Seaborn.
### Histogrammes pour montrer les distributions
Plus tôt, vous avez regroupé les données manuellement pour créer un graphique à barres avec Matplotlib. Le [`catplot()`](https://seaborn.pydata.org/generated/seaborn.catplot.html) de Seaborn (graphique catégoriel) peut effectuer le regroupement et l'agrégation pour vous. Par défaut, `kind="bar"` affiche la moyenne de chaque catégorie avec une ligne noire indiquant l'intervalle de confiance.
1. Créez un graphique à barres du prix moyen par mois :
```python
sns.catplot(x="Month", y="Price", data=new_pumpkins, kind="bar")
```
![Un graphique à barres Seaborn montrant la distribution des prix par mois](../../../../translated_images/fr/catplot.e73fc35fdf96242b.webp)
Cela confirme ce que vous avez vu avec Matplotlib — les prix culminent autour de septembre et octobre — mais Seaborn visualise aussi à quel point le prix _varie_ au sein de chaque mois.
### Cartes thermiques pour montrer les corrélations
Les graphiques de dispersion comparent deux variables à la fois. Lorsque vous avez plusieurs colonnes numériques, une [carte thermique](https://en.wikipedia.org/wiki/Heat_map) vous permet de voir la force de la relation entre _toutes_ les paires de colonnes en même temps. C'est un moyen courant pour repérer quelles caractéristiques sont les plus corrélées avant de choisir ce que vous allez utiliser dans un modèle (et ce même type de graphique est plus tard utilisé pour afficher les matrices de confusion en classification).
1. Construisez une matrice de corrélation avec Pandas, puis tracez-la avec le [`heatmap()`](https://seaborn.pydata.org/generated/seaborn.heatmap.html) de Seaborn. L'option `annot=True` affiche les valeurs de corrélation sur chaque cellule :
```python
correlations = new_pumpkins[['Month', 'Low Price', 'High Price', 'Price']].corr()
sns.heatmap(correlations, annot=True, cmap="coolwarm")
```
![Une carte thermique Seaborn montrant les corrélations entre les colonnes numériques](../../../../translated_images/fr/heatmap.bd98dce43b404c57.webp)
Les valeurs proches de `1` (ou `-1`) signifient que les colonnes sont fortement corrélées _linéairement_. Remarquez comment `Low Price` et `High Price` sont presque parfaitement corrélées. `Month`, en revanche, ne montre qu'une faible corrélation linéaire avec le prix — même si le graphique à barres ci-dessus a révélé un pic saisonnier clair en septembre et octobre. C'est une leçon importante : le coefficient de corrélation ne mesure que les relations _linéaires droites_, il peut donc manquer des motifs saisonniers ou non linéaires. ✅ Pourquoi est-il utile de regarder à la fois une carte thermique *et* des graphiques comme le graphique à barres avant de décider quelles colonnes utiliser ?
### Matplotlib ou Seaborn ?
Les deux bibliothèques valent la peine dêtre connues :
- **Matplotlib** vous donne un contrôle précis sur chaque élément d'un graphique et est la base sur laquelle presque toutes les autres bibliothèques Python de visualisation sont construites.
- **Seaborn** offre des fonctions de plus haut niveau et des valeurs par défaut attrayantes pour les graphiques statistiques, travaille directement avec des dataframes et est souvent plus rapide pour lanalyse exploratoire des données.
Ce graphique est une visualisation de données plus utile ! Il semble indiquer que le prix le plus élevé des citrouilles se produit en septembre et octobre. Cela correspond-il à vos attentes ? Pourquoi ou pourquoi pas ?
Un flux de travail courant est d'utiliser Seaborn pour explorer rapidement vos données, puis de passer à Matplotlib lorsque vous avez besoin de personnaliser les détails.
---
## 🚀Défi
Explorez les différents types de visualisation que Matplotlib propose. Quels types sont les plus appropriés pour les problèmes de régression ?
Explorez les différents types de visualisation que Matplotlib et Seaborn offrent. Quels types sont les plus adaptés aux problèmes de régression ?
## [Quiz après le cours](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz post-conférence](https://ff-quizzes.netlify.app/en/ml/)
## Révision et étude personnelle
## Revue & Auto-apprentissage
Examinez les nombreuses façons de visualiser les données. Faites une liste des différentes bibliothèques disponibles et notez celles qui sont les meilleures pour certains types de tâches, par exemple les visualisations 2D contre les visualisations 3D. Que découvrez-vous ?
Jetez un œil aux nombreuses façons de visualiser les données. Faites une liste des différentes bibliothèques disponibles et notez quelles sont les mieux adaptées à certains types de tâches, par exemple visualisations 2D vs. visualisations 3D. Que découvrez-vous ?
## Devoir
[Explorer la visualisation](assignment.md)
[Exploration de la visualisation](assignment.md)
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -3,7 +3,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"## Régression linéaire pour les citrouilles - Leçon 2\n"
]
},
{
"cell_type": "code",
@ -220,6 +222,7 @@
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"pumpkins = pd.read_csv('../../data/US-pumpkins.csv')\n",
"\n",
"pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]\n",
@ -383,18 +386,78 @@
"plt.ylabel(\"Pumpkin Price\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Visualisation avec Seaborn\n",
"\n",
"[Seaborn](https://seaborn.pydata.org/) est construit au-dessus de Matplotlib et fonctionne directement avec des dataframes, ce qui permet de créer rapidement des graphiques statistiques attrayants avec très peu de code.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Graphiques de dispersion pour montrer les relations\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.relplot(x=\"Price\", y=\"Month\", data=new_pumpkins)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.relplot(x=\"Price\", y=\"Month\", kind=\"line\", data=new_pumpkins)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Diagrammes à barres pour montrer les distributions\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
"source": [
"sns.catplot(x=\"Month\", y=\"Price\", data=new_pumpkins, kind=\"bar\")"
]
},
{
"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"
"### Cartes thermiques pour montrer les corrélations\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"correlations = new_pumpkins[['Month', 'Low Price', 'High Price', 'Price']].corr()\n",
"sns.heatmap(correlations, annot=True, cmap=\"coolwarm\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Avertissement** :\nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -424,13 +487,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "95726f0b8283628d5356a4f8eb8b4b76",
"translation_date": "2025-09-04T01:36:32+00:00",
"source_file": "2-Regression/2-Data/solution/notebook.ipynb",
"language_code": "fr"
}
"orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2

@ -1,11 +1,11 @@
# Introduction à l'apprentissage par renforcement et au Q-Learning
![Résumé du renforcement dans l'apprentissage automatique sous forme de sketchnote](../../../../sketchnotes/ml-reinforcement.png)
![Résumé de l'apprentissage par renforcement en apprentissage automatique dans un sketchnote](../../../../translated_images/fr/ml-reinforcement.94024374d63348db.webp)
> Sketchnote par [Tomomi Imura](https://www.twitter.com/girlie_mac)
L'apprentissage par renforcement repose sur trois concepts importants : l'agent, des états, et un ensemble d'actions par état. En exécutant une action dans un état donné, l'agent reçoit une récompense. Imaginez à nouveau le jeu vidéo Super Mario. Vous êtes Mario, vous êtes dans un niveau de jeu, debout près du bord d'une falaise. Au-dessus de vous se trouve une pièce. Vous, étant Mario, dans un niveau de jeu, à une position spécifique... c'est votre état. Faire un pas vers la droite (une action) vous ferait tomber dans le vide, ce qui vous donnerait un score numérique faible. Cependant, appuyer sur le bouton de saut vous permettrait de marquer un point et de rester en vie. C'est un résultat positif qui devrait vous attribuer un score numérique positif.
L'apprentissage par renforcement implique trois concepts importants : l'agent, certains états et un ensemble d'actions par état. En exécutant une action dans un état spécifié, l'agent reçoit une récompense. Imaginez encore le jeu vidéo Super Mario. Vous êtes Mario, vous êtes dans un niveau de jeu, debout au bord d'une falaise. Au-dessus de vous se trouve une pièce. Vous, en tant que Mario, dans un niveau de jeu, à une position spécifique... c'est votre état. Faire un pas vers la droite (une action) vous ferait tomber du bord, ce qui vous donnerait un score numérique faible. Cependant, appuyer sur le bouton de saut vous permettrait de marquer un point et de rester en vie. C'est un résultat positif qui devrait vous attribuer un score numérique positif.
En utilisant l'apprentissage par renforcement et un simulateur (le jeu), vous pouvez apprendre à jouer au jeu pour maximiser la récompense, c'est-à-dire rester en vie et marquer autant de points que possible.
En utilisant l'apprentissage par renforcement et un simulateur (le jeu), vous pouvez apprendre à jouer afin de maximiser la récompense, qui est de rester en vie et de marquer autant de points que possible.
[![Introduction à l'apprentissage par renforcement](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo)
@ -13,35 +13,35 @@ En utilisant l'apprentissage par renforcement et un simulateur (le jeu), vous po
## [Quiz pré-lecture](https://ff-quizzes.netlify.app/en/ml/)
## Prérequis et configuration
## Prérequis et installation
Dans cette leçon, nous allons expérimenter avec du code en Python. Vous devriez pouvoir exécuter le code du Jupyter Notebook de cette leçon, soit sur votre ordinateur, soit dans le cloud.
Dans cette leçon, nous expérimenterons avec du code Python. Vous devriez pouvoir exécuter le code du Jupyter Notebook de cette leçon, soit sur votre ordinateur, soit dans le cloud.
Vous pouvez ouvrir [le notebook de la leçon](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) et suivre cette leçon pour construire.
> **Note :** Si vous ouvrez ce code depuis le cloud, vous devez également récupérer le fichier [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), qui est utilisé dans le code du notebook. Ajoutez-le au même répertoire que le notebook.
> **Note :** Si vous ouvrez ce code depuis le cloud, vous devez également récupérer le fichier [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), qui est utilisé dans le code du notebook. Ajoutez-le dans le même répertoire que le notebook.
## Introduction
Dans cette leçon, nous allons explorer le monde de **[Pierre et le Loup](https://fr.wikipedia.org/wiki/Pierre_et_le_Loup)**, inspiré d'un conte musical du compositeur russe [Sergei Prokofiev](https://fr.wikipedia.org/wiki/Sergei_Prokofiev). Nous utiliserons **l'apprentissage par renforcement** pour permettre à Pierre d'explorer son environnement, de collecter de savoureuses pommes et d'éviter de rencontrer le loup.
Dans cette leçon, nous allons explorer le monde de **[Pierre et le Loup](https://fr.wikipedia.org/wiki/Pierre_et_le_loup)**, inspiré d'un conte musical du compositeur russe [Sergei Prokofiev](https://fr.wikipedia.org/wiki/Sergei_Prokofiev). Nous utiliserons l'**apprentissage par renforcement** pour permettre à Pierre d'explorer son environnement, de collecter de délicieuses pommes et d'éviter le loup.
**L'apprentissage par renforcement** (RL) est une technique d'apprentissage qui nous permet d'apprendre un comportement optimal d'un **agent** dans un **environnement** en réalisant de nombreuses expériences. Un agent dans cet environnement doit avoir un **objectif**, défini par une **fonction de récompense**.
L'**apprentissage par renforcement** (RL) est une technique d'apprentissage qui nous permet d'apprendre un comportement optimal d'un **agent** dans un **environnement** en réalisant de nombreuses expériences. Un agent dans cet environnement doit avoir un **objectif**, défini par une **fonction de récompense**.
## L'environnement
Pour simplifier, considérons le monde de Pierre comme un plateau carré de taille `width` x `height`, comme ceci :
Pour simplifier, considérons que le monde de Pierre est une grille carrée de taille `largeur` x `hauteur`, comme ceci :
![Environnement de Pierre](../../../../8-Reinforcement/1-QLearning/images/environment.png)
![Environnement de Pierre](../../../../translated_images/fr/environment.40ba3cb66256c93f.webp)
Chaque case de ce plateau peut être :
Chaque case de cette grille peut être :
* **sol**, sur lequel Pierre et d'autres créatures peuvent marcher.
* **eau**, sur laquelle il est évidemment impossible de marcher.
* un **arbre** ou de l'**herbe**, un endroit où l'on peut se reposer.
* un **arbre** ou de **l'herbe**, un endroit où vous pouvez vous reposer.
* une **pomme**, qui représente quelque chose que Pierre serait heureux de trouver pour se nourrir.
* un **loup**, qui est dangereux et doit être évité.
Il existe un module Python séparé, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), qui contient le code pour travailler avec cet environnement. Comme ce code n'est pas essentiel pour comprendre nos concepts, nous allons importer le module et l'utiliser pour créer le plateau d'exemple (bloc de code 1) :
Il existe un module Python séparé, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), qui contient le code pour travailler avec cet environnement. Comme ce code n'est pas important pour comprendre nos concepts, nous importerons le module et l'utiliserons pour créer la grille d'exemple (bloc de code 1) :
```python
from rlboard import *
@ -56,26 +56,26 @@ Ce code devrait afficher une image de l'environnement similaire à celle ci-dess
## Actions et politique
Dans notre exemple, l'objectif de Pierre serait de trouver une pomme tout en évitant le loup et les autres obstacles. Pour ce faire, il peut essentiellement se déplacer jusqu'à ce qu'il trouve une pomme.
Dans notre exemple, l'objectif de Pierre serait de trouver une pomme tout en évitant le loup et d'autres obstacles. Pour cela, il peut essentiellement se déplacer jusqu'à trouver une pomme.
Ainsi, à n'importe quelle position, il peut choisir entre l'une des actions suivantes : haut, bas, gauche et droite.
Ainsi, à n'importe quelle position, il peut choisir entre les actions suivantes : haut, bas, gauche et droite.
Nous définirons ces actions comme un dictionnaire et les mapperons à des paires de changements de coordonnées correspondants. Par exemple, se déplacer vers la droite (`R`) correspondrait à une paire `(1,0)`. (bloc de code 2) :
Nous définirons ces actions sous forme d'un dictionnaire, et les mapperons à des paires correspondant aux changements de coordonnées. Par exemple, aller à droite (`R`) correspondrait à une paire `(1,0)`. (bloc de code 2) :
```python
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
action_idx = { a : i for i,a in enumerate(actions.keys()) }
```
Pour résumer, la stratégie et l'objectif de ce scénario sont les suivants :
En résumé, la stratégie et l'objectif de ce scénario sont les suivants :
- **La stratégie**, de notre agent (Pierre) est définie par ce qu'on appelle une **politique**. Une politique est une fonction qui retourne l'action à effectuer dans un état donné. Dans notre cas, l'état du problème est représenté par le plateau, y compris la position actuelle du joueur.
- **La stratégie**, de notre agent (Pierre) est définie par une **politique**. Une politique est une fonction qui retourne l'action à tout état donné. Dans notre cas, l'état du problème est représenté par la grille, incluant la position actuelle du joueur.
- **L'objectif**, de l'apprentissage par renforcement est d'apprendre finalement une bonne politique qui nous permettra de résoudre le problème efficacement. Cependant, comme point de départ, considérons la politique la plus simple appelée **marche aléatoire**.
- **L'objectif**, de l'apprentissage par renforcement est d'apprendre finalement une bonne politique qui nous permettra de résoudre le problème efficacement. Cependant, comme référence, considérons la politique la plus simple appelée **marche aléatoire**.
## Marche aléatoire
Résolvons d'abord notre problème en implémentant une stratégie de marche aléatoire. Avec la marche aléatoire, nous choisirons aléatoirement la prochaine action parmi les actions autorisées, jusqu'à ce que nous atteignions la pomme (bloc de code 3).
Résolvons d'abord notre problème en implémentant une stratégie de marche aléatoire. Avec la marche aléatoire, nous choisirons de manière aléatoire la prochaine action parmi celles autorisées, jusqu'à atteindre la pomme (bloc de code 3).
1. Implémentez la marche aléatoire avec le code ci-dessous :
@ -84,22 +84,22 @@ Résolvons d'abord notre problème en implémentant une stratégie de marche al
return random.choice(list(actions))
def walk(m,policy,start_position=None):
n = 0 # number of steps
# set initial position
n = 0 # nombre de pas
# définir la position initiale
if start_position:
m.human = start_position
else:
m.random_start()
while True:
if m.at() == Board.Cell.apple:
return n # success!
return n # succès !
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
return -1 # eaten by wolf or drowned
return -1 # mangé par un loup ou noyé
while True:
a = actions[policy(m)]
new_pos = m.move_pos(m.human,a)
if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
m.move(a) # do the actual move
m.move(a) # faire le déplacement réel
break
n+=1
@ -108,7 +108,7 @@ Résolvons d'abord notre problème en implémentant une stratégie de marche al
L'appel à `walk` devrait retourner la longueur du chemin correspondant, qui peut varier d'une exécution à l'autre.
1. Exécutez l'expérience de marche plusieurs fois (disons, 100), et imprimez les statistiques résultantes (bloc de code 4) :
1. Exécutez l'expérience de marche un certain nombre de fois (disons 100), et affichez les statistiques résultantes (bloc de code 4) :
```python
def print_statistics(policy):
@ -125,17 +125,17 @@ Résolvons d'abord notre problème en implémentant une stratégie de marche al
print_statistics(random_policy)
```
Notez que la longueur moyenne d'un chemin est d'environ 30-40 étapes, ce qui est assez élevé, étant donné que la distance moyenne jusqu'à la pomme la plus proche est d'environ 5-6 étapes.
Notez que la longueur moyenne d'un chemin est d'environ 30-40 pas, ce qui est assez long, étant donné que la distance moyenne à la pomme la plus proche est d'environ 5-6 pas.
Vous pouvez également voir à quoi ressemble le mouvement de Pierre pendant la marche aléatoire :
Vous pouvez aussi voir à quoi ressemble le déplacement de Pierre durant la marche aléatoire :
![Marche aléatoire de Pierre](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)
## Fonction de récompense
Pour rendre notre politique plus intelligente, nous devons comprendre quels mouvements sont "meilleurs" que d'autres. Pour ce faire, nous devons définir notre objectif.
Pour rendre notre politique plus intelligente, nous devons comprendre quels mouvements sont « meilleurs » que dautres. Pour cela, nous devons définir notre objectif.
L'objectif peut être défini en termes de **fonction de récompense**, qui retournera une valeur de score pour chaque état. Plus le nombre est élevé, meilleure est la récompense. (bloc de code 5)
L'objectif peut être défini en termes de **fonction de récompense**, qui retournera une valeur de score pour chaque état. Plus ce nombre est élevé, meilleure est la fonction de récompense. (bloc de code 5)
```python
move_reward = -0.1
@ -154,39 +154,115 @@ def reward(m,pos=None):
return move_reward
```
Une chose intéressante à propos des fonctions de récompense est que dans la plupart des cas, *nous ne recevons une récompense substantielle qu'à la fin du jeu*. Cela signifie que notre algorithme doit d'une certaine manière se souvenir des "bons" pas qui mènent à une récompense positive à la fin, et augmenter leur importance. De même, tous les mouvements qui mènent à de mauvais résultats doivent être découragés.
Une chose intéressante au sujet des fonctions de récompense est que dans la plupart des cas, *une récompense substantielle ne nous est donnée qu'à la fin du jeu*. Cela signifie que notre algorithme doit d'une certaine façon mémoriser les « bonnes » étapes qui mènent à une récompense positive à la fin, et augmenter leur importance. De même, tous les mouvements qui mènent à de mauvais résultats doivent être découragés.
## Q-Learning
L'algorithme que nous allons discuter ici s'appelle **Q-Learning**. Dans cet algorithme, la politique est définie par une fonction (ou une structure de données) appelée **Q-Table**. Elle enregistre la "qualité" de chaque action dans un état donné.
Un algorithme que nous allons discuter ici s'appelle **Q-Learning**. Dans cet algorithme, la politique est définie par une fonction (ou une structure de données) appelée **Q-Table**. Elle enregistre la "bonté" de chacune des actions dans un état donné.
On l'appelle une Q-Table car il est souvent pratique de la représenter sous forme de tableau ou de tableau multidimensionnel. Étant donné que notre plateau a des dimensions `width` x `height`, nous pouvons représenter la Q-Table en utilisant un tableau numpy de forme `width` x `height` x `len(actions)` : (bloc de code 6)
Elle s'appelle Q-Table car il est souvent pratique de la représenter sous la forme d'un tableau, ou d'un tableau multidimensionnel. Puisque notre grille a des dimensions `largeur` x `hauteur`, nous pouvons représenter la Q-Table en utilisant un tableau numpy de forme `largeur` x `hauteur` x `len(actions)` : (bloc de code 6)
```python
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
```
Notez que nous initialisons toutes les valeurs de la Q-Table avec une valeur égale, dans notre cas - 0.25. Cela correspond à la politique de "marche aléatoire", car tous les mouvements dans chaque état sont également bons. Nous pouvons passer la Q-Table à la fonction `plot` afin de visualiser le tableau sur le plateau : `m.plot(Q)`.
Notez que nous initialisons toutes les valeurs de la Q-Table avec une valeur égale, dans notre cas - 0,25. Cela correspond à la politique de la « marche aléatoire », car tous les mouvements à chaque état sont également bons. Nous pouvons passer la Q-Table à la fonction `plot` afin de visualiser le tableau sur la grille : `m.plot(Q)`.
![Environnement de Pierre](../../../../8-Reinforcement/1-QLearning/images/env_init.png)
![Environnement de Pierre](../../../../translated_images/fr/env_init.04e8f26d2d60089e.webp)
Au centre de chaque case, il y a une "flèche" qui indique la direction préférée du mouvement. Étant donné que toutes les directions sont égales, un point est affiché.
Au centre de chaque case, il y a une « flèche » qui indique la direction préférée du mouvement. Comme toutes les directions sont égales, un point est affiché.
Nous devons maintenant exécuter la simulation, explorer notre environnement, et apprendre une meilleure distribution des valeurs de la Q-Table, ce qui nous permettra de trouver le chemin vers la pomme beaucoup plus rapidement.
Maintenant, nous devons exécuter la simulation, explorer notre environnement, et apprendre une meilleure distribution des valeurs de la Q-Table, ce qui nous permettra de trouver le chemin vers la pomme beaucoup plus rapidement.
## Essence du Q-Learning : Équation de Bellman
## L'essence du Q-Learning : l'équation de Bellman
Une fois que nous commençons à nous déplacer, chaque action aura une récompense correspondante, c'est-à-dire que nous pourrions théoriquement sélectionner la prochaine action en fonction de la récompense immédiate la plus élevée. Cependant, dans la plupart des états, le mouvement n'atteindra pas notre objectif de trouver la pomme, et nous ne pouvons donc pas immédiatement décider quelle direction est meilleure.
Une fois que nous commençons à bouger, chaque action aura une récompense correspondante, cest-à-dire que nous pouvons théoriquement sélectionner la prochaine action selon la meilleure récompense immédiate. Cependant, dans la plupart des états, le mouvement n'atteindra pas notre objectif d'atteindre la pomme, et nous ne pouvons donc pas immédiatement décider quelle direction est meilleure.
> Rappelez-vous que ce n'est pas le résultat immédiat qui compte, mais plutôt le résultat final, que nous obtiendrons à la fin de la simulation.
> Souvenez-vous que ce nest pas le résultat immédiat qui compte, mais plutôt le résultat final que nous obtiendrons à la fin de la simulation.
Pour tenir compte de cette récompense différée, nous devons utiliser les principes de la **[programmation dynamique](https://fr.wikipedia.org/wiki/Programmation_dynamique)**, qui nous permettent de réfléchir à notre problème de manière récursive.
Pour prendre en compte cette récompense différée, nous devons utiliser les principes de **[programmation dynamique](https://fr.wikipedia.org/wiki/Programmation_dynamique)**, qui nous permettent de penser à notre problème de manière récursive.
Supposons que nous sommes maintenant dans l'état *s*, et que nous voulons passer à l'état suivant *s'*. En faisant cela, nous recevrons la récompense immédiate *r(s,a)*, définie par la fonction de récompense, plus une récompense future. Si nous supposons que notre Q-Table reflète correctement l'"attractivité" de chaque action, alors dans l'état *s'*, nous choisirons une action *a* qui correspond à la valeur maximale de *Q(s',a')*. Ainsi, la meilleure récompense future possible que nous pourrions obtenir dans l'état *s* sera définie comme `max`
Supposons que nous soyons maintenant à l'état *s*, et que nous voulons aller à l'état suivant *s'*. En faisant cela, nous recevrons la récompense immédiate *r(s,a)*, définie par la fonction de récompense, plus une récompense future. Si nous supposons que notre Q-Table reflète correctement « l'attractivité » de chaque action, alors à l'état *s'* nous choisirons une action *a* correspondant à la valeur maximale de *Q(s',a')*. Ainsi, la meilleure récompense future possible à l'état *s* sera définie comme `max`<sub>a'</sub>*Q(s',a')* (le maximum ici est calculé sur toutes les actions possibles *a'* à l'état *s'*).
Cela donne la **formule de Bellman** pour calculer la valeur de la Q-Table à l'état *s*, pour une action donnée *a* :
<img src="../../../../translated_images/fr/bellman-equation.7c0c4c722e5a6b7c.webp"/>
Ici γ est le facteur de **décote** qui détermine à quel point vous devriez préférer la récompense actuelle par rapport à la récompense future et inversement.
## Algorithme d'apprentissage
Avec l'équation ci-dessus, nous pouvons maintenant écrire un pseudo-code pour notre algorithme d'apprentissage :
* Initialiser la Q-Table Q avec des nombres égaux pour tous les états et actions
* Fixer le taux d'apprentissage α ← 1
* Répéter la simulation plusieurs fois
1. Commencer à une position aléatoire
1. Répéter
1. Sélectionner une action *a* à l'état *s*
2. Effectuer l'action en allant à un nouvel état *s'*
3. Si la condition de fin de jeu est atteinte, ou si la récompense totale est trop faible - quitter la simulation
4. Calculer la récompense *r* à ce nouvel état
5. Mettre à jour la fonction Q selon l'équation de Bellman : *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
6. *s* ← *s'*
7. Mettre à jour la récompense totale et diminuer α.
## Exploiter vs. explorer
Dans l'algorithme ci-dessus, nous n'avons pas précisé comment choisir exactement une action à l'étape 2.1. Si nous choisissons l'action au hasard, nous **explorerons** aléatoirement l'environnement, et il est assez probable que nous mourions fréquemment ainsi que dexplorer des zones où nous nirions pas normalement. Une autre approche serait d**exploiter** les valeurs de la Q-Table que nous connaissons déjà, en choisissant ainsi la meilleure action (avec la plus haute valeur Q-Table) à létat *s*. Cela, cependant, nous empêchera dexplorer dautres états, et il est probable que nous ne trouvions pas la solution optimale.
Ainsi, la meilleure approche est de trouver un équilibre entre exploration et exploitation. Cela peut se faire en choisissant l'action à l'état *s* avec des probabilités proportionnelles aux valeurs dans la Q-Table. Au début, lorsque toutes les valeurs de la Q-Table sont identiques, cela correspondrait à une sélection aléatoire, mais à mesure que nous en apprenons davantage sur notre environnement, nous serions plus susceptibles de suivre la route optimale tout en permettant à l'agent de choisir parfois un chemin inexploré.
## Implémentation Python
Nous sommes maintenant prêts à implémenter l'algorithme d'apprentissage. Avant cela, nous avons également besoin d'une fonction qui convertira des nombres arbitraires dans la Q-Table en un vecteur de probabilités pour les actions correspondantes.
1. Créez une fonction `probs()` :
```python
def probs(v,eps=1e-4):
v = v-v.min()+eps
v = v/v.sum()
return v
```
Nous ajoutons quelques `eps` au vecteur original afin d'éviter une division par 0 dans le cas initial, lorsque tous les composants du vecteur sont identiques.
Exécutez l'algorithme d'apprentissage sur 5000 expériences, également appelées **époques** : (bloc de code 8)
```python
for epoch in range(5000):
# Choisir le point initial
m.random_start()
# Commencer à voyager
n=0
cum_reward = 0
while True:
x,y = m.human
v = probs(Q[x,y])
a = random.choices(list(actions),weights=v)[0]
dpos = actions[a]
m.move(dpos,check_correctness=False) # nous permettons au joueur de sortir du plateau, ce qui termine l'épisode
r = reward(m)
cum_reward += r
if r==end_reward or cum_reward < -1000:
lpath.append(n)
break
alpha = np.exp(-n / 10e5)
gamma = 0.5
ai = action_idx[a]
Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max())
n+=1
```
Après avoir exécuté cet algorithme, la Q-Table devrait être mise à jour avec des valeurs qui définissent l'attractivité des différentes actions à chaque étape. Nous pouvons essayer de visualiser la Q-Table en traçant un vecteur à chaque case qui pointera dans la direction souhaitée du mouvement. Par simplicité, nous dessinons un petit cercle au lieu d'une pointe de flèche.
<img src="../../../../translated_images/fr/learned.ed28bcd8484b5287.webp"/>
## Vérification de la politique
Étant donné que la Q-Table liste l'"attractivité" de chaque action dans chaque état, il est assez facile de l'utiliser pour définir une navigation efficace dans notre monde. Dans le cas le plus simple, nous pouvons sélectionner l'action correspondant à la valeur la plus élevée de la Q-Table : (bloc de code 9)
Puisque la Q-Table liste l« attractivité » de chaque action à chaque état, il est assez facile de lutiliser pour définir une navigation efficace dans notre monde. Dans le cas le plus simple, nous pouvons sélectionner laction correspondant à la valeur maximale de la Q-Table : (bloc de code 9)
```python
def qpolicy_strict(m):
@ -198,17 +274,18 @@ def qpolicy_strict(m):
walk(m,qpolicy_strict)
```
> Si vous essayez le code ci-dessus plusieurs fois, vous remarquerez peut-être qu'il "bloque" parfois, et vous devez appuyer sur le bouton STOP dans le notebook pour l'interrompre. Cela se produit parce qu'il peut y avoir des situations où deux états "pointent" l'un vers l'autre en termes de valeur Q optimale, auquel cas l'agent finit par se déplacer indéfiniment entre ces états.
> Si vous essayez le code ci-dessus plusieurs fois, vous remarquerez peut-être que parfois il « se bloque », et vous devez appuyer sur le bouton STOP dans le notebook pour linterrompre. Cela arrive parce quil peut y avoir des situations où deux états se « pointent » mutuellement en termes de valeur Q optimale, auquel cas lagent finit par se déplacer indéfiniment entre ces états.
## 🚀Défi
> **Tâche 1 :** Modifiez la fonction `walk` pour limiter la longueur maximale du chemin à un certain nombre de pas (par exemple, 100), et observez le code ci-dessus retourner cette valeur de temps en temps.
> **Tâche 1 :** Modifiez la fonction `walk` pour limiter la longueur maximale du chemin à un certain nombre de pas (disons, 100), et observez que le code ci-dessus retourne cette valeur de temps en temps.
> **Tâche 2 :** Modifiez la fonction `walk` afin qu'elle ne retourne pas aux endroits où elle est déjà passée auparavant. Cela empêchera `walk` de boucler, cependant, l'agent peut toujours se retrouver "piégé" dans un endroit dont il ne peut pas s'échapper.
> **Tâche 2 :** Modifiez la fonction `walk` pour quelle ne retourne pas aux endroits où elle est déjà passée auparavant. Cela empêchera `walk` de boucler, cependant, lagent peut toujours se retrouver « piégé » dans un endroit dont il ne peut pas séchapper.
## Navigation
Une meilleure politique de navigation serait celle que nous avons utilisée pendant l'entraînement, qui combine exploitation et exploration. Dans cette politique, nous sélectionnerons chaque action avec une certaine probabilité, proportionnelle aux valeurs dans la Q-Table. Cette stratégie peut encore entraîner l'agent à retourner à une position qu'il a déjà explorée, mais, comme vous pouvez le voir dans le code ci-dessous, elle aboutit à un chemin moyen très court vers l'emplacement souhaité (rappelez-vous que `print_statistics` exécute la simulation 100 fois) : (bloc de code 10)
Une meilleure politique de navigation serait celle que nous avons utilisée pendant lentraînement, qui combine exploitation et exploration. Dans cette politique, nous sélectionnerons chaque action avec une certaine probabilité, proportionnelle aux valeurs dans la Q-Table. Cette stratégie peut encore amener lagent à retourner à une position quil a déjà explorée, mais, comme vous pouvez le voir dans le code ci-dessous, cela aboutit à un chemin moyen très court vers la localisation souhaitée (rappelez-vous que `print_statistics` exécute la simulation 100 fois) : (bloc de code 10)
```python
def qpolicy(m):
@ -220,28 +297,32 @@ def qpolicy(m):
print_statistics(qpolicy)
```
Après avoir exécuté ce code, vous devriez obtenir une longueur moyenne de chemin beaucoup plus petite qu'auparavant, dans une plage de 3 à 6.
Après avoir exécuté ce code, vous devriez obtenir une longueur moyenne de chemin beaucoup plus petite quauparavant, dans la plage de 3 à 6.
## Étudier le processus dapprentissage
## Examiner le processus d'apprentissage
Comme nous lavons mentionné, le processus dapprentissage est un équilibre entre exploration et exploitation des connaissances acquises sur la structure de lespace problème. Nous avons vu que les résultats de lapprentissage (la capacité à aider un agent à trouver un chemin court vers lobjectif) se sont améliorés, mais il est aussi intéressant dobserver comment la longueur moyenne du chemin se comporte pendant le processus dapprentissage :
Comme nous l'avons mentionné, le processus d'apprentissage est un équilibre entre l'exploration et l'exploitation des connaissances acquises sur la structure de l'espace problème. Nous avons vu que les résultats de l'apprentissage (la capacité à aider un agent à trouver un chemin court vers l'objectif) se sont améliorés, mais il est également intéressant d'observer comment la longueur moyenne du chemin évolue pendant le processus d'apprentissage :
<img src="../../../../translated_images/fr/lpathlen1.0534784add58d4eb.webp"/>
Les apprentissages peuvent être résumés comme suit :
Les apprentissages peuvent être résumés ainsi :
- **La longueur moyenne du chemin augmente**. Ce que nous observons ici, c'est qu'au début, la longueur moyenne du chemin augmente. Cela est probablement dû au fait que lorsque nous ne savons rien de l'environnement, nous sommes susceptibles de nous retrouver piégés dans des états défavorables, comme l'eau ou le loup. À mesure que nous apprenons davantage et commençons à utiliser ces connaissances, nous pouvons explorer l'environnement plus longtemps, mais nous ne savons toujours pas très bien où se trouvent les pommes.
- **La longueur moyenne du chemin augmente**. Ce que lon voit ici est quau début, la longueur moyenne du chemin augmente. Cela est probablement dû au fait que lorsque nous ne connaissons rien de lenvironnement, il est probable que nous soyons piégés dans de mauvais états, comme dans leau ou près du loup. À mesure que nous apprenons et commençons à utiliser cette connaissance, nous pouvons explorer lenvironnement plus longtemps, mais nous ne savons toujours pas très bien où se trouvent les pommes.
- **La longueur du chemin diminue à mesure que nous apprenons davantage**. Une fois que nous avons suffisamment appris, il devient plus facile pour l'agent d'atteindre l'objectif, et la longueur du chemin commence à diminuer. Cependant, nous restons ouverts à l'exploration, ce qui nous amène souvent à nous éloigner du meilleur chemin et à explorer de nouvelles options, rendant le chemin plus long que l'optimal.
- **La longueur du chemin diminue à mesure que nous apprenons**. Une fois que nous avons suffisamment appris, il devient plus facile pour lagent datteindre lobjectif, et la longueur du chemin commence à diminuer. Cependant, nous restons ouverts à lexploration, donc nous nous écartons souvent du meilleur chemin et explorons de nouvelles options, ce qui rend le chemin plus long que loptimal.
- **La longueur augmente brusquement**. Ce que nous observons également sur ce graphique, c'est qu'à un moment donné, la longueur a augmenté brusquement. Cela indique la nature stochastique du processus, et qu'à un moment donné, nous pouvons "altérer" les coefficients de la Q-Table en les remplaçant par de nouvelles valeurs. Cela devrait idéalement être minimisé en diminuant le taux d'apprentissage (par exemple, vers la fin de l'entraînement, nous ajustons les valeurs de la Q-Table uniquement par une petite valeur).
- **La longueur augmente brusquement**. Ce que nous observons aussi sur ce graphique est quà un moment donné, la longueur a augmenté brusquement. Cela indique la nature stochastique du processus et que nous pouvons à un moment donné « altérer » les coefficients de la Q-Table en les écrasant avec de nouvelles valeurs. Idéalement, cela devrait être minimisé en diminuant le taux dapprentissage (par exemple, vers la fin de lentraînement, nous ajustons les valeurs de la Q-Table par une petite valeur).
Dans l'ensemble, il est important de se rappeler que le succès et la qualité du processus d'apprentissage dépendent significativement des paramètres, tels que le taux d'apprentissage, la décroissance du taux d'apprentissage et le facteur de réduction. Ceux-ci sont souvent appelés **hyperparamètres**, pour les distinguer des **paramètres**, que nous optimisons pendant l'entraînement (par exemple, les coefficients de la Q-Table). Le processus de recherche des meilleures valeurs d'hyperparamètres est appelé **optimisation des hyperparamètres**, et il mérite un sujet à part entière.
Globalement, il est important de se rappeler que le succès et la qualité du processus dapprentissage dépendent significativement des paramètres, tels que le taux dapprentissage, la décroissance du taux dapprentissage, et le facteur de remise. Ceux-ci sont souvent appelés **hyperparamètres**, pour les distinguer des **paramètres**, que nous optimisons pendant lentraînement (par exemple, les coefficients de la Q-Table). Le processus de recherche des meilleures valeurs dhyperparamètres sappelle **optimisation des hyperparamètres**, et mérite un sujet à part entière.
## [Quiz post-conférence](https://ff-quizzes.netlify.app/en/ml/)
## Devoir
## Devoir
[Un monde plus réaliste](assignment.md)
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -1,14 +1,34 @@
# Patinage CartPole
Le problème que nous avons résolu dans la leçon précédente peut sembler être un problème de jouet, pas vraiment applicable aux scénarios de la vie réelle. Ce n'est pas le cas, car de nombreux problèmes réels partagent également ce scénario - y compris jouer aux échecs ou au Go. Ils sont similaires, car nous avons aussi un plateau avec des règles données et un **état discret**.
## [Quiz avant le cours](https://ff-quizzes.netlify.app/en/ml/)
## Introduction
Dans cette leçon, nous appliquerons les mêmes principes du Q-Learning à un problème avec un **état continu**, cest-à-dire un état donné par un ou plusieurs nombres réels. Nous allons traiter le problème suivant :
> **Problème** : Si Peter veut échapper au loup, il doit pouvoir se déplacer plus vite. Nous verrons comment Peter peut apprendre à patiner, en particulier, à garder léquilibre, en utilisant le Q-Learning.
![La grande évasion !](../../../../translated_images/fr/escape.18862db9930337e3.webp)
> Peter et ses amis font preuve de créativité pour échapper au loup ! Image par [Jen Looper](https://twitter.com/jenlooper)
Nous utiliserons une version simplifiée de léquilibre connue sous le nom de problème **CartPole**. Dans le monde du cartpole, nous avons un curseur horizontal qui peut se déplacer à gauche ou à droite, et lobjectif est déquilibrer un poteau vertical au sommet du curseur.
<img alt="un cartpole" src="../../../../translated_images/fr/cartpole.b5609cc0494a14f7.webp" width="200"/>
## Prérequis
Dans cette leçon, nous utiliserons une bibliothèque appelée **OpenAI Gym** pour simuler différents **environnements**. Vous pouvez exécuter le code de cette leçon localement (par exemple, depuis Visual Studio Code), auquel cas la simulation s'ouvrira dans une nouvelle fenêtre. Si vous exécutez le code en ligne, vous devrez peut-être apporter quelques ajustements au code, comme décrit [ici](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
Dans cette leçon, nous utiliserons une bibliothèque appelée **OpenAI Gym** pour simuler différents **environnements**. Vous pouvez exécuter le code de cette leçon localement (par exemple depuis Visual Studio Code), dans ce cas la simulation souvrira dans une nouvelle fenêtre. En exécutant le code en ligne, vous devrez peut-être effectuer quelques ajustements du code, comme décrit [ici](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
## OpenAI Gym
Dans la leçon précédente, les règles du jeu et l'état étaient définis par la classe `Board` que nous avons créée nous-mêmes. Ici, nous utiliserons un **environnement de simulation** spécial, qui simulera la physique derrière le balancement du poteau. L'un des environnements de simulation les plus populaires pour entraîner des algorithmes d'apprentissage par renforcement est appelé [Gym](https://gym.openai.com/), maintenu par [OpenAI](https://openai.com/). Grâce à ce gym, nous pouvons créer différents **environnements**, allant de la simulation de CartPole aux jeux Atari.
Dans la leçon précédente, les règles du jeu et létat étaient donnés par la classe `Board` que nous avions définie nous-mêmes. Ici, nous utiliserons un **environnement de simulation** spécial, qui simulera la physique derrière le poteau en équilibre. Un des environnements de simulation les plus populaires pour lentraînement des algorithmes dapprentissage par renforcement sappelle un [Gym](https://gym.openai.com/), maintenu par [OpenAI](https://openai.com/). En utilisant ce gym, nous pouvons créer différents **environnements** allant dune simulation de cartpole à des jeux Atari.
> **Note** : Vous pouvez consulter les autres environnements disponibles dans OpenAI Gym [ici](https://gym.openai.com/envs/#classic_control).
> **Note** : Vous pouvez voir dautres environnements disponibles sur OpenAI Gym [ici](https://gym.openai.com/envs/#classic_control).
Tout d'abord, installons le gym et importons les bibliothèques nécessaires (bloc de code 1) :
Tout dabord, installons le gym et importons les bibliothèques requises (bloc de code 1) :
```python
import sys
@ -20,13 +40,13 @@ import numpy as np
import random
```
## Exercice - initialiser un environnement CartPole
## Exercice - initialiser un environnement cartpole
Pour travailler sur le problème d'équilibre du CartPole, nous devons initialiser l'environnement correspondant. Chaque environnement est associé à :
Pour travailler avec un problème déquilibre cartpole, nous devons initialiser lenvironnement correspondant. Chaque environnement est associé à un :
- **Espace d'observation** qui définit la structure des informations que nous recevons de l'environnement. Pour le problème CartPole, nous recevons la position du poteau, la vitesse et quelques autres valeurs.
- **espace dobservation** qui définit la structure des informations que nous recevons de lenvironnement. Pour le problème cartpole, nous recevons la position du poteau, la vitesse et dautres valeurs.
- **Espace d'action** qui définit les actions possibles. Dans notre cas, l'espace d'action est discret et se compose de deux actions : **gauche** et **droite**. (bloc de code 2)
- **espace daction** qui définit les actions possibles. Dans notre cas, lespace dactions est discret et se compose de deux actions - **gauche** et **droite**. (bloc de code 2)
1. Pour initialiser, tapez le code suivant :
@ -37,11 +57,11 @@ Pour travailler sur le problème d'équilibre du CartPole, nous devons initialis
print(env.action_space.sample())
```
Pour voir comment fonctionne l'environnement, exécutons une courte simulation de 100 étapes. À chaque étape, nous fournissons une action à effectuer - dans cette simulation, nous sélectionnons simplement une action aléatoire dans `action_space`.
Pour voir comment lenvironnement fonctionne, exécutons une courte simulation sur 100 étapes. À chaque étape, nous fournissons une des actions à prendre dans cette simulation nous sélectionnons simplement une action au hasard parmi `action_space`.
1. Exécutez le code ci-dessous et observez le résultat.
1. Exécutez le code ci-dessous et voyez ce que cela donne.
✅ N'oubliez pas qu'il est préférable d'exécuter ce code sur une installation locale de Python ! (bloc de code 3)
✅ Noubliez pas quil est préférable dexécuter ce code sur une installation Python locale ! (bloc de code 3)
```python
env.reset()
@ -54,9 +74,9 @@ Pour voir comment fonctionne l'environnement, exécutons une courte simulation d
Vous devriez voir quelque chose de similaire à cette image :
![CartPole sans équilibre](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)
![cartpole sans équilibre](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)
1. Pendant la simulation, nous devons obtenir des observations pour décider comment agir. En fait, la fonction step retourne les observations actuelles, une fonction de récompense et un indicateur `done` qui indique s'il est pertinent de continuer la simulation ou non : (bloc de code 4)
1. Pendant la simulation, nous devons obtenir des observations pour décider comment agir. En fait, la fonction step renvoie les observations actuelles, une fonction de récompense, et le drapeau done qui indique sil est judicieux de continuer la simulation ou non : (bloc de code 4)
```python
env.reset()
@ -69,7 +89,7 @@ Pour voir comment fonctionne l'environnement, exécutons une courte simulation d
env.close()
```
Vous obtiendrez quelque chose comme ceci dans la sortie du notebook :
Vous devriez voir quelque chose comme ceci dans la sortie du notebook :
```text
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0
@ -82,43 +102,43 @@ Pour voir comment fonctionne l'environnement, exécutons une courte simulation d
[ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0
```
Le vecteur d'observation retourné à chaque étape de la simulation contient les valeurs suivantes :
Le vecteur dobservations renvoyé à chaque étape de la simulation contient les valeurs suivantes :
- Position du chariot
- Vitesse du chariot
- Angle du poteau
- Taux de rotation du poteau
- Vitesse de rotation du poteau
1. Obtenez les valeurs minimales et maximales de ces nombres : (bloc de code 5)
1. Obtenez les valeurs minimum et maximum de ces nombres : (bloc de code 5)
```python
print(env.observation_space.low)
print(env.observation_space.high)
```
Vous remarquerez également que la valeur de récompense à chaque étape de la simulation est toujours 1. Cela s'explique par le fait que notre objectif est de survivre le plus longtemps possible, c'est-à-dire de maintenir le poteau dans une position raisonnablement verticale pendant la période la plus longue possible.
Vous remarquerez aussi que la valeur de la récompense à chaque étape de la simulation est toujours 1. Cela est dû au fait que notre objectif est de survivre aussi longtemps que possible, cest-à-dire garder le poteau dans une position raisonnablement verticale le plus longtemps possible.
✅ En fait, la simulation CartPole est considérée comme résolue si nous parvenons à obtenir une récompense moyenne de 195 sur 100 essais consécutifs.
✅ En fait, la simulation CartPole est considérée comme résolue si nous obtenons une récompense moyenne de 195 sur 100 essais consécutifs.
## Discrétisation de l'état
## Discrétisation de létat
Dans le Q-Learning, nous devons construire une Q-Table qui définit quoi faire à chaque état. Pour ce faire, l'état doit être **discret**, plus précisément, il doit contenir un nombre fini de valeurs discrètes. Ainsi, nous devons d'une manière ou d'une autre **discrétiser** nos observations, en les mappant à un ensemble fini d'états.
En Q-Learning, nous devons construire une Q-Table qui définit quoi faire à chaque état. Pour cela, létat doit être **discret**, plus précisément, il doit contenir un nombre fini de valeurs discrètes. Ainsi, nous devons dune certaine manière **discrétiser** nos observations, en les mappant à un ensemble fini détats.
Il existe plusieurs façons de procéder :
Il y a plusieurs façons de faire cela :
- **Diviser en intervalles**. Si nous connaissons l'intervalle d'une certaine valeur, nous pouvons diviser cet intervalle en un certain nombre d'**intervalles**, puis remplacer la valeur par le numéro de l'intervalle auquel elle appartient. Cela peut être fait en utilisant la méthode [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html) de numpy. Dans ce cas, nous connaîtrons précisément la taille de l'état, car elle dépendra du nombre d'intervalles que nous sélectionnons pour la digitalisation.
- **Diviser en bacs**. Si nous connaissons lintervalle dune certaine valeur, nous pouvons diviser cet intervalle en un nombre de **bacs**, puis remplacer la valeur par le numéro du bac auquel elle appartient. Cela peut être fait à laide de la méthode numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html). Dans ce cas, nous connaîtrons précisément la taille de létat, car elle dépendra du nombre de bacs sélectionné pour la digitalisation.
✅ Nous pouvons utiliser une interpolation linéaire pour ramener les valeurs à un intervalle fini (disons, de -20 à 20), puis convertir les nombres en entiers en les arrondissant. Cela nous donne un peu moins de contrôle sur la taille de létat, surtout si nous ne connaissons pas les plages exactes des valeurs dentrée. Par exemple, dans notre cas, 2 des 4 valeurs nont pas de bornes supérieures/inférieures, ce qui peut conduire à un nombre infini détats.
✅ Nous pouvons utiliser l'interpolation linéaire pour ramener les valeurs à un intervalle fini (par exemple, de -20 à 20), puis convertir les nombres en entiers en les arrondissant. Cela nous donne un peu moins de contrôle sur la taille de l'état, surtout si nous ne connaissons pas les plages exactes des valeurs d'entrée. Par exemple, dans notre cas, 2 des 4 valeurs n'ont pas de limites supérieures/inférieures, ce qui peut entraîner un nombre infini d'états.
Dans notre exemple, nous allons choisir la deuxième approche. Comme vous le remarquerez plus tard, malgré les bornes supérieures/inférieures indéfinies, ces valeurs prennent rarement des valeurs en dehors de certains intervalles finis, donc ces états avec des valeurs extrêmes seront très rares.
Dans notre exemple, nous opterons pour la deuxième approche. Comme vous le remarquerez plus tard, malgré l'absence de limites supérieures/inférieures, ces valeurs prennent rarement des valeurs en dehors de certains intervalles finis, donc ces états avec des valeurs extrêmes seront très rares.
1. Voici la fonction qui prendra l'observation de notre modèle et produira un tuple de 4 valeurs entières : (bloc de code 6)
1. Voici la fonction qui prendra lobservation de notre modèle et produira un tuple de 4 valeurs entières : (bloc de code 6)
```python
def discretize(x):
return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
```
1. Explorons également une autre méthode de discrétisation utilisant des intervalles : (bloc de code 7)
1. Explorons aussi une autre méthode de discrétisation utilisant des bacs : (bloc de code 7)
```python
def create_bins(i,num):
@ -126,17 +146,17 @@ Dans notre exemple, nous opterons pour la deuxième approche. Comme vous le rema
print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))
ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervals of values for each parameter
nbins = [20,20,10,10] # number of bins for each parameter
ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervalles de valeurs pour chaque paramètre
nbins = [20,20,10,10] # nombre de classes pour chaque paramètre
bins = [create_bins(ints[i],nbins[i]) for i in range(4)]
def discretize_bins(x):
return tuple(np.digitize(x[i],bins[i]) for i in range(4))
```
1. Exécutons maintenant une courte simulation et observons ces valeurs discrètes de l'environnement. N'hésitez pas à essayer `discretize` et `discretize_bins` et à voir s'il y a une différence.
1. Faisons maintenant une courte simulation et observons ces valeurs denvironnement discrètes. Nhésitez pas à essayer `discretize` et `discretize_bins` et à voir sil y a une différence.
`discretize_bins` retourne le numéro de l'intervalle, qui commence à 0. Ainsi, pour les valeurs de la variable d'entrée autour de 0, il retourne le numéro du milieu de l'intervalle (10). Dans `discretize`, nous ne nous sommes pas souciés de la plage des valeurs de sortie, leur permettant d'être négatives, donc les valeurs d'état ne sont pas décalées, et 0 correspond à 0. (bloc de code 8)
discretize_bins renvoie le numéro du bac, qui commence à 0. Ainsi, pour des valeurs de la variable dentrée proches de 0, il renvoie le numéro du milieu de lintervalle (10). Dans discretize, nous ne nous sommes pas souciés de la plage des valeurs de sortie, les autorisant à être négatives, ainsi les valeurs détat ne sont pas décalées, et 0 correspond à 0. (bloc de code 8)
```python
env.reset()
@ -150,15 +170,15 @@ Dans notre exemple, nous opterons pour la deuxième approche. Comme vous le rema
env.close()
```
✅ Décommentez la ligne commençant par `env.render` si vous souhaitez voir comment l'environnement s'exécute. Sinon, vous pouvez l'exécuter en arrière-plan, ce qui est plus rapide. Nous utiliserons cette exécution "invisible" pendant notre processus de Q-Learning.
✅ Décochez la ligne commençant par env.render si vous voulez voir comment lenvironnement sexécute. Sinon, vous pouvez lexécuter en arrière-plan, ce qui est plus rapide. Nous utiliserons cette exécution "invisible" durant notre processus de Q-Learning.
## La structure de la Q-Table
Dans notre leçon précédente, l'état était une simple paire de nombres allant de 0 à 8, et il était donc pratique de représenter la Q-Table par un tenseur numpy de forme 8x8x2. Si nous utilisons la discrétisation par intervalles, la taille de notre vecteur d'état est également connue, nous pouvons donc utiliser la même approche et représenter l'état par un tableau de forme 20x20x10x10x2 (ici 2 est la dimension de l'espace d'action, et les premières dimensions correspondent au nombre d'intervalles que nous avons choisi d'utiliser pour chacun des paramètres dans l'espace d'observation).
Dans notre leçon précédente, létat était une simple paire de nombres de 0 à 8, et donc il était pratique de représenter la Q-Table par un tenseur numpy de forme 8x8x2. Si nous utilisons la discrétisation par bacs, la taille de notre vecteur détat est également connue, donc nous pouvons utiliser la même approche et représenter létat par un tableau de forme 20x20x10x10x2 (ici 2 est la dimension de lespace daction, et les premières dimensions correspondent au nombre de bacs sélectionnés pour chacun des paramètres dans lespace dobservation).
Cependant, parfois, les dimensions précises de l'espace d'observation ne sont pas connues. Dans le cas de la fonction `discretize`, nous ne pouvons jamais être sûrs que notre état reste dans certaines limites, car certaines des valeurs originales ne sont pas bornées. Ainsi, nous utiliserons une approche légèrement différente et représenterons la Q-Table par un dictionnaire.
Cependant, parfois les dimensions précises de lespace dobservation ne sont pas connues. Dans le cas de la fonction `discretize`, nous ne pouvons jamais être sûrs que notre état reste dans certaines limites, car certaines des valeurs originales ne sont pas bornées. Ainsi, nous utiliserons une approche légèrement différente et représenterons la Q-Table par un dictionnaire.
1. Utilisez la paire *(state,action)* comme clé du dictionnaire, et la valeur correspondra à la valeur de l'entrée de la Q-Table. (bloc de code 9)
1. Utilisez la paire *(état, action)* comme clé du dictionnaire, et la valeur correspondra à la valeur de lentrée dans la Q-Table. (bloc de code 9)
```python
Q = {}
@ -168,38 +188,38 @@ Cependant, parfois, les dimensions précises de l'espace d'observation ne sont p
return [Q.get((state,a),0) for a in actions]
```
Ici, nous définissons également une fonction `qvalues()`, qui retourne une liste de valeurs de la Q-Table pour un état donné correspondant à toutes les actions possibles. Si l'entrée n'est pas présente dans la Q-Table, nous retournerons 0 par défaut.
Ici, nous définissons aussi une fonction `qvalues()`, qui renvoie une liste des valeurs de la Q-Table pour un état donné qui correspond à toutes les actions possibles. Si lentrée nest pas présente dans la Q-Table, nous retournerons 0 par défaut.
## Commençons le Q-Learning
Nous sommes maintenant prêts à apprendre à Peter à maintenir l'équilibre !
Maintenant, nous sommes prêts à apprendre à Peter à garder léquilibre !
1. Tout d'abord, définissons quelques hyperparamètres : (bloc de code 10)
1. Dabord, définissons quelques hyperparamètres : (bloc de code 10)
```python
# hyperparameters
# hyperparamètres
alpha = 0.3
gamma = 0.9
epsilon = 0.90
```
Ici, `alpha` est le **taux d'apprentissage** qui définit dans quelle mesure nous devons ajuster les valeurs actuelles de la Q-Table à chaque étape. Dans la leçon précédente, nous avons commencé avec 1, puis diminué `alpha` à des valeurs plus faibles pendant l'entraînement. Dans cet exemple, nous le garderons constant pour simplifier, et vous pourrez expérimenter avec l'ajustement des valeurs de `alpha` plus tard.
`gamma` est le **facteur d'actualisation** qui montre dans quelle mesure nous devons privilégier la récompense future par rapport à la récompense actuelle.
Ici, `alpha` est le **taux dapprentissage** qui définit dans quelle mesure nous devons ajuster les valeurs actuelles de la Q-Table à chaque étape. Dans la leçon précédente, nous avons commencé avec 1, puis diminué `alpha` vers des valeurs plus basses pendant lentraînement. Dans cet exemple, nous le garderons constant par simplicité, et vous pouvez expérimenter en ajustant `alpha` plus tard.
`epsilon` est le **facteur d'exploration/exploitation** qui détermine si nous devons privilégier l'exploration ou l'exploitation. Dans notre algorithme, nous sélectionnerons dans `epsilon` pourcentage des cas la prochaine action en fonction des valeurs de la Q-Table, et dans le reste des cas, nous exécuterons une action aléatoire. Cela nous permettra d'explorer des zones de l'espace de recherche que nous n'avons jamais vues auparavant.
`gamma` est le **facteur dactualisation** qui indique dans quelle mesure nous devons privilégier la récompense future par rapport à la récompense actuelle.
✅ En termes d'équilibre - choisir une action aléatoire (exploration) agirait comme un coup de poing aléatoire dans la mauvaise direction, et le poteau devrait apprendre à récupérer l'équilibre à partir de ces "erreurs".
`epsilon` est le **facteur exploration/exploitation** qui détermine si nous devons privilégier lexploration à lexploitation ou vice versa. Dans notre algorithme, dans `epsilon` pourcents des cas, nous sélectionnerons laction suivante selon les valeurs de la Q-Table, et dans le reste des cas nous exécuterons une action aléatoire. Cela nous permettra dexplorer des zones de lespace de recherche que nous navons jamais vues auparavant.
### Améliorer l'algorithme
✅ En termes déquilibre - choisir une action aléatoire (exploration) agit comme un coup aléatoire dans la mauvaise direction, et le poteau devra apprendre comment récupérer léquilibre après ces "erreurs".
Nous pouvons également apporter deux améliorations à notre algorithme de la leçon précédente :
### Améliorer lalgorithme
- **Calculer la récompense cumulative moyenne**, sur un certain nombre de simulations. Nous imprimerons les progrès tous les 5000 itérations, et nous ferons la moyenne de notre récompense cumulative sur cette période. Cela signifie que si nous obtenons plus de 195 points, nous pouvons considérer le problème comme résolu, avec une qualité encore supérieure à celle requise.
Nous pouvons aussi apporter deux améliorations à notre algorithme de la leçon précédente :
- **Calculer le résultat cumulatif moyen maximum**, `Qmax`, et nous stockerons la Q-Table correspondant à ce résultat. Lorsque vous exécutez l'entraînement, vous remarquerez que parfois le résultat cumulatif moyen commence à diminuer, et nous voulons conserver les valeurs de la Q-Table correspondant au meilleur modèle observé pendant l'entraînement.
- **Calculer la récompense cumulative moyenne**, sur un certain nombre de simulations. Nous afficherons la progression toutes les 5000 itérations, et nous ferons la moyenne de notre récompense cumulative sur cette période. Cela signifie que si nous obtenons plus de 195 points - nous pouvons considérer le problème résolu, avec une qualité encore meilleure que requise.
- **Calculer le maximum de la récompense cumulative moyenne**, `Qmax`, et nous stockerons la Q-Table correspondant à ce résultat. Lorsque vous exécuterez lentraînement, vous remarquerez que parfois, la récompense moyenne cumulative commence à chuter, et nous voulons garder les valeurs de la Q-Table correspondant au meilleur modèle observé pendant lentraînement.
1. Collectez toutes les récompenses cumulatives à chaque simulation dans le vecteur `rewards` pour un futur tracé. (bloc de code 11)
1. Rassembler toutes les récompenses cumulatives à chaque simulation dans le vecteur `rewards` pour un tracé ultérieur. (bloc de code 11)
```python
def probs(v,eps=1e-4):
@ -214,15 +234,15 @@ Nous pouvons également apporter deux améliorations à notre algorithme de la l
obs = env.reset()
done = False
cum_reward=0
# == do the simulation ==
# == faire la simulation ==
while not done:
s = discretize(obs)
if random.random()<epsilon:
# exploitation - chose the action according to Q-Table probabilities
# exploitation - choisir l'action selon les probabilités de la Q-Table
v = probs(np.array(qvalues(s)))
a = random.choices(actions,weights=v)[0]
else:
# exploration - randomly chose the action
# exploration - choisir l'action aléatoirement
a = np.random.randint(env.action_space.n)
obs, rew, done, info = env.step(a)
@ -231,7 +251,7 @@ Nous pouvons également apporter deux améliorations à notre algorithme de la l
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
cum_rewards.append(cum_reward)
rewards.append(cum_reward)
# == Periodically print results and calculate average reward ==
# == Imprimer périodiquement les résultats et calculer la récompense moyenne ==
if epoch%5000==0:
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
if np.average(cum_rewards) > Qmax:
@ -240,25 +260,25 @@ Nous pouvons également apporter deux améliorations à notre algorithme de la l
cum_rewards=[]
```
Ce que vous pouvez remarquer à partir de ces résultats :
Ce que vous pouvez remarquer daprès ces résultats :
- **Proche de notre objectif**. Nous sommes très proches d'atteindre l'objectif de 195 récompenses cumulatives sur 100+ exécutions consécutives de la simulation, ou nous l'avons peut-être déjà atteint ! Même si nous obtenons des nombres plus faibles, nous ne le savons pas, car nous faisons la moyenne sur 5000 exécutions, et seuls 100 exécutions sont nécessaires dans les critères formels.
- **Proche de notre objectif**. Nous sommes très proches datteindre lobjectif dobtenir 195 récompenses cumulées sur 100+ exécutions consécutives de la simulation, ou nous lavons peut-être réellement atteint ! Même si nous obtenons des chiffres plus petits, nous ne savons pas encore, car nous faisons la moyenne sur 5000 exécutions alors que 100 exécutions seulement sont requises officiellement.
- **La récompense commence à chuter**. Parfois, la récompense commence à diminuer, ce qui signifie que nous pouvons "détruire" les valeurs déjà apprises dans la Q-Table avec des valeurs qui aggravent la situation.
- **La récompense commence à diminuer**. Parfois, la récompense commence à diminuer, ce qui signifie que nous pouvons "détruire" les valeurs déjà apprises dans la Q-Table avec celles qui aggravent la situation.
Cette observation est plus clairement visible si nous traçons la progression de lentraînement.
Cette observation est plus clairement visible si nous traçons les progrès de l'entraînement.
## Tracer la progression de lentraînement
## Tracer les progrès de l'entraînement
Pendant l'entraînement, nous avons collecté la valeur de récompense cumulative à chaque itération dans le vecteur `rewards`. Voici à quoi cela ressemble lorsque nous le traçons par rapport au numéro d'itération :
Pendant lentraînement, nous avons collecté la valeur de la récompense cumulative à chaque itération dans le vecteur `rewards`. Voici à quoi cela ressemble lorsque nous la traçons en fonction du numéro ditération :
```python
plt.plot(rewards)
```
![progrès brut](../../../../8-Reinforcement/2-Gym/images/train_progress_raw.png)
![progression brute](../../../../translated_images/fr/train_progress_raw.2adfdf2daea09c59.webp)
À partir de ce graphique, il n'est pas possible de tirer des conclusions, car en raison de la nature du processus d'entraînement stochastique, la durée des sessions d'entraînement varie considérablement. Pour donner plus de sens à ce graphique, nous pouvons calculer la **moyenne mobile** sur une série d'expériences, disons 100. Cela peut être fait facilement en utilisant `np.convolve` : (bloc de code 12)
Sur ce graphique, il est impossible de tirer des conclusions, car en raison de la nature stochastique du processus dentraînement, la durée des sessions dentraînement varie fortement. Pour mieux comprendre ce graphique, nous pouvons calculer la **moyenne glissante** sur une série dexpériences, disons 100. Cela peut être fait aisément avec `np.convolve` : (bloc de code 12)
```python
def running_average(x,window):
@ -267,21 +287,24 @@ def running_average(x,window):
plt.plot(running_average(rewards,100))
```
![progrès de l'entraînement](../../../../8-Reinforcement/2-Gym/images/train_progress_runav.png)
![progression de lentraînement](../../../../translated_images/fr/train_progress_runav.c71694a8fa9ab359.webp)
## Variation des hyperparamètres
Pour rendre l'apprentissage plus stable, il est judicieux d'ajuster certains de nos hyperparamètres pendant l'entraînement. En particulier :
Pour rendre lapprentissage plus stable, il est judicieux dajuster certains de nos hyperparamètres durant lentraînement. En particulier :
- **Pour le taux dapprentissage**, `alpha`, nous pouvons commencer avec des valeurs proches de 1, puis continuer à diminuer ce paramètre. Avec le temps, nous obtiendrons de bonnes valeurs de probabilité dans la Q-Table, et donc nous devrions les ajuster légèrement, sans les écraser complètement avec des nouvelles valeurs.
- **Augmenter epsilon**. Nous pourrions augmenter lentement `epsilon`, afin dexplorer moins et dexploiter plus. Il est probablement judicieux de commencer avec une valeur basse de `epsilon`, puis la faire monter presque à 1.
> **Tâche 1** : Testez les valeurs des hyperparamètres et voyez si vous pouvez obtenir une récompense cumulative plus élevée. Parvenez-vous à dépasser 195 ?
- **Pour le taux d'apprentissage**, `alpha`, nous pouvons commencer avec des valeurs proches de 1, puis diminuer progressivement le paramètre. Avec le temps, nous obtiendrons de bonnes probabilités dans la Q-Table, et nous devrions donc les ajuster légèrement, et non les écraser complètement avec de nouvelles valeurs.
- **Augmenter epsilon**. Nous pouvons vouloir augmenter lentement `epsilon`, afin d'explorer moins et d'exploiter davantage. Il semble logique de commencer avec une valeur plus faible de `epsilon`, et de monter jusqu'à presque 1.
> **Tâche 1** : Expérimentez avec les valeurs des hyperparamètres et voyez si vous pouvez obtenir une récompense cumulative plus élevée. Atteignez-vous plus de 195 ?
> **Tâche 2** : Pour résoudre formellement le problème, vous devez atteindre une récompense moyenne de 195 sur 100 exécutions consécutives. Mesurez cela pendant l'entraînement et assurez-vous d'avoir résolu le problème de manière formelle !
> **Tâche 2** : Pour résoudre formellement le problème, vous devez obtenir une récompense moyenne de 195 sur 100 exécutions consécutives. Mesurez cela pendant l'entraînement et assurez-vous d'avoir formellement résolu le problème !
## Voir le résultat en action
Il serait intéressant de voir comment le modèle entraîné se comporte. Lançons la simulation et suivons la même stratégie de sélection d'actions qu'au cours de l'entraînement, en échantillonnant selon la distribution de probabilité dans la Q-Table : (bloc de code 13)
Il serait intéressant de voir comment le modèle entraîné se comporte réellement. Exécutons la simulation et suivons la même stratégie de sélection d'action que pendant l'entraînement, en échantillonnant selon la distribution de probabilité dans la Q-Table : (bloc de code 13)
```python
obs = env.reset()
@ -297,28 +320,30 @@ env.close()
Vous devriez voir quelque chose comme ceci :
![un chariot en équilibre](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif)
![un pendule inversé en équilibre](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif)
---
## 🚀Défi
> **Tâche 3** : Ici, nous utilisions la copie finale de la Q-Table, qui n'est peut-être pas la meilleure. Rappelez-vous que nous avons stocké la Q-Table la plus performante dans la variable `Qbest` ! Essayez le même exemple avec la Q-Table la plus performante en copiant `Qbest` dans `Q` et voyez si vous remarquez une différence.
> **Tâche 3** : Ici, nous utilisions la copie finale de la Q-Table, qui peut ne pas être la meilleure. Rappelez-vous que nous avons stocké la Q-Table la plus performante dans la variable `Qbest` ! Essayez le même exemple avec la Q-Table la plus performante en recopiant `Qbest` dans `Q` et voyez si vous remarquez la différence.
> **Tâche 4** : Ici, nous ne sélectionnions pas la meilleure action à chaque étape, mais plutôt en échantillonnant avec la distribution de probabilité correspondante. Serait-il plus logique de toujours sélectionner la meilleure action, celle avec la valeur la plus élevée dans la Q-Table ? Cela peut être fait en utilisant la fonction `np.argmax` pour trouver le numéro de l'action correspondant à la valeur la plus élevée dans la Q-Table. Implémentez cette stratégie et voyez si cela améliore l'équilibre.
> **Tâche 4** : Ici, nous ne sélectionnions pas la meilleure action à chaque étape, mais plutôt un échantillonnage selon la distribution de probabilité correspondante. Ne serait-il pas plus logique de toujours sélectionner la meilleure action, avec la valeur la plus haute dans la Q-Table ? Cela peut se faire en utilisant la fonction `np.argmax` pour trouver le numéro de l'action correspondant à la valeur la plus élevée dans la Q-Table. Implémentez cette stratégie et voyez si cela améliore l'équilibre.
## [Quiz post-lecture](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz après cours](https://ff-quizzes.netlify.app/en/ml/)
## Devoir
[Entraîner une voiture de montagne](assignment.md)
[Entraîner une Mountain Car](assignment.md)
## Conclusion
Nous avons maintenant appris à entraîner des agents pour obtenir de bons résultats simplement en leur fournissant une fonction de récompense qui définit l'état souhaité du jeu, et en leur donnant l'opportunité d'explorer intelligemment l'espace de recherche. Nous avons appliqué avec succès l'algorithme de Q-Learning dans des environnements discrets et continus, mais avec des actions discrètes.
Nous avons maintenant appris comment entraîner des agents à obtenir de bons résultats en leur fournissant simplement une fonction de récompense qui définit l'état désiré du jeu, et en leur donnant l'opportunité d'explorer intelligemment l'espace de recherche. Nous avons appliqué avec succès l'algorithme de Q-Learning dans des environnements discrets et continus, mais avec des actions discrètes.
Il est également important d'étudier des situations où l'état des actions est continu, et où l'espace d'observation est beaucoup plus complexe, comme l'image de l'écran d'un jeu Atari. Dans ces problèmes, nous devons souvent utiliser des techniques d'apprentissage automatique plus puissantes, telles que les réseaux neuronaux, pour obtenir de bons résultats. Ces sujets plus avancés seront abordés dans notre prochain cours d'IA avancé.
Il est aussi important d'étudier les situations où l'état d'action est également continu, et où l'espace d'observation est beaucoup plus complexe, comme l'image de l'écran du jeu Atari. Dans ces problèmes, nous devons souvent utiliser des techniques d'apprentissage automatique plus puissantes, telles que les réseaux neuronaux, afin d'obtenir de bons résultats. Ces sujets plus avancés feront l'objet de notre prochain cours d'IA plus avancé.
---
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Avertissement** :
Ce document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforçions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue native doit être considéré comme la source faisant autorité. Pour les informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous ne saurions être tenus responsables des malentendus ou erreurs d'interprétation découlant de l'utilisation de cette traduction.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Loading…
Cancel
Save