Tutorial CNN PyTorch: Membangun dan Melatih Convolutional Neural Networks di Python

Convolutional Neural Networks (CNN) adalah salah satu fondasi visi komputer modern, yang memampukan aplikasi seperti pengenalan gambar, deteksi wajah, dan mobil tanpa pengemudi. Jaringan ini dirancang untuk secara otomatis mengekstrak pola dan fitur dari gambar, sehingga lebih kuat daripada teknik machine learning tradisional untuk tugas-tugas visual.

Dalam tutorial ini, kita akan mengimplementasikan CNN menggunakan PyTorch, sebuah kerangka kerja deep learning yang ramah pengguna dan sangat efisien untuk riset maupun produksi.

Prasyarat: Deep Learning dan PyTorch

Sebelum masuk ke detail CNN, Anda harus familiar dengan bidang deep learning dan pustaka Python yang akan kita gunakan saat menyiapkan lingkungan kerja.

Deep learning adalah subset dari machine learning, dengan struktur model dasar berupa jaringan input, lapisan tersembunyi, dan output. Jaringan semacam ini bisa memiliki satu atau banyak lapisan tersembunyi. Intuisi awal di balik deep learning adalah membuat model yang terinspirasi dari cara otak manusia belajar: melalui sel-sel saling terhubung yang disebut neuron. Inilah sebabnya kita masih menyebut model deep learning sebagai jaringan "neural". Struktur berlapis ini membutuhkan jauh lebih banyak data untuk belajar dibandingkan model supervised learning lain guna menemukan pola dari data tidak terstruktur. Biasanya kita berbicara setidaknya ratusan ribu titik data.

Meskipun ada banyak kerangka dan paket untuk mengimplementasikan algoritma deep learning, kita akan berfokus pada PyTorch, salah satu kerangka paling populer dan terawat. Selain digunakan oleh engineer deep learning di industri, PyTorch juga menjadi favorit para peneliti. Banyak makalah deep learning diterbitkan menggunakan PyTorch. PyTorch dirancang intuitif dan ramah pengguna, dengan banyak kesamaan dengan pustaka Python, NumPy. 

Jika Anda membutuhkan pengantar konsep-konsep ini, pertimbangkan untuk mendaftar ke kursus Deep Learning with PyTorch hari ini. 

Apa itu Convolutional Neural Network (CNN)?

Convolutional neural networks, yang biasa disebut CNN atau ConvNet, adalah jenis jaringan neural dalam yang sangat cocok untuk tugas visi komputer. Penemuan CNN sudah ada sejak 1980-an. Namun, CNN baru menjadi arus utama pada 2010-an, setelah terobosan komputasi berkat implementasi graphics processing units (GPU). Popularisasi CNN yang cepat membantu bidang jaringan neural kembali menonjol, memicu apa yang disebut "gelombang ketiga jaringan neural" yang masih kita rasakan hingga kini.

CNN secara khusus terinspirasi oleh korteks visual biologis. Korteks memiliki wilayah kecil sel yang peka terhadap area spesifik dari medan visual. Gagasan ini dikembangkan melalui eksperimen memikat oleh Hubel dan Wiesel pada 1962. 

CNN mencoba meniru fitur ini dengan membuat jaringan neural kompleks yang terdiri dari lapisan-lapisan berbeda sesuai tugas. CNN disebut "feed-forward" karena informasi mengalir lurus melalui model. Tidak ada koneksi umpan balik di mana output model dimasukkan kembali ke model itu sendiri, berbeda dengan model lain yang menggunakan teknik seperti backpropagation.

Secara khusus, sebuah CNN biasanya terdiri dari lapisan-lapisan berikut:

Lapisan konvolusi

Ini adalah blok pembangun pertama dari CNN. Sesuai namanya, tugas matematis utama yang dilakukan adalah konvolusi, yaitu penerapan fungsi jendela geser ke matriks piksel yang merepresentasikan sebuah gambar. Fungsi geser yang diterapkan ke matriks disebut kernel atau filter. Pada lapisan konvolusi, beberapa filter berukuran sama diterapkan, dan setiap filter digunakan untuk mengenali pola spesifik dari gambar, seperti lengkungan digit, tepi, bentuk keseluruhan digit, dan lainnya. 

Fungsi aktivasi

Biasanya, fungsi aktivasi ReLU diterapkan setelah setiap operasi konvolusi. Fungsi ini membantu jaringan mempelajari hubungan non-linear antar fitur dalam gambar, membuat jaringan lebih tangguh dalam mengidentifikasi berbagai pola. Ini juga membantu mengurangi masalah vanishing gradient. 

Lapisan pooling

Tujuan lapisan pooling adalah mengambil fitur paling signifikan dari matriks hasil konvolusi. Ini dilakukan dengan menerapkan beberapa operasi agregasi, yang mengurangi dimensi peta fitur (matriks hasil konvolusi), sehingga mengurangi penggunaan memori saat melatih jaringan.  Pooling juga relevan untuk mengurangi overfitting.

Lapisan fully connected

Lapisan-lapisan ini berada di bagian akhir convolutional neural network, dan inputnya sesuai dengan matriks satu dimensi yang diratakan, yang dihasilkan oleh lapisan pooling terakhir. Fungsi aktivasi ReLU diterapkan untuk menambahkan non-linearitas. 

Arsitektur Convolution Neural Network. Sumber: DataCamp

Anda dapat membaca penjelasan lebih rinci mengenai matematika di balik CNN dalam tutorial kami, Convolutional Neural Networks in Python.

Mengapa menggunakan CNN untuk klasifikasi gambar?

Convolutional neural networks adalah salah satu inovasi paling berpengaruh di bidang visi komputer. CNN berkinerja jauh lebih baik dibandingkan model machine learning tradisional, seperti SVM dan decision tree, dan menghasilkan hasil mutakhir. 

Selain itu, lapisan konvolusi memberikan karakteristik invarian translasi pada CNN, memampukan mereka mengidentifikasi dan mengekstrak pola serta fitur dari data terlepas dari variasi posisi, orientasi, skala, atau translasi.


CNN telah terbukti berhasil dalam banyak studi kasus dan aplikasi dunia nyata, seperti:

• Klasifikasi gambar, deteksi objek, segmentasi, pengenalan wajah;
• Mobil tanpa pengemudi yang memanfaatkan sistem visi berbasis CNN;
• Klasifikasi struktur kristal menggunakan convolutional neural network;
• Sistem kamera keamanan.

Di luar tugas klasifikasi gambar, CNN bersifat serbaguna dan dapat diterapkan pada beragam domain lain, seperti pemrosesan bahasa alami, analisis deret waktu, dan pengenalan suara.

Mengimplementasikan CNN dengan PyTorch

Sekarang Anda sudah familiar dengan teori CNN, saatnya praktik. Pada bagian ini, kita akan membangun dan melatih CNN sederhana dengan PyTorch. Tujuan kita adalah membangun model untuk mengklasifikasikan digit pada gambar. Untuk melatih dan menguji model, kita akan menggunakan dataset MNIST yang terkenal, kumpulan 70.000 gambar grayscale berukuran 28x28 dengan digit tulisan tangan.

1. Mengimpor pustaka yang diperlukan

Di bawah ini adalah pustaka yang akan kita gunakan dalam tutorial ini. Intinya, kita akan memanfaatkan PyTorch untuk membangun CNN, dan modul visi komputer PyTorch, torchvision, untuk mengunduh dan memuat dataset MNIST. Terakhir, kita juga akan menggunakan torchmetrics untuk mengevaluasi kinerja model.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. Memuat dan prapemrosesan dataset

PyTorch juga dilengkapi ekosistem alat dan ekstensi yang kaya, termasuk torchvision, modul untuk visi komputer. Torchvision mencakup beberapa dataset gambar yang dapat digunakan untuk melatih dan menguji jaringan neural. Dalam tutorial ini, kita akan menggunakan dataset MNIST. 

Pertama, kita akan mengunduh dan mengonversi dataset MNIST menjadi tensor, struktur data inti di PyTorch, mirip dengan array NumPy tetapi dengan kemampuan akselerasi GPU.

Selanjutnya, kita juga akan menggunakan DataLoader untuk menangani batching dan shuffling pada dataset train dan test. DataLoader PyTorch dapat dibuat dari sebuah Dataset untuk memuat data, membaginya ke dalam batch, dan melakukan transformasi pada data jika diinginkan. Kemudian, DataLoader menghasilkan sampel data yang siap untuk pelatihan. Pada kode di bawah, kita memuat data dan menyimpannya dalam DataLoader dengan ukuran batch 60 gambar:

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

Opsional, dataset train dapat dibagi lagi menjadi dua bagian, yaitu train dan validasi. Validasi adalah teknik dalam deep learning untuk mengevaluasi kinerja model selama pelatihan. Teknik ini membantu mendeteksi potensi overfitting dan underfitting pada model kita, dan sangat membantu untuk mengoptimalkan hyperparameter. Namun, demi kesederhanaan, kita tidak akan menggunakan validasi dalam tutorial ini. Jika Anda ingin mempelajari lebih lanjut tentang validasi, simak penjelasan lengkapnya di Introduction to Deep Learning with PyTorch Course kami.

Sekarang kita sudah memiliki data, mari lihat seperti apa satu batch acak digit:

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# get some random training images
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# show images
imshow(torchvision.utils.make_grid(images))

3. Mendefinisikan arsitektur CNN

Untuk menyelesaikan masalah klasifikasi, kita akan memanfaatkan kelas nn.Module, blok bangunan PyTorch untuk secara intuitif membuat arsitektur jaringan neural yang canggih. 

Pada kode di bawah, kita membuat kelas bernama CNN, yang mewarisi properti kelas nn.Module. Kelas CNN akan menjadi cetak biru CNN dengan dua lapisan konvolusi, diikuti oleh satu lapisan fully connected. 

Di PyTorch, kita menggunakan nn.Conv2d untuk mendefinisikan lapisan konvolusi. Kita memberinya jumlah peta fitur input dan output. Kita juga menetapkan beberapa parameter agar lapisan konvolusi bekerja, termasuk ukuran kernel atau filter dan padding. 

Berikutnya, kita menambahkan lapisan max pooling dengan nn.MaxPool2d. Di dalamnya, kita menggeser jendela tanpa tumpang tindih di atas keluaran lapisan konvolusi sebelumnya. Pada setiap posisi, kita memilih nilai maksimum dari jendela untuk diteruskan. Operasi ini mengurangi dimensi spasial peta fitur, menurunkan jumlah parameter dan kompleksitas komputasi dalam jaringan. Terakhir, kita menambahkan lapisan linear fully connected. 

Fungsi forward() mendefinisikan bagaimana lapisan-lapisan terhubung, dengan menambahkan beberapa fungsi aktivasi ReLU setelah setiap lapisan konvolusi.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # 1st convolutional layer
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling layer
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2nd convolutional layer
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Fully connected layer
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # Apply first convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = F.relu(self.conv2(x))  # Apply second convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x

Setelah kita mendefinisikan kelas CNN, kita dapat membuat model dan memindahkannya ke perangkat tempat model akan dilatih dan dijalankan. 

Jaringan neural, termasuk CNN, menunjukkan kinerja lebih baik saat berjalan di GPU, tetapi itu mungkin tidak terjadi pada komputer Anda. Karena itu, kita akan menjalankan model di GPU hanya jika tersedia; jika tidak, kita akan menggunakan CPU biasa.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. Melatih model CNN

Sekarang kita memiliki model, saatnya melatihnya. Untuk itu, pertama kita perlu menentukan bagaimana kita akan mengukur kinerja model. Karena kita berhadapan dengan masalah klasifikasi multikelas, kita akan menggunakan fungsi loss cross-entropy, yang tersedia di PyTorch sebagai nn.CrossEntropyLoss. Kita juga akan menggunakan optimizer Adam, salah satu algoritma optimisasi paling populer. 

# Define the loss function
criterion = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

Kita akan melakukan iterasi selama sepuluh epoch dan batch pelatihan untuk melatih model dan menjalankan rangkaian langkah biasa untuk setiap batch, seperti yang ditunjukkan di bawah.

num_epochs=10
for epoch in range(num_epochs):
 # Iterate over training batches
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()

Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. Mengevaluasi model

Setelah model dilatih, kita dapat mengevaluasi kinerjanya pada dataset uji. Kita akan menggunakan akurasi, metrik populer untuk masalah klasifikasi. Akurasi mengukur proporsi kasus yang diklasifikasikan dengan benar dari total jumlah objek dalam dataset. Akurasi dihitung dengan membagi jumlah prediksi benar dengan total jumlah prediksi yang dibuat model. 

Pertama, kita menyiapkan metrik akurasi dari torchmetrics. Selanjutnya, kita gunakan metode .eval pada model untuk menempatkannya dalam mode evaluasi, karena beberapa lapisan dalam model PyTorch berperilaku berbeda saat pelatihan dan pengujian. Kita juga menambahkan konteks Python dengan torch.no_grad, yang menunjukkan bahwa kita tidak akan melakukan perhitungan gradien.

Kemudian, kita melakukan iterasi pada contoh uji tanpa perhitungan gradien. Untuk setiap batch uji, kita memperoleh keluaran model, mengambil kelas yang paling mungkin, dan memberikannya ke fungsi akurasi bersama labelnya. Terakhir, kita menghitung metrik dan mencetak hasilnya. Kita mendapatkan skor akurasi 0,98, yang berarti model kita dengan benar mengklasifikasikan 98% digit. Cukup baik!

# Set up of multiclass accuracy metric
acc = Accuracy(task="multiclass",num_classes=10)

# Iterate over the dataset batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Get predicted probabilities for test data batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

#Compute total test accuracy
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Anda juga dapat menggunakan metrik klasifikasi populer lainnya, termasuk recall dan precision. Kami membahas semua metrik ini dengan contoh praktis dalam Intermediate Deep Learning with PyTorch Course kami.

Meningkatkan Kinerja Model

Meskipun model CNN kita mencapai kinerja yang kuat, ada beberapa strategi yang dapat kita gunakan untuk lebih meningkatkan akurasi, ketangguhan, dan kemampuan generalisasi ke data baru. 

Di bagian ini, kita akan mengeksplorasi teknik-teknik kunci seperti augmentasi data, penyetelan hyperparameter, dan transfer learning untuk mengoptimalkan kinerja model.

Teknik augmentasi data

Augmentasi data adalah teknik untuk meningkatkan akurasi model dengan secara acak membuat data pelatihan baru. Misalnya, saat memuat, kita dapat menerapkan transformasi pada gambar pelatihan, seperti mengubah ukuran, membalik horizontal atau vertikal, rotasi acak, dan sebagainya. Dengan cara ini, kita dapat membuat gambar hasil augmentasi dan memberinya label yang sama seperti gambar asli, sehingga menambah ukuran himpunan pelatihan.

Menambahkan transformasi acak pada gambar asli memungkinkan kita menghasilkan lebih banyak data sekaligus meningkatkan ukuran dan keragaman himpunan pelatihan. Ini membuat model lebih tangguh terhadap variasi dan distorsi yang umum ditemukan pada gambar dunia nyata, serta mengurangi overfitting karena model belajar mengabaikan transformasi acak. 

Namun, penting untuk berhati-hati dalam augmentasi data, karena terkadang dapat merugikan proses pelatihan. Misalnya, pada masalah kita, jika kita menerapkan pembalikan vertikal pada angka "6", tampilannya akan seperti angka "9". Memberikannya ke model dengan label "6" akan membingungkan model dan menghambat pelatihan. Contoh-contoh ini menunjukkan bahwa, terkadang, augmentasi tertentu dapat memengaruhi label.

Penyetelan hyperparameter

Strategi lain untuk meningkatkan kinerja model adalah dengan mengubah nilai hyperparameter pada berbagai lapisan model. Penyetelan hyperparameter ini memerlukan pemahaman mendalam tentang matematika di balik jaringan neural dan makna dari berbagai hyperparameter. 

Sebagai contoh, Anda dapat menyetel lapisan CNN dengan mengubah ukuran filter atau meningkatkan padding. Anda juga dapat menetapkan nilai berbeda untuk bobot awal neuron. 

Karena kita tidak akan mengetahui nilai optimal hyperparameter sebelumnya, diperlukan sejumlah percobaan dan kesalahan. Ini biasanya dilakukan melalui teknik yang dikenal sebagai grid search, yang memungkinkan Anda mengevaluasi model secara sistematis pada kisi nilai parameter. 

Namun, berhati-hatilah saat menggunakan teknik ini, karena biasanya mahal secara komputasi, terutama saat berhadapan dengan jaringan neural yang kompleks dan dataset pelatihan yang besar.

Demikian pula, Anda dapat meningkatkan kompleksitas model dengan menambahkan lebih banyak lapisan konvolusi dan linear. Namun, berhati-hatilah saat menambahkan lapisan baru, karena jumlah neuron dapat meningkat drastis, mengakibatkan waktu pelatihan lebih lama dan potensi overfitting.

Anda dapat mempelajari lebih lanjut tentang penyetelan hyperparameter di Introduction to Deep Learning with PyTorch Course kami.

Menggunakan model pra-latih

Melatih model deep learning dari awal adalah proses panjang dan melelahkan, dan biasanya memerlukan banyak data pelatihan. Sebagai gantinya, kita sering dapat menggunakan model pra-latih, yaitu model yang sudah dilatih pada suatu tugas. 

Terkadang, kita dapat langsung menggunakan kembali model pra-latih jika model tersebut sudah dapat menyelesaikan tugas yang kita butuhkan. Pada kesempatan lain, kita mungkin perlu menyesuaikan model pra-latih agar cocok dengan tugas baru. Ini dikenal sebagai transfer learning.

Menggunakan model pra-latih di PyTorch cukup mudah. Torchvision menyediakan kumpulan model pra-latih untuk berbagai tugas terkait gambar. Model-model ini dilatih pada dataset gambar skala besar dan mudah diakses. Lihat Deep Learning for Images with PyTorch Course kami untuk mempelajari semua yang perlu Anda ketahui tentangnya.

Mendeploy Model CNN

Setelah melatih model klasifikasi yang sangat akurat di PyTorch, Anda kini dapat menyimpan model dan bobot pra-latihnya untuk digunakan di masa mendatang dan membagikannya dengan tim Anda, memastikan mereka dapat memuatnya dengan mulus.

Untuk menyimpan model, kita dapat menggunakan torch.save. Ekstensi file umum untuk model torch adalah pt atau pth. Untuk menyimpan bobot model, kita meneruskan model.state_dict ke torch.save dengan menyediakan nama file keluaran, misalnya MulticlassCNN.pth.

Untuk memuat model yang disimpan, kita menginisialisasi model baru dengan arsitektur yang sama. Lalu kita gunakan metode load state dict bersama torch.load untuk memuat parameter ke model baru.

# Save the model
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Create a new model
loaded_model = CNN(in_channels=1, num_classes=10)

# Load the saved model
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

Kesimpulan

Kita telah membahas tinjauan lengkap tentang CNN, memberikan detail mengenai setiap lapisan pada arsitektur CNN. Selanjutnya, kami menyediakan panduan tentang cara mengimplementasikan CNN di PyTorch, mencakup langkah utama, mulai dari pemuatan data dan perancangan model hingga pelatihan dan evaluasi model. Terakhir, kami juga menganalisis beberapa strategi untuk meningkatkan kinerja model. Kita menerapkan semua keterampilan ini pada skenario dunia nyata terkait tugas klasifikasi multikelas. 

Masih banyak yang bisa dipelajari tentang deep learning, salah satu bidang AI yang paling menarik dan menantang. Untungnya, DataCamp siap membantu. Lihat materi dan kursus khusus kami dan jadilah ahli jaringan neural:

• An Introduction to Convolutional Neural Networks: A Comprehensive Guide to CNNs in Deep Learning 
• Convolutional Neural Networks in Python with Keras
• Python Convolutional Neural Networks (CNN) with TensorFlow Tutorial
• Introduction to Activation Functions in Neural Networks 
• Master Deep Learning for Text with PyTorch Course
• Deep Learning in Python
• How to Learn Deep Learning in 2025: A Complete Guide
• Intermediate Deep Learning with PyTorch Course
• A Guide to PyTorch Certifications & Certificates