Intuitives Verständnis von 1D-, 2D- und 3D-Faltungen in Faltungs-Neuronalen Netzen

Kann jemand bitte den Unterschied zwischen 1D-, 2D- und 3D-Faltungen in Faltungs-Neuronalen Netzen (beim tiefen Lernen) anhand von Beispielen klar erklären?

Ich möchte mit Bild von C3D erklären .

Kurz gesagt, Faltungsrichtung und Ausgabeform sind wichtig!

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

• nur 1- Richtung (Zeitachse) zur Berechnung der Konv
• Eingabe = [W], Filter = [k], Ausgabe = [W]
• ex) Eingabe = [1,1,1,1,1], Filter = [0,25,0,5,0,25], Ausgabe = [1,1,1,1,1]
• Die Ausgabeform ist ein 1D-Array
• Beispiel) Glättung von Graphen

tf.nn.conv1d Code Toy Beispiel

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)

↑↑↑↑↑ 2D- Konvolutionen - Grundlegend ↑↑↑↑↑

• 2- Richtung (x, y) zur Berechnung der Konv
• Ausgabeform ist 2D- Matrix
• Eingang = [W, H], Filter = [k, k] Ausgang = [W, H]
• Beispiel) Sobel Egde Fllter

tf.nn.conv2d - Spielzeugbeispiel

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)

↑↑↑↑↑ 3D- Konvolutionen - Grundlegend ↑↑↑↑↑

• 3- Richtung (x, y, z) zur Berechnung von conv
• Ausgabeform ist 3D- Volumen
• Eingang = [W, H, L ], Filter = [k, k, d ] Ausgang = [W, H, M]
• d <L ist wichtig! zur Lautstärkeausgabe
• Beispiel) C3D

tf.nn.conv3d - Spielzeugbeispiel

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_width, 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)

↑↑↑↑↑ 2D-Faltungen mit 3D-Eingabe - LeNet, VGG, ..., ↑↑↑↑↑

• Obwohl die Eingabe 3D ist (ex) 224x224x3, 112x112x32
• Die Ausgabeform ist nicht 3D- Volumen, sondern 2D- Matrix
• weil Filtertiefe = L mit Eingangskanälen = L übereinstimmen muss
• 2- Richtung (x, y) zur Berechnung von conv! nicht 3D
• Eingang = [W, H, L ], Filter = [k, k, L ] Ausgang = [W, H]
• Ausgabeform ist 2D- Matrix
• Was ist, wenn wir N Filter trainieren wollen (N ist die Anzahl der Filter)?
• dann ist die Ausgabeform (gestapelt 2D) 3D = 2D x N Matrix.

conv2d - LeNet, VGG, ... für 1 Filter

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, ... für N Filter

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)

↑↑↑↑↑ Bonus 1x1 Conv in CNN - GoogLeNet, ..., ↑↑↑↑↑

• 1x1 conv ist verwirrend, wenn Sie dies als 2D-Bildfilter wie Sobel betrachten
• Für 1x1 Conv in CNN erfolgt die Eingabe in 3D-Form wie im obigen Bild.
• Es berechnet die Tiefenfilterung
• Eingang = [W, H, L], Filter = [1,1, L] Ausgang = [W, H]
• Die gestapelte Ausgabeform ist 3D = 2D x N Matrix.

tf.nn.conv2d - Sonderfall 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)

Animation (2D Conv mit 3D-Eingängen)

- Original Link: LINK
- Der Autor: Martin Görner
- Twitter: @martin_gorner
- Google +: plus.google.com/+MartinGorne

Bonus 1D Convolutions mit 2D-Eingabe

↑↑↑↑↑ 1D-Faltungen mit 1D-Eingang ↑↑↑↑↑

↑↑↑↑↑ 1D Faltungen mit 2D-Eingabe ↑↑↑↑↑

• Obwohl die Eingabe 2D ex) 20x14 ist
• Die Ausgabeform ist nicht 2D , sondern 1D Matrix
• weil Filterhöhe = L mit Eingabehöhe = L übereinstimmen muss
• 1- Richtung (x) zur Berechnung von conv! nicht 2D
• Eingang = [W, L ], Filter = [k, L ] Ausgang = [W]
• Ausgabeform ist 1D Matrix
• Was ist, wenn wir N Filter trainieren wollen (N ist die Anzahl der Filter)?
• dann ist die Ausgabeform (gestapelt 1D) 2D = 1D x N Matrix.

Bonus 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_width, 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()

Eingabe & Ausgabe in Tensorflow

Zusammenfassung

Nach der Antwort von @runhani füge ich ein paar weitere Details hinzu, um die Erklärung etwas klarer zu machen, und werde versuchen, dies etwas genauer zu erklären (und natürlich mit Beispielen aus TF1 und TF2).

Eines der wichtigsten zusätzlichen Elemente, die ich einbeziehe, sind:

• Schwerpunkt auf Anwendungen
• Benutzung von tf.Variable
• Klarere Erklärung der Ein- / Kernel / Ausgänge 1D / 2D / 3D-Faltung
• Die Auswirkungen von Schritt / Polsterung

1D Faltung

Hier erfahren Sie, wie Sie eine 1D-Faltung mit TF 1 und TF 2 durchführen können.

Und um genau zu sein, meine Daten haben folgende Formen:

• 1D vector - [batch size, width, in channels](z 1, 5, 1)
• Kernel - [width, in channels, out channels](zB 5, 1, 4)
• Ausgabe - [batch size, width, out_channels](zB 1, 5, 4)

TF1 Beispiel

import tensorflow as tf
import numpy as np

inp = tf.placeholder(shape=[None, 5, 1], dtype=tf.float32)
kernel = tf.Variable(tf.initializers.glorot_uniform()([5, 1, 4]), dtype=tf.float32)
out = tf.nn.conv1d(inp, kernel, stride=1, padding='SAME')

with tf.Session() as sess:
  tf.global_variables_initializer().run()
  print(sess.run(out, feed_dict={inp: np.array([[[0],[1],[2],[3],[4]],[[5],[4],[3],[2],[1]]])}))

TF2 Beispiel

import tensorflow as tf
import numpy as np

inp = np.array([[[0],[1],[2],[3],[4]],[[5],[4],[3],[2],[1]]]).astype(np.float32)
kernel = tf.Variable(tf.initializers.glorot_uniform()([5, 1, 4]), dtype=tf.float32)
out = tf.nn.conv1d(inp, kernel, stride=1, padding='SAME')
print(out)

Es ist viel weniger Arbeit mit TF2 als TF2 nicht braucht Sessionund variable_initializerzum Beispiel.

Wie könnte das im wirklichen Leben aussehen?

Lassen Sie uns anhand eines Beispiels zur Signalglättung verstehen, was dies bewirkt. Links haben Sie das Original und rechts haben Sie den Ausgang einer Convolution 1D mit 3 Ausgangskanälen.

Was bedeuten mehrere Kanäle?

Mehrere Kanäle sind im Grunde mehrere Feature-Darstellungen eines Eingangs. In diesem Beispiel haben Sie drei Darstellungen, die von drei verschiedenen Filtern erhalten wurden. Der erste Kanal ist der gleichgewichtete Glättungsfilter. Der zweite ist ein Filter, der die Mitte des Filters mehr als die Grenzen gewichtet. Der letzte Filter macht das Gegenteil des zweiten. So können Sie sehen, wie diese verschiedenen Filter unterschiedliche Effekte bewirken.

Deep-Learning-Anwendungen der 1D-Faltung

1D Faltung wurde für die verwendete erfolgreiche Satz Klassifikationsaufgabe.

2D-Faltung

Aus zur 2D-Faltung. Wenn Sie eine tief lernende Person sind, ist die Wahrscheinlichkeit, dass Sie nicht auf 2D-Faltung gestoßen sind,… ungefähr Null. Es wird in CNNs zur Bildklassifizierung, Objekterkennung usw. sowie bei NLP-Problemen verwendet, die Bilder betreffen (z. B. Erzeugung von Bildunterschriften).

Versuchen wir ein Beispiel: Ich habe hier einen Faltungskern mit den folgenden Filtern:

• Kantenerkennungskernel (3x3-Fenster)
• Unschärfekern (3x3 Fenster)
• Kernel schärfen (3x3 Fenster)

Und um genau zu sein, meine Daten haben folgende Formen:

• Bild (schwarz und weiß) - [batch_size, height, width, 1](zB 1, 340, 371, 1)
• Kernel (auch bekannt als Filter) - [height, width, in channels, out channels](zB 3, 3, 1, 3)
• Ausgang (auch bekannt als Feature - Karten) - [batch_size, height, width, out_channels](z 1, 340, 371, 3)

TF1 Beispiel,

import tensorflow as tf
import numpy as np
from PIL import Image

im = np.array(Image.open(<some image>).convert('L'))#/255.0

kernel_init = np.array(
    [
     [[[-1, 1.0/9, 0]],[[-1, 1.0/9, -1]],[[-1, 1.0/9, 0]]],
     [[[-1, 1.0/9, -1]],[[8, 1.0/9,5]],[[-1, 1.0/9,-1]]],
     [[[-1, 1.0/9,0]],[[-1, 1.0/9,-1]],[[-1, 1.0/9, 0]]]
     ])

inp = tf.placeholder(shape=[None, image_height, image_width, 1], dtype=tf.float32)
kernel = tf.Variable(kernel_init, dtype=tf.float32)
out = tf.nn.conv2d(inp, kernel, strides=[1,1,1,1], padding='SAME')

with tf.Session() as sess:
  tf.global_variables_initializer().run()
  res = sess.run(out, feed_dict={inp: np.expand_dims(np.expand_dims(im,0),-1)})

TF2 Beispiel

import tensorflow as tf
import numpy as np
from PIL import Image

im = np.array(Image.open(<some image>).convert('L'))#/255.0
x = np.expand_dims(np.expand_dims(im,0),-1)

kernel_init = np.array(
    [
     [[[-1, 1.0/9, 0]],[[-1, 1.0/9, -1]],[[-1, 1.0/9, 0]]],
     [[[-1, 1.0/9, -1]],[[8, 1.0/9,5]],[[-1, 1.0/9,-1]]],
     [[[-1, 1.0/9,0]],[[-1, 1.0/9,-1]],[[-1, 1.0/9, 0]]]
     ])

kernel = tf.Variable(kernel_init, dtype=tf.float32)

out = tf.nn.conv2d(x, kernel, strides=[1,1,1,1], padding='SAME')

Wie könnte das im wirklichen Leben aussehen?

Hier sehen Sie die Ausgabe, die durch den obigen Code erzeugt wird. Das erste Bild ist das Original und im Uhrzeigersinn haben Sie Ausgänge des 1. Filters, 2. Filters und 3 Filters.

Was bedeuten mehrere Kanäle?

Im Zusammenhang mit 2D-Faltung ist es viel einfacher zu verstehen, was diese mehreren Kanäle bedeuten. Angenommen, Sie machen Gesichtserkennung. Sie können sich vorstellen (dies ist eine sehr unrealistische Vereinfachung, bringt aber den Punkt auf den Punkt), dass jeder Filter ein Auge, einen Mund, eine Nase usw. darstellt, sodass jede Feature-Map eine binäre Darstellung dessen ist, ob dieses Feature in dem von Ihnen bereitgestellten Bild vorhanden ist . Ich glaube nicht, dass ich betonen muss, dass dies für ein Gesichtserkennungsmodell sehr wertvolle Merkmale sind. Weitere Informationen in diesem Artikel .

Dies ist eine Illustration dessen, was ich zu artikulieren versuche.

Deep-Learning-Anwendungen der 2D-Faltung

2D-Faltung ist im Bereich des tiefen Lernens sehr verbreitet.

CNNs (Convolution Neural Networks) verwenden 2D-Faltungsoperationen für fast alle Computer-Vision-Aufgaben (z. B. Bildklassifizierung, Objekterkennung, Videoklassifizierung).

3D-Faltung

Jetzt wird es immer schwieriger zu veranschaulichen, was mit zunehmender Anzahl von Dimensionen vor sich geht. Mit einem guten Verständnis der Funktionsweise von 1D- und 2D-Faltung ist es jedoch sehr einfach, dieses Verständnis auf 3D-Faltung zu verallgemeinern. Also los geht's.

Und um genau zu sein, meine Daten haben folgende Formen:

• 3D - Daten (LIDAR) - [batch size, height, width, depth, in channels](z 1, 200, 200, 200, 1)
• Kernel - [height, width, depth, in channels, out channels](zB 5, 5, 5, 1, 3)
• Ausgabe - [batch size, width, height, width, depth, out_channels](zB 1, 200, 200, 2000, 3)

TF1 Beispiel

import tensorflow as tf
import numpy as np

tf.reset_default_graph()

inp = tf.placeholder(shape=[None, 200, 200, 200, 1], dtype=tf.float32)
kernel = tf.Variable(tf.initializers.glorot_uniform()([5,5,5,1,3]), dtype=tf.float32)
out = tf.nn.conv3d(inp, kernel, strides=[1,1,1,1,1], padding='SAME')

with tf.Session() as sess:
  tf.global_variables_initializer().run()
  res = sess.run(out, feed_dict={inp: np.random.normal(size=(1,200,200,200,1))})

TF2 Beispiel

import tensorflow as tf
import numpy as np

x = np.random.normal(size=(1,200,200,200,1))
kernel = tf.Variable(tf.initializers.glorot_uniform()([5,5,5,1,3]), dtype=tf.float32)
out = tf.nn.conv3d(x, kernel, strides=[1,1,1,1,1], padding='SAME') 

Deep-Learning-Anwendungen der 3D-Faltung

Die 3D-Faltung wurde bei der Entwicklung von Anwendungen für maschinelles Lernen verwendet, die dreidimensionale LIDAR-Daten (Light Detection and Ranging) enthalten.

Was ... mehr Jargon?: Schritt und Polsterung

Okay, du bist fast da. Also halte durch. Mal sehen, was Schritt und Polsterung ist. Sie sind sehr intuitiv, wenn Sie an sie denken.

Wenn Sie über einen Korridor gehen, gelangen Sie in weniger Schritten schneller dorthin. Es bedeutet aber auch, dass Sie eine geringere Umgebung beobachtet haben, als wenn Sie durch den Raum gegangen wären. Lassen Sie uns jetzt unser Verständnis mit einem schönen Bild verstärken! Lassen Sie uns diese über 2D-Faltung verstehen.

Schritt verstehen

Wenn Sie tf.nn.conv2dzum Beispiel verwenden, müssen Sie es als Vektor von 4 Elementen festlegen. Es gibt keinen Grund, sich davon einschüchtern zu lassen. Es enthält nur die Schritte in der folgenden Reihenfolge.

• 2D-Faltung - [batch stride, height stride, width stride, channel stride]. Hier haben Sie Batch-Schritt und Kanal-Schritt nur auf eins gesetzt (ich implementiere seit 5 Jahren Deep-Learning-Modelle und musste sie nie auf etwas anderes als eins setzen). Sie haben also nur noch 2 Schritte zum Setzen.

• 3D Faltung - [batch stride, height stride, width stride, depth stride, channel stride]. Hier kümmern Sie sich nur um Höhen-, Breiten- und Tiefenschritte.

Polsterung verstehen

Jetzt bemerken Sie, dass unabhängig davon, wie klein Ihr Schritt ist (dh 1), während der Faltung eine unvermeidbare Dimensionsreduzierung auftritt (z. B. beträgt die Breite 3 nach dem Falten eines 4 Einheiten breiten Bildes). Dies ist insbesondere beim Aufbau neuronaler Netze mit tiefer Faltung unerwünscht. Hier hilft die Polsterung. Es gibt zwei am häufigsten verwendete Polstertypen.

• SAME und VALID

Unten sehen Sie den Unterschied.

Letztes Wort : Wenn Sie sehr neugierig sind, fragen Sie sich vielleicht. Wir haben gerade eine Bombe auf die vollständige automatische Dimensionsreduzierung abgeworfen und sprechen jetzt davon, unterschiedliche Schritte zu machen. Das Beste am Schritt ist jedoch, dass Sie steuern, wann und wie die Abmessungen reduziert werden.

1. CNN 1D, 2D oder 3D bezieht sich eher auf die Faltungsrichtung als auf die Eingabe- oder Filterdimension.

2. Für einen 1-Kanal-Eingang ist CNN2D gleich CNN1D ist Kernellänge = Eingangslänge. (1 Konv. Richtung)

Zusammenfassend bewegt sich der Kernel in 1D CNN in eine Richtung. Die Eingabe- und Ausgabedaten von 1D CNN sind zweidimensional. Wird hauptsächlich für Zeitreihendaten verwendet.

In 2D CNN bewegt sich der Kernel in zwei Richtungen. Die Eingabe- und Ausgabedaten von 2D-CNN sind dreidimensional. Wird hauptsächlich für Bilddaten verwendet.

In 3D CNN bewegt sich der Kernel in drei Richtungen. Die Eingabe- und Ausgabedaten von 3D CNN sind 4-dimensional. Wird hauptsächlich für 3D-Bilddaten (MRT, CT) verwendet.

Weitere Informationen finden Sie hier: https://medium.com/@xzz201920/conv1d-conv2d-and-conv3d-8a59182c4d6