Caffe2 - Erstellen Sie Ihr eigenes Netzwerk

In dieser Lektion lernen Sie, a zu definieren single layer neural network (NN)in Caffe2 und führen Sie es auf einem zufällig generierten Datensatz aus. Wir werden Code schreiben, um die Netzwerkarchitektur, die Druckeingabe, die Ausgabe, die Gewichte und die Bias-Werte grafisch darzustellen. Um diese Lektion zu verstehen, müssen Sie mit vertraut seinneural network architectures, es ist terms und mathematics in ihnen verwendet.

Netzwerkarchitektur

Betrachten wir, dass wir eine einzelne Schicht NN bauen möchten, wie in der folgenden Abbildung gezeigt -

Mathematisch wird dieses Netzwerk durch den folgenden Python-Code dargestellt:

Y = X * W^T + b

Wo X, W, b sind Tensoren und Yist die Ausgabe. Wir werden alle drei Tensoren mit zufälligen Daten füllen, das Netzwerk betreiben und die untersuchenYAusgabe. Um das Netzwerk und die Tensoren zu definieren, bietet Caffe2 mehrereOperator Funktionen.

Caffe2-Betreiber

In Caffe2, Operatorist die Grundeinheit der Berechnung. Das Caffe2Operator wird wie folgt dargestellt.

Caffe2 bietet eine vollständige Liste der Betreiber. Für das Netzwerk, das wir derzeit entwerfen, verwenden wir den Operator FC, der das Ergebnis der Übergabe eines Eingabevektors berechnetX in ein vollständig verbundenes Netzwerk mit einer zweidimensionalen Gewichtsmatrix W und einen eindimensionalen Vorspannungsvektor b. Mit anderen Worten, es berechnet die folgende mathematische Gleichung

Y = X * W^T + b

Wo X hat Abmessungen (M x k), W hat Abmessungen (n x k) und b ist (1 x n). Die AusgabeY wird von Dimension sein (M x n), wo M ist die Chargengröße.

Für die Vektoren X und Wwerden wir die verwenden GaussianFillOperator, um einige zufällige Daten zu erstellen. Zur Erzeugung von Vorspannungswertenb, wir werden verwenden ConstantFill Operator.

Wir werden nun unser Netzwerk definieren.

Netzwerk erstellen

Importieren Sie zunächst die erforderlichen Pakete -

from caffe2.python import core, workspace

Definieren Sie als Nächstes das Netzwerk durch Aufrufen core.Net wie folgt -

net = core.Net("SingleLayerFC")

Der Name des Netzwerks wird als angegeben SingleLayerFC. Zu diesem Zeitpunkt wird das Netzwerkobjekt net erstellt. Es enthält bisher keine Schichten.

Tensoren erstellen

Wir werden nun die drei Vektoren erstellen, die von unserem Netzwerk benötigt werden. Zuerst erstellen wir einen X-Tensor durch AufrufenGaussianFill Betreiber wie folgt -

X = net.GaussianFill([], ["X"], mean=0.0, std=1.0, shape=[2, 3], run_once=0)

Das X Vektor hat Dimensionen 2 x 3 mit dem mittleren Datenwert von 0,0 und der Standardabweichung von 1.0.

Ebenso schaffen wir W Tensor wie folgt -

W = net.GaussianFill([], ["W"], mean=0.0, std=1.0, shape=[5, 3], run_once=0)

Das W Vektor ist von Größe 5 x 3.

Schließlich schaffen wir Voreingenommenheit b Matrix der Größe 5.

b = net.ConstantFill([], ["b"], shape=[5,], value=1.0, run_once=0)

Jetzt kommt der wichtigste Teil des Codes und das definiert das Netzwerk selbst.

Netzwerk definieren

Wir definieren das Netzwerk in der folgenden Python-Anweisung:

Y = X.FC([W, b], ["Y"])

Wir nennen FC Operator auf den Eingabedaten X. Die Gewichte sind in angegebenWund Voreingenommenheit in b. Die Ausgabe istY. Alternativ können Sie das Netzwerk mit der folgenden ausführlicheren Python-Anweisung erstellen.

Y = net.FC([X, W, b], ["Y"])

Zu diesem Zeitpunkt wird das Netzwerk einfach erstellt. Bis wir das Netzwerk mindestens einmal ausführen, enthält es keine Daten. Bevor wir das Netzwerk ausführen, werden wir seine Architektur untersuchen.

Netzwerkarchitektur drucken

Caffe2 definiert die Netzwerkarchitektur in einer JSON-Datei, die durch Aufrufen der Proto-Methode für die erstellte Datei überprüft werden kann net Objekt.

print (net.Proto())

Dies erzeugt die folgende Ausgabe -

name: "SingleLayerFC"
op {
   output: "X"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 2
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "W"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 5
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "b"
   name: ""
   type: "ConstantFill"
   arg {
      name: "shape"
      ints: 5
   }
   arg {
      name: "value"
      f: 1.0
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

Wie Sie in der obigen Auflistung sehen können, werden zuerst die Operatoren definiert X, W und b. Untersuchen wir die Definition vonWals Beispiel. Die Art vonW wird angegeben als GausianFill. Dasmean ist als float definiert 0.0wird die Standardabweichung als float definiert 1.0, und das shape ist 5 x 3.

op {
   output: "W"
   name: "" type: "GaussianFill"
   arg {
      name: "mean" 
	   f: 0.0
   }
   arg { 
      name: "std" 
      f: 1.0
   }
   arg { 
      name: "shape" 
      ints: 5 
      ints: 3
   }
   ...
}

Untersuchen Sie die Definitionen von X und bfür Ihr eigenes Verständnis. Lassen Sie uns abschließend die Definition unseres Single-Layer-Netzwerks betrachten, die hier wiedergegeben wird

op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

Hier ist der Netzwerktyp FC (Vollständig verbunden) mit X, W, b als Eingänge und Yist die Ausgabe. Diese Netzwerkdefinition ist zu ausführlich und für große Netzwerke wird es mühsam, ihren Inhalt zu untersuchen. Glücklicherweise bietet Caffe2 eine grafische Darstellung für die erstellten Netzwerke.

Grafische Darstellung des Netzwerks

Um die grafische Darstellung des Netzwerks zu erhalten, führen Sie das folgende Code-Snippet aus, das im Wesentlichen nur aus zwei Zeilen Python-Code besteht.

from caffe2.python import net_drawer
from IPython import display
graph = net_drawer.GetPydotGraph(net, rankdir="LR")
display.Image(graph.create_png(), width=800)

Wenn Sie den Code ausführen, wird die folgende Ausgabe angezeigt:

Bei großen Netzwerken ist die grafische Darstellung äußerst nützlich beim Visualisieren und Debuggen von Netzwerkdefinitionsfehlern.

Endlich ist es Zeit, das Netzwerk auszuführen.

Netzwerk ausführen

Sie führen das Netzwerk aus, indem Sie die RunNetOnce Methode auf der workspace Objekt -

workspace.RunNetOnce(net)

Nachdem das Netzwerk einmal ausgeführt wurde, werden alle unsere zufällig generierten Daten erstellt, in das Netzwerk eingespeist und die Ausgabe wird erstellt. Die Tensoren, die nach dem Ausführen des Netzwerks erstellt werden, werden aufgerufenblobsin Caffe2. Der Arbeitsbereich besteht aus demblobsSie erstellen und speichern im Speicher. Dies ist Matlab ziemlich ähnlich.

Nachdem Sie das Netzwerk ausgeführt haben, können Sie das überprüfen blobs dass der Arbeitsbereich Folgendes enthält print Befehl

print("Blobs in the workspace: {}".format(workspace.Blobs()))

Sie sehen die folgende Ausgabe -

Blobs in the workspace: ['W', 'X', 'Y', 'b']

Beachten Sie, dass der Arbeitsbereich aus drei Eingabeblobs besteht - X, W und b. Es enthält auch den aufgerufenen Ausgabe-BlobY. Lassen Sie uns nun den Inhalt dieser Blobs untersuchen.

for name in workspace.Blobs():
   print("{}:\n{}".format(name, workspace.FetchBlob(name)))

Sie sehen die folgende Ausgabe -

W:
[[ 1.0426593 0.15479846 0.25635982]
[-2.2461145 1.4581774 0.16827184]
[-0.12009818 0.30771437 0.00791338]
[ 1.2274994 -0.903331 -0.68799865]
[ 0.30834186 -0.53060573 0.88776857]]
X:
[[ 1.6588869e+00 1.5279824e+00 1.1889904e+00]
[ 6.7048723e-01 -9.7490678e-04 2.5114202e-01]]
Y:
[[ 3.2709925 -0.297907 1.2803618 0.837985 1.7562964]
[ 1.7633215 -0.4651525 0.9211631 1.6511179 1.4302125]]
b:
[1. 1. 1. 1. 1.]

Beachten Sie, dass die Daten auf Ihrem Computer oder tatsächlich bei jedem Lauf des Netzwerks unterschiedlich sind, da alle Eingaben zufällig erstellt werden. Sie haben jetzt erfolgreich ein Netzwerk definiert und auf Ihrem Computer ausgeführt.