{ "nbformat": 4, "nbformat_minor": 5, "metadata": { "kernelspec": { "name": "python3", "display_name": "Python 3", "language": "python" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "336d61b3" }, "source": [ "# De una decisión cotidiana a una red neuronal\n", "### Seminario de Enseñanza de las Matemáticas - Cuaderno guiado para principiantes\n", "**Pregunta central:** ¿cómo puede un programa combinar pistas, producir una respuesta y ajustar sus reglas a partir de ejemplos?\n", "\n", "**Al terminar podrás:**\n", "\n", "* Explicar qué hacen las entradas, los pesos y el sesgo;\n", "* Distinguir reglas programadas de parámetros aprendidos;\n", "* Interpretar un gráfico de decisiones;\n", "* Explicar por qué XOR necesita algo más que una sola neurona de umbral con dos entradas originales.\n", "\n", "**Requisitos:** sumar, multiplicar y leer pares de números. No necesitas experiencia en Python.\n", "\n", "> Estas neuronas son modelos matemáticos muy simplificados. No sienten, no tienen intención y no reproducen toda la actividad de una neurona biológica. Los ejemplos cotidianos representan reglas inventadas, no descripciones completas del comportamiento humano." ], "id": "336d61b3" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9b0d96f9", "outputId": "66e7374e-f29d-4d02-b24a-fb6d45ff7e8c" }, "source": [ "nombre = \"Miss Pili\" # Guardamos un texto en una variable.\n", "print(\"Hola,\", nombre) # Mostramos un mensaje.\n", "print(\"Un ejemplo de suma:\", 1 + 1) # Python también hace operaciones." ], "execution_count": 28, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Hola, Miss Pili\n", "Un ejemplo de suma: 2\n" ] } ], "id": "9b0d96f9" }, { "cell_type": "markdown", "metadata": { "id": "b48dd749" }, "source": [ "### Diccionario mínimo de Python\n", "| Código | Cómo leerlo | Ejemplo |\n", "|---|---|---|\n", "| `nombre = \"Ana\"` | Guarda un valor con un nombre | `=` asigna; no compara |\n", "| `# comentario` | Explicación que Python no ejecuta | Ayuda a leer el código |\n", "| `print(...)` | Muestra algo debajo de la celda | `print(2 + 3)` muestra 5 |\n", "| `[0, 1]` | Lista de valores | Dos entradas de una neurona |\n", "| `pesos[0]` | Primer elemento de una lista | Python comienza a contar en 0 |\n", "| `*`, `+`, `>=`, `==` | Multiplicar, sumar, mayor o igual, igual a | `2 >= 2` es verdadero |\n", "| `def nombre(...):` | Define una función: una receta reutilizable | Se ejecuta cuando la llamas |\n", "| `if ...:` / `else:` | Si se cumple / en caso contrario | Elige qué instrucciones ejecutar |\n", "| `return` | Devuelve el resultado de una función | Nos da el valor de *y* |\n", "| `for ... in ...:` | Repite con cada elemento | Recorre casos de prueba |\n", "\n", "Los espacios al inicio de una línea agrupan instrucciones. Dentro de una función o de un `if`, conserva la sangría. En Python se escribe `0.5`, con punto decimal.\n", "\n", "**Acuerdo especial para esta clase:** `0` significa \"no\" y `1` significa \"sí\". El significado concreto de cada entrada y de la salida se define en cada historia." ], "id": "b48dd749" }, { "cell_type": "markdown", "metadata": { "id": "d5a3ee74" }, "source": [ "## 1. Una sola pista puede bastar: OR\n", "**Historia:** recibes un aviso si llega un mensaje por correo **o** por el chat. Si llegan los dos, también recibes el aviso.\n", "\n", "- $x_1$: ¿llegó correo? 0 = no; 1 = sí.\n", "- $x_2$: ¿llegó mensaje al chat? 0 = no; 1 = sí.\n", "- Salida: ¿se dio el aviso? 0 = no; 1 = sí.\n", "- Umbral: cantidad mínima necesaria para activar el aviso. Aquí es 1.\n", "\n", "$$s=x_1+x_2 \\qquad y=\\begin{cases}1 & s\\geq 1\\\\0 & s<1\\end{cases}$$\n", "\n", "Lee la fórmula así: «sumo las dos entradas; si llego a uno, activo». **OR incluye el caso en que ambas entradas son 1.**\n", "\n", "| Correo | Chat | Suma | ¿Llega al umbral 1? | Aviso |\n", "|---:|---:|---:|---|---:|\n", "| 0 | 0 | 0 | No | 0 |\n", "| 0 | 1 | 1 | Sí | 1 |\n", "| 1 | 0 | 1 | Sí | 1 |\n", "| 1 | 1 | 2 | Sí | 1 |\n", "\n", "**Antes de ejecutar:** si solo llega el chat, ¿cuánto vale la suma?" ], "id": "d5a3ee74" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "a4b93edc", "outputId": "4a862d49-e093-4764-fd94-a1a966380f57" }, "source": [ "def neurona_umbral(x1, x2, umbral):\n", " suma = x1 + x2 # 1. Juntamos las dos señales.\n", " if suma >= umbral: # 2. Comprobamos si alcanzan el mínimo.\n", " return 1 # 3. Si lo alcanzan, devolvemos \"sí\".\n", " else:\n", " return 0 # 4. Si no, devolvemos \"no\".\n", "\n", "correo = 0\n", "chat = 1\n", "aviso = neurona_umbral(correo, chat, umbral=1)\n", "print(\"Suma:\", correo + chat)\n", "print(\"¿Activar aviso?\", aviso)" ], "execution_count": 29, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Suma: 1\n", "¿Activar aviso? 1\n" ] } ], "id": "a4b93edc" }, { "cell_type": "markdown", "metadata": { "id": "3c449ab0" }, "source": [ "Ahora probaremos los cuatro casos posibles. `(0, 1)` es un par de valores. El `for` toma un par por vuelta y lo reparte entre `x1` y `x2`." ], "id": "3c449ab0" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "d1892969", "outputId": "7f2abcc8-a6bd-4fc7-dbb7-dbd0d237f6d5" }, "source": [ "casos = [(0, 0), (0, 1), (1, 0), (1, 1)]\n", "for x1, x2 in casos:\n", " resultado = neurona_umbral(x1, x2, umbral=1)\n", " print(\"Entradas:\", x1, x2, \"| Suma:\", x1 + x2, \"| Salida:\", resultado)" ], "execution_count": 30, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Entradas: 0 0 | Suma: 0 | Salida: 0\n", "Entradas: 0 1 | Suma: 1 | Salida: 1\n", "Entradas: 1 0 | Suma: 1 | Salida: 1\n", "Entradas: 1 1 | Suma: 2 | Salida: 1\n" ] } ], "id": "d1892969" }, { "cell_type": "markdown", "metadata": { "id": "8ed2600d" }, "source": [ "### Un dibujo del umbral\n", "Cada barra es una combinación de entradas. La línea marca el mínimo. Una barra que toca o supera la línea activa el aviso." ], "id": "8ed2600d" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 357 }, "id": "22937b33", "outputId": "46b6a25d-efba-4ea6-8d5e-82029c1c6774" }, "source": [ "import numpy as np # Herramientas numéricas para los gráficos.\n", "import matplotlib.pyplot as plt # Herramientas de dibujo.\n", "\n", "umbral_visual = 1 # CAMBIA SOLO ESTO: prueba 1 y después 2.\n", "sumas = [0, 1, 1, 2]\n", "etiquetas = [\"0, 0\", \"0, 1\", \"1, 0\", \"1, 1\"]\n", "colores = [\"#3399FF\" if s >= umbral_visual else \"#A9AFB9\" for s in sumas]\n", "fig, ax = plt.subplots(figsize=(7, 3.5))\n", "ax.bar(etiquetas, sumas, color=colores)\n", "ax.axhline(umbral_visual, color=\"#A13D63\", linestyle=\"--\", label=\"Umbral\")\n", "for i, s in enumerate(sumas):\n", " ax.text(i, s + 0.08, \"Salida \" + str(int(s >= umbral_visual)), ha=\"center\")\n", "ax.set(xlabel=\"Entradas (correo, chat)\", ylabel=\"Suma\", ylim=(0, 3), title=\"¿La suma supera el umbral?\")\n", "ax.legend()\n", "plt.tight_layout()\n", "plt.show()" ], "execution_count": 31, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "id": "22937b33" }, { "cell_type": "markdown", "metadata": { "id": "e965e58f" }, "source": [ "\n", "## 2. Algunas pistas aportan más: pesos\n", "**Historia:** una regla hipotética para decidir si vas a un concierto. Tener dinero aporta 3 puntos, mientras que vayan tus amigos aporta 1. Necesitas al menos 3 puntos.\n", "\n", "| Elemento | Significado | Valor |\n", "|---|---|---|\n", "| `dinero` | ¿Tengo dinero? | 0 o 1 |\n", "| `amigos` | ¿Van mis amigos? | 0 o 1 |\n", "| `peso_dinero` | Puntos que aporta tener dinero | 3 |\n", "| `peso_amigos` | Puntos que aporta ir con amigos | 1 |\n", "| `umbral` | Puntos mínimos para ir | 3 |\n", "\n", "**Cuenta a mano:** sin dinero y con amigos: `0 × 3 + 1 × 1 = 1`. Como 1 es menor que 3, la respuesta es 0. Es decir: no vas.\n", "\n", "Un **peso** multiplica una entrada. Un peso positivo aporta a la activación, le da más peso, literalmente. Uno negativo resta posibilidad. Cero hace que esa entrada no contribuya, equis, no importa. No es una medida universal de importancia, sino depende de cómo representamos las entradas.\n", "\n", "**Observa algo sutil:** con estos valores, el dinero determina por sí solo la decisión. Los amigos cambian la puntuación, pero no cambian la respuesta final. Prueba luego un umbral de 4." ], "id": "e965e58f" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3968b709", "outputId": "b14126a5-36fe-4d58-e1d4-7e36419bb4b1" }, "source": [ "def neurona_pesos(x1, x2, peso1, peso2, umbral):\n", " aporte1 = x1 * peso1 # Multiplicamos la primera señal por su peso.\n", " aporte2 = x2 * peso2 # Hacemos lo mismo con la segunda.\n", " puntuacion = aporte1 + aporte2 # Sumamos los aportes.\n", " if puntuacion >= umbral:\n", " return 1\n", " else:\n", " return 0\n", "\n", "peso_dinero = 3\n", "peso_amigos = 1\n", "umbral_concierto = 3 # PRUEBA después con 4.\n", "for dinero, amigos in casos:\n", " puntos = dinero * peso_dinero + amigos * peso_amigos\n", " ir = neurona_pesos(dinero, amigos, peso_dinero, peso_amigos, umbral_concierto)\n", " print(\"Dinero:\", dinero, \"| Amigos:\", amigos, \"| Puntos:\", puntos, \"| ¿Voy?\", ir)" ], "execution_count": 32, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Dinero: 0 | Amigos: 0 | Puntos: 0 | ¿Voy? 0\n", "Dinero: 0 | Amigos: 1 | Puntos: 1 | ¿Voy? 0\n", "Dinero: 1 | Amigos: 0 | Puntos: 3 | ¿Voy? 1\n", "Dinero: 1 | Amigos: 1 | Puntos: 4 | ¿Voy? 1\n" ] } ], "id": "3968b709" }, { "cell_type": "markdown", "metadata": { "id": "a77dc678" }, "source": [ "### Del relato a la fórmula\n", "$$s=w_1x_1+w_2x_2$$\n", "`aporte1` corresponde a $w_1x_1$; `aporte2` a $w_2x_2$; `puntuacion` a $s$. La comparación final funciona igual que en OR. El nuevo ingrediente es la multiplicación." ], "id": "a77dc678" }, { "cell_type": "markdown", "metadata": { "id": "2d1f8c9d" }, "source": [ "## 3. El sesgo: escribir el mismo umbral de otra manera\n", "Hasta aquí preguntábamos si la puntuación alcanzaba un mínimo. Podemos pasar ese mínimo al lado izquierdo:\n", "\n", "$$w_1x_1+w_2x_2\\geq\\theta \\quad\\Longleftrightarrow\\quad w_1x_1+w_2x_2-\\theta\\geq0.$$\n", "\n", "Llamamos **sesgo** al número $b=-\\theta$. Así definimos:\n", "\n", "$$z=w_1x_1+w_2x_2+b,\\qquad y=1\\text{ si }z\\geq0;\\; y=0\\text{ en otro caso}.$$\n", "\n", "A pesos fijos, aumentar el sesgo facilita la activación; disminuirlo la dificulta. Este «sesgo» es un parámetro matemático: no significa por sí mismo un prejuicio social." ], "id": "2d1f8c9d" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "e72b9e01", "outputId": "fe168dca-871c-4e6b-d0ae-2feba8127223" }, "source": [ "def neurona_sesgo(x1, x2, peso1, peso2, sesgo):\n", " z = x1 * peso1 + x2 * peso2 + sesgo\n", " if z >= 0:\n", " return 1\n", " else:\n", " return 0\n", "\n", "print(\"Comparamos la MISMA regla en dos escrituras:\")\n", "for x1, x2 in casos:\n", " con_umbral = neurona_pesos(x1, x2, 3, 1, umbral=3)\n", " con_sesgo = neurona_sesgo(x1, x2, 3, 1, sesgo=-3)\n", " print(\"Entradas:\", x1, x2, \"| Umbral:\", con_umbral, \"| Sesgo:\", con_sesgo)\n", "\n", "print(\"AND: tener dinero Y amigos\")\n", "for x1, x2 in casos:\n", " print(x1, x2, \"->\", neurona_sesgo(x1, x2, 1, 1, sesgo=-2))" ], "execution_count": 33, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Comparamos la MISMA regla en dos escrituras:\n", "Entradas: 0 0 | Umbral: 0 | Sesgo: 0\n", "Entradas: 0 1 | Umbral: 0 | Sesgo: 0\n", "Entradas: 1 0 | Umbral: 1 | Sesgo: 1\n", "Entradas: 1 1 | Umbral: 1 | Sesgo: 1\n", "AND: tener dinero Y amigos\n", "0 0 -> 0\n", "0 1 -> 0\n", "1 0 -> 0\n", "1 1 -> 1\n" ] } ], "id": "e72b9e01" }, { "cell_type": "markdown", "metadata": { "id": "e13a04c6" }, "source": [ "### Laboratorio visual\n", "En el gráfico, cada punto es un par de entradas. El número dentro del punto es la respuesta de la neurona. El fondo azul representa salida 1 y el fondo claro salida 0. La línea es donde la puntuación `z` vale cero.\n", "\n", "Las zonas entre los puntos muestran cómo se extendería la fórmula a números intermedios; en nuestros problemas binarios solo importan los cuatro puntos.\n" ], "id": "e13a04c6" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 437 }, "id": "414fa510", "outputId": "4ee71481-c1c8-44ac-cf53-bbac659956d3" }, "source": [ "def dibujar_frontera(peso1, peso2, sesgo, objetivos=None, titulo=\"Decisiones de una neurona\"):\n", " coordenadas = np.linspace(-0.3, 1.3, 180)\n", " X1, X2 = np.meshgrid(coordenadas, coordenadas)\n", " Z = peso1 * X1 + peso2 * X2 + sesgo\n", " fig, ax = plt.subplots(figsize=(5.5, 4.3))\n", " ax.contourf(X1, X2, (Z >= 0).astype(int), levels=[-0.5, 0.5, 1.5], colors=[\"#EDF0F4\", \"#B8E4EA\"])\n", " if Z.min() < 0 < Z.max():\n", " ax.contour(X1, X2, Z, levels=[0], colors=[\"#174B57\"], linewidths=2)\n", " for i, (x1, x2) in enumerate(casos):\n", " prediccion = neurona_sesgo(x1, x2, peso1, peso2, sesgo)\n", " etiqueta = prediccion if objetivos is None else objetivos[i]\n", " ax.scatter(x1, x2, s=550, marker=\"o\" if etiqueta == 1 else \"s\",\n", " color=\"#087E8B\" if etiqueta == 1 else \"#535C6B\", zorder=3)\n", " ax.text(x1, x2, str(etiqueta), color=\"white\", ha=\"center\", va=\"center\", zorder=4)\n", " ax.set(xlabel=\"Entrada x1\", ylabel=\"Entrada x2\", xticks=[0, 1], yticks=[0, 1], title=titulo)\n", " ax.set_aspect(\"equal\")\n", " plt.tight_layout()\n", " plt.show()\n", "\n", "peso1_visual = 1\n", "peso2_visual = 1\n", "sesgo_visual = 0 # CAMBIA SOLO ESTO: -1.5 y después 0.\n", "dibujar_frontera(peso1_visual, peso2_visual, sesgo_visual)" ], "execution_count": 34, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "id": "414fa510" }, { "cell_type": "markdown", "metadata": { "id": "9df5f372" }, "source": [ "## 4. Aprender de ejemplos: el perceptrón\n", "Hasta ahora, **nosotros elegimos los parámetros**. Ahora daremos ejemplos con la respuesta deseada y una regla para corregir parámetros cuando haya errores.\n", "\n", "| Concepto | En palabras sencillas |\n", "|---|---|\n", "| Datos de entrenamiento | Ejemplos junto con la respuesta deseada |\n", "| Predicción | Respuesta que da la neurona con sus parámetros actuales |\n", "| Error | Respuesta deseada menos predicción |\n", "| Tasa de aprendizaje | Tamaño de los ajustes de cada paso |\n", "| Entrenar | Repetir predicción, comparación y ajuste |\n", "\n", "Esto es **aprendizaje supervisado**: las respuestas deseadas vienen de fuera. El programa no inventa el objetivo ni verifica si nuestras etiquetas son razonables. El aprendizaje automático es una parte de la IA, no su única forma." ], "id": "9df5f372" }, { "cell_type": "markdown", "metadata": { "id": "cbda769b" }, "source": [ "### Una corrección, primero a mano\n", "Las reglas son:\n", "\n", "$$e=y_{deseada}-y_{predicha},\\qquad w_i^{nuevo}=w_i^{anterior}+\\alpha e x_i,\\qquad b^{nuevo}=b^{anterior}+\\alpha e.$$\n", "\n", "Para evitar decimales al empezar, usaremos $\\alpha=1$ y parámetros iniciales cero.\n", "\n", "Primer ejemplo OR: entradas (0, 0), salida deseada 0. Con pesos y sesgo cero, $z=0$ y la neurona responde 1. Entonces $e=0-1=-1$.\n", "\n", "- Primer peso: $0+1(-1)(0)=0$.\n", "- Segundo peso: $0+1(-1)(0)=0$.\n", "- Sesgo: $0+1(-1)=-1$.\n", "\n", "| Error | Interpretación | Ajuste |\n", "|---:|---|---|\n", "| 0 | Acertó | No cambia parámetros |\n", "| 1 | Debía activar y no activó | Aumenta sesgo y pesos de entradas activas |\n", "| −1 | Activó cuando no debía | Disminuye sesgo y pesos de entradas activas |" ], "id": "cbda769b" }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "74a8ebe1", "outputId": "56ec7c37-347e-4f9a-cb3c-a365fec7bc60" }, "source": [ "x1 = 0\n", "x2 = 0\n", "respuesta_deseada = 0\n", "peso1 = 0\n", "peso2 = 0\n", "sesgo = 0\n", "tasa = 1\n", "\n", "prediccion = neurona_sesgo(x1, x2, peso1, peso2, sesgo)\n", "error = respuesta_deseada - prediccion\n", "print(\"Antes:\", peso1, peso2, sesgo, \"| Predicción:\", prediccion, \"| Error:\", error)\n", "\n", "peso1 = peso1 + tasa * error * x1\n", "peso2 = peso2 + tasa * error * x2\n", "sesgo = sesgo + tasa * error\n", "print(\"Después:\", peso1, peso2, sesgo)" ], "execution_count": 35, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Antes: 0 0 0 | Predicción: 1 | Error: -1\n", "Después: 0 0 -1\n" ] } ], "id": "74a8ebe1" }, { "cell_type": "markdown", "metadata": { "id": "03f03f29" }, "source": [ "## Recursos adicionales\n", "\n", "| Recurso | Para qué usarlo\n", "|---|---|\n", "| [Preguntas frecuentes de Google Colab](https://research.google.com/colaboratory/faq.html) | Consultar funcionamiento y sesiones |\n", "| [Tutorial oficial de Python: control de flujo, en español](https://docs.python.org/es/3/tutorial/controlflow.html) | Repasar `if`, `for` y funciones |\n", "| [Google: nodos y capas ocultas](https://developers.google.com/machine-learning/crash-course/neural-networks/nodes-hidden-layers?hl=es-419) | Ampliar pesos, sesgo y capas |\n", "| [TensorFlow Playground](https://playground.tensorflow.org/) | Explorar redes visualmente |\n", "\n", "Playground usa otro procedimiento de entrenamiento y activaciones distintas a nuestro escalón; no es una ejecución del mismo código. Sus resultados pueden variar con la inicialización. El objetivo es observar formas de separación, no reproducir nuestros pesos.\n", "\n", "## Notas\n", "\n", "**Alcance:** los ejemplos trabajan con entradas binarias y datos sintéticos. No cubren entrenamiento multicapa, retropropagación, probabilidades ni modelos de lenguaje. El aprendizaje principal es entender el mecanismo y sus límites." ], "id": "03f03f29" } ] }