Apa itu Pembelajaran Pemindahan?
Transfer Learning adalah teknik menggunakan model terlatih untuk menyelesaikan tugas lain yang berkaitan. Ini adalah kaedah penyelidikan Pembelajaran Mesin yang menyimpan pengetahuan yang diperoleh semasa menyelesaikan masalah tertentu dan menggunakan pengetahuan yang sama untuk menyelesaikan masalah lain yang berbeza tetapi berkaitan. Ini meningkatkan kecekapan dengan menggunakan semula maklumat yang dikumpulkan dari tugas yang telah dipelajari sebelumnya.
Sangat popular menggunakan berat model rangkaian yang lain untuk mengurangkan masa latihan anda kerana anda memerlukan banyak data untuk melatih model rangkaian. Untuk mengurangkan masa latihan, anda menggunakan rangkaian lain dan beratnya dan ubah lapisan terakhir untuk menyelesaikan masalah kami. Kelebihannya ialah anda boleh menggunakan set data kecil untuk melatih lapisan terakhir.
Selanjutnya dalam tutorial pembelajaran PyTorch Transfer ini, kita akan belajar bagaimana menggunakan Transfer Learning dengan PyTorch.
Memuatkan Set Data
Sumber: Alien vs Predator Kaggle
Sebelum anda mula menggunakan Transfer Learning PyTorch, anda perlu memahami set 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 memerlukan banyak data untuk dilatih. Anda boleh memuat turun set data dari Kaggle: Alien vs. Predator.
Bagaimana Menggunakan Pembelajaran Transfer?
Berikut adalah proses langkah demi langkah mengenai cara menggunakan Transfer Learning untuk Pembelajaran Dalam dengan PyTorch:
Langkah 1) Muatkan Data
Langkah pertama adalah memuatkan data kita dan melakukan beberapa transformasi kepada gambar sehingga sesuai dengan keperluan rangkaian.
Anda akan memuatkan data dari folder dengan torchvision.dataset. Modul akan berulang dalam folder untuk membahagikan data untuk kereta api dan pengesahan. Proses transformasi akan memotong gambar dari tengah, melakukan flip mendatar, menormalkan, dan akhirnya 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 gambarkan set data kami untuk Pembelajaran PyTorch Transfer. Proses visualisasi akan mendapatkan kumpulan gambar seterusnya dari pemuat data dan label kereta api dan memaparkannya 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 Dalam ini, anda akan menggunakan ResNet18 dari modul torchvision.
Anda akan menggunakan torchvision.models untuk memuatkan resnet18 dengan berat yang telah dilatih ditetapkan menjadi Benar. Selepas itu, anda akan membekukan lapisan supaya lapisan ini tidak dapat dilatih. Anda juga mengubah lapisan terakhir dengan lapisan Linear agar sesuai dengan keperluan kami iaitu 2 kelas. Anda juga menggunakan CrossEntropyLoss untuk fungsi kerugian multi-kelas dan untuk pengoptimum anda akan menggunakan SGD dengan kadar pembelajaran 0.0001 dan momentum 0.9 seperti yang ditunjukkan dalam contoh Pembelajaran PyTorch Transfer Learning di bawah.
## 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) Latih Tubi dan Model Ujian
Kami akan menggunakan beberapa fungsi dari Transfer Learning PyTorch Tutorial untuk membantu kami melatih dan menilai 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)
Akhirnya dalam contoh Transfer Learning in PyTorch ini, mari kita mulakan proses latihan kita dengan bilangan zaman yang ditetapkan kepada 25 dan menilai setelah proses latihan. Pada setiap langkah latihan, model akan mengambil input dan meramalkan hasilnya. Selepas itu, output yang diramalkan akan diteruskan ke kriteria untuk mengira kerugian. Kemudian kerugian akan melakukan pengiraan backprop untuk mengira kecerunan dan akhirnya mengira berat dan mengoptimumkan parameter dengan autograd.
Pada model visualisasi, rangkaian terlatih akan diuji dengan sekumpulan gambar untuk meramalkan label. Kemudian ia akan digambarkan 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 ialah anda mencapai ketepatan 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
Tamat maka output model kami akan dapat dilihat dengan matplot di bawah:
Ringkasan
Oleh itu, mari kita ringkaskan semuanya! Faktor pertama ialah PyTorch adalah kerangka pembelajaran mendalam yang semakin meningkat untuk pemula atau untuk tujuan penyelidikan. Ia menawarkan masa pengiraan yang tinggi, Grafik Dinamik, sokongan GPU dan semuanya ditulis dalam Python. Anda dapat menentukan modul rangkaian kami sendiri dengan mudah dan melakukan proses latihan dengan lelaran yang mudah. Sudah jelas bahawa PyTorch sangat sesuai untuk pemula untuk mengetahui pembelajaran mendalam dan bagi penyelidik profesional sangat berguna dengan masa pengiraan yang lebih cepat dan juga fungsi autograd yang sangat membantu untuk membantu grafik dinamik.