PyTorch - Jaringan Neural Konvolusional

Pembelajaran mendalam adalah divisi pembelajaran mesin dan dianggap sebagai langkah penting yang diambil oleh para peneliti dalam beberapa dekade terakhir. Contoh implementasi pembelajaran mendalam mencakup aplikasi seperti pengenalan gambar dan pengenalan suara.

Dua jenis jaringan neural dalam yang penting diberikan di bawah ini -

  • Jaringan Neural Konvolusional
  • Jaringan Neural Berulang.

Pada bab ini, kita akan fokus pada tipe pertama yaitu Convolutional Neural Networks (CNN).

Jaringan Neural Konvolusional

Jaringan Neural Konvolusional dirancang untuk memproses data melalui beberapa lapisan array. Jenis jaringan saraf ini digunakan dalam aplikasi seperti pengenalan gambar atau pengenalan wajah.

Perbedaan utama antara CNN dan jaringan saraf biasa lainnya adalah bahwa CNN mengambil masukan sebagai larik dua dimensi dan beroperasi secara langsung pada gambar daripada berfokus pada ekstraksi fitur yang menjadi fokus jaringan saraf lain.

Pendekatan dominan CNN mencakup solusi untuk masalah pengenalan. Perusahaan top seperti Google dan Facebook telah berinvestasi dalam proyek penelitian dan pengembangan proyek pengakuan untuk menyelesaikan aktivitas dengan kecepatan yang lebih tinggi.

Setiap jaringan saraf konvolusional mencakup tiga ide dasar -

  • Bidang masing-masing lokal
  • Convolution
  • Pooling

Mari kita pahami masing-masing terminologi ini secara rinci.

Bidang Respektif Lokal

CNN memanfaatkan korelasi spasial yang ada dalam data masukan. Masing-masing di lapisan jaringan saraf bersamaan menghubungkan beberapa neuron masukan. Wilayah khusus ini disebut Bidang Penerimaan Lokal. Ini hanya berfokus pada neuron tersembunyi. Neuron tersembunyi akan memproses data masukan di dalam bidang tersebut tanpa menyadari perubahan di luar batas tertentu.

Representasi diagram untuk menghasilkan bidang masing-masing lokal disebutkan di bawah ini -

Lilitan

Pada gambar di atas, kami mengamati bahwa setiap koneksi mempelajari bobot neuron tersembunyi dengan koneksi terkait dengan pergerakan dari satu lapisan ke lapisan lainnya. Di sini, neuron individu melakukan pergeseran dari waktu ke waktu. Proses ini disebut "konvolusi".

Pemetaan koneksi dari lapisan masukan ke peta fitur tersembunyi didefinisikan sebagai "bobot bersama" dan bias yang disertakan disebut "bias bersama".

Pooling

Jaringan neural konvolusional menggunakan lapisan penggabungan yang ditempatkan segera setelah deklarasi CNN. Ini mengambil masukan dari pengguna sebagai peta fitur yang keluar dari jaringan konvolusional dan menyiapkan peta fitur yang dipadatkan. Pooling layer membantu dalam membuat lapisan dengan neuron dari lapisan sebelumnya.

Implementasi PyTorch

Langkah-langkah berikut digunakan untuk membuat Jaringan Neural Konvolusional menggunakan PyTorch.

Langkah 1

Impor paket yang diperlukan untuk membuat jaringan neural sederhana.

from torch.autograd import Variable
import torch.nn.functional as F

Langkah 2

Buat kelas dengan representasi batch jaringan neural konvolusional. Bentuk batch kita untuk input x adalah dengan dimensi (3, 32, 32).

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

LANGKAH 3

Hitung aktivasi perubahan ukuran konvolusi pertama dari (3, 32, 32) menjadi (18, 32, 32).

Ukuran dimensi berubah dari (18, 32, 32) menjadi (18, 16, 16). Bentuk kembali dimensi data dari lapisan masukan jaringan saraf karena ukurannya berubah dari (18, 16, 16) menjadi (1, 4608).

Ingatlah bahwa -1 menyimpulkan dimensi ini dari dimensi lain yang diberikan.

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)