tensorflow
1D-Faltung verwenden

Grundlegendes Beispiel

Update: TensorFlow unterstützt jetzt die 1D-Faltung seit Version r0.11 mit tf.nn.conv1d .

Betrachten Sie ein grundlegendes Beispiel mit einer Eingabe der Länge 10 und der Dimension 16 . Die Losgröße beträgt 32 . Wir haben daher einen Platzhalter mit Eingabeform [batch_size, 10, 16] .

batch_size = 32
x = tf.placeholder(tf.float32, [batch_size, 10, 16])

Dann erstellen wir einen Filter mit der Breite 3 und nehmen 16 Kanäle als Eingang und geben auch 16 Kanäle aus.

filter = tf.zeros([3, 16, 16])  # these should be real values, not 0

Zum Schluss wenden wir tf.nn.conv1d mit einem Schritt und einer Auffüllung an:

• Schritt : Ganzzahl s
• Polsterung : Dies funktioniert wie in 2D, Sie können zwischen SAME und VALID wählen. SAME gibt die gleiche Eingangslänge aus, während VALID keinen VALID hinzufügt.

Für unser Beispiel nehmen wir einen Schritt von 2 und eine gültige Auffüllung.

output = tf.nn.conv1d(x, filter, stride=2, padding="VALID")

Die Ausgabeform sollte [batch_size, 4, 16] .
Mit padding="SAME" wir eine Ausgabeform von [batch_size, 5, 16] .

Bei früheren TensorFlow-Versionen können Sie einfach 2D-Faltungen verwenden, während Sie die Höhe der Eingänge und der Filter auf 1 .

Mathematik hinter der 1D-Faltung mit fortgeschrittenen Beispielen in TF

`Um die 1D-Faltung von Hand zu berechnen, schieben Sie Ihren Kern über die Eingabe, berechnen die elementweisen Multiplikationen und summieren sie.

Der einfachste Weg ist das Auffüllen = 0, Schritt = 1

Wenn also Ihre input = [1, 0, 2, 3, 0, 1, 1] und der kernel = [2, 1, 3] das Ergebnis der Faltung [8, 11, 7, 9, 4] , dh auf folgende Weise berechnet:

• 8 = 1 * 2 + 0 * 1 + 2 * 3
• 11 = 0 * 2 + 2 * 1 + 3 * 3
• 7 = 2 * 2 + 3 * 1 + 0 * 3
• 9 = 3 * 2 + 0 * 1 + 1 * 3
• 4 = 0 * 2 + 1 * 1 + 1 * 3

Die conv1d- Funktion von TF berechnet Faltungen in Batches. Um dies in TF tun zu können, müssen wir die Daten im richtigen Format bereitstellen (doc erklärt, dass die Eingabe in [batch, in_width, in_channels] muss. Außerdem wird erläutert, wie der Kernel aussehen soll mögen). So

import tensorflow as tf
i = tf.constant([1, 0, 2, 3, 0, 1, 1], dtype=tf.float32, name='i')
k = tf.constant([2, 1, 3], dtype=tf.float32, name='k')

print i, '\n', k, '\n'

data   = tf.reshape(i, [1, int(i.shape[0]), 1], name='data')
kernel = tf.reshape(k, [int(k.shape[0]), 1, 1], name='kernel')

print data, '\n', kernel, '\n'

res = tf.squeeze(tf.nn.conv1d(data, kernel, 1, 'VALID'))
with tf.Session() as sess:
    print sess.run(res)

Sie erhalten die gleiche Antwort, die wir zuvor berechnet haben: [ 8. 11. 7. 9. 4.]

Faltung mit Polsterung

Das Auffüllen ist nur eine fantastische Methode, um Anhängen anzuhängen und Ihre Eingabe mit einem gewissen Wert zu versehen. In den meisten Fällen ist dieser Wert 0 und aus diesem Grund wird er meistens als Nullabstand bezeichnet. TF unterstützt 'VALID' und 'SAME' Zero-Padding. Für ein beliebiges Padding müssen Sie tf.pad () verwenden . "VALID" -Padding bedeutet überhaupt kein Padding. Gleiches bedeutet, dass die Ausgabe dieselbe Größe wie die Eingabe hat. Lassen Sie uns die Faltung mit padding=1 im selben Beispiel berechnen (beachten Sie, dass dies für unseren Kernel 'SAME' ist). Dazu fügen wir einfach unser Array am Anfang / Ende mit 1 Null an: input = [0, 1, 0, 2, 3, 0, 1, 1, 0] .

Hier können Sie feststellen, dass Sie nicht alles neu berechnen müssen: Alle Elemente bleiben mit Ausnahme des ersten / letzten Elements gleich.

• 1 = 0 * 2 + 1 * 1 + 0 * 3
• 3 = 1 * 2 + 1 * 1 + 0 * 3

Das Ergebnis ist also [1, 8, 11, 7, 9, 4, 3] was dasselbe ist, wie mit TF berechnet:

res = tf.squeeze(tf.nn.conv1d(data, kernel, 1, 'SAME'))
with tf.Session() as sess:
    print sess.run(res)

Faltung mit Schritten

Strides ermöglichen das Überspringen von Elementen beim Gleiten. In allen unseren vorherigen Beispielen haben wir 1 Element verschoben, jetzt können Sie s Elemente gleichzeitig verschieben. Da wir ein vorheriges Beispiel verwenden werden, gibt es einen Trick: Gleiten um n Elemente ist gleichbedeutend mit Gleiten um 1 Element und Auswählen jedes n-ten Elements.

Wenn wir also unser vorheriges Beispiel mit padding=1 und den stride auf 2 ändern, nehmen Sie einfach das vorherige Ergebnis [1, 8, 11, 7, 9, 4, 3] und lassen jedes 2. Element zurück, was zu einem Ergebnis führt [1, 11, 9, 3] . Sie können dies in TF auf folgende Weise tun:

res = tf.squeeze(tf.nn.conv1d(data, kernel, 2, 'SAME'))
with tf.Session() as sess:
    print sess.run(res)