Convolutional Neural Network – Implementasi PyTorch Pada Dataset CIFAR-10

Diterbitkan Ulang Oleh Plato

Followers: 0

Artikel ini diterbitkan sebagai bagian dari Blogathon Ilmu Data

Pengantar

Cifar 10 | Jaringan saraf konvolusi pytorch — gambar 1

Jaringan saraf convolutional, juga disebut ConvNets, pertama kali diperkenalkan pada 1980-an oleh Yann LeCun, seorang peneliti ilmu komputer yang bekerja di latar belakang. LeCun dibangun di atas karya Kunihiko Fukushima, seorang ilmuwan Jepang, jaringan dasar untuk pengenalan gambar.

Versi lama CNN, yang disebut LeNet (setelah LeCun), dapat melihat angka tulisan tangan. CNN membantu menemukan kode pin dari pos. Namun terlepas dari keahlian mereka, ConvNets tetap dekat dengan visi komputer dan kecerdasan buatan karena mereka menghadapi masalah besar: Mereka tidak dapat menskalakan banyak. CNN membutuhkan banyak data dan mengintegrasikan sumber daya untuk bekerja dengan baik untuk gambar besar.

Pada saat itu, metode ini hanya berlaku untuk gambar beresolusi rendah. Pytorch adalah perpustakaan yang dapat melakukan operasi pembelajaran mendalam. Kita dapat menggunakan ini untuk melakukan jaringan saraf Convolutional. Jaringan saraf convolutional mengandung banyak lapisan neuron buatan. Neuron sintetis, simulasi kompleks rekan biologis, adalah fungsi matematika yang menghitung massa tertimbang dari beberapa input dan aktivasi nilai produk.

Jaringan saraf konvolusi pytorch — gambar 2

Gambar di atas menunjukkan kepada kita model CNN yang mengambil gambar seperti digit 2 dan memberi kita hasil digit apa yang ditunjukkan pada gambar sebagai angka. Kami akan membahas secara rinci bagaimana kami mendapatkan ini di artikel ini.

CIFAR-10 adalah dataset yang memiliki kumpulan citra dari 10 kelas yang berbeda. Dataset ini banyak digunakan untuk tujuan penelitian untuk menguji berbagai model pembelajaran mesin dan terutama untuk masalah penglihatan komputer. Pada artikel ini, kami akan mencoba membangun model Neural network menggunakan Pytorch dan mengujinya pada dataset CIFAR-10 untuk memeriksa akurasi prediksi apa yang dapat diperoleh.

Mengimpor Pustaka PyTorch

impor numpy sebagai np impor panda sebagai pd

impor obor impor torch.nn.fungsional sebagai F dari set data impor torchvision,transformasi dari impor obor nn impor matplotlib.pyplot sebagai plt impor numpy sebagai np impor seaborn sebagai sns #dari tqdm.notebook impor tqdm dari tqdm impor tqdm

Pada langkah ini, kami mengimpor perpustakaan yang diperlukan. Kita dapat melihat bahwa kita menggunakan NumPy untuk operasi numerik dan panda untuk operasi bingkai data. Pustaka obor digunakan untuk mengimpor Pytorch.

Pytorch memiliki komponen nn yang digunakan untuk abstraksi operasi dan fungsi pembelajaran mesin. Ini diimpor sebagai F. Pustaka torchvision digunakan agar kita dapat mengimpor kumpulan data CIFAR-10. Pustaka ini memiliki banyak kumpulan data gambar dan banyak digunakan untuk penelitian. Transformasi dapat diimpor sehingga kita dapat mengubah ukuran gambar menjadi ukuran yang sama untuk semua gambar. tqdm digunakan agar kita dapat melacak kemajuan selama pelatihan dan digunakan untuk visualisasi.

Baca Dataset yang diperlukan

trainData = pd.read_csv('cifar-10/trainLabels.csv') trainData.head()

Setelah kita membaca dataset kita dapat melihat berbagai label seperti katak, truk, rusa, mobil, dll.

Menganalisis data dengan PyTorch

print("Jumlah poin:",trainData.shape[0]) print("Jumlah fitur:",trainData.shape[1]) print("Fitur:",trainData.columns.values) print("Jumlah Nilai Unik") untuk col di trainData: print(col,":",len(trainData[col].unique())) plt.figure(figsize=(12,8))

Keluaran:

Jumlah poin: 50000 Jumlah fitur: 2 Fitur: ['id' 'label'] Jumlah Nilai Unik id : 50000 label : 10

Pada langkah ini, kami menganalisis dataset dan melihat bahwa data kereta kami memiliki sekitar 50000 baris dengan id dan label terkait. Total ada 10 kelas seperti pada nama CIFAR-10.

Mendapatkan set validasi menggunakan PyTorch

dari torch.utils.data import random_split val_size = 5000 train_size = len(set data) - val_size train_ds, val_ds = random_split(set data, [train_size, val_size]) len(train_ds), len(val_ds)

Langkah ini sama dengan langkah pelatihan, tetapi kami ingin membagi data menjadi rangkaian pelatihan dan validasi.

(45000, 5000)

dari torch.utils.data.dataloader import DataLoader batch_size=64 train_dl = DataLoader(train_ds, batch_size, shuffle=True, num_workers=4, pin_memory=True) val_dl = DataLoader(val_ds, batch_size, num_workers=4, pin_memory=True

Torch.utils memiliki pemuat data yang dapat membantu kami memuat data yang diperlukan dengan melewati berbagai parameter seperti nomor pekerja atau ukuran batch.

Mendefinisikan fungsi yang diperlukan

@torch.no_grad() def akurasi(output, label): _, preds = torch.max(outputs, dim=1) return torch.tensor(torch.sum(preds == labels).item() / len(preds )) class ImageClassificationBase(nn.Module): def training_step(self, batch): images, labels = batch out = self(images) # Menghasilkan prediksi loss = F.cross_entropy(out, labels) # Hitung loss accu = akurasi(out ,labels) return loss,accu def validation_step(self, batch): images, labels = batch out = self(images) # Menghasilkan prediksi loss = F.cross_entropy(out, labels) # Hitung loss acc = akurasi(out, labels) # Hitung akurasi pengembalian {'Loss': loss.detach(), 'Accuracy': acc} def validasi_epoch_end(self, outputs): batch_losses = [x['Loss'] for x in outputs] epoch_loss = torch.stack(batch_losses ).mean() # Gabungkan kerugian batch_accs = [x['Accuracy'] untuk x dalam output] epoch_acc = torch.stack(batch_accs).mean() # Gabungkan akurasi kembali {'Loss': epoch_loss.item(), ' Akurasi': epoch_acc.item()} def epoch_end(self, epoch, hasil): pr int("Epoch :",epoch + 1) print(f'Train Accuracy:{result["train_accuracy"]*100:.2f}% Validasi Akurasi:{result["Accuracy"]*100:.2f}%' ) print(f'Train Loss:{result["train_loss"]:.4f} Validasi Rugi:{result["Loss"]:.4f}')

Seperti yang bisa kita lihat di sini kita telah menggunakan implementasi kelas ImageClassification dan dibutuhkan satu parameter yaitu nn.Module. Di dalam kelas ini, kita dapat mengimplementasikan berbagai fungsi atau berbagai langkah seperti pelatihan, validasi, dll. Fungsi-fungsi di sini adalah implementasi python sederhana.

Langkah pelatihan mengambil gambar dan label dalam batch. kami menggunakan cross-entropy untuk fungsi kerugian dan menghitung kerugian dan mengembalikan kerugian. Ini mirip dengan langkah validasi seperti yang bisa kita lihat di fungsi. Zaman berakhir menggabungkan kerugian dan akurasi dan akhirnya, kami mencetak akurasi dan kerugian.

Implementasi modul jaringan saraf convolutional

class Cifar10CnnModel(ImageClassificationBase): def __init__(self): super().__init__() self.network = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), # keluaran: 64 x 16 x 16 nn.BatchNorm2d(64) , nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1), nn .ReLU(), nn.MaxPool2d(2, 2), # keluaran: 128 x 8 x 8 nn.BatchNorm2d(128), nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), # keluaran: 256 x 4 x 4 nn.BatchNorm2d(256), nn.Flatten(), nn.Linear(256*4*4, 1024), nn.ReLU(), nn.Linear(1024, 512), nn.ReLU(), nn.Linear (512, 10)) def forward(self, xb): kembalikan self.network(xb)

Ini adalah bagian terpenting dari implementasi jaringan saraf. Sepanjang, kami menggunakan modul nn yang kami impor dari obor. Seperti yang bisa kita lihat di baris pertama, Conv2d adalah modul yang membantu mengimplementasikan jaringan saraf convolutional. Parameter pertama 3 di sini menyatakan bahwa gambar berwarna dan dalam format RGB. Jika itu adalah gambar skala abu-abu, kami akan memilih 1.

32 adalah ukuran saluran output awal dan ketika kita pergi untuk lapisan conv2d berikutnya kita akan memiliki 32 ini sebagai saluran input dan 64 sebagai saluran output.

Parameter ke-3 di baris pertama disebut ukuran kernel dan ini membantu kita menjaga filter yang digunakan. Operasi padding adalah parameter terakhir.

Operasi konvolusi terhubung ke lapisan aktivasi dan Relu di sini. Setelah dua lapisan Conv2d, kami memiliki operasi max-pooling ukuran 2 * 2. Nilai yang keluar dari ini adalah batch dinormalisasi untuk stabilitas dan untuk menghindari pergeseran kovariat internal. Operasi ini diulang dengan lebih banyak lapisan untuk memperdalam jaringan dan mengurangi ukurannya. Terakhir, kami meratakan layer sehingga kami dapat membangun layer linier untuk memetakan nilai ke 10 nilai. Probabilitas masing-masing neuron dari 10 neuron ini akan menentukan kelas mana yang dimiliki oleh gambar tertentu berdasarkan probabilitas maksimum.

Latih modelnya

@torch.no_grad() def evaluasi(model, data_loader): model.eval() outputs = [model.validation_step(batch) untuk batch dalam data_loader] kembalikan model.validation_epoch_end(outputs) def fit(model, train_loader, val_loader,epochs =10,learning_rate=0.001: best_valid = Tidak ada history = [] optimizer = torch.optim.Adam(model.parameters(), learning_rate,weight_decay=0.0005) untuk epoch dalam jangkauan(epochs): # Training Phase model.train( ) train_losses = [] train_accuracy = [] untuk batch di tqdm(train_loader): loss,accu = model.training_step(batch) train_losses.append(loss) train_accuracy.append(accu) loss.backward() optimizer.step() pengoptimal .zero_grad() # Hasil fase validasi = evaluasi(model, val_loader) hasil['train_loss'] = torch.stack(train_losses).mean().item() result['train_accuracy'] = torch.stack(train_accuracy). mean().item() model.epoch_end(Epoch, hasil) if(best_valid == Tidak ada atau best_valid

sejarah = fit(model, train_dl, val_dl)

Ini adalah langkah dasar untuk melatih model kita untuk mendapatkan hasil yang diinginkan. fungsi fit disini akan menyesuaikan data train dan Val dengan model yang kita buat. Fungsi fit awalnya mengambil daftar yang disebut riwayat yang menangani data iterasi setiap zaman. Kami menjalankan for loop sehingga kami dapat mengulangi setiap epoch. Untuk setiap batch, kami memastikan bahwa kami menunjukkan kemajuan menggunakan tqdm. Kami menyebut langkah pelatihan yang kami terapkan sebelumnya dan menghitung akurasi dan kerugian. Pergi untuk propagasi mundur dan menjalankan pengoptimal yang telah kita definisikan sebelumnya. Setelah kami melakukan ini, kami melacak daftar kami dan fungsi membantu kami mencetak detail dan kemajuan.

Fungsi evaluasi, di sisi lain, menggunakan fungsi evaluasi, dan untuk setiap langkah, kami mengambil batch yang dimuat dari pemuat data, dan output dihitung. Nilai kemudian diteruskan ke akhir epoch validasi yang kita definisikan sebelumnya dan nilai masing-masing dikembalikan.

Merencanakan hasil

Pada langkah ini, kita akan memvisualisasikan akurasi vs setiap epoch. Kita dapat mengamati bahwa seiring bertambahnya zaman, akurasi sistem terus meningkat dan demikian pula kerugiannya terus menurun. Garis merah di sini menunjukkan kemajuan data pelatihan dan biru untuk validasi. Kita dapat melihat bahwa ada banyak overfitting dalam hasil kami karena data pelatihan cukup mengungguli hasil validasi dan juga jika terjadi kehilangan. Setelah 10 epoch, data train tampaknya melewati akurasi 90% tetapi kehilangan sekitar 0.5. Data uji datang sekitar 81% dan kerugiannya mendekati 0.2.

def plot_accuracies(history): Validation_accuracies = [x['Accuracy'] untuk x dalam riwayat] Training_Accuracy = [x['train_accuracy'] untuk x dalam riwayat] plt.plot(Training_Accuracy, '-rx') plt.plot(Validation_accuracies , '-bx') plt.xlabel('epoch') plt.ylabel('accuracy') plt.legend(['Training', 'Validation']) plt.title('Accuracy vs. No. of epochs') ; plot_akurasi(sejarah)

def plot_losses(history): train_losses = [x.get('train_loss') untuk x dalam sejarah] val_losses = [x['Loss'] untuk x dalam sejarah] plt.plot(train_losses, '-bx') plt.plot (val_losses, '-rx') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(['Training', 'Validation']) plt.title('Loss vs. Jumlah epochs '); plot_losses(sejarah)

test_dataset = ImageFolder(data_dir+'/test', transform=ToTensor()) test_loader = DeviceDataLoader(DataLoader(test_dataset, batch_size), device) result = evaluasi(final_model, test_loader) print(f'Test Accuracy:{result["Accuracy" ]*100:.2f}%')

Akurasi Tes: 81.07%

Kita dapat melihat bahwa kita berakhir dengan akurasi 81.07%.

Kesimpulan:

Gambar: https://unsplash.com/photos/5L0R8ZqPZHk

Tentang saya: Saya seorang Mahasiswa Riset yang tertarik di bidang Pembelajaran Mendalam dan Pemrosesan Bahasa Alami dan saat ini sedang mengejar pasca-kelulusan dalam Kecerdasan Buatan.

Sumber Gambar

Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
Gambar 2: https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/

Jangan ragu untuk terhubung dengan saya di: