Redes neuronales representadas como DAGs de programas computacionales parametrizados

Las redes neuronales pueden verse como algoritmos con parámetros ajustables, cuya optimización se realiza a través del aprendizaje automático. Este enfoque abre la puerta a un análisis más amplio, tanto desde la perspectiva matemática como computacional. En este artículo, exploraremos cómo estos algoritmos se representan mediante grafos dirigidos acíclicos (DAG), siguiendo las ideas presentadas por Blondel et al. (2024). Elements of Differentiable Programming.

La representación de redes neuronales como DAGs tiene varias ventajas:

1. Visualización: Los DAGs permiten una visualización más intuitiva de la estructura de las redes.
2. Optimización: Facilitan el uso de técnicas de optimización basadas en grafos.
3. Diferenciación automática: Facilitan la implementación de algoritmos como la retropropagación.
4. Paralelización: Los DAGs permiten ejecutar programas en paralelo en hardware especializado como GPUs y TPUs.

Además, profundizaremos en cómo los DAGs mejoran tanto el diseño como la comprensión de redes neuronales complejas, y su relación con técnicas avanzadas de aprendizaje profundo, como las redes residuales y recurrentes..

Programas computacionales parametrizados

Cadenas de computación

Para comenzar, consideremos los programas computacionales simples definidos por una secuencia de funciones $f_1, \ldots, f_n$ que se aplican de forma secuencial a una entrada $s_0 \in S_{0}.$ Denominaremos a estos programas cadenas de computación y los representaremos como $f = f_n \circ \cdots \circ f_1.$

Un ejemplo práctico de una cadena de computación es el procesamiento de imágenes, donde una imagen puede someterse a una serie de transformaciones como recorte, rotación y normalización. En el contexto de las redes neuronales, estas transformaciones suelen estar parametrizadas y sus parámetros se ajustan mediante un proceso de optimización durante el entrenamiento.

Figura 1. Representación de una cadena de computación como una secuencia de composiciones de funciones. Cada nodo intermedio simboliza una función, La flecha inicial indica la entrada, y la final, la salida. Las flechas internas ilustran las dependencias entre las funciones, conectando las salidas previas o la entrada inicial con las funciones.

Formalmente, una cadena de computación puede ser escrita como:

Donde $s_0$ es la entrada, $s_k\in S_k$ para $k = 1, \ldots, n-1,$ son los estados intermedios del programa y $s_n\in S_n$ es la salida. Es fundamental que el dominio (espacios de entrada) de $f_k$ sea compatible con la imagen (espacio de salida) de $f_{k-1}$ para que la composición tenga sentido. Es decir, que $f_k: S_{k-1} \to S_k$ para $k = 1, \ldots, n.$ De forma equivalente a la ecuación (1), la cadena de computación completa se puede escribir en una única expresión:

Como veremos a continuación, una cadena de computación puede ser representada como un grafo dirigido acíclico (DAG), donde los nodos del grafo representan las funciones individuales y las aristas representan las dependencias y el flujo de información entre las funciones.

Grafos acíclicos dirigidos

En un programa computacional genérico, las funciones intermedias pueden depender de las salidas de otras funciones. Estas dependencias se pueden representar mediante un Grafo Acíclico Dirigido (DAG). Un grafo dirigido $G = (V, E)$ se compone de un conjunto de nodos $V$ y un conjunto de aristas $E\subseteq V \times V.$ Una arista $(u, v) \in E$ es un par ordenado de nodos $u, v\in V,$ y se puede representar como $u \to v.$ para indicar que $v$ depende de $u.$ Para representar las entradas y las salidas, es conveniente utilizar semi-aristas entrantes $\to j$ y semi-aristas salientes $i \to.$

En un grafo $G = (V, E)$, los padres de un nodo $v\in V$ son aquellos nodos $u\in V$ tales que $(u, v)\in E,$ denotados como:

De manera similar, los hijos de un nodo $v\in V$ son los nodos $w\in V$ tales que $(v, w)\in E,$ representados por:

Los nodos sin padres son llamados raíces y los nodos sin hijos se conocen como hojas.

Un camino de $i$ a $j$ en un grafo $G = (V, E)$ es una secuencia de nodos $v_1, \ldots, v_k$ tal que $i \to v_1 \to \cdots \to v_k \to j.$ Un camino es simple si no contiene nodos repetidos. Un grafo es acíclico si no contiene ciclos, es decir, no existen caminos simples de un nodo a sí mismo. Un grafo acíclico dirigido (DAG) es un grafo dirigido que carece de ciclos.

La aristas de un DAG inducen un orden parcial entre los nodos, que se denota como $i \preceq j$ si existe un camino de $i$ a $j.$ Este orden parcial es una relación reflexiva, transitiva y antisimétrica. Se denomina «parcial» porque no todos los nodos están relacionados entre sí. Sin embargo, es posible definir un orden total llamado orden topológico: cualquier orden tal que $i \preceq j$ si y solo si no hay un camino de $j$ a $i.$

Programas computacionales como DAGs

Un programa computacional se puede pensar como una función en términos matemáticos, lo que significa que el programa debería devolver los mismos valores para las mismas entradas y no debería tener efectos secundarios. Además, asumimos que el programa se detiene después de un número finito de pasos. Dado esto, un programa puede descomponerse en un conjunto finito de funciones y variables intermedias, donde las dependencias entre estas pueden representarse mediante un grafo dirigido acíclico (DAG).

Bajo estas condicione, podemos hacer las siguientes suposiciones sobre un programa computacional:

1. Existe un nodo entrada $s_0$ y un nodo salida $s_n.$
2. Cada función intermedia $f_k$ produce un único valor $s_k \in S_k.$

Con un número finito de nodos como $V = \{0, 1, \ldots, n\},$ donde el nodo $0$ es la raíz, correspondiente a la entrada del programa, y el nodo $n$ es una hoja, correspondiente a la salida del programa. Según estas suposiciones, excepto por $s_0$, cada variable $s_k$ está en biyección con una función $f_k.$ Por lo tanto, el nodo $0$ representa la entrada $s_0$, mientras que los nodos $1, \ldots, n$ representan las funciones $f_1, \ldots, f_n$ y salidas $s_1, \ldots, s_n.$ Es decir, cada nodo $k$ representa tanto la función $f_k$ y la salida $s_k.$

Las aristas de un DAG representan las dependencias entre los nodos. Los padres de un nodo $k,$ denotados como $\{i_1, \ldots, i_{p_k}\} := \mathcal{P}(k),$ donde $p_k:=|\mathcal{P}(k)|,$ indican las variables $s_{\mathcal{P}(k)} := \{s_{i_1}, \ldots, s_{i_{p_k}}\}$ que la función $f_k$ necesita para calcular su salida $s_k$. En otras palabras, los padres $\{i_1, \ldots, i_{p_k}\}$ indican funciones $f_{i_1}, \ldots, f_{i_{p_k}}$ que son necesarias para computar $f_k.$

Ejecución de un programa

Para ejecutar un programa, nosotros necesitamos asegurar que las funciones intermedias son evaluadas en un orden en el orden correcto. Por lo tanto, nosotros asumimos que los nodos $V=\{0, 1, \ldots, n\}$ están ordenados en un orden topológico, (si este no es el caso, entonces el programa no puede ser ejecutado). Nosotros podemos ejecutar un programa para evaluar la salida $s_k \in [n]$

Obsérvese que podemos ver $f_k$ como una función de una sola entrada de $s_{\mathcal{P}(k)},$ el cual es una $n$-tupla de elementos, o como una función de múltiples entradas $s_{i_1}, \ldots, s_{i_{p_k}}.$ Los dos puntos de vistas son esencialmente equivalentes. El proceso de ejecución de un programa es descrito en el Algoritmo 1.

Tratamiento de múltiples entradas o salidas del programa

Cuando un programa tiene múltiples entradas, los agrupamos siempre en una sola entrada $s_0 \in S_0.$ como $s_0 = (s_{0, 1}, \ldots, s_{0, m_0})$ con $S_0 = S_{0, 1} \times \cdots \times S_{0, m_0},$ ya que las funciones posteriores siempre pueden filtrar los elementos de $s_0$ que necesitan. Del mismo modo, si una función intermedia $f_k$ tiene varias salidas, siempre las agrupamos en una sola salida $s_k \in S_k$ como $s_k = (s_{k, 1}, \ldots, s_{k, m_k})$ con $S_k = S_{k, 1} \times \cdots \times S_{k, m_k},$ ya que las funciones posteriores siempre pueden filtrar los elementos de $s_k$.

Figura 2. Dos posibles representaciones de un programa. Izquierda: La funciones son representadas como nodos y las dependencias como aristas. Derecha: Las funciones son representadas como nodos y las dependencias como un conjunto de nodos disjuntos. En ambos casos, la entrada es representada por un nodo raíz y la salida por un nodo hoja.

Representación alternativa de programas: grafos bipartitos

En nuestro formalismo, dado que una función $f_k$ siempre tiene una única salida $s_k,$ se puede considerar que un nodo $k$ representa tanto la función $f_k$ como la salida $s_k.$ Sin embargo, también es posible considerar dos conjuntos de nodos disjuntos: uno para las funciones y otro para las salidas, es decir, un grafo bipartito. Este formalimso es similar a los grafos factoriales (Frey et al., 1997; Loeliger, 2004) utilizados en la modelización probabilísticas, pero con aristas dirigidas. Una ventaja de este formalismo es que permite que las funciones tengan múltiples salidas. Por simplicidad, nos centraremos en la representación de un solo conjunto de nodos.

Circuitos aritméticos

Los circuitos aritméticos son uno de los ejemplos más sencillos de grafos computacionales, originarios de la teoría de la complejidad computacional. Formalmente, un circuito aritmético sobre un campo $\mathbb{F}$, como por ejemplo los número reales $\mathbb{R}$ o los números complejos $\mathbb{C},$ es un grafo dirigido acíclico (DAG) donde los nodos raíces son elementos del campo $\mathbb{F}$ y las funciones intermedias son operaciones aritmética como la suma o la multiplicación. Estas últimas suelen denominarse compuertas aritméticas. Contrariamente al caso general de grafos computacionales, cada función sea una suma o un producto puede tener múltiples nodos raíces. Los nodos raíces pueden ser variables o constantes, y deben pertenecer al campo $\mathbb{F}.$ Los circuitos aritméticos puede utilizarse para calcular polinomios. Puede existir múltiples circuitos aritméticos para representar un polinomio dado. Para comparar dos circuitos aritméticos que representan el mismo polinomio, una noción intuitiva de la complejidad es el tamaño del circuito, como se define a continuación.

Para más información sobre circuitos aritméticos, se puede consultar el libro de Chen et al. 2011.

Redes de propagación hacia adelante

Una red de propagación hacia adelante (feedforward network) es un tipo de cadena de computación con funciones parametrizadas $f_1, \ldots, f_n$ que se aplican de forma secuencial a una entrada $s_0 \in S_0.$ En este caso, las funciones $f_k$ son usualmente funciones parametrizadas que dependen de un vector de parámetros $w_k \in \mathcal{W}_k,$ donde $\mathcal{W}_k$ es el espacio de parámetros de la función $f_k.$ Por lo tanto,

para una entrada $s_0\in S_0$ y para los parámetros entrenables $w = (w_1, \ldots, w_n) \in \mathcal{W} = \mathcal{W}_1 \times \cdots \times \mathcal{W}_n.$ Cada función $f_k$ es una capa de la red y cada $s_k \in S_k$ es una representación intermedia de la entrada $s_0.$ la dimension de $S_k$ se conoce como la dimensión de la capa (o número de unidades ocultas) de la capa $k.$ Una red de propagación hacia adelante puede ser definida como una función $f:S_0 \times \mathcal{W} \to S_n$ que mapea una entrada $s_0$ y parámetros $w$ a una salida $s_n.$

Dado un programa parametrizado de este tipo, los parametros $w$ los podemos aprender ajustando $w$ de acuerdo a un conjunto de datos de entrenamiento. Por ejemplo, dado un conjunto de datos de pares $(x_i, y_i),$ podemos minimizar la función de pérdida $L(w) = \sum_{i=1}^{m} \ell(f(x_i; w), y_i).$ La minimización de la función de pérdida se puede hacer utilizando un algoritmo de optimización como el descenso de gradiente.

Perceptrones multicapa

Combinación de capas afines y funciones de activación

En la sección anterior, no especificamos cual es la forma de parametrizar las redes de propagación hacia adelante. Una parametrización típica, es el perceptron multicapa (multilayer perceptron o MLP), que utiliza capas totalmente conectadas (también conocidas densas) de la forma

donde $w_k = (W_k, b_k)$ son los parámetros de la capa $k,$ $W_k$ es un matriz de pesos y $b_k$ es un vector de sesgos. Ademas la capa las podemos descomponer en dos funciones. La función $s \mapsto W_k s + b_k$ es una capa afín y la función $s \mapsto a_k(s)$ no lineal sin parámetros, llamada función de activación.

Generalmente, podemos remplazar el producto matrix-vector $W_k s_{k-1}$ por cualquier función lineal de $s_{k-1}.$ Por ejemplo, las capas convolucionales utilizan de convolución de la entrada $s_{k-1}$ con algunos filtros $W_k.$

Relación con los modelos lineales generalizados

Cuando la profundidad de la red es $n=1$ (es decir, una sola capa), la salida un MLP es una función lineal de la entrada $x$ es

Esto es llamado un modelo lineal generalizado (generalized linear model o GLM). En este caso, la función de activación $a_1$ es la función identidad. Los modelos lineales generalizados son un caso especial de los MLPs. Es particular, cuando $a_1$ es la función $\operatorname*{softargmax}$, se tiene un modelo de regresión logística. Por lo general para la profundidad $n>1,$ la salida de un MLP es

Esto puede ser visto como un GLM sobre la representación intermedia $s_{n-1}$ de la entrada $s_0.$ Este es el principal atractivo de los MLPs: la capacidad de aprender representaciones intermedias que son útiles para la tarea de interés. Veremos que los MLPs también pueden utilizarse como subcomponentes en otras arquitecturas.

Funciones de activación

Como se mencionó anteriormente, la redes de propagación hacia adelante utilizan funciones de activación $a_k$ para cada capa. En esta sección, vamos a describir algunas de las funciones de activación más comunes de escalar a escalar o de vector a escalar. También presentaremos algunas funciones de probabilidad que pueden ser utilizadas como funciones de activación.

Funciones de activación de escalares a escalares nolineales

La función ReLU (Rectified Linear Unit) es una función de activación no lineal que se define como la parte no negativa de su argumento. Es decir, la función ReLU es la función identidad en los valores no negativos y cero en los valores negativos:

Es una función lineal por partes e incluye un punto de inflexión en $x=0.$ Una perceptron multicapa con activaciones ReLU se denomina red neuronal rectificadora. Las capas toman las forma

donde la ReLU es aplicada elemento a elemento. La función ReLU puede ser remplazada con una versión suavizada, conocida como softplus:

A diferencia de la ReLU, la softplus es una función suave, diferenciable y estrictamente positiva.

Funciones de activación de vectores a escalares nolineales

A menudo es útil reducir vectores a escalares. Estos valores escalares pueden ser vistos como puntajes o probabilidades, que representan la importancia de un vector de entrada. Una función común para hacer esto es usando el valor máximo, también conocido como max-pooling. Dado un vector $x\in \mathbb{R}^d,$ la función de max-pooling es

Como una aproximación suave de la función de max-pooling, se puede usar la función log-sum-exp, la cual se comporta como una versión suavizada de la función max-pooling:

La función log-sum-exp puede ser vista como una generalización de la función softplus a vectores, en efecto para todo $x \in \mathbb{R}$

Una implementación númericamente estable de la función log-sum-exp es la siguiente:

donde $\mathbf{1}$ es un vector de unos y $c = \max_{j\in [\,d\,]} x_j.$

Mapeos de probabilidad de escalar a escalar

En algunas ocasiones queremos mapear algún número real en un número entre 0 y 1, que puede representar la probabilidad de un evento. Para este propósito se usa con frecuencia las sigmoides. Una sigmoide es una función cuya curva se caracteriza por tener forma de «S». Estas funciones se utilizan para comprimir valores reales en un intervalo. Un ejemplo es la función paso binaria, también conocida como la función de paso de Heaviside,

Es un mapeo de $\mathbb{R}$ a $\{0, 1\}.$ Desafortunadamente, la función de paso binaria es discontinua en $x=0.$ Además, debido a que la función es constante en todos los demás puntos, tiene derivada cero en estos puntos, lo que dificulta su uso como parte de una red neuronal con retropropagación.

Una mejor sigmoide es la función logística, la cual mapea de $\mathbb{R}$ a $(0, 1)$ y es definida como:

Ella mapea $(-\infty, 0)$ a $(0, 0.5)$ y $\lbrack 0, \infty \rparen$ a $\lbrack 0.5, 1\rparen.$ y satisface que $\text{logistic}(0) = 0.5.$ Por lo tanto puede ser vista como una función de probabilidad. La función logística puede ser vista como una versión suavizada de la función de paso $\text{step}(x).$ Además la función logística se puede obtener como la derivada de la función $\text{softplus}(x),$ es decir, para todo $x \in \mathbb{R}$

Dos propiedades importantes de la función logística es que para todo $x \in \mathbb{R}$

y

Mapeos de probabilidad de vectores a vectores

En algunas ocasiones queremos mapear un vector en un vector de probabilidades. Este es una mapeo de $\mathbb{R}^d$ a un simplex de probabilidad, definido por:

Dos ejemplos de funciones de mapeo de probabilidad de vector a vector son la función argmax y la función softargmax. La función $\text{argmax}$ mapea un vector a un vector de probabilidad que es cero en todas las entradas excepto en la entrada con el valor máximo que lo hace uno. En efecto,

donde $\phi(j)$ denota el one-hot encoding de un entero $j\in [\,d\,],$ es decir, $\phi(j)_i = 1$ si $i = j$ y cero en otro caso, esto es

Este mapeo coloca toda la masa de probabilidad en la entrada con el valor máximo, en caso de empate, se selecciona la primera entrada con el valor máximo. Desafortunadamente, la función $\text{argmax}$ no es diferenciable, lo que dificulta su uso en la retropropagación.

Una versión suavizada de la función $\text{argmax}$ es la función $\text{softargmax}$. La función $\text{softargmax}$ está definida como

Este operador es comúnmente conocido en la literatura como la función softmax, pero esta denominación es errónea: este operador realmente define una versión suavizada de la función $\text{argmax}.$ La salida de $\text{softargmax}$ pertenece al interior relativo del simplex de probabilidad $\Delta^{d},$ lo que significa que nunca puede alcanzar los bordes del simplex. Si denotamos $p = \text{softargmax}(x),$ entonces $p_j \in (0, 1),$ es decir $0 < p_j < 1$ para todo $j \in [\,d\,].$ La función $\text{softargmax}$ es el gradiente de la función $\text{log-sum-exp}$, es decir, para todo $x \in \mathbb{R}^d$

La función $\text{softargmax}$ se puede ver como una generalización de la función $\text{logistic}$ a vectores, en efecto

Redes neuronales residuales

Como se mencionó anteriormente, las redes de propagación hacia adelante son un tipo de cadena de computación. En este caso, las funciones intermedias son funciones parametrizadas que se aplican de forma secuencial a una entrada. En efecto, consideremos una red de propagación hacia adelante con $n+1$ capas $f_1, \ldots, f_{n+1}$. Seguramente, siempre que $f_{n+1}$ sea la función identidad, el conjunto de funciones que esta red puede representar es el mismo que el de una red de $n$ capas $f_1, \ldots, f_n.$ Por lo tanto, podemos considerar una red de $n+1$ capas como una red de $n$. En otras palabras, la profundidad, en teoría, no debería perjudicar el poder expresivo de las redes de propagación hacia adelante. Desafortunadamente, la suposición de que cada $f_k$ es una función identidad no es realista. Esto significa que la redes más profundas a veces pueden ser más difíciles de entrenar que las más superficiales, haciendo que la precisión se sature o degrade en función de la profundidad.

La idea clave de las redes neuronales residuales (residual neural networks o ResNets) (He et al., 2016) es introducir bloques residuales entre las capas, de tal forma que la salida de una capa se convierte en la entrada de una capa posterior. Formalmente, un bloque residual es una función de la forma

La función $h_k$ es la función residual, dado que modela la diferencia entre la entrada y la salida, es decir, $h_k(s_{k-1}; w_k) = s_{k} - s_{k-1}.$ La función $h_k$ puede ser vista como una corrección que se suma a la entrada $s_{k-1}$ para obtener la salida $s_k.$ La suma con $s_{k-1}$ se conoce como conexión de salto (skip connection o shortcut). Siempre que sea posible ajustar $w_k$ para que $h_k(s_{k-1}; w_k) = 0,$ entonces la función $f_k$ se convierte en la función identidad. Por ejemplo, si nosotros usamos:

donde $w_k = (W_k, b_k, C_k, d_k)$ son los parámetros de la capa $k,$ entonces basta con ajustar $C_k = 0$ y $d_k = 0$ para que $h_k(s_{k-1}; w_k) = 0.$ Los bloques residuales son conocidos para remediar el problema de gradiente de fuga.

En muchos artículos y paquetes de software se incluye una activación adicional y en su lugar se define el bloque residual como:

donde $a_k$ es usualmente la función ReLU. Si se debe incluir esta activación adicional o no, es esencialmente una decisión de modelado. En la práctica, los bloques residuales también pueden incluir operaciones adicionales como normalización por lotes (batch norm) y capa convolucionales.

Redes neuronales recurrentes

La redes neuronales recurrentes (recurrent neural networks o RNNs) (Rumelhart et al., 1986) son un tipo de red neuronal que operan con secuencias de vectores, ya sea como entrada, salida o ambas. Su parametrización real depende de la configuración, pero la idea central es mantener un vector de estado que se actualiza paso a paso mediante una función recursiva que utiliza parámetros compartidos a través de los pasos. Distinguimos entre las siguientes configuraciones:

1. Vector a secuencia (uno a muchos): $$\begin{equation} f^d:\mathbb{R}^d \times \mathbb{R}^{p} \to \mathbb{R}^{l\times m }. \end{equation}$$
2. Secuencia a vector (muchos a uno): $$\begin{equation} f^e:\mathbb{R}^{l\times d} \times \mathbb{R}^{p} \to \mathbb{R}^{m}. \end{equation}$$
3. Secuencia a secuencia (muchos a muchos, alineados): $$\begin{equation} f^a:\mathbb{R}^{l\times d} \times \mathbb{R}^{p} \to \mathbb{R}^{l\times m}. \end{equation}$$
4. Secuencia a secuencia (muchos a muchos, no alineados): $$\begin{equation} f^u:\mathbb{R}^{l\times d} \times \mathbb{R}^{p} \to \mathbb{R}^{l'\times m}. \end{equation}$$

donde $l$ es la longitud de la secuencia de entrada y $l'$ es la longitud de la secuencia de salida. Observe que se usa el mismo número de parámetros $p$ para cada una de las configuraciones, pero esto por supuesto no es necesario. A lo largo de este post, usaremos la notación $p_{1:l} := (p_1, \ldots, p_l)$ para denotar una secuencia de $l$ vectores.

Vector a secuencia

En esta configuración, una función decodificadora $p_{1:l} = f^d(x; w)$ mapea un vector $x \in \mathbb{R}^d$ y un vector de parámetros $w \in \mathbb{R}^p$ a una secuencia de vectores $p_{1:l} \in \mathbb{R}^{l\times m}.$

Figura 3. Uno a muchos (decodificación). Un vector $x \in \mathbb{R}^d$ es mapeado a una secuencia de vectores $p_{1:l} \in \mathbb{R}^{l\times m}.$

Esto es útil para la generación de subtítulos de imágenes, donde se genera una oración (una secuencia de palabras) a partir de una imagen (un vector de píxeles). Formalmente, podemos definir $p_{1:l} = f^d(x; w)$ a través de la recursión:

donde $w ;= (w_g, w_h, s_0)$ son los parámetros de la red, $s_0$ es el estado inicial. El objetivo de $g$ es actualizar el estado $s_i$ en función de la entrada $x$ y el estado anterior $s_{i-1},$ mientras que el objetivo de $h$ es mapear el estado $s_i$ a un vector $p_i$ dado el estado $s_i.$ Es importante destacar que los parámetros de $g$ y $h$ se cruzan a los largo de los pasos de tiempo. Típicamente, $g$ y $h$ se parametrizan utilizando MLPs de una capa oculta. Nótese que $g$ tiene múltiples entradas.

Secuencia a vector

En esta configuración, se define una función codificadora $p = f^e(x_{1:l}; w)$ que mapea una secuencia de vectores $x_{1:l} \in \mathbb{R}^{l\times d}$ y un vector de parámetros $w \in \mathbb{R}^p$ a un vector $p \in \mathbb{R}^m.$

Figura 4. Muchos a uno (codificación). Una secuencia de vectores $x_{1:l} \in \mathbb{R}^{l\times d}$ es mapeada a un vector $p \in \mathbb{R}^m.$

Esto resulta útil para la clasificación de secuencias, donde se clasifica la secuencia completa en una sola categoría, por ejemplo en el análisis de sentimientos. Formalmente, podemos definir $p = f^e(x_{1:l}; w)$ a través de la recursión:

donde $w := (w_g, s_0)$ son los parámetros de la red, $s_0$ es el estado inicial, y $g$ ahora actualiza los estados del codificador y no toma predicciones anteriores como entrada. La función de agrupamiento ($\text{pooling}$) típicamente no tiene parámetros y se utiliza para reducir la secuencia de estados a un solo vector. Ejemplos comunes de funciones de agrupamiento son la media, la suma y la función de max-pooling.

Secuencia a secuencia (alineada)

En esta configuración, se define una función de alineación $p_{1:l} = f^a(x_{1:l}; w)$ que mapea una secuencia de vectores $x_{1:l} \in \mathbb{R}^{l\times d}$ y un vector de parámetros $w \in \mathbb{R}^p$ a una secuencia de vectores $p_{1:l} \in \mathbb{R}^{l\times m}.$ La longitud de la secuencia de entrada y la secuencia de salida son iguales.

Figura 4. Muchos a muchos (alineados). Una secuencia de vectores $x_{1:l} \in \mathbb{R}^{l\times d}$ es mapeada a una secuencia de vectores $p_{1:l} \in \mathbb{R}^{l\times m}.$

Un ejemplo de aplicación es POS-tagging, donde se asigna una etiqueta a cada palabra en una oración. Formalmente, esto se puede definir como $p_{1:l} = f^a(x_{1:l}; w)$ a través de la recursión:

donde $w := (w_g, w_h, s_0)$ son los parámetros de la red, $s_0$ es el estado inicial y $g$ y $h$ son funciones similares a las definidas en la configuración uno a muchos. La función $g$ actualiza el estado $s_i$ en función de la entrada $x_i$ y el estado anterior $s_{i-1},$ mientras que la función $h$ mapea el estado $s_i$ a un vector $p_i$ dado el estado $s_i.$

Secuencia a secuencia (no alineada)

En esta configuración, se define una función de alineación $p_{1:l'} = f^u(x_{1:l}; w)$ que mapea una secuencia de vectores $x_{1:l} \in \mathbb{R}^{l\times d}$ y un vector de parámetros $w \in \mathbb{R}^p$ a una secuencia de vectores $p_{1:l'} \in \mathbb{R}^{l'\times m}.$

Figura 5. Muchos a muchos (no alineados). Una secuencia de vectores $x_{1:l} \in \mathbb{R}^{l\times d}$ es mapeada a una secuencia de vectores $p_{1:l'} \in \mathbb{R}^{l'\times m}.$

La longitud de la secuencia de entrada y la secuencia de salida no necesariamente son iguales. Un ejemplo de aplicación es la traducción automática, donde una oración en un idioma se traduce a una oración en otro idioma. Formalmente, esto se puede definir como $p_{1:l'} = f^u(x_{1:l}; w)$ a través de la recursión:

donde $w := (w_e, w_d)$ son los parámetros de la red, $f^e$ es una función codificadora que mapea la secuencia de entrada a un vector de contexto $c,$ y $f^d$ es una función decodificadora que mapea el vector de contexto a la secuencia de salida. La función de codificación $f^e$ y la función de decodificación $f^d$ pueden ser implementadas como RNNs. Los pasos en detalle, serían:

Esta arquitectura se denomina acertadamente arquitectura codificador-decodificador (encoder-decoder). Tenga en cuenta que denotamos la longitud de la secuencia objetivo como $l'$ en lugar de $l$ para evitar confusiones. Sin embargo, en la práctica, la longitud puede depender de la entrada y a menudo no se conoce de antemano. Para abordar este problema, el vocabulario (de tamaño $d$ en nuestra notación) se aumenta típicamente con un token de «final de secuencia» (EOS, por sus siglas en inglés), para que, en el momento de la inferencia, sepamos cuándo dajar de generar la secuencia de salida. Una desventaja de esta arquitectura, es que toda la información sobre la secuencia de entrada esta contenida en el vector de contexto $c,$ que por lo tanto puede convertirse en un cuello de botella.

Conclusiones

Las redes neuronales, concebidas como programas parametrizados, proporcionan un marco poderoso y flexible para abordar una amplia gama de problemas en aprendizaje automático y procesamiento de datos. A lo largo de este artículo, hemos explorado diversas arquitecturas y configuraciones, desde redes de propagación hacia adelante hasta redes neuronales recurrentes y redes residuales. La representación de estas arquitecturas como grafos dirigidos acíclicos (DAGs) no solo facilita su análisis y optimización, sino que también permite la aplicación eficiente de técnicas como la diferenciación automática. Las diferentes configuraciones discutidas demuestran la versatilidad de estos modelos para tareas que van desde la generación de subtítulos de imágenes hasta la traducción automática.

Este enfoque de ver las redes neuronales como programas parametrizados no solo permite diseñar modelos más eficientes y efectivos, sino que también abre caminos para mejorar la interpretabilidad y explicabilidad de estos modelos, un área de creciente importancia en la inteligencia artificial. Aunque hemos cubierto varios tipos de redes neuronales, es importante destacar que el campo está en constante evolución, con nuevas arquitecturas y técnicas desarrollándose continuamente. En resumen, esta perspectiva proporciona una base sólida para el desarrollo futuro de modelos de aprendizaje automático más avanzados, interpretables y adaptables a una amplia gama de aplicaciones en el mundo real.

Finalmente,si hay errores, omisiones o inexactitudes en este artículo, por favor no dude en contactarnos a través de siguiente canal de Discord: Math & Code.

Referencias