Desde convolución unidimensional, convolución causal (Causal CNN), convolución expandida (Dilation CNN) hasta red convolucional temporal (TCN)

Fuente: cuenta pública de AINLPer WeChat (¡compartir productos secos todos los días!)
Editor: ShuYini
Revisión: ShuYini
Hora: 2022-09-30

introducción

Las redes neuronales convolucionales (CNN), aunque a menudo se asocian con tareas de clasificación de imágenes, también se pueden adaptar para predicciones de modelado de secuencias. En este artículo, exploraremos en detalle los componentes básicos en los que consisten las redes convolucionales temporales (TCN) y cómo encajan para convertirse en poderosos modelos predictivos . La descripción de este documento de Redes convolucionales temporales (TCN) se basa en el siguiente documento: https://arxiv.org/pdf/1803.01271.pdf

Siga la cuenta pública de AINLPer , los últimos productos secos se entregarán lo antes posible

introducción de fondo

Hasta hace poco, el tema del modelado de secuencias en el contexto del aprendizaje profundo estaba relacionado en gran medida con las arquitecturas de redes neuronales recurrentes, como LSTM y GRU. S. Bai y otros muestran que esta forma de pensar está desactualizada y que las redes convolucionales deberían ser uno de los principales candidatos al modelar datos de secuencia. Demuestran que las redes convolucionales pueden lograr un mejor rendimiento que las RNN en muchas tareas, al tiempo que evitan las deficiencias comunes de los modelos recurrentes, como el problema de explosión/desaparición del gradiente o la falta de retención de memoria. Además, el uso de una red convolucional puede mejorar el rendimiento, ya que permite que la salida se calcule en paralelo . Su arquitectura propuesta se llama Red Convolucional Temporal (TCN) y se explicará en las siguientes secciones.

modelo de convolución

TCN es un acrónimo de Time Domain Convolutional Network, que consta de capas convolucionales 1D dilatadas/causales con las mismas longitudes de entrada y salida. Lo que estos términos realmente significan se detalla a continuación.

Red convolucional 1D

Una red convolucional 1D toma un tensor 3D como entrada y genera un tensor 3D. Nuestra implementación de TCN toma tensores de forma de entrada (tamaño_de_lote, longitud_de_entrada, tamaño_de_entrada) y tensores de forma de salida (tamaño_de_lote, longitud_de_entrada, tamaño_de_salida). Dado que cada capa en un TCN tiene las mismas longitudes de entrada y salida, solo difiere la tercera dimensión de los tensores de entrada y salida. En el caso univariado, tanto input_size como output_size serán iguales a 1. En el caso multivariante más general, input_size y output_size pueden diferir, ya que es posible que no queramos predecir cada componente de la secuencia de entrada.

Una sola capa convolucional 1D toma un tensor de forma de entrada (batch_size, input_length, nr_input_channels) y genera un tensor de forma (batch_size, input_length, nr_output_channels). Para comprender cómo una sola capa transforma su entrada en su salida, observemos un elemento del lote (el mismo proceso ocurre para cada elemento del lote). Comencemos con el caso más simple, donde tanto nr_input_channels como nr_output_channels son iguales a 1. En este caso estamos viendo tensores de entrada y salida 1D. La siguiente figura muestra cómo se calcula un elemento del tensor de salida.

Puede ver que para calcular un elemento de la salida, observamos una secuencia de elementos consecutivos de longitud kernel_size en la entrada. En el ejemplo anterior, elegimos un kernel_size de 3. Para obtener la salida, hacemos un producto punto de una subsecuencia de la entrada con un vector kernel de la misma longitud para los pesos aprendidos. Para obtener el siguiente elemento de la salida, se aplica el mismo procedimiento, pero una ventana del tamaño kernel_size de la secuencia de entrada se desplaza un elemento a la derecha (la zancada siempre se establece en 1 para este modelo de predicción). Tenga en cuenta aquí que se utilizará el mismo conjunto de pesos de kernel para calcular cada salida de una capa convolucional. La siguiente figura muestra dos elementos de salida consecutivos y sus respectivas subsecuencias de entrada.

Para facilitar la visualización, ya no se muestra el producto escalar con los vectores kernel, sino que se realiza para cada elemento de salida con el mismo peso kernel.

Para garantizar que la secuencia de salida tenga la misma longitud que la secuencia de entrada, se aplica un relleno con ceros. Esto significa agregar una entrada adicional de valor cero al principio o al final del tensor de entrada para garantizar que la salida tenga la longitud deseada. Cómo hacer esto se explicará más adelante.

Ahora veamos el caso en el que tenemos varios canales de entrada, es decir, nr_input_channels es mayor que 1. En este caso, el proceso anterior se repite para cada canal de entrada, pero cada vez con un kernel diferente. Esto generará vectores de salida intermedios nr_input_channels y algunos pesos de kernel de kernel_size * nr_input_channels. Luego, todos los vectores de salida intermedios se suman para obtener el vector de salida final. En cierto sentido, esto es equivalente a una convolución bidimensional con un tensor de entrada de (input_size, nr_input_channels) y un kernel de (kernel_size, nr_input_channels), como se muestra en la siguiente figura. Todavía es 1D porque la ventana solo se mueve a lo largo de un solo eje, pero tenemos una convolución 2D en cada paso porque estamos usando una matriz de kernel 2D.

Para este ejemplo, elegimos nr_input_channels igual a 2. En lugar de deslizarnos sobre una secuencia de entrada 1D, ahora tenemos nr_input_channels deslizándose a lo largo de nr_input_channels amplia longitud de serie input_length por kernel_size kernel matrix.

Si tanto nr_input_channels como nr_output_channels son mayores que 1, simplemente repita el proceso anterior para cada canal de salida con una matriz de kernel diferente. Luego, los vectores de salida se apilan para formar un tensor de forma de salida (input_length, nr_output_channels). En este caso, el número de pesos de kernel es igual a kernel_size nr_input_channels nr_output_channels.

Las dos variables nr_input_channels y nr_output_channels dependen de la posición de la capa en la red. nr_input_channels = input_size de la primera capa, nr_output_channels = output_size de la última capa. Todas las demás capas utilizarán el número de canales intermedios dado por num_filters.

convolución causal

Para una capa convolucional causal, para ${0, ..., input\_length — 1\}$ Para cada i entrada p u t _ l e n g th —1 }, el i-ésimo elemento de la secuencia de salida puede depender solo de elementos de la $secuencia$ $de$ $entrada$ $con$ $índices$ ${$ $0$ $,$ $\dots$ $,$ $i$ $}$ $.$ En otras palabras, un elemento en la secuencia de salida solo puede depender del elemento anterior en la secuencia de entrada. Como se mencionó anteriormente, para garantizar que el tensor de salida tenga la misma longitud que el tensor de entrada, debemos aplicar relleno cero. Si solo aplicamos cero relleno en el lado izquierdo del tensor de entrada, entonces se asegurará la convolución causal. Para entender esto, considere el elemento de salida más a la derecha. Dado que no hay relleno en el lado derecho de la secuencia de entrada, se basa en que el último elemento sea el último elemento de la entrada. Ahora considere el penúltimo elemento de salida de la secuencia de salida. Su ventana del kernel se desplaza a la izquierda en uno en comparación con el último elemento de salida, lo que significa que su dependencia más a la derecha en la secuencia de entrada es el penúltimo elemento de la secuencia de entrada. Por inducción, para cada elemento de la secuencia de salida, su última dependencia en la secuencia de entrada tiene el mismo índice que él mismo. La siguiente figura muestra un ejemplo con una input_length de 4 y un kernel_size de 3.

Podemos ver que con el relleno de cero a la izquierda de 2 entradas podemos lograr la misma longitud de salida respetando las reglas de causalidad. De hecho, en ausencia de inflación, el número de entradas de relleno cero requeridas para mantener la longitud de entrada siempre es igual a kernel_size – 1.

Convolución de dilatación

Una propiedad deseable de un modelo predictivo es que el valor de una entrada particular en la salida depende de todas las entradas anteriores en la entrada, es decir, todas las entradas con un índice menor o igual que él. Esto se logra cuando el campo de recepción (es decir, el conjunto original de entradas de entrada que afectan a una entrada en particular para la salida) tiene el tamaño input_length. También lo llamamos "Informe de historial completo". Como vimos anteriormente, una capa convolucional tradicional hace que las entradas en la salida dependan de las entradas kernel_size de la entrada cuyo índice es menor o igual que él mismo. Por ejemplo, si kernel_size es 3, el quinto elemento de la salida dependerá de los elementos 3, 4 y 5 de la entrada. Este rango se expande cuando colocamos varias capas juntas. En la imagen a continuación, podemos ver que al apilar dos capas con kernel_size 3, obtenemos un campo receptivo de tamaño 5 .

Más generalmente, una red convolucional 1D con n capas y kernel_sizek tiene un área receptiva de tamaño r. $r = 1 + norte * (k - 1)$
Para saber cuántas capas se necesitan para una cobertura completa, podemos establecer el tamaño del campo receptivo en input_length l y calcular el número de capas n (si no es un valor entero, debemos redondear): n = [ ( l - 1 ) / ( k - 1 $norte = [(yo - 1) / (k - 1)]$
Esto significa que, dado un kernel_size fijo, la cantidad de capas requeridas para una cobertura completa es lineal en la longitud del tensor de entrada, lo que conduce a redes que se vuelven muy profundas y muy rápidas, lo que da como resultado modelos con muchos parámetros. Toma más tiempo para entrenar. Además, a medida que aumenta el número de capas del modelo, es fácil que aparezca el problema de la desaparición del gradiente. Una forma de aumentar el tamaño de la región receptiva manteniendo el número de capas relativamente pequeño es introducir dilatación en la red convolucional.

La dilatación en el contexto de una capa convolucional se refiere a la distancia entre los elementos de la secuencia de entrada que se utilizan para calcular una entrada de la secuencia de salida. Por lo tanto, una capa convolucional tradicional puede verse como una capa 1 dilatada, ya que los elementos de entrada de 1 valor de salida son adyacentes. La siguiente figura muestra un ejemplo de una capa dilatada en 2 con una input_length de 4 y un kernel_size de 3.

En comparación con el caso de 1 dilatación, las áreas receptivas de esta capa se distribuyen en una longitud de 5 en lugar de 3. De manera más general, la distribución del campo receptivo de una capa dilatada en d con un tamaño de núcleo k es $1 + d * (k - 1)$ sobre la longitud. Si d es fijo, esto todavía requiere un número lineal en la longitud del tensor de entrada para lograr una cobertura de campo receptiva completa.

Este problema se puede resolver aumentando exponencialmente el valor de d a medida que avanzamos en la capa. Para hacer esto, elegimos un entero b constante de dilation_base que nos permitirá calcular la dilatación d de una capa en particular como una función del número de capas i debajo de ella, como d = bid=b^ $d = b^{yo}$ _ La siguiente figura muestra una red con input_length 10, kernel_size 3 y dilation_base 2, que produce 3 capas convolucionales dilatadas para una cobertura completa.

Aquí, solo mostramos el efecto de la entrada en el último valor de salida. Del mismo modo, solo se muestran las entradas rellenadas con ceros requeridas para el último valor de salida. Obviamente, el último valor de salida depende de toda la cobertura de entrada. De hecho, dados los hiperparámetros, se pueden usar longitudes de entrada de hasta 15 mientras se mantiene una cobertura de campo receptiva completa. En general, cada capa adicional aumenta el ancho del campo receptivo actual en $d * (k - 1)$ donde d se calcula como $d=b^i$ , donde i representa el número de capas debajo de la nueva capa. Por lo tanto, el ancho de la región receptiva w de un TCN con expansión exponencial de base b, tamaño de kernel k y número de capas n se puede calcular mediante: w = $w=1+\sum_{i=0}^{n-1}(k-1)\cdot b^{i}=1+(k -1 )\cdot\frac{b^{n}-1}{b-1}$ Sin embargo, dependiendo de los valores de b y k, puede haber "agujeros" en este campo receptivo. Considere la siguiente red con una base de dilatación de 3 y un tamaño de kernel de 2:

el dominio de la región receptiva cubre un rango que es mayor que el tamaño de entrada (es decir, 15). Sin embargo, el cerebro tiene agujeros en su campo receptivo, es decir, hay entradas en la secuencia de entrada de las que no depende el valor de salida (mostrado en rojo arriba). Para arreglar el 'agujero' necesitamos aumentar el tamaño del núcleo a 3, o reducir la base de inflación a 2 . En general, para una región receptiva sin poros, el tamaño k del núcleo debe ser al menos tan grande como la base expandida b.

Teniendo en cuenta estas observaciones, es posible calcular cuántas capas necesita nuestra red para cubrir el historial completo. Suponiendo que el tamaño del núcleo es k, la base de expansión es b, donde k≥b, y la longitud de entrada es l, se debe cumplir la siguiente desigualdad para una cobertura histórica completa: 1 + ( k − 1 ) ⋅ bn $-1)\cdot\frac{b^{n}-1}{b-1}\geqslant l$ Podemos resolver para n y obtener el número mínimo de capas requeridas como: $n=\left [ \log_ { b}(\frac{(l-1)\cdot (b-1)}{(k-1)}+1) \right ]$ Podemos ver que el número de capas ahora es logarítmico en la longitud de entrada en lugar de lineal. Esta es una mejora significativa que se puede lograr sin sacrificar la cobertura del campo receptivo.

Lo único que debe especificarse ahora es la cantidad de entradas de relleno cero requeridas para cada capa. Dada una base de dilatación b, un tamaño de kernel k y el número de capas i por debajo de la capa actual, el número p de entradas de relleno cero requeridas para la capa actual se calcula como: p = bi ⋅ ( k − 1 ) p $b^i\cdot (k-1)$

Modelo TCN básico

Dado input_length, kernel_size, dilatation_base y la cantidad mínima de capas requeridas para una cobertura completa del historial, una red TCN básica se ve así:

Pronóstico

Hasta ahora, solo hemos discutido "secuencia de entrada" y "secuencia de salida", pero no la relación entre ellos. En el pronóstico contextual, deseamos predecir la próxima entrada de una serie de tiempo en el futuro. Para entrenar nuestra red TCN para hacer predicciones, el conjunto de entrenamiento constará de (secuencia de entrada, secuencia objetivo): pares de subsecuencias de igual tamaño de la serie de tiempo dada. Las secuencias de destino serán secuencias desplazadas hacia adelante por pasos de longitud de salida en relación con sus respectivas secuencias de entrada. Esto significa que una secuencia objetivo de longitud longitud_entrada contiene el último elemento (longitud_entrada - longitud_salida) de su respectiva secuencia de entrada como primer elemento, y el elemento longitud_salida después de la última entrada de la secuencia de entrada como último elemento. En las predicciones de contexto, esto significa que el rango máximo de predicción que se puede predecir con este modelo es igual a output_length. Usando métodos de ventana deslizante, se pueden crear muchos pares superpuestos de series de entrada y objetivo a partir de una serie de tiempo.

Actualización del modelo TCN

S. Bai propuso algunas adiciones (es decir, conexiones residuales, regularización y funciones de activación) a la arquitectura básica de TCN para mejorar su rendimiento. La siguiente descripción de las redes convolucionales temporales se basa en el siguiente artículo: https://arxiv.org/pdf/1803.01271.pdf

bloque residual

La mayor modificación realizada al modelo TCN básico presentado anteriormente es cambiar el bloque de construcción básico del modelo de una capa convolucional causal 1D simple a un bloque residual de 2 capas con el mismo factor de dilatación y conexión residual.

Consideremos una capa del modelo base con un factor de dilatación d de 2 y un tamaño de kernel k de 3 y veamos cómo esto se traduce en el bloque residual del modelo mejorado. Primero la siguiente figura:

Luego se convierte en la siguiente figura:

la salida de las dos capas convolucionales se agregará a la entrada del bloque residual para producir la entrada del siguiente bloque. Para todos los bloques internos de la red, es decir, todos excepto el primero y el último, los anchos de los canales de entrada y salida son los mismos, es decir, num_filters. Dado que la primera capa convolucional del primer bloque residual y la segunda capa convolucional del último bloque residual pueden tener diferentes anchos de canal de entrada y salida, puede ser necesario ajustar el ancho del tensor residual, lo cual se hace usando convolución 1×1 .

Este cambio afecta el cálculo del número mínimo de capas necesarias para una cobertura completa. Ahora tenemos que considerar cuántos bloques residuales se necesitan para lograr una cobertura completa del campo receptivo. Agregar un bloque residual a un TCN aumenta el ancho del campo receptivo dos veces más que agregar una capa causal base, ya que incluye 2 de esas capas. Por lo tanto, el tamaño total de la región receptiva r de un TCN con una base expandida b, el tamaño del núcleo k para k ≥ b y el número de bloques residuales n se pueden calcular como: r = 1 + ∑ i = 1 n $r=1+\sum_{i=1}^{n-1}2\cdot(k- 1)\cdot b^ {i}=1+2\cdot(k-1)\cdot\frac{b^{n}-1}{b-1}$ Esto da como resultado que el número mínimo de bloques residuales n para la cobertura completa del historial de input_length sea: $\left [ \log_{b}(\frac{(l-1)\cdot (b-1)}{(k-1)\cdot2}+1) \right ]$

Activación, Normalización, Regularización

Para hacer que TCN sea algo más que un modelo de regresión lineal demasiado complejo, es necesario agregar funciones de activación encima de las capas convolucionales para introducir no linealidades. Las activaciones de ReLU se agregan al bloque residual después de las dos capas convolucionales.
Para normalizar la entrada a la capa oculta (que contrarresta problemas como la explosión de gradientes), se aplica normalización de peso a cada capa convolucional.
Para evitar el sobreajuste, la regularización se introduce mediante abandono después de cada capa convolucional de cada bloque residual. La siguiente figura muestra el bloque residual final.

El asterisco en la segunda unidad ReLU en el diagrama anterior indica que existe en todas las capas excepto en la última, ya que queremos que la salida final también pueda tomar valores negativos (esto es diferente de la arquitectura descrita en el documento ).

modelo definitivo

La siguiente figura muestra nuestro modelo TCN final, donde l es igual a input_length, k es igual a kernel_size, b es igual a dilation_base, k ≥ b y tiene el número mínimo de bloques residuales con cobertura de historial completo n, donde n se puede calcular de acuerdo con los parámetros anteriores.

Lectura recomendada

[1] Un artículo para comprender la regresión lineal [más detallado] (incluido el código fuente)
[2] Un artículo para comprender la regresión logística [más detallado] (incluido el código fuente)
[3] Un artículo para comprender la EMNLP International Top Conference && descarga de Documentos de EMNLP a lo largo de los años && incluido EMNLP2022
[4] [Descarga de documentos de NeurIPS a lo largo de los años] Este artículo lo llevará a comprender la Conferencia Internacional de NeurIPS (incluido NeurIPS2022)