LN

cayetanoguerra · Nov 12, 2024 · 44937e4 · 44937e4
1 parent d39ef97
commit 44937e4
Show file tree

Hide file tree

Showing 2 changed files with 52 additions and 31 deletions.
diff --git a/ia/nbpy/nlp/Tema-05/.DS_Store b/ia/nbpy/nlp/Tema-05/.DS_Store
diff --git a/ia/nbpy/nlp/Tema-05/nb07.ipynb b/ia/nbpy/nlp/Tema-05/nb07.ipynb
@@ -183,7 +183,7 @@
     "\n",
     "\"Layer Normalization\" es una técnica de normalización utilizada en el entrenamiento de redes neuronales profundas, introducida por Jimmy Lei Ba, Jamie Ryan Kiros y Geoffrey Hinton en 2016 (https://arxiv.org/pdf/1607.06450.pdf). Esta técnica es fundamental para mejorar la estabilidad y acelerar el entrenamiento de modelos de aprendizaje profundo, especialmente en el contexto de redes neuronales recurrentes (RNN) y modelos de atención como los Transformers.\n",
     "\n",
-    "### Conceptos clave de la Layer Normalization:\n",
+    "### **Conceptos clave de la Layer Normalization:**\n",
     "\n",
     "1. **Normalización por Ejemplo**: La Layer Normalization normaliza los datos a lo largo de las características para cada ejemplo individual en un lote. Esto significa que, para cada dato en el lote, la normalización se realiza calculando la media y la varianza de todas sus características.\n",
     "\n",
@@ -195,7 +195,7 @@
     "\n",
     "5. **Aplicaciones en Modelos de Secuencia**: La Layer Normalization ha demostrado ser particularmente efectiva en modelos que procesan datos secuenciales, como las redes neuronales recurrentes y los modelos basados en el mecanismo de atención, donde ayuda a mejorar la estabilidad y eficiencia del entrenamiento.\n",
     "\n",
-    "### Ventajas de la Layer Normalization:\n",
+    "### **Ventajas de la Layer Normalization:**\n",
     "\n",
     "- **Estabilidad en el Entrenamiento**: Contribuye a la estabilidad del entrenamiento de redes neuronales profundas, lo que es crucial para lograr un buen rendimiento en tareas complejas.\n",
     "- **Eficiencia en Modelos de Secuencia**: Facilita el entrenamiento eficiente de modelos que trabajan con datos secuenciales, mejorando tanto la velocidad de convergencia como la calidad del modelo entrenado.\n",
@@ -206,7 +206,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Representación matemática:\n",
+    "### **Representación matemática:**\n",
     "\n",
     "La Layer Normalization se centra en normalizar las activaciones dentro de una capa para cada ejemplo de datos. A continuación se describe el proceso matemáticamente:\n",
     "\n",
@@ -239,63 +239,84 @@
    "source": [
     "---\n",
     "\n",
-    "## Ejercicio: Implementación de la normalización de capa\n",
+    "## **Ejercicio: Implementación de la normalización de capa**\n",
     "\n",
-    "Asumiento los parámetros $\\gamma$ y $\\beta$ como 1 y 0 respectivamente, desarrolla un código que normalice los siguientes vectores de características:\n"
+    "Asumiento los parámetros $\\gamma$ y $\\beta$ como 1 y 0 respectivamente, desarrolla un código que normalice el siguiente tensor de entrada:\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tamaño del lote: 3\n",
+      "Tamaño de la secuencia: 2\n",
+      "Tamaño de la entrada: 2\n",
+      "\n",
+      "tensor([[[-1.3416, -0.4472],\n",
+      "         [ 0.4472,  1.3416]],\n",
+      "\n",
+      "        [[-1.3416, -0.4472],\n",
+      "         [ 0.4472,  1.3416]],\n",
+      "\n",
+      "        [[-1.3416, -0.4472],\n",
+      "         [ 0.4472,  1.3416]]])\n"
+     ]
+    }
+   ],
    "source": [
     "import torch\n",
     "\n",
-    "v1 = torch.tensor([1.0, 2.0, 3.0])\n",
-    "v2 = torch.tensor([2.0, 2.0, 2.0])\n",
-    "v3 = torch.tensor([23.0, 0.01, 5.0])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "El resultado debe ser:"
+    "my_tensor = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=torch.float32)\n",
+    "\n",
+    "nl = torch.nn.LayerNorm((2, 2), eps=1e-05, elementwise_affine=False)\n",
+    "\n",
+    "print(\"Tamaño del lote:\", my_tensor.shape[0])\n",
+    "print(\"Tamaño de la secuencia:\", my_tensor.shape[1])\n",
+    "print(\"Tamaño de la entrada:\", my_tensor.shape[2])\n",
+    "print()\n",
+    "\n",
+    "print(nl(my_tensor))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([-1.2247,  0.0000,  1.2247], grad_fn=<NativeLayerNormBackward0>)\n",
-      "tensor([0., 0., 0.], grad_fn=<NativeLayerNormBackward0>)\n",
-      "tensor([ 1.3838, -0.9446, -0.4392], grad_fn=<NativeLayerNormBackward0>)\n"
+      "[[[-1.3416288 -0.4472096]\n",
+      "  [ 0.4472096  1.3416288]]\n",
+      "\n",
+      " [[-1.3416288 -0.4472096]\n",
+      "  [ 0.4472096  1.3416288]]\n",
+      "\n",
+      " [[-1.3416288 -0.4472096]\n",
+      "  [ 0.4472096  1.3416288]]]\n"
      ]
     }
    ],
    "source": [
-    "nl = torch.nn.LayerNorm(3, eps=1e-05, elementwise_affine=True)\n",
+    "# Hagamos lo mismo pero usando solo Python, sin PyTorch\n",
+    "import numpy as np\n",
     "\n",
-    "print(nl(v1))\n",
-    "print(nl(v2))\n",
-    "print(nl(v3))"
+    "my_tensor = my_tensor.numpy()\n",
+    "mean = np.mean(my_tensor, axis=(1, 2), keepdims=True)\n",
+    "std = np.std(my_tensor, axis=(1, 2), keepdims=True)\n",
+    "print((my_tensor - mean) / (std + 1e-05))"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "env",
    "language": "python",
    "name": "python3"
   },