Questo articolo è stato pubblicato nell'ambito del Blogathon sulla scienza dei dati
Panoramica
Questo articolo discuterà brevemente della CNN, una variante speciale delle reti neurali progettate specificamente per compiti relativi alle immagini. L'articolo si concentrerà principalmente sulla parte di implementazione della CNN. È stato fatto ogni sforzo per rendere questo articolo interattivo e semplice.. Spero che ti piaccia Buon apprendimento !!
introduzione
Le reti neurali convoluzionali sono state introdotte da Yann LeCun e Yoshua Bengio nell'anno 1995 che in seguito ha dimostrato di mostrare risultati eccezionali nel dominio delle immagini. Quindi, Cosa le rendeva speciali rispetto alle normali reti neurali quando applicate nel dominio dell'immagine?? Spiegherò uno dei motivi con un semplice esempio. Tenga en cuenta que se le ha encomendado la tarea de clasificar las imágenes de dígitos escritos a mano y que a continuación se muestran algunos ejemplos de conjuntos de addestramentoLa formazione è un processo sistematico volto a migliorare le competenze, conoscenze o abilità fisiche. Viene applicato in vari ambiti, come lo sport, Formazione e sviluppo professionale. Un programma di allenamento efficace include la pianificazione degli obiettivi, Pratica regolare e valutazione dei progressi. L'adattamento alle esigenze individuali e la motivazione sono fattori chiave per ottenere risultati di successo e sostenibili in qualsiasi disciplina.....
Se osservi correttamente, potresti scoprire che tutte le cifre appaiono al centro delle rispettive immagini. Entrenar un modelo de neuronale rossoLe reti neurali sono modelli computazionali ispirati al funzionamento del cervello umano. Usano strutture note come neuroni artificiali per elaborare e apprendere dai dati. Queste reti sono fondamentali nel campo dell'intelligenza artificiale, consentendo progressi significativi in attività come il riconoscimento delle immagini, Elaborazione del linguaggio naturale e previsione delle serie temporali, tra gli altri. La loro capacità di apprendere schemi complessi li rende strumenti potenti.. normal con estas imágenes puede dar un buen resultado si la imagen de prueba es de un tipo similar. Ma, Cosa succede se l'immagine di prova è come sotto??
Qui il numero nove appare nell'angolo dell'immagine. Se usiamo un semplice modello di rete neurale per classificare questa immagine, il nostro modello potrebbe fallire improvvisamente. Ma se la stessa immagine di prova viene data a un modello della CNN, è molto probabile che venga classificato correttamente. Il motivo delle prestazioni migliori è che cerca le caratteristiche spaziali nell'immagine. Per il caso di cui sopra stesso, anche se il numero nove è nell'angolo sinistro della cornice, il modello CNN addestrato cattura le caratteristiche nell'immagine e probabilmente prevede che il numero sia la cifra nove. Una normale rete neurale non può fare questo tipo di magia. Ora discutiamo brevemente i principali elementi costitutivi della CNN.
Componenti principali dell'architettura di un modello CNN
Questo è un semplice modello CNN creato per classificare se l'immagine contiene o meno un gatto. Quindi, i componenti principali di una CNN sono:
1. copertina convolutivaLa capa convolucional, fundamental en las redes neuronales convolucionales (CNN), se utiliza principalmente para el procesamiento de datos con estructuras en forma de cuadrícula, come immagini. Esta capa aplica filtros que extraen características relevantes, como bordes y texturas, permitiendo que el modelo reconozca patrones complejos. Su capacidad para reducir la dimensionalidad de los datos y mantener información esencial la convierte en una herramienta clave en tareas de visión por computadora...
2. Livello di raggruppamento
3.Strato completamente connesso
copertina convolutiva
I livelli convolutivi ci aiutano a estrarre le caratteristiche presenti nell'immagine. Questa estrazione si ottiene con l'ausilio di filtri. Osservare la seguente operazione.
Qui possiamo vedere che una finestra scorre sull'intera immagine in cui l'immagine viene visualizzata come una griglia (Questo è il modo in cui il computer vede le immagini in cui le griglie sono piene di numeri!!). Ora vediamo come vengono eseguiti i calcoli nell'operazione di convoluzione.
Supponiamo che la mappa delle caratteristiche di input sia la nostra immagine e che il filtro convoluzionale sia la finestra su cui andremo a scorrere. Ora diamo un'occhiata a una delle istanze dell'operazione di convoluzione.
Quando il filtro di convoluzione è sovrapposto all'immagine, i rispettivi elementi sono moltiplicati. Dopo, i valori moltiplicati vengono aggiunti per ottenere un singolo valore che viene popolato sulla mappa delle caratteristiche di output. Questa operazione continua finché non facciamo scorrere la finestra sulla mappa delle caratteristiche di input., riempiendo così la mappa delle caratteristiche di output.
Livello di raggruppamento
La idea detrás del uso de una capa de agrupación es reducir la dimensione"Dimensione" È un termine che viene utilizzato in varie discipline, come la fisica, Matematica e filosofia. Si riferisce alla misura in cui un oggetto o un fenomeno può essere analizzato o descritto. In fisica, ad esempio, Si parla di dimensioni spaziali e temporali, mentre in matematica può riferirsi al numero di coordinate necessarie per rappresentare uno spazio. Comprenderlo è fondamentale per lo studio e... del mapa de características. Per la rappresentazione fornita di seguito, abbiamo utilizzato un livello di raggruppamento massimo di 2 * 2. Ogni volta che la finestra scorre sull'immagine, prendiamo il valore massimo presente all'interno della finestra.
Finalmente, dopo il massimo funzionamento del gruppo, possiamo vedere qui che la dimensione dell'input, vale a dire, 4 * 4, è stato ridotto a 2 * 2.
Strato completamente connesso
Questo livello è presente nella sezione di coda dell'architettura del modello CNN come visto prima. L'input al livello completamente connesso sono le ricche funzionalità che sono state estratte dai filtri convoluzionali. Esto luego se propaga hacia adelante hasta la capa de salidaIl "capa de salida" es un concepto utilizado en el ámbito de la tecnología de la información y el diseño de sistemas. Se refiere a la última capa de un modelo de software o arquitectura que se encarga de presentar los resultados al usuario final. Esta capa es crucial para la experiencia del usuario, ya que permite la interacción directa con el sistema y la visualización de datos procesados...., dove otteniamo la probabilità che l'immagine in ingresso appartenga a classi diverse. Il risultato previsto è la classe con la più alta probabilità prevista dal modello.
Implementazione del codice
Qui prendiamo il Fashion MNIST come il nostro set di dati problematico. Il set di dati contiene magliette, pantaloni, maglione, vestiti, cappotti, infradito, camicie, scarpe, borse e stivaletti. Il compito è classificare una certa immagine nelle classi di cui sopra dopo aver addestrato il modello.
Implementeremo il codice in Google Colab, in quanto forniscono l'uso di risorse GPU gratuite per un periodo di tempo fisso. Se non conosci l'ambiente Colab e le GPU, controlla questo blog per farti un'idea migliore. Di seguito è riportata l'architettura della CNN che andremo a costruire.
passo 1: Importa le librerie richieste
importare il sistema operativo importare la torcia importare torchvision importa file tar da torchvision import trasforma da torch.utils.data import random_split da torch.utils.data.dataloader import DataLoader import torcia.nn come nn da torch.nn import funzionale come F dalla catena di importazione di itertools
passo -2: Download del set di dati di test e training
train_set = torchvision.datasets.FashionMNIST("/usr", download=Vero, trasformare=
trasforma.Componi([trasforma.ToTensor()]))
test_set = torchvision.datasets.FashionMNIST("./dati", download=Vero, treno=falso, trasformare=
trasforma.Componi([trasforma.ToTensor()]))passo 3 Divisione del training set per la formazione e la validazione
train_size = 48000 val_size = 60000 - train_size train_ds,val_ds = random_split(train_set,[train_size,val_size])
passo 4 Carica il set di dati in memoria utilizzando Dataloader
train_dl = DataLoader(train_ds,batch_size=20,shuffle=Vero) val_dl = DataLoader(val_ds,batch_size=20,shuffle=Vero) classi = train_set.classes
Ora visualizziamo i dati caricati,
per imgs,etichette in train_dl:
per img in imgs:
arr_ = np.squeeze(img)
plt.mostra()
rottura
rottura
passo -5 Definire l'architettura
import torcia.nn come nn
import torcia.nn.funzionale come F
#definire l'architettura della CNN
classe Net(nn.Modulo):
def __init__(se stesso):
super(Netto, se stesso).__dentro__()
#strato convolutivo-1
self.conv1 = nn.Conv2d(1,6,5, imbottitura=0)
#strato convolutivo-2
self.conv2 = nn.Conv2d(6,10,5,imbottitura=0)
# livello di raggruppamento massimo
self.pool = nn.MaxPool2d(2, 2)
# Strato completamente connesso 1
self.ff1 = nn.Lineare(4*4*10,56)
# Strato completamente connesso 2
self.ff2 = nn.Lineare(56,10) def avanti(se stesso, X):
# aggiunta di una sequenza di livelli convoluzionali e massimi di pooling
#ingresso dim-28*28*1
x = self.conv1(X)
# Dopo l'operazione di convoluzione, output_dim - 24*24*6
x = self.pool(X)
# Dopo il massimo funzionamento in piscina, l'uscita dim - 12*12*6
x = self.conv2(X)
# Dopo l'operazione di convoluzione uscita dim - 8*8*10
x = self.pool(X)
# uscita max piscina dim 4*4*10
x = x.vista(-1,4*4*10) # Rimodellare i valori in una forma appropriata all'input del livello completamente connesso
x = F.relu(self.ff1(X)) # Applicazione di Relu all'output del primo strato
x = F.sigmoide(self.ff2(X)) # Applicazione di sigmoid all'output del secondo strato
restituire x# creare una CNN . completa model_scratch = Net() Stampa(modello)
# sposta i tensori su GPU se CUDA è disponibile
if use_cuda:
model_scratch.cuda()passo 6: definición de la función de pérdidaLa función de pérdida es una herramienta fundamental en el aprendizaje automático que cuantifica la discrepancia entre las predicciones del modelo y los valores reales. Su objetivo es guiar el proceso de entrenamiento al minimizar esta diferencia, permitiendo así que el modelo aprenda de manera más efectiva. Existen diferentes tipos de funciones de pérdida, como el error cuadrático medio y la entropía cruzada, cada una adecuada para distintas tareas y...
# Funzione di perdita
import torcia.nn come nn
importa torch.optim come optim
criterio_scratch = nn.CrossEntropyLoss()
def get_optimizer_scratch(modello):
ottimizzatore = optim.SGD(parametri.modello(),lr = 0.04)
ottimizzatore di ritornopasso 7: implementazione dell'algoritmo di addestramento e convalida
# Implementazione dell'algoritmo di addestramento
def treno(n_epoche, caricatori, modello, ottimizzatore, criterio, use_cuda, save_path):
"""restituisce il modello addestrato"""
# inizializza il tracker per una perdita di convalida minima
valid_loss_min = np.Inf
per epoca in gamma(1, n_epoche+1):
# inizializzare le variabili per monitorare la perdita di addestramento e convalida
train_loss = 0.0
valid_loss = 0.0
# fase del treno #
# impostare il modulo in modalità allenamento
modello.treno()
per batch_idx, (dati, obbiettivo) in enumerare(caricatori['treno']):
# passa alla GPU
if use_cuda:
dati, target = data.cuda(), target.cuda()
ottimizzatore.zero_grad()
uscita = modello(dati)
perdita = criterio(produzione, obbiettivo)
perdita.indietro()
ottimizzatore.passo()
train_loss = train_loss + ((1 / (batch_idx + 1)) * (perdita.dati.elemento() - train_loss))
# convalidare il modello #
# impostare il modello in modalità di valutazione
model.eval()
per batch_idx, (dati, obbiettivo) in enumerare(caricatori['valido']):
# passa alla GPU
if use_cuda:
dati, target = data.cuda(), target.cuda()
uscita = modello(dati)
perdita = criterio(produzione, obbiettivo)
valid_loss = valid_loss + ((1 / (batch_idx + 1)) * (perdita.dati.elemento() - valid_loss))
# stampa statistiche di addestramento/convalida
Stampa('Epoca: {} tPerdita di allenamento: {:.6F} tPerdita di convalida: {:.6F}'.formato(
epoca,
train_loss,
valid_loss
))
## Se la perdita di valutazione è diminuita, quindi salvare il modello
se valid_loss <= valid_loss_min:
Stampa('Perdita di convalida diminuita ({:.6F} --> {:.6F}). Salvataggio del modello ...'.format(
valid_loss_min,
valid_loss))
torcia.salva(model.state_dict(), save_path)
valid_loss_min = valid_loss
modello di ritornopasso 8: Fase di formazione e valutazione
num_epoche = 15
model_scratch = treno(num_epoche, loaders_scratch, model_scratch, get_optimizer_scratch(model_scratch),
criterio_gratta, use_cuda, 'model_scratch.pt')
Nota che quando ogni volta la perdita di convalida diminuisce, stiamo salvando lo stato del modello.
passo 9 Fase di prova
def test(caricatori, modello, criterio, use_cuda):
# monitorare la perdita e l'accuratezza del test
test_loss = 0.
corretto = 0.
totale = 0.
# impostare il modulo in modalità di valutazione
model.eval()
per batch_idx, (dati, obbiettivo) in enumerare(caricatori['test']):
# passa alla GPU
if use_cuda:
dati, target = data.cuda(), target.cuda()
# passaggio in avanti: calcolare gli output previsti passando gli input al modello
uscita = modello(dati)
# calcolare la perdita
perdita = criterio(produzione, obbiettivo)
# aggiorna la perdita media del test
test_loss = test_loss + ((1 / (batch_idx + 1)) * (perdita.dati.elemento() - test_loss))
# convertire le probabilità di output in classe prevista
pred = output.data.max(1, keepdim=Vero)[1]
# confronta le previsioni con l'etichetta vera
corretto += np.somma(np.squeeze(pred.eq(target.data.view_as(pred)),asse=1).processore().insensibile())
totale += data.size(0)
Stampa("Perdita di prova": {:.6F}n'.formato(test_loss))
Stampa('nTest Precisione: %2D%% (%2d /% 2d)' % (
100. * corretta / totale, corretta, totale))
# caricare il modello che ha ottenuto la migliore accuratezza di convalida
model_scratch.load_state_dict(torcia.carico('model_scratch.pt'))
test(loaders_scratch, model_scratch, criterio_gratta, use_cuda)
passo 10 Prova con un campione
La funzione definita per testare il modello con una singola immagine.
def previsione_immagine(img, modello):
# Converti in un lotto di 1
xb = img.unsqueeze(0)
# Ottieni previsioni dal modello
yb = modello(xb)
# Scegli l'indice con la più alta probabilità
_, pred = torcia.max(yb, dim=1)
# stampare l'immagine
plt.imshow(img.squeeze( ))
#restituendo l'etichetta della classe relativa all'immagine
return train_set.classes[pred[0].articolo()]img,etichetta = set_test[9] forecast_image(img,model_scratch)
conclusione
Aquí habíamos discutido brevemente las principales operaciones en una convolucional neuronale rossoReti neurali convoluzionali (CNN) son un tipo de arquitectura de red neuronal diseñadas especialmente para el procesamiento de datos con una estructura de cuadrícula, come immagini. Utilizan capas de convolución para extraer características jerárquicas, lo que las hace especialmente efectivas en tareas de reconocimiento de patrones y clasificación. Gracias a su capacidad para aprender de grandes volúmenes de datos, las CNN han revolucionado campos como la visión por computadora... y su arquitectura. È stato anche implementato un semplice modello di rete neurale convoluzionale per dare una migliore idea del caso d'uso pratico. Puoi trovare il codice implementato in my Archivio GitHub. Cosa c'è di più, puoi migliorare le prestazioni del modello distribuito aumentando il set di dati, utilizando técnicas de regolarizzazioneLa regularización es un proceso administrativo que busca formalizar la situación de personas o entidades que operan fuera del marco legal. Este procedimiento es fundamental para garantizar derechos y deberes, así como para fomentar la inclusión social y económica. En muchos países, la regularización se aplica en contextos migratorios, laborales y fiscales, permitiendo a quienes se encuentran en situaciones irregulares acceder a beneficios y protegerse de posibles sanciones.... come il standardizzazioneLa normalización es un proceso fundamental en diversas disciplinas, que busca establecer estándares y criterios uniformes para mejorar la calidad y la eficiencia. En contextos como la ingeniería, la educación y la administración, la normalización facilita la comparación, la interoperabilidad y la comprensión mutua. Al implementar normas, se promueve la cohesión y se optimizan recursos, lo que contribuye al desarrollo sostenible y a la mejora continua de los procesos.... por lotes y el abandono en las capas completamente conectadas de la arquitectura. Cosa c'è di più, nota che sono disponibili anche modelli CNN pre-addestrati, che sono stati formati utilizzando grandi set di dati. Utilizzando questi modelli di ultima generazione, otterrai senza dubbio i migliori punteggi di metrica per un determinato problema.
Riferimenti
- https://www.youtube.com/watch?v = EHuACSjijbI – gioviano
- https://www.youtube.com/watch?v = 2-Ol7ZB0MmU&t=1503s- Un'introduzione amichevole alle reti neurali convoluzionali e al riconoscimento delle immagini
Circa l'autore
Mi chiamo Adwait Datan, Attualmente sto perseguendo la mia laurea magistrale in Intelligenza Artificiale e Data Science. Sentiti libero di connetterti con me attraverso Linkedin.
Il supporto mostrato in questo articolo non è di proprietà di DataPeaker e viene utilizzato a discrezione dell'autore.
