[PYTHON] Ich habe versucht, die Strichzeichnung mit Deep Learning aus dem Bild zu extrahieren

Ich habe versucht, mit Deep Learning # eine Strichzeichnung aus einem Bild zu extrahieren

Als ich es bemerkte, ging GW in einem Augenblick vorbei. Das diesjährige GW lief mit der ganzen Familie durch Tokio (einschließlich einiger Saitama). Ich bin auf den Himmelsbaum geklettert, aber ich habe nicht gedacht, dass es so viele Menschen gibt. Es schien interessant, nachts zu gehen, wenn ich als nächstes gehen musste. Es sieht so aus, als würde es gescreent.

6/11 Update

Ich habe die Netzwerkstruktur und verschiedene Dinge im Dataset geändert, um die Strichzeichnung zu verbessern, die extrahiert werden kann. Deshalb habe ich sie einschließlich ihres Inhalts aktualisiert.

Ich möchte eine Strichzeichnung

Wie ich im vorherigen Artikel geschrieben habe, habe ich versucht, mit Deep Learning Strichzeichnungen zu färben, aber dabei hatte ich das Gefühl, dass es einige Probleme mit dem Datensatz gab. Die Strichzeichnung selbst wurde unter Bezugnahme auf http://qiita.com/khsk/items/6cf4bae0166e4b12b942 erstellt, es scheint jedoch einige Probleme zu geben.

• Das Binarisieren eines reduzierten Bildes ist zu gezackt
• Dies selbst wurde durch Binärisieren und anschließendes Schrumpfen gelöst (schließlich tritt bei Verwendung von BiCubic ein Zottel auf).
• Bei Verwendung ohne Binärisierung gibt es je nach verwendeter Farbe viele Fälle, in denen der ursprünglich abgedunkelte Teil heller wird.
• Da der absolute Wert des Farbunterschieds verwendet wird, wird er zwangsläufig heller, wenn ähnliche Farben zwischen der Linie und der gemalten Farbe verwendet werden.
• Je nachdem, wie die Farbe angewendet wird, werden möglicherweise zusätzliche Details angezeigt.
• Besonders auffällig in Schatten in der Anime-Malerei

Nun, es gibt einige Probleme, aber ich arbeite immer noch daran, weil es einfach (nur wenn OpenCV funktioniert) und mit hoher Geschwindigkeit (OpenCV wird abgekürzt) erstellt werden kann.

Forschung, um rau in Strichzeichnung zu verwandeln

Einige der vorhandenen Forschungsergebnisse lauten wie folgt. http://hi.cs.waseda.ac.jp:8081/

Dies ist ein Papier. http://hi.cs.waseda.ac.jp/~esimo/publications/SimoSerraSIGGRAPH2016.pdf

Dies ist eine Technik für AutoEncoder, die grobe in Strichzeichnungen konvertiert. Diesmal habe ich es in Bezug darauf gemacht.

class AutoEncoder(object):
    """Define autoencoder"""

    def __init__(self):
        self.conv1 = Encoder(3, 48, 5, 5, strides=[1, 2, 2, 1], name='encoder1')
        self.conv1_f1 = Encoder(48, 128, 3, 3, name='encoder1_flat1')
        self.conv1_f2 = Encoder(128, 128, 3, 3, name='encoder1_flat2')
        self.conv2 = Encoder(128, 256, 5, 5, strides=[1, 2, 2, 1], name='encoder2')
        self.conv2_f1 = Encoder(256, 256, 3, 3, name='encoder2_flat1')
        self.conv2_f2 = Encoder(256, 256, 3, 3, name='encoder2_flat2')
        self.conv3 = Encoder(256, 256, 5, 5, strides=[1, 2, 2, 1], name='encoder3')
        self.conv3_f1 = Encoder(256, 512, 3, 3, name='encoder3_flat1')
        self.conv3_f2 = Encoder(512, 1024, 3, 3, name='encoder3_flat2')
        self.conv3_f3 = Encoder(1024, 512, 3, 3, name='encoder3_flat3')
        self.conv3_f4 = Encoder(512, 256, 3, 3, name='encoder3_flat4')

        self.bnc1 = op.BatchNormalization(name='bnc1')
        self.bnc1_f1 = op.BatchNormalization(name='bnc1_flat1')
        self.bnc1_f2 = op.BatchNormalization(name='bnc1_flat2')
        self.bnc2 = op.BatchNormalization(name='bnc2')
        self.bnc2_f1 = op.BatchNormalization(name='bnc2_flat1')
        self.bnc2_f2 = op.BatchNormalization(name='bnc2_flat2')
        self.bnc3 = op.BatchNormalization(name='bnc3')
        self.bnc3_f1 = op.BatchNormalization(name='bnc3_flat1')
        self.bnc3_f2 = op.BatchNormalization(name='bnc3_flat2')
        self.bnc3_f3 = op.BatchNormalization(name='bnc3_flat3')
        self.bnc3_f4 = op.BatchNormalization(name='bnc3_flat4')

        self.deconv1 = Decoder(256, 256, 4, 4, strides=[1, 2, 2, 1], name='decoder1')
        self.deconv1_f1 = Encoder(256, 128, 3, 3, name='decoder1_flat1')
        self.deconv1_f2 = Encoder(128, 128, 3, 3, name='decoder1_flat2')
        self.deconv2 = Decoder(128, 128, 4, 4, strides=[1, 2, 2, 1], name='decoder2')
        self.deconv2_f1 = Encoder(128, 128, 3, 3, name='decoder2_flat1')
        self.deconv2_f2 = Encoder(128, 48, 3, 3, name='decoder2_flat2')
        self.deconv3 = Decoder(48, 48, 4, 4, strides=[1, 2, 2, 1], name='decoder3')
        self.deconv3_f1 = Decoder(48, 24, 3, 3, name='decoder3_flat1')
        self.deconv3_f2 = Decoder(24, 1, 3, 3, name='decoder3_flat2')

        self.bnd1 = op.BatchNormalization(name='bnd1')
        self.bnd1_f1 = op.BatchNormalization(name='bnd1_flat1')
        self.bnd1_f2 = op.BatchNormalization(name='bnd1_flat2')
        self.bnd2 = op.BatchNormalization(name='bnd2')
        self.bnd2_f1 = op.BatchNormalization(name='bnd2_flat1')
        self.bnd2_f2 = op.BatchNormalization(name='bnd2_flat2')
        self.bnd3 = op.BatchNormalization(name='bnd3')
        self.bnd3_f1 = op.BatchNormalization(name='bnd3_flat1')


def autoencoder(images, height, width):
    """make autoencoder network"""

    AE = AutoEncoder()

    def div(v, d):
        return max(1, v // d)

    relu = tf.nn.relu
    net = relu(AE.bnc1(AE.conv1(images, [height, width])))
    net = relu(AE.bnc1_f1(AE.conv1_f1(net, [div(height, 2), div(width, 2)])))
    net = relu(AE.bnc1_f2(AE.conv1_f2(net, [div(height, 2), div(width, 2)])))
    net = relu(AE.bnc2(AE.conv2(net, [div(height, 2), div(width, 2)])))
    net = relu(AE.bnc2_f1(AE.conv2_f1(net, [div(height, 4), div(width, 4)])))
    net = relu(AE.bnc2_f2(AE.conv2_f2(net, [div(height, 4), div(width, 4)])))
    net = relu(AE.bnc3(AE.conv3(net, [div(height, 4), div(width, 4)])))
    net = relu(AE.bnc3_f1(AE.conv3_f1(net, [div(height, 8), div(width, 8)])))
    net = relu(AE.bnc3_f2(AE.conv3_f2(net, [div(height, 8), div(width, 8)])))
    net = relu(AE.bnc3_f3(AE.conv3_f3(net, [div(height, 8), div(width, 8)])))
    net = relu(AE.bnc3_f4(AE.conv3_f4(net, [div(height, 8), div(width, 8)])))
    net = relu(AE.bnd1(AE.deconv1(net, [div(height, 4), div(width, 4)])))
    net = relu(AE.bnd1_f1(AE.deconv1_f1(net, [div(height, 4), div(width, 4)])))
    net = relu(AE.bnd1_f2(AE.deconv1_f2(net, [div(height, 4), div(width, 4)])))
    net = relu(AE.bnd2(AE.deconv2(net, [div(height, 2), div(width, 2)])))
    net = relu(AE.bnd2_f1(AE.deconv2_f1(net, [div(height, 2), div(width, 2)])))
    net = relu(AE.bnd2_f2(AE.deconv2_f2(net, [div(height, 2), div(width, 2)])))
    net = relu(AE.bnd3(AE.deconv3(net, [height, width])))
    net = relu(AE.bnd3_f1(AE.deconv3_f1(net, [height, width])))

    net = tf.nn.sigmoid(AE.deconv3_f2(net, [height, width]))

    return net

AutoEncoder sieht so aus. Ich fragte mich, ob ich es irgendwie bekommen könnte. In der Arbeit scheint der Fokus auf der Methode namens Loss Map zu liegen, aber da ich nicht weiß, wie ich auf das Histogramm in Tensorflow verweisen soll, wird dieser Teil implementiert.

Ich versuchte es

Das verwendete Netzwerk war ungefähr 250.000 Mal mit den folgenden Parametern.

• batch size = 15
• Größe des Trainingsbild-Patches = 128 \ * 128
• 128 \ * 128 zufällig aus dem Originalbild zuschneiden und verwenden
• Konvertieren Sie zufällig oben / unten / links / rechts / Farbton
• learning rate = 0.00002
• Optimizer = ADAM

Ich habe die enorme Größe aufgegeben, weil ich selbst mit 2 GB Speicher überhaupt nicht überleben konnte. Es scheint gut, es einmal zu reduzieren, zu extrahieren und dann einen Encoder einzufügen, um die Auflösung zu erhöhen.

Bild von angemessener Größe

Mikon! Ich habe es gemalt. Amezuku @ Auf der Suche nach einem Job

Alle Originalbilder sind ausgeliehen, weil ich sie mit Pixiv gemalt habe. Dieses Bild hat keine ursprüngliche Strichzeichnung und es gibt überhaupt kein Vergleichsziel. Sowohl für diese Größe als auch für die GPU hat es ungefähr 10 Sekunden gedauert, also möchte ich ehrlich gesagt nicht darüber nachdenken, es mit einer CPU zu machen.

Ich finde es ziemlich solide. Die durchschnittliche Größe der Bilder im Datensatz beträgt ungefähr 1000 \ * 1000, was ziemlich groß ist, sodass auch Bilder einer bestimmten Größe verarbeitet werden können. Leider gibt es eine Zackigkeit, die dem unteren Teil eigen ist ... Dies kann nicht gesagt werden, da es Zeiten gibt, in denen es herauskommt und Zeiten, in denen es nicht herauskommt.

Thumblet Größe

Die Größe beträgt 256 \ * 256. Vorerst werde ich auch die Version aufnehmen, die ich mit OpenCV herausgezogen habe. Ignorieren Sie das Tsukkomi, dass 256 \ * 256 als Miniaturansicht angezeigt wird.

Originalbild. Auf den ersten Blick scheint eine Linie zu erscheinen, aber ...

OpenCV-Version. Da alle feinen Farben freigegeben wurden, kann ich das Gefühl nicht leugnen, dass es sich um eine Strichzeichnung oder eine Graustufe handelt.

Diese Netzwerkversion. Es ist teilweise verdächtig (oder besser gesagt, der Handteil ist unmöglich zu spielen), aber der Einfluss des Schattens kann ziemlich richtig ignoriert werden, und der Ausdruck des Haarteils ist einfach, es ist ein Front-Miso, aber es fühlt sich ziemlich gut an Es ist nicht? Zu feine Details wie Rüschen werden vom Stein zerquetscht, aber es scheint, dass dies nach und nach gelöst werden kann, wenn Sie weiter lernen.

Über den Datensatz

Der für das Training verwendete Datensatz stammt im Wesentlichen aus den von Pixiv gemalten Kategorien. Das Wichtigste bei der Erstellung eines Datensatzes war, dass ** die Strichzeichnung und die farbige Zeichnung den gleichen Aspekt hatten **. Wenn sich dies ändert, wird es so sein, als ob ich überhaupt nicht lernen könnte, also habe ich sie gesammelt, während ich jeden einzelnen überprüft habe.

Außerdem stellte ich manchmal fest, dass selbst bei gleichem Seitenverhältnis ein geringfügiger Unterschied zwischen der Strichzeichnung und dem farbigen Bild ** bestand. Ich musste es richtig weglassen, weil das Lernen nicht weitergehen würde, wenn es das auch gäbe.

Schwächen

Es hängt davon ab, wie Sie es malen, aber es ist eine einfachere Linie als OpenCV, und ich denke, es fühlt sich so an, als würden die Details nicht so sehr verloren gehen. Aufgrund der Struktur oder der Art unserer Aktivitäten gibt es jedoch Nachteile, einschließlich der Tatsache, dass wir nichts dagegen tun können.

• Der schwarze Teil erscheint so wie er ist
• In den zum Lernen verwendeten Daten bleibt der schwarze Teil in erheblichem Maße unverändert, verbunden mit der Tatsache, dass die ursprüngliche Strichzeichnung selbst schwarz gestrichen wurde.
• Kleine Größe neigt dazu, zu verschwimmen
• Dies liegt daran, dass das Originalbild mindestens 256 \ * 256 groß war, sodass ich der Meinung bin, dass es nicht möglich ist, damit umzugehen, wenn detailliertere Funktionen erfüllt sind.
• Geben Sie unscharfe Teile grundsätzlich auf
• Ich habe auch versucht, es zu zwingen, mit einem schwachen Bild mit einem Gaußschen Filter zu lernen, aber es ist ziemlich eng
• Der Teil, der fast mit der gleichen Farbe wie die Linienfarbe bemalt ist, wird ziemlich mehrdeutig
• Abhängig von dunklen Schatten und Malmethode
• Es ist grundsätzlich unmöglich, das Original zu reproduzieren (etwas wird in die Zeile eingefügt)

Anstatt es so zu verwenden, wie es ist, denke ich, wird es eher wie eine Verarbeitung auf dieser Grundlage sein.

Zusammenfassung

Generationsnetzwerke wie AutoEncoder sind interessant. Ich möchte mich auch der Herausforderung stellen, Parameter anzugeben, um die Art und Weise zu ändern, wie Strichzeichnungen erstellt werden.

Es ist schwierig zu untersuchen und zu implementieren, aber da Amateure Deep Learning durchführen können, empfehlen wir, dass Sie ein wenig investieren und es ausprobieren (alleine oder in der Cloud).