Apa itu Transfer Learning?
Transfer Learning adalah teknik menggunakan model terlatih untuk menyelesaikan tugas terkait lainnya. Ini adalah metode penelitian Pembelajaran Mesin yang menyimpan pengetahuan yang diperoleh saat memecahkan masalah tertentu dan menggunakan pengetahuan yang sama untuk memecahkan masalah lain yang berbeda namun terkait. Ini meningkatkan efisiensi dengan menggunakan kembali informasi yang dikumpulkan dari tugas yang dipelajari sebelumnya.
Sangat populer menggunakan bobot model jaringan lain untuk mengurangi waktu pelatihan karena Anda memerlukan banyak data untuk melatih model jaringan. Untuk mengurangi waktu pelatihan, Anda menggunakan jaringan lain dan bobotnya dan memodifikasi lapisan terakhir untuk menyelesaikan masalah kita. Keuntungannya adalah Anda dapat menggunakan kumpulan data kecil untuk melatih lapisan terakhir.
Selanjutnya dalam tutorial pembelajaran PyTorch Transfer ini, kita akan mempelajari cara menggunakan Transfer Learning dengan PyTorch.
Memuat Set Data
Sumber: Alien vs. Predator Kaggle
Sebelum Anda mulai menggunakan Transfer Learning PyTorch, Anda perlu memahami kumpulan data yang akan Anda gunakan. Dalam contoh Transfer Learning PyTorch ini, Anda akan mengklasifikasikan Alien dan Predator dari hampir 700 gambar. Untuk teknik ini, Anda tidak membutuhkan banyak data untuk dilatih. Anda dapat mengunduh kumpulan data dari Kaggle: Alien vs. Predator.
Bagaimana Cara Menggunakan Pembelajaran Transfer?
Berikut adalah proses langkah demi langkah tentang cara menggunakan Transfer Learning untuk Deep Learning dengan PyTorch:
Langkah 1) Muat Data
Langkah pertama adalah memuat data kita dan melakukan beberapa transformasi ke gambar agar sesuai dengan persyaratan jaringan.
Anda akan memuat data dari folder dengan torchvision.dataset. Modul akan melakukan iterasi dalam folder untuk memisahkan data untuk pelatihan dan validasi. Proses transformasi akan memotong gambar dari tengah, melakukan flip horizontal, menormalkan, dan terakhir mengubahnya menjadi tensor menggunakan Deep Learning.
from __future__ import print_function, divisionimport osimport timeimport torchimport torchvisionfrom torchvision import datasets, models, transformsimport torch.optim as optimimport numpy as npimport matplotlib.pyplot as pltdata_dir = "alien_pred"input_shape = 224mean = [0.5, 0.5, 0.5]std = [0.5, 0.5, 0.5]#data transformationdata_transforms = {'train': transforms.Compose([transforms.CenterCrop(input_shape),transforms.ToTensor(),transforms.Normalize(mean, std)]),'validation': transforms.Compose([transforms.CenterCrop(input_shape),transforms.ToTensor(),transforms.Normalize(mean, std)]),}image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),transform=data_transforms[x])for x in ['train', 'validation']}dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=32,shuffle=True, num_workers=4)for x in ['train', 'validation']}dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'validation']}print(dataset_sizes)class_names = image_datasets['train'].classesdevice = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
Mari visualisasikan kumpulan data kita untuk PyTorch Transfer Learning. Proses visualisasi akan mendapatkan kumpulan gambar berikutnya dari pemuat data dan label kereta dan menampilkannya dengan matplot.
images, labels = next(iter(dataloaders['train']))rows = 4columns = 4fig=plt.figure()for i in range(16):fig.add_subplot(rows, columns, i+1)plt.title(class_names[labels[i]])img = images[i].numpy().transpose((1, 2, 0))img = std * img + meanplt.imshow(img)plt.show()
Langkah 2) Tentukan Model
Dalam proses Pembelajaran Mendalam ini, Anda akan menggunakan ResNet18 dari modul torchvision.
Anda akan menggunakan torchvision.models untuk memuat resnet18 dengan bobot yang telah dilatih sebelumnya disetel ke True. Setelah itu, Anda akan membekukan lapisan tersebut sehingga lapisan tersebut tidak bisa dilatih. Anda juga memodifikasi layer terakhir dengan layer Linear agar sesuai dengan kebutuhan kita yaitu 2 kelas. Anda juga menggunakan CrossEntropyLoss untuk fungsi kerugian multi-kelas dan untuk pengoptimal Anda akan menggunakan SGD dengan kecepatan pembelajaran 0,0001 dan momentum 0,9 seperti yang ditunjukkan pada contoh Pembelajaran Transfer PyTorch di bawah ini.
## Load the model based on VGG19vgg_based = torchvision.models.vgg19(pretrained=True)## freeze the layersfor param in vgg_based.parameters():param.requires_grad = False# Modify the last layernumber_features = vgg_based.classifier[6].in_featuresfeatures = list(vgg_based.classifier.children())[:-1] # Remove last layerfeatures.extend([torch.nn.Linear(number_features, len(class_names))])vgg_based.classifier = torch.nn.Sequential(*features)vgg_based = vgg_based.to(device)print(vgg_based)criterion = torch.nn.CrossEntropyLoss()optimizer_ft = optim.SGD(vgg_based.parameters(), lr=0.001, momentum=0.9)
Struktur model keluaran
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace)(16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(17): ReLU(inplace)(18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace)(23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(24): ReLU(inplace)(25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(26): ReLU(inplace)(27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace)(30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(31): ReLU(inplace)(32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(33): ReLU(inplace)(34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(35): ReLU(inplace)(36): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(classifier): Sequential((0): Linear(in_features=25088, out_features=4096, bias=True)(1): ReLU(inplace)(2): Dropout(p=0.5)(3): Linear(in_features=4096, out_features=4096, bias=True)(4): ReLU(inplace)(5): Dropout(p=0.5)(6): Linear(in_features=4096, out_features=2, bias=True)))
Langkah 3) Melatih dan Menguji Model
Kami akan menggunakan beberapa fungsi dari Transfer Learning PyTorch Tutorial untuk membantu kami melatih dan mengevaluasi model kami.
def train_model(model, criterion, optimizer, num_epochs=25):since = time.time()for epoch in range(num_epochs):print('Epoch {}/{}'.format(epoch, num_epochs - 1))print('-' * 10)#set model to trainable# model.train()train_loss = 0# Iterate over data.for i, data in enumerate(dataloaders['train']):inputs , labels = datainputs = inputs.to(device)labels = labels.to(device)optimizer.zero_grad()with torch.set_grad_enabled(True):outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item() * inputs.size(0)print('{} Loss: {:.4f}'.format('train', train_loss / dataset_sizes['train']))time_elapsed = time.time() - sinceprint('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))return modeldef visualize_model(model, num_images=6):was_training = model.trainingmodel.eval()images_so_far = 0fig = plt.figure()with torch.no_grad():for i, (inputs, labels) in enumerate(dataloaders['validation']):inputs = inputs.to(device)labels = labels.to(device)outputs = model(inputs)_, preds = torch.max(outputs, 1)for j in range(inputs.size()[0]):images_so_far += 1ax = plt.subplot(num_images//2, 2, images_so_far)ax.axis('off')ax.set_title('predicted: {} truth: {}'.format(class_names[preds[j]], class_names[labels[j]]))img = inputs.cpu().data[j].numpy().transpose((1, 2, 0))img = std * img + meanax.imshow(img)if images_so_far == num_images:model.train(mode=was_training)returnmodel.train(mode=was_training)
Terakhir dalam contoh Transfer Learning in PyTorch ini, mari kita mulai proses pelatihan kita dengan jumlah epoch yang disetel ke 25 dan evaluasi setelah proses pelatihan. Pada setiap tahap pelatihan, model akan mengambil masukan dan memprediksi keluaran. Setelah itu, keluaran yang diprediksi akan diteruskan ke kriteria untuk menghitung kerugian. Kemudian kerugian akan melakukan perhitungan backprop untuk menghitung gradien dan terakhir menghitung bobot dan mengoptimalkan parameter dengan autograd.
Pada model visualisasi, jaringan yang terlatih akan diuji dengan sekumpulan gambar untuk memprediksi label. Kemudian akan divisualisasikan dengan bantuan matplotlib.
vgg_based = train_model(vgg_based, criterion, optimizer_ft, num_epochs=25)visualize_model(vgg_based)plt.show()
Langkah 4) Hasil
Hasil akhirnya adalah Anda mencapai akurasi 92%.
Epoch 23/24----------train Loss: 0.0044train Loss: 0.0078train Loss: 0.0141train Loss: 0.0221train Loss: 0.0306train Loss: 0.0336train Loss: 0.0442train Loss: 0.0482train Loss: 0.0557train Loss: 0.0643train Loss: 0.0763train Loss: 0.0779train Loss: 0.0843train Loss: 0.0910train Loss: 0.0990train Loss: 0.1063train Loss: 0.1133train Loss: 0.1220train Loss: 0.1344train Loss: 0.1382train Loss: 0.1429train Loss: 0.1500Epoch 24/24----------train Loss: 0.0076train Loss: 0.0115train Loss: 0.0185train Loss: 0.0277train Loss: 0.0345train Loss: 0.0420train Loss: 0.0450train Loss: 0.0490train Loss: 0.0644train Loss: 0.0755train Loss: 0.0813train Loss: 0.0868train Loss: 0.0916train Loss: 0.0980train Loss: 0.1008train Loss: 0.1101train Loss: 0.1176train Loss: 0.1282train Loss: 0.1323train Loss: 0.1397train Loss: 0.1436train Loss: 0.1467Training complete in 2m 47s
Akhiri kemudian keluaran model kita akan divisualisasikan dengan matplot di bawah ini:
Ringkasan
Jadi, mari kita rangkum semuanya! Faktor pertama adalah PyTorch adalah kerangka pembelajaran mendalam yang berkembang untuk pemula atau untuk tujuan penelitian. Ini menawarkan waktu komputasi yang tinggi, Grafik Dinamis, dukungan GPU dan sepenuhnya ditulis dengan Python. Anda dapat menentukan modul jaringan kami sendiri dengan mudah dan melakukan proses pelatihan dengan iterasi yang mudah. Jelas bahwa PyTorch sangat ideal bagi pemula untuk mengetahui pembelajaran mendalam dan bagi peneliti profesional itu sangat berguna dengan waktu komputasi yang lebih cepat dan juga fungsi autograd yang sangat membantu untuk membantu grafik dinamis.