Alai

Introduzione

“Costruire un modello di deep learning in pochi minuti? Ci vorranno ore per addestrarlo! Non ho nemmeno una macchina abbastanza buona”. Ho sentito questo innumerevoli volte da aspiranti scienziati dei dati che evitano di costruire modelli di deep learning sulle loro macchine.

Non è necessario lavorare per Google o altre grandi aziende tecnologiche per lavorare su set di dati di deep learning! È del tutto possibile costruire la propria rete neurale da zero in pochi minuti, senza bisogno di affittare i server di Google. Gli studenti di Fast.ai hanno progettato un modello sul dataset Imagenet in 18 minuti – e io mostrerò qualcosa di simile in questo articolo.

Il deep learning è un campo molto vasto, quindi restringeremo un po’ il nostro campo di azione e affronteremo la sfida di risolvere un progetto di classificazione delle immagini. Inoltre, useremo un’architettura di deep learning molto semplice per raggiungere un punteggio di precisione piuttosto impressionante.

Potete considerare il codice Python che vedremo in questo articolo come un punto di riferimento per costruire modelli di classificazione delle immagini. Una volta che hai afferrato bene il concetto, vai avanti e gioca con il codice, partecipa alle competizioni e scala la classifica!

Se sei nuovo all’apprendimento profondo e sei affascinato dal campo della computer vision (chi non lo è?!), dai un’occhiata al corso ‘Computer Vision using Deep Learning’. E’ un’introduzione completa a questo meraviglioso campo e ti preparerà per quello che sarà inevitabilmente un enorme mercato del lavoro nel prossimo futuro.

Progetto per applicare la classificazione delle immagini

Più del 25% dell’intero fatturato dell’E-Commerce è attribuito all’abbigliamento &accessori. Uno dei problemi principali da affrontare è la categorizzazione di questi capi d’abbigliamento dalle sole immagini, specialmente quando le categorie fornite dai marchi sono incoerenti. Questo pone un interessante problema di computer vision che ha catturato gli occhi di diversi ricercatori di deep learning.

Fashion MNIST è una sostituzione drop-in per il ben noto, machine learning hello world – MNIST dataset che può essere controllato al problema pratico ‘Identify the digits’. Invece delle cifre, le immagini mostrano un tipo di abbigliamento, ad esempio maglietta, pantaloni, borsa, ecc. Il dataset usato in questo problema è stato creato da Zalando Research.

Pratica ora

Tabella del contenuto

1. Cos’è la classificazione delle immagini e i suoi casi d’uso
2. Impostare la struttura dei nostri dati immagine
3. Smontare il processo di costruzione del modello Processo
4. Impostazione del problema e comprensione dei dati
5. Passi per costruire il modello di classificazione delle immagini
6. Cogliere un’altra sfida

Cosa è la classificazione delle immagini?

Considera la seguente immagine:

L’avrai riconosciuta immediatamente – è un’auto (di lusso). Fai un passo indietro e analizza come sei arrivato a questa conclusione – ti è stata mostrata un’immagine e hai classificato la classe a cui appartiene (un’auto, in questo caso). E questo, in poche parole, è ciò che riguarda la classificazione delle immagini.

Ci sono potenzialmente n categorie in cui una data immagine può essere classificata. Controllare e classificare manualmente le immagini è un processo molto noioso. Il compito diventa quasi impossibile quando ci troviamo di fronte a un numero enorme di immagini, diciamo 10.000 o addirittura 100.000. Quanto sarebbe utile se potessimo automatizzare l’intero processo ed etichettare rapidamente le immagini per la loro classe corrispondente?

Le auto a guida autonoma sono un ottimo esempio per capire dove la classificazione delle immagini viene utilizzata nel mondo reale. Per abilitare la guida autonoma, possiamo costruire un modello di classificazione delle immagini che riconosca vari oggetti, come veicoli, persone, oggetti in movimento, ecc. sulla strada. Vedremo un altro paio di casi d’uso più avanti in questo articolo, ma ci sono molte altre applicazioni intorno a noi. Usate la sezione commenti sotto l’articolo per farmi sapere quali potenziali casi d’uso vi vengono in mente!

Ora che abbiamo una conoscenza della nostra materia, immergiamoci in come viene costruito un modello di classificazione delle immagini, quali sono i prerequisiti per esso, e come può essere implementato in Python.

Impostare la struttura dei nostri dati immagine

I nostri dati devono essere in un formato particolare per poter risolvere un problema di classificazione delle immagini. Vedremo questo in azione in un paio di sezioni, ma tieni a mente queste indicazioni finché non ci arriviamo.

Dovresti avere 2 cartelle, una per il training set e l’altra per il test set. Nel set di allenamento, avrai un file .csv e una cartella delle immagini:

• Il file .csv contiene i nomi di tutte le immagini di allenamento e le loro corrispondenti etichette vere
• La cartella delle immagini contiene tutte le immagini di allenamento.

Il file .csv nel nostro set di prova è diverso da quello presente nel set di allenamento. Questo file .csv del set di prova contiene i nomi di tutte le immagini di prova, ma non hanno alcuna etichetta corrispondente. Riesci a indovinare perché? Il nostro modello sarà addestrato sulle immagini presenti nel set di allenamento e le previsioni delle etichette avverranno sulle immagini del set di test

Se i tuoi dati non sono nel formato descritto sopra, dovrai convertirli di conseguenza (altrimenti le previsioni saranno sbagliate e abbastanza inutili).

Smontare il processo di costruzione del modello

Prima di immergerci nel codice Python, prendiamoci un momento per capire come un modello di classificazione delle immagini è tipicamente progettato. Possiamo dividere questo processo a grandi linee in 4 fasi. Ogni fase richiede una certa quantità di tempo per l’esecuzione:

1. Caricamento e pre-elaborazione dei dati – 30% tempo
2. Definizione dell’architettura del modello – 10% tempo
3. Formazione del modello – 50% tempo
4. Stima delle prestazioni – 10% tempo

Lasciatemi spiegare ciascuna delle fasi di cui sopra un po’ più in dettaglio. Questa sezione è cruciale perché non tutti i modelli sono costruiti al primo tentativo. Avrete bisogno di tornare indietro dopo ogni iterazione, mettere a punto i vostri passi, ed eseguirlo di nuovo. Avere una solida comprensione dei concetti sottostanti andrà molto lontano nell’accelerare l’intero processo.

Fase 1: Caricamento e pre-elaborazione dei dati

I dati sono oro per quanto riguarda i modelli di apprendimento profondo. Il tuo modello di classificazione delle immagini ha molte più possibilità di funzionare bene se hai una buona quantità di immagini nel set di allenamento. Inoltre, la forma dei dati varia a seconda dell’architettura/framework che usiamo.

Da qui, il passo critico di pre-elaborazione dei dati (il passo eternamente importante in qualsiasi progetto). Raccomando vivamente di leggere ‘Basics of Image Processing in Python’ per capire meglio come funziona la pre-elaborazione dei dati di immagine.

Ma non ci siamo ancora. Per vedere come il nostro modello si comporta su dati non visti (e prima di esporlo al set di test), abbiamo bisogno di creare un set di validazione. Questo viene fatto partizionando i dati del training set.

In breve, addestriamo il modello sui dati di training e lo validiamo sui dati di validazione. Una volta che siamo soddisfatti delle prestazioni del modello sul set di convalida, possiamo usarlo per fare previsioni sui dati di test.

Tempo richiesto per questo passo: Abbiamo bisogno di circa 2-3 minuti per questo compito.

Fase 2: Definire l’architettura del modello

Questo è un altro passo cruciale nel nostro processo di costruzione del modello di deep learning. Dobbiamo definire come sarà il nostro modello e questo richiede di rispondere a domande come:

• Quanti strati convoluzionali vogliamo?
• Quale dovrebbe essere la funzione di attivazione per ogni strato?
• Quante unità nascoste dovrebbe avere ogni strato?

E molte altre. Questi sono essenzialmente gli iperparametri del modello che giocano un ruolo MASSIMO nel decidere quanto saranno buone le previsioni.

Come decidiamo questi valori? Domanda eccellente! Una buona idea è quella di scegliere questi valori sulla base di ricerche/studi esistenti. Un’altra idea è quella di continuare a sperimentare con i valori fino a trovare la migliore corrispondenza, ma questo può essere un processo che richiede molto tempo.

Tempo richiesto per questo passo: Si dovrebbe impiegare circa 1 minuto per definire l’architettura del modello.

Fase 3: Addestramento del modello

Per l’addestramento del modello, abbiamo bisogno di:

• Immagini di allenamento e le loro corrispondenti etichette vere
• Immagini di validazione e le loro corrispondenti etichette vere (usiamo queste etichette solo per validare il modello e non durante la fase di allenamento)

In questa fase definiamo anche il numero di epoche. Per cominciare, eseguiremo il modello per 10 epoche (è possibile cambiare il numero di epoche in seguito).

Tempo richiesto per questo passo: Poiché l’addestramento richiede che il modello impari le strutture, abbiamo bisogno di circa 5 minuti per questo passo.

E ora è il momento di fare previsioni!

Fase 4: Stimare le prestazioni del modello

Finalmente, carichiamo i dati di test (immagini) e passiamo anche qui attraverso il passo di pre-elaborazione. Poi prevediamo le classi per queste immagini usando il modello addestrato.

Tempo richiesto per questo passo: ~ 1 minuto.

Impostazione del problema e comprensione dei dati

Coglieremo una sfida davvero interessante per capire la classificazione delle immagini. Dobbiamo costruire un modello che possa classificare un dato insieme di immagini in base all’abbigliamento (camicia, pantaloni, scarpe, calzini, ecc.). In realtà è un problema affrontato da molti rivenditori di e-commerce, il che lo rende un problema di computer vision ancora più interessante.

Questa sfida si chiama ‘Identificare l’abbigliamento’ ed è uno dei problemi pratici che abbiamo sulla nostra piattaforma DataHack. Dovrai registrarti e scaricare il dataset dal link qui sopra.

Abbiamo un totale di 70.000 immagini (dimensione 28 x 28), di cui 60.000 sono dal set di allenamento e 10.000 da quello di test. Le immagini di allenamento sono pre-etichettate secondo il tipo di abbigliamento con 10 classi totali. Le immagini di test non sono, ovviamente, etichettate. La sfida è identificare il tipo di abbigliamento presente in tutte le immagini di test.

Costruiremo il nostro modello su Google Colab poiché fornisce una GPU gratuita per addestrare i nostri modelli.

Passi per costruire il nostro modello

È ora di accendere le vostre abilità Python e sporcarsi le mani. Siamo finalmente alla parte di implementazione del nostro apprendimento!

1. Impostare Google Colab
2. Importare le librerie
3. Caricare e pre-elaborare i dati – (3 minuti)
4. Creare un set di validazione
5. Definizione della struttura del modello – (1 min)
6. Allenamento del modello – (5 min)
7. Fare previsioni – (1 min)

Guardiamo ogni passo in dettaglio.

Passo 1: Impostare Google Colab

Siccome stiamo importando i nostri dati da un link di Google Drive, avremo bisogno di aggiungere alcune righe di codice nel nostro notebook Google Colab. Creare un nuovo quaderno Python 3 e scrivere i seguenti blocchi di codice:

!pip install PyDrive

Questo installerà PyDrive. Ora importeremo alcune librerie necessarie:

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

Poi, creeremo una variabile drive per accedere a Google Drive:

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

Per scaricare il dataset, useremo l’ID del file caricato su Google Drive:

download = drive.CreateFile({'id': '1BZOv422XJvxFUnGh-0xVeSvgFgqVY45q'})

Sostituiamo l'”id” nel codice precedente con l’ID del vostro file. Ora scaricheremo questo file e lo decomprimeremo:

download.GetContentFile('train_LbELtWX.zip')!unzip train_LbELtWX.zip

Devi eseguire questi blocchi di codice ogni volta che avvii il tuo notebook.

Passo 2: Importa le librerie di cui avremo bisogno durante la nostra fase di costruzione del modello.

import kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

Passo 3: Ricorda i passi di pre-elaborazione che abbiamo discusso prima. Li useremo qui dopo aver caricato i dati.

train = pd.read_csv('train.csv')

In seguito, leggeremo tutte le immagini di allenamento, le memorizzeremo in una lista e infine convertiremo quella lista in un array numpy.

# We have grayscale images, so while loading the images we will keep grayscale=True, if you have RGB images, you should set grayscale as Falsetrain_image = for i in tqdm(range(train.shape)): img = image.load_img('train/'+train.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

Siccome si tratta di un problema di classificazione multiclasse (10 classi), codificheremo la variabile target in un solo colpo.

y=train.valuesy = to_categorical(y)

Passo 4: Creare un set di validazione dai dati di allenamento.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

Passo 5: Definire la struttura del modello.

Creeremo una semplice architettura con 2 strati convoluzionali, uno strato nascosto denso e uno strato di uscita.

model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

In seguito, compileremo il modello che abbiamo creato.

model.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

Step 6: Addestramento del modello.

In questo passo, addestreremo il modello sulle immagini del training set e lo convalideremo usando, avete indovinato, il validation set.

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

Step 7: Fare le previsioni!

Proseguiremo inizialmente i passi che abbiamo eseguito quando abbiamo trattato i dati di addestramento. Carichiamo le immagini di test e prevediamo le loro classi usando la funzione model.predict_classes().

download = drive.CreateFile({'id': '1KuyWGFEpj7Fr2DgBsW8qsWvjqEzfoJBY'})download.GetContentFile('test_ScVgIM0.zip')!unzip test_ScVgIM0.zip

Importiamo il file di test:

test = pd.read_csv('test.csv')

Ora, leggeremo e memorizzeremo tutte le immagini di test:

test_image = for i in tqdm(range(test.shape)): img = image.load_img('test/'+test.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

# making predictionsprediction = model.predict_classes(test)

Creeremo anche un file di presentazione da caricare sulla pagina della piattaforma DataHack (per vedere come vanno i nostri risultati nella classifica).

download = drive.CreateFile({'id': '1z4QXy7WravpSj-S4Cs9Fk8ZNaX-qh5HF'})download.GetContentFile('sample_submission_I5njJSF.csv')

# creating submission filesample = pd.read_csv('sample_submission_I5njJSF.csv')sample = predictionsample.to_csv('sample_cnn.csv', header=True, index=False)

Scaricate questo file sample_cnn.csv e caricatelo sulla pagina del concorso per generare i vostri risultati e controllare la vostra posizione in classifica. Questo ti darà una soluzione di riferimento per iniziare con qualsiasi problema di classificazione delle immagini!

Puoi provare la regolazione dell’iperparametro e le tecniche di regolarizzazione per migliorare ulteriormente le prestazioni del tuo modello. Ti consiglio di dare un’occhiata a questo articolo per capire questa fase di fine-tuning in modo molto più dettagliato – ‘A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch’.

Prendendo una sfida diversa

Testiamo il nostro apprendimento su un dataset diverso. In questa sezione risolveremo il problema pratico ‘Identificare le cifre’. Vai avanti e scarica il set di dati. Prima di procedere oltre, prova a risolverlo da solo. Hai già gli strumenti per risolverlo – devi solo applicarli! Torna qui per controllare i tuoi risultati o se ti blocchi in qualche punto.

In questa sfida, dobbiamo identificare la cifra in una data immagine. Abbiamo un totale di 70.000 immagini – 49.000 etichettate nel set di allenamento e le rimanenti 21.000 nel set di test (le immagini di test sono prive di etichetta). Dobbiamo identificare/prevedere la classe di queste immagini non etichettate.

Pronto per iniziare? Fantastico! Crea un nuovo quaderno Python 3 ed esegui il seguente codice:

# Setting up Colab!pip install PyDrive

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

# Replace the id and filename in the below codesdownload = drive.CreateFile({'id': '1ZCzHDAfwgLdQke_GNnHp_4OheRRtNPs-'})download.GetContentFile('Train_UQcUa52.zip')!unzip Train_UQcUa52.zip

# Importing librariesimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

train = pd.read_csv('train.csv')

# Reading the training imagestrain_image = for i in tqdm(range(train.shape)): img = image.load_img('Images/train/'+train, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

# Creating the target variabley=train.valuesy = to_categorical(y)

# Creating validation setX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Define the model structuremodel = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

# Compile the modelmodel.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

# Training the modelmodel.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

download = drive.CreateFile({'id': '1zHJR6yiI06ao-UAh_LXZQRIOzBO3sNDq'})download.GetContentFile('Test_fCbTej3.csv')

test_file = pd.read_csv('Test_fCbTej3.csv')

test_image = for i in tqdm(range(test_file.shape)): img = image.load_img('Images/test/'+test_file, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

prediction = model.predict_classes(test)

download = drive.CreateFile({'id': '1nRz5bD7ReGrdinpdFcHVIEyjqtPGPyHx'})download.GetContentFile('Sample_Submission_lxuyBuB.csv')

sample = pd.read_csv('Sample_Submission_lxuyBuB.csv')sample = test_filesample = predictionsample.to_csv('sample.csv', header=True, index=False)

Invia questo file nella pagina del problema pratico per ottenere un numero di precisione abbastanza decente. È un buon inizio, ma c’è sempre un margine di miglioramento. Continua a giocare con i valori degli iperparametri e vedi se puoi migliorare il nostro modello di base.

Note finali

Chi ha detto che i modelli di apprendimento profondo richiedono ore o giorni per l’addestramento. Il mio scopo qui era quello di mostrare che si può ottenere un modello di deep learning abbastanza decente in un tempo doppio. Dovresti raccogliere sfide simili e provare a codificarle anche dalla tua parte. Non c’è niente di meglio che imparare facendo!

I migliori scienziati e analisti di dati hanno questi codici pronti prima ancora che un Hackathon inizi. Usano questi codici per fare le prime presentazioni prima di tuffarsi in un’analisi dettagliata. Una volta che hanno una soluzione di riferimento, iniziano a migliorare il loro modello utilizzando diverse tecniche.