Lessons translation

lessons/2-Symbolic/README.es.md

@@ -0,0 +1,44 @@
+# Representación del Conocimiento y Sistemas Expertos
+
+![Summary of Symbolic AI content](../sketchnotes/ai-symbolic.png)
+
+> 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.
+
+  <img src="images/DIKW_Pyramid.png" width="30%"/>
+
+*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:
+
+![Knowledge representation spectrum](images/knowledge-spectrum.png)
+
+> 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

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.
+
+|      |      |
+|--------------|-----------|
+|<img src='images/Rosenblatt-wikipedia.jpg' alt='Frank Rosenblatt'/> | <img src='images/Mark_I_perceptron_wikipedia.jpg' alt='The Mark 1 Perceptron' />|
+
+> 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(w<sup>T</sup>x)
+
+donde f es una función de activación escalonada
+
+<!-- img src="http://www.sciweavers.org/tex2img.php?eq=f%28x%29%20%3D%20%5Cbegin%7Bcases%7D%0A%20%20%20%20%20%20%20%20%20%2B1%20%26%20x%20%5Cgeq%200%20%5C%5C%0A%20%20%20%20%20%20%20%20%20-1%20%26%20x%20%3C%200%0A%20%20%20%20%20%20%20%5Cend%7Bcases%7D%20%5C%5C%0A&bc=White&fc=Black&im=jpg&fs=12&ff=arev&edit=0" align="center" border="0" alt="f(x) = \begin{cases} +1 & x \geq 0 \\ -1 & x < 0 \end{cases} \\" width="154" height="50" / -->
+<img src="images/activation-func.png"/>
+
+## 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) = -&sum;w<sup>T</sup>x<sub>i</sub>t<sub>i</sub>
+
+dónde:
+
+* la suma se toma de aquellos puntos de datos de entrenamiento i que resultan en una clasificación incorrecta
+* x<sub>i</sub> son los datos de entrada y t<sub>i</sub> 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<sup>(0)</sup> y luego, en cada paso, actualizamos los pesos de acuerdo con la fórmula:
+
+w<sup>(t+1)</sup> = w<sup>(t)</sup> - &eta;&nabla;E(w)
+
+Aquí &eta; es la llamada **tasa de aprendizaje**, y &nabla;E(w) denota el **gradiente** de E. Después de calcular el gradiente, terminamos con
+
+w<sup>(t+1)</sup> = w<sup>(t)</sup> + &sum;&eta;x<sub>i</sub>t<sub>i</sub>
+
+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)

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** &sum;<sub>i</sub>|f(x<sup>(i)</sup>)-y< sup>(i)</sup>|, o **error al cuadrado** &sum;<sub>i</sub>(f(x<sup>(i)</sup>)-y<sup>(i )</sup>)<sup>2</sup>
+* 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<sup>(0)</sup>, b<sup>(0)</sup>
+*Repetir el siguiente paso muchas veces:
+     - w<sup>(i+1)</sup> = w<sup>(i)</sup>-&eta;&part;&lagran;/&part;w
+     - b<sup>(i+1)</sup> = b<sup>(i)</sup>-&eta;&part;&lagran;/&part;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:
+* z<sub>1</sub>=w<sub>1</sub>x+b<sub>1</sub>
+* z<sub>2</sub>=w<sub>2</sub>&alpha;(z<sub>1</sub>)+b<sub>2</sub>
+* f = &sigma;(z<sub>2</sub>)
+
+Aquí, &alfa; es una **función de activación no lineal**, &sigma; es una función softmax y los parámetros &theta;=<*w<sub>1</sub>,b<sub>1</sub>,w<sub>2</sub>,b<sub>2</sub >*>.
+
+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:
+
+* &part;&lagran;/&part;w<sub>2</sub> = (&part;&lagran;/&part;&sigma;)(&part;&sigma;/&part;z<sub>2</sub>)(&part; z<sub>2</sub>/&part;w<sub>2</sub>)
+* &part;&lagran;/&part;w<sub>1</sub> = (&part;&lagran;/&part;&sigma;)(&part;&sigma;/&part;z<sub>2</sub>)(&part; z<sub>2</sub>/&part;&alpha;)(&part;&alpha;/&part;z<sub>1</sub>)(&part;z<sub>1</sub>/&part;w< sub>1</sub>)
+
+> ✅ 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'.
+
+<img alt="calcular gráfico" src="images/ComputeGraphGrad.png"/>
+
+> 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)