Learn AI with Python · Pelajaran

Membangun dan Melatih CNN di PyTorch

nn.Conv2d, nn.MaxPool2d, nn.Linear, loop pelatihan, pengoptimal, loss, pelacakan akurasi.

Membangun dan Melatih CNN di PyTorch adalah pelajaran Learn AI with Python gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn AI with Python, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn AI with Python mencakup 4 pelajaran total.

Mengapa CNN untuk Gambar?

Jaringan Saraf Konvolusional mempelajari pola spasial: tepi, tekstur, lalu bentuk dan objek. Konvolusi berbagi bobot di seluruh gambar, sehingga CNN efisien dan peka terhadap pergeseran, serta menjadi tulang punggung visi komputer.

import torch
import torch.nn as nn

Kelas Dasar nn.Module

Model merupakan subkelas dari nn.Module. Anda mendefinisikan lapisan di __init__ dan aliran data di forward. PyTorch melacak parameter dan gradien secara otomatis.

class CNN(nn.Module):
    def __init__(self):
        super().__init__()

Lapisan Konvolusi

nn.Conv2d(in_channels, out_channels, kernel_size) menggeser filter yang dapat dipelajari di atas gambar untuk menghasilkan peta fitur. Konvolusi pertama menerima 3 kanal (RGB) dan menghasilkan lebih banyak kanal yang menangkap fitur berbeda.

self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)

Lapisan Penggabungan

nn.MaxPool2d menurunkan resolusi peta fitur dengan mempertahankan nilai maksimum di setiap jendela. Ini menyusutkan ukuran spasial, mengurangi komputasi, dan menambahkan sedikit invariansi terhadap pergeseran.

self.pool = nn.MaxPool2d(kernel_size=2, stride=2)

Lapisan Terhubung Penuh

Setelah konvolusi, ratakan fitur dan masukkan ke lapisan nn.Linear untuk menghasilkan skor kelas. Linear terakhir menghasilkan satu nilai untuk setiap kelas.

self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.fc2 = nn.Linear(128, 10)  # 10 classes

Metode forward

Metode forward mendefinisikan aliran data: konvolusi ke ReLU ke penggabungan, diulang, lalu diratakan dan dimasukkan ke lapisan linear. F.relu menambahkan nonlinieritas yang memungkinkan jaringan mempelajari pola kompleks.

import torch.nn.functional as F

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(x.size(0), -1)  # flatten
        x = F.relu(self.fc1(x))
        return self.fc2(x)

Kerugian dan Pengoptimal

Untuk klasifikasi, gunakan CrossEntropyLoss. Pengoptimal seperti Adam memperbarui bobot menggunakan gradien. Berikan parameter model dan laju pembelajaran.

model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

Loop Pelatihan: Mengosongkan Gradien

Setiap langkah dimulai dengan menghapus gradien lama menggunakan optimizer.zero_grad(). Jika langkah ini dilewati, gradien akan terakumulasi di seluruh kelompok dan merusak pembaruan Anda.

for images, labels in loader:
    optimizer.zero_grad()

Lintasan forward dan Kerugian

Jalankan kelompok melalui model untuk mendapatkan prediksi, lalu hitung kerugian dengan membandingkan prediksi dengan label sebenarnya. Kerugian adalah satu angka yang mengukur seberapa keliru model.

    outputs = model(images)
    loss = criterion(outputs, labels)

Backward dan Step

loss.backward() menghitung gradien melalui diferensiasi otomatis, sedangkan optimizer.step() sedikit mengubah bobot untuk mengurangi kerugian. Keduanya membentuk satu langkah pembelajaran.

    loss.backward()
    optimizer.step()

Melacak Akurasi

Pantau kemajuan dengan menghitung prediksi yang benar. Ambil argmax dari keluaran untuk mendapatkan kelas prediksi, bandingkan dengan label, lalu bagi jumlah yang benar dengan totalnya.

    preds = outputs.argmax(dim=1)
    correct = (preds == labels).sum().item()
    acc = correct / labels.size(0)
    print("batch acc:", acc)

Pemeriksaan Singkat

Uji pengetahuan Anda tentang loop pelatihan.

Rangkuman: Membangun dan Melatih CNN

Anda membangun CNN dengan membuat subkelas nn.Module yang memiliki lapisan nn.Conv2d, nn.MaxPool2d, dan nn.Linear, serta metode forward. Anda melatihnya dengan loop: zero_grad, lintasan forward, loss.backward(), optimizer.step(), dan melacak akurasi melalui argmax.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun dan Melatih CNN di PyTorch” gratis?

Ya — teks lengkap “Membangun dan Melatih CNN di PyTorch” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn AI with Python, upgrade ke CoddyKit PRO. Kursus Learn AI with Python mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun dan Melatih CNN di PyTorch”?

nn.Conv2d, nn.MaxPool2d, nn.Linear, loop pelatihan, pengoptimal, loss, pelacakan akurasi. Kamu berlatih Learn AI with Python dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn AI with Python?

Tidak diperlukan pengalaman sebelumnya. Learn AI with Python di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Membangun dan Melatih CNN di PyTorch” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn AI with Python ini?

Ya. Setiap pelajaran Learn AI with Python menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn AI with Python