[PYTHON] Ein Anfänger versuchte, eine Strichzeichnung mit einem Kettenmesser zu färben. Ich konnte es schaffen.

Deplaning ist tai2an, das hauptsächlich für die Arbeit bei P-FN zuständig ist, das als Ware bezeichnet wird und das Löten einen höheren Mehrwert hat. Bei der Amazon Picking Challenge, die landesweit auf NHK ausgestrahlt wurde, machte ich eine klebrige Hand und eine Folie voller Robocon-Feeling. Ich wollte jedoch tief lernen, also habe ich vor ein oder zwei Monaten angefangen, Chainer zu studieren. Ich wollte die Strichzeichnung ausmalen, weil es eine große Sache war, also habe ich verschiedene Dinge ausprobiert.

Das Färben von Strichzeichnungen ist ein überwachter Lernprozess. Sie benötigen daher einen (vorzugsweise großen) Datensatz mit Strichzeichnungen und farbigen Bildern. Dieses Mal wird OpenCV verwendet, um Strichzeichnungen ordnungsgemäß aus Farbbildern zu extrahieren.

Extraktionsbeispiel →　

Der Datensatz wird durch Sammeln von Farbbildern und Erstellen einer Strichzeichnung vervollständigt. (Ich benutze diesmal ungefähr 600.000)

In Bezug auf die Form des Netzwerks habe ich ein Netzwerk namens U-net verwendet, das verwendet wird, indem die Ausgabe der Schicht beim Falten am Anfang zusammengeführt und am Ende dekonvolviert wird. Es scheint geeignet zu sein, wenn man sich auf eine Strichzeichnung bezieht und diese einfärbt. (U-net wird auch in px2px verwendet) Vorerst habe ich versucht zu lernen, das Quadrat des Fehlers aus der richtigen Antwort zu minimieren. Ich verstehe, dass die Netzwerkdefinition selbst im Allgemeinen in Ordnung ist, wenn die Ausgabe einer Schicht und die Eingabe der nächsten Schicht übereinstimmen, aber es ist ein wenig schwierig zu verstehen, da es nicht viele Möglichkeiten gab, ein von mir selbst definiertes Dataset zu erstellen. Ich fragte mich.

Hier ist das Ergebnis des Studiums über Nacht und der Fütterung der Testdaten ↓

Nun, ich kann das Gefühl des neuronalen Netzes spüren: "Ich kann die Hautfarbe irgendwie verstehen, aber ich weiß nichts anderes, ich kann die Farbe der Haare oder der Kleidung des abgebildeten Charakters nicht erraten." .. ..

Hier kommt das gegnerische Netz ins Spiel. Bekannt als Ad Auntie. Tante ist ein Typ, der den Unterschied zwischen einem realen Bild und einem farbigen Bild eines neuronalen Netzes lernt und eine Delle macht. Wenn Sie also nur hautfarbene sepiaähnliche Bilder ausgeben, lernen Sie auf einen Schlag und essen am Ende schlechte Dinge.

Wenn die Anzeigenfrau jedoch zu stark ist, wird die farbige Seite mit dem gebogenen Nabel unscharf. Seien Sie also vorsichtig.

Mit dieser Art von Gefühl sind die Farben sicherlich verbunden, aber es wird ein Kunstsystem, als ob es eine Strichzeichnung wäre. (Nun, das könnte der Weg der Kunst sein

Wenn Sie das Lernen drehen, während Sie auf das Gleichgewicht mit der Differenzkomponente zum Originalbild achten. .. ..

Es wird bunt! Huh

Es ist noch besser! Ich habe auch ein Netzwerk gelernt, das die Strichzeichnung von 512 x 512 Pixel reduziert, in der ersten Stufe 128 x 128 Pixel malt und in der zweiten Stufe 512 x 512 Pixel färbt (die Form des Netzwerks ist in der zweiten Stufe fast gleich, aber die Eingabe ist 4-Kanal und neu hinzugefügt. Retrain. Dies ist keine Ad-Tante)

Das Ergebnis ist hier ↓

(Ich habe diese Strichzeichnung aus der Veröffentlichung von @ lio8644 ausgeliehen.)

Es ist in Ordnung.

Es ist nicht schlecht.

Solange ich die extrahierte Strichzeichnung für den Test verwende, sieht sie ziemlich gut aus, aber was ist mit der tatsächlichen Strichzeichnung?

Ich habe mir eine Strichzeichnung von einem Tag des Bildsystems von pixiv ausgeliehen und sie getestet. (Grundsätzlich sind alle CNNs. Selbst wenn sich das Seitenverhältnis ein wenig ändert, kann es gehandhabt werden.

Denden

groß.

Es wurde ein buntes Monster, aber es gibt solche.

Sich sicher zusammengefasst fühlen

Übrigens gibt es doch so etwas wie den Wunsch, dass Sie diese Farbe malen, oder? Deshalb habe ich den Eingang der ersten Stufe auf 4ch geändert, damit ich zusätzliche Hinweise geben kann.

Tsumari

Sie können Anforderungen wie braunes Haar, hellblauen Pullover und dunkelblauen Rock festlegen.

Wenn Sie einen groben Eindruck erwecken, dass es so aussehen soll, ist es ziemlich gut.

(Wenn die Strichzeichnung gut ist, finde ich es schön, wenn ich sie male, aber w

Es ist auch möglich, viele Hinweise sehr detailliert zu geben. (Es ist ein wenig schwer zu verstehen, aber ich treffe viele Hinweise

Fröhliche Weihnachten! !!

Damit werde ich auch von einem Handwerker zu einem Zeichenhandwerker befördert!

Daher denke ich, dass das automatische Färben von Strichzeichnungen und das Färben mit Hinweisen erheblich erfolgt sind.

Ich glaube nicht, dass ich das richtige Gemälde der Maler übertreffen kann, aber ich denke, es ist bequem, grob zu malen. Es wäre praktisch, wenn es schneller wäre, die Cartoons zu färben, als die Töne einzufügen. (Dieses neuronale Netz ist stark für die Hautfarbe ... Wissen Sie, was Sie sagen möchten?)

Nebenbei bemerkt gibt es noch einige Schwächen.

Da Sie beispielsweise Adversary Net und Hinweise gleichzeitig lernen, kann der Welleneffekt beim Geben von Hinweisen instabil werden.

↑ Ich wollte, dass nur der Badeanzug in einer anderen Farbe lackiert wird, aber auch die Farben der anderen Teile haben sich erheblich geändert. Wenn Sie es nur als einfaches Malwerkzeug verwenden, ist es möglicherweise stabiler, nur mit Hinweisen zu trainieren.

Da die Farbe nach einmaligem Reduzieren gemalt wird, selbst wenn die Strichzeichnung zu dick / dünn ist, gibt es Fälle, in denen die Linie gequetscht oder übersprungen wird und nicht funktioniert, oder auch wenn Sie feines Malen mit Hinweisen anweisen In einigen Fällen wird dies nicht wiedergegeben.

Es wäre cool, wenn ein NN alle Details verarbeiten könnte, aber es scheint notwendig, Anpassungen für jede Anwendung vorzunehmen, wenn sie als Werkzeug verwendet wird.

Strichzeichnung Kreditnehmer http://www.pixiv.net/member_illust.php?mode=medium&illust_id=31274285 http://www.pixiv.net/member_illust.php?mode=manga&illust_id=43369404 http://www.pixiv.net/member_illust.php?mode=medium&illust_id=56689287 http://www.pixiv.net/member_illust.php?mode=medium&illust_id=40487409 http://www.pixiv.net/member_illust.php?mode=medium&illust_id=10552795 https://twitter.com/lio8644

• Ich habe die extrahierte Strichzeichnung weggelassen, da ich die ursprüngliche Referenz nicht sofort finden konnte. Es tut mir Leid

Übrigens ist die Struktur dieses Netzwerks sowohl für die erste als auch für die zweite Stufe gleich, und es sieht so aus

unet.py

    class UNET(chainer.Chain):
        def __init__(self):
            super(UNET, self).__init__(
                c0 = L.Convolution2D(4, 32, 3, 1, 1),
                c1 = L.Convolution2D(32, 64, 4, 2, 1),
                c2 = L.Convolution2D(64, 64, 3, 1, 1),
                c3 = L.Convolution2D(64, 128, 4, 2, 1),
                c4 = L.Convolution2D(128, 128, 3, 1, 1),
                c5 = L.Convolution2D(128, 256, 4, 2, 1),
                c6 = L.Convolution2D(256, 256, 3, 1, 1),
                c7 = L.Convolution2D(256, 512, 4, 2, 1),
                c8 = L.Convolution2D(512, 512, 3, 1, 1),

                dc8 = L.Deconvolution2D(1024, 512, 4, 2, 1),
                dc7 = L.Convolution2D(512, 256, 3, 1, 1),
                dc6 = L.Deconvolution2D(512, 256, 4, 2, 1),
                dc5 = L.Convolution2D(256, 128, 3, 1, 1),
                dc4 = L.Deconvolution2D(256, 128, 4, 2, 1),
                dc3 = L.Convolution2D(128, 64, 3, 1, 1),
                dc2 = L.Deconvolution2D(128, 64, 4, 2, 1),
                dc1 = L.Convolution2D(64, 32, 3, 1, 1),
                dc0 = L.Convolution2D(64, 3, 3, 1, 1),

                bnc0 = L.BatchNormalization(32),
                bnc1 = L.BatchNormalization(64),
                bnc2 = L.BatchNormalization(64),
                bnc3 = L.BatchNormalization(128),
                bnc4 = L.BatchNormalization(128),
                bnc5 = L.BatchNormalization(256),
                bnc6 = L.BatchNormalization(256),
                bnc7 = L.BatchNormalization(512),
                bnc8 = L.BatchNormalization(512),

                bnd8 = L.BatchNormalization(512),
                bnd7 = L.BatchNormalization(256),
                bnd6 = L.BatchNormalization(256),
                bnd5 = L.BatchNormalization(128),
                bnd4 = L.BatchNormalization(128),
                bnd3 = L.BatchNormalization(64),
                bnd2 = L.BatchNormalization(64),
                bnd1 = L.BatchNormalization(32)
        )

    def calc(self,x, test = False):
        e0 = F.relu(self.bnc0(self.c0(x), test=test))
        e1 = F.relu(self.bnc1(self.c1(e0), test=test))
        e2 = F.relu(self.bnc2(self.c2(e1), test=test))
        e3 = F.relu(self.bnc3(self.c3(e2), test=test))
        e4 = F.relu(self.bnc4(self.c4(e3), test=test))
        e5 = F.relu(self.bnc5(self.c5(e4), test=test))
        e6 = F.relu(self.bnc6(self.c6(e5), test=test))
        e7 = F.relu(self.bnc7(self.c7(e6), test=test))
        e8 = F.relu(self.bnc8(self.c8(e7), test=test))

        d8 = F.relu(self.bnd8(self.dc8(F.concat([e7, e8])), test=test))
        d7 = F.relu(self.bnd7(self.dc7(d8), test=test))
        d6 = F.relu(self.bnd6(self.dc6(F.concat([e6, d7])), test=test))
        d5 = F.relu(self.bnd5(self.dc5(d6), test=test))
        d4 = F.relu(self.bnd4(self.dc4(F.concat([e4, d5])), test=test))
        d3 = F.relu(self.bnd3(self.dc3(d4), test=test))
        d2 = F.relu(self.bnd2(self.dc2(F.concat([e2, d3])), test=test))
        d1 = F.relu(self.bnd1(self.dc1(d2), test=test))
        d0 = self.dc0(F.concat([e0, d1]))

        return d0

Ad Tante

adv.py

class DIS(chainer.Chain):
    def __init__(self):
        super(DIS, self).__init__(
                c1 = L.Convolution2D(3, 32, 4, 2, 1),
                c2 = L.Convolution2D(32, 32, 3, 1, 1),
                c3 = L.Convolution2D(32, 64, 4, 2, 1),
                c4 = L.Convolution2D(64, 64, 3, 1, 1),
                c5 = L.Convolution2D(64, 128, 4, 2, 1),
                c6 = L.Convolution2D(128, 128, 3, 1, 1),
                c7 = L.Convolution2D(128, 256, 4, 2, 1),
                l8l = L.Linear(None, 2, wscale=0.02*math.sqrt(8*8*256)),

                bnc1 = L.BatchNormalization(32),
                bnc2 = L.BatchNormalization(32),
                bnc3 = L.BatchNormalization(64),
                bnc4 = L.BatchNormalization(64),
                bnc5 = L.BatchNormalization(128),
                bnc6 = L.BatchNormalization(128),
                bnc7 = L.BatchNormalization(256),
        )

    def calc(self,x, test = False):
        h = F.relu(self.bnc1(self.c1(x), test=test))
        h = F.relu(self.bnc2(self.c2(h), test=test))
        h = F.relu(self.bnc3(self.c3(h), test=test))
        h = F.relu(self.bnc4(self.c4(h), test=test))
        h = F.relu(self.bnc5(self.c5(h), test=test))
        h = F.relu(self.bnc6(self.c6(h), test=test))
        h = F.relu(self.bnc7(self.c7(h), test=test))
        return  self.l8l(h)