Caffe2 - Creazione della tua rete

In questa lezione imparerai a definire un file single layer neural network (NN)in Caffe2 ed eseguirlo su un set di dati generato casualmente. Scriveremo codice per rappresentare graficamente l'architettura di rete, input di stampa, output, pesi e valori di polarizzazione. Per capire questa lezione, devi avere familiarità conneural network architectures, suo terms e mathematics utilizzato in loro.

Architettura di rete

Consideriamo di voler costruire un NN a singolo strato come mostrato nella figura sotto -

Matematicamente, questa rete è rappresentata dal seguente codice Python:

Y = X * W^T + b

Dove X, W, b sono tensori e Yè l'output. Riempiremo tutti e tre i tensori con alcuni dati casuali, eseguiremo la rete ed esamineremo il fileYproduzione. Per definire la rete e i tensori, Caffe2 ne fornisce diversiOperator funzioni.

Operatori Caffe2

In Caffe2, Operatorè l'unità di calcolo di base. Il Caffe2Operator è rappresentato come segue.

Caffe2 fornisce un elenco esaustivo di operatori. Per la rete che stiamo progettando attualmente, utilizzeremo l'operatore chiamato FC, che calcola il risultato del passaggio di un vettore di inputX in una rete completamente connessa con una matrice di peso bidimensionale W e un vettore bias monodimensionale b. In altre parole, calcola la seguente equazione matematica

Y = X * W^T + b

Dove X ha dimensioni (M x k), W ha dimensioni (n x k) e b è (1 x n). Il risultatoY sarà di dimensione (M x n), dove M è la dimensione del batch.

Per i vettori X e W, useremo il GaussianFilloperatore per creare alcuni dati casuali. Per generare valori di biasb, noi useremo ConstantFill operatore.

Procederemo ora a definire la nostra rete.

Creazione di rete

Prima di tutto, importa i pacchetti richiesti -

from caffe2.python import core, workspace

Quindi, definire la rete chiamando core.Net come segue -

net = core.Net("SingleLayerFC")

Il nome della rete è specificato come SingleLayerFC. A questo punto, viene creato l'oggetto di rete denominato net. Finora non contiene alcun livello.

Creazione di tensori

Creeremo ora i tre vettori richiesti dalla nostra rete. Innanzitutto, creeremo il tensore X chiamandoGaussianFill operatore come segue -

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

Il X il vettore ha dimensioni 2 x 3 con il valore medio dei dati di 0,0 e la deviazione standard di 1.0.

Allo stesso modo, creiamo W tensore come segue -

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

Il W il vettore è di dimensioni 5 x 3.

Infine, creiamo pregiudizi b matrice di dimensione 5.

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

Ora, arriva la parte più importante del codice e questa è la definizione della rete stessa.

Definizione di rete

Definiamo la rete nella seguente istruzione Python:

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

Noi chiamiamo FC operatore sui dati di input X. I pesi sono specificati inWe bias in b. L'output èY. In alternativa, puoi creare la rete utilizzando la seguente istruzione Python, che è più dettagliata.

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

A questo punto, la rete viene semplicemente creata. Fino a quando non eseguiremo la rete almeno una volta, non conterrà alcun dato. Prima di eseguire la rete, esamineremo la sua architettura.

Architettura di rete di stampa

Caffe2 definisce l'architettura di rete in un file JSON, che può essere esaminato chiamando il metodo Proto sul file net oggetto.

print (net.Proto())

Questo produce il seguente output:

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"
}

Come puoi vedere nell'elenco sopra, definisce prima gli operatori X, W e b. Esaminiamo la definizione diWcome esempio. Il tipo diW è specificato come GausianFill. Ilmean è definito come float 0.0, la deviazione standard è definita float 1.0, e il shape è 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
   }
   ...
}

Esamina le definizioni di X e bper la tua comprensione. Infine, esaminiamo la definizione della nostra rete a strato singolo, che viene riprodotta qui

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

Qui, il tipo di rete è FC (Completamente connesso) con X, W, b come input e Yè l'output. Questa definizione di rete è troppo prolissa e per reti di grandi dimensioni diventerà noioso esaminarne il contenuto. Fortunatamente, Caffe2 fornisce una rappresentazione grafica delle reti create.

Rappresentazione grafica di rete

Per ottenere la rappresentazione grafica della rete, eseguire il seguente frammento di codice, che è essenzialmente solo due righe di codice Python.

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

Quando esegui il codice, vedrai il seguente output:

Per reti di grandi dimensioni, la rappresentazione grafica diventa estremamente utile per visualizzare ed eseguire il debug degli errori di definizione della rete.

Infine, è ora il momento di eseguire la rete.

Rete in esecuzione

Gestisci la rete chiamando il RunNetOnce metodo sul workspace oggetto -

workspace.RunNetOnce(net)

Dopo che la rete è stata eseguita una volta, tutti i nostri dati generati a caso verranno creati, inseriti nella rete e verrà creato l'output. Vengono chiamati i tensori che vengono creati dopo aver eseguito la reteblobsin Caffe2. L'area di lavoro è costituita dablobscreate e archiviate in memoria. Questo è abbastanza simile a Matlab.

Dopo aver eseguito la rete, puoi esaminare il file blobs che l'area di lavoro contiene utilizzando quanto segue print comando

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

Vedrai il seguente output:

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

Si noti che l'area di lavoro è composta da tre BLOB di input: X, W e b. Contiene anche il BLOB di output chiamatoY. Esaminiamo ora il contenuto di questi blob.

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