Understanding tf.extract_image_patches zum Extrahieren von Patches aus einem Bild

Question

Ich habe die folgende Methode tf.extract_image_patches in Tensorflow API gefunden, aber ich bin nicht klar über seine Funktionalität.

Sagen Sie den batch_size = 1, und ein Bild der Größe 225x225x3, und wir wollen 32x32 Flecken Größe extrahieren.

Wie genau verhält sich diese Funktion? Insbesondere erwähnt die Dokumentation die Dimension des Ausgangstensors [batch, out_rows, out_cols, ksize_rows * ksize_cols * depth], aber was out_rows und out_cols sind, wird nicht erwähnt.

Idealerweise gegeben ein Eingangsbild Tensor Größe 1x225x225x3 (wobei 1 die Chargengröße ist), ich möchte in der Lage zu bekommen Kx32x32x3 als Ausgang, wo K die Gesamtzahl der Patches und 32x32x3 ist die Dimension eines jeden Patch . Gibt es etwas im Tensorflow, das dies bereits erreicht?

Answer 1

Hier ist, wie die Methode funktioniert:

• ksizes verwendet wird, um die Dimensionen jedes Patch, um zu entscheiden, oder in anderen Worten, wie viele Pixel jeder Patch enthalten sollte.
• strides bezeichnet die Länge der Lücke zwischen dem Start eines Patches und dem Start des nächsten nachfolgenden Patches innerhalb des Originalbildes.
• rates ist eine Zahl, die im Wesentlichen bedeutet, dass unser Patch um rates Pixel im Originalbild für jedes weitere Pixel springen soll, das in unserem Patch endet. (Das folgende Beispiel veranschaulicht dies.)
• padding ist entweder "VALID", was bedeutet, dass jedes Patch vollständig im Bild enthalten sein muss, oder "SAME", was bedeutet, dass Patches unvollständig sein dürfen (die restlichen Pixel sind) mit Nullen gefüllt).

Hier ist ein Beispielcode mit einer Leistung zeigen zu helfen, wie es funktioniert:

import tensorflow as tf 

n = 10 
# images is a 1 x 10 x 10 x 1 array that contains the numbers 1 through 100 in order 
images = [[[[x * n + y + 1] for y in range(n)] for x in range(n)]] 

# We generate four outputs as follows: 
# 1. 3x3 patches with stride length 5 
# 2. Same as above, but the rate is increased to 2 
# 3. 4x4 patches with stride length 7; only one patch should be generated 
# 4. Same as above, but with padding set to 'SAME' 
with tf.Session() as sess: 
    print tf.extract_image_patches(images=images, ksizes=[1, 3, 3, 1], strides=[1, 5, 5, 1], rates=[1, 1, 1, 1], padding='VALID').eval(), '\n\n' 
    print tf.extract_image_patches(images=images, ksizes=[1, 3, 3, 1], strides=[1, 5, 5, 1], rates=[1, 2, 2, 1], padding='VALID').eval(), '\n\n' 
    print tf.extract_image_patches(images=images, ksizes=[1, 4, 4, 1], strides=[1, 7, 7, 1], rates=[1, 1, 1, 1], padding='VALID').eval(), '\n\n' 
    print tf.extract_image_patches(images=images, ksizes=[1, 4, 4, 1], strides=[1, 7, 7, 1], rates=[1, 1, 1, 1], padding='SAME').eval() 

Ausgang:

[[[[ 1 2 3 11 12 13 21 22 23] 
    [ 6 7 8 16 17 18 26 27 28]] 

    [[51 52 53 61 62 63 71 72 73] 
    [56 57 58 66 67 68 76 77 78]]]] 


[[[[ 1 3 5 21 23 25 41 43 45] 
    [ 6 8 10 26 28 30 46 48 50]] 

    [[ 51 53 55 71 73 75 91 93 95] 
    [ 56 58 60 76 78 80 96 98 100]]]] 


[[[[ 1 2 3 4 11 12 13 14 21 22 23 24 31 32 33 34]]]] 


[[[[ 1 2 3 4 11 12 13 14 21 22 23 24 31 32 33 34] 
    [ 8 9 10 0 18 19 20 0 28 29 30 0 38 39 40 0]] 

    [[ 71 72 73 74 81 82 83 84 91 92 93 94 0 0 0 0] 
    [ 78 79 80 0 88 89 90 0 98 99 100 0 0 0 0 0]]]] 

So zum Beispiel unser erstes Ergebnis sieht wie folgt aus:

* * * 4 5 * * * 9 10 
* * * 14 15 * * * 19 20 
* * * 24 25 * * * 29 30 
31 32 33 34 35 36 37 38 39 40 
41 42 43 44 45 46 47 48 49 50 
* * * 54 55 * * * 59 60 
* * * 64 65 * * * 69 70 
* * * 74 75 * * * 79 80 
81 82 83 84 85 86 87 88 89 90 
91 92 93 94 95 96 97 98 99 100 

Wie Sie sehen können, haben wir 2 Zeilen und 2 Spalten wor th der Patches, die out_rows und out_cols sind.

Answer 2

Um Neals detaillierte Antwort zu erweitern, gibt es eine Menge Feinheiten mit Nullauffüllung bei Verwendung von "SAME", da extract_image_patches versucht, die Patches im Bild nach Möglichkeit zu zentrieren. Je nach Schritt kann oben und links ein Padding vorhanden sein oder nicht, und der erste Patch muss nicht unbedingt oben links beginnen.

beispielsweise dem vorhergehenden Beispiel erstreckt:

print tf.extract_image_patches(images, [1, 3, 3, 1], [1, n, n, 1], [1, 1, 1, 1], 'SAME').eval()[0] 

Mit einem Stride von n = 1, wird das Bild mit Nullen aufgefüllt rundum und der erste Patch beginnt mit Polsterung. Andere Schritte füllen das Bild nur auf der rechten und unteren Seite oder gar nicht auf. Mit einem Schritt von n = 10 startet der einzelne Patch bei Element 34 (in der Mitte des Bildes).

tf.extract_image_patches wird von der Eigenbibliothek implementiert, speziell Tensor ImagePatchOp. Sie können diesen Code untersuchen, um genau zu sehen, wie Patch-Positionen und Abstände berechnet werden.