Alai

Indledning

“Byg en deep learning-model på få minutter? Det vil tage timer at træne den! Jeg har ikke engang en maskine, der er god nok.” Jeg har hørt dette utallige gange fra håbefulde dataloger, der viger tilbage fra at bygge deep learning-modeller på deres egne maskiner.

Du behøver ikke at arbejde for Google eller andre store teknologivirksomheder for at arbejde på deep learning-datasæt! Det er helt muligt at opbygge dit eget neurale netværk fra bunden på få minutter uden at skulle leje Googles servere. Fast.ai’s studerende designede en model på Imagenet-datasættet på 18 minutter – og jeg vil vise noget lignende i denne artikel.

Deep learning er et stort område, så vi vil indsnævre vores fokus en smule og tage udfordringen op med at løse et billedklassifikationsprojekt. Derudover vil vi bruge en meget simpel deep learning-arkitektur til at opnå en ret imponerende nøjagtighedsscore.

Du kan betragte den Python-kode, vi vil se i denne artikel, som et benchmark for opbygning af billedklassifikationsmodeller. Når du har fået et godt greb om konceptet, kan du gå videre og lege med koden, deltage i konkurrencer og klatre op ad ranglisten!

Hvis du er ny til deep learning og er fascineret af området computer vision (hvem er ikke det?!), skal du tjekke kurset ‘Computer Vision using Deep Learning’ ud. Det er en omfattende introduktion til dette vidunderlige område og vil ruste dig til det, der uundgåeligt vil blive et enormt jobmarked i den nærmeste fremtid.

Projekt til anvendelse af billedklassifikation

Mere end 25 % af den samlede omsætning i e-handel tilskrives beklædning & tilbehør. Et stort problem, som de står over for, er at kategorisere disse beklædningsgenstande ud fra billederne alene, især når de kategorier, som mærkerne har angivet, er inkonsekvente. Dette udgør et interessant computer vision-problem, som flere forskere inden for deep learning har fået øjnene op for.

Fashion MNIST er en drop-in erstatning for det meget velkendte, maskinlæringsbaserede hello world – MNIST-datasæt, som kan tjekkes på “Identify the digits”-øvelsesproblemet. I stedet for cifre viser billederne en type beklædningsgenstand, f.eks. T-shirt, bukser, taske osv. Det datasæt, der blev anvendt i dette problem, blev oprettet af Zalando Research.

Praktik nu

Indholdsfortegnelse

1. Hvad er billedklassifikation og dens anvendelsesområder
2. Opbygning af strukturen af vores billeddata
3. Afbrydning af modelopbygningen Process
4. Opbygning af problemformuleringen og forståelse af dataene
5. Strin til opbygning af billedklassifikationsmodellen
6. Optagelse af en anden udfordring

Hvad er billedklassifikation?

Se på nedenstående billede:

Du vil straks have genkendt det – det er en (smart) bil. Tag et skridt tilbage og analysér, hvordan du kom frem til denne konklusion – du fik vist et billede, og du klassificerede den klasse, det tilhørte (en bil i dette tilfælde). Og det er i en nøddeskal det, som billedklassificering handler om.

Der er potentielt n antal kategorier, som et givet billede kan klassificeres i. Det er en meget kedelig proces at kontrollere og klassificere billeder manuelt. Opgaven bliver næsten umulig, når vi står over for et meget stort antal billeder, f.eks. 10 000 eller endog 100 000. Hvor nyttigt ville det være, hvis vi kunne automatisere hele denne proces og hurtigt kunne mærke billederne efter deres tilsvarende klasse?

Selvkørende biler er et godt eksempel til at forstå, hvor billedklassificering bruges i den virkelige verden. For at muliggøre autonom kørsel kan vi opbygge en billedklassifikationsmodel, der genkender forskellige objekter som f.eks. køretøjer, mennesker, bevægelige objekter osv. på vejen. Vi vil se et par andre anvendelsestilfælde senere i denne artikel, men der er mange flere anvendelser omkring os. Brug kommentarfeltet under artiklen til at fortælle mig, hvilke potentielle use cases du kan komme med op!

Nu har vi styr på vores emne, så lad os dykke ned i, hvordan en billedklassifikationsmodel opbygges, hvad der er forudsætningerne for den, og hvordan den kan implementeres i Python.

Opsætning af strukturen af vores billeddata

Vores data skal være i et bestemt format for at kunne løse et billedklassifikationsproblem. Vi vil se dette i praksis i et par afsnit, men hold blot disse henvisninger i tankerne, indtil vi når dertil.

Du bør have 2 mapper, en til træningssættet og den anden til testsættet. I træningssættet skal du have en .csv-fil og en billedmappe:

• Den .csv-fil indeholder navnene på alle træningsbillederne og deres tilsvarende sande etiketter
• Billedmappen indeholder alle træningsbillederne.

Den .csv-fil i vores testsæt er forskellig fra den, der er til stede i træningssættet. Denne .csv-fil i testsættene indeholder navnene på alle testbillederne, men de har ikke nogen tilsvarende etiketter. Kan du gætte hvorfor? Vores model vil blive trænet på de billeder, der er til stede i træningssættet, og labelprædiktionerne vil ske på billederne i testsættet

Hvis dine data ikke er i det format, der er beskrevet ovenfor, skal du konvertere dem i overensstemmelse hermed (ellers vil forudsigelserne være skæve og temmelig ubrugelige).

Afbrydning af processen for modelopbygning

Hvor vi dykker dybt ned i Python-koden, skal vi bruge et øjeblik på at forstå, hvordan en billedklassifikationsmodel typisk er designet. Vi kan groft sagt opdele denne proces i 4 faser. Hvert trin kræver en vis mængde tid at udføre:

1. Indlæsning og forbehandling af data – 30 % tid
2. Definering af modelarkitektur – 10 % tid
3. Træning af modellen – 50 % tid
4. Evaluering af ydeevne – 10 % tid

Lad mig forklare hvert af de ovennævnte trin lidt mere detaljeret. Dette afsnit er afgørende, fordi det ikke er alle modeller, der bliver bygget i første omgang. Du bliver nødt til at gå tilbage efter hver iteration, finjustere dine trin og køre den igen. Hvis du har en solid forståelse af de underliggende begreber, vil det være med til at fremskynde hele processen.

Stræk 1: Indlæsning og forbehandling af data

Data er guld, når det gælder deep learning-modeller. Din billedklassifikationsmodel har langt større chance for at klare sig godt, hvis du har en god mængde billeder i træningssættet. Desuden varierer dataenes form alt efter den arkitektur/ramme, vi bruger.

Deraf det kritiske dataforbehandlingsskridt (det evigt vigtige skridt i ethvert projekt). Jeg kan varmt anbefale at gennemgå ‘Basics of Image Processing in Python’ for at forstå mere om, hvordan forbehandling fungerer med billeddata.

Men vi er ikke helt i mål endnu. For at se, hvordan vores model klarer sig på usete data (og før vi udsætter den for testsæt), skal vi oprette et valideringssæt. Dette gøres ved at opdele dataene fra træningssættet.

Kort sagt træner vi modellen på træningsdataene og validerer den på valideringsdataene. Når vi er tilfredse med modellens præstation på valideringssættet, kan vi bruge den til at foretage forudsigelser på testdataene.

Tid, der kræves til dette trin: Vi har brug for ca. 2-3 minutter til denne opgave.

Trin 2: Definition af modellens arkitektur

Dette er et andet afgørende trin i vores proces til opbygning af deep learning-modeller. Vi skal definere, hvordan vores model skal se ud, og det kræver, at vi besvarer spørgsmål som:

• Hvor mange konvolutionelle lag ønsker vi?
• Hvad skal aktiveringsfunktionen for hvert lag være?
• Hvor mange skjulte enheder skal hvert lag have?

Og mange flere. Dette er i det væsentlige modellens hyperparametre, som spiller en MASSIV rolle for, hvor gode forudsigelserne bliver.

Hvordan bestemmer vi disse værdier? Udmærket spørgsmål! En god idé er at vælge disse værdier på baggrund af eksisterende forskning/undersøgelser. En anden idé er at blive ved med at eksperimentere med værdierne, indtil du finder det bedste match, men dette kan være en ret tidskrævende proces.

Tidskrævende for dette trin: Det bør tage ca. 1 minut at definere modellens arkitektur.

Trin 3: Træning af modellen

For at træne modellen har vi brug for:

• Træningsbilleder og deres tilsvarende sande etiketter
• Valideringsbilleder og deres tilsvarende sande etiketter (vi bruger kun disse etiketter til at validere modellen og ikke i træningsfasen)

Vi definerer også antallet af epokeringer i dette trin. Til at begynde med kører vi modellen i 10 epokeringer (du kan ændre antallet af epokeringer senere).

Den tid, der kræves til dette trin: Da træning kræver, at modellen lærer strukturer, har vi brug for ca. 5 minutter til at gennemgå dette trin.

Og nu er det tid til at lave forudsigelser!

Trin 4: Estimering af modellens ydeevne

Sluttelig indlæser vi testdataene (billeder) og gennemgår også her forbehandlings-trinnet. Derefter forudsiger vi klasserne for disse billeder ved hjælp af den trænede model.

Tidsforbrug til dette trin: ~ 1 minut.

Opstilling af problemformulering og forståelse af dataene

Vi skal hente en rigtig fed udfordring til at forstå billedklassifikation. Vi skal opbygge en model, der kan klassificere et givet sæt billeder i henhold til beklædning (skjorte, bukser, sko, sokker osv.). Det er faktisk et problem, som mange e-handelsforhandlere står over for, hvilket gør det til et endnu mere interessant computer vision-problem.

Denne udfordring hedder “Identify the Apparels” og er et af de øvelsesproblemer, vi har på vores DataHack-platform. Du skal registrere dig og downloade datasættet fra ovenstående link.

Vi har i alt 70.000 billeder (dimension 28 x 28), hvoraf 60.000 er fra træningssættet og 10.000 fra test-sættet. Træningsbillederne er på forhånd mærket efter beklædningstype med i alt 10 klasser. Testbillederne er naturligvis ikke mærket. Udfordringen er at identificere den tøjtype, der er til stede i alle testbillederne.

Vi vil opbygge vores model på Google Colab, da det giver en gratis GPU til at træne vores modeller.

Stræk til opbygning af vores model

Det er tid til at fyre op for dine Python-færdigheder og få hænderne beskidte. Vi er endelig nået til implementeringsdelen af vores læring!

1. Indstilling af Google Colab
2. Import af biblioteker
3. Indlæsning og forbehandling af data – (3 minutter)
4. Oprettelse af et valideringssæt
5. Definering af modellens struktur – (1 min)
6. Træning af modellen – (5 min)
7. Medførelse af forudsigelser – (1 min)

Lad os se på hvert trin i detaljer.

Strin 1: Opsætning af Google Colab

Da vi importerer vores data fra et Google Drive-link, skal vi tilføje et par linjer kode i vores Google Colab-notebook. Opret en ny Python 3-notebook, og skriv følgende kodeblokke:

!pip install PyDrive

Dette vil installere PyDrive. Nu vil vi importere et par nødvendige biblioteker:

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

Næst vil vi oprette en drevvariabel for at få adgang til Google Drive:

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

For at downloade datasættet vil vi bruge ID’et for den fil, der er uploadet på Google Drive:

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

Udskift “id” i ovenstående kode med ID’et for din fil. Nu downloader vi denne fil og udpakker den:

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

Du skal køre disse kodeblokke, hver gang du starter din notesbog.

Stræk 2 : Importer de biblioteker, vi skal bruge i vores modelopbygningsfase.

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

Stræk 3: Husk på de forbehandlingstrin, vi diskuterede tidligere. Vi bruger dem her efter indlæsning af dataene.

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

Næste trin er at læse alle træningsbillederne, gemme dem i en liste og endelig konvertere denne liste til et 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)

Da det er et klassifikationsproblem med flere klasser (10 klasser), vil vi en-hot kode målvariablen.

y=train.valuesy = to_categorical(y)

Stræk 4: Oprettelse af et valideringssæt ud fra træningsdataene.

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

Stræk 5: Definition af modellens struktur.

Vi vil oprette en simpel arkitektur med 2 konvolutionelle lag, et tæt skjult lag og et outputlag.

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æst vil vi kompilere den model, vi har oprettet.

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

Stræk 6: Træning af modellen.

I dette trin træner vi modellen på billederne fra træningssættet og validerer den ved hjælp af, du gættede det, valideringssættet.

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

Stræk 7: Forudsigelser!

Vi følger i første omgang de trin, vi udførte, da vi behandlede træningsdataene. Indlæs testbillederne, og forudsig deres klasser ved hjælp af funktionen model.predict_classes().

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

Lad os importere testfilen:

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

Nu vil vi læse og gemme alle testbillederne:

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 vil også oprette en indsendelsesfil til upload på DataHack-platformens side (for at se, hvordan vores resultater klarer sig på leaderboardet).

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 denne sample_cnn.csv-fil og upload den på konkurrencesiden for at generere dine resultater og tjekke din placering på leaderboardet. Dette vil give dig en benchmark-løsning, så du kan komme i gang med ethvert billedklassifikationsproblem!

Du kan prøve hyperparameterafstemning og reguleringsteknikker for at forbedre din models ydeevne yderligere. Jeg opfordrer dig til at tjekke denne artikel for at forstå dette finjusteringstrin meget mere detaljeret – ‘A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch’.

Picking up a Different Challenge

Lad os teste vores læring på et andet datasæt. Vi skal knække øvelsesopgaven “Identificer cifrene” i dette afsnit. Gå videre og download datasættet. Før du går videre, skal du prøve at løse det på egen hånd. Du har allerede værktøjerne til at løse det – du skal bare anvende dem! Kom tilbage her for at tjekke dine resultater, eller hvis du går i stå på et tidspunkt.

I denne udfordring skal vi identificere cifret i et givet billede. Vi har i alt 70.000 billeder – 49.000 mærkede billeder i træningssættet og de resterende 21.000 billeder i testsættet (testbillederne er umærkede). Vi skal identificere/forudsige klassen for disse umærkede billeder.

Er du klar til at begynde? Fantastisk! Opret en ny Python 3-notebook, og kør følgende kode:

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

Send denne fil på siden med øvelsesproblemer for at få et ret fornuftigt nøjagtighedstal. Det er en god start, men der er altid plads til forbedringer. Bliv ved med at lege med hyperparameterværdierne, og se, om du kan forbedre vores grundmodel.

Slutnoter

Hvem sagde, at deep learning-modeller kræver timer eller dage at træne. Mit mål her var at vise, at man kan lave en ret anstændig deep learning-model på dobbelt så hurtig tid. Du bør samle lignende udfordringer op og forsøge at kode dem fra din ende også. Der er intet bedre end at lære ved at gøre!

De bedste datavidenskabsfolk og analytikere har disse koder klar, før et Hackathon overhovedet begynder. De bruger disse koder til at lave tidlige indsendelser, inden de dykker ned i en detaljeret analyse. Når de har en benchmark-løsning, begynder de at forbedre deres model ved hjælp af forskellige teknikker.