Melatih model dengan PyTorch

Selesai

PyTorch adalah kerangka kerja pembelajaran mesin yang umum digunakan untuk melatih model pembelajaran mendalam. Di Azure Databricks, PyTorch telah diinstal sebelumnya di kluster ML .

Nota

Cuplikan kode dalam unit ini disediakan sebagai contoh untuk menekankan poin kunci. Anda akan memiliki kesempatan untuk menjalankan kode untuk contoh kerja lengkap dalam latihan nanti dalam modul ini.

Menentukan jaringan PyTorch

Di PyTorch, model didasarkan pada jaringan yang Anda tentukan. Jaringan terdiri dari beberapa lapisan, masing-masing dengan input dan output yang ditentukan. Selain itu, pekerjaan ini mendefinisikan fungsi forward yang menerapkan proses ke setiap lapisan saat data melewati jaringan.

Contoh kode berikut mendefinisikan jaringan.

import torch
import torch.nn as nn
import torch.nn.functional as F

class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.layer1 = nn.Linear(4, 5)
        self.layer2 = nn.Linear(5, 5)
        self.layer3 = nn.Linear(5, 3)

    def forward(self, x):
        layer1_output = torch.relu(self.layer1(x))
        layer2_output = torch.relu(self.layer2(layer1_output))
        y = self.layer3(layer2_output)
        return y

Meskipun kode mungkin tampak kompleks pada awalnya, kelas ini mendefinisikan jaringan yang relatif sederhana dengan tiga lapisan:

• Lapisan input yang menerima empat nilai input dan menghasilkan lima nilai output untuk lapisan berikutnya.
• Lapisan yang menerima lima input dan menghasilkan lima output.
• Lapisan output akhir yang menerima lima input dan menghasilkan tiga output.

Fungsi penerusan menerapkan lapisan ke data input (x), meneruskan output dari setiap lapisan ke lapisan berikutnya dan akhirnya mengembalikan output dari lapisan terakhir (yang berisi vektor prediksi label, y). Fungsi aktivasi unit linear terhitung (ReLU) diterapkan ke output lapisan 1 dan 2 untuk membatasi nilai output ke angka positif.

Nota

Tergantung pada jenis kriteria kerugian yang digunakan, Anda dapat memilih untuk menerapkan fungsi aktivasi seperti log_softmax ke nilai pengembalian untuk memaksanya ke rentang 0 hingga 1. Namun, beberapa kriteria kerugian (seperti CrossEntropyLoss, yang umumnya digunakan untuk klasifikasi multikelas) secara otomatis menerapkan fungsi yang sesuai.

Untuk membuat model pelatihan, Anda hanya perlu membuat instans kelas jaringan seperti ini:

myModel = MyNet()

Menyiapkan data untuk pemodelan

Lapisan PyTorch bekerja pada data yang diformat sebagai tensor - struktur seperti matriks. Ada berbagai fungsi untuk mengonversi format data umum lainnya ke tensor, dan Anda dapat menentukan pemuat data PyTorch untuk membaca tensor data menjadi model untuk pelatihan atau inferensi.

Seperti kebanyakan teknik pembelajaran mesin yang diawasi, Anda harus menentukan himpunan data terpisah untuk pelatihan dan validasi. Pemisahan ini memungkinkan Anda memvalidasi bahwa model memprediksi secara akurat saat disajikan dengan data yang tidak dilatih.

Kode berikut mendefinisikan dua pemuat data; satu untuk pelatihan dan yang lainnya untuk pengujian. Data sumber untuk setiap pemuat dalam contoh ini diasumsikan berupa array Numpy nilai fitur dan array Numpy dari nilai label yang sesuai.

# Create a dataset and loader for the training data and labels
train_x = torch.Tensor(x_train).float()
train_y = torch.Tensor(y_train).long()
train_ds = td.TensorDataset(train_x,train_y)
train_loader = td.DataLoader(train_ds, batch_size=20,
    shuffle=False, num_workers=1)

# Create a dataset and loader for the test data and labels
test_x = torch.Tensor(x_test).float()
test_y = torch.Tensor(y_test).long()
test_ds = td.TensorDataset(test_x,test_y)
test_loader = td.DataLoader(test_ds, batch_size=20,
    shuffle=False, num_workers=1)

Loader dalam contoh ini membagi data menjadi batch 30, yang diteruskan ke fungsi forward selama pelatihan atau inferensi.

Pilih kriteria kerugian dan algoritma pengoptimal

Model ini dilatih dengan memberi makan data pelatihan ke dalam jaringan, mengukur kehilangan (perbedaan agregat antara nilai yang diprediksi dan aktual), dan mengoptimalkan jaringan dengan menyesuaikan bobot dan keseimbangan untuk meminimalkan kehilangan. Detail spesifik tentang bagaimana kerugian dihitung dan diminimalkan diatur oleh kriteria kerugian dan algoritma pengoptimal yang Anda pilih.

Kriteria kerugian

PyTorch mendukung beberapa fungsi kriteria kerugian, termasuk (di antara banyak lainnya):

• cross_entropy: Fungsi yang mengukur perbedaan agregat antara nilai yang diprediksi dan aktual untuk beberapa variabel (biasanya digunakan untuk mengukur kehilangan probabilitas kelas dalam klasifikasi multikelas).
• binary_cross_entropy: Fungsi yang mengukur perbedaan antara probabilitas yang diprediksi dan aktual (biasanya digunakan untuk mengukur kerugian dalam klasifikasi biner).
• mse_loss: Fungsi yang mengukur kerugian kesalahan kuadrat rata-rata untuk nilai numerik yang diprediksi dan aktual (biasanya digunakan untuk regresi).

Untuk menentukan kriteria kerugian yang ingin Anda gunakan saat melatih model, Anda membuat instans fungsi yang sesuai; Seperti ini:

import torch.nn as nn

loss_criteria = nn.CrossEntropyLoss

Petunjuk / Saran

Untuk informasi selengkapnya tentang kriteria kerugian yang tersedia di PyTorch, lihat Fungsi kehilangan dalam dokumentasi PyTorch.

Algoritma optimisasi

Setelah menghitung kehilangan, pengoptimal digunakan untuk menentukan cara terbaik untuk menyesuaikan bobot dan keseimbangan untuk meminimalkannya. Algoritma pengoptimalan adalah implementasi khusus dari pendekatan penurunan gradien untuk meminimalkan suatu fungsi. Pengoptimal yang tersedia di PyTorch meliputi (antara lain):

• Adadelta: Pengoptimal berdasarkan algoritma Tingkat Pembelajaran Adaptif .
• Adam: Pengoptimal yang efisien secara komputasi berdasarkan algoritma Adam .
• SGD: Pengoptimal berdasarkan algoritma penurunan gradien stokastik.

Untuk menggunakan salah satu algoritma ini untuk melatih model, Anda perlu membuat instans pengoptimal dan mengatur parameter yang diperlukan. Parameter tertentu bervariasi tergantung pada pengoptimal yang dipilih, tetapi sebagian besar mengharuskan Anda menentukan tingkat pembelajaran yang mengatur ukuran penyesuaian yang dibuat dengan setiap pengoptimalan.

Kode berikut membuat instans pengoptimal Adam .

import torch.optim as opt

learning_rate = 0.001
optimizer = opt.Adam(model.parameters(), lr=learning_rate)

Petunjuk / Saran

Untuk informasi selengkapnya tentang pengoptimal yang tersedia di PyTorch, lihat Algoritma dalam dokumentasi PyTorch.

Membuat fungsi pelatihan dan pengujian

Setelah menentukan jaringan dan menyiapkan data untuknya, Anda dapat menggunakan data untuk melatih dan menguji model dengan meneruskan data pelatihan melalui jaringan, menghitung kehilangan, mengoptimalkan bobot dan bias jaringan, dan memvalidasi performa jaringan dengan data pengujian. Adalah umum untuk menentukan fungsi yang meneruskan data melalui jaringan untuk melatih model dengan data pelatihan, dan fungsi terpisah untuk menguji model dengan data pengujian.

Membuat fungsi pelatihan

Contoh berikut menunjukkan fungsi untuk melatih model.

def train(model, data_loader, optimizer):

    # Use GPU if available, otherwise CPU
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    
    # Set the model to training mode (to enable backpropagation)
    model.train()
    train_loss = 0
    
    # Feed the batches of data forward through the network
    for batch, tensor in enumerate(data_loader):
        data, target = tensor # Specify features and labels in a tensor
        optimizer.zero_grad() # Reset optimizer state
        out = model(data) # Pass the data through the network
        loss = loss_criteria(out, target) # Calculate the loss
        train_loss += loss.item() # Keep a running total of loss for each batch

        # backpropagate adjustments to weights/bias
        loss.backward()
        optimizer.step()

    #Return average loss for all batches
    avg_loss = train_loss / (batch+1)
    print('Training set: Average loss: {:.6f}'.format(avg_loss))
    return avg_loss

Contoh berikut menunjukkan fungsi untuk menguji model.

def test(model, data_loader):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    # Switch the model to evaluation mode (so we don't backpropagate)
    model.eval()
    test_loss = 0
    correct = 0

    # Pass the data through with no gradient computation
    with torch.no_grad():
        batch_count = 0
        for batch, tensor in enumerate(data_loader):
            batch_count += 1
            data, target = tensor
            # Get the predictions
            out = model(data)

            # calculate the loss
            test_loss += loss_criteria(out, target).item()

            # Calculate the accuracy
            _, predicted = torch.max(out.data, 1)
            correct += torch.sum(target==predicted).item()
            
    # Calculate the average loss and total accuracy for all batches
    avg_loss = test_loss/batch_count
    print('Validation set: Average loss: {:.6f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        avg_loss, correct, len(data_loader.dataset),
        100. * correct / len(data_loader.dataset)))
    return avg_loss

Melatih model selama beberapa iterasi (epoch)

Untuk melatih model pembelajaran mendalam, Anda biasanya menjalankan fungsi pelatihan beberapa kali (disebut sebagai epoch), dengan tujuan mengurangi kerugian yang dihitung dari data pelatihan setiap zaman. Anda dapat menggunakan fungsi pengujian untuk memvalidasi bahwa kehilangan dari data pengujian (di mana model tidak dilatih) juga berkurang sejalan dengan kehilangan pelatihan - dengan kata lain bahwa pelatihan model tidak menghasilkan model yang terlalu cocok dengan data pelatihan.

Petunjuk / Saran

Anda tidak perlu menjalankan fungsi pengujian untuk setiap epoch. Anda dapat memilih untuk menjalankannya setiap epoch kedua, atau sekali di akhir. Namun, menguji model saat dilatih dapat membantu dalam menentukan setelah berapa epoch suatu model mulai mengalami overfitting.

Kode berikut melatih model selama 50 epoch.

epochs = 50
for epoch in range(1, epochs + 1):

    # print the epoch number
    print('Epoch: {}'.format(epoch))
    
    # Feed training data into the model to optimize the weights
    train_loss = train(model, train_loader, optimizer)
    print(train_loss)
    
    # Feed the test data into the model to check its performance
    test_loss = test(model, test_loader)
    print(test_loss)

Simpan status model yang telah dilatih

Setelah berhasil melatih model, Anda dapat menyimpan bobot dan biasnya seperti ini:

model_file = '/dbfs/my_model.pkl'
torch.save(model.state_dict(), model_file)

Untuk memuat dan menggunakan model di lain waktu, buat instans kelas jaringan tempat model didasarkan dan muat bobot dan bias yang disimpan.

model = myNet()
model.load_state_dict(torch.load(model_file))