machine-learning - medium - pooling convolutional neural network




Compreensão intuitiva das convoluções 1D, 2D e 3D em redes neurais convolucionais (2)

  1. CNN 1D, 2D ou 3D refere-se à direção da convolução, em vez da dimensão da entrada ou do filtro.

  2. Para entrada de 1 canal, CNN2D é igual a CNN1D é comprimento do kernel = comprimento da entrada. (1 direção conv)

Alguém pode explicar claramente a diferença entre as convoluções 1D, 2D e 3D na CNN (Deep Learning) com exemplos?


Eu quero explicar com imagem de C3D .

Em poucas palavras, a direção convolucional e o formato da saída são importantes!

↑↑↑↑↑ 1D Convolutions - Basic ↑↑↑↑↑

  • apenas 1 direção (eixo do tempo) para calcular conv
  • entrada = [W], filtro = [k], saída = [W]
  • ex) entrada = [1,1,1,1,1], filtro = [0,25,0,5,0,25], saída = [1,1,1,1,1]
  • forma de saída é matriz 1D
  • exemplo) suavização de gráficos

Código tf.nn.conv1d Exemplo de brinquedo

import tensorflow as tf
import numpy as np

sess = tf.Session()

ones_1d = np.ones(5)
weight_1d = np.ones(3)
strides_1d = 1

in_1d = tf.constant(ones_1d, dtype=tf.float32)
filter_1d = tf.constant(weight_1d, dtype=tf.float32)

in_width = int(in_1d.shape[0])
filter_width = int(filter_1d.shape[0])

input_1d   = tf.reshape(in_1d, [1, in_width, 1])
kernel_1d = tf.reshape(filter_1d, [filter_width, 1, 1])
output_1d = tf.squeeze(tf.nn.conv1d(input_1d, kernel_1d, strides_1d, padding='SAME'))
print sess.run(output_1d)

↑↑↑↑↑ Convoluções 2D - Básica ↑↑↑↑↑

  • Direção 2 (x, y) para calcular conv
  • formato de saída é matriz 2D
  • entrada = [W, H], filtro = [k, k] saída = [W, H]
  • exemplo) Sobel Egde Fllter

tf.nn.conv2d - Exemplo de brinquedo

ones_2d = np.ones((5,5))
weight_2d = np.ones((3,3))
strides_2d = [1, 1, 1, 1]

in_2d = tf.constant(ones_2d, dtype=tf.float32)
filter_2d = tf.constant(weight_2d, dtype=tf.float32)

in_width = int(in_2d.shape[0])
in_height = int(in_2d.shape[1])

filter_width = int(filter_2d.shape[0])
filter_height = int(filter_2d.shape[1])

input_2d   = tf.reshape(in_2d, [1, in_height, in_width, 1])
kernel_2d = tf.reshape(filter_2d, [filter_height, filter_width, 1, 1])

output_2d = tf.squeeze(tf.nn.conv2d(input_2d, kernel_2d, strides=strides_2d, padding='SAME'))
print sess.run(output_2d)

↑↑↑↑↑ Convoluções 3D - Básicas ↑↑↑↑↑

  • Direção 3 (x, y, z) para calcular a conv
  • a forma de saída é o volume 3D
  • entrada = [W, H, L ], filtro = [k, k, d ] saída = [W, H, M]
  • d <L é importante! para fazer volume de saída
  • exemplo) C3D

tf.nn.conv3d - Exemplo de brinquedo

ones_3d = np.ones((5,5,5))
weight_3d = np.ones((3,3,3))
strides_3d = [1, 1, 1, 1, 1]

in_3d = tf.constant(ones_3d, dtype=tf.float32)
filter_3d = tf.constant(weight_3d, dtype=tf.float32)

in_width = int(in_3d.shape[0])
in_height = int(in_3d.shape[1])
in_depth = int(in_3d.shape[2])

filter_width = int(filter_3d.shape[0])
filter_height = int(filter_3d.shape[1])
filter_depth = int(filter_3d.shape[2])

input_3d   = tf.reshape(in_3d, [1, in_depth, in_height, in_depth, 1])
kernel_3d = tf.reshape(filter_3d, [filter_depth, filter_height, filter_width, 1, 1])

output_3d = tf.squeeze(tf.nn.conv3d(input_3d, kernel_3d, strides=strides_3d, padding='SAME'))
print sess.run(output_3d)

↑↑↑↑↑ Convoluções 2D com entrada 3D - LeNet, VGG, ..., ↑↑↑↑↑

  • Eventhough entrada é 3D ex) 224x224x3, 112x112x32
  • a forma da saída não é o volume 3D , mas a matriz 2D
  • porque a profundidade do filtro = L deve corresponder aos canais de entrada = L
  • Direção 2 (x, y) para calcular conv! não 3D
  • entrada = [W, H, L ], filtro = [k, k, L ] saída = [W, H]
  • formato de saída é matriz 2D
  • e se quisermos treinar N filtros (N é o número de filtros)
  • então a forma de saída é (2D empilhado) 3D = 2D x N matriz.

conv2d - LeNet, VGG, ... para 1 filtro

in_channels = 32 # 3 for RGB, 32, 64, 128, ... 
ones_3d = np.ones((5,5,in_channels)) # input is 3d, in_channels = 32
# filter must have 3d-shpae with in_channels
weight_3d = np.ones((3,3,in_channels)) 
strides_2d = [1, 1, 1, 1]

in_3d = tf.constant(ones_3d, dtype=tf.float32)
filter_3d = tf.constant(weight_3d, dtype=tf.float32)

in_width = int(in_3d.shape[0])
in_height = int(in_3d.shape[1])

filter_width = int(filter_3d.shape[0])
filter_height = int(filter_3d.shape[1])

input_3d   = tf.reshape(in_3d, [1, in_height, in_width, in_channels])
kernel_3d = tf.reshape(filter_3d, [filter_height, filter_width, in_channels, 1])

output_2d = tf.squeeze(tf.nn.conv2d(input_3d, kernel_3d, strides=strides_2d, padding='SAME'))
print sess.run(output_2d)

conv2d - LeNet, VGG, ... para filtros N

in_channels = 32 # 3 for RGB, 32, 64, 128, ... 
out_channels = 64 # 128, 256, ...
ones_3d = np.ones((5,5,in_channels)) # input is 3d, in_channels = 32
# filter must have 3d-shpae x number of filters = 4D
weight_4d = np.ones((3,3,in_channels, out_channels))
strides_2d = [1, 1, 1, 1]

in_3d = tf.constant(ones_3d, dtype=tf.float32)
filter_4d = tf.constant(weight_4d, dtype=tf.float32)

in_width = int(in_3d.shape[0])
in_height = int(in_3d.shape[1])

filter_width = int(filter_4d.shape[0])
filter_height = int(filter_4d.shape[1])

input_3d   = tf.reshape(in_3d, [1, in_height, in_width, in_channels])
kernel_4d = tf.reshape(filter_4d, [filter_height, filter_width, in_channels, out_channels])

#output stacked shape is 3D = 2D x N matrix
output_3d = tf.nn.conv2d(input_3d, kernel_4d, strides=strides_2d, padding='SAME')
print sess.run(output_3d)

↑↑↑↑↑ Bônus 1x1 conv na CNN - GoogLeNet, ..., ↑↑↑↑↑

  • 1x1 conv é confuso quando você pensa isso como filtro de imagem 2D como sobel
  • para 1x1 conv na CNN, a entrada é 3D, como na figura acima.
  • calcula a filtragem profunda
  • entrada = [W, H, L], filtro = [1,1, L] saída = [W, H]
  • A forma empilhada de saída é 3D = matriz 2D x N.

tf.nn.conv2d - caso especial 1x1 conv

in_channels = 32 # 3 for RGB, 32, 64, 128, ... 
out_channels = 64 # 128, 256, ...
ones_3d = np.ones((1,1,in_channels)) # input is 3d, in_channels = 32
# filter must have 3d-shpae x number of filters = 4D
weight_4d = np.ones((3,3,in_channels, out_channels))
strides_2d = [1, 1, 1, 1]

in_3d = tf.constant(ones_3d, dtype=tf.float32)
filter_4d = tf.constant(weight_4d, dtype=tf.float32)

in_width = int(in_3d.shape[0])
in_height = int(in_3d.shape[1])

filter_width = int(filter_4d.shape[0])
filter_height = int(filter_4d.shape[1])

input_3d   = tf.reshape(in_3d, [1, in_height, in_width, in_channels])
kernel_4d = tf.reshape(filter_4d, [filter_height, filter_width, in_channels, out_channels])

#output stacked shape is 3D = 2D x N matrix
output_3d = tf.nn.conv2d(input_3d, kernel_4d, strides=strides_2d, padding='SAME')
print sess.run(output_3d)

Animação (2D Conv com entradas 3D)

- Link original: LINK
- O autor: Martin Görner
- Twitter: @martin_gorner
- Google +: plus.google.com/+MartinGorne

Convoluções 1D bônus com entrada 2D

↑↑↑↑↑ Convoluções 1D com entrada 1D ↑↑↑↑↑

↑↑↑↑↑ Convoluções 1D com entrada 2D ↑↑↑↑↑

  • A entrada de Eventhough é 2D ex) 20x14
  • formato de saída não é 2D , mas matriz 1D
  • porque a altura do filtro = L deve corresponder à altura da entrada = L
  • 1- direção (x) para calcular a conv! não 2D
  • entrada = [W, L ], filtro = [k, L ] saída = [W]
  • forma de saída é 1D Matrix
  • e se quisermos treinar N filtros (N é o número de filtros)
  • então a forma de saída é (empilhada 1D) 2D = 1D x N matriz.

Bônus C3D

in_channels = 32 # 3, 32, 64, 128, ... 
out_channels = 64 # 3, 32, 64, 128, ... 
ones_4d = np.ones((5,5,5,in_channels))
weight_5d = np.ones((3,3,3,in_channels,out_channels))
strides_3d = [1, 1, 1, 1, 1]

in_4d = tf.constant(ones_4d, dtype=tf.float32)
filter_5d = tf.constant(weight_5d, dtype=tf.float32)

in_width = int(in_4d.shape[0])
in_height = int(in_4d.shape[1])
in_depth = int(in_4d.shape[2])
filter_width = int(filter_5d.shape[0])
filter_height = int(filter_5d.shape[1])
filter_depth = int(filter_5d.shape[2])

input_4d   = tf.reshape(in_4d, [1, in_depth, in_height, in_depth, in_channels])
kernel_5d = tf.reshape(filter_5d, [filter_depth, filter_height, filter_width, in_channels, out_channels])

output_4d = tf.nn.conv3d(input_4d, kernel_5d, strides=strides_3d, padding='SAME')
print sess.run(output_4d)

sess.close()

Entrada e Saída em Tensorflow

Sumário







convolution