Machine Learning Academy · Pelajaran

Membina Rangkaian Suapan Hadapan dengan nn.Module

Pelajar akan mencipta subkelas nn.Module, menyusun lapisan Linear dan ReLU dalam __init__, melaksanakan hantaran hadapan, dan mengesahkan bentuk output dengan input olok-olok.

Pelajaran 3 daripada 413 langkah

Membina Rangkaian Suapan Hadapan dengan nn.Module ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Apakah nn.Module?

nn.Module ialah kelas asas PyTorch untuk semua komponen rangkaian neural. Setiap lapisan, fungsi pengaktifan, fungsi kehilangan dan model lengkap dalam PyTorch ialah subkelas nn.Module. Ia menyediakan pengurusan parameter, pemindahan peranti, pensirilan serta pertukaran mod latihan/penilaian secara terbina dalam. Dengan menjadikannya subkelas, anda memperoleh semua fungsi ini secara percuma dan hanya perlu mentakrifkan seni bina serta laluan hadapan.

import torch.nn as nn

# Inspect what nn.Module gives you
model = nn.Linear(4, 2)
print(type(model))               # <class 'torch.nn.modules.linear.Linear'>
print(isinstance(model, nn.Module))  # True
print(list(model.parameters()))  # weight and bias tensors

Menjadikan nn.Module Subkelas: init dan forward

Mencipta rangkaian tersuai memerlukan dua kaedah. Dalam __init__, anda memanggil super().__init__() dan mentakrifkan semua lapisan yang boleh dipelajari sebagai atribut. Dalam forward, anda menerangkan cara data mengalir melalui lapisan tersebut. PyTorch menjejaki mana-mana nn.Module atau nn.Parameter yang diberikan kepada self sebagai komponen yang boleh dilatih. Memanggil model seperti fungsi (model(x)) akan memanggil forward secara automatik dan menjalankan sebarang cangkuk yang didaftarkan.

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

model = SimpleNet(4, 16, 3)
print(model)

Lapisan Linear: nn.Linear

nn.Linear(in_features, out_features) menggunakan transformasi y = x @ W.T + b, dengan W ialah matriks pemberat dan b ialah vektor pincang. Lapisan ini memulakan pemberat secara automatik menggunakan taburan seragam kaiming dan pincang menggunakan taburan seragam. Ia merupakan blok binaan rangkaian suapan hadapan, yang juga dipanggil lapisan bersambung penuh atau padat.

import torch
import torch.nn as nn

layer = nn.Linear(5, 3)  # 5 inputs, 3 outputs

print('Weight shape:', layer.weight.shape)  # (3, 5)
print('Bias shape:',   layer.bias.shape)    # (3,)

# Forward pass with a batch of 8 samples
x = torch.randn(8, 5)
out = layer(x)
print('Output shape:', out.shape)   # (8, 3)

Fungsi Pengaktifan: ReLU, Sigmoid, Tanh

Fungsi pengaktifan memperkenalkan ketaklinearan, lalu membolehkan rangkaian mempelajari corak kompleks yang tidak dapat diwakili oleh susunan lapisan linear. ReLU (max(0, x)) ialah lalai untuk lapisan tersembunyi — pantas dan mengelakkan kecerunan yang lenyap. Sigmoid memampatkan output kepada [0, 1] dan digunakan untuk output pengelasan binari. Tanh memampatkannya kepada [-1, 1] dan lazim digunakan dalam RNN. Kesemuanya tersedia sebagai modul dalam nn.

import torch
import torch.nn as nn

x = torch.tensor([-2.0, -0.5, 0.0, 0.5, 2.0])

print('ReLU:   ', nn.ReLU()(x))
# tensor([0.0, 0.0, 0.0, 0.5, 2.0])

print('Sigmoid:', nn.Sigmoid()(x))
# tensor([0.12, 0.38, 0.50, 0.62, 0.88])

print('Tanh:   ', nn.Tanh()(x))
# tensor([-0.96, -0.46,  0.00,  0.46,  0.96])

Menyusun Lapisan dengan nn.Sequential

nn.Sequential ialah bekas mudah yang menghantar output setiap modul sebagai input kepada modul seterusnya. Ia sesuai untuk seni bina suapan hadapan yang ringkas, apabila data mengalir secara linear. Untuk rangkaian yang lebih kompleks dengan sambungan pintasan, berbilang input atau laluan bercabang, anda memerlukan pendekatan subkelas nn.Module sepenuhnya. Rangkaian Sequential masih boleh dikembangkan dengan menjadikannya subkelas dan menggunakan Sequential sebagai subblok.

import torch
import torch.nn as nn

# Build with nn.Sequential
model = nn.Sequential(
    nn.Linear(10, 64),
    nn.ReLU(),
    nn.Linear(64, 32),
    nn.ReLU(),
    nn.Linear(32, 1)
)

x = torch.randn(16, 10)    # batch of 16
out = model(x)
print(out.shape)            # torch.Size([16, 1])

Mengesahkan Bentuk Output dengan Input Olok-olok

Satu teknik penyahpepijatan penting ketika membina rangkaian ialah menjalankan tensor olok-olok melalui model sebelum latihan. Ini mengesahkan bahawa semua dimensi lapisan serasi dan mendedahkan ketidakpadanan bentuk dengan serta-merta. Tensor olok-olok mempunyai bentuk yang sama seperti data sebenar anda tetapi mengandungi nilai rawak — ia hanya menguji laluan hadapan. Sentiasa lakukan perkara ini selepas mentakrifkan seni bina baharu.

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
    def forward(self, x):
        return self.net(x)

model = MLP()
dummy = torch.randn(32, 784)   # batch of 32 MNIST images
out = model(dummy)
print(out.shape)                # torch.Size([32, 10]) -- correct!

Menyenaraikan dan Mengira Parameter

Memahami jumlah keseluruhan parameter yang boleh dilatih dalam model memberikan gambaran tentang kapasitinya dan keperluan memorinya. model.parameters() mengembalikan lelaran terhadap semua tensor yang boleh dipelajari; model.named_parameters() memadankan setiap tensor dengan namanya untuk pemeriksaan. Pengira parameter yang ringkas ialah salah satu utiliti pertama yang dibina oleh setiap pengamal PyTorch.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10)
)

total_params = sum(p.numel() for p in model.parameters())
trainable = sum(p.numel() for p in model.parameters()
                if p.requires_grad)

print(f'Total params:     {total_params:,}')   # 203,530
print(f'Trainable params: {trainable:,}')       # 203,530

for name, p in model.named_parameters():
    print(name, p.shape)

Memindahkan Model ke GPU

Memindahkan model ke GPU semudah memanggil model.to(device). Ini memindahkan semua parameter dan penimbal yang didaftarkan dalam modul kepada peranti sasaran. Selepas panggilan ini, semua pengiraan laluan hadapan berlaku pada GPU secara automatik — selagi tensor input anda juga berada pada peranti yang sama. Mencampurkan tensor CPU dan GPU akan menghasilkan ralat masa jalan.

import torch
import torch.nn as nn

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

model = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),
    nn.Linear(8, 2)
).to(device)   # move entire model to device

# Input must be on the same device
x = torch.randn(5, 4).to(device)
out = model(x)
print(out.device)   # cuda:0 (or cpu)

Mod Latihan berbanding Penilaian

Sesetengah lapisan (Dropout, BatchNorm) berkelakuan berbeza semasa latihan dan inferens. Memanggil model.train() mengaktifkan tingkah laku stokastik (dropout rawak, statistik kelompok); model.eval() menukar kepada tingkah laku inferens deterministik. Jika terlupa memanggil model.eval() sebelum penilaian, hasil menjadi tidak konsisten kerana Dropout menetapkan pengaktifan tertentu kepada sifar secara rawak. Sentiasa pasangkan panggilan ini dengan torch.no_grad() semasa inferens untuk kecekapan maksimum.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(4, 8),
    nn.Dropout(p=0.5),
    nn.Linear(8, 2)
)

# Training mode: dropout is active
model.train()
x = torch.randn(4, 4)
print(model(x))   # some activations zeroed randomly

# Eval mode: dropout is disabled
model.eval()
with torch.no_grad():
    print(model(x))   # deterministic output

Rangkaian Tersuai: Perceptron Berbilang Lapisan

Dengan menggabungkan semuanya, perceptron berbilang lapisan (MLP) ialah rangkaian suapan hadapan dengan satu atau lebih lapisan tersembunyi antara input dan output. Setiap lapisan tersembunyi menggunakan transformasi linear yang diikuti pengaktifan tak linear. Pengaktifan lapisan output bergantung pada tugasan — tiada pengaktifan untuk regresi, softmax untuk pengelasan berbilang kelas, dan sigmoid untuk pengelasan binari. Contoh di bawah membina MLP 3 lapisan untuk pengelasan 10 kelas.

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, in_dim, hidden_dims, out_dim):
        super().__init__()
        layers = []
        prev = in_dim
        for h in hidden_dims:
            layers.append(nn.Linear(prev, h))
            layers.append(nn.ReLU())
            prev = h
        layers.append(nn.Linear(prev, out_dim))
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

model = MLP(784, [256, 128, 64], 10)
dummy = torch.randn(32, 784)
print(model(dummy).shape)  # torch.Size([32, 10])

Menyimpan dan Memuatkan Keadaan Rangkaian

Latihan rangkaian neural memerlukan kos yang tinggi, jadi anda menyimpan model selepas latihan. Konvensyen PyTorch ialah menyimpan hanya state_dict — kamus tensor parameter — bukannya keseluruhan objek model. Ini mengelakkan kebergantungan pickle pada takrifan kelas. Untuk memulihkannya, cipta tika model baharu dengan seni bina yang sama, kemudian muatkan kamus keadaan menggunakan load_state_dict. Sentiasa tetapkan model.eval() selepas memuatkan model untuk inferens.

import torch
import torch.nn as nn

model = nn.Linear(4, 2)

# Save only parameters (recommended)
torch.save(model.state_dict(), '/tmp/model.pt')

# Restore
new_model = nn.Linear(4, 2)  # same architecture
new_model.load_state_dict(torch.load('/tmp/model.pt'))
new_model.eval()

x = torch.randn(3, 4)
print(new_model(x))   # same output as original model

Semakan Pantas

Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: nn.Module ialah kelas asas untuk semua rangkaian neural PyTorch, yang memerlukan __init__ untuk mentakrifkan lapisan dan forward untuk mentakrifkan aliran data; nn.Sequential menyediakan bekas ringkas untuk susunan lapisan linear; dan model.train() / model.eval() menukar tingkah laku lapisan seperti Dropout dan BatchNorm. Seterusnya, kita akan menulis gelung latihan lengkap yang merangkumi kehilangan, pengoptimum dan berbilang kala.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membina Rangkaian Suapan Hadapan dengan nn.Module” percuma?

Ya — teks penuh “Membina Rangkaian Suapan Hadapan dengan nn.Module” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membina Rangkaian Suapan Hadapan dengan nn.Module”?

Pelajar akan mencipta subkelas nn.Module, menyusun lapisan Linear dan ReLU dalam __init__, melaksanakan hantaran hadapan, dan mengesahkan bentuk output dengan input olok-olok. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Membina Rangkaian Suapan Hadapan dengan nn.Module” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Tensor PyTorch: Penciptaan, Operasi dan Pemindahan GPU
Autograd: Pembezaan Automatik untuk Perambatan Balik
Membina Rangkaian Suapan Hadapan dengan nn.Module
Gelung Latihan: Kehilangan, Pengoptimum dan Epoch

← Kembali ke Machine Learning Academy