Convolutional Neural Network – PyTorch-Implementierung im CIFAR-10-Datensatz

Dieser Artikel wurde als Teil des veröffentlicht Data-Science-Blogathon

Einleitung

Convolutional neuronale Netze, auch ConvNets genannt, wurden erstmals in den 1980er Jahren von Yann LeCun, einem Informatiker, der im Hintergrund arbeitete, eingeführt. LeCun baute auf der Arbeit von Kunihiko Fukushima, einem japanischen Wissenschaftler, ein grundlegendes Netzwerk zur Bilderkennung auf.

Die alte Version von CNN, genannt LeNet (nach LeCun), kann handgeschriebene Ziffern sehen. CNN hilft bei der Suche nach PIN-Codes von der Post. Aber trotz ihrer Expertise blieben ConvNets der Computer Vision und der künstlichen Intelligenz nahe, weil sie vor einem großen Problem standen: Sie konnten nicht viel skalieren. CNNs benötigen viele Daten und integrieren Ressourcen, um für große Bilder gut zu funktionieren.

Zu dieser Zeit war diese Methode nur auf Bilder mit niedriger Auflösung anwendbar. Pytorch ist eine Bibliothek, die Deep-Learning-Operationen durchführen kann. Wir können dies verwenden, um Convolutional Neural Networks durchzuführen. Convolutional neuronale Netze enthalten viele Schichten künstlicher Neuronen. Synthetische Neuronen, komplexe Simulationen biologischer Gegenstücke, sind mathematische Funktionen, die die gewichtete Masse mehrerer Eingaben und die Produktwertaktivierung berechnen.

Das obige Bild zeigt uns ein CNN-Modell, das ein ziffernähnliches Bild von 2 aufnimmt und uns das Ergebnis liefert, welche Ziffer im Bild als Zahl angezeigt wurde. Wir werden in diesem Artikel ausführlich besprechen, wie wir dies erreichen.

CIFAR-10 ist ein Datensatz, der eine Sammlung von Bildern aus 10 verschiedenen Klassen enthält. Dieser Datensatz wird häufig für Forschungszwecke verwendet, um verschiedene Modelle des maschinellen Lernens und insbesondere für Computer Vision-Probleme zu testen. In diesem Artikel werden wir versuchen, ein neuronales Netzwerkmodell mit Pytorch zu erstellen und es mit dem CIFAR-10-Datensatz zu testen, um zu überprüfen, welche Genauigkeit der Vorhersage erreicht werden kann.

Importieren der PyTorch-Bibliothek 

import numpy als np import pandas als pd

brenner importieren brenner importieren als F von brennervision importieren datasets, transforms von brenner importieren nn importieren matplotlib.pyplot als plt importieren numpy als np importieren seaborn als sns importieren #from tqdm.notebook tqdm von tqdm importieren tqdm importieren

In diesem Schritt importieren wir die benötigten Bibliotheken. Wir können sehen, dass wir NumPy für numerische Operationen und Pandas für Datenrahmenoperationen verwenden. Die Fackelbibliothek wird verwendet, um Pytorch zu importieren.

Pytorch hat eine nn-Komponente, die für die Abstraktion von Machine-Learning-Operationen und -Funktionen verwendet wird. Dies wird als F importiert. Die Torchvision-Bibliothek wird verwendet, damit wir den CIFAR-10-Datensatz importieren können. Diese Bibliothek enthält viele Bilddatensätze und wird häufig für die Forschung verwendet. Die Transformationen können importiert werden, sodass wir die Größe des Bildes für alle Bilder auf die gleiche Größe ändern können. Das tqdm wird verwendet, damit wir den Fortschritt während des Trainings verfolgen können und wird zur Visualisierung verwendet.

Lesen Sie den erforderlichen Datensatz

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

Sobald wir den Datensatz gelesen haben, können wir verschiedene Etiketten wie Frosch, Lastwagen, Hirsch, Auto usw.

Analysieren der Daten mit PyTorch

print("Anzahl Punkte:",trainData.shape[0]) print("Anzahl Features:",trainData.shape[1]) print("Features:",trainData.columns.values) print("Anzahl von Unique Values") für col in trainData: print(col,":",len(trainData[col].unique())) plt.figure(figsize=(12,8))

Ausgang:

Anzahl der Punkte: 50000 Anzahl der Funktionen: 2 Funktionen: ['id' 'label'] Anzahl der eindeutigen Werte id : 50000 label : 10

In diesem Schritt analysieren wir den Datensatz und sehen, dass unsere Zugdaten etwa 50000 Zeilen mit ihrer ID und dem zugehörigen Label enthalten. Es gibt insgesamt 10 Klassen wie im Namen CIFAR-10.

Abrufen des Validierungssatzes mit PyTorch

aus Torch.utils.data import random_split val_size = 5000 train_size = len(dataset) - val_size train_ds, val_ds = random_split(dataset, [train_size, val_size]) len(train_ds), len(val_ds)

Dieser Schritt ist mit dem Trainingsschritt identisch, aber wir möchten die Daten in Trainings- und Validierungssätze aufteilen.

(45000, 5000)

from 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)

Die Torch.utils verfügen über einen Datenlader, der uns helfen kann, die erforderlichen Daten zu laden, wobei verschiedene Parameter wie Arbeiternummer oder Batchgröße umgangen werden.

Definieren der benötigten Funktionen

@torch.no_grad() def Genauigkeit(Ausgänge, Labels): _, preds = Torch.max(Ausgänge, 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) # Vorhersagen generieren loss = F.cross_entropy(out, labels) # berechnungsverlust accu = Genauigkeit(out ,labels) Rückflussdämpfung,accu defvalidierungsschritt(self, batch): images, labels = batch out = self(images) # Vorhersagen generieren loss = F.cross_entropy(out, labels) # Calculate loss acc = Genauigkeit(out, labels) # Genauigkeit berechnen return {'Loss': loss.detach(), 'Accuracy': acc} defvalidation_epoch_end(self, output): batch_losses = [x['Loss'] for x in output] epoch_loss = Torch.stack(batch_losses ) Genauigkeit': epoch_acc.item()} def epoch_end(self, epoch, result): pr int("Epoch :",epoch + 1) print(f'Train Accuracy:{result["train_accuracy"]*100:.2f}% Validierungsgenauigkeit:{result["Accuracy"]*100:.2f}%' ) print(f'Train Loss:{result["train_loss"]:.4f} Validierungsverlust:{result["Loss"]:.4f}')

Wie wir hier sehen können, haben wir die Klassenimplementierung von ImageClassification verwendet und sie benötigt einen Parameter, der nn.Module ist. Innerhalb dieser Klasse können wir die verschiedenen Funktionen oder verschiedene Schritte wie Training, Validierung usw. implementieren. Die Funktionen hier sind einfache Python-Implementierungen.

Der Trainingsschritt nimmt Bilder und Beschriftungen in Stapeln auf. Wir verwenden Kreuzentropie für die Verlustfunktion und berechnen den Verlust und geben den Verlust zurück. Dies ähnelt dem Validierungsschritt, wie wir in der Funktion sehen können. Die Epochenenden kombinieren Verluste und Genauigkeiten und schließlich drucken wir die Genauigkeiten und Verluste.

Implementierung des Convolutional Neural Network Moduls

Klasse 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), # Ausgabe: 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), # Ausgabe: 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), # Ausgabe: 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): return self.network(xb)

Dies ist der wichtigste Teil der Implementierung eines neuronalen Netzwerks. Durchgängig verwenden wir das nn-Modul, das wir aus der Fackel importiert haben. Wie wir in der ersten Zeile sehen können, handelt es sich bei Conv2d um ein Modul, das bei der Implementierung eines neuronalen Faltungsnetzes hilft. Der erste Parameter 3 stellt hier dar, dass das Bild farbig und im RGB-Format ist. Wenn es ein Graustufenbild wäre, hätten wir uns für 1 entschieden.

32 ist die Größe des anfänglichen Ausgangskanals und wenn wir zur nächsten conv2d-Schicht gehen, haben wir diese 32 als Eingangskanal und 64 als Ausgangskanal.

Der dritte Parameter in der ersten Zeile heißt Kernelgröße und hilft uns, die verwendeten Filter zu beachten. Der Auffüllvorgang ist der letzte Parameter.

Die Faltungsoperation ist hier mit einer Aktivierungsschicht und Relu verbunden. Nach zwei Conv2d-Schichten haben wir eine Max-Pooling-Operation der Größe 2 * 2. Der daraus resultierende Wert wird aus Stabilitätsgründen und zur Vermeidung einer internen Kovariatenverschiebung chargennormalisiert. Diese Operationen werden mit mehr Schichten wiederholt, um das Netzwerk zu vertiefen und die Größe zu reduzieren. Schließlich glätten wir die Ebene, damit wir eine lineare Ebene erstellen können, um die Werte auf 10 Werte abzubilden. Die Wahrscheinlichkeit jedes Neurons dieser 10 Neuronen bestimmt basierend auf der maximalen Wahrscheinlichkeit, zu welcher Klasse ein bestimmtes Bild gehört.

Trainiere das Modell

@torch.no_grad() def evaluieren(model, data_loader): model.eval() Ausgaben = [model.validation_step(batch) für Batch in data_loader] return model.validation_epoch_end(outputs) def fit(model, train_loader, val_loader,epochs =10,learning_rate=0.001): best_valid = Keine history = [] Optimizer = Torch.optim.Adam(model.parameters(), learning_rate,weight_decay=0.0005) für Epoche im Bereich(epochen): # Trainingsphase model.train( ) train_losses = [] train_accuracy = [] für Batch in tqdm(train_loader): loss,accu = model.training_step(batch) train_losses.append(loss) train_accuracy.append(accu) loss.backward() Optimizer.step() Optimizer .zero_grad() # Validierungsphase result = evaluieren(model, val_loader) result['train_loss'] = brenner.stack(train_verluste).mean().item() result['train_accuracy'] = brenner.stack(train_accuracy). mean().item() model.epoch_end(epoch, result) if(best_valid == None or best_valid

History = fit(model, train_dl, val_dl)

Dies ist ein grundlegender Schritt, um unser Modell zu trainieren, um das erforderliche Ergebnis zu erzielen. Die Anpassungsfunktion hier passt die Zug- und Val-Daten an das von uns erstellte Modell an. Die Fit-Funktion verwendet zunächst eine Liste namens history, die sich um die Iterationsdaten jeder Epoche kümmert. Wir führen eine for-Schleife aus, damit wir über jede Epoche iterieren können. Für jeden Batch stellen wir sicher, dass wir den Fortschritt mit tqdm anzeigen. Wir nennen den zuvor implementierten Trainingsschritt und berechnen Genauigkeit und Verlust. Gehen Sie zur Rückwärtspropagation und führen Sie den Optimierer aus, den wir zuvor definiert haben. Sobald wir dies tun, behalten wir den Überblick über unsere Liste und die Funktionen helfen uns, die Details und den Fortschritt auszudrucken.

Die Auswertungsfunktion hingegen verwendet die Auswertungsfunktion, und für jeden Schritt nehmen wir den aus dem Datenlader geladenen Stapel und die Ausgabe wird berechnet. Der Wert wird dann an das zuvor definierte Validierungsepochenende übergeben und der entsprechende Wert zurückgegeben.

Ergebnisse grafisch darstellen

In diesem Schritt werden wir die Genauigkeit gegenüber jeder Epoche visualisieren. Wir können beobachten, dass mit zunehmender Epoche die Genauigkeit des Systems weiter zunimmt und in ähnlicher Weise der Verlust weiter abnimmt. Die rote Linie zeigt hier den Fortschritt der Trainingsdaten und die blaue Linie für die Validierung an. Wir können sehen, dass es in unseren Ergebnissen eine gute Überanpassung gegeben hat, da die Trainingsdaten das Validierungsergebnis ziemlich übertreffen und ähnlich im Falle eines Verlustes. Nach 10 Epochen scheinen die Zugdaten eine Genauigkeit von 90% zu umgehen, haben aber einen Verlust von etwa 0.5. Die Testdaten liegen bei rund 81% und die Verluste liegen bei nahe 0.2.

def plot_accuracies(history): Validation_accuracies = [x['Accuracy'] für x im Verlauf] Training_Accuracy = [x['train_accuracy'] für x im Verlauf] plt.plot(Training_Accuracies, '-rx') plt.plot(Validation_accuracies , '-bx') plt.xlabel('epoch') plt.ylabel('accuracy') plt.legend(['Training', 'Validation']) plt.title('Genauigkeit vs. Anzahl der Epochen') ; plot_accuracies(Geschichte)

def plot_losses(history): train_losses = [x.get('train_loss') für x im Verlauf] val_losses = [x['Loss'] für x im Verlauf] plt.plot(train_losses, '-bx') plt.plot (val_losses, '-rx') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(['Training', 'Validation']) plt.title('Verlust vs. Anzahl der Epochen '); plot_losses(Geschichte)

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

Testgenauigkeit: 81.07 %

Wir können sehen, dass wir am Ende eine Genauigkeit von 81.07% haben.

Fazit:

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

Über mich: Ich bin ein Research Student, der sich für das Gebiet Deep Learning und Natural Language Processing interessiert und derzeit ein Postgraduiertenstudium in Künstlicher Intelligenz absolviert.

Bildquelle

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

Kontaktieren Sie mich gerne unter:

1.  Linkedin: https://www.linkedin.com/in/siddharth-m-426a9614a/
2.  Github: https://github.com/Siddharth1698

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Verbunden

Quelle: https://www.analyticsvidhya.com/blog/2021/09/convolutional-neural-network-pytorch-implementation-on-cifar10-dataset/