Alai

Introduktion

”Bygga en modell för djupinlärning på några minuter? Det tar timmar att träna den! Jag har inte ens en tillräckligt bra maskin.” Jag har hört detta otaliga gånger från blivande datavetare som drar sig för att bygga djupinlärningsmodeller på sina egna maskiner.

Du behöver inte arbeta för Google eller andra stora teknikföretag för att arbeta med djupinlärningsdatamängder! Det är fullt möjligt att bygga ditt eget neurala nätverk från grunden på några minuter utan att behöva hyra Googles servrar. Fast.ai:s studenter utformade en modell på Imagenet-dataset på 18 minuter – och jag kommer att visa upp något liknande i den här artikeln.

Djupinlärning är ett stort område, så vi kommer att begränsa vårt fokus lite och anta utmaningen att lösa ett projekt för bildklassificering. Dessutom kommer vi att använda en mycket enkel arkitektur för djupinlärning för att uppnå en ganska imponerande noggrannhet.

Du kan betrakta Pythonkoden som vi kommer att se i den här artikeln som ett riktmärke för att bygga modeller för bildklassificering. När du har fått ett bra grepp om konceptet kan du leka med koden, delta i tävlingar och klättra uppåt på topplistan!

Om du är nybörjare på djupinlärning och är fascinerad av området datorseende (vem är inte det?!), kan du kolla in kursen ”Computer Vision using Deep Learning”. Det är en omfattande introduktion till detta underbara område och kommer att förbereda dig för vad som oundvikligen kommer att bli en enorm arbetsmarknad inom en nära framtid.

Projekt för att tillämpa bildklassificering

Mer än 25 % av alla intäkter inom e-handel tillskrivs kläder & accessoarer. Ett stort problem som de står inför är att kategorisera dessa kläder enbart utifrån bilderna, särskilt när de kategorier som varumärkena tillhandahåller är inkonsekventa. Detta är ett intressant datorseendeproblem som flera forskare inom djupinlärning har fått upp ögonen för.

Fashion MNIST är en ersättare för det mycket välkända MNIST-dataset (maskininlärning – hello world), som kan kontrolleras på övningsuppgiften ”Identify the digits” (Identifiera siffrorna). I stället för siffror visar bilderna en typ av kläder, t.ex. T-shirt, byxor, väska osv. Datamängden som användes i detta problem skapades av Zalando Research.

Öva nu

Innehållsförteckning

1. Vad är bildklassificering och dess användningsområden
2. Sätta upp strukturen för våra bilddata
3. Bryta ner modellbygget. Process
4. Skapa problemformulering och förstå data
5. Steg för att bygga bildklassificeringsmodellen
6. Att ta sig an en annan utmaning

Vad är bildklassificering?

Tänk på nedanstående bild:

Du kommer omedelbart att känna igen den – det är en (flott) bil. Ta ett steg tillbaka och analysera hur du kom fram till denna slutsats – du fick se en bild och du klassificerade vilken klass den tillhörde (en bil, i det här fallet). Och det är i ett nötskal vad bildklassificering handlar om.

Det finns potentiellt n antal kategorier i vilka en given bild kan klassificeras. Att manuellt kontrollera och klassificera bilder är en mycket omständlig process. Uppgiften blir nästan omöjlig när vi står inför ett stort antal bilder, säg 10 000 eller till och med 100 000. Hur användbart skulle det vara om vi kunde automatisera hela denna process och snabbt märka bilderna enligt deras motsvarande klass?

Självkörande bilar är ett utmärkt exempel för att förstå var bildklassificering används i den verkliga världen. För att möjliggöra autonom körning kan vi bygga en bildklassificeringsmodell som känner igen olika objekt, t.ex. fordon, människor, rörliga objekt osv. på vägen. Vi kommer att se några fler användningsfall senare i den här artikeln, men det finns många fler tillämpningar runt omkring oss. Använd kommentarsfältet under artikeln för att låta mig veta vilka potentiella användningsfall du kan komma på!

Nu när vi har koll på vårt ämne ska vi dyka ner i hur en modell för bildklassificering byggs upp, vilka förutsättningar den har och hur den kan implementeras i Python.

Inställer strukturen för våra bilddata

Våra data måste vara i ett visst format för att vi ska kunna lösa ett bildklassificeringsproblem. Vi kommer att se detta i praktiken i ett par avsnitt, men håll dessa tips i minnet tills vi kommer dit.

Du bör ha två mappar, en för träningsuppsättningen och den andra för testuppsättningen. I träningsuppsättningen ska du ha en .csv-fil och en bildmapp:

• Den .csv-filen innehåller namnen på alla träningsbilder och deras motsvarande sanna etiketter
• I bildmappen finns alla träningsbilder.

Den .csv-fil som finns i vår testuppsättning skiljer sig från den som finns i träningsuppsättningen. Denna .csv-fil i testuppsättningen innehåller namnen på alla testbilder, men de har inga motsvarande etiketter. Kan du gissa varför? Vår modell kommer att tränas på de bilder som finns i träningsuppsättningen och etikettprediktionerna kommer att ske på bilderna i testuppsättningen

Om dina data inte är i det format som beskrivs ovan måste du konvertera dem i enlighet med detta (annars kommer prediktionerna att bli fel och ganska värdelösa).

Avveckling av processen för modellbygge

För att vi ska kunna dyka djupt in i Pythonkoden, ska vi ta ett ögonblick för att förstå hur en modell för bildklassificering typiskt sett är utformad. Vi kan dela in denna process i stort sett i fyra steg. Varje steg kräver en viss tid för att utföras:

1. Laddning och förbehandling av data – 30 % tid
2. Definiering av modellarkitektur – 10 % tid
3. Träning av modellen – 50 % tid
4. Uppskattning av prestanda – 10 % tid

Låt mig förklara vart och ett av de ovanstående stegen lite mer i detalj. Det här avsnittet är viktigt eftersom alla modeller inte byggs i första taget. Du måste gå tillbaka efter varje iteration, finjustera dina steg och köra den igen. Att ha en gedigen förståelse för de underliggande begreppen kommer att vara till stor hjälp för att påskynda hela processen.

Steg 1: Laddning och förbehandling av data

Data är guld när det gäller modeller för djupinlärning. Din modell för bildklassificering har mycket större chans att prestera bra om du har en bra mängd bilder i träningsuppsättningen. Dessutom varierar formen på data beroende på vilken arkitektur/ram vi använder.

Här kommer det kritiska steget för förbehandling av data (det evigt viktiga steget i alla projekt). Jag rekommenderar starkt att du går igenom ”Basics of Image Processing in Python” för att förstå mer om hur förbearbetning fungerar med bilddata.

Men vi är inte riktigt framme än. För att se hur vår modell presterar på osynliga data (och innan vi utsätter den för testuppsättningen) måste vi skapa en valideringsuppsättning. Detta görs genom att partitionera data från träningsuppsättningen.

Samt sett tränar vi modellen på träningsdata och validerar den på valideringsdata. När vi är nöjda med modellens prestanda på valideringsuppsättningen kan vi använda den för att göra förutsägelser på testdata.

Tidsåtgång för detta steg: Vi behöver cirka 2-3 minuter för den här uppgiften.

Steg 2: Definiera modellens arkitektur

Det här är ett annat viktigt steg i vår process för att bygga en modell för djupinlärning. Vi måste definiera hur vår modell ska se ut och det kräver svar på frågor som:

• Hur många konvolutionella lager vill vi ha?
• Vad ska aktiveringsfunktionen för varje lager vara?
• Hur många dolda enheter ska varje lager ha?

Och många fler. Detta är i huvudsak modellens hyperparametrar som spelar en MYCKET stor roll när det gäller att avgöra hur bra förutsägelserna blir.

Hur bestämmer vi dessa värden? Utmärkt fråga! En bra idé är att välja dessa värden utifrån befintlig forskning/studier. En annan idé är att fortsätta experimentera med värdena tills du hittar den bästa matchningen, men detta kan vara en ganska tidskrävande process.

Tidsåtgång för detta steg: För att träna modellen behöver vi:

• Träningsbilder och deras motsvarande sanna etiketter
• Valideringsbilder och deras motsvarande sanna etiketter (vi använder dessa etiketter endast för att validera modellen och inte under träningsfasen)

Vi definierar också antalet epoker i detta steg. Till att börja med kör vi modellen i 10 epoker (du kan ändra antalet epoker senare).

Tidsåtgång för detta steg: Eftersom träningen kräver att modellen lär sig strukturer behöver vi cirka 5 minuter för att gå igenom det här steget.

Och nu är det dags att göra förutsägelser!

Steg 4: Uppskattning av modellens prestanda

Slutligt laddar vi testdatan (bilderna) och går igenom förbehandlingssteget även här. Vi förutsäger sedan klasserna för dessa bilder med hjälp av den tränade modellen.

Tidsåtgång för detta steg: ~ 1 minut.

Sätta upp problemformuleringen och förstå data

Vi kommer att plocka upp en riktigt häftig utmaning för att förstå bildklassificering. Vi måste bygga en modell som kan klassificera en given uppsättning bilder enligt kläderna (skjorta, byxor, skor, strumpor osv.). Det är faktiskt ett problem som många e-handelsförsäljare står inför, vilket gör det till ett ännu mer intressant datorseendeproblem.

Denna utmaning heter ”Identify the Apparels” och är ett av de övningsproblem som vi har på vår DataHack-plattform. Du måste registrera dig och ladda ner datasetet från ovanstående länk.

Vi har totalt 70 000 bilder (dimension 28 x 28), varav 60 000 är från träningsuppsättningen och 10 000 från testuppsättningen. Träningsbilderna är förmärkta enligt klädtypen med totalt 10 klasser. Testbilderna är naturligtvis inte märkta. Utmaningen är att identifiera vilken typ av klädesplagg som finns i alla testbilder.

Vi kommer att bygga vår modell på Google Colab eftersom det tillhandahåller en gratis GPU för att träna våra modeller.

Steg för att bygga vår modell

Det är dags att elda upp dina Pythonkunskaper och få dina händer smutsiga. Vi är äntligen framme vid implementeringsdelen av vår inlärning!

1. Installation av Google Colab
2. Import av bibliotek
3. Laddning och förbehandling av data – (3 minuter)
4. Skapande av en valideringsuppsättning
5. Definiera modellstrukturen – (1 min)
6. Träna modellen – (5 min)
7. Göra förutsägelser – (1 min)

Låt oss titta på varje steg i detalj.

Steg 1: Konfigurera Google Colab

Då vi importerar våra data från en Google Drive-länk måste vi lägga till några rader kod i vår anteckningsbok för Google Colab. Skapa en ny anteckningsbok för Python 3 och skriv följande kodblock:

!pip install PyDrive

Detta kommer att installera PyDrive. Nu ska vi importera några nödvändiga bibliotek:

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

Nästan ska vi skapa en drive-variabel för att få tillgång till Google Drive:

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

För att hämta datasetet använder vi ID:et för den fil som laddats upp på Google Drive:

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

Ersätt ”id” i koden ovan med ID:et för din fil. Nu laddar vi ner filen och packar upp den:

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

Du måste köra dessa kodblock varje gång du startar din anteckningsbok.

Steg 2 : Importera biblioteken som vi kommer att behöva under modellbyggnadsfasen.

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

Steg 3: Återkalla förbehandlingsstegen som vi diskuterade tidigare. Vi kommer att använda dem här efter att ha laddat data.

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

Nästan kommer vi att läsa alla träningsbilder, lagra dem i en lista och slutligen konvertera den listan till en numpy-array.

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

Då det är ett klassificeringsproblem med flera klasser (10 klasser) kommer vi att en-hot koda målvariabeln.

y=train.valuesy = to_categorical(y)

Steg 4: Skapa en valideringsuppsättning från träningsdata.

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

Steg 5: Definiera modellstrukturen.

Vi kommer att skapa en enkel arkitektur med två konvolutionella lager, ett tätt dolt lager och ett utgångslager.

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ästan kommer vi att kompilera den modell vi har skapat.

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

Steg 6: Träning av modellen.

I det här steget tränar vi modellen på bilderna i träningsuppsättningen och validerar den med hjälp av, du gissade det, valideringsuppsättningen.

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

Steg 7: Göra förutsägelser!

Vi följer till att börja med de steg vi utförde när vi hanterade träningsdata. Ladda testbilderna och förutsäga deras klasser med hjälp av funktionen model.predict_classes().

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

Låt oss importera testfilen:

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

Nu kommer vi att läsa och lagra alla testbilder:

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)

Vi kommer också att skapa en inlämningsfil som vi kan ladda upp på sidan för DataHack-plattformen (för att se hur våra resultat ligger till på topplistan).

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)

Hämta den här filen sample_cnn.csv och ladda upp den på tävlingssidan för att skapa dina resultat och kontrollera din placering på topplistan. Detta kommer att ge dig en referenslösning för att komma igång med alla problem med bildklassificering!

Du kan prova hyperparameterinställning och regleringstekniker för att förbättra din modells prestanda ytterligare. Jag uppmuntrar dig att läsa den här artikeln för att förstå detta finjusteringssteg mycket mer i detalj – ”A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch”.

Picking up a Different Challenge

Låt oss testa vår inlärning på ett annat dataset. Vi kommer att knäcka övningsproblemet ”Identifiera siffrorna” i det här avsnittet. Gå vidare och ladda ner datasetet. Innan du går vidare kan du försöka lösa detta på egen hand. Du har redan verktygen för att lösa det – du behöver bara tillämpa dem! Kom tillbaka hit för att kontrollera dina resultat eller om du fastnar vid något tillfälle.

I den här utmaningen måste vi identifiera siffran i en given bild. Vi har totalt 70 000 bilder – 49 000 märkta bilder i träningsuppsättningen och resterande 21 000 i testuppsättningen (testbilderna är omärkta). Vi måste identifiera/förutsäga klassen för dessa omärkta bilder.

Är du redo att börja? Fantastiskt! Skapa en ny anteckningsbok för Python 3 och kör följande kod:

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

Sänd in den här filen på sidan med övningsproblem för att få ett ganska hyfsat noggrannhetstal. Det är en bra början, men det finns alltid utrymme för förbättringar. Fortsätt att leka med hyperparametervärdena och se om du kan förbättra vår grundmodell.

Slutanteckningar

Vem har sagt att djupinlärningsmodeller kräver timmar eller dagar för att tränas? Mitt syfte här var att visa att man kan få fram en ganska hygglig djupinlärningsmodell på dubbelt så snabb tid. Du bör plocka upp liknande utmaningar och försöka koda dem från din sida också. Det finns inget bättre än att lära sig genom att göra!

De bästa datavetarna och analytikerna har dessa koder klara innan ett hackathon ens börjar. De använder dessa koder för att göra tidiga inlämningar innan de dyker in i en detaljerad analys. När de väl har en referenslösning börjar de förbättra sin modell med hjälp av olika tekniker.