Alai

Introducere

„Construiți un model de învățare profundă în câteva minute? Va dura ore întregi pentru a se antrena! Nici măcar nu am o mașină suficient de bună.” Am auzit acest lucru de nenumărate ori de la cercetători de date aspiranți care se feresc să construiască modele de învățare profundă pe propriile lor mașini.

Nu trebuie să lucrați pentru Google sau alte firme mari de tehnologie pentru a lucra pe seturi de date de învățare profundă! Este absolut posibil să vă construiți propria rețea neuronală de la zero în câteva minute, fără a fi nevoie să închiriați serverele Google. Studenții de la Fast.ai au proiectat un model pe setul de date Imagenet în 18 minute – iar eu voi prezenta ceva similar în acest articol.

Învățarea profundă este un domeniu vast, așa că ne vom restrânge puțin atenția și vom accepta provocarea de a rezolva un proiect de clasificare a imaginilor. În plus, vom folosi o arhitectură foarte simplă de învățare profundă pentru a obține un scor de acuratețe destul de impresionant.

Puteți considera codul Python pe care îl vom vedea în acest articol ca fiind un punct de referință pentru construirea modelelor de clasificare a imaginilor. Odată ce înțelegeți bine conceptul, mergeți mai departe și jucați-vă cu codul, participați la competiții și urcați în clasament!

Dacă sunteți nou în învățarea profundă și sunteți fascinat de domeniul vederii computerizate (cine nu este?!), consultați cursul „Computer Vision using Deep Learning”. Este o introducere cuprinzătoare în acest domeniu minunat și vă va pregăti pentru ceea ce va fi, în mod inevitabil, o piață de muncă imensă în viitorul apropiat.

Proiect pentru aplicarea clasificării imaginilor

Mai mult de 25% din totalul veniturilor din comerțul electronic sunt atribuite accesoriilor de îmbrăcăminte &. O problemă majoră cu care se confruntă aceștia este clasificarea acestor articole de îmbrăcăminte doar din imagini, mai ales atunci când categoriile furnizate de mărci sunt inconsistente. Acest lucru reprezintă o problemă interesantă de viziune computerizată care a atras atenția mai multor cercetători în domeniul învățării profunde.

Fashion MNIST este un înlocuitor pentru foarte bine cunoscutul set de date MNIST – Machine Learning Hello World, care poate fi verificat la problema practică „Identify the digits”. În loc de cifre, imaginile prezintă un tip de îmbrăcăminte, de exemplu, tricou, pantaloni, geantă etc. Setul de date utilizat în această problemă a fost creat de Zalando Research.

Practicați acum

Tabel de materii

1. Ce este clasificarea imaginilor și cazurile sale de utilizare
2. Stabilirea structurii datelor noastre de imagine
3. Descompunerea construcției modelului Proces
4. Stabilirea enunțului problemei și înțelegerea datelor
5. Pași pentru construirea modelului de clasificare a imaginilor
6. Începând o altă provocare

Ce este clasificarea imaginilor?

Considerați imaginea de mai jos:

Vă veți fi recunoscut instantaneu – este o mașină (șic). Faceți un pas înapoi și analizați cum ați ajuns la această concluzie – vi s-a arătat o imagine și ați clasificat clasa căreia îi aparține (o mașină, în acest caz). Și, pe scurt, despre asta este vorba în clasificarea imaginilor.

Există un număr potențial n de categorii în care poate fi clasificată o anumită imagine. Verificarea și clasificarea manuală a imaginilor este un proces foarte anevoios. Sarcina devine aproape imposibilă atunci când ne confruntăm cu un număr masiv de imagini, să zicem 10.000 sau chiar 100.000. Cât de util ar fi dacă am putea să automatizăm acest întreg proces și să etichetăm rapid imaginile în funcție de clasa lor corespunzătoare?

Mașinile care se conduc singure sunt un exemplu excelent pentru a înțelege unde este utilizată clasificarea imaginilor în lumea reală. Pentru a permite conducerea autonomă, putem construi un model de clasificare a imaginilor care să recunoască diverse obiecte, cum ar fi vehicule, persoane, obiecte în mișcare etc. pe șosea. Vom vedea alte câteva cazuri de utilizare mai târziu în acest articol, dar există o mulțime de alte aplicații în jurul nostru. Folosiți secțiunea de comentarii de sub articol pentru a-mi spune ce potențiale cazuri de utilizare vă pot veni în minte!

Acum că ne-am familiarizat cu subiectul nostru, haideți să ne scufundăm în modul în care se construiește un model de clasificare a imaginilor, care sunt premisele pentru acesta și cum poate fi implementat în Python.

Stabilirea structurii datelor noastre de imagine

Datele noastre trebuie să fie într-un anumit format pentru a rezolva o problemă de clasificare a imaginilor. Vom vedea acest lucru în acțiune în câteva secțiuni, dar țineți minte aceste indicații până ajungem acolo.

Ar trebui să aveți 2 foldere, unul pentru setul de antrenament și celălalt pentru setul de testare. În setul de antrenament, veți avea un fișier .csv și un dosar de imagini:

• Fisierul .csv conține numele tuturor imaginilor de antrenament și etichetele lor adevărate corespunzătoare
• Darul de imagini conține toate imaginile de antrenament.

Fisierul .csv din setul nostru de testare este diferit de cel prezent în setul de antrenament. Acest fișier .csv din setul de testare conține numele tuturor imaginilor de testare, dar acestea nu au nicio etichetă corespunzătoare. Puteți ghici de ce? Modelul nostru va fi antrenat pe imaginile prezente în setul de antrenament, iar predicțiile etichetelor se vor face pe imaginile din setul de testare

Dacă datele dvs. nu sunt în formatul descris mai sus, va trebui să le convertiți în mod corespunzător (în caz contrar, predicțiile vor fi greșite și destul de inutile).

Descompunerea procesului de construire a modelului

Înainte de a intra în profunzimea codului Python, haideți să ne oprim un moment pentru a înțelege cum este proiectat, de obicei, un model de clasificare a imaginilor. Putem împărți acest proces în linii mari în 4 etape. Fiecare etapă necesită o anumită cantitate de timp pentru a fi executată:

1. Încărcarea și preprocesarea datelor – 30% timp
2. Definirea arhitecturii modelului – 10% timp
3. Învățarea modelului – 50% timp
4. Estimarea performanței – 10% timp

Dați-mi voie să explic fiecare dintre etapele de mai sus puțin mai detaliat. Această secțiune este crucială, deoarece nu orice model este construit din prima încercare. Va trebui să vă întoarceți după fiecare iterație, să vă ajustați pașii și să îl rulați din nou. Având o înțelegere solidă a conceptelor care stau la bază, veți accelera mult întregul proces.

Etapa 1: Încărcarea și preprocesarea datelor

Datele sunt aur în ceea ce privește modelele de învățare profundă. Modelul dvs. de clasificare a imaginilor are o șansă mult mai mare de a performa bine dacă aveți o cantitate bună de imagini în setul de antrenament. De asemenea, forma datelor variază în funcție de arhitectura/framework-ul pe care îl folosim.

De aici, etapa critică de preprocesare a datelor (etapa veșnic importantă în orice proiect). Vă recomand cu căldură să parcurgeți „Bazele procesării imaginilor în Python” pentru a înțelege mai multe despre cum funcționează preprocesarea cu datele de imagine.

Dar nu am ajuns încă acolo. Pentru a vedea cum se comportă modelul nostru pe date nevăzute (și înainte de a-l expune la setul de testare), trebuie să creăm un set de validare. Acest lucru se face prin împărțirea datelor din setul de antrenament.

Pe scurt, antrenăm modelul pe datele de antrenament și îl validăm pe datele de validare. Odată ce suntem mulțumiți de performanța modelului pe setul de validare, îl putem folosi pentru a face predicții pe datele de testare.

Timp necesar pentru această etapă: Avem nevoie de aproximativ 2-3 minute pentru această sarcină.

Etapa 2: Definirea arhitecturii modelului

Aceasta este o altă etapă crucială în procesul de construire a modelului nostru de învățare profundă. Trebuie să definim cum va arăta modelul nostru și asta necesită să răspundem la întrebări precum:

• Câte straturi convoluționale ne dorim?
• Ce funcție de activare ar trebui să fie pentru fiecare strat?
• Câte unități ascunse ar trebui să aibă fiecare strat?

Și multe altele. Aceștia sunt, în esență, hiperparametrii modelului care joacă un rol MASIV în a decide cât de bune vor fi predicțiile.

Cum decidem aceste valori? Excelentă întrebare! O idee bună este să alegem aceste valori pe baza cercetărilor/studiilor existente. O altă idee este să continuați să experimentați cu valorile până când găsiți cea mai bună potrivire, dar acest lucru poate fi un proces destul de consumator de timp.

Timp necesar pentru această etapă: Ar trebui să dureze în jur de 1 minut pentru a defini arhitectura modelului.

Etapa 3: Formarea modelului

Pentru formarea modelului, avem nevoie de:

• Imagini de formare și etichetele adevărate corespunzătoare
• Imagini de validare și etichetele adevărate corespunzătoare (folosim aceste etichete doar pentru a valida modelul și nu în timpul fazei de formare)

De asemenea, definim numărul de epoci în această etapă. Pentru început, vom rula modelul timp de 10 epoci (puteți modifica numărul de epoci ulterior).

Timp necesar pentru această etapă: Deoarece antrenamentul necesită ca modelul să învețe structuri, avem nevoie de aproximativ 5 minute pentru a parcurge această etapă.

Și acum este timpul să facem predicții!

Etapa 4: Estimarea performanței modelului

În cele din urmă, încărcăm datele de test (imagini) și parcurgem etapa de preprocesare și aici. Apoi prezicem clasele pentru aceste imagini folosind modelul antrenat.

Timp necesar pentru această etapă: ~ 1 minut.

Stabilirea enunțului problemei și înțelegerea datelor

Vom prelua o provocare foarte interesantă pentru a înțelege clasificarea imaginilor. Trebuie să construim un model care poate clasifica un set dat de imagini în funcție de îmbrăcăminte (cămașă, pantaloni, pantofi, șosete, etc.). Este de fapt o problemă cu care se confruntă mulți comercianți cu amănuntul de comerț electronic, ceea ce o face o problemă de viziune computerizată și mai interesantă.

Această provocare se numește „Identify the Apparels” și este una dintre problemele de practică pe care le avem pe platforma noastră DataHack. Va trebui să vă înregistrați și să descărcați setul de date de la link-ul de mai sus.

Avem un total de 70.000 de imagini (dimensiunea 28 x 28), dintre care 60.000 sunt din setul de antrenament și 10.000 din cel de testare. Imaginile de antrenament sunt pre-etichetate în funcție de tipul de îmbrăcăminte, cu un total de 10 clase. Imaginile de test nu sunt, bineînțeles, etichetate. Provocarea este de a identifica tipul de îmbrăcăminte prezent în toate imaginile de test.

Ne vom construi modelul nostru pe Google Colab, deoarece oferă un GPU gratuit pentru a ne antrena modelele.

Pasi pentru construirea modelului nostru

Este timpul să vă activați abilitățile Python și să vă murdăriți mâinile. Am ajuns în sfârșit la partea de implementare a învățării noastre!

1. Configurarea Google Colab
2. Importul bibliotecilor
3. Încărcarea și preprocesarea datelor – (3 minute)
4. Crearea unui set de validare

.

5. Definirea structurii modelului – (1 min)
6. Învățarea modelului – (5 min)
7. Facerea predicțiilor – (1 min)

Să analizăm fiecare etapă în detaliu.

Pasul 1: Configurarea Google Colab

Din moment ce importăm datele noastre de la un link Google Drive, va trebui să adăugăm câteva linii de cod în caietul nostru Google Colab. Creați un nou caiet Python 3 și scrieți următoarele blocuri de cod:

!pip install PyDrive

Acest lucru va instala PyDrive. Acum vom importa câteva biblioteci necesare:

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

În continuare, vom crea o variabilă drive pentru a accesa Google Drive:

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

Pentru a descărca setul de date, vom folosi ID-ul fișierului încărcat pe Google Drive:

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

Înlocuiți „id” din codul de mai sus cu ID-ul fișierului dumneavoastră. Acum vom descărca acest fișier și îl vom dezarhiva:

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

Trebuie să rulați aceste blocuri de cod de fiecare dată când porniți notebook-ul.

Pasul 2 : Importați bibliotecile de care vom avea nevoie în timpul fazei de construire a modelului.

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

Pasul 3: Reamintiți pașii de preprocesare pe care i-am discutat mai devreme. Le vom folosi aici după ce încărcăm datele.

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

În continuare, vom citi toate imaginile de antrenament, le vom stoca într-o listă și, în cele din urmă, vom converti acea listă într-o matrice 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)

Pentru că este o problemă de clasificare multiclasă (10 clase), vom codifica într-un singur rând variabila țintă.

y=train.valuesy = to_categorical(y)

Etapa 4: Crearea unui set de validare din datele de instruire.

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

Etapa 5: Definirea structurii modelului.

Vom crea o arhitectură simplă cu 2 straturi convoluționale, un strat ascuns dens și un strat de ieșire.

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

În continuare, vom compila modelul pe care l-am creat.

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

Etapa 6: Instruirea modelului.

În acest pas, vom antrena modelul pe imaginile din setul de antrenament și îl vom valida folosind, ați ghicit, setul de validare.

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

Etapa 7: Realizarea predicțiilor!

Vom urma inițial pașii pe care i-am efectuat atunci când ne-am ocupat de datele de antrenament. Vom încărca imaginile de test și vom prezice clasele acestora folosind funcția model.predict_classes().

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

Să importăm fișierul de test:

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

Acum, vom citi și stoca toate imaginile de 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)

Vom crea, de asemenea, un fișier de trimitere pentru a-l încărca pe pagina platformei DataHack (pentru a vedea cum se situează rezultatele noastre în clasament).

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)

Download this sample_cnn.csv file and upload it on the contest page to generate your results and check your ranking on the leaderboard. Acest lucru vă va oferi o soluție de referință pentru a începe cu orice problemă de clasificare a imaginilor!

Puteți încerca tehnici de reglare a hiperparametrilor și de regularizare pentru a îmbunătăți și mai mult performanța modelului dvs. Vă încurajez să consultați acest articol pentru a înțelege acest pas de reglare fină mult mai detaliat – ‘A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch’.

Picking up a Different Challenge

Să testăm învățarea noastră pe un set de date diferit. În această secțiune vom rezolva problema practică „Identify the Digits”. Mergeți mai departe și descărcați setul de date. Înainte de a continua, încercați să o rezolvați pe cont propriu. Aveți deja instrumentele necesare pentru a o rezolva – trebuie doar să le aplicați! Reveniți aici pentru a vă verifica rezultatele sau dacă vă blocați la un moment dat.

În această probă, trebuie să identificăm cifra dintr-o imagine dată. Avem un total de 70.000 de imagini – 49.000 etichetate în setul de antrenament și restul de 21.000 în setul de test (imaginile de test sunt neetichetate). Trebuie să identificăm/precizăm clasa acestor imagini neetichetate.

Pregătiți să începeți? Minunat! Creați un nou notebook Python 3 și rulați următorul cod:

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

Subliniți acest fișier pe pagina cu probleme practice pentru a obține un număr de acuratețe destul de decent. Este un început bun, dar există întotdeauna loc de îmbunătățire. Continuați să vă jucați cu valorile hiperparametrilor și vedeți dacă puteți îmbunătăți modelul nostru de bază.

Note de final

Cine a spus că modelele de învățare profundă necesită ore sau zile pentru a fi antrenate. Scopul meu aici a fost să arăt că se poate obține un model de învățare profundă destul de decent în timp dublu-rapid. Ar trebui să preluați provocări similare și să încercați să le codificați și din partea dumneavoastră. Nimic nu se compară cu învățarea prin practică!

Cei mai buni oameni de știință și analiști de date au aceste coduri pregătite chiar înainte de a începe un Hackathon. Ei folosesc aceste coduri pentru a face prezentări timpurii înainte de a se scufunda într-o analiză detaliată. Odată ce au o soluție de referință, ei încep să își îmbunătățească modelul folosind diferite tehnici.

.