Caffe2 - Panduan Cepat

Beberapa tahun terakhir, Pembelajaran Mendalam telah menjadi tren besar dalam Pembelajaran Mesin. Ini telah berhasil diterapkan untuk menyelesaikan masalah yang sebelumnya tidak terpecahkan di Vision, Speech Recognition and Natural Language Processing(NLP). Masih banyak lagi domain tempat Deep Learning diterapkan dan telah menunjukkan kegunaannya.

Caffe (Convolutional Architecture for Fast Feature Embedding) adalah kerangka pembelajaran mendalam yang dikembangkan di Berkeley Vision and Learning Center (BVLC). Proyek Caffe diciptakan oleh Yangqing Jia selama gelar Ph.D. di University of California - Berkeley. Caffe menyediakan cara mudah untuk bereksperimen dengan deep learning. Ini ditulis dalam C ++ dan menyediakan binding untukPython dan Matlab.

Ini mendukung berbagai jenis arsitektur pembelajaran mendalam seperti CNN (Jaringan Neural Konvolusional), LSTM(Memori Jangka Pendek Panjang) dan FC (Terhubung Penuh). Ini mendukung GPU dan karenanya, cocok untuk lingkungan produksi yang melibatkan jaringan neural dalam. Ini juga mendukung pustaka kernel berbasis CPU sepertiNVIDIA, Pustaka CUDA Deep Neural Network (cuDNN) dan Intel Math Kernel Library (Intel MKL).

Pada April 2017, perusahaan layanan jejaring sosial yang berbasis di AS Facebook mengumumkan Caffe2, yang sekarang menyertakan RNN (Recurrent Neural Networks) dan pada Maret 2018, Caffe2 digabungkan menjadi PyTorch. Pencipta Caffe2 dan anggota komunitas telah menciptakan model untuk memecahkan berbagai masalah. Model ini tersedia untuk umum sebagai model terlatih. Caffe2 membantu pembuat dalam menggunakan model ini dan membuat jaringan sendiri untuk membuat prediksi pada kumpulan data.

Sebelum kita membahas detail Caffe2, mari kita pahami perbedaannya machine learning dan deep learning. Ini diperlukan untuk memahami bagaimana model dibuat dan digunakan di Caffe2.

Pembelajaran Mesin v / s Deep Learning

Dalam algoritme pembelajaran mesin apa pun, baik algoritme tradisional maupun pembelajaran mendalam, pemilihan fitur dalam kumpulan data memainkan peran yang sangat penting dalam mendapatkan akurasi prediksi yang diinginkan. Dalam teknik pembelajaran mesin tradisional, filefeature selectionsebagian besar dilakukan dengan inspeksi manusia, penilaian dan pengetahuan domain yang mendalam. Terkadang, Anda mungkin mencari bantuan dari beberapa algoritme yang diuji untuk pemilihan fitur.

Alur pembelajaran mesin tradisional digambarkan pada gambar di bawah -

Dalam pembelajaran mendalam, pemilihan fitur dilakukan secara otomatis dan merupakan bagian dari algoritma pembelajaran mendalam itu sendiri. Ini ditunjukkan pada gambar di bawah -

Dalam algoritma pembelajaran mendalam, feature engineeringdilakukan secara otomatis. Secara umum, rekayasa fitur memakan waktu dan membutuhkan keahlian yang baik dalam domain. Untuk menerapkan ekstraksi fitur otomatis, algoritme pembelajaran mendalam biasanya meminta sejumlah besar data, jadi jika Anda hanya memiliki ribuan dan puluhan ribu titik data, teknik pembelajaran mendalam mungkin gagal memberikan hasil yang memuaskan.

Dengan data yang lebih besar, algoritme pembelajaran mendalam menghasilkan hasil yang lebih baik dibandingkan dengan algoritme ML tradisional dengan keuntungan tambahan berupa sedikit atau tanpa rekayasa fitur.

Sekarang, karena Anda telah mendapatkan beberapa wawasan tentang pembelajaran mendalam, mari kita lihat gambaran umum tentang apa itu Caffe.

Melatih CNN

Mari kita pelajari proses melatih CNN untuk mengklasifikasikan gambar. Prosesnya terdiri dari langkah-langkah berikut -

  • Data Preparation- Dalam langkah ini, kami memangkas gambar di tengah dan mengubah ukurannya sehingga semua gambar untuk pelatihan dan pengujian memiliki ukuran yang sama. Ini biasanya dilakukan dengan menjalankan skrip Python kecil pada data gambar.

  • Model Definition- Pada langkah ini, kami mendefinisikan arsitektur CNN. Konfigurasi disimpan di.pb (protobuf)mengajukan. Arsitektur CNN yang khas ditunjukkan pada gambar di bawah ini.

  • Solver Definition- Kami mendefinisikan file konfigurasi solver. Solver melakukan pengoptimalan model.

  • Model Training- Kami menggunakan utilitas Caffe bawaan untuk melatih model. Pelatihan mungkin memakan banyak waktu dan penggunaan CPU. Setelah pelatihan selesai, Caffe menyimpan model dalam file, yang nantinya dapat digunakan pada data pengujian dan penerapan akhir untuk prediksi.

Apa yang Baru di Caffe2

Di Caffe2, Anda akan menemukan banyak model terlatih yang siap digunakan dan juga cukup sering memanfaatkan kontribusi komunitas dari model dan algoritme baru. Model yang Anda buat dapat ditingkatkan dengan mudah menggunakan kekuatan GPU di cloud dan juga dapat digunakan secara massal di seluler dengan pustaka lintas platformnya.

Perbaikan yang dilakukan di Caffe2 atas Caffe dapat diringkas sebagai berikut -

  • Penerapan seluler
  • Dukungan perangkat keras baru
  • Dukungan untuk pelatihan terdistribusi skala besar
  • Perhitungan terkuantisasi
  • Stres diuji di Facebook

Demo Model Terlatih

Situs Berkeley Vision and Learning Center (BVLC) menyediakan demo jaringan terlatih mereka. Salah satu jaringan untuk klasifikasi citra tersebut tersedia di tautan yang disebutkan di sinihttps://caffe2.ai/docs/learn-more#null__caffe-neural-network-for-image-classification dan digambarkan pada gambar di bawah.

Pada tangkapan layar, gambar seekor anjing diklasifikasikan dan diberi label dengan akurasi prediksinya. Ia juga mengatakan bahwa itu hanya butuh0.068 secondsuntuk mengklasifikasikan gambar. Anda dapat mencoba gambar pilihan Anda sendiri dengan menentukan URL gambar atau mengunggah gambar itu sendiri dalam opsi yang diberikan di bagian bawah layar.

Sekarang, setelah Anda mendapatkan cukup wawasan tentang kapabilitas Caffe2, sekarang saatnya untuk bereksperimen sendiri dengan Caffe2. Untuk menggunakan model yang telah dilatih sebelumnya atau untuk mengembangkan model Anda dalam kode Python Anda sendiri, Anda harus menginstal Caffe2 di komputer Anda terlebih dahulu.

Di halaman instalasi situs Caffe2 yang tersedia di link https://caffe2.ai/docs/getting-started.html Anda akan melihat yang berikut ini untuk memilih platform Anda dan jenis pemasangan.

Seperti yang Anda lihat pada gambar di atas, Caffe2 mendukung beberapa platform populer termasuk yang seluler.

Sekarang, kita akan memahami langkah-langkahnya MacOS installation di mana semua proyek dalam tutorial ini diuji.

Instalasi MacOS

Instalasi dapat terdiri dari empat jenis seperti yang diberikan di bawah ini -

  • Binari yang Dibangun Sebelumnya
  • Bangun Dari Sumber
  • Gambar Docker
  • Cloud

Tergantung pada preferensi Anda, pilih salah satu di atas sebagai jenis instalasi Anda. Instruksi yang diberikan di sini sesuai dengan situs instalasi Caffe2 untukpre-built binaries. Ini menggunakan Anaconda untukJupyter environment. Jalankan perintah berikut pada prompt konsol Anda

pip install torch_nightly -f 
https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html

Selain yang di atas, Anda memerlukan beberapa pustaka pihak ketiga, yang diinstal menggunakan perintah berikut -

conda install -c anaconda setuptools
conda install -c conda-forge graphviz  
conda install -c conda-forge hypothesis
conda install -c conda-forge ipython
conda install -c conda-forge jupyter
conda install -c conda-forge matplotlib
conda install -c anaconda notebook
conda install -c anaconda pydot
conda install -c conda-forge python-nvd3
conda install -c anaconda pyyaml
conda install -c anaconda requests
conda install -c anaconda scikit-image
conda install -c anaconda scipy

Beberapa tutorial di situs web Caffe2 juga memerlukan penginstalan zeromq, yang diinstal menggunakan perintah berikut -

conda install -c anaconda zeromq

Instalasi Windows / Linux

Jalankan perintah berikut pada prompt konsol Anda -

conda install -c pytorch pytorch-nightly-cpu

Seperti yang Anda ketahui, Anda membutuhkan Anaconda untuk menggunakan instalasi di atas. Anda perlu menginstal paket tambahan seperti yang ditentukan diMacOS installation.

Menguji Instalasi

Untuk menguji instalasi Anda, skrip Python kecil diberikan di bawah ini, yang dapat Anda potong dan tempel di proyek Juypter Anda dan jalankan.

from caffe2.python import workspace
import numpy as np
print ("Creating random data")
data = np.random.rand(3, 2)
print(data)
print ("Adding data to workspace ...")
workspace.FeedBlob("mydata", data)
print ("Retrieving data from workspace")
mydata = workspace.FetchBlob("mydata")
print(mydata)

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

Creating random data
[[0.06152718 0.86448082]
[0.36409966 0.52786113]
[0.65780886 0.67101053]]
Adding data to workspace ...
Retrieving data from workspace
[[0.06152718 0.86448082]
[0.36409966 0.52786113]
[0.65780886 0.67101053]]

Tangkapan layar dari halaman uji penginstalan ditampilkan di sini untuk referensi cepat Anda -

Sekarang, setelah Anda menginstal Caffe2 di komputer Anda, lanjutkan untuk menginstal aplikasi tutorial.

Instalasi Tutorial

Unduh sumber tutorial menggunakan perintah berikut di konsol Anda -

git clone --recursive https://github.com/caffe2/tutorials caffe2_tutorials

Setelah pengunduhan selesai, Anda akan menemukan beberapa proyek Python di file caffe2_tutorialsfolder di direktori instalasi Anda. Tangkapan layar dari folder ini diberikan untuk pembacaan cepat Anda.

/Users/yourusername/caffe2_tutorials

Anda bisa membuka beberapa tutorial ini untuk melihat apa itu Caffe2 codeseperti. Dua proyek berikutnya yang dijelaskan dalam tutorial ini sebagian besar didasarkan pada contoh yang ditunjukkan di atas.

Sekarang saatnya untuk melakukan pengkodean Python kita sendiri. Mari kita pahami, cara menggunakan model terlatih dari Caffe2. Nanti, Anda akan belajar membuat jaringan neural trivial Anda sendiri untuk melatih kumpulan data Anda sendiri.

Sebelum Anda belajar menggunakan model yang telah dilatih sebelumnya dalam aplikasi Python Anda, mari kita verifikasi terlebih dahulu bahwa model tersebut diinstal pada mesin Anda dan dapat diakses melalui kode Python.

Saat Anda menginstal Caffe2, model terlatih disalin di folder instalasi. Pada mesin dengan penginstalan Anaconda, model ini tersedia di folder berikut.

anaconda3/lib/python3.7/site-packages/caffe2/python/models

Lihat folder instalasi pada mesin Anda untuk mengetahui keberadaan model-model ini. Anda dapat mencoba memuat model ini dari folder instalasi dengan skrip singkat Python berikut -

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)

Ketika skrip berhasil dijalankan, Anda akan melihat output berikut -

/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/init_net.pb
/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/predict_net.pb

Ini menegaskan bahwa squeezenet modul diinstal pada mesin Anda dan dapat diakses oleh kode Anda.

Sekarang, Anda siap untuk menulis kode Python Anda sendiri untuk klasifikasi gambar menggunakan Caffe2 squeezenet modul terlatih.

Dalam pelajaran ini, Anda akan belajar menggunakan model terlatih untuk mendeteksi objek dalam gambar tertentu. Anda akan menggunakansqueezenet modul terlatih yang mendeteksi dan mengklasifikasikan objek dalam gambar tertentu dengan sangat akurat.

Buka yang baru Juypter notebook dan ikuti langkah-langkah untuk mengembangkan aplikasi klasifikasi gambar ini.

Mengimpor Perpustakaan

Pertama, kami mengimpor paket yang diperlukan menggunakan kode di bawah ini -

from caffe2.proto import caffe2_pb2
from caffe2.python import core, workspace, models
import numpy as np
import skimage.io
import skimage.transform
from matplotlib import pyplot
import os
import urllib.request as urllib2
import operator

Selanjutnya, kami menyiapkan beberapa variables -

INPUT_IMAGE_SIZE = 227
mean = 128

Gambar yang digunakan untuk pelatihan jelas akan memiliki ukuran yang bervariasi. Semua gambar ini harus diubah menjadi ukuran tetap untuk pelatihan yang akurat. Demikian pula, gambar uji dan gambar yang ingin Anda prediksi di lingkungan produksi juga harus dikonversi ke ukurannya, sama dengan yang digunakan selama pelatihan. Jadi, kami membuat variabel di atas disebutINPUT_IMAGE_SIZE memiliki nilai 227. Karenanya, kami akan mengonversi semua gambar kami ke ukuran227x227 sebelum menggunakannya di classifier kami.

Kami juga mendeklarasikan variabel yang disebut mean memiliki nilai 128, yang nantinya digunakan untuk meningkatkan hasil klasifikasi.

Selanjutnya, kami akan mengembangkan dua fungsi untuk memproses gambar.

Pengolahan citra

Pemrosesan gambar terdiri dari dua langkah. Yang pertama adalah mengubah ukuran gambar, dan yang kedua adalah memotong gambar secara terpusat. Untuk kedua langkah ini, kami akan menulis dua fungsi untuk mengubah ukuran dan memotong.

Mengubah Ukuran Gambar

Pertama, kita akan menulis fungsi untuk mengubah ukuran gambar. Seperti yang dikatakan sebelumnya, kami akan mengubah ukuran gambar menjadi227x227. Jadi mari kita definisikan fungsinyaresize sebagai berikut -

def resize(img, input_height, input_width):

Kami mendapatkan rasio aspek gambar dengan membagi lebar dengan tinggi.

original_aspect = img.shape[1]/float(img.shape[0])

Jika rasio aspek lebih besar dari 1, ini menunjukkan bahwa gambar tersebut lebar, artinya dalam mode lanskap. Kami sekarang menyesuaikan tinggi gambar dan mengembalikan gambar yang diubah ukurannya menggunakan kode berikut -

if(original_aspect>1):
   new_height = int(original_aspect * input_height)
   return skimage.transform.resize(img, (input_width,
   new_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Jika rasio aspeknya less than 1, ini menunjukkan portrait mode. Kami sekarang menyesuaikan lebar menggunakan kode berikut -

if(original_aspect<1):
   new_width = int(input_width/original_aspect)
   return skimage.transform.resize(img, (new_width,
   input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Jika rasio aspek sama 1, kami tidak melakukan penyesuaian tinggi / lebar.

if(original_aspect == 1):
   return skimage.transform.resize(img, (input_width,
   input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Kode fungsi lengkap diberikan di bawah ini untuk referensi cepat Anda -

def resize(img, input_height, input_width):
   original_aspect = img.shape[1]/float(img.shape[0])
   if(original_aspect>1):
      new_height = int(original_aspect * input_height)
      return skimage.transform.resize(img, (input_width,
	   new_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)
   if(original_aspect<1):
         new_width = int(input_width/original_aspect)
         return skimage.transform.resize(img, (new_width,
         input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)
   if(original_aspect == 1):
         return skimage.transform.resize(img, (input_width,
         input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Kami sekarang akan menulis fungsi untuk memotong gambar di sekitar pusatnya.

Pemotongan Gambar

Kami mendeklarasikan crop_image berfungsi sebagai berikut -

def crop_image(img,cropx,cropy):

Kami mengekstrak dimensi gambar menggunakan pernyataan berikut -

y,x,c = img.shape

Kami membuat titik awal baru untuk gambar menggunakan dua baris kode berikut -

startx = x//2-(cropx//2)
starty = y//2-(cropy//2)

Akhirnya, kami mengembalikan gambar yang dipotong dengan membuat objek gambar dengan dimensi baru -

return img[starty:starty+cropy,startx:startx+cropx]

Seluruh kode fungsi diberikan di bawah ini untuk referensi cepat Anda -

def crop_image(img,cropx,cropy):
   y,x,c = img.shape
   startx = x//2-(cropx//2)
   starty = y//2-(cropy//2)
   return img[starty:starty+cropy,startx:startx+cropx]

Sekarang, kami akan menulis kode untuk menguji fungsi-fungsi ini.

Memproses Gambar

Pertama, salin file gambar ke images subfolder dalam direktori proyek Anda. tree.jpgfile disalin dalam proyek. Kode Python berikut memuat gambar dan menampilkannya di konsol -

img = skimage.img_as_float(skimage.io.imread("images/tree.jpg")).astype(np.float32)
print("Original Image Shape: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Original image')

Outputnya adalah sebagai berikut -

Perhatikan bahwa ukuran gambar aslinya adalah 600 x 960. Kami perlu mengubah ukurannya menjadi spesifikasi kami227 x 227. Memanggil kami yang didefinisikan sebelumnyaresizefungsi melakukan pekerjaan ini.

img = resize(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after resizing: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Resized image')

Outputnya seperti yang diberikan di bawah ini -

Perhatikan bahwa sekarang ukuran gambar adalah 227 x 363. Kita perlu memotong ini227 x 227untuk umpan terakhir bagi algoritme kami. Kami memanggil fungsi tanaman yang telah ditentukan sebelumnya untuk tujuan ini.

img = crop_image(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after cropping: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Center Cropped')

Di bawah ini disebutkan adalah output dari kode -

Pada titik ini, gambar berukuran besar 227 x 227dan siap untuk diproses lebih lanjut. Kami sekarang menukar sumbu gambar untuk mengekstrak tiga warna menjadi tiga zona berbeda.

img = img.swapaxes(1, 2).swapaxes(0, 1)
print("CHW Image Shape: " , img.shape)

Diberikan di bawah ini adalah output -

CHW Image Shape: (3, 227, 227)

Perhatikan bahwa sumbu terakhir sekarang menjadi dimensi pertama dalam larik. Kami sekarang akan memplot tiga saluran menggunakan kode berikut -

pyplot.figure()
for i in range(3):
   pyplot.subplot(1, 3, i+1)
   pyplot.imshow(img[i])
   pyplot.axis('off')
   pyplot.title('RGB channel %d' % (i+1))

Outputnya dinyatakan di bawah ini -

Akhirnya, kami melakukan beberapa pemrosesan tambahan pada gambar seperti mengonversi Red Green Blue untuk Blue Green Red (RGB to BGR), menghapus mean untuk hasil yang lebih baik dan menambahkan sumbu ukuran batch menggunakan tiga baris kode berikut -

# convert RGB --> BGR
img = img[(2, 1, 0), :, :]
# remove mean
img = img * 255 - mean
# add batch size axis
img = img[np.newaxis, :, :, :].astype(np.float32)

Pada titik ini, gambar Anda sudah masuk NCHW formatdan siap untuk dimasukkan ke dalam jaringan kami. Selanjutnya, kami akan memuat file model terlatih kami dan memasukkan gambar di atas ke dalamnya untuk prediksi.

Memprediksi Objek dalam Gambar Olahan

Kami pertama-tama menyiapkan jalur untuk file init dan predict jaringan yang ditentukan dalam model Caffe terlatih.

Mengatur Jalur File Model

Ingat dari diskusi kita sebelumnya, semua model terlatih dipasang di modelsmap. Kami mengatur jalur ke folder ini sebagai berikut -

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")

Kami menyiapkan jalur ke init_net protobuf dari file squeezenet model sebagai berikut -

INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')

Demikian juga, kami menyiapkan jalur ke predict_net protobuf sebagai berikut -

PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')

Kami mencetak dua jalur untuk tujuan diagnosis -

print(INIT_NET)
print(PREDICT_NET)

Kode di atas bersama dengan hasilnya diberikan di sini untuk referensi cepat Anda -

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)

Outputnya disebutkan di bawah ini -

/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/init_net.pb
/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/predict_net.pb

Selanjutnya, kami akan membuat prediktor.

Membuat Predictor

Kami membaca file model menggunakan dua pernyataan berikut -

with open(INIT_NET, "rb") as f:
   init_net = f.read()
with open(PREDICT_NET, "rb") as f:
   predict_net = f.read()

Prediktor dibuat dengan meneruskan pointer ke dua file sebagai parameter ke Predictor fungsi.

p = workspace.Predictor(init_net, predict_net)

Itu pobjek adalah prediktor, yang digunakan untuk memprediksi objek dalam gambar tertentu. Perhatikan bahwa setiap gambar masukan harus dalam format NCHW seperti yang telah kita lakukan sebelumnyatree.jpg mengajukan.

Memprediksi Objek

Untuk memprediksi objek dalam gambar tertentu itu sepele - hanya menjalankan satu baris perintah. Kami memanggilrun metode di predictor objek untuk deteksi objek dalam gambar tertentu.

results = p.run({'data': img})

Hasil prediksi sekarang tersedia di results objek, yang kami ubah menjadi larik agar mudah dibaca.

results = np.asarray(results)

Cetak dimensi larik untuk pemahaman Anda menggunakan pernyataan berikut -

print("results shape: ", results.shape)

Outputnya seperti yang ditunjukkan di bawah ini -

results shape: (1, 1, 1000, 1, 1)

Kami sekarang akan menghapus sumbu yang tidak perlu -

preds = np.squeeze(results)

Predikasi teratas sekarang dapat diambil dengan mengambil max nilai dalam preds Himpunan.

curr_pred, curr_conf = max(enumerate(preds), key=operator.itemgetter(1))
print("Prediction: ", curr_pred)
print("Confidence: ", curr_conf)

Outputnya adalah sebagai berikut -

Prediction: 984
Confidence: 0.89235985

Seperti yang Anda lihat, model telah memprediksi objek dengan nilai indeks 984 dengan 89%kepercayaan. Indeks 984 tidak terlalu masuk akal bagi kami dalam memahami jenis objek yang terdeteksi. Kita perlu mendapatkan nama yang dirangkai untuk objek tersebut menggunakan nilai indeksnya. Jenis objek yang dikenali model beserta nilai indeksnya yang sesuai tersedia di repositori github.

Sekarang, kita akan melihat bagaimana mengambil nama untuk objek kita yang memiliki nilai indeks 984.

Hasil Merangkai

Kami membuat objek URL ke repositori github sebagai berikut -

codes = "https://gist.githubusercontent.com/aaronmarkham/cd3a6b6ac0
71eca6f7b4a6e40e6038aa/raw/9edb4038a37da6b5a44c3b5bc52e448ff09bfe5b/alexnet_codes"

Kami membaca konten URL -

response = urllib2.urlopen(codes)

Tanggapan akan berisi daftar semua kode dan deskripsinya. Beberapa baris tanggapan ditampilkan di bawah ini untuk pemahaman Anda tentang isinya -

5: 'electric ray, crampfish, numbfish, torpedo',
6: 'stingray',
7: 'cock',
8: 'hen',
9: 'ostrich, Struthio camelus',
10: 'brambling, Fringilla montifringilla',

Kami sekarang mengulangi seluruh larik untuk menemukan kode yang kami inginkan dari 984 menggunakan file for loop sebagai berikut -

for line in response:
   mystring = line.decode('ascii')
   code, result = mystring.partition(":")[::2]
   code = code.strip()
   result = result.replace("'", "")
   if (code == str(curr_pred)):
      name = result.split(",")[0][1:]
      print("Model predicts", name, "with", curr_conf, "confidence")

Saat Anda menjalankan kode, Anda akan melihat output berikut -

Model predicts rapeseed with 0.89235985 confidence

Sekarang Anda dapat mencoba model pada gambar lain.

Memprediksi Gambar yang Berbeda

Untuk memprediksi gambar lain, cukup salin file gambar ke dalam imagesfolder dari direktori proyek Anda. Ini adalah direktori tempat kami sebelumnyatree.jpgfile disimpan. Ubah nama file gambar di kode. Hanya satu perubahan yang diperlukan seperti yang ditunjukkan di bawah ini

img = skimage.img_as_float(skimage.io.imread("images/pretzel.jpg")).astype(np.float32)

Gambar asli dan hasil prediksi ditunjukkan di bawah ini -

Outputnya disebutkan di bawah ini -

Model predicts pretzel with 0.99999976 confidence

Seperti yang Anda lihat, model terlatih mampu mendeteksi objek dalam gambar tertentu dengan sangat akurat.

Sumber Penuh

Sumber lengkap kode di atas yang menggunakan model terlatih untuk deteksi objek dalam gambar tertentu disebutkan di sini untuk referensi cepat Anda -

def crop_image(img,cropx,cropy):
   y,x,c = img.shape
   startx = x//2-(cropx//2)
   starty = y//2-(cropy//2)
   return img[starty:starty+cropy,startx:startx+cropx]
img = skimage.img_as_float(skimage.io.imread("images/pretzel.jpg")).astype(np.float32)
print("Original Image Shape: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Original image')
img = resize(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after resizing: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Resized image')
img = crop_image(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after cropping: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Center Cropped')
img = img.swapaxes(1, 2).swapaxes(0, 1)
print("CHW Image Shape: " , img.shape)
pyplot.figure()
for i in range(3):
pyplot.subplot(1, 3, i+1)
pyplot.imshow(img[i])
pyplot.axis('off')
pyplot.title('RGB channel %d' % (i+1))
# convert RGB --> BGR
img = img[(2, 1, 0), :, :]
# remove mean
img = img * 255 - mean
# add batch size axis
img = img[np.newaxis, :, :, :].astype(np.float32)
CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)
with open(INIT_NET, "rb") as f:
   init_net = f.read()
with open(PREDICT_NET, "rb") as f:
   predict_net = f.read()
p = workspace.Predictor(init_net, predict_net)
results = p.run({'data': img})
results = np.asarray(results)
print("results shape: ", results.shape)
preds = np.squeeze(results)
curr_pred, curr_conf = max(enumerate(preds), key=operator.itemgetter(1))
print("Prediction: ", curr_pred)
print("Confidence: ", curr_conf)
codes = "https://gist.githubusercontent.com/aaronmarkham/cd3a6b6ac071eca6f7b4a6e40e6038aa/raw/9edb4038a37da6b5a44c3b5bc52e448ff09bfe5b/alexnet_codes"
response = urllib2.urlopen(codes)
for line in response:
   mystring = line.decode('ascii')
   code, result = mystring.partition(":")[::2]
   code = code.strip()
   result = result.replace("'", "")
   if (code == str(curr_pred)):
      name = result.split(",")[0][1:]
      print("Model predicts", name, "with", curr_conf, "confidence")

Saat ini, Anda sudah tahu cara menggunakan model terlatih untuk melakukan prediksi pada kumpulan data Anda.

Selanjutnya adalah mempelajari cara mendefinisikan file neural network (NN) arsitektur di Caffe2dan latih mereka di kumpulan data Anda. Sekarang kita akan belajar cara membuat NN layer tunggal yang sepele.

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.

Pada pelajaran sebelumnya, Anda belajar membuat jaringan yang sepele dan mempelajari cara menjalankannya serta memeriksa keluarannya. Proses untuk membuat jaringan yang kompleks mirip dengan proses yang dijelaskan di atas. Caffe2 menyediakan sejumlah besar operator untuk membuat arsitektur yang kompleks. Anda didorong untuk memeriksa dokumentasi Caffe2 untuk mengetahui daftar operator. Setelah mempelajari tujuan berbagai operator, Anda akan berada dalam posisi untuk membuat jaringan yang kompleks dan melatihnya. Untuk melatih jaringan, Caffe2 menyediakan beberapapredefined computation units- itulah operatornya. Anda perlu memilih operator yang sesuai untuk melatih jaringan Anda untuk jenis masalah yang Anda coba selesaikan.

Setelah jaringan dilatih sesuai keinginan Anda, Anda dapat menyimpannya dalam file model yang mirip dengan file model terlatih yang Anda gunakan sebelumnya. Model terlatih ini dapat dikontribusikan ke repositori Caffe2 untuk keuntungan pengguna lain. Atau Anda dapat menggunakan model terlatih untuk penggunaan produksi pribadi Anda sendiri.

Ringkasan

Caffe2, yang merupakan kerangka kerja pembelajaran mendalam memungkinkan Anda bereksperimen dengan beberapa jenis jaringan neural untuk memprediksi data Anda. Situs Caffe2 menyediakan banyak model terlatih. Anda telah belajar menggunakan salah satu model terlatih untuk mengklasifikasikan objek dalam gambar tertentu. Anda juga belajar menentukan arsitektur jaringan saraf pilihan Anda. Jaringan khusus tersebut dapat dilatih menggunakan banyak operator yang telah ditentukan sebelumnya di Caffe. Model terlatih disimpan dalam file yang dapat dibawa ke lingkungan produksi.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved