{"id":158,"date":"2026-04-11T18:01:03","date_gmt":"2026-04-11T18:01:03","guid":{"rendered":"https:\/\/pulki.es\/blog\/?p=158"},"modified":"2026-04-11T18:01:03","modified_gmt":"2026-04-11T18:01:03","slug":"large-language-model-llm-from-scratch-neural-networks","status":"publish","type":"post","link":"https:\/\/pulki.es\/blog\/index.php\/2026\/04\/11\/large-language-model-llm-from-scratch-neural-networks\/","title":{"rendered":"Large Language Model (LLM) from scratch. Neural Networks."},"content":{"rendered":"\n

En esta entrada introduciremos las redes neuronales, una pieza clave en el desarrollo de nuestro LLM. En el contexto de este proyecto, su importancia radica en que permiten transformar secuencias de tokens en representaciones internas que capturan patrones y relaciones complejas del lenguaje, muchas de ellas no lineales. Gracias a ello, el modelo puede predecir el siguiente token de forma mucho m\u00e1s flexible y potente que un modelo lineal.<\/p>\n\n\n\n

Para ilustrar su relevancia, comenzaremos explicando qu\u00e9 entendemos por red neuronal y luego veremos un componente clave de ellas: las capas. Posteriormente, mediante un ejemplo \u2014el problema XOR\u2014, mostraremos que a\u00f1adir capas permite construir representaciones internas m\u00e1s ricas, lo que ampl\u00eda la capacidad del modelo para resolver problemas que un modelo lineal no puede resolver.<\/p>\n\n\n\n

Redes neuronales<\/em><\/strong>: intro<\/strong><\/em><\/p>\n\n\n\n

Siguiendo a Jurafsky y Martin (2026)<\/strong>, una red neuronal moderna puede entenderse como una red de peque\u00f1as unidades computacionales, cada una de las cuales recibe un vector de entrada y produce una \u00fanica salida. El t\u00e9rmino \u201cneuronal\u201d proviene de la neurona de McCulloch-Pitts, un modelo simplificado de la neurona biol\u00f3gica descrito en t\u00e9rminos de l\u00f3gica proposicional. Sin embargo, las redes neuronales contempor\u00e1neas se apartan de esa formulaci\u00f3n original y hoy se utilizan sobre todo como modelos computacionales abstractos.<\/p>\n\n\n\n

La arquitectura que veremos en esta entrada se llama feedforward network<\/strong>. Como es usual en redes neuronales, esta red estar\u00e1 compuesta por peque\u00f1as unidades computacionales, donde cada unidad tiene la siguiente estructura:<\/p>\n\n\n\n

z<\/mi>=<\/mo>b<\/mi>+<\/mo>\u2211<\/mo>i<\/mi><\/munder><\/mrow>w<\/mi>i<\/mi><\/msub>x<\/mi>i<\/mi><\/msub>.<\/mi><\/mrow>z = b + \\sum_{i}w_{i}x_{i}.<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Como ya hemos visto en otras entradas, z<\/mi>z<\/annotation><\/semantics><\/math> ser\u00e1 la salida, b<\/mi>b<\/annotation><\/semantics><\/math> el sesgo, w<\/mi>i<\/mi><\/msub>w_{i}<\/annotation><\/semantics><\/math> los pesos, y x<\/mi>i<\/mi><\/msub>x_{i}<\/annotation><\/semantics><\/math> los valores de entrada. Al igual que en otras publicaciones, aplicaremos una funci\u00f3n no lineal sobre z<\/mi>z<\/annotation><\/semantics><\/math>, y lo que salga de ah\u00ed se llamar\u00e1 el valor de activaci\u00f3n<\/strong> (a).<\/p>\n\n\n\n

En la pr\u00e1ctica, existen tres funciones no lineales importantes. Por una parte est\u00e1 tanh<\/mi>\u2061<\/mo><\/mrow>(<\/mo>)<\/mo><\/mrow>\\tanh()<\/annotation><\/semantics><\/math>:<\/p>\n\n\n\n
a<\/mi>=<\/mo>t<\/mi>a<\/mi>n<\/mi>h<\/mi>(<\/mo>z<\/mi>)<\/mo>=<\/mo>e<\/mi>z<\/mi><\/msup>\u2212<\/mo>e<\/mi>\u2212<\/mo>z<\/mi><\/mrow><\/msup><\/mrow>e<\/mi>z<\/mi><\/msup>+<\/mo>e<\/mi>\u2212<\/mo>z<\/mi><\/mrow><\/msup><\/mrow><\/mfrac><\/mrow>a = tanh(z) = \\frac{e^{z} – e^{-z}}{e^{z} + e^{-z}}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Luego tenemos la sigmoide:<\/p>\n\n\n\n

a<\/mi>=<\/mo>\u03c3<\/mi>(<\/mo>z<\/mi>)<\/mo>=<\/mo>1<\/mn>1<\/mn>+<\/mo>e<\/mi>\u2212<\/mo>z<\/mi><\/mrow><\/msup><\/mrow><\/mfrac><\/mrow>a = \\sigma(z) = \\frac{1}{1+e^{-z}}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

y finalmente, ReLU (del ingl\u00e9s rectified linear unit<\/em>):<\/p>\n\n\n\n

a<\/mi>=<\/mo>R<\/mi>e<\/mi>L<\/mi>U<\/mi>(<\/mo>z<\/mi>)<\/mo>=<\/mo>max<\/mi>\u2061<\/mo><\/mrow>(<\/mo>0<\/mn>,<\/mo>z<\/mi>)<\/mo>.<\/mi><\/mrow>a = ReLU(z) = \\max(0,z).<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Tal como explican Jurafsky y Martin (2026)<\/strong>, en este contexto las funciones de activaci\u00f3n m\u00e1s empleadas son tanh<\/strong> \u2014muchas veces en reemplazo de la sigmoide, porque en la pr\u00e1ctica suele funcionar mejor\u2014 y ReLU<\/strong>. La funci\u00f3n tanh<\/strong> es popular porque es suavemente diferenciable y porque lleva los valores extremos hacia el centro. ReLU<\/strong>, por su parte, es muy utilizada porque conserva ciertas ventajas de las funciones lineales al ser lineal cuando z<\/mi>><\/mo>0<\/mn><\/mrow>z>0<\/annotation><\/semantics><\/math>. En este sentido, en funciones como la sigmoide y t<\/mi>a<\/mi>n<\/mi>h<\/mi><\/mrow>tanh<\/annotation><\/semantics><\/math>, valores muy altos en magnitud de z<\/mi><\/mrow>z<\/annotation><\/semantics><\/math> hacen que la salida se sature: en la sigmoide hacia 0 o 1, y en t<\/mi>a<\/mi>n<\/mi>h<\/mi><\/mrow>tanh<\/annotation><\/semantics><\/math> hacia -1 o 1. En esas zonas, las derivadas se vuelven muy peque\u00f1as, lo que puede causar un problema conocido como vanishing gradient problem<\/em>. En cambio, para ReLU<\/strong>, este problema no aparece de la misma forma para valores altos de activaci\u00f3n.<\/p>\n\n\n\n

En t\u00e9rminos visuales, la unidad que mencionamos anteriormente se puede ilustrar de la siguiente forma:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

En la pr\u00e1ctica, es com\u00fan utilizar m\u00faltiples unidades y m\u00faltiples capas. En la siguiente secci\u00f3n veremos esto en detalle.<\/p>\n\n\n\n

A\u00f1adiendo capas<\/em><\/strong><\/p>\n\n\n\n

Anteriormente mostramos una unidad, no obstante, podemos conformar una red uniendo m\u00faltiples unidades. La arquitectura est\u00e1ndar para hacer esto se muestra en la siguiente imagen:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Como podemos ver, tenemos una red feedforward<\/strong> totalmente conectada, con una capa de entrada, una capa oculta (h<\/mi>h<\/annotation><\/semantics><\/math>), y una de salida. Es totalmente conectada, porque cada x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math> se conecta con todos los h<\/mi>j<\/mi><\/msub><\/mrow>h_j<\/annotation><\/semantics><\/math>, y cada h<\/mi>j<\/mi><\/msub><\/mrow>h_j<\/annotation><\/semantics><\/math>\u200b con todos los nodos de salida. Adem\u00e1s, es feedforward porque la informaci\u00f3n fluye \u00fanicamente desde la entrada hacia la salida, sin ciclos ni retroalimentaci\u00f3n. Si deseas profundizar en la intuici\u00f3n, recomiendo que visites el siguiente recurso<\/a>.<\/p>\n\n\n\n

A\u00f1adiendo capas: el problema XOR.<\/em><\/strong><\/p>\n\n\n\n

En la introducci\u00f3n de esta publicaci\u00f3n dijimos que a\u00f1adir capas permite construir representaciones internas m\u00e1s ricas. Una forma cl\u00e1sica de ilustrar esta idea es mediante el problema XOR, que muestra que un perceptr\u00f3n<\/strong> no puede computar esta funci\u00f3n. La raz\u00f3n es que XOR no es linealmente separable. En cambio, al a\u00f1adir una capa oculta, la red puede construir una nueva representaci\u00f3n de la entrada que s\u00ed permite resolver el problema.<\/p>\n\n\n\n

Para mostrar brevemente la l\u00f3gica detr\u00e1s de este problema, debemos definir qu\u00e9 es un perceptr\u00f3n<\/strong>, y qu\u00e9 hace la operaci\u00f3n AND, OR y XOR.<\/p>\n\n\n\n

Un perceptron<\/strong>, es una unidad neuronal con la siguiente estructura:<\/p>\n\n\n\n

y<\/mi>=<\/mo>{<\/mo>0<\/mn>,<\/mo><\/mrow><\/mtd>si <\/mtext>\ud835\udc30<\/mi>\u22c5<\/mo>\ud835\udc31<\/mi>+<\/mo>b<\/mi>\u2264<\/mo>0<\/mn><\/mrow><\/mtd><\/mtr>1<\/mn>,<\/mo><\/mrow><\/mtd>si <\/mtext>\ud835\udc30<\/mi>\u22c5<\/mo>\ud835\udc31<\/mi>+<\/mo>b<\/mi>><\/mo>0<\/mn><\/mrow><\/mtd><\/mtr><\/mtable><\/mo><\/mrow><\/mrow>y =\n\\begin{cases}\n0, & \\text{si } \\mathbf{w}\\cdot\\mathbf{x} + b \\leq 0 \\\\\n1, & \\text{si } \\mathbf{w}\\cdot\\mathbf{x} + b > 0\n\\end{cases}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

La operaci\u00f3n AND se define como:<\/p>\n\n\n\n

AND<\/mtext>=<\/mo><\/mspace>x<\/mi>1<\/mn><\/msub><\/mtd>x<\/mi>2<\/mn><\/msub><\/mtd>y<\/mi><\/mtd><\/mtr>0<\/mn><\/mtd>0<\/mn><\/mtd>0<\/mn><\/mtd><\/mtr>0<\/mn><\/mtd>1<\/mn><\/mtd>0<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>0<\/mn><\/mtd>0<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn><\/mtd><\/mtr><\/mtable><\/mrow>\\text{AND} =\n\\qquad\n\\begin{array}{c c|c}\nx_1 & x_2 & y \\\\\n\\hline\n0 & 0 & 0 \\\\\n0 & 1 & 0 \\\\\n1 & 0 & 0 \\\\\n1 & 1 & 1\n\\end{array}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

la operaci\u00f3n OR como:<\/p>\n\n\n\n

OR<\/mtext>=<\/mo><\/mspace>x<\/mi>1<\/mn><\/msub><\/mtd>x<\/mi>2<\/mn><\/msub><\/mtd>y<\/mi><\/mtd><\/mtr>0<\/mn><\/mtd>0<\/mn><\/mtd>0<\/mn><\/mtd><\/mtr>0<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>0<\/mn><\/mtd>1<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn><\/mtd><\/mtr><\/mtable><\/mrow>\\text{OR} =\n\\qquad\n\\begin{array}{c c|c}\nx_1 & x_2 & y \\\\\n\\hline\n0 & 0 & 0 \\\\\n0 & 1 & 1 \\\\\n1 & 0 & 1 \\\\\n1 & 1 & 1\n\\end{array}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

y XOR como<\/p>\n\n\n\n

XOR<\/mtext>=<\/mo><\/mspace>x<\/mi>1<\/mn><\/msub><\/mtd>x<\/mi>2<\/mn><\/msub><\/mtd>y<\/mi><\/mtd><\/mtr>0<\/mn><\/mtd>0<\/mn><\/mtd>0<\/mn><\/mtd><\/mtr>0<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>0<\/mn><\/mtd>1<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>1<\/mn><\/mtd>0<\/mn><\/mtd><\/mtr><\/mtable><\/mrow>\\text{XOR} =\n\\qquad\n\\begin{array}{c c|c}\nx_1 & x_2 & y \\\\\n\\hline\n0 & 0 & 0 \\\\\n0 & 1 & 1 \\\\\n1 & 0 & 1 \\\\\n1 & 1 & 0\n\\end{array}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Luego, siguiendo a Jurafsky y Martin (2026)<\/strong>, podemos ver que si elegimos los siguientes pesos,<\/p>\n\n\n\n

w<\/mi>1<\/mn><\/msub>w_{1}<\/annotation><\/semantics><\/math><\/td>w<\/mi>2<\/mn><\/msub>w_{2}<\/annotation><\/semantics><\/math><\/td>b<\/mi>b<\/annotation><\/semantics><\/math><\/td><\/tr>
1<\/td>1<\/td>-1<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

es posible construir la funci\u00f3n AND. \u00bfC\u00f3mo? En la siguiente tabla lo hacemos en detalle:<\/p>\n\n\n\n

x<\/mi>1<\/mn><\/msub><\/mtd>x<\/mi>2<\/mn><\/msub><\/mtd>w<\/mi>\u22c5<\/mo>x<\/mi>+<\/mo>b<\/mi><\/mrow><\/mtd>y<\/mi><\/mtd><\/mtr>0<\/mn><\/mtd>0<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>0<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>0<\/mn>\u2212<\/mo>1<\/mn>\u2264<\/mo>0<\/mn><\/mrow><\/mtd>0<\/mn><\/mtd><\/mtr>0<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>0<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>1<\/mn>\u2212<\/mo>1<\/mn>\u2264<\/mo>0<\/mn><\/mrow><\/mtd>0<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>0<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>1<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>0<\/mn>\u2212<\/mo>1<\/mn>\u2264<\/mo>0<\/mn><\/mrow><\/mtd>0<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>1<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>1<\/mn>\u2212<\/mo>1<\/mn>><\/mo>0<\/mn><\/mrow><\/mtd>1<\/mn><\/mtd><\/mtr><\/mtable>\\begin{array}{c c| c |c}\nx_1 & x_2 & w\\cdot x + b & y \\\\\n\\hline\n0 & 0 & 1 \\times 0 + 1\\times 0-1 \\leq 0 & 0 \\\\\n0 & 1 & 1 \\times 0 + 1\\times 1-1 \\leq 0 & 0 \\\\\n1 & 0 & 1 \\times 1 + 1\\times 0-1 \\leq 0 & 0 \\\\\n1 & 1 & 1 \\times 1 + 1\\times 1-1>0 & 1\n\\end{array}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Tambi\u00e9n, con los siguientes pesos,<\/p>\n\n\n\n

w<\/mi>1<\/mn><\/msub>w_{1}<\/annotation><\/semantics><\/math><\/td>w<\/mi>2<\/mn><\/msub>w_{2}<\/annotation><\/semantics><\/math><\/td>b<\/mi>b<\/annotation><\/semantics><\/math><\/td><\/tr>
1<\/td>1<\/td>0<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

la funci\u00f3n OR es representable, tal como lo evidencia la siguiente tabla:<\/p>\n\n\n\n

x<\/mi>1<\/mn><\/msub><\/mtd>x<\/mi>2<\/mn><\/msub><\/mtd>w<\/mi>\u22c5<\/mo>x<\/mi>+<\/mo>b<\/mi><\/mrow><\/mtd>y<\/mi><\/mtd><\/mtr>0<\/mn><\/mtd>0<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>0<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>0<\/mn>+<\/mo>0<\/mn>\u2264<\/mo>0<\/mn><\/mrow><\/mtd>0<\/mn><\/mtd><\/mtr>0<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>0<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>1<\/mn>+<\/mo>0<\/mn>><\/mo>0<\/mn><\/mrow><\/mtd>1<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>0<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>1<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>0<\/mn>+<\/mo>0<\/mn>><\/mo>0<\/mn><\/mrow><\/mtd>1<\/mn><\/mtd><\/mtr>1<\/mn><\/mtd>1<\/mn><\/mtd>1<\/mn>\u00d7<\/mo>1<\/mn>+<\/mo>1<\/mn>\u00d7<\/mo>1<\/mn>+<\/mo>0<\/mn>><\/mo>0<\/mn><\/mrow><\/mtd>1<\/mn><\/mtd><\/mtr><\/mtable>\\begin{array}{c c| c |c}\nx_1 & x_2 & w\\cdot x + b & y \\\\\n\\hline\n0 & 0 & 1 \\times 0 + 1\\times 0+0 \\leq 0 & 0 \\\\\n0 & 1 & 1 \\times 0 + 1\\times 1+0 > 0 & 1 \\\\\n1 & 0 & 1 \\times 1 + 1\\times 0+0 > 0 & 1 \\\\\n1 & 1 & 1 \\times 1 + 1\\times 1+0>0 & 1\n\\end{array}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

No obstante, sin importar los pesos que elijamos, la funci\u00f3n XOR no puede ser replicada, debido a que XOR no es linealmente separable (para una intuici\u00f3n simple, ver Jurafsky y Martin (2026)<\/strong> y para una m\u00e1s compleja, puedes consultar aqu\u00ed<\/a>). En cambio, al a\u00f1adir una capa oculta, la red puede construir una nueva representaci\u00f3n de la entrada que s\u00ed permite resolver el problema.<\/p>\n\n\n\n

En la siguiente imagen, mostramos un esquema en el que la funci\u00f3n XOR puede ser resuelta con una capa oculta:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

A modo de ejercicio, prueba con los par\u00e1metros de la imagen, y verifica que la funci\u00f3n XOR se pueda representar con aquellos.<\/p>\n\n\n\n

Estructura de una red neuronal<\/em><\/strong><\/p>\n\n\n\n

Para ilustrar la estructura de una red neuronal, partiremos con un tipo de red simple llamado feedforward<\/em>. Aquella, est\u00e1 compuesta por unidades de entrada, unidades ocultas y unidades de salida. Siguiendo la notaci\u00f3n de Jurafsky y Martin (2026)<\/strong>, denotaremos la capa oculta como h<\/mi><\/mrow>h<\/annotation><\/semantics><\/math>, y cada una de sus unidades como h<\/mi>i<\/mi><\/msub><\/mrow>h_i<\/annotation><\/semantics><\/math>. Como en este ejemplo tenemos una red completamente conectada, cada unidad de una capa tomar\u00e1 como entrada las salidas de todas las unidades de la capa anterior. Adem\u00e1s, puesto que aqu\u00ed trabajaremos con una sola capa oculta, h<\/mi><\/mrow>h<\/annotation><\/semantics><\/math> ser\u00e1 \u00fanico. En cambio, si la red tuviera m\u00faltiples capas ocultas, usaremos una notaci\u00f3n indexada por capa, como a<\/mi>[<\/mo>i<\/mi>]<\/mo><\/mrow><\/msup>a^{[i]}<\/annotation><\/semantics><\/math>, para distinguir la activaci\u00f3n de cada una de ellas.<\/p>\n\n\n\n

Por otra parte, siguiendo Jurafsky y Martin (2026)<\/strong>, definiremos una matriz W<\/mi>W<\/annotation><\/semantics><\/math><\/strong>, donde el elemento i<\/mi>i<\/annotation><\/semantics><\/math> representa la conexi\u00f3n desde la entrada x<\/mi>i<\/mi><\/msub>x_{i}<\/annotation><\/semantics><\/math> hasta la unidad oculta h<\/mi>j<\/mi><\/msub>h_{j}<\/annotation><\/semantics><\/math> <\/strong>y b<\/mi>b<\/annotation><\/semantics><\/math><\/strong> un vector de sesgos. Por ejemplo, para la imagen, la matriz viene dada por:<\/p>\n\n\n\n
W<\/mi>=<\/mo>[<\/mo>w<\/mi>h<\/mi>1<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub><\/mrow><\/msub><\/mtd>w<\/mi>h<\/mi>1<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub><\/mrow><\/msub><\/mtd><\/mtr>w<\/mi>h<\/mi>2<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub><\/mrow><\/msub><\/mtd>w<\/mi>h<\/mi>2<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub><\/mrow><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>,<\/mo><\/mrow>W=\\begin{bmatrix} w_{h_{1},x_{1}} & w_{h_{1},x_{2}} \\\\ w_{h_{2},x_{1}} & w_{h_{2},x_{2}}\\end{bmatrix},\n<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

y X<\/strong> y B<\/strong> por:<\/p>\n\n\n\n

X<\/mi>=<\/mo>[<\/mo>x<\/mi>1<\/mn><\/msub><\/mtd><\/mtr>x<\/mi>2<\/mn><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow><\/mspace>B<\/mi>=<\/mo>[<\/mo>b<\/mi>h<\/mi>1<\/mn><\/msub><\/msub><\/mtd><\/mtr>b<\/mi>h<\/mi>2<\/mn><\/msub><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow><\/mrow>X =\\begin{bmatrix} x_{1}\\\\ x_{2}\\end{bmatrix} \\quad B=\\begin{bmatrix} b_{h_{1}}\\\\ b_{h_{2}}\\end{bmatrix}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Entonces, en este ejercicio, la capa oculta h<\/mi><\/mrow>h<\/annotation><\/semantics><\/math><\/strong>, viene dada por:<\/p>\n\n\n\n
h<\/mi>=<\/mo>\u03c3<\/mi>(<\/mo>W<\/mi>x<\/mi>+<\/mo>b<\/mi>)<\/mo>.<\/mi><\/mrow>h = \\sigma(Wx + b).<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

es decir,<\/p>\n\n\n\n

h<\/mi>=<\/mo>\u03c3<\/mi>(<\/mo>[<\/mo>w<\/mi>h<\/mi>1<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub><\/mrow><\/msub>x<\/mi>1<\/mn><\/msub>+<\/mo>w<\/mi>h<\/mi>1<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub><\/mrow><\/msub>x<\/mi>2<\/mn><\/msub>+<\/mo>b<\/mi>h<\/mi>1<\/mn><\/msub><\/msub><\/mrow><\/mtd><\/mtr>w<\/mi>h<\/mi>2<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub><\/mrow><\/msub>x<\/mi>1<\/mn><\/msub>+<\/mo>w<\/mi>h<\/mi>2<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub><\/mrow><\/msub>x<\/mi>2<\/mn><\/msub>+<\/mo>b<\/mi>h<\/mi>2<\/mn><\/msub><\/msub><\/mrow><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>)<\/mo><\/mrow>h =\\sigma\\bigg(\\begin{bmatrix} w_{h_{1},x_{1}}x_{1} + w_{h_{1},x_{2}}x_{2} + b_{h_{1}}\\\\ w_{h_{2},x_{1}}x_{1} + w_{h_{2},x_{2}}x_{2} + b_{h_{2}}\\end{bmatrix}\\bigg)<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Luego, aplicamos \u03c3<\/mi>(<\/mo>\u22c5<\/mo>)<\/mo><\/mrow>\\sigma(\\cdot)<\/annotation><\/semantics><\/math> a cada elemento, para obtener:<\/p>\n\n\n\n
h<\/mi>=<\/mo>[<\/mo>\u03c3<\/mi>(<\/mo>w<\/mi>h<\/mi>1<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub><\/mrow><\/msub>x<\/mi>1<\/mn><\/msub>+<\/mo>w<\/mi>h<\/mi>1<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub><\/mrow><\/msub>x<\/mi>2<\/mn><\/msub>+<\/mo>b<\/mi>h<\/mi>1<\/mn><\/msub><\/msub>)<\/mo><\/mrow><\/mtd><\/mtr>\u03c3<\/mi>(<\/mo>w<\/mi>h<\/mi>2<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub><\/mrow><\/msub>x<\/mi>1<\/mn><\/msub>+<\/mo>w<\/mi>h<\/mi>2<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub><\/mrow><\/msub>x<\/mi>2<\/mn><\/msub>+<\/mo>b<\/mi>h<\/mi>2<\/mn><\/msub><\/msub>)<\/mo><\/mrow><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>.<\/mi><\/mrow>h =\\begin{bmatrix} \\sigma(w_{h_{1},x_{1}}x_{1} + w_{h_{1},x_{2}}x_{2} + b_{h_{1}})\\\\ \\sigma(w_{h_{2},x_{1}}x_{1} + w_{h_{2},x_{2}}x_{2} + b_{h_{2}})\\end{bmatrix}.<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Hasta este punto hemos obtenido h<\/mi>i<\/mi><\/msub>h_{i}<\/annotation><\/semantics><\/math>, no obstante, el objetivo es calcular la salida final y<\/mi>y<\/annotation><\/semantics><\/math><\/strong>. Dependiendo de la aplicaci\u00f3n, y<\/mi>y<\/annotation><\/semantics><\/math><\/strong> puede ser un n\u00famero real, o un vector. Si por ejemplo, la intenci\u00f3n del investigador es calificar si alg\u00fan texto es medieval o no, y<\/mi>y<\/annotation><\/semantics><\/math><\/strong> ser\u00e1 un n\u00famero real que contendr\u00e1 una probabilidad. Por otra parte, si el objetivo es clasificar si el texto est\u00e1 escrito en espa\u00f1ol, ingl\u00e9s o portugu\u00e9s, probablemente, y<\/mi>y<\/annotation><\/semantics><\/math><\/strong> ser\u00e1 un vector.<\/p>\n\n\n\n

En el caso de que y<\/mi>y<\/annotation><\/semantics><\/math> es un vector (de dos elementos, y<\/mi>1<\/mn><\/msub>y_{1} <\/annotation><\/semantics><\/math>e y<\/mi>2<\/mn><\/msub>y_{2} <\/annotation><\/semantics><\/math>), y usando la notaci\u00f3n de Jurafsky y Martin (2026)<\/strong>, definiremos una matriz U<\/strong> que albergar\u00e1 los pesos de salida:<\/p>\n\n\n\n
U<\/mi>=<\/mo>[<\/mo>w<\/mi>y<\/mi>1<\/mn><\/msub>,<\/mo>h<\/mi>1<\/mn><\/msub><\/mrow><\/msub><\/mtd>w<\/mi>y<\/mi>1<\/mn><\/msub>,<\/mo>h<\/mi>2<\/mn><\/msub><\/mrow><\/msub><\/mtd><\/mtr>w<\/mi>y<\/mi>2<\/mn><\/msub>,<\/mo>h<\/mi>1<\/mn><\/msub><\/mrow><\/msub><\/mtd>w<\/mi>y<\/mi>2<\/mn><\/msub>,<\/mo>h<\/mi>2<\/mn><\/msub><\/mrow><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>,<\/mo><\/mrow>U=\\begin{bmatrix} w_{y_{1},h_{1}} & w_{y_{1},h_{2}} \\\\ w_{y_{2},h_{1}} & w_{y_{2},h_{2}}\\end{bmatrix},\n<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Luego, con la siguiente operaci\u00f3n, obtenemos la salida intermedia:<\/p>\n\n\n\n

z<\/mi>=<\/mo>U<\/mi>h<\/mi><\/mrow>z=Uh<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Finalmente, para convertir la salida intermedia en la final, debemos convertir el vector anterior en uno que contenga probabilidades. Para eso, usamos la funci\u00f3n softmax<\/strong>:<\/p>\n\n\n\n

y<\/mi>i<\/mi><\/msub>=<\/mo>s<\/mi>o<\/mi>f<\/mi>t<\/mi>m<\/mi>a<\/mi>x<\/mi>(<\/mo>z<\/mi>i<\/mi><\/msub>)<\/mo>=<\/mo>e<\/mi>x<\/mi>p<\/mi>(<\/mo>z<\/mi>i<\/mi><\/msub>)<\/mo><\/mrow>\u2211<\/mo>j<\/mi>=<\/mo>1<\/mn><\/mrow>d<\/mi><\/msubsup>e<\/mi>x<\/mi>p<\/mi>(<\/mo>z<\/mi>j<\/mi><\/msub>)<\/mo><\/mrow><\/mfrac>,<\/mo><\/mspace>i<\/mi>\u2264<\/mo>i<\/mi>\u2264<\/mo>d<\/mi><\/mrow>y_{i} = softmax(z_{i}) = \\frac{exp(z_{i})}{\\sum_{j=1}^{d}exp(z_{j})}, \\quad i \\leq i \\leq d<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

donde d<\/mi>d<\/annotation><\/semantics><\/math> es el tama\u00f1o del vector z<\/mi>z<\/annotation><\/semantics><\/math> (con d<\/mi>=<\/mo>2<\/mn><\/mrow>d=2<\/annotation><\/semantics><\/math> para este ejemplo). En este punto, ya estamos listos para calcular los pesos, es decir, la matriz U<\/strong> y W<\/strong>. A continuaci\u00f3n, esbozaremos el m\u00e9todo para llevarlo a cabo.<\/p>\n\n\n\n

Aprendiendo los pesos para cada capa<\/strong><\/p>\n\n\n\n

Tal como lo hemos hecho en otras entradas, el objetivo es aprender los par\u00e1metros de la red para que y<\/mi>^<\/mo><\/mover><\/mrow>\\hat y<\/annotation><\/semantics><\/math> se aproxime lo mejor posible a y<\/mi><\/mrow>y<\/annotation><\/semantics><\/math>. Para esto, us\u00e1bamos una loss function<\/strong>. En este caso, al igual que en la entrada pasada<\/a>, usamos la cross-entropy loss<\/strong>:<\/p>\n\n\n\n
L<\/mi>C<\/mi>E<\/mi><\/mrow><\/msub>(<\/mo>y<\/mi>^<\/mo><\/mover>,<\/mo>y<\/mi>)<\/mo>=<\/mo>\u2212<\/mo>log<\/mi>\u2061<\/mo><\/mspace><\/mrow>p<\/mi>(<\/mo>y<\/mi>|<\/mo>x<\/mi>)<\/mo>=<\/mo>\u2212<\/mo>[<\/mo>y<\/mi><\/mspace>log<\/mi>\u2061<\/mo><\/mspace><\/mrow>y<\/mi>^<\/mo><\/mover>+<\/mo>(<\/mo>1<\/mn>\u2212<\/mo>y<\/mi>)<\/mo><\/mspace>log<\/mi>\u2061<\/mo><\/mrow>(<\/mo>1<\/mn>\u2212<\/mo>y<\/mi>^<\/mo><\/mover>)<\/mo>]<\/mo><\/mrow>.<\/mi><\/mrow>L_{CE}(\\hat{y}, y) = -\\log p(y \\mid x) = -\\left[y \\log \\hat{y} + (1-y)\\log(1-\\hat{y})\\right].<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Finalmente, como sabemos, dicha funci\u00f3n debe ser minimizada. En este sentido, dado el alcance de esta serie no expondremos la estrategia de minimizaci\u00f3n, no obstante, un lector interesado puede consultar la secci\u00f3n 6.6.2 de Jurafsky y Martin (2026)<\/strong> para mayor detalle.<\/p>\n\n\n\n

Notas finales, y pr\u00f3xima entrada\u2026<\/em><\/strong><\/p>\n\n\n\n

En esta entrada introdujimos las redes neuronales y explicamos sus fundamentos te\u00f3ricos m\u00e1s b\u00e1sicos. Dado que se trata de un t\u00f3pico central para nuestro proyecto, en la siguiente entrada desarrollaremos un ejemplo pr\u00e1ctico.<\/p>\n\n\n\n

Jos\u00e9 Miguel Mu\u00f1oz Urra \u2013\u00a0jmunozu@pulki.es<\/a><\/p>\n\n\n\n

<\/p>\n","protected":false},"excerpt":{"rendered":"

En esta entrada introduciremos las redes neuronales, una pieza clave en el desarrollo de nuestro LLM. En el contexto de este proyecto, su importancia radica en que permiten transformar secuencias de tokens en representaciones internas que capturan patrones y relaciones complejas del lenguaje, muchas de ellas no lineales. Gracias a ello, el modelo puede predecir […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-158","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/158","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=158"}],"version-history":[{"count":14,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/158\/revisions"}],"predecessor-version":[{"id":184,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/158\/revisions\/184"}],"wp:attachment":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=158"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=158"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=158"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}