Alai

Inleiding

“Een deep learning model bouwen in een paar minuten? Het zal uren duren om te trainen! Ik heb niet eens een machine die goed genoeg is.” Ik heb dit ontelbare keren gehoord van aspirant-datawetenschappers die terugdeinzen voor het bouwen van deep learning-modellen op hun eigen machines.

Je hoeft niet voor Google of andere grote techbedrijven te werken om aan deep learning-datasets te werken! Het is heel goed mogelijk om je eigen neurale netwerk vanaf de grond op te bouwen in een kwestie van minuten zonder Google’s servers te hoeven leasen. Studenten van Fast.ai ontwierpen een model op de Imagenet dataset in 18 minuten – en ik zal iets soortgelijks laten zien in dit artikel.

Diep leren is een enorm gebied, dus we zullen onze focus een beetje verkleinen en de uitdaging aangaan om een beeldclassificatieproject op te lossen. Bovendien zullen we een zeer eenvoudige deep learning-architectuur gebruiken om een behoorlijk indrukwekkende nauwkeurigheidsscore te behalen.

Je kunt de Python-code die we in dit artikel zullen zien, beschouwen als een benchmark voor het bouwen van modellen voor beeldclassificatie. Als je het concept eenmaal goed in de vingers hebt, ga je gang en speel je met de code, neem je deel aan wedstrijden en klim je op het leaderboard!

Als je nieuw bent op het gebied van deep learning en gefascineerd bent door het gebied van computervisie (wie is dat niet?!), bekijk dan de cursus ‘Computer Vision using Deep Learning’. Het is een uitgebreide inleiding in dit prachtige vakgebied en zal u voorbereiden op wat in de nabije toekomst onvermijdelijk een enorme banenmarkt zal worden.

Project om beeldclassificatie toe te passen

Meer dan 25% van de totale omzet in de e-handel wordt toegeschreven aan kleding & accessoires. Een groot probleem is het categoriseren van deze kleding op basis van alleen de afbeeldingen, vooral wanneer de door de merken verstrekte categorieën inconsistent zijn. Dit stelt een interessant computer vision probleem dat de ogen heeft getrokken van verschillende deep learning onderzoekers.

Fashion MNIST is een drop-in vervanging voor de zeer bekende, machine learning hello world – MNIST dataset die kan worden gecontroleerd op ‘Identify the digits’ oefenprobleem. In plaats van cijfers tonen de afbeeldingen een type kledingstuk, bv. T-shirt, broek, tas, enz. De dataset die voor dit probleem is gebruikt, is gemaakt door Zalando Research.

Nu oefenen

Inhoudsopgave

1. Wat is beeldclassificatie en de gebruikssituaties
2. Opzetten van de structuur van onze beeldgegevens
3. Ontbreken van het modelbouw Proces
4. Opstellen van de probleemstelling en begrip van de gegevens
5. Stappen om het model voor beeldclassificatie te bouwen
6. Opnieuw een uitdaging aangaan

Wat is beeldclassificatie?

Kijk eens naar de onderstaande afbeelding:

U herkent het meteen – het is een (chique) auto. Neem een stap terug en analyseer hoe u tot deze conclusie bent gekomen – u kreeg een afbeelding te zien en u classificeerde de klasse waartoe deze behoorde (een auto, in dit geval). En dat, in een notendop, is waar het bij beeldindeling om gaat.

Er zijn potentieel n aantal categorieën waarin een gegeven beeld kan worden ingedeeld. Het handmatig controleren en classificeren van afbeeldingen is een zeer vervelend proces. De taak wordt bijna onmogelijk wanneer we geconfronteerd worden met een enorm aantal beelden, laten we zeggen 10.000 of zelfs 100.000. Hoe nuttig zou het zijn als we dit hele proces zouden kunnen automatiseren en beelden snel zouden kunnen classificeren?

Zelfrijdende auto’s zijn een goed voorbeeld om te begrijpen waar beeldclassificatie in de echte wereld wordt gebruikt. Om autonoom rijden mogelijk te maken, kunnen we een beeldclassificatiemodel bouwen dat verschillende objecten herkent, zoals voertuigen, mensen, bewegende objecten, enz. op de weg. We zullen later in dit artikel nog een paar use cases zien, maar er zijn nog veel meer toepassingen om ons heen. Gebruik de commentaar sectie onder het artikel om me te laten weten welke potentiële use cases je kunt bedenken!

Nu we grip hebben op ons onderwerp, laten we eens duiken in hoe een beeld classificatie model wordt gebouwd, wat de vereisten ervoor zijn, en hoe het kan worden geïmplementeerd in Python.

Opzetten van de structuur van onze Beeld Data

Onze data moet in een bepaald formaat zijn om een beeld classificatie probleem op te lossen. We zullen dit in een paar secties in actie zien, maar houd deze aanwijzingen in gedachten tot we er zijn.

Je zou 2 mappen moeten hebben, een voor de trainingsset en de andere voor de testset. In de trainingsset hebt u een .csv-bestand en een map met afbeeldingen:

• Het .csv-bestand bevat de namen van alle trainingsafbeeldingen en hun overeenkomstige ware labels
• De map met afbeeldingen bevat alle trainingsafbeeldingen.

Het .csv-bestand in onze testset is anders dan dat in de trainingsset. Dit test set .csv bestand bevat de namen van alle test afbeeldingen, maar ze hebben geen overeenkomstige labels. Kun je raden waarom? Ons model zal worden getraind op de afbeeldingen in de trainingsset en de labelvoorspellingen zullen gebeuren op de afbeeldingen in de testset

Als uw gegevens niet in het hierboven beschreven formaat zijn, moet u ze dienovereenkomstig converteren (anders zullen de voorspellingen verkeerd en tamelijk nutteloos zijn).

Het proces van modelbouw

Voordat we diep in de Python-code duiken, nemen we even de tijd om te begrijpen hoe een beeldclassificatiemodel gewoonlijk wordt ontworpen. We kunnen dit proces grofweg in 4 fasen verdelen. Elke fase vergt een bepaalde hoeveelheid tijd om uit te voeren:

1. Gegevens inladen en voorbewerken – 30% tijd
2. Modelarchitectuur bepalen – 10% tijd
3. Trainen van het model – 50% tijd
4. Raming van de prestaties – 10% tijd

Laat me elk van de bovenstaande stappen een beetje meer in detail uitleggen. Dit gedeelte is van cruciaal belang omdat niet elk model in één keer wordt gebouwd. Na elke iteratie moet je teruggaan, je stappen bijstellen en het opnieuw uitvoeren. Een goed begrip van de onderliggende concepten zal het hele proces versnellen.

Stap 1: Het laden en voorbewerken van de gegevens

Data is goud voor zover het deep learning-modellen betreft. Uw model voor beeldclassificatie heeft een veel betere kans om goed te presteren als u een goede hoeveelheid afbeeldingen in de trainingsset hebt. Ook varieert de vorm van de gegevens afhankelijk van de architectuur/framework dat we gebruiken.

Hence, de kritieke data pre-processing stap (de eeuwig belangrijke stap in elk project). Ik raad ten zeerste aan de ‘Basics of Image Processing in Python’ door te nemen om meer te begrijpen over hoe pre-processing werkt met beeldgegevens.

Maar we zijn er nog niet helemaal. Om te zien hoe ons model presteert op ongeziene data (en voordat we het blootstellen aan de testset), moeten we een validatieset maken. Dit wordt gedaan door de gegevens van de trainingsset te partitioneren.

In het kort, we trainen het model op de trainingsgegevens en valideren het op de validatiegegevens. Zodra we tevreden zijn met de prestaties van het model op de validatieset, kunnen we het gebruiken voor het maken van voorspellingen op de testdata.

Tijd nodig voor deze stap: We hebben ongeveer 2-3 minuten nodig voor deze taak.

Stap 2: De architectuur van het model definiëren

Dit is een andere cruciale stap in ons deep learning modelbouwproces. We moeten definiëren hoe ons model eruit zal zien en dat vereist het beantwoorden van vragen als:

• Hoeveel convolutionele lagen willen we?
• Wat moet de activeringsfunctie voor elke laag zijn?
• Hoeveel verborgen eenheden moet elke laag hebben?

En nog veel meer. Dit zijn in wezen de hyperparameters van het model die een MASSIEVE rol spelen bij het bepalen hoe goed de voorspellingen zullen zijn.

Hoe bepalen we deze waarden? Uitstekende vraag! Een goed idee is om deze waarden te kiezen op basis van bestaande onderzoeken/studies. Een ander idee is om te blijven experimenteren met de waarden totdat je de beste match vindt, maar dit kan een vrij tijdrovend proces zijn.

Tijd nodig voor deze stap: Het zou ongeveer 1 minuut moeten duren om de architectuur van het model te definiëren.

Stap 3: Het model trainen

Voor het trainen van het model hebben we nodig:

• Trainingafbeeldingen en hun overeenkomstige ware labels
• Validatieafbeeldingen en hun overeenkomstige ware labels (we gebruiken deze labels alleen om het model te valideren en niet tijdens de trainingsfase)

We bepalen ook het aantal epochs in deze stap. Om te beginnen laten we het model 10 keer draaien (u kunt het aantal later wijzigen).

De benodigde tijd voor deze stap: Aangezien training vereist dat het model structuren leert, hebben we ongeveer 5 minuten nodig om deze stap te doorlopen.

En nu tijd om voorspellingen te doen!

Stap 4: Het schatten van de prestaties van het model

Tot slot laden we de testgegevens (afbeeldingen) en doorlopen ook hier de voorbewerkingsstap. Vervolgens voorspellen we de klassen voor deze afbeeldingen met behulp van het getrainde model.

Tijd nodig voor deze stap: ~ 1 minuut.

Opzetten van de probleemstelling en begrijpen van de gegevens

We zullen een echt coole uitdaging oppakken om beeldclassificatie te begrijpen. We moeten een model bouwen dat een gegeven set afbeeldingen kan classificeren aan de hand van de kleding (overhemd, broek, schoenen, sokken, etc.). Het is eigenlijk een probleem waar veel e-commerce retailers mee te maken hebben, wat het een nog interessanter computer vision probleem maakt.

Deze uitdaging heet ‘Identify the Apparels’ en is een van de oefenproblemen die we hebben op ons DataHack platform. U moet zich registreren en de dataset downloaden via de bovenstaande link.

We hebben in totaal 70.000 afbeeldingen (afmeting 28 x 28), waarvan 60.000 uit de trainingsset en 10.000 uit de testset. De trainingsbeelden zijn vooraf gelabeld volgens het type kleding met 10 totale klassen. De testbeelden zijn, uiteraard, niet gelabeld. De uitdaging is om het type kleding te identificeren dat in alle testafbeeldingen aanwezig is.

We zullen ons model bouwen op Google Colab omdat het een gratis GPU biedt om onze modellen te trainen.

Stappen om ons model te bouwen

Tijd om je Python-vaardigheden aan te wakkeren en je handen vuil te maken. We zijn eindelijk bij de uitvoering van ons leerproces!

1. Opzetten van Google Colab
2. Bibliotheken importeren
3. Gegevens laden en voorbewerken – (3 mins)
4. Een validatieset maken
5. De modelstructuur bepalen – (1 min)
6. Het model trainen – (5 min)
7. Voorspellingen doen – (1 min)

Laten we elke stap eens in detail bekijken.

Stap 1: Google Colab instellen

Omdat we onze gegevens importeren van een Google Drive-link, moeten we een paar regels code toevoegen in ons Google Colab-notitieblok. Maak een nieuw Python 3 notitieboek en schrijf de volgende codeblokken:

!pip install PyDrive

Dit zal PyDrive installeren. Nu zullen we een paar benodigde bibliotheken importeren:

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

Volgende, we zullen een drive variabele aanmaken om toegang te krijgen tot Google Drive:

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

Om de dataset te downloaden, zullen we de ID gebruiken van het bestand dat is geupload op Google Drive:

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

Vervang de ‘id’ in de bovenstaande code met de ID van uw bestand. Nu zullen we dit bestand downloaden en uitpakken:

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

Je moet deze codeblokken elke keer uitvoeren als je je notebook opstart.

Stap 2 : Importeer de bibliotheken die we nodig zullen hebben tijdens onze modelbouwfase.

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

Stap 3: Herinner je de pre-processing stappen die we eerder hebben besproken. We zullen ze hier gebruiken na het laden van de data.

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

Volgende, zullen we alle trainingsafbeeldingen lezen, ze opslaan in een lijst, en ten slotte die lijst omzetten in een 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)

Omdat het een multi-class classificatie probleem is (10 klassen), zullen we de doelvariabele een-hot coderen.

y=train.valuesy = to_categorical(y)

Stap 4: Het creëren van een validatie set van de training data.

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

Stap 5: Definieer de model structuur.

We zullen een eenvoudige architectuur met 2 convolutionele lagen, een dichte verborgen laag en een output layer.

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

Volgende, zullen we compileren het model dat we hebben gemaakt.

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

Stap 6: Het trainen van het model.

In deze stap trainen we het model op de afbeeldingen van de trainingsset en valideren we het met, u raadt het al, de validatieset.

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

Stap 7: Voorspellingen doen!

We volgen eerst de stappen die we bij de trainingsgegevens hebben uitgevoerd. Laad de testafbeeldingen en voorspel hun klassen met de functie model.predict_classes().

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

Laten we het testbestand importeren:

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

Nu zullen we alle testafbeeldingen lezen en opslaan:

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)

We zullen ook een indieningsbestand maken om te uploaden op de DataHack-platformpagina (om te zien hoe onze resultaten het doen op het leaderboard).

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 dit voorbeeldbestand_cnn.csv en upload het naar de wedstrijdpagina om uw resultaten te genereren en uw plaats op het leaderboard te controleren. Dit geeft u een benchmark-oplossing om u op weg te helpen met elk beeldclassificatieprobleem!

U kunt hyperparameterafstelling en regularisatietechnieken proberen om de prestaties van uw model verder te verbeteren. Ik raad u aan dit artikel te lezen om deze fijnafstemmingsstap in veel meer detail te begrijpen – ‘Een uitgebreide handleiding om Convolutionele Neurale Netwerken vanaf nul te leren’.

Een andere uitdaging oppakken

Laten we ons leerproces eens testen op een andere dataset. We zullen het ‘Identificeer de cijfers’-oefenprobleem in deze sectie kraken. Ga je gang en download de dataset. Voordat je verder gaat, probeer dit zelf op te lossen. Je hebt de middelen al om het op te lossen – je moet ze alleen nog toepassen! Kom hier terug om je resultaten te controleren of als je op een bepaald punt vastloopt.

In deze uitdaging moeten we het cijfer in een gegeven afbeelding identificeren. We hebben in totaal 70.000 afbeeldingen – 49.000 gelabelde in de trainingsset en de resterende 21.000 in de testset (de testafbeeldingen zijn niet gelabeld). We moeten de klasse van deze ongelabelde afbeeldingen bepalen/voorspellen.

Klaar om te beginnen? Geweldig! Maak een nieuw Python 3 notebook aan en voer de volgende code uit:

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

Zend dit bestand in op de oefenprobleempagina om een behoorlijk nauwkeurigheidscijfer te krijgen. Het is een goed begin, maar er is altijd ruimte voor verbetering. Blijf spelen met de hyperparameterwaarden en kijk of je ons basismodel kunt verbeteren.

End Notes

Wie zei dat deep learning modellen uren of dagen nodig hebben om te trainen. Mijn doel hier was om te laten zien dat je een behoorlijk deep learning model kunt maken in dubbelsnelle tijd. Je moet soortgelijke uitdagingen oppakken en proberen ze ook van jouw kant te coderen. Er gaat niets boven leren door te doen!

De beste datawetenschappers en -analisten hebben deze codes al klaar voordat een Hackathon begint. Ze gebruiken deze codes om in een vroeg stadium voorstellen te doen voordat ze in een gedetailleerde analyse duiken. Zodra ze een benchmarkoplossing hebben, beginnen ze hun model te verbeteren met behulp van verschillende technieken.