From 804cb7f9e960161adaae38a3f33d01e1b1a317be Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 13 Oct 2023 13:38:45 -0400
Subject: [PATCH 01/33] Create README.es.md
---
lessons/1-Intro/README.es.md | 588 +++++++++++++++++++++++++++++++++++
1 file changed, 588 insertions(+)
create mode 100644 lessons/1-Intro/README.es.md
diff --git a/lessons/1-Intro/README.es.md b/lessons/1-Intro/README.es.md
new file mode 100644
index 00000000..e3ea89d3
--- /dev/null
+++ b/lessons/1-Intro/README.es.md
@@ -0,0 +1,588 @@
+# Introducción a la IA
+
+
+
+> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
+
+## [Prueba previa a la conferencia](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
+
+**La Inteligencia Artificial** es una apasionante disciplina científica que estudia cómo podemos hacer que las computadoras muestren un comportamiento inteligente, p. hacer aquellas cosas que los seres humanos hacen bien.
+Originalmente, las computadoras fueron inventadas por [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) para operar con números siguiendo un procedimiento bien definido - un algoritmo. Las computadoras modernas, aunque significativamente más avanzadas que el modelo original propuesto en el siglo XIX, todavía siguen la misma idea de cálculos controlados. Por lo tanto, es posible programar una computadora para que haga algo si conocemos la secuencia exacta de pasos que debemos seguir para lograr el objetivo.
+
+
+> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
+
+> ✅ Definir la edad de una persona a partir de su fotografía es una tarea que no se puede programar explícitamente, porque no sabemos cómo se nos ocurre un número dentro de la cabeza cuando lo hacemos.
+---
+
+Sin embargo, hay algunas tareas que no sabemos explícitamente cómo resolver. Considere determinar la edad de una persona a partir de su fotografía. De alguna manera aprendemos a hacerlo, porque hemos visto muchos ejemplos de personas de diferentes edades, pero no podemos explicar explícitamente cómo lo hacemos, ni podemos programar la computadora para que lo haga. Este es exactamente el tipo de tarea que interesa a la **Inteligencia Artificial** (IA para abreviar).
+> ✅ Piense en algunas tareas que podría descargar a una computadora que se beneficiaría de la IA. Consideremos los campos de las finanzas, la medicina y las artes: ¿cómo se benefician hoy estos campos de la IA?
+
+## IA débil versus IA fuerte
+
+La tarea de resolver un problema humano específico, como determinar la edad de una persona a partir de una fotografía, se puede llamar **IA débil**, porque estamos creando un sistema para una sola tarea, y no un sistema que pueda resolver muchas. tareas que pueden ser realizadas por un ser humano. Por supuesto, el desarrollo de un sistema informático generalmente inteligente también es muy interesante desde muchos puntos de vista, también para los estudiantes de filosofía de la conciencia. Dicho sistema se llamaría **Fuerte IA** o **[Inteligencia general artificial](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
+
+## La definición de inteligencia y el test de Turing
+
+Uno de los problemas al abordar el término **[Inteligencia](https://en.wikipedia.org/wiki/Intelligence)** es que no existe una definición clara de este término. Se puede argumentar que la inteligencia está relacionada con el **pensamiento abstracto** o con la **autoconciencia**, pero no podemos definirlo adecuadamente.
+
+
+
+> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
+
+To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
+
+✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
+
+---
+
+When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
+
+> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
+
+✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
+
+## Different Approaches to AI
+
+If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
+
+> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
+
+There are two possible approaches to this problem:
+
+Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
+---------------------------------------|-------------------------------------
+A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
+
+There are also some other possible approaches to intelligence:
+
+* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
+
+* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
+
+We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
+
+### The Top-Down Approach
+
+In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
+
+People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
+
+This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
+
+### Bottom-Up Approach
+
+Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
+
+✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
+
+> | What about ML? | |
+> |--------------|-----------|
+> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
+
+## A Brief History of AI
+
+Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
+
+We can observe how the approaches changed, for example, in creating a chess playing computer program:
+
+* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
+* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
+* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
+
+✅ Do a little research on other games that have been played by AI.
+
+Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
+
+* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
+* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
+* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
+
+
+
+> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
+
+## Recent AI Research
+
+The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
+
+Since then, Neural Networks demonstrated very successful behaviour in many tasks:
+
+---
+
+Year | Human Parity achieved
+-----|--------
+2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
+2016 | [Conversational Speech Recognition](https://arxiv.org/abs/1610.05256)
+2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
+2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
+
+Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
+
+## 🚀 Challenge
+
+Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
+
+## Review & Self Study
+
+Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element # Introduction to AI
+
+
+
+> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
+
+**Artificial Intelligence** is an exciting scientific discipline that studies how we can make computers exhibit intelligent behavior, e.g. do those things that human beings are good at doing.
+
+Originally, computers were invented by [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) to operate on numbers following a well-defined procedure - an algorithm. Modern computers, even though significantly more advanced than the original model proposed in the 19th century, still follow the same idea of controlled computations. Thus it is possible to program a computer to do something if we know the exact sequence of steps that we need to do in order to achieve the goal.
+
+
+
+> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
+
+> ✅ Defining the age of a person from his or her photograph is a task that cannot be explicitly programmed, because we do not know how we come up with a number inside our head when we do it.
+
+---
+
+There are some tasks, however, that we do not explicitly know how to solve. Consider determining the age of a person from his/her photograph. We somehow learn to do it, because we have seen many examples of people of different age, but we cannot explicitly explain how we do it, nor can we program the computer to do it. This is exactly the kind of task that are of interest to **Artificial Intelligence** (AI for short).
+
+✅ Think of some tasks that you could offload to a computer that would benefit from AI. Consider the fields of finance, medicine, and the arts - how are these fields benefiting today from AI?
+
+## Weak AI vs. Strong AI
+
+The task of solving a specific human-like problem, such as determining a person's age from a photo, can be called **Weak AI**, because we are creating a system for only one task, and not a system that can solve many tasks, such as can be done by a human being. Of course, developing a generally intelligent computer system is also extremely interesting from many points of view, including for students of the philosophy of consciousness. Such system would be called **Strong AI**, or **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
+
+## The Definition of Intelligence and the Turing Test
+
+One of the problems when dealing with the term **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** is that there is no clear definition of this term. One can argue that intelligence is connected to **abstract thinking**, or to **self-awareness**, but we cannot properly define it.
+
+
+
+> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
+
+To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
+
+✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
+
+---
+
+When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
+
+> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
+
+✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
+
+## Different Approaches to AI
+
+If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
+
+> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
+
+There are two possible approaches to this problem:
+
+Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
+---------------------------------------|-------------------------------------
+A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
+
+There are also some other possible approaches to intelligence:
+
+* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
+
+* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
+
+We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
+
+### The Top-Down Approach
+
+In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
+
+People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
+
+This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
+
+### Bottom-Up Approach
+
+Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
+
+✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
+
+> | What about ML? | |
+> |--------------|-----------|
+> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
+
+## A Brief History of AI
+
+Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
+
+We can observe how the approaches changed, for example, in creating a chess playing computer program:
+
+* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
+* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
+* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
+
+✅ Do a little research on other games that have been played by AI.
+
+Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
+
+* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
+* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
+* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
+
+
+
+> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
+
+## Recent AI Research
+
+The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
+
+Since then, Neural Networks demonstrated very successful behaviour in many tasks:
+
+---
+
+Year | Human Parity achieved
+-----|--------
+2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
+2016 | [Conversational Speech Rec# Introduction to AI
+
+
+
+> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
+
+**Artificial Intelligence** is an exciting scientific discipline that studies how we can make computers exhibit intelligent behavior, e.g. do those things that human beings are good at doing.
+
+Originally, computers were invented by [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) to operate on numbers following a well-defined procedure - an algorithm. Modern computers, even though significantly more advanced than the original model proposed in the 19th century, still follow the same idea of controlled computations. Thus it is possible to program a computer to do something if we know the exact sequence of steps that we need to do in order to achieve the goal.
+
+
+
+> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
+
+> ✅ Defining the age of a person from his or her photograph is a task that cannot be explicitly programmed, because we do not know how we come up with a number inside our head when we do it.
+
+---
+
+There are some tasks, however, that we do not explicitly know how to solve. Consider determining the age of a person from his/her photograph. We somehow learn to do it, because we have seen many examples of people of different age, but we cannot explicitly explain how we do it, nor can we program the computer to do it. This is exactly the kind of task that are of interest to **Artificial Intelligence** (AI for short).
+
+✅ Think of some tasks that you could offload to a computer that would benefit from AI. Consider the fields of finance, medicine, and the arts - how are these fields benefiting today from AI?
+
+## Weak AI vs. Strong AI
+
+The task of solving a specific human-like problem, such as determining a person's age from a photo, can be called **Weak AI**, because we are creating a system for only one task, and not a system that can solve many tasks, such as can be done by a human being. Of course, developing a generally intelligent computer system is also extremely interesting from many points of view, including for students of the philosophy of consciousness. Such system would be called **Strong AI**, or **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
+
+## The Definition of Intelligence and the Turing Test
+
+One of the problems when dealing with the term **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** is that there is no clear definition of this term. One can argue that intelligence is connected to **abstract thinking**, or to **self-awareness**, but we cannot properly define it.
+
+
+
+> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
+
+To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
+
+✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
+
+---
+
+When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
+
+> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
+
+✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
+
+## Different Approaches to AI
+
+If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
+
+> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
+
+There are two possible approaches to this problem:
+
+Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
+---------------------------------------|-------------------------------------
+A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
+
+There are also some other possible approaches to intelligence:
+
+* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
+
+* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
+
+We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
+
+### The Top-Down Approach
+
+In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
+
+People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
+
+This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
+
+### Bottom-Up Approach
+
+Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
+
+✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
+
+> | What about ML? | |
+> |--------------|-----------|
+> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
+
+## A Brief History of AI
+
+Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
+
+We can observe how the approaches changed, for example, in creating a chess playing computer program:
+
+* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
+* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
+* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
+
+✅ Do a little research on other games that have been played by AI.
+
+Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
+
+* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
+* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
+* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
+
+
+
+> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
+
+## Recent AI Research
+
+The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
+
+Since then, Neural Networks demonstrated very successful behaviour in many tasks:
+
+---
+
+Year | Human Parity achieved
+-----|--------
+2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
+2016 | [Conversational Speech Recognition](https://arxiv.org/abs/1610.05256)
+2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
+2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
+
+Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
+
+## 🚀 Challenge
+
+Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
+
+## Review & Self Study
+
+Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element # Introduction to AI
+
+
+
+> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
+
+**Artificial Intelligence** is an exciting scientific discipline that studies how we can make computers exhibit intelligent behavior, e.g. do those things that human beings are good at doing.
+
+Originally, computers were invented by [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) to operate on numbers following a well-defined procedure - an algorithm. Modern computers, even though significantly more advanced than the original model proposed in the 19th century, still follow the same idea of controlled computations. Thus it is possible to program a computer to do something if we know the exact sequence of steps that we need to do in order to achieve the goal.
+
+
+
+> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
+
+> ✅ Defining the age of a person from his or her photograph is a task that cannot be explicitly programmed, because we do not know how we come up with a number inside our head when we do it.
+
+---
+
+There are some tasks, however, that we do not explicitly know how to solve. Consider determining the age of a person from his/her photograph. We somehow learn to do it, because we have seen many examples of people of different age, but we cannot explicitly explain how we do it, nor can we program the computer to do it. This is exactly the kind of task that are of interest to **Artificial Intelligence** (AI for short).
+
+✅ Think of some tasks that you could offload to a computer that would benefit from AI. Consider the fields of finance, medicine, and the arts - how are these fields benefiting today from AI?
+
+## Weak AI vs. Strong AI
+
+The task of solving a specific human-like problem, such as determining a person's age from a photo, can be called **Weak AI**, because we are creating a system for only one task, and not a system that can solve many tasks, such as can be done by a human being. Of course, developing a generally intelligent computer system is also extremely interesting from many points of view, including for students of the philosophy of consciousness. Such system would be called **Strong AI**, or **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
+
+## The Definition of Intelligence and the Turing Test
+
+One of the problems when dealing with the term **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** is that there is no clear definition of this term. One can argue that intelligence is connected to **abstract thinking**, or to **self-awareness**, but we cannot properly define it.
+
+
+
+> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
+
+To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
+
+✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
+
+---
+
+When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
+
+> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
+
+✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
+
+## Different Approaches to AI
+
+If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
+
+> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
+
+There are two possible approaches to this problem:
+
+Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
+---------------------------------------|-------------------------------------
+A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
+
+There are also some other possible approaches to intelligence:
+
+* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
+
+* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
+
+We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
+
+### The Top-Down Approach
+
+In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
+
+People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
+
+This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
+
+### Bottom-Up Approach
+
+Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
+
+✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
+
+> | What about ML? | |
+> |--------------|-----------|
+> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
+
+## A Brief History of AI
+
+Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
+
+We can observe how the approaches changed, for example, in creating a chess playing computer program:
+
+* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
+* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
+* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
+
+✅ Do a little research on other games that have been played by AI.
+
+Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
+
+* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
+* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
+* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
+
+
+
+> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
+
+## Recent AI Research
+
+The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
+
+Since then, Neural Networks demonstrated very successful behaviour in many tasks:
+
+---
+
+Year | Human Parity achieved
+-----|--------
+2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
+2016 | [Conversational Speech Recognition](https://arxiv.org/abs/1610.05256)
+2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
+2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
+
+Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
+
+## 🚀 Challenge
+
+Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
+
+## Review & Self Study
+
+Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
+
+**Assignment**: [Game Jam](assignment.md)
+from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
+
+**Assignment**: [Game Jam](assignment.md)
+ognition](https://arxiv.org/abs/1610.05256)
+2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
+2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
+
+Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
+
+## 🚀 Challenge
+
+Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
+
+## Review & Self Study
+
+Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
+
+**Assignment**: [Game Jam](assignment.md)
+from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
+
+**Assignment**: [Game Jam](assignment.md)
From 73b567b1f78fb1ba31be278219857ad5daf152d8 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 27 Oct 2023 21:35:23 -0400
Subject: [PATCH 02/33] Update README.es.md
---
lessons/1-Intro/README.es.md | 558 ++++-------------------------------
1 file changed, 57 insertions(+), 501 deletions(-)
diff --git a/lessons/1-Intro/README.es.md b/lessons/1-Intro/README.es.md
index e3ea89d3..5a928c7c 100644
--- a/lessons/1-Intro/README.es.md
+++ b/lessons/1-Intro/README.es.md
@@ -4,13 +4,13 @@
> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
-## [Prueba previa a la conferencia](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
**La Inteligencia Artificial** es una apasionante disciplina científica que estudia cómo podemos hacer que las computadoras muestren un comportamiento inteligente, p. hacer aquellas cosas que los seres humanos hacen bien.
Originalmente, las computadoras fueron inventadas por [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) para operar con números siguiendo un procedimiento bien definido - un algoritmo. Las computadoras modernas, aunque significativamente más avanzadas que el modelo original propuesto en el siglo XIX, todavía siguen la misma idea de cálculos controlados. Por lo tanto, es posible programar una computadora para que haga algo si conocemos la secuencia exacta de pasos que debemos seguir para lograr el objetivo.
-> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
+> Foto de [Vickie Soshnikova](http://twitter.com/vickievalerie)
> ✅ Definir la edad de una persona a partir de su fotografía es una tarea que no se puede programar explícitamente, porque no sabemos cómo se nos ocurre un número dentro de la cabeza cuando lo hacemos.
---
@@ -20,569 +20,125 @@ Sin embargo, hay algunas tareas que no sabemos explícitamente cómo resolver. C
## IA débil versus IA fuerte
-La tarea de resolver un problema humano específico, como determinar la edad de una persona a partir de una fotografía, se puede llamar **IA débil**, porque estamos creando un sistema para una sola tarea, y no un sistema que pueda resolver muchas. tareas que pueden ser realizadas por un ser humano. Por supuesto, el desarrollo de un sistema informático generalmente inteligente también es muy interesante desde muchos puntos de vista, también para los estudiantes de filosofía de la conciencia. Dicho sistema se llamaría **Fuerte IA** o **[Inteligencia general artificial](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
+La tarea de resolver un problema humano específico, como determinar la edad de una persona a partir de una fotografía, se puede llamar **IA débil**, porque estamos creando un sistema para una sola tarea, y no un sistema que pueda resolver muchas. tareas que pueden ser realizadas por un ser humano. Por supuesto, el desarrollo de un sistema informático generalmente inteligente también es muy interesante desde muchos puntos de vista, también para los estudiantes de filosofía de la conciencia. Dicho sistema se llamaría **Fuerte IA** o **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
## La definición de inteligencia y el test de Turing
-Uno de los problemas al abordar el término **[Inteligencia](https://en.wikipedia.org/wiki/Intelligence)** es que no existe una definición clara de este término. Se puede argumentar que la inteligencia está relacionada con el **pensamiento abstracto** o con la **autoconciencia**, pero no podemos definirlo adecuadamente.
+Uno de los problemas al abordar el término **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** es que no existe una definición clara de este término. Se puede argumentar que la inteligencia está relacionada con el **pensamiento abstracto** o con la **autoconciencia**, pero no podemos definirlo adecuadamente.
> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
-To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
+Para ver la ambigüedad de un término *inteligencia*, intenta responder a una pregunta: "¿Es inteligente un gato?". Diferentes personas tienden a dar diferentes respuestas a esta pregunta, ya que no existe una prueba universalmente aceptada para demostrar que la afirmación es cierta o no. Y si crees que sí, prueba a someter a tu gato a una prueba de coeficiente intelectual...
-✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
+✅ Piensa por un minuto en cómo defines la inteligencia. ¿Es inteligente un cuervo que puede resolver un laberinto y llegar a algo de comida? ¿Es inteligente un niño?
---
-When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
-
-> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
-
-✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
+Cuando hablamos de AGI, necesitamos tener alguna forma de saber si hemos creado un sistema verdaderamente inteligente. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) propuso una forma llamada **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, que también actúa como una definición de inteligencia. La prueba compara un sistema dado con algo inherentemente inteligente: un ser humano real, y debido a que cualquier comparación automática puede ser eludida por un programa de computadora, usamos un interrogador humano. Por lo tanto, si un ser humano es incapaz de distinguir entre una persona real y un sistema informático en un diálogo basado en texto, el sistema se considera inteligente.
-## Different Approaches to AI
+> Un chat-bot llamado [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), desarrollado en San Petersburgo, estuvo a punto de pasar el test de Turing en 2014 mediante el uso de un ingenioso truco de personalidad. Anunciaba por adelantado que se trataba de un niño ucraniano de 13 años, lo que explicaría la falta de conocimiento y algunas discrepancias en el texto. El bot convenció al 30% de los jueces de que era humano después de un diálogo de 5 minutos, una métrica que Turing creía que una máquina sería capaz de pasar en el año 2000. Sin embargo, hay que entender que esto no indica que hayamos creado un sistema inteligente, o que un sistema informático haya engañado al interrogador humano: ¡el sistema no engañó a los humanos, sino que lo hicieron los creadores de los bots!
-If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
+✅ ¿Alguna vez has sido engañado por un bot de chat para que pienses que estás hablando con un humano? ¿Cómo te convenció?
-> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
+## Diferentes enfoques de la IA
-There are two possible approaches to this problem:
+Si queremos que una computadora se comporte como un humano, necesitamos de alguna manera modelar dentro de una computadora nuestra forma de pensar. En consecuencia, tenemos que tratar de entender qué es lo que hace que un ser humano sea inteligente.
-Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
----------------------------------------|-------------------------------------
-A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
+> Para poder programar la inteligencia en una máquina, necesitamos entender cómo funcionan nuestros propios procesos de toma de decisiones. Si haces un poco de introspección, te darás cuenta de que hay algunos procesos que ocurren inconscientemente, por ejemplo. Podemos distinguir a un gato de un perro sin pensar en ello, mientras que otros implican razonamiento.
-There are also some other possible approaches to intelligence:
+Hay dos enfoques posibles para este problema:
-* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
+Enfoque de arriba hacia abajo (razonamiento simbólico) | Enfoque ascendente (redes neuronales)
+-------------------------------------------------------|-----------------------------------------------------
+Un enfoque de arriba hacia abajo modela la forma en que una persona razona para resolver un problema. Consiste en extraer **conocimiento** de un ser humano y representarlo en una forma legible por computadora. También necesitamos desarrollar una forma de modelar el **razonamiento** dentro de una computadora. | Un enfoque ascendente modela la estructura de un cerebro humano, que consiste en un gran número de unidades simples llamadas **neuronas**. Cada neurona actúa como un promedio ponderado de sus entradas, y podemos entrenar una red de neuronas para resolver problemas útiles proporcionando **datos de entrenamiento**.
-* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
+También hay otros enfoques posibles de la inteligencia:
-We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
+* Un enfoque **Emergente**, **Sinérgico** o **multi-agente** se basa en el hecho de que se puede obtener un comportamiento inteligente complejo mediante la interacción de un gran número de agentes simples. Según [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), La inteligencia puede *emerger* de un comportamiento más simple y reactivo en el proceso de *transición del metasistema*.
+
+* Un **enfoque evolutivo**, o **algoritmo genético** es un proceso de optimización basado en los principios de la evolución.
+
+Consideraremos esos enfoques más adelante en el curso, pero en este momento nos centraremos en dos direcciones principales: de arriba hacia abajo y de abajo hacia arriba.
-### The Top-Down Approach
+### El enfoque de arriba hacia abajo
-In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
+En un **enfoque de arriba hacia abajo**, tratamos de modelar nuestro razonamiento. Debido a que podemos seguir nuestros pensamientos cuando razonamos, podemos tratar de formalizar este proceso y programarlo dentro de la computadora. A esto se le llama **razonamiento simbólico**.
-People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
+Las personas tienden a tener algunas reglas en su cabeza que guían sus procesos de toma de decisiones. Por ejemplo, cuando un médico está diagnosticando a un paciente, puede darse cuenta de que una persona tiene fiebre y, por lo tanto, puede haber algo de inflamación dentro del cuerpo. Al aplicar un gran conjunto de reglas a un problema específico, un médico puede llegar al diagnóstico final.
-This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
+Este enfoque se basa en gran medida en la **representación del conocimiento** y el **razonamiento**. Extraer el conocimiento de un experto humano puede ser la parte más difícil, porque un médico en muchos casos no sabría exactamente por qué está llegando a un diagnóstico en particular. A veces, la solución simplemente surge en su cabeza sin pensar explícitamente. Algunas tareas, como determinar la edad de una persona a partir de una fotografía, no pueden reducirse en absoluto a manipular el conocimiento.
-### Bottom-Up Approach
+### Enfoque ascendente
-Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
+Alternativamente, podemos intentar modelar los elementos más simples dentro de nuestro cerebro: una neurona. Podemos construir una llamada **red neuronal artificial** dentro de una computadora, y luego tratar de enseñarle a resolver problemas dándole ejemplos. Este proceso es similar a la forma en que un niño recién nacido aprende sobre su entorno haciendo observaciones.
-✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
+✅ Investigue un poco sobre cómo aprenden los bebés. ¿Cuáles son los elementos básicos del cerebro de un bebé?
-> | What about ML? | |
+> | ¿Qué pasa con el aprendizaje automático? | |
> |--------------|-----------|
-> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
+> | Parte de la Inteligencia Artificial que se basa en el aprendizaje informático para resolver un problema basado en unos datos se denomina **Machine Learning**. No consideraremos el aprendizaje automático clásico en este curso, lo remitimos a un [Machine Learning for Beginners](http://aka.ms/ml-beginners) currículo. |  |
-## A Brief History of AI
+## Breve historia de la IA
-Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
+La Inteligencia Artificial se inició como campo a mediados del siglo XX. Inicialmente, el razonamiento simbólico era un enfoque prevalente, y condujo a una serie de éxitos importantes, como los sistemas expertos, programas informáticos que eran capaces de actuar como expertos en algunos dominios problemáticos limitados. Sin embargo, pronto quedó claro que este enfoque no se adapta bien.Extraer el conocimiento de un experto, representarlo en una computadora y mantener esa base de conocimiento precisa resulta ser una tarea muy compleja y demasiado costosa para ser práctica en muchos casos. Esto llevó a los llamados [AI Winter](https://en.wikipedia.org/wiki/AI_winter) en la década de 1970.
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
+> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
-As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
+Con el paso del tiempo, los recursos informáticos se volvieron más baratos y se dispuso de más datos, por lo que los enfoques de redes neuronales comenzaron a demostrar un gran rendimiento para competir con los seres humanos en muchas áreas, como la visión por computadora o la comprensión del habla. En la última década, el término Inteligencia Artificial se ha utilizado principalmente como sinónimo de Redes Neuronales, porque la mayoría de los éxitos de la IA de los que oímos hablar se basan en ellas.
-We can observe how the approaches changed, for example, in creating a chess playing computer program:
+Podemos observar cómo cambiaron los enfoques, por ejemplo, en la creación de un programa informático para jugar al ajedrez:
-* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
-* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
-* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
+* Los primeros programas de ajedrez se basaban en la búsqueda: un programa intentaba explícitamente estimar los posibles movimientos de un oponente para un número determinado de movimientos siguientes, y seleccionaba un movimiento óptimo basado en la posición óptima que se puede lograr en unos pocos movimientos. Condujo al desarrollo de la llamada [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) algoritmo de búsqueda.
+* Las estrategias de búsqueda funcionan bien hacia el final del juego, donde el espacio de búsqueda está limitado por un pequeño número de movimientos posibles. Sin embargo, al comienzo del juego, el espacio de búsqueda es enorme y el algoritmo se puede mejorar aprendiendo de las coincidencias existentes entre jugadores humanos. En experimentos posteriores se emplearon los llamados [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), donde el programa buscaba casos en la base de conocimiento muy similares a la posición actual en el juego.
+* Los programas modernos que conquistan a los jugadores humanos se basan en redes neuronales y [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), donde los programas aprenden a jugar únicamente jugando mucho tiempo contra sí mismos y aprendiendo de sus propios errores, al igual que lo hacen los seres humanos cuando aprenden a jugar al ajedrez. Sin embargo, un programa de computadora puede jugar muchos más juegos en mucho menos tiempo y, por lo tanto, puede aprender mucho más rápido.
-✅ Do a little research on other games that have been played by AI.
+✅ Investiga un poco sobre otros juegos que han sido jugados por IA.
-Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
+Del mismo modo, podemos ver cómo cambió el enfoque hacia la creación de "programas parlantes" (que podrían pasar el test de Turing):
-* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
-* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
-* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
+* Los primeros programas de este tipo, tales como [Eliza](https://en.wikipedia.org/wiki/ELIZA), se basaban en reglas gramaticales muy simples y en la reformulación de la oración introducida en una pregunta.
+* Los asistentes modernos, como Cortana, Siri o Google Assistant son todos sistemas híbridos que utilizan redes neuronales para convertir el habla en texto y reconocer nuestra intención, y luego emplean algunos algoritmos de razonamiento o explícitos para realizar las acciones requeridas.
+* En el futuro, podemos esperar un modelo completo basado en neuronas que maneje el diálogo por sí mismo. El reciente GPT y [Turing-NLG](https://turing.microsoft.com/) familia de redes neuronales muestran un gran éxito en esto.
-> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
+> Imagen de Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
-## Recent AI Research
+## Investigación reciente sobre IA
-The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
+El enorme crecimiento reciente en la investigación de redes neuronales comenzó alrededor de 2010, cuando grandes conjuntos de datos públicos comenzaron a estar disponibles. Una enorme colección de imágenes llamada [ImageNet](https://en.wikipedia.org/wiki/ImageNet), que contiene alrededor de 14 millones de imágenes anotadas, dio origen a la [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
+> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
-In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
+En 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) se utilizaron por primera vez en la clasificación de imágenes, lo que condujo a una caída significativa en los errores de clasificación (de casi el 30% al 16,4%). En 2015, la arquitectura ResNet de Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
-Since then, Neural Networks demonstrated very successful behaviour in many tasks:
+Desde entonces, las Redes Neuronales han demostrado un comportamiento muy exitoso en muchas tareas:
---
-Year | Human Parity achieved
+Año | Paridad Humana lograda
-----|--------
2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
2016 | [Conversational Speech Recognition](https://arxiv.org/abs/1610.05256)
2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
-Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
+En los últimos años hemos sido testigos de grandes éxitos con grandes modelos de lenguaje, como BERT y GPT-3. Esto sucedió principalmente debido al hecho de que hay una gran cantidad de datos de texto general disponibles que nos permiten entrenar modelos para capturar la estructura y el significado de los textos, entrenarlos previamente en colecciones de texto generales y luego especializar esos modelos para tareas más específicas. Aprenderemos más sobre [Natural Language Processing](../5-NLP/README.md) más adelante en este curso.
-## 🚀 Challenge
+## 🚀 Desafiar
-Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
+Haga un recorrido por Internet para determinar dónde, en su opinión, se utiliza la IA de manera más efectiva. ¿Está en una aplicación de mapas, o en algún servicio de voz a texto o en un videojuego? Investiga cómo se construyó el sistema.
## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
-## Review & Self Study
-
-Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element # Introduction to AI
-
-
-
-> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
-
-## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
-
-**Artificial Intelligence** is an exciting scientific discipline that studies how we can make computers exhibit intelligent behavior, e.g. do those things that human beings are good at doing.
-
-Originally, computers were invented by [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) to operate on numbers following a well-defined procedure - an algorithm. Modern computers, even though significantly more advanced than the original model proposed in the 19th century, still follow the same idea of controlled computations. Thus it is possible to program a computer to do something if we know the exact sequence of steps that we need to do in order to achieve the goal.
-
-
-
-> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
-
-> ✅ Defining the age of a person from his or her photograph is a task that cannot be explicitly programmed, because we do not know how we come up with a number inside our head when we do it.
-
----
-
-There are some tasks, however, that we do not explicitly know how to solve. Consider determining the age of a person from his/her photograph. We somehow learn to do it, because we have seen many examples of people of different age, but we cannot explicitly explain how we do it, nor can we program the computer to do it. This is exactly the kind of task that are of interest to **Artificial Intelligence** (AI for short).
-
-✅ Think of some tasks that you could offload to a computer that would benefit from AI. Consider the fields of finance, medicine, and the arts - how are these fields benefiting today from AI?
-
-## Weak AI vs. Strong AI
-
-The task of solving a specific human-like problem, such as determining a person's age from a photo, can be called **Weak AI**, because we are creating a system for only one task, and not a system that can solve many tasks, such as can be done by a human being. Of course, developing a generally intelligent computer system is also extremely interesting from many points of view, including for students of the philosophy of consciousness. Such system would be called **Strong AI**, or **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
-
-## The Definition of Intelligence and the Turing Test
-
-One of the problems when dealing with the term **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** is that there is no clear definition of this term. One can argue that intelligence is connected to **abstract thinking**, or to **self-awareness**, but we cannot properly define it.
-
-
-
-> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
-
-To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
-
-✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
-
----
-
-When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
-
-> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
-
-✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
-
-## Different Approaches to AI
-
-If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
-
-> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
-
-There are two possible approaches to this problem:
-
-Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
----------------------------------------|-------------------------------------
-A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
-
-There are also some other possible approaches to intelligence:
-
-* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
-
-* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
-
-We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
-
-### The Top-Down Approach
-
-In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
-
-People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
-
-This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
-
-### Bottom-Up Approach
-
-Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
-
-✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
-
-> | What about ML? | |
-> |--------------|-----------|
-> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
-
-## A Brief History of AI
-
-Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
-
-
-
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
-
-As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
-
-We can observe how the approaches changed, for example, in creating a chess playing computer program:
-
-* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
-* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
-* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
-
-✅ Do a little research on other games that have been played by AI.
-
-Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
-
-* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
-* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
-* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
-
-
-
-> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
-
-## Recent AI Research
-
-The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
-
-
-
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
-
-In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
-
-Since then, Neural Networks demonstrated very successful behaviour in many tasks:
-
----
-
-Year | Human Parity achieved
------|--------
-2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
-2016 | [Conversational Speech Rec# Introduction to AI
-
-
-
-> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
-
-## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
-
-**Artificial Intelligence** is an exciting scientific discipline that studies how we can make computers exhibit intelligent behavior, e.g. do those things that human beings are good at doing.
-
-Originally, computers were invented by [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) to operate on numbers following a well-defined procedure - an algorithm. Modern computers, even though significantly more advanced than the original model proposed in the 19th century, still follow the same idea of controlled computations. Thus it is possible to program a computer to do something if we know the exact sequence of steps that we need to do in order to achieve the goal.
-
-
-
-> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
-
-> ✅ Defining the age of a person from his or her photograph is a task that cannot be explicitly programmed, because we do not know how we come up with a number inside our head when we do it.
-
----
-
-There are some tasks, however, that we do not explicitly know how to solve. Consider determining the age of a person from his/her photograph. We somehow learn to do it, because we have seen many examples of people of different age, but we cannot explicitly explain how we do it, nor can we program the computer to do it. This is exactly the kind of task that are of interest to **Artificial Intelligence** (AI for short).
-
-✅ Think of some tasks that you could offload to a computer that would benefit from AI. Consider the fields of finance, medicine, and the arts - how are these fields benefiting today from AI?
-
-## Weak AI vs. Strong AI
-
-The task of solving a specific human-like problem, such as determining a person's age from a photo, can be called **Weak AI**, because we are creating a system for only one task, and not a system that can solve many tasks, such as can be done by a human being. Of course, developing a generally intelligent computer system is also extremely interesting from many points of view, including for students of the philosophy of consciousness. Such system would be called **Strong AI**, or **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
-
-## The Definition of Intelligence and the Turing Test
-
-One of the problems when dealing with the term **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** is that there is no clear definition of this term. One can argue that intelligence is connected to **abstract thinking**, or to **self-awareness**, but we cannot properly define it.
-
-
-
-> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
-
-To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
-
-✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
-
----
-
-When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
-
-> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
-
-✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
-
-## Different Approaches to AI
-
-If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
-
-> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
-
-There are two possible approaches to this problem:
-
-Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
----------------------------------------|-------------------------------------
-A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
-
-There are also some other possible approaches to intelligence:
-
-* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
-
-* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
-
-We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
-
-### The Top-Down Approach
-
-In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
-
-People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
-
-This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
-
-### Bottom-Up Approach
-
-Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
-
-✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
-
-> | What about ML? | |
-> |--------------|-----------|
-> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
-
-## A Brief History of AI
-
-Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
-
-
-
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
-
-As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
-
-We can observe how the approaches changed, for example, in creating a chess playing computer program:
-
-* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
-* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
-* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
-
-✅ Do a little research on other games that have been played by AI.
-
-Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
-
-* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
-* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
-* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
-
-
-
-> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
-
-## Recent AI Research
-
-The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
-
-
-
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
-
-In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
-
-Since then, Neural Networks demonstrated very successful behaviour in many tasks:
-
----
-
-Year | Human Parity achieved
------|--------
-2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
-2016 | [Conversational Speech Recognition](https://arxiv.org/abs/1610.05256)
-2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
-2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
-
-Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
-
-## 🚀 Challenge
-
-Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
-
-## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
-
-## Review & Self Study
-
-Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element # Introduction to AI
-
-
-
-> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
-
-## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/101)
-
-**Artificial Intelligence** is an exciting scientific discipline that studies how we can make computers exhibit intelligent behavior, e.g. do those things that human beings are good at doing.
-
-Originally, computers were invented by [Charles Babbage](https://en.wikipedia.org/wiki/Charles_Babbage) to operate on numbers following a well-defined procedure - an algorithm. Modern computers, even though significantly more advanced than the original model proposed in the 19th century, still follow the same idea of controlled computations. Thus it is possible to program a computer to do something if we know the exact sequence of steps that we need to do in order to achieve the goal.
-
-
-
-> Photo by [Vickie Soshnikova](http://twitter.com/vickievalerie)
-
-> ✅ Defining the age of a person from his or her photograph is a task that cannot be explicitly programmed, because we do not know how we come up with a number inside our head when we do it.
-
----
-
-There are some tasks, however, that we do not explicitly know how to solve. Consider determining the age of a person from his/her photograph. We somehow learn to do it, because we have seen many examples of people of different age, but we cannot explicitly explain how we do it, nor can we program the computer to do it. This is exactly the kind of task that are of interest to **Artificial Intelligence** (AI for short).
-
-✅ Think of some tasks that you could offload to a computer that would benefit from AI. Consider the fields of finance, medicine, and the arts - how are these fields benefiting today from AI?
-
-## Weak AI vs. Strong AI
-
-The task of solving a specific human-like problem, such as determining a person's age from a photo, can be called **Weak AI**, because we are creating a system for only one task, and not a system that can solve many tasks, such as can be done by a human being. Of course, developing a generally intelligent computer system is also extremely interesting from many points of view, including for students of the philosophy of consciousness. Such system would be called **Strong AI**, or **[Artificial General Intelligence](https://en.wikipedia.org/wiki/Artificial_general_intelligence)** (AGI).
-
-## The Definition of Intelligence and the Turing Test
-
-One of the problems when dealing with the term **[Intelligence](https://en.wikipedia.org/wiki/Intelligence)** is that there is no clear definition of this term. One can argue that intelligence is connected to **abstract thinking**, or to **self-awareness**, but we cannot properly define it.
-
-
-
-> [Photo](https://unsplash.com/photos/75715CVEJhI) by [Amber Kipp](https://unsplash.com/@sadmax) from Unsplash
-
-To see the ambiguity of a term *intelligence*, try answering a question: "Is a cat intelligent?". Different people tend to give different answers to this question, as there is no universally accepted test to prove the assertion is true or not. And if you think there is - try running your cat through an IQ test...
-
-✅ Think for a minute about how you define intelligence. Is a crow who can solve a maze and get at some food intelligent? Is a child intelligent?
-
----
-
-When speaking about AGI we need to have some way to tell if we have created a truly intelligent system. [Alan Turing](https://en.wikipedia.org/wiki/Alan_Turing) proposed a way called a **[Turing Test](https://en.wikipedia.org/wiki/Turing_test)**, which also acts like a definition of intelligence. The test compares a given system to something inherently intelligent - a real human being, and because any automatic comparison can be bypassed by a computer program, we use a human interrogator. So, if a human being is unable to distinguish between a real person and a computer system in text-based dialogue - the system is considered intelligent.
-
-> A chat-bot called [Eugene Goostman](https://en.wikipedia.org/wiki/Eugene_Goostman), developed in St.Petersburg, came close to passing the Turing test in 2014 by using a clever personality trick. It announced up front that it was a 13-year old Ukrainian boy, which would explain the lack of knowledge and some discrepancies in the text. The bot convinced 30% of the judges that it was human after a 5 minute dialogue, a metric that Turing believed a machine would be able to pass by 2000. However, one should understand that this does not indicate that we have created an intelligent system, or that a computer system has fooled the human interrogator - the system didn't fool the humans, but rather the bot creators did!
-
-✅ Have you ever been fooled by a chat bot into thinking that you are speaking to a human? How did it convince you?
-
-## Different Approaches to AI
-
-If we want a computer to behave like a human, we need somehow to model inside a computer our way of thinking. Consequently, we need to try to understand what makes a human being intelligent.
-
-> To be able to program intelligence into a machine, we need to understand how our own processes of making decisions work. If you do a little self-introspection, you will realize that there are some processes that happen subconsciously – eg. we can distinguish a cat from a dog without thinking about it - while some others involve reasoning.
-
-There are two possible approaches to this problem:
-
-Top-down Approach (Symbolic Reasoning) | Bottom-up Approach (Neural Networks)
----------------------------------------|-------------------------------------
-A top-down approach models the way a person reasons to solve a problem. It involves extracting **knowledge** from a human being, and representing it in a computer-readable form. We also need to develop a way to model **reasoning** inside a computer. | A bottom-up approach models the structure of a human brain, consisting of huge number of simple units called **neurons**. Each neuron acts like a weighted average of its inputs, and we can train a network of neurons to solve useful problems by providing **training data**.
-
-There are also some other possible approaches to intelligence:
-
-* An **Emergent**, **Synergetic** or **multi-agent approach** are based on the fact that complex intelligent behaviour can be obtained by an interaction of a large number of simple agents. According to [evolutionary cybernetics](https://en.wikipedia.org/wiki/Global_brain#Evolutionary_cybernetics), intelligence can *emerge* from more simple, reactive behaviour in the process of *metasystem transition*.
-
-* An **Evolutionary approach**, or **genetic algorithm** is an optimization process based on the principles of evolution.
-
-We will consider those approaches later in the course, but right now we will focus on two main directions: top-down and bottom-up.
-
-### The Top-Down Approach
-
-In a **top-down approach**, we try to model our reasoning. Because we can follow our thoughts when we reason, we can try to formalize this process and program it inside the computer. This is called **symbolic reasoning**.
-
-People tend to have some rules in their head that guide their decision making processes. For example, when a doctor is diagnosing a patient, he or she may realize that a person has a fever, and thus there might be some inflammation going on inside the body. By applying a large set of rules to a specific problem a doctor may be able to come up with the final diagnosis.
-
-This approach relies heavily on **knowledge representation** and **reasoning**. Extracting knowledge from a human expert might be the most difficult part, because a doctor in many cases would not know exactly why he or she is coming up with a particular diagnosis. Sometimes the solution just comes up in his or her head without explicit thinking. Some tasks, such as determining the age of a person from a photograph, cannot be at all reduced to manipulating knowledge.
-
-### Bottom-Up Approach
-
-Alternately, we can try to model the simplest elements inside our brain – a neuron. We can construct a so-called **artificial neural network** inside a computer, and then try to teach it to solve problems by giving it examples. This process is similar to how a newborn child learns about his or her surroundings by making observations.
-
-✅ Do a little research on how babies learn. What are the basic elements of a baby's brain?
-
-> | What about ML? | |
-> |--------------|-----------|
-> | Part of Artificial Intelligence that is based on computer learning to solve a problem based on some data is called **Machine Learning**. We will not consider classical machine learning in this course - we refer you to a separate [Machine Learning for Beginners](http://aka.ms/ml-beginners) curriculum. |  |
-
-## A Brief History of AI
-
-Artificial Intelligence was started as a field in the middle of the twentieth century. Initially, symbolic reasoning was a prevalent approach, and it led to a number of important successes, such as expert systems – computer programs that were able to act as an expert in some limited problem domains. However, it soon became clear that such approach does not scale well. Extracting the knowledge from an expert, representing it in a computer, and keeping that knowledgebase accurate turns out to be a very complex task, and too expensive to be practical in many cases. This led to so-called [AI Winter](https://en.wikipedia.org/wiki/AI_winter) in the 1970s.
-
-
-
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
-
-As time passed, computing resources became cheaper, and more data has become available, so neural network approaches started demonstrating great performance in competing with human beings in many areas, such as computer vision or speech understanding. In the last decade, the term Artificial Intelligence has been mostly used as a synonym for Neural Networks, because most of the AI successes that we hear about are based on them.
-
-We can observe how the approaches changed, for example, in creating a chess playing computer program:
-
-* Early chess programs were based on search – a program explicitly tried to estimate possible moves of an opponent for a given number of next moves, and selected an optimal move based on the optimal position that can be achieved in a few moves. It led to the development of the so-called [alpha-beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning) search algorithm.
-* Search strategies work well toward the end of the game, where the search space is limited by a small number of possible moves. However, at the beginning of the game, the search space is huge, and the algorithm can be improved by learning from existing matches between human players. Subsequent experiments employed so-called [case-based reasoning](https://en.wikipedia.org/wiki/Case-based_reasoning), where the program looked for cases in the knowledge base very similar to the current position in the game.
-* Modern programs that win over human players are based on neural networks and [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning), where the programs learn to play solely by playing a long time against themselves and learning from their own mistakes – much like human beings do when learning to play chess. However, a computer program can play many more games in much less time, and thus can learn much faster.
-
-✅ Do a little research on other games that have been played by AI.
-
-Similarly, we can see how the approach towards creating “talking programs” (that might pass the Turing test) changed:
-
-* Early programs of this kind such as [Eliza](https://en.wikipedia.org/wiki/ELIZA), were based on very simple grammatical rules and the re-formulation of the input sentence into a question.
-* Modern assistants, such as Cortana, Siri or Google Assistant are all hybrid systems that use Neural networks to convert speech into text and recognize our intent, and then employ some reasoning or explicit algorithms to perform required actions.
-* In the future, we may expect a complete neural-based model to handle dialogue by itself. The recent GPT and [Turing-NLG](https://turing.microsoft.com/) family of neural networks show great success in this.
-
-
-
-> Image by Dmitry Soshnikov, [photo](https://unsplash.com/photos/r8LmVbUKgns) by [Marina Abrosimova](https://unsplash.com/@abrosimova_marina_foto), Unsplash
-
-## Recent AI Research
-
-The huge recent growth in neural network research started around 2010, when large public datasets started to become available. A huge collection of images called [ImageNet](https://en.wikipedia.org/wiki/ImageNet), which contains around 14 million annotated images, gave birth to the [ImageNet Large Scale Visual Recognition Challenge](https://image-net.org/challenges/LSVRC/).
-
-
-
-> Image by [Dmitry Soshnikov](http://soshnikov.com)
-
-In 2012, [Convolutional Neural Networks](../4-ComputerVision/07-ConvNets/README.md) were first used in image classification, which led to a significant drop in classification errors (from almost 30% to 16.4%). In 2015, ResNet architecture from Microsoft Research [achieved human-level accuracy](https://doi.org/10.1109/ICCV.2015.123).
-
-Since then, Neural Networks demonstrated very successful behaviour in many tasks:
-
----
-
-Year | Human Parity achieved
------|--------
-2015 | [Image Classification](https://doi.org/10.1109/ICCV.2015.123)
-2016 | [Conversational Speech Recognition](https://arxiv.org/abs/1610.05256)
-2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
-2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
-
-Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
-
-## 🚀 Challenge
-
-Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
-
-## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
-
-## Review & Self Study
-
-Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
-
-**Assignment**: [Game Jam](assignment.md)
-from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
-
-**Assignment**: [Game Jam](assignment.md)
-ognition](https://arxiv.org/abs/1610.05256)
-2018 | [Automatic Machine Translation](https://arxiv.org/abs/1803.05567) (Chinese-to-English)
-2020 | [Image Captioning](https://arxiv.org/abs/2009.13682)
-
-Over the past few years we have witnessed huge successes with large language models, such as BERT and GPT-3. This happened mostly due to the fact that there is a lot of general text data available that allows us to train models to capture the structure and meaning of texts, pre-train them on general text collections, and then specialize those models for more specific tasks. We will learn more about [Natural Language Processing](../5-NLP/README.md) later in this course.
-
-## 🚀 Challenge
-
-Do a tour of the internet to determine where, in your opinion, AI is most effectively used. Is it in a Mapping app, or some speech-to-text service or a video game? Research how the system was built.
-
-## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/201)
-
-## Review & Self Study
-
-Review the history of AI and ML by reading through [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Take an element from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
+## Repaso y autoestudio
-**Assignment**: [Game Jam](assignment.md)
-from the sketchnote at the top of that lesson or this one and research it in more depth to understand the cultural context informing its evolution.
+Revise la historia de la IA y el ML leyendo [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/2-history-of-ML). Toma un elemento de la nota de boceto en la parte superior de esa lección o de esta otra e investiga con más profundidad para comprender el contexto cultural que informa su evolución.
-**Assignment**: [Game Jam](assignment.md)
+**Assignment**: [Game Jam](assignment.md):
From 328ba5a7cbd554d9c430fd08f792ab1adeb127fd Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 27 Oct 2023 21:42:26 -0400
Subject: [PATCH 03/33] Create README.es.md
---
lessons/2-Symbolic/README.es.md | 1 +
1 file changed, 1 insertion(+)
create mode 100644 lessons/2-Symbolic/README.es.md
diff --git a/lessons/2-Symbolic/README.es.md b/lessons/2-Symbolic/README.es.md
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/lessons/2-Symbolic/README.es.md
@@ -0,0 +1 @@
+
From 64ae42a7d79393598d83decb984d319d6f00951b Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 27 Oct 2023 21:56:58 -0400
Subject: [PATCH 04/33] Update README.es.md
---
lessons/2-Symbolic/README.es.md | 43 +++++++++++++++++++++++++++++++++
1 file changed, 43 insertions(+)
diff --git a/lessons/2-Symbolic/README.es.md b/lessons/2-Symbolic/README.es.md
index 8b137891..e4fef1f5 100644
--- a/lessons/2-Symbolic/README.es.md
+++ b/lessons/2-Symbolic/README.es.md
@@ -1 +1,44 @@
+# Representación del Conocimiento y Sistemas Expertos
+
+
+> Sketchnote by [Tomomi Imura](https://twitter.com/girlie_mac)
+
+La búsqueda de la inteligencia artificial se basa en una búsqueda de conocimiento, para dar sentido al mundo de forma similar a como lo hacen los humanos. Pero, ¿cómo se puede hacer esto?
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/102)
+
+En los primeros días de la IA, el enfoque de arriba hacia abajo para crear sistemas inteligentes (discutido en la lección anterior) era popular. La idea era extraer el conocimiento de las personas en una forma legible por máquina y luego usarlo para resolver problemas automáticamente. Este enfoque se basó en dos grandes ideas:
+
+* Representación del conocimiento
+*Razonamiento
+
+## Representación del conocimiento
+
+Uno de los conceptos importantes en la IA simbólica es el **conocimiento**. Es importante diferenciar el conocimiento de la *información* o los *datos*. Por ejemplo, se puede decir que los libros contienen conocimiento, porque uno puede estudiar libros y convertirse en un experto. Sin embargo, lo que contienen los libros en realidad se llama *datos*, y al leer libros e integrar estos datos en nuestro modelo de mundo, convertimos estos datos en conocimiento.
+
+> ✅ **El conocimiento** es algo que está contenido en nuestra cabeza y representa nuestra comprensión del mundo. Se obtiene mediante un proceso activo de **aprendizaje**, que integra piezas de información que recibimos en nuestro modelo activo del mundo.
+
+La mayoría de las veces, no definimos estrictamente el conocimiento, sino que lo alineamos con otros conceptos relacionados utilizando [DIKW Pyramid](https://en.wikipedia.org/wiki/DIKW_pyramid).Contiene los siguientes conceptos:
+
+* **Datos** es algo representado en medios físicos, como texto escrito o palabras habladas. Los datos existen independientemente de los seres humanos y pueden transmitirse entre personas.
+* **Información** es la forma en que interpretamos los datos en nuestra cabeza. Por ejemplo, cuando escuchamos la palabra *computadora*, tenemos cierta comprensión de lo que es.
+* **Conocimiento** es información que se integra en nuestro modelo de mundo. Por ejemplo, una vez que aprendemos lo que es una computadora, empezamos a tener algunas ideas sobre cómo funciona, cuánto cuesta y para qué se puede utilizar. Esta red de conceptos interrelacionados forma nuestro conocimiento.
+* **Sabiduría** es un nivel más de nuestra comprensión del mundo, y representa *meta-conocimiento*, por ejemplo. alguna noción sobre cómo y cuándo se debe utilizar el conocimiento.
+
+ 
+
+*Image [from Wikipedia](https://commons.wikimedia.org/w/index.php?curid=37705247), By Longlivetheux - Own work, CC BY-SA 4.0*
+
+Por lo tanto, el problema de la **representación del conocimiento** es encontrar alguna forma efectiva de representar el conocimiento dentro de una computadora en forma de datos, para que sea utilizable automáticamente. Esto se puede ver como un espectro:
+
+
+
+> Image by [Dmitry Soshnikov](http://soshnikov.com)
+
+* A la izquierda, hay tipos muy simples de representaciones de conocimiento que pueden ser utilizadas de manera efectiva por las computadoras. La más simple es la algorítmica, cuando el conocimiento está representado por un programa informático. Esta, sin embargo, no es la mejor manera de representar el conocimiento, porque no es flexible. El conocimiento dentro de nuestra cabeza a menudo no es algorítmico.
+* A la derecha, hay representaciones como texto natural. Es el más poderoso, pero no se puede usar para el razonamiento automático.
+
+> ✅ Piensa por un minuto en cómo representas el conocimiento en tu cabeza y conviértelo en notas. ¿Hay algún formato en particular que funcione bien para ayudar en la retención?
+
+## Clasificación de representaciones de conocimiento informático
From 41f10f71d2d4e0d53c99c84e6c96aa5e786e6f7d Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sat, 6 Jan 2024 20:37:51 -0500
Subject: [PATCH 05/33] Create README.es.md
---
lessons/3-NeuralNetworks/README.es.md | 46 +++++++++++++++++++++++++++
1 file changed, 46 insertions(+)
create mode 100644 lessons/3-NeuralNetworks/README.es.md
diff --git a/lessons/3-NeuralNetworks/README.es.md b/lessons/3-NeuralNetworks/README.es.md
new file mode 100644
index 00000000..1090083a
--- /dev/null
+++ b/lessons/3-NeuralNetworks/README.es.md
@@ -0,0 +1,46 @@
+# Introducción a las Redes Neuronales
+
+![Summary of Intro Neural Networks content in a doodle]
+
+Como comentamos en la introducción, una de las formas de lograr inteligencia es entrenar un **modelo de computadora** o un **cerebro artificial**. Desde mediados del siglo XX, los investigadores probaron diferentes modelos matemáticos, hasta que en los últimos años esta tendencia resultó tener un gran éxito. Estos modelos matemáticos del cerebro se denominan **redes neuronales**.
+
+> A veces las redes neuronales se denominan *Redes Neuronales Artificiales*, RNA, para indicar que estamos hablando de modelos, no de redes reales de neuronas.
+
+## Aprendizaje automático
+
+Las redes neuronales son parte de una disciplina más amplia llamada **Aprendizaje automático**, cuyo objetivo es utilizar datos para entrenar modelos informáticos que sean capaces de resolver problemas. El aprendizaje automático constituye una gran parte de la inteligencia artificial; sin embargo, no cubrimos el aprendizaje automático clásico en este plan de estudios.
+> Visite nuestro plan de estudios separado **[Aprendizaje automático para principiantes](http://github.com/microsoft/ml-for-beginners)** para obtener más información sobre el aprendizaje automático clásico.
+
+En Machine Learning, asumimos que tenemos algún conjunto de datos de ejemplos **X** y los valores de salida correspondientes **Y**. Los ejemplos suelen ser vectores de N dimensiones que constan de **características** y las salidas se denominan **etiquetas**.
+
+Consideraremos los dos problemas de aprendizaje automático más comunes:
+
+* **Clasificación**, donde necesitamos clasificar un objeto de entrada en dos o más clases.
+* **Regresión**, donde necesitamos predecir un número numérico para cada una de las muestras de entrada.
+
+> Al representar entradas y salidas como tensores, el conjunto de datos de entrada es una matriz de tamaño M×N, donde M es el número de muestras y N es el número de características. Las etiquetas de salida Y es el vector de tamaño M.
+
+En este plan de estudios, sólo nos centraremos en los modelos de redes neuronales.
+
+## Un modelo de neurona
+Por la biología sabemos que nuestro cerebro está formado por células neuronales, cada una de las cuales tiene múltiples "entradas" (axones) y una salida (dendritas). Los axones y las dendritas pueden conducir señales eléctricas, y las conexiones entre axones y dendritas pueden exhibir diferentes grados de conductividad (controladas por neuromediadores).
+
+ | 
+----|----
+*([Image](https://en.wikipedia.org/wiki/Synapse#/media/File:SynapseSchematic_lines.svg) from Wikipedia)* | Artificial Neuron *(Image by Author)*
+
+Así, el modelo matemático más simple de una neurona contiene varias entradas X1, ..., XN y una salida Y, y una serie de pesos W1. , ..., WN. Una salida se calcula como:
+
+
+
+donde f es alguna **función de activación** no lineal.
+
+> Los primeros modelos de neuronas se describieron en el artículo clásico [A logical calculus of the ideas immanent in nervous activity](http://www.springerlink.com/content/61446605110620kg/fulltext.pdf) de Warren McCullock y Walter Pitts en 1943. Donald Hebb en su libro "[The Organization of Behavior: A Neuropsychological Theory](https://books.google.com/books?id=VNetYrB8EBoC)" propuso la forma en que se pueden entrenar esas redes.
+
+## En esta sección
+
+En esta sección aprenderemos sobre:
+* [Perceptron](03-Perceptron/README.md), uno de los primeros modelos de redes neuronales para la clasificación de dos clases
+* [Multi-layered networks](04-OwnFramework/README.md) con un cuaderno emparejado [how to build our own framework](04-OwnFramework/OwnFramework.ipynb)
+* [Neural Network Frameworks](05-Frameworks/README.md), con estos cuadernos: [PyTorch](05-Frameworks/IntroPyTorch.ipynb) y [Keras/Tensorflow](05-Frameworks/IntroKerasTF.ipynb)
+* [Overfitting](05-Frameworks/Overfitting.md)
From 50bc1d16cb1c5a1bf76a8a50317a5e395127a11a Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sat, 6 Jan 2024 20:43:19 -0500
Subject: [PATCH 06/33] Create README.es.md
---
lessons/4-ComputerVision/README.es.md | 13 +++++++++++++
1 file changed, 13 insertions(+)
create mode 100644 lessons/4-ComputerVision/README.es.md
diff --git a/lessons/4-ComputerVision/README.es.md b/lessons/4-ComputerVision/README.es.md
new file mode 100644
index 00000000..60781549
--- /dev/null
+++ b/lessons/4-ComputerVision/README.es.md
@@ -0,0 +1,13 @@
+# Visión por computador
+
+
+
+En esta sección aprenderemos sobre:
+
+* [Intro to Computer Vision and OpenCV](06-IntroCV/README.md)
+* [Convolutional Neural Networks](07-ConvNets/README.md)
+* [Pre-trained Networks and Transfer Learning](08-TransferLearning/README.md)
+* [Autoencoders](09-Autoencoders/README.md)
+* [Generative Adversarial Networks](10-GANs/README.md)
+* [Object Detection](11-ObjectDetection/README.md)
+* [Semantic Segmentation](12-Segmentation/README.md)
From bf3fd6e6b2e9f2ee11554e46fffd29f1083c3437 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sat, 6 Jan 2024 21:07:13 -0500
Subject: [PATCH 07/33] Create README.es.md
---
.../03-Perceptron/README.es.md | 93 +++++++++++++++++++
1 file changed, 93 insertions(+)
create mode 100644 lessons/3-NeuralNetworks/03-Perceptron/README.es.md
diff --git a/lessons/3-NeuralNetworks/03-Perceptron/README.es.md b/lessons/3-NeuralNetworks/03-Perceptron/README.es.md
new file mode 100644
index 00000000..8f8884b6
--- /dev/null
+++ b/lessons/3-NeuralNetworks/03-Perceptron/README.es.md
@@ -0,0 +1,93 @@
+# Introducción a las redes neuronales: perceptrón
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/103)
+
+Uno de los primeros intentos de implementar algo similar a una red neuronal moderna lo realizó Frank Rosenblatt del Laboratorio Aeronáutico de Cornell en 1957. Se trataba de una implementación de hardware llamada "Mark-1", diseñada para reconocer figuras geométricas primitivas, como triángulos, cuadrados. y círculos.
+
+| | |
+|--------------|-----------|
+|
| 
|
+
+> Images [from Wikipedia](https://en.wikipedia.org/wiki/Perceptron)
+
+Una imagen de entrada estaba representada por una matriz de fotocélulas de 20x20, por lo que la red neuronal tenía 400 entradas y una salida binaria. Una red simple contenía una neurona, también llamada **unidad lógica de umbral**. Los pesos de las redes neuronales actuaron como potenciómetros que requirieron ajuste manual durante la fase de entrenamiento.
+
+> ✅ Un potenciómetro es un dispositivo que permite al usuario ajustar la resistencia de un circuito.
+
+> El New York Times escribió en aquella época sobre el perceptrón: *el embrión de una computadora electrónica que [la Marina] espera que pueda caminar, hablar, ver, escribir, reproducirse y ser consciente de su existencia.*
+
+## Modelo de perceptrón
+
+Supongamos que tenemos N características en nuestro modelo, en cuyo caso el vector de entrada sería un vector de tamaño N. Un perceptrón es un modelo de **clasificación binaria**, es decir, puede distinguir entre dos clases de datos de entrada. Supondremos que para cada vector de entrada x la salida de nuestro perceptrón sería +1 o -1, dependiendo de la clase. La salida se calculará mediante la fórmula:
+
+y(x) = f(wTx)
+
+donde f es una función de activación escalonada
+
+
+
+
+## Entrenando el perceptrón
+
+Para entrenar un perceptrón necesitamos encontrar un vector de pesos w que clasifique la mayoría de los valores correctamente, es decir, que dé como resultado el **error** más pequeño. Este error se define mediante el **criterio de perceptrón** de la siguiente manera:
+
+E(w) = -∑wTxiti
+
+dónde:
+
+* la suma se toma de aquellos puntos de datos de entrenamiento i que resultan en una clasificación incorrecta
+* xi son los datos de entrada y ti es -1 o +1 para ejemplos negativos y positivos, respectivamente.
+
+Este criterio se considera en función de los pesos w y debemos minimizarlo. A menudo, se utiliza un método llamado **descenso de gradiente**, en el que comenzamos con algunos pesos iniciales w(0) y luego, en cada paso, actualizamos los pesos de acuerdo con la fórmula:
+
+w(t+1) = w(t) - η∇E(w)
+
+Aquí η es la llamada **tasa de aprendizaje**, y ∇E(w) denota el **gradiente** de E. Después de calcular el gradiente, terminamos con
+
+w(t+1) = w(t) + ∑ηxiti
+
+El algoritmo en Python se ve así:
+
+```python
+def train(positive_examples, negative_examples, num_iterations = 100, eta = 1):
+
+ weights = [0,0,0] # Initialize weights (almost randomly :)
+
+ for i in range(num_iterations):
+ pos = random.choice(positive_examples)
+ neg = random.choice(negative_examples)
+
+ z = np.dot(pos, weights) # compute perceptron output
+ if z < 0: # positive example classified as negative
+ weights = weights + eta*weights.shape
+
+ z = np.dot(neg, weights)
+ if z >= 0: # negative example classified as positive
+ weights = weights - eta*weights.shape
+
+ return weights
+```
+
+## Conclusión
+
+En esta lección, aprendió sobre un perceptrón, que es un modelo de clasificación binaria, y cómo entrenarlo usando un vector de pesos.
+
+## 🚀 Desafío
+
+Si desea intentar construir su propio perceptrón, intente [this lab on Microsoft Learn](https://docs.microsoft.com/en-us/azure/machine-learning/component-reference/two-class-averaged-perceptron?WT.mc_id=academic-77998-cacaste) que utiliza el [Azure ML designer](https://docs.microsoft.com/en-us/azure/machine-learning/concept-designer?WT.mc_id=academic-77998-cacaste).
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/203)
+
+## Revisión y autoestudio
+
+Para ver cómo podemos usar el perceptrón para resolver un problema de juguete, así como problemas de la vida real, y continuar aprendiendo, vaya a [Perceptron](Perceptron.ipynb) notebook.
+
+Aquí hay un interesante [article about perceptrons](https://towardsdatascience.com/what-is-a-perceptron-basics-of-neural-networks-c4cfea20c590
+) también.
+
+## [Assignment](lab/README.md)
+
+En esta lección, hemos implementado un perceptrón para tareas de clasificación binaria y lo hemos usado para clasificar entre dos dígitos escritos a mano. En esta práctica de laboratorio, se le pedirá que resuelva por completo el problema de clasificación de dígitos, es decir, que determine qué dígito tiene más probabilidades de corresponder a una imagen determinada.
+
+* [Instructions](lab/README.md)
+* [Notebook](lab/PerceptronMultiClass.ipynb)
From c0cecaed4f5b5fd4dfbe5c51f0ebb1ffc1b84bed Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sat, 6 Jan 2024 21:16:34 -0500
Subject: [PATCH 08/33] Create README.es.md
---
.../04-OwnFramework/README.es.md | 86 +++++++++++++++++++
1 file changed, 86 insertions(+)
create mode 100644 lessons/3-NeuralNetworks/04-OwnFramework/README.es.md
diff --git a/lessons/3-NeuralNetworks/04-OwnFramework/README.es.md b/lessons/3-NeuralNetworks/04-OwnFramework/README.es.md
new file mode 100644
index 00000000..90978d2b
--- /dev/null
+++ b/lessons/3-NeuralNetworks/04-OwnFramework/README.es.md
@@ -0,0 +1,86 @@
+# Introducción a las Redes Neuronales. Perceptrón multicapa
+
+En la sección anterior, aprendió sobre el modelo de red neuronal más simple: el perceptrón de una capa, un modelo de clasificación lineal de dos clases.
+
+En esta sección ampliaremos este modelo a un marco más flexible, lo que nos permitirá:
+
+* realizar **clasificación multiclase** además de dos clases
+* resolver **problemas de regresión** además de clasificación
+* clases separadas que no son linealmente separables
+
+También desarrollaremos nuestro propio framework modular en Python que nos permitirá construir diferentes arquitecturas de redes neuronales.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/104)
+
+## Formalización del aprendizaje automático
+
+Comencemos por formalizar el problema del aprendizaje automático. Supongamos que tenemos un conjunto de datos de entrenamiento **X** con etiquetas **Y** y necesitamos crear un modelo *f* que haga las predicciones más precisas. La calidad de las predicciones se mide mediante la **Función de pérdida** ℒ. A menudo se utilizan las siguientes funciones de pérdida:
+
+* Para problemas de regresión, cuando necesitamos predecir un número, podemos usar **error absoluto** ∑i|f(x(i))-y< sup>(i)|, o **error al cuadrado** ∑i(f(x(i))-y(i ))2
+* Para la clasificación, utilizamos **pérdida 0-1** (que es esencialmente lo mismo que **precisión** del modelo) o **pérdida logística**.
+
+Para el perceptrón de un nivel, la función *f* se definió como una función lineal *f(x)=wx+b* (aquí *w* es la matriz de peso, *x* es el vector de características de entrada y *b* es el vector de sesgo). Para diferentes arquitecturas de redes neuronales, esta función puede adoptar una forma más compleja.
+
+> En el caso de la clasificación, a menudo es deseable obtener probabilidades de las clases correspondientes como salida de la red. Para convertir números arbitrarios en probabilidades (por ejemplo, para normalizar la salida), a menudo usamos la función **softmax** γ, y la función *f* se convierte en *f(x)=γsigma;(wx+b)*
+
+En la definición de *f* anterior, *w* y *b* se denominan **parámetros** θ=⟨*w,b*⟩. Dado el conjunto de datos ⟨**X**,**Y**⟩, podemos calcular un error general en todo el conjunto de datos en función de los parámetros θ.
+
+> ✅ **El objetivo del entrenamiento de redes neuronales es minimizar el error variando los parámetros θ**
+
+## Optimización del descenso de gradiente
+
+Existe un método bien conocido de optimización de funciones llamado **descenso de gradiente**. La idea es que podemos calcular una derivada (en el caso multidimensional llamada **gradiente**) de la función de pérdida con respecto a los parámetros y variar los parámetros de tal manera que el error disminuya. Esto se puede formalizar de la siguiente manera:
+
+* Inicializa los parámetros con algunos valores aleatorios w(0), b(0)
+*Repetir el siguiente paso muchas veces:
+ - w(i+1) = w(i)-η∂ℒ/∂w
+ - b(i+1) = b(i)-η∂ℒ/∂b
+
+Durante el entrenamiento, se supone que los pasos de optimización se calculan considerando todo el conjunto de datos (recuerde que la pérdida se calcula como una suma de todas las muestras de entrenamiento). Sin embargo, en la vida real tomamos pequeñas porciones del conjunto de datos llamados **minilotes** y calculamos gradientes en función de un subconjunto de datos. Debido a que el subconjunto se toma aleatoriamente cada vez, dicho método se denomina **descenso de gradiente estocástico** (SGD).
+
+## Perceptrones multicapa y retropropagación
+
+La red de una capa, como hemos visto anteriormente, es capaz de clasificar clases linealmente separables. Para construir un modelo más rico, podemos combinar varias capas de la red. Matemáticamente significaría que la función *f* tendría una forma más compleja y se calcularía en varios pasos:
+* z1=w1x+b1
+* z2=w2α(z1)+b2
+* f = σ(z2)
+
+Aquí, &alfa; es una **función de activación no lineal**, σ es una función softmax y los parámetros θ=<*w1,b1,w2,b2*>.
+
+El algoritmo de descenso de gradientes seguiría siendo el mismo, pero sería más difícil calcular los gradientes. Dada la regla de diferenciación de cadenas, podemos calcular las derivadas como:
+
+* ∂ℒ/∂w2 = (∂ℒ/∂σ)(∂σ/∂z2)(∂ z2/∂w2)
+* ∂ℒ/∂w1 = (∂ℒ/∂σ)(∂σ/∂z2)(∂ z2/∂α)(∂α/∂z1)(∂z1/∂w< sub>1)
+
+> ✅ La regla de diferenciación de cadenas se utiliza para calcular las derivadas de la función de pérdida con respecto a los parámetros.
+
+Tenga en cuenta que la parte más a la izquierda de todas esas expresiones es la misma y, por lo tanto, podemos calcular derivadas de manera efectiva comenzando desde la función de pérdida y yendo "hacia atrás" a través del gráfico computacional. Por lo tanto, el método de entrenamiento de un perceptrón de múltiples capas se llama **backpropagation** o 'backprop'.
+
+
+
+> TODO: cita de imagen
+
+> ✅ Cubriremos el backprop con mucho más detalle en nuestro ejemplo de cuaderno.
+
+## Conclusión
+
+En esta lección, hemos creado nuestra propia biblioteca de redes neuronales y la hemos utilizado para una tarea sencilla de clasificación bidimensional.
+
+## 🚀 Desafío
+
+En el cuaderno adjunto, implementará su propio marco para construir y entrenar perceptrones de múltiples capas. Podrás ver en detalle cómo funcionan las redes neuronales modernas.
+
+Proceder al [OwnFramework](OwnFramework.ipynb) notebook and work through it.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/204)
+
+## Revisión y autoestudio
+
+La retropropagación es un algoritmo común utilizado en IA y ML que vale la pena estudiar [in more detail](https://wikipedia.org/wiki/Backpropagation)
+
+## [Assignment](lab/README.md)
+
+En esta práctica de laboratorio, se le pedirá que utilice el marco que construyó en esta lección para resolver la clasificación de dígitos escritos a mano de MNIST.
+
+* [Instructions](lab/README.md)
+* [Notebook](lab/MyFW_MNIST.ipynb)
From 33fb7f3af1638c546cab77bc533bda402011c95e Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sat, 6 Jan 2024 21:49:52 -0500
Subject: [PATCH 09/33] Create README.es.md
---
.../05-Frameworks/README.es.md | 120 ++++++++++++++++++
1 file changed, 120 insertions(+)
create mode 100644 lessons/3-NeuralNetworks/05-Frameworks/README.es.md
diff --git a/lessons/3-NeuralNetworks/05-Frameworks/README.es.md b/lessons/3-NeuralNetworks/05-Frameworks/README.es.md
new file mode 100644
index 00000000..5ccc504f
--- /dev/null
+++ b/lessons/3-NeuralNetworks/05-Frameworks/README.es.md
@@ -0,0 +1,120 @@
+# Marcos de redes neuronales
+
+Como ya hemos aprendido, para poder entrenar redes neuronales de manera eficiente necesitamos hacer dos cosas:
+
+* Para operar con tensores, por ej. para multiplicar, sumar y calcular algunas funciones como sigmoide o softmax
+* Para calcular los gradientes de todas las expresiones, para realizar la optimización del descenso de gradientes.
+
+ ## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/105)
+
+Si bien la biblioteca `numpy` puede hacer la primera parte, necesitamos algún mecanismo para calcular los gradientes. En [our framework](../04-OwnFramework/OwnFramework.ipynb) que hemos desarrollado en la sección anterior, tuvimos que programar manualmente todas las funciones derivadas dentro del método "hacia atrás", que realiza retropropagación. Idealmente, un marco debería darnos la oportunidad de calcular gradientes de *cualquier expresión* que podamos definir.
+
+Otra cosa importante es poder realizar cálculos en GPU o cualquier otra unidad de cálculo especializada, como [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit).El entrenamiento de redes neuronales profundas requiere *muchos* cálculos, y poder paralelizar esos cálculos en las GPU es muy importante.
+
+> ✅ El término 'paralelizar' significa distribuir los cálculos en múltiples dispositivos.
+
+Actualmente, los dos marcos neuronales más populares son: [TensorFlow](http://TensorFlow.org) y [PyTorch](https://pytorch.org/). Ambos proporcionan una API de bajo nivel para operar con tensores tanto en CPU como en GPU. Además de la API de bajo nivel, también existe una API de nivel superior, llamada [Keras](https://keras.io/) y [PyTorch Lightning](https://pytorchlightning.ai/) correspondientemente.
+
+API de bajo nivel | [TensorFlow](http://TensorFlow.org) | [PyTorch](https://pytorch.org/)
+--------------|-------------------------------------|--------------------------------
+API de alto nivel| [Keras](https://keras.io/) | [PyTorch Lightning](https://pytorchlightning.ai/)
+
+Las **API de bajo nivel** en ambos marcos le permiten crear los llamados **gráficos computacionales**. Este gráfico define cómo calcular la salida (normalmente la función de pérdida) con parámetros de entrada determinados y se puede enviar para su cálculo en la GPU, si está disponible. Hay funciones para diferenciar este gráfico computacional y calcular gradientes, que luego se pueden usar para optimizar los parámetros del modelo.
+
+Las **API de alto nivel** consideran las redes neuronales como una **secuencia de capas** y facilitan mucho la construcción de la mayoría de las redes neuronales. Entrenar el modelo generalmente requiere preparar los datos y luego llamar a una función "adecuada" para hacer el trabajo.
+
+La API de alto nivel le permite construir redes neuronales típicas muy rápidamente sin preocuparse por muchos detalles. Al mismo tiempo, las API de bajo nivel ofrecen mucho más control sobre el proceso de entrenamiento y, por lo tanto, se utilizan mucho en la investigación cuando se trata de nuevas arquitecturas de redes neuronales.
+
+También es importante comprender que puede utilizar ambas API juntas, por ejemplo. puede desarrollar su propia arquitectura de capa de red utilizando API de bajo nivel y luego usarla dentro de la red más grande construida y entrenada con API de alto nivel. O puede definir una red utilizando la API de alto nivel como una secuencia de capas y luego usar su propio bucle de entrenamiento de bajo nivel para realizar la optimización. Ambas API utilizan los mismos conceptos básicos subyacentes y están diseñadas para funcionar bien juntas.
+
+## Aprendiendo
+
+En este curso, ofrecemos la mayor parte del contenido tanto para PyTorch como para TensorFlow. Puedes elegir tu marco preferido y solo revisar los cuadernos correspondientes. Si no está seguro de qué marco elegir, lea algunas discusiones en Internet sobre **PyTorch vs. TensorFlow**. También puede echar un vistazo a ambos marcos para comprender mejor.
+
+Siempre que sea posible, utilizaremos API de alto nivel para simplificar. Sin embargo, creemos que es importante comprender cómo funcionan las redes neuronales desde cero, por lo que al principio comenzamos trabajando con API y tensores de bajo nivel. Sin embargo, si desea comenzar rápidamente y no quiere perder mucho tiempo aprendiendo estos detalles, puede omitirlos e ir directamente a los cuadernos de API de alto nivel.
+
+## ✍️ Ejercicios: Marcos
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+API de bajo nivel | [TensorFlow+Keras Notebook](IntroKerasTF.ipynb) | [PyTorch](IntroPyTorch.ipynb)
+--------------|-------------------------------------|--------------------------------
+API de alto nivel| [Keras](IntroKeras.ipynb) | *PyTorch Lightning*
+
+Después de dominar los marcos, recapitulemos la noción de sobreajuste.
+
+# Sobreajuste
+
+El sobreajuste es un concepto extremadamente importante en el aprendizaje automático y es muy importante hacerlo bien.
+
+Considere el siguiente problema de aproximar 5 puntos (representado por "x" en los gráficos siguientes):
+
+ | 
+-------------------------|--------------------------
+**Modelo lineal, 2 parámetros** | **Modelo no lineal, 7 parámetros**
+Error de entrenamiento = 5,3 | Error de entrenamiento = 0
+Error de validación = 5.1 | Error de validación = 20
+
+* A la izquierda vemos una buena aproximación en línea recta. Debido a que el número de parámetros es adecuado, el modelo capta correctamente la idea detrás de la distribución de puntos.
+* A la derecha, el modelo es demasiado poderoso. Debido a que solo tenemos 5 puntos y el modelo tiene 7 parámetros, se puede ajustar de tal manera que pase por todos los puntos, lo que hace que el error de entrenamiento sea 0. Sin embargo, esto impide que el modelo comprenda el patrón correcto detrás de los datos, por lo que el error de validación es muy alto.
+
+Es muy importante lograr un equilibrio correcto entre la riqueza del modelo (número de parámetros) y el número de muestras de entrenamiento.
+
+## ¿Por qué ocurre el sobreajuste?
+
+ * No hay suficientes datos de entrenamiento
+ * Modelo demasiado potente
+ * Demasiado ruido en los datos de entrada
+
+## Cómo detectar el sobreajuste
+
+Como puede ver en el gráfico anterior, el sobreajuste se puede detectar mediante un error de entrenamiento muy bajo y un error de validación alto. Normalmente, durante el entrenamiento, veremos que tanto los errores de entrenamiento como los de validación comienzan a disminuir y luego, en algún momento, el error de validación puede dejar de disminuir y comenzar a aumentar. Esto será una señal de sobreajuste y el indicador de que probablemente deberíamos dejar de entrenar en este punto (o al menos tomar una instantánea del modelo).
+
+
+
+## Cómo prevenir el sobreajuste
+
+Si puede ver que se produce un sobreajuste, puede realizar una de las siguientes acciones:
+
+ * Aumentar la cantidad de datos de entrenamiento.
+ * Disminuir la complejidad del modelo.
+ * Usa algo [regularization technique](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md), como [Dropout](../../4-ComputerVision/08-TransferLearning/TrainingTricks.md#Dropout), lo que consideraremos más adelante.
+
+## Compensación entre sobreajuste y sesgo-varianza
+
+El sobreajuste es en realidad un caso de un problema más genérico en estadística llamado [Bias-Variance Tradeoff](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff). Si consideramos las posibles fuentes de error en nuestro modelo, podemos ver dos tipos de errores:
+
+* **Los errores de sesgo** se deben a que nuestro algoritmo no puede capturar correctamente la relación entre los datos de entrenamiento. Puede deberse al hecho de que nuestro modelo no es lo suficientemente potente (**underfitting**).
+* **Errores de varianza**, que se deben a que el modelo aproxima el ruido en los datos de entrada en lugar de una relación significativa (**sobreajuste**).
+
+Durante el entrenamiento, el error de sesgo disminuye (a medida que nuestro modelo aprende a aproximar los datos) y el error de varianza aumenta. Es importante detener el entrenamiento, ya sea manualmente (cuando detectamos un sobreajuste) o automáticamente (al introducir la regularización), para evitar el sobreajuste.
+
+## Conclusión
+
+En esta lección, aprendió sobre las diferencias entre las distintas API para los dos marcos de IA más populares, TensorFlow y PyTorch. Además, aprendiste sobre un tema muy importante, el sobreajuste.
+
+## 🚀 Desafío
+
+En los cuadernos adjuntos encontrará "tareas" en la parte inferior; Trabajar en los cuadernos y completar las tareas.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/205)
+
+## Revisión y autoestudio
+
+Investiga un poco sobre los siguientes temas:
+
+- TensorFlow
+-PyTorch
+- Sobreajuste
+
+Pregúntate a ti mismo las siguientes preguntas:
+
+- ¿Cuál es la diferencia entre TensorFlow y PyTorch?
+- ¿Cuál es la diferencia entre sobreajuste y desajuste?
+
+ ## [Assignment](lab/README.md)
+
+En esta práctica de laboratorio, se le pedirá que resuelva dos problemas de clasificación utilizando redes completamente conectadas de una o varias capas utilizando PyTorch o TensorFlow.
+
+* [Instructions](lab/README.md)
+* [Notebook](lab/LabFrameworks.ipynb)
From 6cff8a3eb76afc8e842d3851a16fc822646c21ab Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 20:42:22 -0500
Subject: [PATCH 10/33] Create README.es.md
---
.../4-ComputerVision/06-IntroCV/README.es.md | 109 ++++++++++++++++++
1 file changed, 109 insertions(+)
create mode 100644 lessons/4-ComputerVision/06-IntroCV/README.es.md
diff --git a/lessons/4-ComputerVision/06-IntroCV/README.es.md b/lessons/4-ComputerVision/06-IntroCV/README.es.md
new file mode 100644
index 00000000..02a68634
--- /dev/null
+++ b/lessons/4-ComputerVision/06-IntroCV/README.es.md
@@ -0,0 +1,109 @@
+# Introducción a la visión por computadora
+
+[Computer Vision](https://wikipedia.org/wiki/Computer_vision) es una disciplina cuyo objetivo es permitir que las computadoras obtengan un alto nivel de comprensión de las imágenes digitales. Esta es una definición bastante amplia, porque *comprender* puede significar muchas cosas diferentes, incluyendo encontrar un objeto en una imagen (**detección de objetos**), comprender lo que está sucediendo (**detección de eventos**), describir una imagen en texto o reconstruir una escena en 3D. También hay tareas especiales relacionadas con imágenes humanas: estimación de edad y emociones, detección e identificación de rostros y estimación de pose 3D, por nombrar algunas.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/106)
+
+Una de las tareas más simples de la visión por computadora es la **clasificación de imágenes**.
+
+La visión por computadora a menudo se considera una rama de la IA. Hoy en día, la mayoría de las tareas de visión por computadora se resuelven mediante redes neuronales. Aprenderemos más sobre el tipo especial de redes neuronales utilizadas para la visión por computadora, [convolutional neural networks](../07-ConvNets/README.md), a lo largo de esta sección.
+
+Sin embargo, antes de pasar la imagen a una red neuronal, en muchos casos tiene sentido utilizar algunas técnicas algorítmicas para mejorar la imagen.
+
+Hay varias bibliotecas de Python disponibles para el procesamiento de imágenes:
+
+* **[imageio](https://imageio.readthedocs.io/en/stable/)** se puede utilizar para leer/escribir diferentes formatos de imagen. También es compatible con ffmpeg, una herramienta útil para convertir fotogramas de vídeo en imágenes.
+* **[Pillow](https://pillow.readthedocs.io/en/stable/index.html)** (también conocido como PIL) es un poco más potente y también admite algunas manipulaciones de imágenes, como transformación, ajustes de paleta y más.
+* **[OpenCV](https://opencv.org/)** es una potente biblioteca de procesamiento de imágenes escrita en C++, que se ha convertido en el estándar *de facto* para el procesamiento de imágenes. Tiene una cómoda interfaz Python.
+* **[dlib](http://dlib.net/)** es una biblioteca de C++ que implementa muchos algoritmos de aprendizaje automático, incluidos algunos de los algoritmos de visión por computadora. También tiene una interfaz Python y se puede utilizar para tareas desafiantes como la detección de rostros y puntos de referencia faciales.
+
+## OpenCV
+
+[OpenCV](https://opencv.org/) se considera el estándar *de facto* para el procesamiento de imágenes. Contiene muchos algoritmos útiles, implementados en C++. También puedes llamar a OpenCV desde Python.
+
+Un buen lugar para aprender OpenCV es [this Learn OpenCV course](https://learnopencv.com/getting-started-with-opencv/). En nuestro plan de estudios, nuestro objetivo no es aprender OpenCV, sino mostrarle algunos ejemplos de cuándo se puede utilizar y cómo.
+
+### Cargando imágenes
+
+Las imágenes en Python se pueden representar convenientemente mediante matrices NumPy. Por ejemplo, las imágenes en escala de grises con un tamaño de 320x200 píxeles se almacenarían en una matriz de 200x320, y las imágenes en color de la misma dimensión tendrían una forma de 200x320x3 (para 3 canales de color). Para cargar una imagen, puede utilizar el siguiente código:
+
+```python
+import cv2
+import matplotlib.pyplot as plt
+
+im = cv2.imread('image.jpeg')
+plt.imshow(im)
+```
+
+Tradicionalmente, OpenCV usos Codificación BGR (Azul-Verde-Rojo) para imágenes en color, mientras que el resto de herramientas de Python utilizan la más tradicional RGB (Rojo-Verde-Azul). Para que la imagen se vea bien, debe convertirla al espacio de color RGB, ya sea intercambiando dimensiones en la matriz NumPy o llamando a una función OpenCV:
+
+```python
+im = cv2.cvtColor(im,cv2.COLOR_BGR2RGB)
+```
+
+La misma `cvtColor` La función se puede utilizar para realizar otras transformaciones del espacio de color, como convertir una imagen a escala de grises o al espacio de color HSV (Tono-Saturación-Valor).
+
+También puede utilizar OpenCV para cargar vídeo fotograma a fotograma; en el ejercicio se proporciona un ejemplo [OpenCV Notebook](OpenCV.ipynb).
+
+### Procesamiento de imágenes
+
+Antes de enviar una imagen a una red neuronal, es posible que desee aplicar varios pasos de preprocesamiento.
+
+* **Resizing** la imagen usando `im = cv2.resize(im, (320,200),interpolation=cv2.INTER_LANCZOS)`
+* **Blurring** la imagen usando `im = cv2.medianBlur(im,3)` o `im = cv2.GaussianBlur(im, (3,3), 0)`
+* Se puede cambiar el **brillo y contraste** de la imagen mediante manipulaciones de matriz NumPy, como se describe [in this Stackoverflow note](https://stackoverflow.com/questions/39308030/how-do-i-increase-the-contrast-of-an-image-in-python-opencv).
+* Usando [thresholding](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) llamando `cv2.threshold`/`cv2.adaptiveThreshold` funciones, lo que a menudo es preferible a ajustar el brillo o el contraste.
+* Aplicando diferentes [transformations](https://docs.opencv.org/4.5.5/da/d6e/tutorial_py_geometric_transformations.html) a la imagen:
+ - **[Affine transformations](https://docs.opencv.org/4.5.5/d4/d61/tutorial_warp_affine.html)** Puede resultar útil si necesita combinar rotación, cambio de tamaño e inclinación de la imagen y conoce la ubicación de origen y destino de tres puntos de la imagen. Las transformaciones afines mantienen las líneas paralelas paralelas.
+ - **[Perspective transformations](https://medium.com/analytics-vidhya/opencv-perspective-transformation-9edffefb2143)** Puede resultar útil cuando conoce las posiciones de origen y destino de 4 puntos en la imagen. Por ejemplo, si toma una fotografía de un documento rectangular con la cámara de un teléfono inteligente desde algún ángulo y desea crear una imagen rectangular del documento en sí.
+* Comprender el movimiento dentro de la imagen mediante el uso **[optical flow](https://docs.opencv.org/4.5.5/d4/dee/tutorial_optical_flow.html)**.
+
+## Ejemplos de uso de la visión por computadora
+
+En nuestro [OpenCV Notebook](OpenCV.ipynb), damos algunos ejemplos de cuándo se puede utilizar la visión por computadora para realizar tareas específicas:
+
+* **Preprocesamiento de una fotografía de un libro Braille**. Nos centramos en cómo podemos utilizar umbrales, detección de características, transformación de perspectiva y manipulaciones NumPy para separar símbolos Braille individuales para su posterior clasificación mediante una red neuronal.
+
+ |  | 
+----|-----|-----
+
+> Imagen de [OpenCV.ipynb](OpenCV.ipynb)
+
+* **Detección de movimiento en video usando diferencia de fotogramas**. Si la cámara está fija, los fotogramas de la cámara deberían ser bastante similares entre sí. Dado que los fotogramas se representan como matrices, simplemente restando esas matrices para dos fotogramas posteriores obtendremos la diferencia de píxeles, que debería ser baja para fotogramas estáticos y aumentar una vez que haya un movimiento sustancial en la imagen.
+
+
+
+> Imagen de [OpenCV.ipynb](OpenCV.ipynb)
+
+* **Detección de movimiento mediante flujo óptico**. [Optical flow](https://docs.opencv.org/3.4/d4/dee/tutorial_optical_flow.html) nos permite comprender cómo se mueven los píxeles individuales en los cuadros de video. Hay dos tipos de flujo óptico:
+
+* - **Flujo óptico denso** calcula el campo vectorial que muestra para cada píxel dónde se mueve
+ - **Flujo óptico disperso** se basa en tomar algunas características distintivas de la imagen (por ejemplo, bordes) y construir su trayectoria de cuadro a cuadro.
+
+
+
+> Imagen de [OpenCV.ipynb](OpenCV.ipynb)
+
+## ✍️ Cuadernos de ejemplo: OpenCV [try OpenCV in Action](OpenCV.ipynb)
+
+Hagamos algunos experimentos con OpenCV explorando [OpenCV Notebook](OpenCV.ipynb)
+
+## Conclusión
+
+A veces, tareas relativamente complejas, como la detección de movimiento o la detección de las yemas de los dedos, pueden resolverse únicamente mediante visión por computadora. Por lo tanto, es muy útil conocer las técnicas básicas de visión por computadora y qué pueden hacer bibliotecas como OpenCV.
+
+## 🚀 Desafío
+
+Mirar [this video](https://docs.microsoft.com/shows/ai-show/ai-show--2021-opencv-ai-competition--grand-prize-winners--cortic-tigers--episode-32?WT.mc_id=academic-77998-cacaste) del programa de IA para conocer el proyecto Cortic Tigers y cómo construyeron una solución basada en bloques para democratizar las tareas de visión por computadora a través de un robot. Investigue un poco sobre otros proyectos como este que ayuden a incorporar nuevos estudiantes al campo.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/206)
+
+## Revisión y autoestudio
+
+Lea más sobre el flujo óptico [in this great tutorial](https://learnopencv.com/optical-flow-in-opencv/).
+
+## [Assignment](lab/README.md)
+
+En esta práctica de laboratorio, grabará un video con gestos simples y su objetivo es extraer movimientos hacia arriba/abajo/izquierda/derecha utilizando el flujo óptico.
+
+
From df6c826546948bae3b8c2e8031b09c1571dcd9eb Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 20:56:21 -0500
Subject: [PATCH 11/33] Create README.es.md
---
.../4-ComputerVision/07-ConvNets/README.es.md | 61 +++++++++++++++++++
1 file changed, 61 insertions(+)
create mode 100644 lessons/4-ComputerVision/07-ConvNets/README.es.md
diff --git a/lessons/4-ComputerVision/07-ConvNets/README.es.md b/lessons/4-ComputerVision/07-ConvNets/README.es.md
new file mode 100644
index 00000000..3b8ef3ed
--- /dev/null
+++ b/lessons/4-ComputerVision/07-ConvNets/README.es.md
@@ -0,0 +1,61 @@
+# Redes neuronales convolucionales
+
+Hemos visto antes que las redes neuronales son bastante buenas para manejar imágenes, e incluso el perceptrón de una capa es capaz de reconocer dígitos escritos a mano del conjunto de datos MNIST con una precisión razonable. Sin embargo, el conjunto de datos MNIST es muy especial y todos los dígitos están centrados dentro de la imagen, lo que simplifica la tarea.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/107)
+
+En la vida real, queremos poder reconocer objetos en una imagen independientemente de su ubicación exacta en la imagen. La visión por computadora es diferente de la clasificación genérica, porque cuando intentamos encontrar un determinado objeto en la imagen, escaneamos la imagen en busca de algunos **patrones** específicos y sus combinaciones. Por ejemplo, cuando buscamos un gato, primero podemos buscar líneas horizontales, que pueden formar bigotes, y luego una combinación de bigotes puede decirnos que en realidad es una imagen de un gato. Lo importante es la posición relativa y la presencia de ciertos patrones, no su posición exacta en la imagen.
+
+Para extraer patrones, usaremos la noción de **filtros convolucionales**. Como sabes, una imagen está representada por una matriz 2D o un tensor 3D con profundidad de color. Aplicar un filtro significa que tomamos una matriz de **núcleo de filtro** relativamente pequeña y, para cada píxel de la imagen original, calculamos el promedio ponderado con los puntos vecinos. Podemos ver esto como una pequeña ventana que se desliza sobre toda la imagen y promedia todos los píxeles de acuerdo con los pesos en la matriz del núcleo del filtro.
+
+ | 
+----|----
+
+> Imagen de Dmitry Soshnikov
+
+Por ejemplo, si aplicamos filtros de borde vertical y borde horizontal de 3x3 a los dígitos MNIST, podemos obtener resaltados (por ejemplo, valores altos) donde hay bordes verticales y horizontales en nuestra imagen original. Por tanto, esos dos filtros se pueden utilizar para "buscar" bordes. De manera similar, podemos diseñar diferentes filtros para buscar otros patrones de bajo nivel:
+
+
+
+
+Imagen de [Leung-Malik Filter Bank](https://www.robots.ox.ac.uk/~vgg/research/texclass/filters.html)
+
+Sin embargo, si bien podemos diseñar los filtros para extraer algunos patrones manualmente, también podemos diseñar la red de tal manera que aprenda los patrones automáticamente. Es una de las ideas principales detrás de la CNN.
+
+## Ideas principales detrás de CNN
+
+La forma en que funcionan las CNN se basa en las siguientes ideas importantes:
+
+* Los filtros convolucionales pueden extraer patrones.
+* Podemos diseñar la red de tal manera que los filtros se entrenen automáticamente
+* Podemos utilizar el mismo enfoque para encontrar patrones en funciones de alto nivel, no solo en la imagen original. Por lo tanto, la extracción de características de CNN funciona en una jerarquía de características, desde combinaciones de píxeles de bajo nivel hasta combinaciones de partes de imagen de nivel superior.
+
+
+
+Imagen de [a paper by Hislop-Lynch](https://www.semanticscholar.org/paper/Computer-vision-based-pedestrian-trajectory-Hislop-Lynch/26e6f74853fc9bbb7487b06dc2cf095d36c9021d), basa en [their research](https://dl.acm.org/doi/abs/10.1145/1553374.1553453)
+
+## ✍️ Ejercicios: Redes Neuronales Convolucionales
+
+Sigamos explorando cómo funcionan las redes neuronales convolucionales y cómo podemos lograr filtros entrenables, trabajando con los cuadernos correspondientes:
+
+* [Convolutional Neural Networks - PyTorch](ConvNetsPyTorch.ipynb)
+* [Convolutional Neural Networks - TensorFlow](ConvNetsTF.ipynb)
+
+## Pyramid Architecture
+
+Most of the CNNs used for image processing follow a so-called pyramid architecture. The first convolutional layer applied to the original images typically has a relatively low number of filters (8-16), which correspond to different pixel combinations, such as horizontal/vertical lines of strokes. At the next level, we reduce the spatial dimension of the network, and increase the number of filters, which corresponds to more possible combinations of simple features. With each layer, as we move towards the final classifier, spatial dimensions of the image decrease, and the number of filters grow.
+
+As an example, let's look at the architecture of VGG-16, a network that achieved 92.7% accuracy in ImageNet's top-5 classification in 2014:
+
+
+
+
+
+> Imagen de [Researchgate](https://www.researchgate.net/figure/Vgg16-model-structure-To-get-the-VGG-NIN-model-we-replace-the-2-nd-4-th-6-th-7-th_fig2_335194493)
+
+## Arquitecturas CNN más conocidas
+
+[Continue your study about the best-known CNN architectures](CNN_Architectures.md)
+
+
+
From f1a533e175c0abc21b4b0e56cc3fec40079f79ee Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 21:09:44 -0500
Subject: [PATCH 12/33] Create README.es.md
---
.../08-TransferLearning/README.es.md | 77 +++++++++++++++++++
1 file changed, 77 insertions(+)
create mode 100644 lessons/4-ComputerVision/08-TransferLearning/README.es.md
diff --git a/lessons/4-ComputerVision/08-TransferLearning/README.es.md b/lessons/4-ComputerVision/08-TransferLearning/README.es.md
new file mode 100644
index 00000000..f78b39da
--- /dev/null
+++ b/lessons/4-ComputerVision/08-TransferLearning/README.es.md
@@ -0,0 +1,77 @@
+# Pre-trained Networks and Transfer Learning
+
+Training CNNs can take a lot of time, and a lot of data is required for that task. However, much of the time is spent learning the best low-level filters that a network can use to extract patterns from images. A natural question arises - can we use a neural network trained on one dataset and adapt it to classify different images without requiring a full training process?
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/108)
+
+Este enfoque se llama **aprendizaje por transferencia** porque transferimos algunos conocimientos de un modelo de red neuronal a otro. En el aprendizaje por transferencia, normalmente comenzamos con un modelo previamente entrenado, que ha sido entrenado en algún conjunto de datos de imágenes grande, como **ImageNet**. Esos modelos ya pueden hacer un buen trabajo extrayendo diferentes características de imágenes genéricas y, en muchos casos, simplemente construir un clasificador sobre esas características extraídas puede producir un buen resultado.
+
+> ✅ Transfer Learning es un término que se encuentra en otros campos académicos, como la Educación. Se refiere al proceso de tomar conocimiento de un dominio y aplicarlo a otro.
+
+## Modelos previamente entrenados como extractores de características
+
+Las redes convolucionales de las que hemos hablado en la sección anterior contenían una serie de capas, cada una de las cuales se supone que extrae algunas características de la imagen, comenzando desde combinaciones de píxeles de bajo nivel (como una línea o trazo horizontal/vertical), hasta a combinaciones de características de nivel superior, correspondientes a cosas como el ojo de una llama. Si entrenamos a CNN con un conjunto de datos suficientemente grande de imágenes genéricas y diversas, la red debería aprender a extraer esas características comunes.
+
+Tanto Keras como PyTorch contienen funciones para cargar fácilmente pesos de redes neuronales previamente entrenados para algunas arquitecturas comunes, la mayoría de las cuales fueron entrenadas en imágenes de ImageNet. Los más utilizados se describen en la página [Arquitecturas CNN](../07-ConvNets/CNN_Architectures.md) de la lección anterior. En particular, es posible que desee considerar el uso de uno de los siguientes:
+
+* **VGG-16/VGG-19** que son modelos relativamente simples que aún ofrecen buena precisión. A menudo, utilizar VGG como primer intento es una buena opción para ver cómo funciona el aprendizaje por transferencia.
+* **ResNet** es una familia de modelos propuesta por Microsoft Research en 2015. Tienen más capas y, por lo tanto, requieren más recursos.
+* **MobileNet** es una familia de modelos de tamaño reducido, aptos para dispositivos móviles. Úselos si tiene pocos recursos y puede sacrificar un poco de precisión.
+
+Aquí hay ejemplos de características extraídas de una imagen de un gato por la red VGG-16:
+
+
+
+## Conjunto de datos sobre gatos y perros
+
+En este ejemplo, usaremos un conjunto de datos de [Cats and Dogs](https://www.microsoft.com/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste), which is very close to a real-life image classification scenario.
+
+## ✍️ Exercise: Transfer Learning
+
+Let's see transfer learning in action in corresponding notebooks:
+
+* [Transfer Learning - PyTorch](TransferLearningPyTorch.ipynb)
+* [Transfer Learning - TensorFlow](TransferLearningTF.ipynb)
+
+## Visualizando al gato adversario
+
+La red neuronal previamente entrenada contiene diferentes patrones dentro de su *cerebro*, incluidas nociones de **gato ideal** (así como de perro ideal, cebra ideal, etc.). Sería interesante de alguna manera **visualizar esta imagen**. Sin embargo, no es sencillo, porque los patrones están repartidos por todos los pesos de la red y también organizados en una estructura jerárquica.
+
+Un enfoque que podemos tomar es comenzar con una imagen aleatoria y luego intentar usar la técnica de **optimización de descenso de gradiente** para ajustar esa imagen de tal manera que la red comience a pensar que es un gato.
+
+
+
+Sin embargo, si hacemos esto, recibiremos algo muy similar a un ruido aleatorio. Esto se debe a que *hay muchas maneras de hacer que la red piense que la imagen de entrada es un gato*, incluidas algunas que no tienen sentido visualmente. Si bien esas imágenes contienen muchos patrones típicos de un gato, no hay nada que las limite a ser visualmente distintivas.
+
+Para mejorar el resultado, podemos agregar otro término a la función de pérdida, que se llama **pérdida de variación**. Es una métrica que muestra qué tan similares son los píxeles vecinos de la imagen. Minimizar la pérdida de variación hace que la imagen sea más suave y elimina el ruido, revelando así patrones más atractivos visualmente. A continuación se muestra un ejemplo de imágenes "ideales" que se clasifican como gatos y cebras con alta probabilidad:
+
+ | 
+-----|-----
+ *Ideal Cat* | *Ideal Zebra*
+
+ Se puede utilizar un enfoque similar para realizar los llamados **ataques adversarios** en una red neuronal. Supongamos que queremos engañar a una red neuronal y hacer que un perro parezca un gato. Si tomamos la imagen del perro, que una red reconoce como un perro, podemos modificarla un poco pero usando la optimización de descenso de gradiente, hasta que la red comience a clasificarlo como un gato:
+
+  | 
+-----|-----
+*Imagen original de un perro* | *Foto de un perro clasificado como gato*
+
+Vea el código para reproducir los resultados anteriores en el siguiente cuaderno:
+
+* [Ideal and Adversarial Cat - TensorFlow](AdversarialCat_TF.ipynb)
+## Conclusion
+
+Al utilizar el aprendizaje por transferencia, puede crear rápidamente un clasificador para una tarea de clasificación de objetos personalizada y lograr una alta precisión. Puede ver que las tareas más complejas que estamos resolviendo ahora requieren una mayor potencia computacional y no se pueden resolver fácilmente en la CPU. En la siguiente unidad, intentaremos utilizar una implementación más ligera para entrenar el mismo modelo utilizando menores recursos informáticos, lo que da como resultado una precisión ligeramente menor.
+
+## 🚀 Desafío
+
+En los cuadernos adjuntos, hay notas al final sobre cómo funciona mejor la transferencia de conocimientos con datos de entrenamiento algo similares (un nuevo tipo de animal, tal vez). Experimente un poco con tipos de imágenes completamente nuevos para ver qué tan bien o mal funcionan sus modelos de transferencia de conocimiento.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
+
+## Revisión y autoestudio
+
+Leer de parte a parte [TrainingTricks.md](TrainingTricks.md) para profundizar su conocimiento sobre alguna otra forma de entrenar sus modelos.
+
+## [Assignment](lab/README.md)
+
+En este laboratorio, usaremos la vida real [Oxford-IIIT](https://www.robots.ox.ac.uk/~vgg/data/pets/) conjunto de datos de mascotas con 35 razas de perros y gatos, y crearemos un clasificador de aprendizaje por transferencia.
From 3da6b361d7d371e60d6b6e50ae65735c48f2d356 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 21:23:45 -0500
Subject: [PATCH 13/33] Create README.es.md
---
.../09-Autoencoders/README.es.md | 97 +++++++++++++++++++
1 file changed, 97 insertions(+)
create mode 100644 lessons/4-ComputerVision/09-Autoencoders/README.es.md
diff --git a/lessons/4-ComputerVision/09-Autoencoders/README.es.md b/lessons/4-ComputerVision/09-Autoencoders/README.es.md
new file mode 100644
index 00000000..f6fd0524
--- /dev/null
+++ b/lessons/4-ComputerVision/09-Autoencoders/README.es.md
@@ -0,0 +1,97 @@
+# codificadores automáticos
+
+Al entrenar CNN, uno de los problemas es que necesitamos muchos datos etiquetados. En el caso de la clasificación de imágenes, necesitamos separar las imágenes en diferentes clases, lo cual es un esfuerzo manual.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/109)
+
+Sin embargo, es posible que deseemos utilizar datos sin procesar (sin etiquetar) para entrenar extractores de funciones de CNN, lo que se denomina **aprendizaje autosupervisado**. En lugar de etiquetas, utilizaremos imágenes de entrenamiento como entrada y salida de la red. La idea principal de **autoencoder** es que tendremos una **red codificadora** que convierte la imagen de entrada en algún **espacio latente** (normalmente es solo un vector de un tamaño más pequeño), luego el **red decodificadora**, cuyo objetivo sería reconstruir la imagen original.
+
+> ✅ Un [autoencoder](https://wikipedia.org/wiki/Autoencoder) es "un tipo de red neuronal artificial utilizada para aprender codificaciones eficientes de datos sin etiquetar".
+>
+> Dado que estamos entrenando un codificador automático para capturar la mayor cantidad posible de información de la imagen original para una reconstrucción precisa, la red intenta encontrar la mejor **incrustación** de imágenes de entrada para capturar el significado.
+>
+> 
+
+> Imagen de [Keras blog](https://blog.keras.io/building-autoencoders-in-keras.html)
+>
+> ## Escenarios para usar codificadores automáticos
+
+Si bien la reconstrucción de imágenes originales no parece útil por sí sola, existen algunos escenarios en los que los codificadores automáticos son especialmente útiles:
+
+* **Reducir la dimensión de las imágenes para visualización** o **entrenar incrustaciones de imágenes**. Por lo general, los codificadores automáticos dan mejores resultados que PCA porque tienen en cuenta la naturaleza espacial de las imágenes y las características jerárquicas.
+* **Eliminación de ruido**, es decir, eliminación del ruido de la imagen. Debido a que el ruido transporta una gran cantidad de información inútil, el codificador automático no puede caber todo en un espacio latente relativamente pequeño y, por lo tanto, captura solo una parte importante de la imagen. Al entrenar eliminadores de ruido, comenzamos con imágenes originales y usamos imágenes con ruido agregado artificialmente como entrada para el codificador automático.
+* **Superresolución**, aumentando la resolución de la imagen. Comenzamos con imágenes de alta resolución y usamos la imagen con menor resolución como entrada del codificador automático.
+* **Modelos generativos**. Una vez que entrenamos el codificador automático, la parte del decodificador se puede usar para crear nuevos objetos a partir de vectores latentes aleatorios.
+
+## Autocodificadores variacionales (VAE)
+
+Los codificadores automáticos tradicionales reducen de alguna manera la dimensión de los datos de entrada, descubriendo las características importantes de las imágenes de entrada. Sin embargo, los vectores latentes a menudo no tienen mucho sentido. En otras palabras, tomando como ejemplo el conjunto de datos MNIST, descubrir qué dígitos corresponden a diferentes vectores latentes no es una tarea fácil, porque los vectores latentes cercanos no necesariamente corresponderían a los mismos dígitos.
+
+Por otro lado, para entrenar modelos *generativos* es mejor tener cierto conocimiento del espacio latente. Esta idea nos lleva al **codificador automático variacional** (VAE).
+
+VAE es el codificador automático que aprende a predecir la *distribución estadística* de los parámetros latentes, la llamada **distribución latente**. Por ejemplo, es posible que deseemos que los vectores latentes se distribuyan normalmente con alguna media zmedia y desviación estándar zsigma (tanto la media como la desviación estándar son vectores de alguna dimensionalidad d). El codificador en VAE aprende a predecir esos parámetros y luego el decodificador toma un vector aleatorio de esta distribución para reconstruir el objeto.
+
+Para resumir:
+
+ * A partir del vector de entrada, predecimos `z_mean` y `z_log_sigma` (en lugar de predecir la desviación estándar en sí, predecimos su logaritmo)
+ * Tomamos una muestra de un vector `muestra` de la distribución N(zmean,exp(zlog\_sigma))
+ * El decodificador intenta decodificar la imagen original usando `muestra` como vector de entrada
+
+
+
+> Imagen de [this blog post](https://ijdykeman.github.io/ml/2016/12/21/cvae.html) by Isaak Dykeman
+
+Los codificadores automáticos variacionales utilizan una función de pérdida compleja que consta de dos partes:
+
+* **Pérdida de reconstrucción** es la función de pérdida que muestra qué tan cerca está una imagen reconstruida del objetivo (puede ser un error cuadrático medio o MSE). Es la misma función de pérdida que en los codificadores automáticos normales.
+* **Pérdida de KL**, que garantiza que las distribuciones de variables latentes se mantengan cercanas a la distribución normal. Se basa en la noción de [divergencia Kullback-Leibler](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained), una métrica para estimar qué tan similares son dos distribuciones estadísticas. son.
+
+Una ventaja importante de los VAE es que nos permiten generar nuevas imágenes con relativa facilidad, porque sabemos de qué distribución tomar muestras de vectores latentes. Por ejemplo, si entrenamos VAE con un vector latente 2D en MNIST, podemos variar los componentes del vector latente para obtener diferentes dígitos:
+
+
+
+> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
+
+Observe cómo las imágenes se mezclan entre sí, a medida que comenzamos a obtener vectores latentes de las diferentes partes del espacio de parámetros latentes. También podemos visualizar este espacio en 2D:
+
+
+
+> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
+
+## ✍️ Ejercicios: Autocodificadores
+
+Obtenga más información sobre los codificadores automáticos en estos cuadernos correspondientes:
+
+* [Autoencoders in TensorFlow](AutoencodersTF.ipynb)
+* [Autoencoders in PyTorch](AutoEncodersPyTorch.ipynb)
+
+## Propiedades de los codificadores automáticos
+
+* **Datos específicos**: solo funcionan bien con el tipo de imágenes en las que han sido entrenados. Por ejemplo, si entrenamos una red de superresolución en flores, no funcionará bien en retratos. Esto se debe a que la red puede producir imágenes de mayor resolución al tomar detalles finos de las características aprendidas del conjunto de datos de entrenamiento.
+* **Con pérdida**: la imagen reconstruida no es la misma que la imagen original. La naturaleza de la pérdida está definida por la *función de pérdida* utilizada durante el entrenamiento
+* Funciona con **datos sin etiqueta**
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/209)
+
+## Conclusión
+
+En esta lección, aprendió sobre los distintos tipos de codificadores automáticos disponibles para el científico de IA. Aprendiste cómo construirlos y cómo usarlos para reconstruir imágenes. También aprendió sobre VAE y cómo usarlo para generar nuevas imágenes.
+
+## 🚀 Desafío
+
+En esta lección, aprendió a usar codificadores automáticos para imágenes. ¡Pero también se pueden utilizar para música! Consulte el proyecto [MusicVAE](https://magenta.tensorflow.org/music-vae) del proyecto Magenta, que utiliza codificadores automáticos para aprender a reconstruir música. Realice algunos [experimentos](https://colab.research.google.com/github/magenta/magenta-demos/blob/master/colab-notebooks/Multitrack_MusicVAE.ipynb) con esta biblioteca para ver qué puede crear.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/208)
+
+## Review & Self Study
+
+For reference, read more about autoencoders in these resources:
+
+* [Building Autoencoders in Keras](https://blog.keras.io/building-autoencoders-in-keras.html)
+* [Blog post on NeuroHive](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/)
+* [Variational Autoencoders Explained](https://kvfrans.com/variational-autoencoders-explained/)
+* [Conditional Variational Autoencoders](https://ijdykeman.github.io/ml/2016/12/21/cvae.html)
+
+## Asignación
+
+Al final de [this notebook using TensorFlow](AutoencodersTF.ipynb), encontrará una 'tarea'; utilícela como su tarea.
From 4d9de7440a59c60a6363f3f2049601d6c66cdfa5 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 22:09:47 -0500
Subject: [PATCH 14/33] Create README.es.md
---
lessons/4-ComputerVision/10-GANs/README.es.md | 98 +++++++++++++++++++
1 file changed, 98 insertions(+)
create mode 100644 lessons/4-ComputerVision/10-GANs/README.es.md
diff --git a/lessons/4-ComputerVision/10-GANs/README.es.md b/lessons/4-ComputerVision/10-GANs/README.es.md
new file mode 100644
index 00000000..cd796bcf
--- /dev/null
+++ b/lessons/4-ComputerVision/10-GANs/README.es.md
@@ -0,0 +1,98 @@
+# Redes generativas de confrontación
+
+En la sección anterior, aprendimos sobre los **modelos generativos**: modelos que pueden generar nuevas imágenes similares a las del conjunto de datos de entrenamiento. VAE fue un buen ejemplo de modelo generativo.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/110)
+
+Sin embargo, si intentamos generar algo realmente significativo, como una pintura con una resolución razonable, con VAE, veremos que el entrenamiento no converge bien. Para este caso de uso, deberíamos conocer otra arquitectura dirigida específicamente a modelos generativos: **Redes generativas adversas** o GAN.
+
+La idea principal de una GAN es tener dos redes neuronales que se entrenarán entre sí:
+
+
+
+> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
+
+> ✅ Un poco de vocabulario:
+> * **Generador** es una red que toma algún vector aleatorio y produce la imagen como resultado
+> * **Discriminator** es una red que toma una imagen y debe indicar si es una imagen real (del conjunto de datos de entrenamiento) o si fue generada por un generador. Es esencialmente un clasificador de imágenes.
+
+### Discriminador
+
+La arquitectura del discriminador no difiere de la de una red de clasificación de imágenes ordinaria. En el caso más simple, puede ser un clasificador completamente conectado, pero lo más probable es que sea una [red convolucional] (../07-ConvNets/README.md).
+
+> ✅ Una GAN basada en redes convolucionales se llama [DCGAN](https://arxiv.org/pdf/1511.06434.pdf)
+
+Un discriminador CNN consta de las siguientes capas: varias convoluciones + agrupaciones (con tamaño espacial decreciente) y una o más capas completamente conectadas para obtener el "vector de características", clasificador binario final.
+
+> ✅ Un 'pooling' en este contexto es una técnica que reduce el tamaño de la imagen. "La agrupación de capas reduce las dimensiones de los datos al combinar las salidas de los grupos de neuronas en una capa en una sola neurona en la siguiente capa". - [fuente](https://wikipedia.org/wiki/Convolutional_neural_network#Pooling_layers)
+
+### Generador
+
+Un generador es un poco más complicado. Puedes considerarlo como un discriminador inverso. A partir de un vector latente (en lugar de un vector de características), tiene una capa completamente conectada para convertirla al tamaño/forma requerido, seguida de deconvoluciones + ampliación de escala. Esto es similar a la parte *decodificador* de [autoencoder](../09-Autoencoders/README.md).
+
+> ✅ Debido a que la capa de convolución se implementa como un filtro lineal que atraviesa la imagen, la deconvolución es esencialmente similar a la convolución y se puede implementar usando la misma lógica de capa.
+
+
+
+> Imagen de [Dmitry Soshnikov](http://soshnikov.com)
+
+### Entrenando la GAN
+
+Las GAN se denominan **adversarias** porque existe una competencia constante entre el generador y el discriminador. Durante esta competencia, tanto el generador como el discriminador mejoran, por lo que la red aprende a producir cada vez mejores imágenes.
+
+La formación se desarrolla en dos etapas:
+
+* **Entrenando al discriminador**. Esta tarea es bastante sencilla: generamos un lote de imágenes mediante el generador, las etiquetamos con 0, que significa imagen falsa, y tomamos un lote de imágenes del conjunto de datos de entrada (con etiqueta 1, imagen real). Obtenemos algo de *pérdida de discriminador* y realizamos backprop.
+* **Entrenamiento del generador**. Esto es un poco más complicado, porque no conocemos directamente la salida esperada del generador. Tomamos toda la red GAN que consta de un generador seguido de un discriminador, la alimentamos con algunos vectores aleatorios y esperamos que el resultado sea 1 (correspondiente a imágenes reales). Luego congelamos los parámetros del discriminador (no queremos que se entrene en este paso) y realizamos la backprop.
+
+Durante este proceso, las pérdidas tanto del generador como del discriminador no disminuyen significativamente. En la situación ideal deberían oscilar, correspondiendo a que ambas redes mejoren su rendimiento.
+
+## ✍️ Ejercicios: GAN
+
+* [GAN Notebook in TensorFlow/Keras](GANTF.ipynb)
+* [GAN Notebook in PyTorch](GANPyTorch.ipynb)
+
+### Problemas con el entrenamiento GAN
+
+Se sabe que las GAN son especialmente difíciles de entrenar. Aquí hay algunos problemas:
+
+* **Modo Colapso**. Con este término queremos decir que el generador aprende a producir una imagen exitosa que engaña al generador, y no una variedad de imágenes diferentes.
+* **Sensibilidad a los hiperparámetros**. A menudo se puede ver que una GAN no converge en absoluto y luego, repentinamente, la tasa de aprendizaje disminuye, lo que conduce a la convergencia.
+* Mantener un **equilibrio** entre el generador y el discriminador. En muchos casos, la pérdida del discriminador puede caer a cero con relativa rapidez, lo que provoca que el generador no pueda seguir entrenándose. Para superar esto, podemos intentar establecer diferentes tasas de aprendizaje para el generador y el discriminador, u omitir el entrenamiento del discriminador si la pérdida ya es demasiado baja.
+* Entrenamiento para **alta resolución**. Reflejando el mismo problema que con los codificadores automáticos, este problema se desencadena porque la reconstrucción de demasiadas capas de red convolucional genera artefactos. Este problema generalmente se resuelve con el llamado **crecimiento progresivo**, cuando primero se entrenan algunas capas en imágenes de baja resolución y luego se "desbloquean" o agregan capas. Otra solución sería agregar conexiones adicionales entre capas y entrenar varias resoluciones a la vez; consulte este [artículo sobre GAN de gradiente multiescala] (https://arxiv.org/abs/1903.06048) para obtener más detalles.
+
+## Transferencia de estilo
+
+Las GAN son una excelente manera de generar imágenes artísticas. Otra técnica interesante es la llamada **transferencia de estilo**, que toma una **imagen de contenido** y la vuelve a dibujar en un estilo diferente, aplicando filtros de **imagen de estilo**.
+
+La forma en que funciona es la siguiente:
+* Comenzamos con una imagen de ruido aleatorio (o con una imagen de contenido, pero para facilitar la comprensión es más fácil comenzar con ruido aleatorio)
+* Nuestro objetivo sería crear una imagen de este tipo, que se acerque tanto a la imagen de contenido como a la imagen de estilo. Esto estaría determinado por dos funciones de pérdida:
+ - La **pérdida de contenido** se calcula en función de las características extraídas por CNN en algunas capas de la imagen actual y la imagen del contenido.
+ - La **pérdida de estilo** se calcula entre la imagen actual y la imagen de estilo de una manera inteligente utilizando matrices de Gram (más detalles en el [example notebook](StyleTransfer.ipynb))
+* Para suavizar la imagen y eliminar el ruido, también introducimos la **Pérdida de variación**, que calcula la distancia promedio entre píxeles vecinos.
+* El bucle de optimización principal ajusta la imagen actual mediante el descenso de gradiente (o algún otro algoritmo de optimización) para minimizar la pérdida total, que es una suma ponderada de las tres pérdidas.
+
+## ✍️ Ejemplo: [Style Transfer](StyleTransfer.ipynb)
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/210)
+
+## Conclusión
+
+En esta lección, aprendiste sobre GANS y cómo entrenarlos. También aprendió sobre los desafíos especiales que puede enfrentar este tipo de red neuronal y algunas estrategias sobre cómo superarlos.
+
+## 🚀 Desafío
+
+Corre por el [Style Transfer notebook](StyleTransfer.ipynb) usando tus propias imágenes.
+
+## Revisión y autoestudio
+
+Como referencia, lea más sobre las GAN en estos recursos:
+
+* Marco Pasini, [10 Lessons I Learned Training GANs for one Year](https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c9071159628)
+* [StyleGAN](https://en.wikipedia.org/wiki/StyleGAN), a *de facto* GAN arquitectura a considerar
+* [Creating Generative Art using GANs on Azure ML](https://soshnikov.com/scienceart/creating-generative-art-using-gan-on-azureml/)
+
+## Asignación
+
+Vuelva a visitar uno de los dos cuadernos asociados a esta lección y vuelva a entrenar la GAN con sus propias imágenes. ¿Qué puedes crear?
From 82c7b9b898d500aced038d7bf51009f32f028b11 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 22:31:21 -0500
Subject: [PATCH 15/33] Create README.es.md
---
.../11-ObjectDetection/README.es.md | 185 ++++++++++++++++++
1 file changed, 185 insertions(+)
create mode 100644 lessons/4-ComputerVision/11-ObjectDetection/README.es.md
diff --git a/lessons/4-ComputerVision/11-ObjectDetection/README.es.md b/lessons/4-ComputerVision/11-ObjectDetection/README.es.md
new file mode 100644
index 00000000..0d4c26ad
--- /dev/null
+++ b/lessons/4-ComputerVision/11-ObjectDetection/README.es.md
@@ -0,0 +1,185 @@
+# Detección de objetos
+
+Los modelos de clasificación de imágenes que hemos tratado hasta ahora tomaron una imagen y produjeron un resultado categórico, como la clase "número" en un problema MNIST. Sin embargo, en muchos casos no queremos simplemente saber que una imagen representa objetos, sino que queremos poder determinar su ubicación exacta. Este es exactamente el punto de **detección de objetos**.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/111)
+
+
+
+> Imagen de [YOLO v2 web site](https://pjreddie.com/darknet/yolov2/)
+
+## A Naive Approach to Object Detection
+
+Assuming we wanted to find a cat on a picture, a very naive approach to object detection would be the following:
+
+1. Break the picture down to a number of tiles
+2. Run image classification on each tile.
+3. Those tiles that result in sufficiently high activation can be considered to contain the object in question.
+
+
+
+> *Imagen de [Exercise Notebook](ObjectDetection-TF.ipynb)*
+
+Sin embargo, este enfoque está lejos de ser ideal, porque solo permite que el algoritmo ubique el cuadro delimitador del objeto de manera muy imprecisa. Para una ubicación más precisa, necesitamos ejecutar algún tipo de **regresión** para predecir las coordenadas de los cuadros delimitadores y, para ello, necesitamos conjuntos de datos específicos.
+
+## Regresión para la detección de objetos
+
+[This blog post](https://towardsdatascience.com/object-detection-with-neural-networks-a4e2c46b4491) tiene una excelente y suave introducción a la detección de formas.
+
+## Conjuntos de datos para la detección de objetos
+
+Es posible que se encuentre con los siguientes conjuntos de datos para esta tarea:
+
+* [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) - 20 clases
+* [COCO](http://cocodataset.org/#home) - Objetos comunes en contexto. 80 clases, cuadros delimitadores y máscara de segmentación.
+
+
+
+## Métricas de detección de objetos
+
+### Intersección sobre Unión
+
+Mientras que para la clasificación de imágenes es fácil medir qué tan bien funciona el algoritmo, para la detección de objetos necesitamos medir tanto la exactitud de la clase como la precisión de la ubicación del cuadro delimitador inferida. Para este último, utilizamos la llamada **Intersección sobre Unión** (IoU), que mide qué tan bien se superponen dos cuadros (o dos áreas arbitrarias).
+
+
+
+> *Figura 2 de [this excellent blog post on IoU](https://pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/)*
+
+La idea es simple: dividimos el área de intersección entre dos figuras por el área de su unión. Para dos áreas idénticas, IoU sería 1, mientras que para áreas completamente desunidas será 0. De lo contrario, variará de 0 a 1. Por lo general, solo consideramos aquellos cuadros delimitadores para los cuales IoU supera un cierto valor.
+
+### Precisión promedio
+
+Supongamos que queremos medir qué tan bien se reconoce una determinada clase de objetos $C$. Para medirlo, utilizamos métricas de **Precisión promedio**, que se calcula de la siguiente manera:
+
+1. Considere la curva de recuperación de precisión que muestra la precisión en función de un valor de umbral de detección (de 0 a 1).
+2. Dependiendo del umbral obtendremos más o menos objetos detectados en la imagen, y diferentes valores de precisión y recuperación.
+3. La curva se verá así:
+
+
+
+> *Image from [NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
+
+La precisión promedio para una clase dada $C$ es el área bajo esta curva. Más precisamente, el eje de recuperación generalmente se divide en 10 partes y la precisión se promedia en todos esos puntos:
+
+$$
+AP = {1\over11}\sum_{i=0}^{10}\mbox{Precision}(\mbox{Recall}={i\over10})
+$$
+
+### AP y pagaré
+
+Consideraremos solo aquellas detecciones para las cuales IoU esté por encima de un cierto valor. Por ejemplo, en el conjunto de datos PASCAL VOC normalmente se supone $\mbox{IoU Threshold} = 0,5$, mientras que en COCO AP se mide para diferentes valores de $\mbox{IoU Threshold}$.
+
+
+
+> *Imagen de [NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
+
+### Precisión media media - mapa
+
+La métrica principal para la detección de objetos se llama **Precisión promedio media** o **mAP**. Es el valor de la precisión promedio, el promedio de todas las clases de objetos y, a veces, también por encima de $\mbox{IoU Threshold}$. Con más detalle, se describe el proceso de cálculo de **mAP**.
+[in this blog post](https://medium.com/@timothycarlen/understanding-the-map-evaluation-metric-for-object-detection-a07fe6962cf3)), y tambien [here with code samples](https://gist.github.com/tarlen5/008809c3decf19313de216b9208f3734).
+
+## Diferentes enfoques de detección de objetos
+
+Hay dos clases amplias de algoritmos de detección de objetos:
+
+* **Redes de propuesta regional** (R-CNN, Fast R-CNN, Faster R-CNN). La idea principal es generar **regiones de interés** (ROI) y ejecutar CNN sobre ellas, buscando la máxima activación. Es un poco similar al enfoque ingenuo, con la excepción de que los ROI se generan de una manera más inteligente. Uno de los mayores inconvenientes de estos métodos es que son lentos, porque necesitamos muchas pasadas del clasificador CNN sobre la imagen.
+* **Métodos de una sola pasada** (YOLO, SSD, RetinaNet). En esas arquitecturas diseñamos la red para predecir tanto las clases como el ROI en una sola pasada.
+
+### R-CNN: CNN basada en regiones
+
+[R-CNN](http://islab.ulsan.ac.kr/files/announcement/513/rcnn_pami.pdf) usos [Selective Search](http://www.huppelen.nl/publications/selectiveSearchDraft.pdf) to generate hierarchical structure of ROI regions, which are then passed through CNN feature extractors and SVM-classifiers to determine the object class, and linear regression to determine *bounding box* coordinates. [Official Paper](https://arxiv.org/pdf/1506.01497v1.pdf)
+
+
+
+> *Imagen de van de Sande et al. ICCV’11*
+
+
+
+> *Imagen de [this blog](https://towardsdatascience.com/r-cnn-fast-r-cnn-faster-r-cnn-yolo-object-detection-algorithms-36d53571365e)
+
+### F-RCNN - R-CNN rápido
+
+Este enfoque es similar a R-CNN, pero las regiones se definen después de que se hayan aplicado las capas de convolución.
+
+
+
+> Imagen de [the Official Paper](https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Girshick_Fast_R-CNN_ICCV_2015_paper.pdf), [arXiv](https://arxiv.org/pdf/1504.08083.pdf), 2015
+
+### R-CNN más rápido
+
+La idea principal de este enfoque es utilizar una red neuronal para predecir el ROI, la llamada *Red de propuesta de región*. [Artículo](https://arxiv.org/pdf/1506.01497.pdf), 2016
+
+
+
+> Imagen de [the official paper](https://arxiv.org/pdf/1506.01497.pdf)
+
+### R-FCN: red totalmente convolucional basada en regiones
+
+Este algoritmo es incluso más rápido que Faster R-CNN. La idea principal es la siguiente:
+
+1. Extraemos funciones usando ResNet-101
+1. Las características se procesan mediante **Mapa de puntuación sensible a la posición**. Cada objeto de las clases $C$ se divide por $k\times k$ regiones, y estamos entrenando para predecir partes de objetos.
+1. Para cada parte de $k\times k$ regiones, todas las redes votan por clases de objetos y se selecciona la clase de objeto con voto máximo.
+
+
+
+> Imagen de [official paper](https://arxiv.org/abs/1605.06409)
+
+### YOLO - Sólo miras una vez
+
+YOLO es un algoritmo de un solo paso en tiempo real. La idea principal es la siguiente:
+
+ * La imagen está dividida en regiones $S\times S$
+ * Para cada región, **CNN** predice $n$ posibles objetos, *coordenadas del *cuadro delimitador* y *confianza*=*probabilidad* * IoU.
+
+
+
+> Imagen de [official paper](https://arxiv.org/abs/1506.02640)
+
+### Otros algoritmos
+
+* RetinaNet: [official paper](https://arxiv.org/abs/1708.02002)
+ - [PyTorch Implementation in Torchvision](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html)
+ - [Keras Implementation](https://github.com/fizyr/keras-retinanet)
+ - [Object Detection with RetinaNet](https://keras.io/examples/vision/retinanet/) en Keras Samples
+* SSD (Single Shot Detector): [official paper](https://arxiv.org/abs/1512.02325)
+
+ ## ✍️ Ejercicios: Detección de objetos
+
+Continúa tu aprendizaje en el siguiente cuaderno:
+
+[ObjectDetection.ipynb](ObjectDetection.ipynb)
+
+## Conclusión
+
+En esta lección, realizó un recorrido relámpago por las diversas formas en que se puede lograr la detección de objetos.
+
+## 🚀 Desafío
+
+Lea estos artículos y cuadernos sobre YOLO y pruébelos usted mismo.
+
+* [Good blog post](https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-framewor-python/) describiendo YOLO
+ * [Official site](https://pjreddie.com/darknet/yolo/)
+ * Yolo: [Keras implementation](https://github.com/experiencor/keras-yolo2), [step-by-step notebook](https://github.com/experiencor/basic-yolo-keras/blob/master/Yolo%20Step-by-Step.ipynb)
+ * Yolo v2: [Keras implementation](https://github.com/experiencor/keras-yolo2), [step-by-step notebook](https://github.com/experiencor/keras-yolo2/blob/master/Yolo%20Step-by-Step.ipynb)
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/211)
+
+## Revisión y autoestudio
+
+* [Object Detection](https://tjmachinelearning.com/lectures/1718/obj/) by Nikhil Sardana
+* [A good comparison of object detection algorithms](https://lilianweng.github.io/lil-log/2018/12/27/object-detection-part-4.html)
+* [Review of Deep Learning Algorithms for Object Detection](https://medium.com/comet-app/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852)
+* [A Step-by-Step Introduction to the Basic Object Detection Algorithms](https://www.analyticsvidhya.com/blog/2018/10/a-step-by-step-introduction-to-the-basic-object-detection-algorithms-part-1/)
+* [Implementation of Faster R-CNN in Python for Object Detection](https://www.analyticsvidhya.com/blog/2018/11/implementation-faster-r-cnn-python-object-detection/)
+
+## [Assignment: Object Detection](lab/README.md)
+
+
+
+
+
+
+
+
+
From 112e9746fd1f55b1704081bb9281aa0b9f2ff6e8 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Sun, 7 Jan 2024 22:41:50 -0500
Subject: [PATCH 16/33] Create README.es.md
---
.../12-Segmentation/README.es.md | 67 +++++++++++++++++++
1 file changed, 67 insertions(+)
create mode 100644 lessons/4-ComputerVision/12-Segmentation/README.es.md
diff --git a/lessons/4-ComputerVision/12-Segmentation/README.es.md b/lessons/4-ComputerVision/12-Segmentation/README.es.md
new file mode 100644
index 00000000..90c0393e
--- /dev/null
+++ b/lessons/4-ComputerVision/12-Segmentation/README.es.md
@@ -0,0 +1,67 @@
+# Segmentación
+
+Anteriormente aprendimos sobre la Detección de Objetos, que nos permite localizar objetos en la imagen prediciendo sus *cuadros delimitadores*. Sin embargo, para algunas tareas no sólo necesitamos cuadros delimitadores, sino también una localización de objetos más precisa. Esta tarea se llama **segmentación**.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/112)
+
+La segmentación puede verse como una **clasificación de píxeles**, mientras que para **cada** píxel de imagen debemos predecir su clase (*el fondo* es una de las clases). Hay dos algoritmos de segmentación principales:
+
+* **Segmentación semántica** solo indica la clase de píxel y no hace distinción entre diferentes objetos de la misma clase.
+* **La segmentación de instancias** divide las clases en diferentes instancias.
+
+Por ejemplo, en la segmentación, estas ovejas son objetos diferentes, pero para la segmentación semántica todas las ovejas están representadas por una clase.
+
+
+
+> Imagen de [this blog post](https://nirmalamurali.medium.com/image-classification-vs-semantic-segmentation-vs-instance-segmentation-625c33a08d50)
+
+Existen diferentes arquitecturas neuronales para la segmentación, pero todas tienen la misma estructura. En cierto modo, es similar al codificador automático que conoció anteriormente, pero en lugar de deconstruir la imagen original, nuestro objetivo es deconstruir una **máscara**. Así, una red de segmentación tiene las siguientes partes:
+
+* **Codificador** extrae características de la imagen de entrada
+* **Decoder** transforma esas características en la **imagen de máscara**, con el mismo tamaño y número de canales correspondientes al número de clases.
+
+
+
+> Imagen de [this publication](https://arxiv.org/pdf/2001.05566.pdf)
+
+Debemos mencionar especialmente la función de pérdida que se utiliza para la segmentación. Cuando utilizamos codificadores automáticos clásicos, necesitamos medir la similitud entre dos imágenes y podemos usar el error cuadrático medio (MSE) para hacerlo. En la segmentación, cada píxel en la imagen de la máscara de destino representa el número de clase (codificado en caliente a lo largo de la tercera dimensión), por lo que necesitamos usar funciones de pérdida específicas para la clasificación: pérdida de entropía cruzada, promediada sobre todos los píxeles. Si la máscara es binaria, se utiliza **pérdida de entropía cruzada binaria** (BCE).
+
+> ✅ La codificación one-hot es una forma de codificar una etiqueta de clase en un vector de longitud igual al número de clases. Echa un vistazo a [this article](https://datagy.io/sklearn-one-hot-encode/) en esta técnica.
+>
+> ## Segmentación para imágenes médicas
+
+En esta lección, veremos la segmentación en acción entrenando a la red para que reconozca nevos humanos (también conocidos como lunares) en imágenes médicas. Usaremos la PH2 Base de datos de imágenes de dermatoscopia como imagen. fuente. Este conjunto de datos contiene 200 imágenes de tres clases: nevo típico, nevo atípico y melanoma. Todas las imágenes también contienen una **máscara** correspondiente que delinea el nevo.
+
+> ✅ Esta técnica es particularmente apropiada para este tipo de imágenes médicas, pero ¿qué otras aplicaciones en el mundo real podrías imaginar?
+>
+> 
+
+> Imagen de the PH2 Database
+
+Entrenaremos un modelo para segmentar cualquier nevo desde su fondo.
+
+## ✍️ Ejercicios: Segmentación Semántica
+
+Abra los cuadernos siguientes para obtener más información sobre las diferentes arquitecturas de segmentación semántica, practicar cómo trabajar con ellas y verlas en acción.
+
+* [Semantic Segmentation Pytorch](SemanticSegmentationPytorch.ipynb)
+* [Semantic Segmentation TensorFlow](SemanticSegmentationTF.ipynb)
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/212)
+
+## Conclusión
+
+La segmentación es una técnica muy poderosa para la clasificación de imágenes, que va más allá de los cuadros delimitadores a la clasificación a nivel de píxeles. Es una técnica utilizada en imágenes médicas, entre otras aplicaciones.
+
+## 🚀 Desafío
+
+La segmentación corporal es solo una de las tareas comunes que podemos realizar con imágenes de personas. Otras tareas importantes incluyen **detección de esqueleto** y **detección de pose**. Pruebe la biblioteca [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) para ver cómo se puede utilizar la detección de pose.
+
+## Revisión y autoestudio
+
+Es [wikipedia article](https://wikipedia.org/wiki/Image_segmentation) ofrece una buena visión general de las diversas aplicaciones de esta técnica. Obtenga más información por su cuenta sobre los subdominios de segmentación de instancias y segmentación panóptica en este campo de investigación.
+## [Assignment](lab/README.md)
+
+En este laboratorio, intente **human body segmentation** usando [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) de Kaggle.
+
+
From 70e60891f807ec53726a0b7a1822ebc1b4720b0b Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 17:38:10 -0500
Subject: [PATCH 17/33] Create README.es.md
---
lessons/5-NLP/13-TextRep/README.es.md | 73 +++++++++++++++++++++++++++
1 file changed, 73 insertions(+)
create mode 100644 lessons/5-NLP/13-TextRep/README.es.md
diff --git a/lessons/5-NLP/13-TextRep/README.es.md b/lessons/5-NLP/13-TextRep/README.es.md
new file mode 100644
index 00000000..d952a199
--- /dev/null
+++ b/lessons/5-NLP/13-TextRep/README.es.md
@@ -0,0 +1,73 @@
+# Representando el texto como tensoras
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/113)
+
+## Clasificación de texto
+
+A lo largo de la primera parte de esta sección, nos centraremos en la tarea de **clasificación de texto**. Usaremos el [AG News](https://www.kaggle.com/amananandrai/ag-news-classification-dataset) Conjunto de datos, que contiene artículos de noticias como los siguientes:
+
+* Categoría: Ciencia/Tecnología
+* Título: Ky. Company gana una subvención para estudiar péptidos (AP)
+*Cuerpo: AP - Una empresa fundada por un investigador de química de la Universidad de Louisville ganó una subvención para desarrollar...
+
+Nuestro objetivo será clasificar la noticia en una de las categorías basadas en texto.
+
+## Representando texto
+
+Si queremos resolver tareas de procesamiento del lenguaje natural (PNL) con redes neuronales, necesitamos alguna forma de representar el texto como tensores. Las computadoras ya representan caracteres textuales como números que se asignan a fuentes en la pantalla mediante codificaciones como ASCII o UTF-8.
+
+
+
+> [Image source](https://www.seobility.net/en/wiki/ASCII)
+
+Como seres humanos, entendemos lo que **representa** cada letra y cómo todos los caracteres se unen para formar las palabras de una oración. Sin embargo, los ordenadores por sí solos no tienen esa comprensión y las redes neuronales tienen que aprender el significado durante el entrenamiento.
+
+Por tanto, podemos utilizar diferentes enfoques a la hora de representar texto:
+
+* **Representación a nivel de carácter**, cuando representamos texto tratando cada carácter como un número. Dado que tenemos *C* caracteres diferentes en nuestro corpus de texto, la palabra *Hola* estaría representada por el tensor 5x*C*. Cada letra correspondería a una columna tensorial en codificación one-hot.
+* **Representación a nivel de palabra**, en la que creamos un **vocabulario** de todas las palabras de nuestro texto y luego las representamos usando codificación one-hot. Este enfoque es algo mejor, porque cada letra por sí sola no tiene mucho significado y, por lo tanto, al utilizar conceptos semánticos de nivel superior (palabras), simplificamos la tarea de la red neuronal. Sin embargo, dado el gran tamaño del diccionario, debemos lidiar con tensores dispersos de alta dimensión.
+
+Independientemente de la representación, primero debemos convertir el texto en una secuencia de **tokens**, siendo un token un carácter, una palabra o, a veces, incluso parte de una palabra. Luego, convertimos el token en un número, normalmente usando **vocabulario**, y este número se puede introducir en una red neuronal mediante codificación one-hot.
+
+## N-Gramos
+
+En el lenguaje natural, el significado preciso de las palabras sólo puede determinarse en contexto. Por ejemplo, los significados de *red neuronal* y *red de pesca* son completamente diferentes. Una de las formas de tener esto en cuenta es construir nuestro modelo sobre pares de palabras y considerar los pares de palabras como fichas de vocabulario separadas. De esta forma, la frase *me gusta ir a pescar* quedará representada por la siguiente secuencia de fichas: *me gusta*, *me gusta*, *ir*, *ir a pescar*. El problema con este enfoque es que el tamaño del diccionario crece significativamente y combinaciones como *ir a pescar* y *ir de compras* se presentan mediante tokens diferentes, que no comparten ninguna similitud semántica a pesar del mismo verbo.
+
+En algunos casos, también podemos considerar el uso de trigramas (combinaciones de tres palabras). Por lo tanto, el enfoque a menudo se denomina **n-gramas**. Además, tiene sentido utilizar n-gramas con representación a nivel de carácter, en cuyo caso los n-gramas corresponderán aproximadamente a diferentes programas de estudio.
+
+## Bolsa de palabras y TF/IDF
+
+Al resolver tareas como la clasificación de texto, debemos poder representar el texto mediante un vector de tamaño fijo, que usaremos como entrada para el clasificador denso final. Una de las formas más sencillas de hacerlo es combinar todas las representaciones de palabras individuales, por ejemplo. agregándolos. Si agregamos codificaciones one-hot de cada palabra, terminaremos con un vector de frecuencias, que muestra cuántas veces aparece cada palabra dentro del texto. Esta representación de texto se llama **bolsa de palabras** (BoW).
+
+
+
+> Image by the author
+
+Un BoW esencialmente representa qué palabras aparecen en el texto y en qué cantidades, lo que de hecho puede ser una buena indicación de de qué trata el texto. Por ejemplo, es probable que un artículo de noticias sobre política contenga palabras como *presidente* y *país*, mientras que una publicación científica tendría algo como *colisionador*, *descubierto*, etc. Por lo tanto, la frecuencia de las palabras puede en muchos casos ser una buena indicador del contenido del texto.
+
+El problema con BoW es que ciertas palabras comunes, como *and*, *is*, etc. aparecen en la mayoría de los textos y tienen frecuencias más altas, enmascarando las palabras que son realmente importantes. Podemos reducir la importancia de esas palabras teniendo en cuenta la frecuencia con la que aparecen en toda la colección de documentos. Esta es la idea principal detrás del enfoque TF/IDF, que se trata con más detalle en los cuadernos adjuntos a esta lección.
+
+Sin embargo, ninguno de esos enfoques puede tener en cuenta plenamente la **semántica** del texto. Necesitamos modelos de redes neuronales más potentes para hacer esto, lo cual discutiremos más adelante en esta sección.
+
+## ✍️ Ejercicios: Representación de Texto
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [Text Representation with PyTorch](TextRepresentationPyTorch.ipynb)
+* [Text Representation with TensorFlow](TextRepresentationTF.ipynb)
+
+## Conclusión
+
+Hasta ahora, hemos estudiado técnicas que pueden agregar peso de frecuencia a diferentes palabras. Sin embargo, no pueden representar significado u orden. Como dijo el famoso lingüista J. R. Firth en 1935: "El significado completo de una palabra es siempre contextual, y ningún estudio del significado aparte del contexto puede tomarse en serio". Más adelante en el curso aprenderemos cómo capturar información contextual del texto utilizando modelos de lenguaje.
+
+## 🚀 Desafío
+
+Pruebe otros ejercicios utilizando una bolsa de palabras y diferentes modelos de datos. Quizás te inspire esto [competition on Kaggle](https://www.kaggle.com/competitions/word2vec-nlp-tutorial/overview/part-1-for-beginners-bag-of-words)
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/213)
+
+## Revisión y autoestudio
+
+Practica tus habilidades con incrustaciones de texto y técnicas de bolsa de palabras en [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste)
+
+## [Assignment: Notebooks](assignment.md)
From d282cfad5b5867908b32db659334afe84fe16318 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 17:48:19 -0500
Subject: [PATCH 18/33] Create README.es.md
---
lessons/5-NLP/14-Embeddings/README.es.md | 66 ++++++++++++++++++++++++
1 file changed, 66 insertions(+)
create mode 100644 lessons/5-NLP/14-Embeddings/README.es.md
diff --git a/lessons/5-NLP/14-Embeddings/README.es.md b/lessons/5-NLP/14-Embeddings/README.es.md
new file mode 100644
index 00000000..cf258e67
--- /dev/null
+++ b/lessons/5-NLP/14-Embeddings/README.es.md
@@ -0,0 +1,66 @@
+# incrustaciones
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/114)
+
+Cuando entrenábamos clasificadores basados en BoW o TF/IDF, operamos con vectores de bolsa de palabras de alta dimensión con longitud "vocab_size", y convertíamos explícitamente desde vectores de representación posicional de baja dimensión a una representación única y dispersa. Sin embargo, esta representación única no es eficiente en cuanto a memoria. Además, cada palabra se trata de forma independiente entre sí, es decir, los vectores codificados en caliente no expresan ninguna similitud semántica entre palabras.
+
+La idea de **incrustar** es representar palabras mediante vectores densos de dimensiones inferiores, que de alguna manera reflejan el significado semántico de una palabra. Más adelante discutiremos cómo crear incrustaciones de palabras significativas, pero por ahora pensemos en las incrustaciones como una forma de reducir la dimensionalidad de un vector de palabras.
+
+Entonces, la capa de incrustación tomaría una palabra como entrada y produciría un vector de salida del `embedding_size` especificado. En cierto sentido, es muy similar a una capa "Lineal", pero en lugar de tomar un vector codificado en caliente, podrá tomar un número de palabra como entrada, lo que nos permitirá evitar la creación de grandes archivos codificados en caliente. vectores.
+
+Al usar una capa de incrustación como primera capa en nuestra red clasificadora, podemos cambiar de una bolsa de palabras al modelo de **bolsa de incrustación**, donde primero convertimos cada palabra en nuestro texto en la incrustación correspondiente y luego calculamos algunas función agregada sobre todas esas incrustaciones, como "suma", "promedio" o "máximo".
+
+
+
+> Imagen del autor
+
+## ✍️ Ejercicios: Incrustaciones
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+* [Embeddings with PyTorch](EmbeddingsPyTorch.ipynb)
+* [Embeddings TensorFlow](EmbeddingsTF.ipynb)
+
+## Incrustaciones semánticas: Word2Vec
+
+Si bien la capa de incrustación aprendió a asignar palabras a una representación vectorial, esta representación no necesariamente tenía mucho significado semántico. Sería bueno aprender una representación vectorial de modo que palabras similares o sinónimos correspondan a vectores que estén cerca entre sí en términos de alguna distancia vectorial (por ejemplo, distancia euclidiana).
+
+Para hacer eso, necesitamos entrenar previamente nuestro modelo de incrustación en una gran colección de texto de una manera específica. Una forma de entrenar incrustaciones semánticas se llama [Word2Vec](https://en.wikipedia.org/wiki/Word2vec). Se basa en dos arquitecturas principales que se utilizan para producir una representación distribuida de palabras:
+
+ - **Bolsa de palabras continua** (CBoW): en esta arquitectura, entrenamos el modelo para predecir una palabra a partir del contexto circundante. Dado el ngrama $(W_{-2},W_{-1},W_0,W_1,W_2)$, el objetivo del modelo es predecir $W_0$ a partir de $(W_{-2},W_{-1} ,W_1,W_2)$.
+ - **Salto continuo de gramo** es opuesto a CBoW. El modelo utiliza una ventana circundante de palabras de contexto para predecir la palabra actual.
+
+CBoW es más rápido, mientras que skip-gram es más lento, pero representa mejor palabras poco frecuentes.
+
+
+
+> Imagen de [this paper](https://arxiv.org/pdf/1301.3781.pdf)
+
+Las incrustaciones previamente entrenadas de Word2Vec (así como otros modelos similares, como GloVe) también se pueden usar en lugar de la capa de incrustación en redes neuronales. Sin embargo, debemos ocuparnos de los vocabularios, porque es probable que el vocabulario utilizado para entrenar previamente Word2Vec/GloVe difiera del vocabulario de nuestro corpus de texto. Eche un vistazo a los cuadernos anteriores para ver cómo se puede resolver este problema.
+
+## Incrustaciones contextuales
+
+Una limitación clave de las representaciones de incrustación tradicionales previamente entrenadas, como Word2Vec, es el problema de la desambiguación del sentido de las palabras. Si bien las incrustaciones previamente entrenadas pueden capturar parte del significado de las palabras en contexto, cada significado posible de una palabra está codificado en la misma incrustación. Esto puede causar problemas en los modelos posteriores, ya que muchas palabras, como la palabra "jugar", tienen diferentes significados según el contexto en el que se utilizan.
+
+Por ejemplo, la palabra "jugar" en esas dos oraciones diferentes tiene un significado bastante diferente:
+
+- Fui a una **obra** en el teatro.
+- John quiere **jugar** con sus amigos.
+
+Las incrustaciones previamente entrenadas anteriores representan ambos significados de la palabra "jugar" en la misma incrustación. Para superar esta limitación, necesitamos crear incrustaciones basadas en el **modelo de lenguaje**, que se entrena en un gran corpus de texto y *sabe* cómo se pueden juntar las palabras en diferentes contextos. Hablar de incrustaciones contextuales está fuera del alcance de este tutorial, pero volveremos a ellas cuando hablemos de modelos de lenguaje más adelante en el curso.
+
+## Conclusión
+
+En esta lección, descubrió cómo crear y utilizar capas incrustadas en TensorFlow y Pytorch para reflejar mejor los significados semánticos de las palabras.
+
+## 🚀 Desafío
+
+Word2Vec se ha utilizado para algunas aplicaciones interesantes, incluida la generación de letras de canciones y poesía. Eche un vistazo a [este artículo](https://www.politetype.com/blog/word2vec-color-poems) que explica cómo el autor utilizó Word2Vec para generar poesía. Mirar [this video by Dan Shiffmann](https://www.youtube.com/watch?v=LSS_bos_TPI&ab_channel=TheCodingTrain) así como descubrir una explicación diferente de esta técnica. Luego intente aplicar estas técnicas a su propio corpus de texto, tal vez obtenido de Kaggle.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/214)
+
+## Revisión y autoestudio
+
+Lea este documento sobre Word2Vec: [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/pdf/1301.3781.pdf)
+
+## [Assignment: Notebooks](assignment.md)
+
From 4265dc1b553f1bd0f7dc4381f2215ae7e0629e02 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 17:54:52 -0500
Subject: [PATCH 19/33] Create README.es.md
---
.../5-NLP/15-LanguageModeling/README.es.md | 43 +++++++++++++++++++
1 file changed, 43 insertions(+)
create mode 100644 lessons/5-NLP/15-LanguageModeling/README.es.md
diff --git a/lessons/5-NLP/15-LanguageModeling/README.es.md b/lessons/5-NLP/15-LanguageModeling/README.es.md
new file mode 100644
index 00000000..49c4df31
--- /dev/null
+++ b/lessons/5-NLP/15-LanguageModeling/README.es.md
@@ -0,0 +1,43 @@
+# Modelado de lenguaje
+
+Las incrustaciones semánticas, como Word2Vec y GloVe, son de hecho un primer paso hacia el **modelado del lenguaje**: crear modelos que de alguna manera *comprenden* (o *representan*) la naturaleza del lenguaje.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/115)
+
+La idea principal detrás del modelado de lenguajes es entrenarlos en conjuntos de datos sin etiquetar y sin supervisión. Esto es importante porque tenemos grandes cantidades de texto sin etiquetar disponibles, mientras que la cantidad de texto etiquetado siempre estará limitada por la cantidad de esfuerzo que podamos dedicar al etiquetado. En la mayoría de los casos, podemos crear modelos de lenguaje que pueden **predecir las palabras que faltan** en el texto, porque es fácil enmascarar una palabra aleatoria en el texto y usarla como muestra de entrenamiento.
+
+## Integraciones de entrenamiento
+
+En nuestros ejemplos anteriores, utilizamos incorporaciones semánticas previamente entrenadas, pero es interesante ver cómo se pueden entrenar esas incorporaciones. Hay varias ideas posibles que se pueden utilizar:
+
+* Modelado de lenguaje **N-Gram**, cuando predecimos un token observando N tokens anteriores (N-gram)
+* **Bolsa de palabras continua** (CBoW), cuando predecimos el token medio $W_0$ en una secuencia de tokens $W_{-N}$, ..., $W_N$.
+* **Skip-gram**, donde predecimos un conjunto de tokens vecinos {$W_{-N},\dots, W_{-1}, W_1,\dots, W_N$} del token del medio $W_0$.
+
+
+
+> Imagen de [this paper](https://arxiv.org/pdf/1301.3781.pdf)
+
+## ✍️ Cuadernos de ejemplo: Entrenamiento del modelo CBoW
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [Training CBoW Word2Vec with TensorFlow](CBoW-TF.ipynb)
+* [Training CBoW Word2Vec with PyTorch](CBoW-PyTorch.ipynb)
+
+## Conclusión
+
+¡En la lección anterior vimos que las incrustaciones de palabras funcionan como magia! Ahora sabemos que entrenar incrustaciones de palabras no es una tarea muy compleja y, si es necesario, deberíamos poder entrenar nuestras propias incrustaciones de palabras para texto de dominio específico.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/215)
+
+## Revisión y autoestudio
+
+* [Official PyTorch tutorial on Language Modeling](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html).
+* [Official TensorFlow tutorial on training Word2Vec model](https://www.TensorFlow.org/tutorials/text/word2vec).
+* Se describe el uso del marco **gensim** para entrenar las incrustaciones más utilizadas en unas pocas líneas de código [in this documentation](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html).
+
+## 🚀 [Assignment: Train Skip-Gram Model](lab/README.md)
+
+In the lab, we challenge you to modify the code from this lesson to train skip-gram model instead of CBoW.[Read the details](lab/README.md)
+
From c23a54ddce7ffb8d1b3abb96cc6907525cf5b147 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 18:06:37 -0500
Subject: [PATCH 20/33] Create README.es.md
---
lessons/5-NLP/16-RNN/README.es.md | 87 +++++++++++++++++++++++++++++++
1 file changed, 87 insertions(+)
create mode 100644 lessons/5-NLP/16-RNN/README.es.md
diff --git a/lessons/5-NLP/16-RNN/README.es.md b/lessons/5-NLP/16-RNN/README.es.md
new file mode 100644
index 00000000..a94346d5
--- /dev/null
+++ b/lessons/5-NLP/16-RNN/README.es.md
@@ -0,0 +1,87 @@
+# Redes neuronales recurrentes
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/116)
+
+En secciones anteriores, hemos estado utilizando representaciones semánticas ricas de texto y un clasificador lineal simple además de las incrustaciones. Lo que hace esta arquitectura es capturar el significado agregado de las palabras en una oración, pero no tiene en cuenta el **orden** de las palabras, porque la operación de agregación además de las incrustaciones eliminó esta información del texto original. Debido a que estos modelos no pueden modelar el orden de las palabras, no pueden resolver tareas más complejas o ambiguas, como la generación de texto o la respuesta a preguntas.
+
+Para capturar el significado de la secuencia de texto, necesitamos utilizar otra arquitectura de red neuronal, que se denomina **red neuronal recurrente** o RNN. En RNN, pasamos nuestra oración a través de la red, un símbolo a la vez, y la red produce algún **estado**, que luego pasamos a la red nuevamente con el siguiente símbolo.
+
+
+
+> Imagen del autor
+
+Dada la secuencia de entrada de tokens X0,...,Xn, RNN crea una secuencia de bloques de red neuronal y entrena esta secuencia de un extremo a otro mediante retropropagación. . Cada bloque de red toma un par (Xi,Si) como entrada y produce Si+1 como resultado. El estado final Sn o (salida Yn) entra en un clasificador lineal para producir el resultado. Todos los bloques de red comparten los mismos pesos y se entrenan de un extremo a otro mediante un paso de retropropagación.
+
+Debido a que los vectores de estado S0,...,Sn pasan a través de la red, es posible aprender las dependencias secuenciales entre palabras. Por ejemplo, cuando la palabra *no* aparece en algún lugar de la secuencia, puede aprender a negar ciertos elementos dentro del vector de estado, lo que resulta en negación.
+
+> ✅ Dado que los pesos de todos los bloques RNN en la imagen de arriba son compartidos, la misma imagen se puede representar como un bloque (a la derecha) con un bucle de retroalimentación recurrente, que devuelve el estado de salida de la red a la entrada.
+
+## Anatomía de una célula RNN
+
+Veamos cómo se organiza una celda RNN simple. Acepta el estado anterior Si-1 y el símbolo actual Xi como entradas, y tiene que producir el estado de salida Si (y, A veces, también estamos interesados en algún otro resultado Yi,como en el caso de las redes generativas).
+
+Una celda RNN simple tiene dos matrices de peso en su interior: una transforma un símbolo de entrada (llamémoslo W) y otra transforma un estado de entrada (H). En este caso, la salida de la red se calcula como σ(W×Xi+H×Si-1+b), donde σ es la función de activación y b es el sesgo adicional.
+
+
+
+> Imagen del autor
+
+En muchos casos, los tokens de entrada pasan a través de la capa de incrustación antes de ingresar al RNN para reducir la dimensionalidad. En este caso, si la dimensión de los vectores de entrada es *emb_size* y el vector de estado es *hid_size*, el tamaño de W es *emb_size*×*hid_size* y el tamaño de H es *hid_size*×* tamaño_hid*.
+
+## Memoria a largo plazo (LSTM)
+
+Uno de los principales problemas de los RNN clásicos es el llamado problema de los **gradientes de fuga**. Debido a que los RNN se entrenan de un extremo a otro en un paso de retropropagación, tienen dificultades para propagar el error a las primeras capas de la red y, por lo tanto, la red no puede aprender las relaciones entre tokens distantes. Una de las formas de evitar este problema es introducir **administración de estado explícita** mediante el uso de las llamadas **puertas**. Hay dos arquitecturas bien conocidas de este tipo: **Memoria a corto plazo** (LSTM) y **Unidad de retransmisión cerrada** (GRU).
+
+
+
+> Fuente de la imagen por determinar
+
+La red LSTM está organizada de manera similar a RNN, pero hay dos estados que se pasan de una capa a otra: el estado real C y el vector oculto H. En cada unidad, el vector oculto Hi< /sub> está concatenado con la entrada Xi, y controlan lo que sucede con el estado C a través de **puertas**. Cada puerta es una red neuronal con activación sigmoidea (salida en el rango [0,1]), que puede considerarse como una máscara bit a bit cuando se multiplica por el vector de estado. Existen las siguientes puertas (de izquierda a derecha en la imagen de arriba):
+
+* La **puerta del olvido** toma un vector oculto y determina qué componentes del vector C debemos olvidar y por cuáles pasar.
+* La **puerta de entrada** toma información de los vectores ocultos y de entrada y la inserta en el estado.
+* La **puerta de salida** transforma el estado a través de una capa lineal con activación *tanh*, luego selecciona algunos de sus componentes usando un vector oculto Hi para producir un nuevo estado Ci+ 1.
+
+Los componentes del estado C pueden considerarse como algunas banderas que se pueden activar y desactivar. Por ejemplo, cuando encontramos un nombre *Alice* en la secuencia, podemos asumir que se refiere a un personaje femenino y levantar la bandera en el estado de que tenemos un sustantivo femenino en la oración. Cuando encontremos más frases *y Tom*, levantaremos la bandera de que tenemos un sustantivo plural. Así, manipulando el estado supuestamente podemos realizar un seguimiento de las propiedades gramaticales de las partes de la oración.
+
+> ✅ Un excelente recurso para comprender los aspectos internos de LSTM es este excelente artículo [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/)
+>
+> ## RNN bidireccionales y multicapa
+
+Hemos discutido redes recurrentes que operan en una dirección, desde el principio de una secuencia hasta el final. Parece natural porque se parece a la forma en que leemos y escuchamos el habla. Sin embargo, dado que en muchos casos prácticos tenemos acceso aleatorio a la secuencia de entrada, podría tener sentido ejecutar cálculos recurrentes en ambas direcciones. Estas redes se denominan RNN **bidireccionales**. Cuando se trata de una red bidireccional, necesitaríamos dos vectores de estado ocultos, uno para cada dirección.
+
+Una red recurrente, ya sea unidireccional o bidireccional, captura ciertos patrones dentro de una secuencia y puede almacenarlos en un vector de estado o pasarlos a la salida. Al igual que con las redes convolucionales, podemos construir otra capa recurrente encima de la primera para capturar patrones de nivel superior y construir a partir de patrones de bajo nivel extraídos por la primera capa. Esto nos lleva a la noción de un **RNN multicapa** que consta de dos o más redes recurrentes, donde la salida de la capa anterior se pasa a la siguiente capa como entrada.
+
+
+
+*Photo de [this wonderful post](https://towardsdatascience.com/from-a-lstm-cell-to-a-multilayer-lstm-network-with-pytorch-2899eb5696f3) by Fernando López*
+
+## ✍️ Ejercicios: Incrustaciones
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [RNNs with PyTorch](RNNPyTorch.ipynb)
+* [RNNs with TensorFlow](RNNTF.ipynb)
+
+## Conclusión
+
+En esta unidad, hemos visto que los RNN se pueden usar para la clasificación de secuencias, pero de hecho, pueden manejar muchas más tareas, como generación de texto, traducción automática y más. Consideraremos esas tareas en la siguiente unidad.
+
+## 🚀 Desafío
+
+Lea algo de literatura sobre LSTM y considere sus aplicaciones:
+
+- [Grid Long Short-Term Memory](https://arxiv.org/pdf/1507.01526v1.pdf)
+- [Show, Attend and Tell: Neural Image Caption
+Generation with Visual Attention](https://arxiv.org/pdf/1502.03044v2.pdf)
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/216)
+
+## Revisión y autoestudio
+
+- [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) by Christopher Olah.
+
+## [Assignment: Notebooks](assignment.md)
+
+
+
From 5a780a96b330995b04f88c2a9b10de2801f87d25 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:11:42 -0500
Subject: [PATCH 21/33] Create README.es.md
---
.../5-NLP/17-GenerativeNetworks/README.es.md | 76 +++++++++++++++++++
1 file changed, 76 insertions(+)
create mode 100644 lessons/5-NLP/17-GenerativeNetworks/README.es.md
diff --git a/lessons/5-NLP/17-GenerativeNetworks/README.es.md b/lessons/5-NLP/17-GenerativeNetworks/README.es.md
new file mode 100644
index 00000000..c3711969
--- /dev/null
+++ b/lessons/5-NLP/17-GenerativeNetworks/README.es.md
@@ -0,0 +1,76 @@
+# Redes generativas
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/117)
+
+Las redes neuronales recurrentes (RNN) y sus variantes de células cerradas, como las células de memoria a corto plazo (LSTM) y las unidades recurrentes cerradas (GRU), proporcionaron un mecanismo para el modelado del lenguaje en el sentido de que pueden aprender el orden de las palabras y proporcionar predicciones para la siguiente palabra en un secuencia. Esto nos permite utilizar RNN para **tareas generativas**, como la generación de texto normal, la traducción automática e incluso los subtítulos de imágenes.
+
+> ✅ Piensa en todas las veces que te has beneficiado de tareas generativas como completar texto mientras escribes. Investigue un poco sobre sus aplicaciones favoritas para ver si aprovecharon los RNN.
+
+En la arquitectura RNN que analizamos en la unidad anterior, cada unidad RNN produjo el siguiente estado oculto como salida. Sin embargo, también podemos agregar otra salida a cada unidad recurrente, lo que nos permitiría generar una **secuencia** (que tiene la misma longitud que la secuencia original). Además, podemos usar unidades RNN que no aceptan una entrada en cada paso, y simplemente toman algún vector de estado inicial y luego producen una secuencia de salidas.
+
+Esto permite diferentes arquitecturas neuronales que se muestran en la siguiente imagen:
+
+
+
+> Imagen de la publicación del blog [Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) by [Andrej Karpaty](http://karpathy.github.io/)
+>
+> * **Uno a uno** es una red neuronal tradicional con una entrada y una salida
+* **Uno a muchos** es una arquitectura generativa que acepta un valor de entrada y genera una secuencia de valores de salida. Por ejemplo, si queremos entrenar una red de **subtítulos de imágenes** que produzca una descripción textual de una imagen, podemos usar una imagen como entrada, pasarla a través de una CNN para obtener su estado oculto y luego tener una cadena recurrente. generar subtítulos palabra por palabra
+* **Muchos a uno** corresponde a las arquitecturas RNN que describimos en la unidad anterior, como la clasificación de texto.
+* **Muchos a muchos**, o **secuencia a secuencia** corresponde a tareas como **traducción automática**, donde primero hacemos que RNN recopile toda la información de la secuencia de entrada al estado oculto. y otra cadena RNN desenrolla este estado en la secuencia de salida.
+
+En esta unidad, nos centraremos en modelos generativos simples que nos ayudan a generar texto. Para simplificar, utilizaremos la tokenización a nivel de personaje.
+
+Entrenaremos a este RNN para generar texto paso a paso. En cada paso, tomaremos una secuencia de caracteres de longitud `nchars` y le pediremos a la red que genere el siguiente carácter de salida para cada carácter de entrada:
+
+
+
+Al generar texto (durante la inferencia), comenzamos con algún **mensaje**, que se pasa a través de las celdas RNN para generar su estado intermedio, y luego desde este estado comienza la generación. Generamos un carácter a la vez y pasamos el estado y el carácter generado a otra celda RNN para generar la siguiente, hasta que generemos suficientes caracteres.
+
+
+
+> Image by the author
+
+## ✍️ Ejercicios: Redes Generativas
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [Generative Networks with PyTorch](GenerativePyTorch.ipynb)
+* [Generative Networks with TensorFlow](GenerativeTF.ipynb)
+
+## Generación de texto suave y temperatura
+
+La salida de cada celda RNN es una distribución de probabilidad de caracteres. Si siempre tomamos el carácter con mayor probabilidad como el siguiente carácter en el texto generado, el texto a menudo puede "ciclarse" entre las mismas secuencias de caracteres una y otra vez, como en este ejemplo:
+
+```
+hoy del segundo la empresa y un segundo la empresa…
+```
+
+Sin embargo, si observamos la distribución de probabilidad del siguiente carácter, podría ser que la diferencia entre algunas probabilidades más altas no sea enorme, p. un carácter puede tener una probabilidad de 0,2, otro - 0,19, etc. Por ejemplo, cuando se busca el siguiente carácter en la secuencia '*play*', el siguiente carácter puede ser igualmente un espacio o **e** (como en el palabra *jugador*).
+
+Esto nos lleva a la conclusión de que no siempre es "justo" seleccionar el personaje con mayor probabilidad, porque elegir el segundo más alto aún podría llevarnos a un texto significativo. Es más prudente **muestrear** caracteres de la distribución de probabilidad proporcionada por la salida de la red. También podemos usar un parámetro, **temperatura**, que aplanará la distribución de probabilidad, en caso de que queramos agregar más aleatoriedad, o hacerla más pronunciada, si queremos ceñirnos más a los caracteres de mayor probabilidad.
+
+Explore cómo se implementa esta generación de texto suave en los cuadernos vinculados anteriormente.
+
+## Conclusión
+
+Si bien la generación de texto puede ser útil por sí sola, los principales beneficios provienen de la capacidad de generar texto utilizando RNN a partir de algún vector de características inicial. Por ejemplo, la generación de texto se utiliza como parte de la traducción automática (secuencia a secuencia, en este caso el vector de estado del *codificador* se utiliza para generar o *decodificar* el mensaje traducido), o generar una descripción textual de una imagen (en la que caso, el vector de características provendría del extractor de CNN).
+
+## 🚀 Desafío
+
+Tome algunas lecciones en Microsoft Learn sobre este tema
+
+* Generación de texto con [PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/6-generative-networks/?WT.mc_id=academic-77998-cacaste)/[TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/5-generative-networks/?WT.mc_id=academic-77998-cacaste)
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/217)
+
+## Revisión y autoestudio
+
+Aquí te dejamos algunos artículos para ampliar tus conocimientos.
+
+* Diferentes enfoques para la generación de texto con Markov Chain, LSTM y GPT-2: [blog post](https://towardsdatascience.com/text-generation-gpt-2-lstm-markov-chain-9ea371820e1e)
+* Text generation sample in [Keras documentation](https://keras.io/examples/generative/lstm_character_level_text_generation/)
+
+## [Assignment](lab/README.md)
+
+Hemos visto cómo generar texto carácter por carácter. En la práctica de laboratorio, explorará la generación de texto a nivel de palabra.
From 431f5e5631cff559aff174bddf361b8584d83a27 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:25:53 -0500
Subject: [PATCH 22/33] Create README.es.md
---
lessons/5-NLP/18-Transformers/README.es.md | 111 +++++++++++++++++++++
1 file changed, 111 insertions(+)
create mode 100644 lessons/5-NLP/18-Transformers/README.es.md
diff --git a/lessons/5-NLP/18-Transformers/README.es.md b/lessons/5-NLP/18-Transformers/README.es.md
new file mode 100644
index 00000000..7092a787
--- /dev/null
+++ b/lessons/5-NLP/18-Transformers/README.es.md
@@ -0,0 +1,111 @@
+# Mecanismos de Atención y Transformadores
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/118)
+
+Uno de los problemas más importantes en el ámbito de la PNL es la **traducción automática**, una tarea esencial en la que se basan herramientas como Google Translate. En esta sección, nos centraremos en la traducción automática o, más generalmente, en cualquier tarea de *secuencia a secuencia* (que también se denomina **transducción de oraciones**).
+
+Con los RNN, la secuencia a secuencia se implementa mediante dos redes recurrentes, donde una red, el **codificador**, colapsa una secuencia de entrada en un estado oculto, mientras que otra red, el **decodificador**, desenrolla este estado oculto. en un resultado traducido. Hay un par de problemas con este enfoque:
+
+* El estado final de la red del codificador tiene dificultades para recordar el comienzo de una oración, lo que provoca una mala calidad del modelo para oraciones largas.
+* Todas las palabras de una secuencia tienen el mismo impacto en el resultado. En realidad, sin embargo, palabras específicas en la secuencia de entrada a menudo tienen más impacto que otras en las salidas secuenciales.
+
+Los **Mecanismos de atención** proporcionan un medio para ponderar el impacto contextual de cada vector de entrada en cada predicción de salida del RNN. La forma en que se implementa es creando accesos directos entre los estados intermedios del RNN de entrada y el RNN de salida. De esta manera, al generar el símbolo de salida yt, tendremos en cuenta todos los estados ocultos de entrada hi, con diferentes coeficientes de peso αt,i< /sub>.
+
+
+
+> El modelo codificador-decodificador con mecanismo de atención aditiva en [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf), citado de [this blog post](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)
+
+La matriz de atención {αi,j} representaría el grado que ciertas palabras de entrada juegan en la generación de una palabra determinada en la secuencia de salida. A continuación se muestra un ejemplo de dicha matriz:
+
+
+
+> Figura de [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf) (Fig.3)
+
+Los mecanismos de atención son responsables de gran parte del estado actual o casi actual de la PNL. Sin embargo, agregar atención aumenta en gran medida la cantidad de parámetros del modelo, lo que generó problemas de escala con los RNN. Una limitación clave del escalamiento de RNN es que la naturaleza recurrente de los modelos dificulta el entrenamiento por lotes y paralelizado. En un RNN, cada elemento de una secuencia debe procesarse en orden secuencial, lo que significa que no se puede paralelizar fácilmente.
+
+
+
+> Figura de [Google's Blog](https://research.googleblog.com/2016/09/a-neural-network-for-machine.html)
+
+La adopción de mecanismos de atención combinada con esta restricción llevó a la creación de los modelos de transformadores de última generación que conocemos y utilizamos hoy, como BERT para Open-GPT3.
+
+## Modelos de transformadores
+
+Una de las ideas principales detrás de los transformadores es evitar la naturaleza secuencial de los RNN y crear un modelo que sea paralelizable durante el entrenamiento. Esto se logra implementando dos ideas:
+
+* codificación posicional
+* usar un mecanismo de autoatención para capturar patrones en lugar de RNN (o CNN) (por eso el artículo que presenta los transformadores se llama *[La atención es todo lo que necesitas](https://arxiv.org/abs/1706.03762)*
+
+### Codificación/incrustación posicional
+
+La idea de codificación posicional es la siguiente.
+1. Cuando se utilizan RNN, la posición relativa de los tokens está representada por el número de pasos y, por lo tanto, no es necesario representarla explícitamente.
+2. Sin embargo, una vez que pasamos a prestar atención, necesitamos conocer las posiciones relativas de las fichas dentro de una secuencia.
+3. Para obtener codificación posicional, aumentamos nuestra secuencia de tokens con una secuencia de posiciones de tokens en la secuencia (es decir, una secuencia de números 0,1,...).
+4. Luego mezclamos la posición del token con un vector de incrustación del token. Para transformar la posición (entero) en un vector, podemos utilizar diferentes enfoques:
+
+* Incrustación entrenable, similar a la incrustación de tokens. Este es el enfoque que consideramos aquí. Aplicamos capas de incrustación sobre ambos tokens y sus posiciones, lo que da como resultado vectores de incrustación de las mismas dimensiones, que luego sumamos.
+* Función de codificación de posición fija, como se propone en el artículo original.
+
+
+
+> Imagen del autor
+
+El resultado que obtenemos con la incrustación posicional incrusta tanto el token original como su posición dentro de una secuencia.
+
+### Autoatención de múltiples cabezas
+
+A continuación, necesitamos capturar algunos patrones dentro de nuestra secuencia. Para hacer esto, los transformadores utilizan un mecanismo de **autoatención**, que es esencialmente atención aplicada a la misma secuencia que la entrada y la salida. Aplicar la atención personal nos permite tener en cuenta el **contexto** dentro de la oración y ver qué palabras están interrelacionadas. Por ejemplo, nos permite ver a qué palabras se hace referencia mediante correferencias, como *it*, y también tener en cuenta el contexto:
+
+
+
+> Imagen de [Google Blog](https://research.googleblog.com/2017/08/transformer-novel-neural-network.html)
+
+En los transformadores, utilizamos **Atención de múltiples cabezales** para darle a la red el poder de capturar varios tipos diferentes de dependencias, por ejemplo. relaciones de palabras a largo plazo versus a corto plazo, correferencia versus otra cosa, etc.
+
+[TensorFlow Notebook](TransformersTF.ipynb) contiene más detalles sobre la implementación de capas transformadoras.
+
+### Atención codificador-decodificador
+
+En los transformadores, la atención se utiliza en dos lugares:
+
+* Para capturar patrones dentro del texto ingresado usando la atención propia
+* Para realizar la traducción de secuencias: es la capa de atención entre el codificador y el decodificador.
+
+La atención del codificador-decodificador es muy similar al mecanismo de atención utilizado en los RNN, como se describe al principio de esta sección. Este diagrama animado explica el papel de la atención del codificador-decodificador.
+
+
+
+Dado que cada posición de entrada se asigna de forma independiente a cada posición de salida, los transformadores pueden paralelizarse mejor que los RNN, lo que permite modelos de lenguaje mucho más grandes y expresivos. Cada cabeza de atención se puede utilizar para aprender diferentes relaciones entre palabras, lo que mejora las tareas posteriores de procesamiento del lenguaje natural.
+
+##BERTO
+
+**BERT** (Representaciones de codificador bidireccional de transformadores) es una red de transformadores multicapa muy grande con 12 capas para *BERT-base* y 24 para *BERT-large*. Primero, el modelo se entrena previamente en un gran corpus de datos de texto (WikiPedia + libros) mediante entrenamiento no supervisado (predicción de palabras enmascaradas en una oración). Durante el entrenamiento previo, el modelo absorbe niveles significativos de comprensión del lenguaje que luego se pueden aprovechar con otros conjuntos de datos mediante un ajuste fino. Este proceso se llama **transferencia de aprendizaje**.
+
+
+
+> Imagen [source](http://jalammar.github.io/illustrated-bert/)
+
+## ✍️ Ejercicios: Transformadores
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [Transformers in PyTorch](TransformersPyTorch.ipynb)
+* [Transformers in TensorFlow](TransformersTF.ipynb)
+
+## Conclusión
+
+En esta lección aprendiste sobre los transformadores y los mecanismos de atención, todas herramientas esenciales en la caja de herramientas de la PNL. Existen muchas variaciones de arquitecturas Transformer, incluidas BERT, DistilBERT. BigBird, OpenGPT3 y más que se pueden ajustar. El [paquete HuggingFace](https://github.com/huggingface/) proporciona un repositorio para entrenar muchas de estas arquitecturas con PyTorch y TensorFlow.
+
+## 🚀 Desafío
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/218)
+
+# Revisión y autoestudio
+
+* [Blog post](https://mchromiak.github.io/articles/2017/Sep/12/Transformer-Attention-is-all-you-need/), explaining the classical [Attention is all you need](https://arxiv.org/abs/1706.03762) paper on transformers.
+* [A series of blog posts](https://towardsdatascience.com/transformers-explained-visually-part-1-overview-of-functionality-95a6dd460452) on transformers, explaining the architecture in detail.
+
+## [Assignment](assignment.md)
+
+
From 612e0af0030011bc7e78334618c500cee0b33c39 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:34:43 -0500
Subject: [PATCH 23/33] Create README.es.md
---
lessons/5-NLP/19-NER/README.es.md | 82 +++++++++++++++++++++++++++++++
1 file changed, 82 insertions(+)
create mode 100644 lessons/5-NLP/19-NER/README.es.md
diff --git a/lessons/5-NLP/19-NER/README.es.md b/lessons/5-NLP/19-NER/README.es.md
new file mode 100644
index 00000000..128eb478
--- /dev/null
+++ b/lessons/5-NLP/19-NER/README.es.md
@@ -0,0 +1,82 @@
+# Reconocimiento de entidad nombrada
+
+Hasta ahora nos hemos concentrado principalmente en una tarea de PNL: la clasificación. Sin embargo, también existen otras tareas de PNL que se pueden realizar con redes neuronales. Una de esas tareas es **[Reconocimiento de entidad con nombre](https://wikipedia.org/wiki/Named-entity_recognition)** (NER), que se ocupa del reconocimiento de entidades específicas dentro del texto, como lugares, nombres de personas, fechas. -intervalos de tiempo, fórmulas químicas, etc.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/119)
+
+## Ejemplo de uso de NER
+
+Suponga que desea desarrollar un bot de chat en lenguaje natural, similar a Amazon Alexa o Google Assistant. La forma en que funcionan los chatbots inteligentes es *comprender* lo que el usuario quiere clasificando el texto en la oración de entrada. El resultado de esta clasificación es la llamada **intención**, que determina lo que debe hacer un chat bot.
+
+
+
+> Imagen del autor
+
+Sin embargo, un usuario puede proporcionar algunos parámetros como parte de la frase. Por ejemplo, cuando pregunta por el tiempo, puede especificar un lugar o una fecha. Un robot debería poder comprender esas entidades y completar los espacios de parámetros en consecuencia antes de realizar la acción. Aquí es exactamente donde entra en juego NER.
+
+> ✅ Otro ejemplo sería [análisis de artículos médicos científicos] (https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Una de las principales cosas que debemos buscar son términos médicos específicos, como enfermedades y sustancias médicas. Si bien es probable que se pueda extraer una pequeña cantidad de enfermedades mediante la búsqueda de subcadenas, entidades más complejas, como compuestos químicos y nombres de medicamentos, necesitan un enfoque más complejo.
+>
+> ## NER como clasificación de tokens
+
+Los modelos NER son esencialmente **modelos de clasificación de tokens**, porque para cada uno de los tokens de entrada debemos decidir si pertenece a una entidad o no, y si es así, a qué clase de entidad.
+
+Considere el siguiente título del artículo:
+
+**Insuficiencia de la válvula tricúspide** y **carbonato de litio** **toxicidad** en un recién nacido.
+
+Las entidades aquí son:
+
+* La insuficiencia de la válvula tricúspide es una enfermedad (`DIS`)
+* El carbonato de litio es una sustancia química (`CHEM`)
+* La toxicidad también es una enfermedad (`DIS`)
+
+Observe que una entidad puede abarcar varios tokens. Y, como en este caso, debemos distinguir entre dos entidades consecutivas. Por lo tanto, es común usar dos clases para cada entidad: una que especifica el primer token de la entidad (a menudo se usa el prefijo `B-`, para **b**comienzo) y otra, la continuación de una entidad ( `I-`, para **i**nner token). También usamos `O` como clase para representar todos los **otros** tokens. Este etiquetado de tokens se denomina [etiquetado BIO](https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)) (o IOB). Cuando esté etiquetado, nuestro título se verá así:
+
+Ficha | Etiqueta
+------|-----
+Tricúspide | B-DIS
+válvula | I-DIS
+regurgitación | I-DIS
+y | O
+litio | B-CHEM
+carbonato | I-CHEM
+toxicidad | B-DIS
+en | O
+un | O
+recién nacido | O
+infantil | O
+. | O
+
+Dado que necesitamos construir una correspondencia uno a uno entre tokens y clases, podemos entrenar un modelo de red neuronal **muchos a muchos** más a la derecha a partir de esta imagen:
+
+
+
+> *Imagen de [this blog post](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) by [Andrej Karpathy](http://karpathy.github.io/). NER token classification models correspond to the right-most network architecture on this picture.*
+
+## Entrenamiento de modelos NER
+
+Dado que un modelo NER es esencialmente un modelo de clasificación de tokens, podemos usar RNN con los que ya estamos familiarizados para esta tarea. En este caso, cada bloque de red recurrente devolverá el ID del token. El siguiente cuaderno de ejemplo muestra cómo entrenar LSTM para la clasificación de tokens.
+
+## ✍️ Cuadernos de ejemplo: NER
+
+Continúa tu aprendizaje en el siguiente cuaderno:
+
+* [NER with TensorFlow](NER-TF.ipynb)
+
+## Conclusión
+
+Un modelo NER es un **modelo de clasificación de tokens**, lo que significa que se puede utilizar para realizar una clasificación de tokens. Esta es una tarea muy común en PNL y ayuda a reconocer entidades específicas dentro del texto, incluidos lugares, nombres, fechas y más.
+
+## 🚀 Desafío
+
+Complete la tarea vinculada a continuación para entrenar un modelo de reconocimiento de entidades con nombre para términos médicos y luego pruébelo en un conjunto de datos diferente.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/219)
+
+## Revisión y autoestudio
+
+Leer el blog [The Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/) y siga la sección de lecturas adicionales de ese artículo para profundizar sus conocimientos.
+
+## [Assignment](lab/README.md)
+
+En la tarea de esta lección, deberá entrenar un modelo de reconocimiento de entidades médicas. Puede comenzar entrenando un modelo LSTM como se describe en esta lección y continuar usando el modelo de transformador BERT. Lea [las instrucciones](lab/README.md) para obtener todos los detalles.
From 57dd8585f0517ab0067b8c6792d3151d8d38f65b Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:43:25 -0500
Subject: [PATCH 24/33] Create README.es.md
---
lessons/5-NLP/20-LangModels/README.es.md | 53 ++++++++++++++++++++++++
1 file changed, 53 insertions(+)
create mode 100644 lessons/5-NLP/20-LangModels/README.es.md
diff --git a/lessons/5-NLP/20-LangModels/README.es.md b/lessons/5-NLP/20-LangModels/README.es.md
new file mode 100644
index 00000000..afa70fbf
--- /dev/null
+++ b/lessons/5-NLP/20-LangModels/README.es.md
@@ -0,0 +1,53 @@
+# Modelos de lenguaje grandes previamente entrenados
+
+En todas nuestras tareas anteriores, estábamos entrenando una red neuronal para realizar una determinada tarea utilizando un conjunto de datos etiquetados. Con modelos transformadores grandes, como BERT, utilizamos el modelado de lenguaje de forma autosupervisada para construir un modelo de lenguaje, que luego se especializa para tareas posteriores específicas con capacitación adicional en un dominio específico. Sin embargo, se ha demostrado que los modelos de lenguaje grandes también pueden resolver muchas tareas sin NINGUNA capacitación específica en el dominio. Una familia de modelos capaces de hacer eso se llama **GPT**: Transformador generativo preentrenado.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/120)
+
+## Generación de texto y perplejidad
+
+La idea de que una red neuronal pueda realizar tareas generales sin entrenamiento posterior se presenta en [Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) papel. La idea principal es que muchas otras tareas se pueden modelar utilizando **generación de texto**, porque comprender el texto significa esencialmente poder producirlo. Debido a que el modelo se entrena con una gran cantidad de texto que abarca el conocimiento humano, también adquiere conocimientos sobre una amplia variedad de temas.
+
+> Comprender y ser capaz de producir texto también implica saber algo sobre el mundo que nos rodea. La gente también aprende leyendo en gran medida, y la red GPT es similar a este respecto.
+
+Las redes de generación de texto funcionan prediciendo la probabilidad de la siguiente palabra $$P(w_N)$$ Sin embargo, la probabilidad incondicional de la siguiente palabra es igual a la frecuencia de esta palabra en el corpus de texto. GPT es capaz de darnos **probabilidad condicional** de la siguiente palabra, dadas las anteriores: $$P(w_N | w_{n-1}, ..., w_0)$$
+
+> Puedes leer más sobre probabilidades en nuestro [Data Science for Beginers Curriculum](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/1-Introduction/04-stats-and-probability)
+
+La calidad del modelo generador de lenguaje se puede definir usando **perplejidad**. Es una métrica intrínseca que nos permite medir la calidad del modelo sin ningún conjunto de datos específico de la tarea. Se basa en la noción de *probabilidad de una oración*: el modelo asigna alta probabilidad a una oración que probablemente sea real (es decir, el modelo no está **perplejo** por ella), y baja probabilidad a oraciones que hacen menos sentido (p. ej. *¿Puede hacer qué?*). Cuando damos a nuestro modelo oraciones de un corpus de texto real, esperaríamos que tuvieran una alta probabilidad y una baja **perplejidad**. Matemáticamente, se define como probabilidad inversa normalizada del conjunto de prueba:
+$$
+\mathrm{Perplejidad}(W) = \sqrt[N]{1\over P(W_1,...,W_N)}
+$$
+
+**Puedes experimentar con la generación de texto usando el [editor de texto con tecnología GPT de Hugging Face](https://transformer.huggingface.co/doc/gpt2-large)**. En este editor, comienza a escribir su texto y al presionar **[TAB]** se le ofrecerán varias opciones para completarlo. Si son demasiado cortos o no está satisfecho con ellos, presione [TAB] nuevamente y tendrá más opciones, incluidos fragmentos de texto más largos.
+
+## GPT es una familia
+
+GPT no es un modelo único, sino más bien una colección de modelos desarrollados y entrenados por [OpenAI](https://openai.com).
+
+Bajo los modelos GPT, tenemos:
+
+| [GPT-2](https://huggingface.co/docs/transformers/model_doc/gpt2#openai-gpt2) | [GPT 3](https://openai.com/research/language-models-are-few-shot-learners) | [GPT-4](https://openai.com/gpt-4) |
+| -- | -- | -- |
+|Language model with upto 1.5 billion parameters. | Language model with up to 175 billion parameters | 100T parameters and accepts both image and text inputs and outputs text. |
+
+
+Los modelos GPT-3 y GPT-4 están disponibles [as a cognitive service from Microsoft Azure](https://azure.microsoft.com/en-us/services/cognitive-services/openai-service/#overview?WT.mc_id=academic-77998-cacaste), and as [OpenAI API](https://openai.com/api/).
+
+## Ingeniería rápida
+
+Debido a que GPT ha sido capacitado con grandes volúmenes de datos para comprender el lenguaje y el código, proporciona resultados en respuesta a las entradas (indicaciones). Las indicaciones son entradas o consultas de GPT mediante las cuales uno proporciona instrucciones a los modelos sobre las tareas que completarán a continuación. Para obtener el resultado deseado, necesita el mensaje más eficaz que implica seleccionar las palabras, formatos, frases o incluso símbolos correctos. Este enfoque es [Ingeniería rápida](https://learn.microsoft.com/en-us/shows/ai-show/the-basics-of-prompt-engineering-with-azure-openai-service?WT.mc_id= académico-77998-bethanycheum)
+
+[This documentation](https://learn.microsoft.com/en-us/semantic-kernel/prompt-engineering/?WT.mc_id=academic-77998-bethanycheum) le proporciona más información sobre ingeniería rápida.
+
+## ✍️ Cuaderno de ejemplo: [Playing with OpenAI-GPT](GPT-PyTorch.ipynb)
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [Generating text with OpenAI-GPT and Hugging Face Transformers](GPT-PyTorch.ipynb)
+
+## Conclusión
+
+Los nuevos modelos de lenguaje generales previamente entrenados no solo modelan la estructura del lenguaje, sino que también contienen una gran cantidad de lenguaje natural. Por lo tanto, se pueden utilizar de manera efectiva para resolver algunas tareas de PNL en entornos de cero tareas o de pocas oportunidades.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/220)
From 02fc16327bd64d2290264ec7da76c6eca80bb820 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:50:43 -0500
Subject: [PATCH 25/33] Create README.es.md
---
lessons/5-NLP/README.es.md | 65 ++++++++++++++++++++++++++++++++++++++
1 file changed, 65 insertions(+)
create mode 100644 lessons/5-NLP/README.es.md
diff --git a/lessons/5-NLP/README.es.md b/lessons/5-NLP/README.es.md
new file mode 100644
index 00000000..069b3d7c
--- /dev/null
+++ b/lessons/5-NLP/README.es.md
@@ -0,0 +1,65 @@
+# Procesamiento natural del lenguaje
+
+
+
+En esta sección, nos centraremos en el uso de redes neuronales para manejar tareas relacionadas con el **Procesamiento del lenguaje natural (NLP)**. Hay muchos problemas de PNL que queremos que las computadoras puedan resolver:
+
+* **Clasificación de texto** es un problema de clasificación típico relacionado con secuencias de texto. Los ejemplos incluyen clasificar mensajes de correo electrónico como spam versus no spam, o categorizar artículos como deportes, negocios, política, etc. Además, cuando desarrollamos chatbots, a menudo necesitamos entender lo que un usuario quería decir, en este caso. Estamos tratando con **clasificación de intención**. A menudo, en la clasificación de intenciones necesitamos tratar con muchas categorías.
+* **El análisis de sentimiento** es un problema de regresión típico, en el que necesitamos atribuir un número (un sentimiento) correspondiente a qué tan positivo/negativo es el significado de una oración. Una versión más avanzada del análisis de sentimientos es el **análisis de sentimientos basado en aspectos** (ABSA), donde atribuimos el sentimiento no a la oración completa, sino a diferentes partes de ella (aspectos), por ejemplo. *En este restaurante me gustó la cocina, pero el ambiente era horrible*.
+* **Reconocimiento de entidades nombradas** (NER) se refiere al problema de extraer ciertas entidades del texto. Por ejemplo, es posible que debamos entender que en la frase *Necesito volar a París mañana* la palabra *mañana* se refiere a FECHA y *París* es una UBICACIÓN.
+* **La extracción de palabras clave** es similar a NER, pero necesitamos extraer palabras importantes para el significado de la oración automáticamente, sin entrenamiento previo para tipos de entidades específicos.
+* **La agrupación de texto** puede ser útil cuando queremos agrupar oraciones similares, por ejemplo, solicitudes similares en conversaciones de soporte técnico.
+* **Respuesta a preguntas** se refiere a la capacidad de un modelo para responder una pregunta específica. El modelo recibe un pasaje de texto y una pregunta como entradas y necesita proporcionar un lugar en el texto donde esté contenida la respuesta a la pregunta (o, a veces, generar el texto de respuesta).
+* **Generación de texto** es la capacidad de un modelo para generar texto nuevo. Puede considerarse como una tarea de clasificación que predice la siguiente letra/palabra basándose en algún *indicador de texto*. Los modelos avanzados de generación de texto, como GPT-3, pueden resolver otras tareas de PNL, como la clasificación, utilizando una técnica llamada [programación rápida] (https://towardsdatascience.com/software-3-0-how-prompting-will- cambiar-las-reglas-del-juego-a982fbfe1e0) o [ingeniería rápida](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29)
+* **Resumen de texto** es una técnica cuando queremos que una computadora "lea" un texto largo y lo resuma en unas pocas oraciones.
+* **La traducción automática** puede verse como una combinación de comprensión de texto en un idioma y generación de texto en otro.
+
+Inicialmente, la mayoría de las tareas de PNL se resolvían utilizando métodos tradicionales como las gramáticas. Por ejemplo, en la traducción automática se utilizaban analizadores para transformar la oración inicial en un árbol de sintaxis, luego se extraían estructuras semánticas de nivel superior para representar el significado de la oración y, en base a este significado y la gramática del idioma de destino, se generaba el resultado. Hoy en día, muchas tareas de PNL se resuelven de forma más eficaz mediante redes neuronales.
+
+> Muchos métodos clásicos de PNL se implementan en [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) Biblioteca de Python. Hay un gran [NLTK Book](https://www.nltk.org/book/) disponible en línea que cubre cómo se pueden resolver diferentes tareas de PNL utilizando NLTK.
+
+En nuestro curso, nos centraremos principalmente en el uso de redes neuronales para PNL y usaremos NLTK cuando sea necesario.
+
+Ya hemos aprendido sobre el uso de redes neuronales para manejar datos tabulares e imágenes. La principal diferencia entre esos tipos de datos y el texto es que el texto es una secuencia de longitud variable, mientras que el tamaño de entrada en el caso de las imágenes se conoce de antemano. Si bien las redes convolucionales pueden extraer patrones de los datos de entrada, los patrones en el texto son más complejos. Por ejemplo, podemos hacer que la negación separada del sujeto sea arbitraria para muchas palabras (por ejemplo, *No me gustan las naranjas*, vs. *No me gustan esas naranjas grandes, coloridas y sabrosas*), y eso aún debería interpretarse como un patrón. Por lo tanto, para manejar el lenguaje necesitamos introducir nuevos tipos de redes neuronales, como *redes recurrentes* y *transformadores*.
+
+## Instalar bibliotecas
+
+Si está utilizando la instalación local de Python para ejecutar este curso, es posible que deba instalar todas las bibliotecas necesarias para PNL usando los siguientes comandos:
+
+**Para PyTorch**
+```golpecito
+instalación de pip -r requisitos-torch.txt
+```
+**Para TensorFlow**
+```golpecito
+instalación de pip -r requisitos-tf.txt
+```
+
+> Puedes probar la PNL con TensorFlow activado
+
+## Advertencia de GPU
+
+En esta sección, en algunos de los ejemplos entrenaremos modelos bastante grandes. Es recomendable ejecutar las computadoras portátiles en una computadora con GPU para minimizar el tiempo de espera.
+
+Cuando se ejecuta en GPU, es posible que experimente situaciones en las que se quede sin memoria de GPU. Durante el entrenamiento, la cantidad de memoria de GPU consumida depende de muchos factores, incluido el tamaño del minibatch. Si experimenta algún problema de memoria, puede intentar minimizar el tamaño del minibatch en el código.
+
+Además, algunas versiones anteriores de TensorFlow no liberan correctamente la memoria de la GPU si entrenas varios modelos en un kernel de Python. Para utilizar la memoria de la GPU con precaución, puede configurar la opción TensorFlow para aumentar la asignación de memoria de la GPU solo cuando sea necesario. Debería incluir el siguiente código en sus cuadernos:
+
+```pitón
+dispositivos_físicos = tf.config.list_physical_devices('GPU')
+si len(dispositivos_físicos)>0:
+ tf.config.experimental.set_memory_growth(dispositivos_físicos[0], Verdadero)
+```
+
+Si está interesado en aprender sobre PNL desde una perspectiva clásica de ML, visite [this suite of lessons](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
+
+## In this Section
+In this section we will learn about:
+
+* [Representing text as tensors](13-TextRep/README.md)
+* [Word Embeddings](14-Emdeddings/README.md)
+* [Language Modeling](15-LanguageModeling/README.md)
+* [Recurrent Neural Networks](16-RNN/README.md)
+* [Generative Networks](17-GenerativeNetworks/README.md)
+* [Transformers](18-Transformers/README.md)
+
From d1f3f099369a62eed7341d3b69feb112d75f22c1 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:53:06 -0500
Subject: [PATCH 26/33] Create README.es.md
---
lessons/6-Other/README.es.md | 5 +++++
1 file changed, 5 insertions(+)
create mode 100644 lessons/6-Other/README.es.md
diff --git a/lessons/6-Other/README.es.md b/lessons/6-Other/README.es.md
new file mode 100644
index 00000000..03e0580a
--- /dev/null
+++ b/lessons/6-Other/README.es.md
@@ -0,0 +1,5 @@
+# Descripción general
+
+
+
+> Nota de boceto por [Tomomi Imura](https://twitter.com/girlie_mac)
From 6c98aaefca76396aa59c494efafe34fc82d95345 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 19:59:38 -0500
Subject: [PATCH 27/33] Create README.es.md
---
.../6-Other/21-GeneticAlgorithms/README.es.md | 77 +++++++++++++++++++
1 file changed, 77 insertions(+)
create mode 100644 lessons/6-Other/21-GeneticAlgorithms/README.es.md
diff --git a/lessons/6-Other/21-GeneticAlgorithms/README.es.md b/lessons/6-Other/21-GeneticAlgorithms/README.es.md
new file mode 100644
index 00000000..a9bb1cf8
--- /dev/null
+++ b/lessons/6-Other/21-GeneticAlgorithms/README.es.md
@@ -0,0 +1,77 @@
+# Algoritmos genéticos
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/121)
+
+Los **Algoritmos genéticos** (GA) se basan en un **enfoque evolutivo** de la IA, en el que se utilizan métodos de evolución de una población para obtener una solución óptima para un problema determinado. Fueron propuestos en 1975 por [John Henry Holland](https://wikipedia.org/wiki/John_Henry_Holland).
+
+Los algoritmos genéticos se basan en las siguientes ideas:
+
+* Las soluciones válidas al problema se pueden representar como **genes**
+* **Crossover** nos permite combinar dos soluciones para obtener una nueva solución válida
+* **Selección** se utiliza para seleccionar soluciones más óptimas usando alguna **función de fitness**
+* **Se introducen mutaciones** para desestabilizar la optimización y sacarnos del mínimo local
+
+Si desea implementar un algoritmo genético, necesita lo siguiente:
+
+ * Encontrar un método para codificar las soluciones de nuestros problemas utilizando **genes** g∈Γ
+ * Sobre el conjunto de genes Γ Necesitamos definir **función de aptitud** ajuste: Γ→**R**. Los valores de función más pequeños corresponden a mejores soluciones.
+ * Definir el mecanismo de **cruce** para combinar dos genes para obtener una nueva solución de cruce válida: Γ2→Γ.
+ * Para definir el mecanismo de **mutación** mutar: Γ→Γ.
+
+En muchos casos, el cruce y la mutación son algoritmos bastante simples para manipular genes como secuencias numéricas o vectores de bits.
+
+La implementación específica de un algoritmo genético puede variar de un caso a otro, pero la estructura general es la siguiente:
+
+1. Seleccione una población inicial G=Γ
+2. Seleccione aleatoriamente una de las operaciones que se realizarán en este paso: cruce o mutación
+3. **Cruce**:
+ * Seleccione aleatoriamente dos genes g1, g2 ∈ GRAMO
+ * Calcular el cruce g=crossover(g1,g2)
+ * Si fit(g)1) o fit(g)2) - reemplace el gen correspondiente en la población por g.
+4. **Mutación**: seleccione el gen aleatorio g∈G y reemplácelo por mutate(g)
+5. Repita desde el paso 2, hasta que obtengamos un valor de ajuste suficientemente pequeño, o hasta que se alcance el límite en el número de pasos.
+
+## Tareas típicas
+
+Las tareas que normalmente resuelven los algoritmos genéticos incluyen:
+
+1. Optimización de horarios
+1. Embalaje óptimo
+1. Corte óptimo
+1. Acelerar la búsqueda exhaustiva
+
+## ✍️ Ejercicios: Algoritmos Genéticos
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+Ir a [this notebook](Genetic.ipynb) para ver dos ejemplos de uso de Algoritmos Genéticos:
+
+1. División justa del tesoro
+1. Problema de las 8 reinas
+
+## Conclusión
+
+Los algoritmos genéticos se utilizan para resolver muchos problemas, incluidos problemas de logística y búsqueda. El campo está inspirado en investigaciones que fusionaron temas de Psicología e Informática.
+
+## 🚀 Desafío
+
+"Los algoritmos genéticos son sencillos de implementar, pero su comportamiento es difícil de entender" [source](https://wikipedia.org/wiki/Genetic_algorithm) Investigue un poco para encontrar una implementación de un algoritmo genético, como resolver un Sudoku, y explique cómo funciona como un boceto o diagrama de flujo.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/221)
+
+## Revisión y autoestudio
+
+Mirar [this great video](https://www.youtube.com/watch?v=qv6UVOQ0F44) hablando de cómo una computadora puede aprender a jugar Super Mario usando redes neuronales entrenadas por algoritmos genéticos. Aprenderemos más sobre el aprendizaje por computadora para jugar juegos como ese [in the next section](../22-DeepRL/README.md).
+
+## [Assignment: Diophantine Equation](Diophantine.ipynb)
+
+Tu objetivo es resolver la llamada **ecuación diofántica**, una ecuación con raíces enteras. Por ejemplo, considere la ecuación a+2b+3c+4d=30. Necesitas encontrar las raíces enteras que satisfagan esta ecuación.
+
+*Esta tarea está inspirada en [this post](https://habr.com/post/128704/).*
+
+Consejos:
+
+1. Puedes considerar que las raíces están en el intervalo [0;30]
+1. Como gen, considere usar la lista de valores raíz.
+
+Usar [Diophantine.ipynb](Diophantine.ipynb) como punto de partida.
From 2d360bbe9b71fa119e938b494d0d213aed012331 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 20:11:16 -0500
Subject: [PATCH 28/33] Create README.es.md
---
lessons/6-Other/22-DeepRL/README.es.md | 114 +++++++++++++++++++++++++
1 file changed, 114 insertions(+)
create mode 100644 lessons/6-Other/22-DeepRL/README.es.md
diff --git a/lessons/6-Other/22-DeepRL/README.es.md b/lessons/6-Other/22-DeepRL/README.es.md
new file mode 100644
index 00000000..7e81790c
--- /dev/null
+++ b/lessons/6-Other/22-DeepRL/README.es.md
@@ -0,0 +1,114 @@
+# Aprendizaje por refuerzo profundo
+
+El aprendizaje por refuerzo (RL) se considera uno de los paradigmas básicos del aprendizaje automático, junto al aprendizaje supervisado y el aprendizaje no supervisado. Mientras que en el aprendizaje supervisado nos basamos en el conjunto de datos con resultados conocidos, RL se basa en **aprender haciendo**. Por ejemplo, cuando vemos por primera vez un juego de computadora, comenzamos a jugar, incluso sin conocer las reglas, y pronto somos capaces de mejorar nuestras habilidades simplemente jugando y ajustando nuestro comportamiento.
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/122)
+
+Para realizar RL, necesitamos:
+
+* Un **entorno** o **simulador** que marca las reglas del juego. Deberíamos poder ejecutar los experimentos en el simulador y observar los resultados.
+* Alguna **Función de recompensa**, que indica el éxito de nuestro experimento. En caso de aprender a jugar a un juego de ordenador, la recompensa sería nuestra puntuación final.
+
+Basándonos en la función de recompensa, deberíamos poder ajustar nuestro comportamiento y mejorar nuestras habilidades, para que la próxima vez juguemos mejor. La principal diferencia entre otros tipos de aprendizaje automático y RL es que en RL normalmente no sabemos si ganamos o perdemos hasta que terminamos el juego. Por lo tanto, no podemos decir si un determinado movimiento por sí solo es bueno o no; solo recibimos una recompensa al final del juego.
+
+Durante RL, normalmente realizamos muchos experimentos. Durante cada experimento, debemos equilibrar entre seguir la estrategia óptima que hemos aprendido hasta ahora (**explotación**) y explorar nuevos estados posibles (**exploración**).
+
+## Gimnasio OpenAI
+
+Una gran herramienta para RL es el [OpenAI Gym](https://gym.openai.com/) - a **simulation environment**, which can simulate many different environments starting from Atari games, to the physics behind pole balancing. It is one of the most popular simulation environments for training reinforcement learning algorithms, and is maintained by [OpenAI](https://openai.com/).
+
+> **Nota**: Puedes ver todos los entornos disponibles en OpenAI Gym [here](https://gym.openai.com/envs/#classic_control).
+
+## Equilibrio de postes de carrito
+
+Probablemente todos habéis visto dispositivos de equilibrio modernos como el *Segway* o los *Gyroscooters*. Pueden equilibrarse automáticamente ajustando sus ruedas en respuesta a una señal de un acelerómetro o giroscopio. En esta sección, aprenderemos cómo resolver un problema similar: equilibrar un poste. Es similar a una situación en la que un artista de circo necesita equilibrar un poste en su mano, pero este equilibrio del poste solo ocurre en 1D.
+
+Una versión simplificada del equilibrio se conoce como problema **CartPole**. En el mundo de los postes, tenemos un control deslizante horizontal que se puede mover hacia la izquierda o hacia la derecha, y el objetivo es equilibrar un poste vertical encima del control deslizante a medida que se mueve.
+
+
+
+Para crear y utilizar este entorno, necesitamos un par de líneas de código Python:
+
+```pitón
+importar gimnasio
+env = gimnasio.make("CartPole-v1")
+
+entorno.reset()
+hecho = falso
+recompensa_total = 0
+mientras no haya terminado:
+ entorno.render()
+ acción = env.action_space.sample()
+ observación, recompensa, hecho, información = env.step(acción)
+ recompensa_total += recompensa
+
+print(f"Recompensa total: {recompensa_total}")
+```
+
+Se puede acceder a cada entorno exactamente de la misma manera:
+* `env.reset` inicia un nuevo experimento
+* `env.step` realiza un paso de simulación. Recibe una **acción** del **espacio de acción** y devuelve una **observación** (del espacio de observación), así como una recompensa y un indicador de terminación.
+
+En el ejemplo anterior realizamos una acción aleatoria en cada paso, razón por la cual la duración del experimento es muy corta:
+
+
+
+El objetivo de un algoritmo RL es entrenar un modelo: la llamada **política** π - que devolverá la acción en respuesta a un estado determinado. También podemos considerar que la política es probabilística, por ejemplo. para cualquier estado *s* y acción *a* devolverá la probabilidad π(*a*|*s*) de que debamos tomar *a* en el estado *s*.
+
+## Algoritmo de gradientes de políticas
+
+La forma más obvia de modelar una política es crear una red neuronal que tome estados como entrada y devuelva las acciones correspondientes (o más bien las probabilidades de todas las acciones). En cierto sentido, sería similar a una tarea de clasificación normal, con una diferencia importante: no sabemos de antemano qué acciones debemos realizar en cada uno de los pasos.
+
+La idea aquí es estimar esas probabilidades. Creamos un vector de **recompensas acumulativas** que muestra nuestra recompensa total en cada paso del experimento. También aplicamos **descuento de recompensas** multiplicando las recompensas anteriores por algún coeficiente γ=0,99, para disminuir el papel de las recompensas anteriores. Luego, reforzamos aquellos pasos a lo largo del camino del experimento que generan mayores recompensas.
+
+> Obtenga más información sobre el algoritmo de gradiente de políticas y véalo en acción en el [example notebook](CartPole-RL-TF.ipynb).
+
+## Actor-Critic Algorithm
+
+An improved version of the Policy Gradients approach is called **Actor-Critic**. The main idea behind it is that the neural network would be trained to return two things:
+
+* The policy, which determines which action to take. This part is called **actor**
+* The estimation of the total reward we can expect to get at this state - this part is called **critic**.
+
+In a sense, this architecture resembles a [GAN](../../4-ComputerVision/10-GANs/README.md), donde tenemos dos redes que se entrenan entre sí. En el modelo actor-crítico, el actor propone la acción que debemos realizar y el crítico intenta ser crítico y estimar el resultado. Sin embargo, nuestro objetivo es entrenar esas redes al unísono.
+
+Como conocemos tanto las recompensas acumuladas reales como los resultados arrojados por el crítico durante el experimento, es relativamente fácil construir una función de pérdida que minimice la diferencia entre ellos. Eso nos daría una **pérdida crítica**. Podemos calcular la **pérdida de actor** utilizando el mismo enfoque que en el algoritmo de gradiente de políticas.
+
+Después de ejecutar uno de esos algoritmos, podemos esperar que nuestro CartPole se comporte así:
+
+
+
+## ✍️ Ejercicios: gradientes de políticas y RL actor-crítico
+
+Continúa tu aprendizaje en los siguientes cuadernos:
+
+* [RL in TensorFlow](CartPole-RL-TF.ipynb)
+* [RL in PyTorch](CartPole-RL-PyTorch.ipynb)
+
+## Otras tareas de RL
+
+El aprendizaje por refuerzo es hoy en día un campo de investigación de rápido crecimiento. Algunos de los ejemplos interesantes de aprendizaje por refuerzo son:
+
+* Enseñar a una computadora a jugar **Juegos Atari**. La parte desafiante de este problema es que no tenemos un estado simple representado como un vector, sino más bien una captura de pantalla, y necesitamos usar CNN para convertir esta imagen de pantalla en un vector de características o para extraer información de recompensa. Los juegos de Atari están disponibles en el gimnasio.
+* Enseñar a una computadora a jugar juegos de mesa, como Chess and Go. Recientemente, dos agentes entrenaron programas de última generación como **Alpha Zero** desde cero, jugando uno contra el otro y mejorando en cada paso.
+* En la industria, RL se utiliza para crear sistemas de control a partir de simulación. un servicio llamado [Bonsai](https://azure.microsoft.com/services/project-bonsai/?WT.mc_id=academic-77998-cacaste) está diseñado específicamente para eso.
+
+* ## Conclusión
+
+Ahora hemos aprendido cómo entrenar agentes para lograr buenos resultados simplemente proporcionándoles una función de recompensa que defina el estado deseado del juego y dándoles la oportunidad de explorar inteligentemente el espacio de búsqueda. Probamos con éxito dos algoritmos y logramos un buen resultado en un período de tiempo relativamente corto. Sin embargo, este es solo el comienzo de su viaje hacia la vida real y definitivamente debería considerar tomar un curso por separado si desea profundizar más.
+
+## 🚀 Desafío
+
+Explore las aplicaciones enumeradas en la sección 'Otras tareas de RL' e intente implementar una.
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/222)
+
+## Revisión y autoestudio
+
+Obtenga más información sobre el aprendizaje por refuerzo clásico en nuestro [Machine Learning for Beginners Curriculum](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/README.md).
+
+Mirar [this great video](https://www.youtube.com/watch?v=qv6UVOQ0F44) hablando de cómo una computadora puede aprender a jugar Super Mario.
+
+## Asignación: [Train a Mountain Car](lab/README.md)
+
+Su objetivo durante esta tarea sería entrenar en un ambiente de gimnasio diferente - [Mountain Car](https://www.gymlibrary.ml/environments/classic_control/mountain_car/).
From f9319e42f697c623f48a28039cc519d598314a86 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 20:26:54 -0500
Subject: [PATCH 29/33] Create README.es.md
---
.../6-Other/23-MultiagentSystems/README.es.md | 152 ++++++++++++++++++
1 file changed, 152 insertions(+)
create mode 100644 lessons/6-Other/23-MultiagentSystems/README.es.md
diff --git a/lessons/6-Other/23-MultiagentSystems/README.es.md b/lessons/6-Other/23-MultiagentSystems/README.es.md
new file mode 100644
index 00000000..d8f4ef26
--- /dev/null
+++ b/lessons/6-Other/23-MultiagentSystems/README.es.md
@@ -0,0 +1,152 @@
+# Sistemas multiagente
+
+Una de las posibles formas de lograr inteligencia es el llamado enfoque **emergente** (o **sinérgico**), que se basa en el hecho de que el comportamiento combinado de muchos agentes relativamente simples puede dar como resultado un conjunto más complejo ( o inteligente) del sistema en su conjunto. Teóricamente, esto se basa en los principios de [Inteligencia Colectiva](https://en.wikipedia.org/wiki/Collective_intelligence), [Emergentismo](https://en.wikipedia.org/wiki/Global_brain) y [Evolución Cibernética](https://en.wikipedia.org/wiki/Global_brain), que afirma que los sistemas de nivel superior obtienen algún tipo de valor agregado cuando se combinan adecuadamente con sistemas de nivel inferior (el llamado *principio de transición del metasistema* ).
+
+## [Pre-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/123)
+
+La dirección de los **Sistemas Multi-Agente** surgió en la IA en la década de 1990 como respuesta al crecimiento de Internet y los sistemas distribuidos. Uno de los libros de texto clásicos sobre IA, [Inteligencia artificial: un enfoque moderno](https://en.wikipedia.org/wiki/Artificial_Intelligence:_A_Modern_Approach), se centra en la visión de la IA clásica desde el punto de vista de los sistemas multiagente. .
+
+Un elemento central del enfoque de agentes múltiples es la noción de **Agente**: una entidad que vive en algún **entorno**, que puede percibir y sobre el cual puede actuar. Esta es una definición muy amplia y podrían existir muchos tipos y clasificaciones diferentes de agentes:
+
+* Por su capacidad de razonar:
+ - Los agentes **reactivos** suelen tener un tipo de comportamiento de solicitud-respuesta simple.
+ - Los agentes **deliberativos** emplean algún tipo de razonamiento lógico y/o capacidades de planificación.
+* Por el lugar donde el agente ejecuta su código:
+ - Los agentes **estáticos** trabajan en un nodo de red dedicado
+ - Los agentes **móviles** pueden mover su código entre nodos de red
+* Por su comportamiento:
+ - **Los agentes pasivos** no tienen objetivos específicos. Estos agentes pueden reaccionar a estímulos externos, pero no iniciarán ninguna acción por sí mismos.
+ - **Los agentes activos** tienen algunos objetivos que persiguen
+ - **Los agentes cognitivos** implican una planificación y un razonamiento complejos
+
+Los sistemas multiagente se utilizan hoy en día en diversas aplicaciones:
+
+* En los juegos, muchos personajes no jugadores emplean algún tipo de IA y pueden considerarse agentes inteligentes.
+* En la producción de video, la representación de escenas 3D complejas que involucran multitudes generalmente se realiza mediante simulación de múltiples agentes.
+* En el modelado de sistemas, se utiliza un enfoque de múltiples agentes para simular el comportamiento de un modelo complejo. Por ejemplo, se ha utilizado con éxito un enfoque de múltiples agentes para predecir la propagación de la enfermedad COVID-19 en todo el mundo. Se puede utilizar un enfoque similar para modelar el tráfico en la ciudad y ver cómo reacciona a los cambios en las normas de tráfico.
+* En sistemas de automatización complejos, cada dispositivo puede actuar como un agente independiente, lo que hace que todo el sistema sea menos monolítico y más robusto.
+
+No dedicaremos mucho tiempo a profundizar en los sistemas multiagente, pero consideremos un ejemplo de **Modelado multiagente**.
+
+## Logotipo de red
+
+[NetLogo](https://ccl.northwestern.edu/netlogo/) es un entorno de modelado multiagente basado en una versión modificada del [Logo](https://en.wikipedia.org/wiki/Logo_(programming_language)) lenguaje de programación. Este lenguaje fue desarrollado para enseñar conceptos de programación a niños y te permite controlar un agente llamado **tortuga**, que puede moverse dejando un rastro. Esto permite crear figuras geométricas complejas, lo cual es una forma muy visual de entender el comportamiento de un agente.
+
+En NetLogo, podemos crear muchas tortugas usando el comando `create-turtles`. Luego podemos ordenar a todas las tortugas que realicen algunas acciones (en el siguiente ejemplo, más de 10 puntos hacia adelante):
+
+```
+crear-tortugas 10
+pregúntale a las tortugas [
+ adelante 10
+]
+```
+
+Por supuesto, no es interesante cuando todas las tortugas hacen lo mismo, así que podemos "preguntar" a grupos de tortugas, por ejemplo. aquellos que se encuentran en las proximidades de un determinado punto. También podemos crear tortugas de diferentes *razas* usando el comando `breed [cats cat]`. Aquí "gato" es el nombre de una raza, y necesitamos especificar tanto la palabra singular como la plural, porque diferentes comandos usan diferentes formas para mayor claridad.
+
+> ✅ No profundizaremos en el aprendizaje del lenguaje NetLogo en sí; puedes visitar el brillante [Beginner's Interactive NetLogo Dictionary](https://ccl.northwestern.edu/netlogo/bind/) recurso si está interesado en aprender más.
+>
+> Puede [download](https://ccl.northwestern.edu/netlogo/download.shtml) e instale NetLogo para probarlo.
+
+### Biblioteca de modelos
+
+Lo bueno de NetLogo es que contiene una biblioteca de modelos funcionales que puedes probar. Vaya a **Archivo → Biblioteca de modelos** y tienes muchas categorías de modelos para elegir.
+
+
+
+> Una captura de pantalla de la biblioteca de modelos por Dmitry Soshnikov
+
+Puede abrir uno de los modelos, por ejemplo **Biología → Flocado**.
+
+### Principios principales
+
+Después de abrir el modelo, accederá a la pantalla principal de NetLogo. A continuación se muestra un modelo de muestra que describe la población de lobos y ovejas, dados recursos finitos (pasto).
+
+
+
+> Captura de pantalla de Dmitry Soshnikov
+
+En esta pantalla podrás ver:
+
+* La sección **Interfaz** que contiene:
+ - El campo principal, donde viven todos los agentes.
+ - Diferentes controles: botones, sliders, etc.
+ - Gráficos que puedes utilizar para mostrar los parámetros de la simulación.
+* La pestaña **Código** que contiene el editor, donde puede escribir el programa NetLogo
+
+En la mayoría de los casos, la interfaz tendría un botón **Configuración**, que inicializa el estado de simulación, y un botón **Ir** que inicia la ejecución. Estos son manejados por los controladores correspondientes en el código que se ve así:
+
+```
+ir [
+...
+]
+```
+
+El mundo de NetLogo consta de los siguientes objetos:
+
+* **Agentes** (tortugas) que pueden moverse por el campo y hacer algo. Usted ordena a los agentes usando la sintaxis `preguntar a las tortugas [...]`, y todos los agentes ejecutan el código entre paréntesis en *modo tortuga*.
+* **Parches** son áreas cuadradas del campo en las que viven los agentes. Puede consultar todos los agentes en el mismo parche o puede cambiar los colores del parche y algunas otras propiedades. También puedes "pedirle a los parches" que hagan algo.
+* **Observador** es un agente único que controla el mundo. Todos los controladores de botones se ejecutan en *modo observador*.
+
+> ✅ La belleza de un entorno multiagente es que el código que se ejecuta en modo tortuga o en modo parche es ejecutado al mismo tiempo por todos los agentes en paralelo. Por lo tanto, al escribir un pequeño código y programar el comportamiento de un agente individual, se puede crear un comportamiento complejo del sistema de simulación en su conjunto.
+
+### Flocado
+
+Como ejemplo de comportamiento multiagente, consideremos **[Flocking](https://en.wikipedia.org/wiki/Flocking_(behavior))**. La bandada es un patrón complejo que es muy similar a cómo vuelan las bandadas de pájaros. Al verlos volar se puede pensar que siguen algún tipo de algoritmo colectivo, o que poseen alguna forma de *inteligencia colectiva*. Sin embargo, este comportamiento complejo surge cuando cada agente individual (en este caso, un *pájaro*) sólo observa a otros agentes a corta distancia de él y sigue tres reglas simples:
+
+* **Alineación** - se orienta hacia el rumbo promedio de los agentes vecinos
+* **Cohesión** - intenta dirigirse hacia la posición promedio de los vecinos (*atracción de largo alcance*)
+* **Separación** - cuando se acerca demasiado a otras aves, intenta alejarse (*repulsión de corto alcance*)
+
+Puede ejecutar el ejemplo de flocado y observar el comportamiento. También puedes ajustar parámetros, como el *grado de separación* o el *rango de visión*, que define hasta dónde puede ver cada pájaro. Tenga en cuenta que si reduce el rango de visión a 0, todas las aves se vuelven ciegas y la bandada se detiene. Si reduce la separación a 0, todas las aves se juntan en línea recta.
+
+> ✅ Cambie a la pestaña **Código** y vea dónde se implementan en el código tres reglas de flocado (alineación, cohesión y separación). Nótese cómo nos referimos sólo a aquellos agentes que están a la vista.
+
+### Otros modelos para ver
+
+Hay algunos modelos más interesantes con los que puedes experimentar:
+
+* **Arte → Fuegos artificiales** muestra cómo un fuego artificial puede considerarse un comportamiento colectivo de corrientes de fuego individuales.
+* **Ciencias Sociales → Tráfico Básico** y **Ciencias Sociales → Traffic Grid** muestra el modelo de tráfico de la ciudad en cuadrícula 1D y 2D con o sin semáforos. Cada coche de la simulación sigue las siguientes reglas:
+ - Si el espacio frente a él está vacío, acelera (hasta una cierta velocidad máxima)
+ - Si ve el obstáculo delante, frene (y puede ajustar hasta dónde puede ver el conductor)
+* **Ciencias Sociales → Party** muestra cómo las personas se agrupan durante un cóctel. Puedes encontrar la combinación de parámetros que conducen al aumento más rápido de la felicidad del grupo.
+
+Como puede ver en estos ejemplos, las simulaciones de múltiples agentes pueden ser una forma bastante útil de comprender el comportamiento de un sistema complejo formado por individuos que siguen la misma lógica o una similar. También se puede utilizar para controlar agentes virtuales, como [NPC](https://en.wikipedia.org/wiki/NPC) en juegos de computadora o agentes en mundos animados en 3D.
+
+## Agentes deliberantes
+
+Los agentes descritos anteriormente son muy simples y reaccionan a los cambios en el entorno utilizando algún tipo de algoritmo. Como tales, son **agentes reactivos**. Sin embargo, a veces los agentes pueden razonar y planificar su acción, en cuyo caso se les llama **deliberativos**.
+
+Un ejemplo típico sería un agente personal que recibe instrucciones de un humano para reservar un viaje de vacaciones. Supongamos que hay muchos agentes que viven en Internet y que pueden ayudarle. Luego deberá contactar con otros agentes para ver qué vuelos hay disponibles, cuáles son los precios de los hoteles para las distintas fechas e intentar negociar el mejor precio. Cuando el plan de vacaciones esté completo y confirmado por el propietario, podrá proceder con la reserva.
+
+Para hacerlo, los agentes deben **comunicarse**. Para una comunicación exitosa necesitan:
+
+* Algunos **idiomas estándar para intercambiar conocimientos**, como [Knowledge Interchange Format](https://en.wikipedia.org/wiki/Knowledge_Interchange_Format) (KIF) y [Knowledge Query and Manipulation Language](https://en.wikipedia.org/wiki/Knowledge_Query_and_Manipulation_Language) (KQML). Esos lenguajes están diseñados en base a [Speech Act theory](https://en.wikipedia.org/wiki/Speech_act).
+* Esos idiomas también deben incluir algunos **protocolos de negociación**, basados en diferentes **tipos de subasta**.
+* Una **ontología** común a utilizar, para que se refieran a los mismos conceptos conociendo su semántica
+* Una forma de **descubrir** qué pueden hacer diferentes agentes, también basada en algún tipo de ontología
+
+Los agentes deliberativos son mucho más complejos que reactivos, porque no sólo reaccionan a los cambios en el entorno, sino que también deberían poder *iniciar* acciones. Una de las arquitecturas propuestas para los agentes deliberativos es el llamado agente Creencia-Deseo-Intención (BDI):
+
+* **Las creencias** forman un conjunto de conocimientos sobre el entorno de un agente. Puede estructurarse como una base de conocimientos o un conjunto de reglas que un agente puede aplicar a una situación específica del entorno.
+* **Los deseos** definen lo que un agente quiere hacer, es decir, sus objetivos. Por ejemplo, el objetivo del agente asistente personal anterior es reservar un recorrido y el objetivo de un agente hotelero es maximizar las ganancias.
+* **Las intenciones** son acciones específicas que un agente planea para lograr sus objetivos. Las acciones suelen cambiar el entorno y provocar la comunicación con otros agentes.
+
+Hay algunas plataformas disponibles para construir sistemas multiagente, como [JADE](https://jade.tilab.com/). [This paper](https://arxiv.org/ftp/arxiv/papers/2007/2007.08961.pdf) contiene una revisión de las plataformas multiagente, junto con una breve historia de los sistemas multiagente y sus diferentes escenarios de uso.
+
+## Conclusión
+
+Los sistemas multiagente pueden adoptar formas muy diferentes y utilizarse en muchas aplicaciones diferentes.
+Todos tienden a centrarse en el comportamiento más simple de un agente individual y logran un comportamiento más complejo del sistema general debido al **efecto sinérgico**.
+
+## 🚀 Desafío
+
+Lleve esta lección al mundo real e intente conceptualizar un sistema multiagente que pueda resolver un problema. ¿Qué tendría que hacer, por ejemplo, un sistema multiagente para optimizar la ruta de un autobús escolar? ¿Cómo podría funcionar en una panadería?
+
+## [Post-lecture quiz](https://red-field-0a6ddfd03.1.azurestaticapps.net/quiz/223)
+
+## Revisión y autoestudio
+
+Revisar el uso de este tipo de sistemas en la industria. Elija un dominio como la fabricación o la industria de los videojuegos y descubra cómo se pueden utilizar los sistemas multiagente para resolver problemas únicos.
+
+## [NetLogo Assignment](assignment.md)
From 5a360e4295da9e22a0d5dfac97058f33566a04a0 Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 20:34:29 -0500
Subject: [PATCH 30/33] Create README.es.md
---
lessons/7-Ethics/README.es.md | 41 +++++++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
create mode 100644 lessons/7-Ethics/README.es.md
diff --git a/lessons/7-Ethics/README.es.md b/lessons/7-Ethics/README.es.md
new file mode 100644
index 00000000..e6abaf02
--- /dev/null
+++ b/lessons/7-Ethics/README.es.md
@@ -0,0 +1,41 @@
+# IA ética y responsable
+
+Ya casi has terminado este curso y espero que ahora veas claramente que la IA se basa en una serie de métodos matemáticos formales que nos permiten encontrar relaciones en los datos y entrenar modelos para replicar algunos aspectos del comportamiento humano. En este momento de la historia, consideramos que la IA es una herramienta muy poderosa para extraer patrones de datos y aplicar esos patrones para resolver nuevos problemas.
+
+## [Pre-lecture quiz](https://white-water-09ec41f0f.azurestaticapps.net/quiz/5/)
+
+Sin embargo, en la ciencia ficción vemos a menudo historias en las que la IA representa un peligro para la humanidad. Por lo general, esas historias se centran en algún tipo de rebelión de la IA, cuando la IA decide enfrentarse a los seres humanos. Esto implica que la IA tiene algún tipo de emoción o puede tomar decisiones imprevistas por sus desarrolladores.
+
+El tipo de IA que hemos aprendido en este curso no es más que aritmética de matrices grandes. Es una herramienta muy poderosa para ayudarnos a resolver nuestros problemas y, como cualquier otra herramienta poderosa, puede usarse para bien o para mal. Es importante destacar que se puede *usar mal*.
+
+## Principios de una IA responsable
+
+Para evitar este mal uso accidental o intencionado de la IA, Microsoft afirma la importante [Principles of Responsible AI](https://www.microsoft.com/ai/responsible-ai?WT.mc_id=academic-77998-cacaste). Los siguientes conceptos sustentan estos principios:
+
+* **La equidad** está relacionada con el importante problema de los *sesgos del modelo*, que pueden deberse al uso de datos sesgados para el entrenamiento. Por ejemplo, cuando intentamos predecir la probabilidad de que una persona consiga un trabajo de desarrollador de software, es probable que el modelo dé mayor preferencia a los hombres, simplemente porque el conjunto de datos de entrenamiento probablemente estaba sesgado hacia una audiencia masculina. Necesitamos equilibrar cuidadosamente los datos de entrenamiento e investigar el modelo para evitar sesgos y asegurarnos de que el modelo tenga en cuenta características más relevantes.
+* **Confiabilidad y Seguridad**. Por su naturaleza, los modelos de IA pueden cometer errores. Una red neuronal devuelve probabilidades y debemos tenerlas en cuenta a la hora de tomar decisiones. Cada modelo tiene cierta precisión y recuerdo, y debemos entenderlo para evitar el daño que pueden causar los consejos incorrectos.
+* **Privacidad y seguridad** tienen algunas implicaciones específicas de la IA. Por ejemplo, cuando utilizamos algunos datos para entrenar un modelo, estos datos se "integran" de alguna manera en el modelo. Por un lado, esto aumenta la seguridad y la privacidad; por otro, debemos recordar con qué datos se entrenó el modelo.
+* **Inclusividad** significa que no estamos creando IA para reemplazar a las personas, sino para aumentarlas y hacer que nuestro trabajo sea más creativo. También está relacionado con la equidad, porque cuando tratamos con comunidades subrepresentadas, es probable que la mayoría de los conjuntos de datos que recopilamos estén sesgados, y debemos asegurarnos de que esas comunidades estén incluidas y manejadas correctamente por la IA.
+* **Transparencia**. Esto incluye asegurarnos de que siempre tengamos claro el uso de la IA. Además, siempre que sea posible, queremos utilizar sistemas de IA que sean *interpretables*.
+* **Responsabilidad**. Cuando los modelos de IA toman algunas decisiones, no siempre está claro quién es responsable de esas decisiones. Necesitamos asegurarnos de comprender dónde reside la responsabilidad de las decisiones de la IA. En la mayoría de los casos, querríamos incluir a los seres humanos en el proceso de toma de decisiones importantes, de modo que personas reales rindan cuentas.
+
+## Herramientas para una IA responsable
+
+Microsoft ha desarrollado el [Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox) que contiene un conjunto de herramientas:
+
+* Panel de interpretabilidad (InterpretML)
+* Panel de equidad (FairLearn)
+* Panel de análisis de errores
+* Panel de control de IA responsable que incluye
+
+ - EconML: herramienta para análisis causal, que se centra en preguntas hipotéticas.
+ - DiCE: herramienta para análisis contrafactual que le permite ver qué características deben cambiarse para afectar la decisión del modelo.
+
+Para obtener más información sobre la ética de la IA, visite [this lesson](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/3-fairness?WT.mc_id=academic-77998-cacaste) en el plan de estudios de aprendizaje automático que incluye tareas.
+
+## Revisión y autoestudio
+
+Toma esto [Learn Path](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77998-cacaste) to learn more about responsible AI.
+
+## [Post-lecture quiz](https://white-water-09ec41f0f.azurestaticapps.net/quiz/6/)
+
From 6928a25195fba527ba76fe8ed368449a922f84bd Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 20:49:32 -0500
Subject: [PATCH 31/33] Create README.es.md
---
lessons/X-Extras/X1-MultiModal/README.es.md | 78 +++++++++++++++++++++
1 file changed, 78 insertions(+)
create mode 100644 lessons/X-Extras/X1-MultiModal/README.es.md
diff --git a/lessons/X-Extras/X1-MultiModal/README.es.md b/lessons/X-Extras/X1-MultiModal/README.es.md
new file mode 100644
index 00000000..049487dc
--- /dev/null
+++ b/lessons/X-Extras/X1-MultiModal/README.es.md
@@ -0,0 +1,78 @@
+# Redes multimodales
+
+Tras el éxito de los modelos de transformadores para resolver tareas de PNL, se han aplicado arquitecturas iguales o similares a tareas de visión por computadora. Existe un interés creciente en construir modelos que *combinen* capacidades de visión y lenguaje natural. Uno de esos intentos lo realizó OpenAI y se llama CLIP y DALL.E.
+
+## Preentrenamiento de imagen contrastiva (CLIP)
+
+La idea principal de CLIP es poder comparar mensajes de texto con una imagen y determinar qué tan bien corresponde la imagen al mensaje.
+
+
+
+> *Imagen de [this blog post](https://openai.com/blog/clip/)*
+
+El modelo se entrena con imágenes obtenidas de Internet y sus leyendas. Para cada lote, tomamos N pares de (imagen, texto) y los convertimos en algunas representaciones vectoriales I1,..., IN / T 1, ..., TN. Luego, esas representaciones se combinan. La función de pérdida se define para maximizar la similitud del coseno entre vectores correspondientes a un par (por ejemplo, Ii y Ti) y minimizar la similitud del coseno entre todos los demás pares. Ésa es la razón por la que este enfoque se llama **contrastivo**.
+
+El modelo/biblioteca CLIP está disponible en [OpenAI GitHub](https://github.com/openai/CLIP). El enfoque se describe en [this blog post](https://openai.com/blog/clip/),y con más detalle en [this paper](https://arxiv.org/pdf/2103.00020.pdf).
+
+Una vez que este modelo esté previamente entrenado, podemos darle un lote de imágenes y un lote de mensajes de texto, y devolverá el tensor con probabilidades. CLIP se puede utilizar para varias tareas:
+
+**Clasificación de imágenes**
+
+Supongamos que necesitamos clasificar imágenes entre, digamos, gatos, perros y humanos. En este caso, podemos darle al modelo una imagen y una serie de mensajes de texto: "*una imagen de un gato*", "*una imagen de un perro*", "*una imagen de un humano*". En el vector resultante de 3 probabilidades solo necesitamos seleccionar el índice con mayor valor.
+
+
+
+> *Imagen de [this blog post](https://openai.com/blog/clip/)*
+
+**Búsqueda de imágenes basada en texto**
+
+También podemos hacer lo contrario. Si tenemos una colección de imágenes, podemos pasar esta colección al modelo y un mensaje de texto; esto nos dará la imagen que sea más similar a un mensaje determinado.
+
+## ✍️ Ejemplo: [Using CLIP for Image Classification and Image Search](Clip.ipynb)
+
+Abre el [Clip.ipynb](Clip.ipynb) cuaderno para ver CLIP en acción.
+
+## Generación de imágenes con VQGAN+ CLIP
+
+CLIP también se puede utilizar para **generar imágenes** a partir de un mensaje de texto. Para hacer esto, necesitamos un **modelo generador** que pueda generar imágenes basadas en alguna entrada vectorial. Uno de esos modelos se llama [VQGAN](https://compvis.github.io/taming-transformers/) (Vector-Quantized GAN).
+
+Las principales ideas de VQGAN que lo diferencian del ordinario [GAN](../../4-ComputerVision/10-GANs/README.md) son los siguientes:
+* Utilizar una arquitectura transformadora autorregresiva para generar una secuencia de partes visuales ricas en contexto que componen la imagen. Esas partes visuales, a su vez, las aprende [CNN](../../4-ComputerVision/07-ConvNets/README.md)
+* Utilice un discriminador de subimagen que detecte si partes de la imagen son "reales" o "falsas" (a diferencia del enfoque de "todo o nada" en GAN tradicional).
+
+Obtenga más información sobre VQGAN en el [Taming Transformers](https://compvis.github.io/taming-transformers/) sitio web.
+
+Una de las diferencias importantes entre VQGAN y GAN tradicional es que este último puede producir una imagen decente a partir de cualquier vector de entrada, mientras que es probable que VQGAN produzca una imagen que no sea coherente. Por lo tanto, necesitamos guiar más el proceso de creación de imágenes, y eso se puede hacer usando CLIP.
+
+
+
+Para generar una imagen correspondiente a un mensaje de texto, comenzamos con algún vector de codificación aleatorio que se pasa a través de VQGAN para producir una imagen. Luego se utiliza CLIP para producir una función de pérdida que muestra qué tan bien corresponde la imagen al mensaje de texto. El objetivo entonces es minimizar esta pérdida, utilizando la propagación hacia atrás para ajustar los parámetros del vector de entrada.
+
+Una gran biblioteca que implementa VQGAN+CLIP es [Pixray](http://github.com/pixray/pixray)
+
+ |  | 
+----|----|----
+Imagen generada a partir del mensaje *un primer retrato en acuarela de un joven profesor de literatura con un libro* | Imagen generada a partir del mensaje *un primer retrato al óleo de una joven profesora de informática con una computadora* | Imagen generada a partir del mensaje *un primer retrato al óleo de un anciano profesor de matemáticas frente a la pizarra*
+
+> Imágenes de la colección **Artificial Teachers** de [Dmitry Soshnikov](http://soshnikov.com)
+
+## DALL-E
+### [DALL-E 1](https://openai.com/research/dall-e)
+
+DALL-E is a version of GPT-3 trained to generate images from prompts. It has been trained with 12-billion parameters.
+
+Unlike CLIP, DALL-E receives both text and image as a single stream of tokens for both images and text. Therefore, from multiple prompts, you can generate images based on the text.
+### [DALL-E 2](https://openai.com/dall-e-2)
+La principal diferencia entre DALL.E 1 y 2 es que genera imágenes y arte más realistas.
+
+Ejemplos de generaciones de imágenes con DALL-E:
+ |  | 
+----|----|----
+Imagen generada a partir del mensaje *un primer retrato en acuarela de un joven profesor de literatura con un libro* | Imagen generada a partir del mensaje *un primer retrato al óleo de una joven profesora de informática con una computadora* | Imagen generada a partir del mensaje *un primer retrato al óleo de un anciano profesor de matemáticas frente a la pizarra*
+
+## Referencias
+
+* Papel VQGAN: [Taming Transformers for High-Resolution Image Synthesis](https://compvis.github.io/taming-transformers/paper/paper.pdf)
+* Papel CLIP: [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/pdf/2103.00020.pdf)
+
+
From 1cfe35a1479dc050f4063a89bb7284eb8d7edf9e Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 20:51:05 -0500
Subject: [PATCH 32/33] Create README.es.md
---
lessons/sketchnotes/README.es.md | 5 +++++
1 file changed, 5 insertions(+)
create mode 100644 lessons/sketchnotes/README.es.md
diff --git a/lessons/sketchnotes/README.es.md b/lessons/sketchnotes/README.es.md
new file mode 100644
index 00000000..7e132107
--- /dev/null
+++ b/lessons/sketchnotes/README.es.md
@@ -0,0 +1,5 @@
+Todas las notas esquemáticas del plan de estudios se pueden descargar aquí.
+
+🎨 Creado por: Tomomi Imura (Twitter: [@girlie_mac](https://twitter.com/girlie_mac), GitHub: [girliemac](https://github.com/girliemac))
+
+[](https://creativecommons.org/licenses/by-sa/4.0/)
From 5b29fa1ab3dbd077d0ba838bd62fef042df2205c Mon Sep 17 00:00:00 2001
From: Ina <59503454+Ina220@users.noreply.github.com>
Date: Fri, 12 Jan 2024 20:52:47 -0500
Subject: [PATCH 33/33] Create README.es.md
---
lessons/README.es.md | 5 +++++
1 file changed, 5 insertions(+)
create mode 100644 lessons/README.es.md
diff --git a/lessons/README.es.md b/lessons/README.es.md
new file mode 100644
index 00000000..03e0580a
--- /dev/null
+++ b/lessons/README.es.md
@@ -0,0 +1,5 @@
+# Descripción general
+
+
+
+> Nota de boceto por [Tomomi Imura](https://twitter.com/girlie_mac)