web-dev-qa-db-fra.com

Convolution2D + LSTM contre ConvLSTM2D

Sont 1 et 2 le même?

  1. Utilisation Convolution2D couches et LSTM couches
  2. Utilisation ConvLSTM2D

S'il y a une différence, pourriez-vous l'expliquer pour moi?

pythontensorflowkeras
16
hiker

Ce ne sont pas exactement les mêmes, voici pourquoi:

1. Utilisez les calques Convolution2D Et LSTM

Comme on le sait, Convolution2D Sert bien à capturer des images ou des caractéristiques spatiales, tandis que LSTM est utilisé pour détecter des corrélations dans le temps. Cependant, en empilant ce type de couches, la corrélation entre les caractéristiques spatiales et temporelles peut ne pas être capturée correctement.

2. Utilisez ConvLSTM2D

Pour résoudre ce problème, Xingjian Shi et al. a proposé une structure de réseau capable de capturer des corrélations spatio-temporelles, à savoir ConvLSTM. Dans Keras, cela se reflète dans la classe ConvLSTM2D , qui calcule les opérations convolutives dans les transformations d'entrée et récurrentes.

Code Keras

Pour illustrer cela, vous pouvez voir ici le code LSTM, si vous allez dans la méthode call de LSTMCell, vous ne verrez que:

    x_i = K.dot(inputs_i, self.kernel_i)
    x_f = K.dot(inputs_f, self.kernel_f)
    x_c = K.dot(inputs_c, self.kernel_c)
    x_o = K.dot(inputs_o, self.kernel_o)

Au lieu de cela, la classe ConvLSTM2DCell appelle:

    x_i = self.input_conv(inputs_i, self.kernel_i, self.bias_i, padding=self.padding)
    x_f = self.input_conv(inputs_f, self.kernel_f, self.bias_f, padding=self.padding)
    x_c = self.input_conv(inputs_c, self.kernel_c, self.bias_c, padding=self.padding)
    x_o = self.input_conv(inputs_o, self.kernel_o, self.bias_o, padding=self.padding)
    h_i = self.recurrent_conv(h_tm1_i, self.recurrent_kernel_i)
    h_f = self.recurrent_conv(h_tm1_f, self.recurrent_kernel_f)
    h_c = self.recurrent_conv(h_tm1_c, self.recurrent_kernel_c)
    h_o = self.recurrent_conv(h_tm1_o, self.recurrent_kernel_o)

Où:

def input_conv(self, x, w, b=None, padding='valid'):
    conv_out = K.conv2d(x, w, strides=self.strides,
                        padding=padding,
                        data_format=self.data_format,
                        dilation_rate=self.dilation_rate)
    if b is not None:
        conv_out = K.bias_add(conv_out, b,
                              data_format=self.data_format)
    return conv_out

def recurrent_conv(self, x, w):
    conv_out = K.conv2d(x, w, strides=(1, 1),
                        padding='same',
                        data_format=self.data_format)
    return conv_out

Dans LSTM, l'équivalent de h_x (Transformations récurrentes) serait:

K.dot(h_tm1_x, self.recurrent_kernel_x)

Au lieu de ConvLSTM2D:

self.recurrent_conv(h_tm1_x, self.recurrent_kernel_x)

Ce type de transformations n'a pas pu être calculé avec des couches empilées Conv2D Et LSTM.

12
ebeneditos
  1. Utiliser les couches Convolution2D et la couche LSTM

Dans cette technique, vous empilez des couches de convolution et LSTM. Les couches convolutives vous aident à apprendre les caractéristiques spatiales et le LSTM vous aide à apprendre la corrélation dans le temps.

2.Utilisez ConvLSTM2D

ConvLSTM est un LSTM dans lequel les portes (entrée à état et transitions d'état à état) sont des opérations de convolution.
Document de recherche - Réseau LSTM convolutionnel: une approche d'apprentissage automatique pour la prévision immédiate des précipitations

Plus d'informations sur ConvLSTM dans cette SO

5
user239457