Caffe2 - Membuat Jaringan Anda Sendiri

Dalam pelajaran ini, Anda akan belajar mendefinisikan a single layer neural network (NN)di Caffe2 dan menjalankannya pada kumpulan data yang dibuat secara acak. Kami akan menulis kode untuk menggambarkan arsitektur jaringan, mencetak input, output, bobot, dan nilai bias secara grafis. Untuk memahami pelajaran ini, Anda harus terbiasa dengannyaneural network architectures, itu terms dan mathematics digunakan di dalamnya.

Arsitektur jaringan

Mari kita pertimbangkan bahwa kita ingin membangun satu layer NN seperti yang ditunjukkan pada gambar di bawah ini -

Secara matematis, jaringan ini diwakili oleh kode Python berikut -

Y = X * W^T + b

Dimana X, W, b adalah tensor dan Yadalah hasilnya. Kami akan mengisi ketiga tensor dengan beberapa data acak, menjalankan jaringan dan memeriksaYkeluaran. Untuk menentukan jaringan dan tensor, Caffe2 menyediakan beberapaOperator fungsi.

Operator Caffe2

Di Caffe2, Operatoradalah unit dasar komputasi. The Caffe2Operator direpresentasikan sebagai berikut.

Caffe2 menyediakan daftar lengkap operator. Untuk jaringan yang kita rancang saat ini, kita akan menggunakan operator bernama FC, yang menghitung hasil dari melewatkan vektor inputX ke dalam jaringan yang terhubung sepenuhnya dengan matriks bobot dua dimensi W dan vektor bias satu dimensi b. Dengan kata lain, ia menghitung persamaan matematika berikut

Y = X * W^T + b

Dimana X memiliki dimensi (M x k), W memiliki dimensi (n x k) dan b adalah (1 x n). HasilY akan menjadi dimensi (M x n), dimana M adalah ukuran batch.

Untuk vektor X dan W, kami akan menggunakan GaussianFilloperator untuk membuat beberapa data acak. Untuk menghasilkan nilai biasb, kami akan menggunakan ConstantFill operator.

Kami sekarang akan melanjutkan untuk menentukan jaringan kami.

Membuat Jaringan

Pertama-tama, impor paket yang diperlukan -

from caffe2.python import core, workspace

Selanjutnya, tentukan jaringan dengan menelepon core.Net sebagai berikut -

net = core.Net("SingleLayerFC")

Nama jaringan ditentukan sebagai SingleLayerFC. Pada titik ini, objek jaringan yang disebut net dibuat. Sejauh ini tidak ada lapisan apa pun.

Membuat Tensor

Kami sekarang akan membuat tiga vektor yang dibutuhkan oleh jaringan kami. Pertama, kita akan membuat tensor X dengan memanggilGaussianFill operator sebagai berikut -

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

Itu X vektor memiliki dimensi 2 x 3 dengan nilai mean data 0,0 dan standar deviasi 1.0.

Demikian juga yang kita buat W tensor sebagai berikut -

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

Itu W vektor adalah ukuran 5 x 3.

Akhirnya, kami menciptakan bias b matriks ukuran 5.

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

Sekarang, sampai pada bagian terpenting dari kode dan itu mendefinisikan jaringan itu sendiri.

Mendefinisikan Jaringan

Kami mendefinisikan jaringan dalam pernyataan Python berikut -

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

Kami memanggil FC operator pada data masukan X. Bobot ditentukan dalamWdan bias di b. Outputnya adalahY. Atau, Anda dapat membuat jaringan menggunakan pernyataan Python berikut, yang lebih bertele-tele.

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

Pada titik ini, jaringan dibuat dengan mudah. Hingga kami menjalankan jaringan setidaknya sekali, itu tidak akan berisi data apa pun. Sebelum menjalankan jaringan, kita akan memeriksa arsitekturnya.

Arsitektur Jaringan Percetakan

Caffe2 mendefinisikan arsitektur jaringan dalam file JSON, yang dapat diperiksa dengan memanggil metode Proto pada file yang dibuat net obyek.

print (net.Proto())

Ini menghasilkan keluaran berikut -

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

Seperti yang Anda lihat pada daftar di atas, pertama kali mendefinisikan operator X, W dan b. Mari kita periksa definisiWsebagai contoh. Tipe dariW ditentukan sebagai GausianFill. Itumean didefinisikan sebagai float 0.0, deviasi standar didefinisikan sebagai float 1.0, dan shape adalah 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
   }
   ...
}

Perhatikan definisi dari X dan buntuk pemahaman Anda sendiri. Akhirnya, mari kita lihat definisi jaringan lapisan tunggal kita, yang direproduksi di sini

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

Di sini, jenis jaringannya adalah FC (Sepenuhnya Terhubung) dengan X, W, b sebagai masukan dan Yadalah hasilnya. Definisi jaringan ini terlalu panjang dan untuk jaringan besar, akan membosankan untuk memeriksa isinya. Untungnya, Caffe2 menyediakan representasi grafis untuk jaringan yang dibuat.

Representasi Grafis Jaringan

Untuk mendapatkan representasi grafis dari jaringan, jalankan potongan kode berikut, yang pada dasarnya hanya dua baris kode 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)

Saat Anda menjalankan kode, Anda akan melihat output berikut -

Untuk jaringan besar, representasi grafis menjadi sangat berguna dalam memvisualisasikan dan men-debug kesalahan definisi jaringan.

Akhirnya, sekarang saatnya menjalankan jaringan.

Menjalankan Jaringan

Anda menjalankan jaringan dengan memanggil RunNetOnce metode di workspace objek -

workspace.RunNetOnce(net)

Setelah jaringan dijalankan sekali, semua data kami yang dihasilkan secara acak akan dibuat, dimasukkan ke dalam jaringan dan hasilnya akan dibuat. Tensor yang dibuat setelah menjalankan jaringan dipanggilblobsdi Caffe2. Ruang kerja terdiri dariblobsAnda buat dan simpan dalam memori. Ini sangat mirip dengan Matlab.

Setelah menjalankan jaringan, Anda dapat memeriksa file blobs yang berisi ruang kerja menggunakan berikut ini print perintah

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

Anda akan melihat output berikut -

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

Perhatikan bahwa ruang kerja terdiri dari tiga blob masukan - X, W dan b. Ini juga berisi blob keluaran yang disebutY. Sekarang mari kita periksa isi dari gumpalan ini.

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

Anda akan melihat output berikut -

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.]

Perhatikan bahwa data pada mesin Anda atau faktanya pada setiap jalannya jaringan akan berbeda karena semua input dibuat secara acak. Anda sekarang telah berhasil menentukan jaringan dan menjalankannya di komputer Anda.