Rete neurale convoluzionale: implementazione di PyTorch su set di dati CIFAR-10

Questo articolo è stato pubblicato come parte di Blogathon sulla scienza dei dati

Introduzione

Le reti neurali convoluzionali, chiamate anche ConvNets, sono state introdotte per la prima volta negli anni '1980 da Yann LeCun, un ricercatore di informatica che ha lavorato in background. LeCun ha costruito sul lavoro di Kunihiko Fukushima, uno scienziato giapponese, una rete di base per il riconoscimento delle immagini.

La vecchia versione della CNN, chiamata LeNet (dopo LeCun), può vedere le cifre scritte a mano. La CNN aiuta a trovare i codici PIN dal servizio postale. Ma nonostante la loro esperienza, ConvNets è rimasto vicino alla visione artificiale e all'intelligenza artificiale perché hanno dovuto affrontare un grosso problema: non potevano scalare molto. Le CNN richiedono molti dati e integrano risorse per funzionare bene per immagini di grandi dimensioni.

A quel tempo, questo metodo era applicabile solo alle immagini a bassa risoluzione. Pytorch è una libreria in grado di eseguire operazioni di deep learning. Possiamo usarlo per eseguire reti neurali convoluzionali. Le reti neurali convoluzionali contengono molti strati di neuroni artificiali. I neuroni sintetici, complesse simulazioni di controparti biologiche, sono funzioni matematiche che calcolano la massa ponderata di più input e l'attivazione del valore del prodotto.

L'immagine sopra ci mostra un modello della CNN che riprende un'immagine simile a una cifra di 2 e ci dà il risultato di quale cifra è stata mostrata nell'immagine come numero. Discuteremo in dettaglio come otteniamo questo in questo articolo.

CIFAR-10 è un set di dati che ha una raccolta di immagini di 10 classi diverse. Questo set di dati è ampiamente utilizzato a scopo di ricerca per testare diversi modelli di apprendimento automatico e in particolare per problemi di visione artificiale. In questo articolo, proveremo a costruire un modello di rete neurale utilizzando Pytorch e lo testeremo sul set di dati CIFAR-10 per verificare quale accuratezza della previsione può essere ottenuta.

Importazione della libreria PyTorch 

importa numpy come np importa panda come pd

import torch import torch.nn.functional as F from torchvision import datasets,transforms from torch import nn import matplotlib.pyplot as plt import numpy as np import seaborn as sns #from tqdm.notebook import tqdm from tqdm import tqdm

In questo passaggio, importiamo le librerie richieste. Possiamo vedere che usiamo NumPy per operazioni numeriche e panda per operazioni con frame di dati. La libreria della torcia viene utilizzata per importare Pytorch.

Pytorch ha un componente nn che viene utilizzato per l'astrazione di operazioni e funzioni di apprendimento automatico. Questo viene importato come F. La libreria torchvision viene utilizzata in modo da poter importare il set di dati CIFAR-10. Questa libreria ha molti set di dati di immagini ed è ampiamente utilizzata per la ricerca. Le trasformazioni possono essere importate in modo da poter ridimensionare l'immagine alla stessa dimensione per tutte le immagini. Il tqdm viene utilizzato in modo da poter tenere traccia dei progressi durante l'allenamento e viene utilizzato per la visualizzazione.

Leggi il set di dati richiesto

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

Una volta letto il set di dati, possiamo vedere varie etichette come la rana, il camion, il cervo, l'automobile, ecc.

Analizzare i dati con PyTorch

print("Numero di punti:",trainData.shape[0]) print("Numero di caratteristiche:",trainData.shape[1]) print("Caratteristiche:",trainData.columns.values) print("Numero di Valori univoci") per col in trainData: print(col,":",len(trainData[col].unique())) plt.figure(figsize=(12,8))

Produzione:

Numero di punti: 50000 Numero di caratteristiche: 2 Caratteristiche: ['id' 'etichetta'] Numero di valori univoci id: 50000 etichetta: 10

In questo passaggio, analizziamo il set di dati e vediamo che i nostri dati del treno hanno circa 50000 righe con il loro ID e l'etichetta associata. C'è un totale di 10 classi come nel nome CIFAR-10.

Ottenere il set di convalida utilizzando PyTorch

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

Questo passaggio è uguale al passaggio di addestramento, ma vogliamo dividere i dati in set di addestramento e convalida.

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

Le torch.utils hanno un caricatore di dati che può aiutarci a caricare i dati richiesti ignorando vari parametri come il numero del lavoratore o la dimensione del batch.

Definizione delle funzioni richieste

@torch.no_grad() def precision(output, label): _, preds = torch.max(outputs, dim=1) return torch.tensor(torch.sum(preds == label).item() / len(preds )) class ImageClassificationBase(nn.Module): def training_step(self, batch): images, label = batch out = self(images) # Genera previsioni di perdita = F.cross_entropy(out, label) # Calcola la perdita accu = precision(out ,labels) return loss,accu def validation_step(self, batch): images, label = batch out = self(images) # Genera previsioni di perdita = F.cross_entropy(out, label) # Calcola la perdita acc = precision(out, label) # Calcola la precisione return {'Loss': loss.detach(), 'Accuracy': acc} def validation_epoch_end(self, outputs): batch_loss = [x['Loss'] for x negli output] epoch_loss = torch.stack(batch_losss ).mean() # Combina le perdite batch_accs = [x['Precisione'] for x negli output] epoch_acc = torch.stack(batch_accs).mean() # Combina le precisioni return {'Perdita': epoch_loss.item(), ' Precisione': epoch_acc.item()} def epoch_end(self, epoch, result): pr int("Epoca :",epoca + 1) print(f'Precisione treno:{result["precisione_traino"]*100:.2f}% Precisione convalida:{result["Precisione"]*100:.2f}%' ) print(f'Train Loss:{result["train_loss"]:.4f} Validation Loss:{result["Loss"]:.4f}')

Come possiamo vedere qui, abbiamo usato l'implementazione della classe di ImageClassification e richiede un parametro che è nn.Module. All'interno di questa classe, possiamo implementare le varie funzioni o vari passaggi come addestramento, convalida, ecc. Le funzioni qui sono semplici implementazioni di Python.

La fase di addestramento acquisisce immagini ed etichette in batch. usiamo l'entropia incrociata per la funzione di perdita e calcoliamo la perdita e restituiamo la perdita. Questo è simile al passaggio di convalida come possiamo vedere nella funzione. La fine dell'epoca combina perdite e precisioni e, infine, stampiamo le precisioni e le perdite.

Implementazione del modulo di rete neurale convoluzionale

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), # output: 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), # output: 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), # output: 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): restituisce self.network(xb)

Questa è la parte più importante dell'implementazione della rete neurale. In tutto, usiamo il modulo nn che abbiamo importato dalla torcia. Come possiamo vedere nella prima riga, Conv2d è un modulo che aiuta a implementare una rete neurale convoluzionale. Il primo parametro 3 qui rappresenta che l'immagine è colorata e in formato RGB. Se fosse stata un'immagine in scala di grigi, avremmo scelto 1.

32 è la dimensione del canale di output iniziale e quando andiamo per il prossimo livello conv2d avremmo questo 32 come canale di input e 64 come canale di output.

Il terzo parametro nella prima riga si chiama dimensione del kernel e ci aiuta a prenderci cura dei filtri utilizzati. L'operazione di riempimento è l'ultimo parametro.

L'operazione di convoluzione è collegata a un livello di attivazione e Relu qui. Dopo due livelli Conv2d, abbiamo un'operazione di max-pooling di dimensione 2 * 2. Il valore che esce da questo è normalizzato in batch per stabilità e per evitare lo spostamento della covariata interna. Queste operazioni vengono ripetute con più livelli per approfondire la rete e ridurne le dimensioni. Infine, appiattiamo il livello in modo da poter costruire un livello lineare per mappare i valori su 10 valori. La probabilità di ciascun neurone di questi 10 neuroni determinerà a quale classe appartiene una particolare immagine in base alla probabilità massima.

Allena il modello

@torch.no_grad() def valuta(model, data_loader): model.eval() outputs = [model.validation_step(batch) for batch in data_loader] return model.validation_epoch_end(output) def fit(model, train_loader, val_loader,epochs =10,learning_rate=0.001): best_valid = Nessuno history = [] ottimizzatore = torch.optim.Adam(model.parameters(), learning_rate,weight_decay=0.0005) for epoch in range(epochs): # Training Phase model.train( ) train_losses = [] train_accuracy = [] per batch in tqdm(train_loader): loss,accu = model.training_step(batch) train_losses.append(loss) train_accuracy.append(accu) loss.backward() ottimizzatore.step() .zero_grad() # Fase di convalida risultato = valuta(modello, val_loader) risultato['train_loss'] = torch.stack(train_losses).mean().item() risultato['train_accuracy'] = torch.stack(train_accuracy). mean().item() model.epoch_end(epoca, risultato) if(best_valid == Nessuno o best_valid

cronologia = fit(modello, train_dl, val_dl)

Questo è un passaggio fondamentale per addestrare il nostro modello per ottenere il risultato richiesto. la funzione di adattamento qui si adatterà ai dati del treno e della Val con il modello che abbiamo creato. La funzione di adattamento prende inizialmente una lista chiamata cronologia che si occupa dei dati di iterazione di ogni epoca. Eseguiamo un ciclo for in modo da poter iterare su ogni epoca. Per ogni batch, ci assicuriamo di mostrare i progressi usando tqdm. Chiamiamo la fase di addestramento che abbiamo implementato prima e calcoliamo l'accuratezza e la perdita. Il passo per la propagazione all'indietro e l'ottimizzatore di esecuzione che abbiamo definito in precedenza. Una volta fatto ciò, teniamo traccia del nostro elenco e le funzioni ci aiutano a stampare i dettagli e i progressi.

La funzione di valutazione, d'altra parte, utilizza la funzione eval e, per ogni passaggio, prendiamo il batch caricato dal caricatore di dati e l'output viene calcolato. Il valore viene quindi passato alla fine dell'epoca di convalida definita in precedenza e viene restituito il rispettivo valore.

Tracciare i risultati

In questo passaggio, visualizzeremo l'accuratezza rispetto a ciascuna epoca. Possiamo osservare che all'aumentare dell'epoca la precisione del sistema continua ad aumentare e allo stesso modo la perdita continua a diminuire. La linea rossa qui indica l'avanzamento dei dati di addestramento e blu per la convalida. Possiamo vedere che c'è stata una buona quantità di overfitting nei nostri risultati poiché i dati di allenamento hanno abbastanza prestazioni superiori al risultato di convalida e allo stesso modo in caso di perdita. Dopo 10 epoche, i dati del treno sembrano aggirare il 90% di precisione ma hanno una perdita di circa 0.5. I dati del test si aggirano intorno all'81% e le perdite sono vicine allo 0.2.

def plot_accuracies(history): Validation_accuracies = [x['Accuracy'] per x nella cronologia] Training_Accuracies = [x['train_accuracy'] per x nella cronologia] plt.plot(Training_Accuracies, '-rx') plt.plot(Validation_accuracies , '-bx') plt.xlabel('epoch') plt.ylabel('accuracy') plt.legend(['Training', 'Validation']) plt.title('Accuracy vs. N. di epoche') ; plot_accuracies(cronologia)

def plot_loss(history): train_loss = [x.get('train_loss') for x in history] val_loss = [x['Loss'] for x in history] plt.plot(train_loss, '-bx') plt.plot (val_loss, '-rx') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(['Training', 'Validation']) plt.title('Perdita vs. N. di epoche '); trama_perdite(cronologia)

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

Precisione del test: 81.07%

Possiamo vedere che ci ritroviamo con una precisione dell'81.07%.

Conclusione:

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

A proposito di Me: Sono uno studente di ricerca interessato al campo dell'apprendimento profondo e dell'elaborazione del linguaggio naturale e attualmente sto perseguendo un post-laurea in Intelligenza artificiale.

Image Source

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

Sentiti libero di connetterti con me su:

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

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell'autore.

Leggi Anche

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