Evrişimli Sinir Ağı – CIFAR-10 Veri Kümesinde PyTorch Uygulaması

Plato tarafından yeniden yayınlandı

İzleyiciler: 0

Giriş

Cifar 10 | Evrişimli sinir ağları pytorch — görüntü 1

ConvNets olarak da adlandırılan evrişimsel sinir ağları, ilk olarak 1980'lerde arka planda çalışan bir bilgisayar bilimi araştırmacısı olan Yann LeCun tarafından tanıtıldı. LeCun, görüntü tanıma için temel bir ağ olan Japon bilim adamı Kunihiko Fukushima'nın çalışmaları üzerine inşa edildi.

CNN'nin LeNet (LeCun'dan sonra) olarak adlandırılan eski versiyonu, el yazısı rakamları görebilir. CNN, postadan pin kodlarını bulmaya yardımcı olur. Ancak uzmanlıklarına rağmen ConvNets, bilgisayar görüşüne ve yapay zekaya yakın kaldı çünkü büyük bir sorunla karşı karşıya kaldılar: Çok fazla ölçeklenemediler. CNN'ler, büyük görüntüler için iyi çalışması için çok fazla veri gerektirir ve kaynakları entegre eder.

O zamanlar bu yöntem yalnızca düşük çözünürlüklü görüntüler için geçerliydi. Pytorch, derin öğrenme işlemleri yapabilen bir kütüphanedir. Bunu, Evrişimli sinir ağlarını gerçekleştirmek için kullanabiliriz. Evrişimsel sinir ağları, birçok yapay nöron katmanı içerir. Biyolojik muadillerinin karmaşık simülasyonları olan sentetik nöronlar, çoklu girdilerin ağırlıklı kütlesini ve ürün değeri aktivasyonunu hesaplayan matematiksel fonksiyonlardır.

Evrişimli sinir ağları pytorch — görüntü 2

Yukarıdaki görüntü bize 2 rakamına benzer bir görüntü alan ve görüntüde hangi rakamın sayı olarak gösterildiğinin sonucunu veren bir CNN modelini göstermektedir. Bunu nasıl elde ettiğimizi bu makalede ayrıntılı olarak tartışacağız.

CIFAR-10, 10 farklı sınıfa ait görüntü koleksiyonuna sahip bir veri kümesidir. Bu veri seti, farklı makine öğrenme modellerini test etmek için araştırma amaçlı ve özellikle bilgisayarla görme sorunları için yaygın olarak kullanılmaktadır. Bu yazımızda, Pytorch kullanarak bir Sinir ağı modeli oluşturmaya ve bunu CIFAR-10 veri seti üzerinde test ederek hangi tahmin doğruluğunun elde edilebileceğini kontrol etmeye çalışacağız.

PyTorch Kitaplığını İçe Aktarma

numpy'yi np olarak içe aktar pandaları pd olarak içe aktar

torcu içe aktar torch.nn.işlevselini F olarak torçvision veri kümelerinden içe aktar, torçtan dönüşümleri içe aktar nn'den matplotlib.pyplot'u plt olarak içe aktar numpy'yi np olarak içe aktar Seaborn'u sns olarak içe aktar # tqdm.notebook'tan tqdm'den tqdm'yi içe aktar tqdm

Bu adımda gerekli kütüphaneleri içe aktarıyoruz. NumPy'yi sayısal işlemler için ve pandaları veri çerçevesi işlemleri için kullandığımızı görebiliriz. Torç kitaplığı, Pytorch'u içe aktarmak için kullanılır.

Pytorch, makine öğrenimi işlemlerinin ve işlevlerinin soyutlanması için kullanılan bir nn bileşenine sahiptir. Bu F olarak içe aktarılır. CIFAR-10 veri setini içe aktarabilmemiz için torçvizyon kitaplığı kullanılır. Bu kütüphane birçok görüntü veri setine sahiptir ve araştırma için yaygın olarak kullanılmaktadır. Görüntüyü tüm görüntüler için eşit boyuta yeniden boyutlandırabilmemiz için dönüşümler içe aktarılabilir. tqdm, eğitim sırasında ilerlemeyi takip edebilmemiz için kullanılır ve görselleştirme için kullanılır.

Gerekli Veri Kümesini okuyun

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

Veri setini okuduktan sonra kurbağa, kamyon, geyik, otomobil vb. gibi çeşitli etiketler görebiliriz.

PyTorch ile verileri analiz etme

print("Nokta sayısı:",trainData.shape[0]) print("Özellik sayısı:",trainData.shape[1]) print("Özellikler:",trainData.columns.values) print("Sayısı TrainData'da col için Benzersiz Değerler"): print(col,":",len(trainData[col].unique())) plt.figure(figsize=(12,8))

Çıktı:

Puan sayısı: 50000 Özellik sayısı: 2 Özellik: ['id' 'label'] Benzersiz Değer Sayısı id : 50000 etiket : 10

Bu adımda, veri setini analiz ediyoruz ve tren verilerimizin kimlikleri ve ilgili etiketleriyle birlikte yaklaşık 50000 satıra sahip olduğunu görüyoruz. CIFAR-10 isminde olduğu gibi toplam 10 sınıf bulunmaktadır.

PyTorch kullanarak doğrulama setini alma

torch.utils.data'dan içe aktar random_split val_size = 5000 train_size = len(veri kümesi) - val_size train_ds, val_ds = random_split(veri kümesi, [train_size, val_size]) len(train_ds), len(val_ds)

Bu adım, eğitim adımıyla aynıdır, ancak verileri eğitim ve doğrulama kümelerine bölmek istiyoruz.

(45000, 5000)

torch.utils.data.dataloader'dan DataLoader'ı içe aktarın 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=Tru_mem)

Torç.utils, çalışan numarası veya parti boyutu gibi çeşitli parametreleri atlayarak gerekli verileri yüklememize yardımcı olabilecek bir veri yükleyiciye sahiptir.

Gerekli fonksiyonların tanımlanması

@torch.no_grad() def doğruluk(çıktılar, etiketler): _, preds = torch.max(çıkışlar, dim=1) dönüş torch.tensor(torch.sum(preds == etiketler).item() / len(preds )) class ImageClassificationBase(nn.Module): def training_step(self, toplu): görüntüler, etiketler = toplu çıkış = self(görüntüler) # Tahmin oluştur kaybı = F.cross_entropy(out, labels) # Kaybı hesapla accu = doğruluk(çıkış) ,etiketler) geri dönüş kaybı,accu def validation_step(self, toplu): görüntüler, etiketler = toplu çıkış = self(görüntüler) # Tahmin oluştur kaybı = F.cross_entropy(out, etiketler) # Kaybı hesapla acc = doğruluk(çıkış, etiketler) # Doğruluk dönüşünü hesapla {'Kayıp': kayıp.detach(), 'Doğruluk': acc} def validation_epoch_end(kendi, çıktılar): batch_losses = çıkışlarda x için [x['Kayıp'] epoch_loss = torch.stack(batch_losses) .mean() # Kayıpları birleştir batch_accs = çıkışlarda x için [x['Doğruluk']] epoch_acc = torch.stack(batch_accs).mean() # Doğrulukları bir araya getir {'Kayıp': epoch_loss.item(), ' Doğruluk': epoch_acc.item()} def epoch_end(self, çağ, sonuç): pr int("Epoch :",epoch + 1) print(f'Train Accuracy:{result["train_accuracy"]*100:.2f}% Doğrulama Doğruluğu:{sonuç["Doğruluk"]*100:.2f}%' ) print(f'Tren Kaybı:{sonuç["tren_kaybı"]:.4f} Doğrulama Kaybı:{sonuç["Kayıp"]:.4f}')

Burada görebileceğimiz gibi, ImageClassification'ın sınıf uygulamasını kullandık ve nn.Module olan bir parametre alıyor. Bu sınıf içerisinde çeşitli fonksiyonları veya eğitim, doğrulama vb. çeşitli adımları uygulayabiliriz. Buradaki fonksiyonlar basit python uygulamalarıdır.

Eğitim adımı, toplu olarak görüntüleri ve etiketleri alır. kayıp fonksiyonu için çapraz entropiyi kullanırız ve kaybı hesaplar ve kaybı döndürürüz. Bu, fonksiyonda gördüğümüz gibi doğrulama adımına benzer. Dönem sonları, kayıpları ve doğrulukları birleştirir ve son olarak, doğrulukları ve kayıpları yazdırırız.

Evrişimli sinir ağı modülünün uygulanması

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, adım=1, dolgu=1), nn.ReLU(), nn.MaxPool2d(2, 2), # çıktı: 64 x 16 x 16 nn.BatchNorm2d(64) , nn.Conv2d(64, 128, kernel_size=3, adım=1, dolgu=1), nn.ReLU(), nn.Conv2d(128, 128, kernel_size=3, adım=1, dolgu=1), nn .ReLU(), nn.MaxPool2d(2, 2), # çıktı: 128 x 8 x 8 nn.BatchNorm2d(128), nn.Conv2d(128, 256, kernel_size=3, adım=1, dolgu=1), nn.ReLU(), nn.Conv2d(256, 256, kernel_size=3, adım=1, dolgu=1), nn.ReLU(), nn.MaxPool2d(2, 2), # çıktı: 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): self.network(xb) döndür

Bu, sinir ağı uygulamasının en önemli kısmıdır. Boyunca torçtan ithal ettiğimiz nn modülünü kullanıyoruz. İlk satırda görebileceğimiz gibi, Conv2d, evrişimli bir sinir ağının uygulanmasına yardımcı olan bir modüldür. Buradaki ilk parametre 3, görüntünün renkli ve RGB formatında olduğunu gösterir. Gri tonlamalı bir görüntü olsaydı, 1'e giderdik.

32, ilk çıkış kanalının boyutudur ve bir sonraki conv2d katmanına gittiğimizde bu 32'yi giriş kanalı ve 64'ü çıkış kanalı olarak alırdık.

İlk satırdaki 3. parametreye çekirdek boyutu denir ve kullanılan filtrelerin bakımını yapmamıza yardımcı olur. Doldurma işlemi son parametredir.

Evrişim işlemi burada bir aktivasyon katmanına ve Relu'ya bağlıdır. İki Conv2d katmanından sonra, 2 * 2 boyutunda bir maksimum havuzlama işlemine sahibiz. Bundan çıkan değer, kararlılık için ve dahili ortak değişken kaymasını önlemek için toplu olarak normalleştirilir. Bu işlemler ağı derinleştirmek ve boyutu küçültmek için daha fazla katmanla tekrarlanır. Son olarak, değerleri 10 değere eşlemek için doğrusal bir katman oluşturabilmemiz için katmanı düzleştiririz. Bu 10 nöronun her bir nöronunun olasılığı, maksimum olasılığa bağlı olarak belirli bir görüntünün hangi sınıfa ait olduğunu belirleyecektir.

Modeli eğitin

@torch.no_grad() def değerlendirme(model, data_loader): model.eval() çıkışlar = data_loader'daki toplu iş için model.validation_step(batch)] dönüş model.validation_epoch_end(çıkışlar) def fit(model, train_loader, val_loader,epochs) =10,learning_rate=0.001): best_valid = Geçmiş yok = [] optimizer = torch.optim.Adam(model.parameters(), learning_rate,weight_decay=0.0005) epoch in range(epochs): # Training Phase model.train( ) train_lossses = [] train_accuracy = [] tqdm'deki toplu iş için(train_loader): kayıp,accu = model.training_step(batch) train_lossses.append(kayıp) train_accuracy.append(accu) loss.backward() optimizer.step() iyileştirici .zero_grad() # Doğrulama aşaması sonucu = değerlendir(model, val_loader) sonucu['train_loss'] = torch.stack(train_lossses).mean().item() sonucu['train_accuracy'] = torch.stack(train_accuracy). ortalama().item() model.epoch_end(dönem, sonuç) if(best_valid == Yok veya best_valid

geçmiş = sığdır(model, train_dl, val_dl)

Bu, gerekli sonucu elde etmek için modelimizi eğitmek için temel bir adımdır. buradaki fit fonksiyonu, oluşturduğumuz model ile tren ve Val verilerine uyacaktır. Fit işlevi, başlangıçta, her dönemin yineleme verileriyle ilgilenen geçmiş adlı bir liste alır. Her çağda yineleme yapabilmemiz için bir for döngüsü çalıştırıyoruz. Her parti için ilerlemeyi tqdm kullanarak gösterdiğimizden emin oluruz. Daha önce uyguladığımız eğitim adımına diyoruz ve doğruluk ve kayıp hesaplıyoruz. Daha önce tanımladığımız geriye doğru yayılma ve çalıştırma optimize ediciye gidin. Bunu yaptığımızda, listemizin kaydını tutarız ve işlevler ayrıntıları ve ilerlemeyi yazdırmamıza yardımcı olur.

Değerlendirme işlevi ise eval işlevini kullanır ve her adım için veri yükleyiciden yüklenen toplu işi alırız ve çıktı hesaplanır. Değer daha sonra daha önce tanımladığımız doğrulama dönemi sonuna iletilir ve ilgili değer döndürülür.

Sonuçların çizilmesi

Bu adımda, her bir döneme karşı doğruluğu görselleştireceğiz. Çağ arttıkça sistemin doğruluğunun artmaya devam ettiğini ve benzer şekilde kaybın azalmaya devam ettiğini gözlemleyebiliriz. Buradaki kırmızı çizgi, eğitim verilerinin ilerlemesini ve doğrulama için maviyi gösterir. Eğitim verileri doğrulama sonucundan oldukça daha iyi performans gösterdiğinden ve benzer şekilde kayıp durumunda sonuçlarımızda iyi miktarda fazla uyum olduğunu görebiliriz. 10 epok sonra, tren verileri %90 doğruluğu atlıyor gibi görünüyor, ancak yaklaşık 0.5'lik bir kayıp var. Test verileri %81 civarında ve kayıplar 0.2 civarında.

def plot_accuracies(history): Validation_accuracies = [geçmişte x için x['Doğruluk']] Training_Accuracies = tarihte x için [x['train_accuracy']] plt.plot(Training_Accuracies, '-rx') plt.plot(Validation_accuracies , '-bx') plt.xlabel('epoch') plt.ylabel('doğruluk') plt.legend(['Eğitim', 'Doğrulama']) plt.title('Doğruluk ve Dönem Sayısı') ; plot_accuracies(tarih)

def plot_losses(history): train_losses = [x.get('train_loss') tarihteki x için] val_losses = [x['Kayıp'], tarihteki x için] plt.plot(train_losses, '-bx') plt.plot (val_lossses, '-rx') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(['Eğitim', 'Validation']) plt.title('Zarar ve Dönem Sayısı Karşılaştırması '); arsa_kayıpları(tarih)

test_dataset = ImageFolder(data_dir+'/test', transform=ToTensor()) test_loader = DeviceDataLoader(DataLoader(test_dataset, batch_size), device) sonuç = değerlendirme(final_model, test_loader) print(f'Test Doğruluğu:{sonuç["Doğruluk" ]*100:.2f}%')

Test Doğruluğu:%81.07

%81.07 doğrulukla sonuçlandığımızı görebiliriz.

Sonuç:

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

Benim hakkımda: Derin Öğrenme ve Doğal Dil İşleme alanıyla ilgilenen ve şu anda Yapay Zeka alanında yüksek lisans yapmakta olan bir Araştırma Öğrencisiyim.

Resim Kaynak

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

Benimle bağlantı kurmaktan çekinmeyin: