Alai

Úvod

„Sestavte model hlubokého učení za pár minut? Trénování zabere hodiny! Vždyť ani nemám dostatečně dobrý stroj.“ Tohle jsem slyšel nesčetněkrát od začínajících datových vědců, kteří se vyhýbají sestavování modelů hlubokého učení na vlastních strojích.

Nemusíte pracovat pro Google nebo jiné velké technologické firmy, abyste mohli pracovat na datových sadách hlubokého učení! Je zcela možné vytvořit vlastní neuronovou síť od základu během několika minut, aniž byste si museli pronajímat servery společnosti Google. Studenti společnosti Fast.ai navrhli model na datové sadě Imagenet za 18 minut – a něco podobného předvedu i v tomto článku.

Hluboké učení je rozsáhlý obor, takže si trochu zúžíme záběr a pustíme se do řešení projektu Klasifikace obrázků. Navíc budeme používat velmi jednoduchou architekturu hlubokého učení, abychom dosáhli poměrně působivého skóre přesnosti.

Kód v jazyce Python, který uvidíme v tomto článku, můžete považovat za měřítko pro vytváření modelů Klasifikace obrázků. Jakmile tento koncept dobře pochopíte, pusťte se do hraní s kódem, účastněte se soutěží a stoupejte v žebříčku!“

Pokud s hlubokým učením začínáte a fascinuje vás oblast počítačového vidění (koho ne?!), podívejte se na kurz „Computer Vision using Deep Learning“. Je to komplexní úvod do tohoto úžasného oboru a připraví vás na to, co v blízké budoucnosti nevyhnutelně čeká obrovský trh práce.

Projekt pro aplikaci klasifikace obrazu

Více než 25 % všech příjmů v e-komerci připadá na oděvní & doplňky. Hlavním problémem, se kterým se potýkají, je kategorizace těchto oděvů pouze z obrázků, zejména když kategorie poskytované značkami nejsou konzistentní. To představuje zajímavý problém počítačového vidění, který upoutal pozornost několika výzkumníků zabývajících se hlubokým učením.

Fashion MNIST je kapkovitou náhradou za velmi dobře známý, strojově učící se hello world – MNIST dataset, který si můžete vyzkoušet na cvičné úloze ‚Identify the digits‘. Místo číslic je na obrázcích zobrazen typ oblečení, např. tričko, kalhoty, taška atd. Datovou sadu použitou v tomto problému vytvořila společnost Zalando Research.

Practice Now

Tabulka obsahu

1. Co je to klasifikace obrázků a případy jejího použití
2. Nastavení struktury našich obrazových dat
3. Rozdělení tvorby modelu. Proces
4. Nastavení zadání problému a pochopení dat
5. Kroky k sestavení modelu klasifikace obrazu
6. Přijetí další výzvy

Co je klasifikace obrazu?

Podívejte se na následující obrázek:

Jistě jste ho okamžitě poznali – je to (švihácké) auto. Udělejte krok zpět a analyzujte, jak jste k tomuto závěru dospěli – byl vám ukázán obrázek a vy jste zařadili třídu, do které patří (v tomto případě auto). A o tom je ve zkratce klasifikace obrázků.

Potenciálně existuje n kategorií, do kterých lze daný obrázek zařadit. Ruční kontrola a klasifikace obrázků je velmi zdlouhavý proces. Tento úkol se stává téměř nemožným, když se setkáme s obrovským počtem obrázků, řekněme 10 000 nebo dokonce 100 000 obrázků. Jak užitečné by bylo, kdybychom mohli celý tento proces automatizovat a rychle označit obrázky podle příslušné třídy?“

Samostatně řízená auta jsou skvělým příkladem pro pochopení toho, kde se klasifikace obrázků v reálném světě používá. Abychom umožnili autonomní řízení, můžeme vytvořit model klasifikace obrazu, který rozpozná různé objekty, jako jsou vozidla, lidé, pohybující se objekty atd. na silnici. Později v tomto článku si ukážeme několik dalších případů použití, ale kolem nás je spousta dalších aplikací. Využijte sekci komentářů pod článkem a dejte mi vědět, jaké potenciální případy použití vás napadnou!“

Teď, když jsme se seznámili s naším tématem, se vrhneme na to, jak se model klasifikace obrazu vytváří, jaké jsou jeho předpoklady a jak jej lze implementovat v jazyce Python.

Nastavení struktury našich obrazových dat

Naše data musí být v určitém formátu, abychom mohli řešit problém klasifikace obrazu. Uvidíme to v akci v několika částech, ale než se k tomu dostaneme, mějte na paměti tyto pokyny.

Měli byste mít 2 složky, jednu pro trénovací množinu a druhou pro testovací množinu. V tréninkové sadě budete mít soubor .csv a složku s obrázky:

• Soubor .csv obsahuje názvy všech tréninkových obrázků a jim odpovídající pravdivé značky
• Složka s obrázky obsahuje všechny tréninkové obrázky.

Soubor .csv v naší testovací sadě se liší od souboru přítomného v tréninkové sadě. Tento soubor .csv testovací sady obsahuje názvy všech testovacích obrázků, ale nemají žádné odpovídající popisky. Dokážete odhadnout proč? Náš model bude vycvičen na obrázcích přítomných v trénovací sadě a předpovědi štítků budou probíhat na obrázcích z testovací sady

Pokud vaše data nejsou ve výše popsaném formátu, budete je muset odpovídajícím způsobem převést (jinak budou předpovědi chybné a poměrně nepoužitelné).

Představení procesu tvorby modelu

Než se ponoříme do kódu Pythonu, věnujme chvíli pochopení toho, jak se obvykle navrhuje model klasifikace obrázků. Tento proces můžeme rámcově rozdělit do 4 fází. Každá etapa vyžaduje určitý čas k provedení:

1. Načítání a předběžné zpracování dat – 30 % času
2. Definování architektury modelu – 10 % času
3. Trénování modelu – 50 % času
4. Odhad výkonu – 10 % času

Dovolte mi vysvětlit každý z výše uvedených kroků trochu podrobněji. Tato část je klíčová, protože ne každý model je sestaven na první pokus. Po každé iteraci se budete muset vrátit, doladit kroky a znovu jej spustit. Důkladné pochopení základních konceptů vám pomůže celý proces urychlit.

Fáze 1: Zpracování modelu: Načtení a předběžné zpracování dat

Data jsou zlato, pokud jde o modely hlubokého učení. Váš model klasifikace obrázků má mnohem větší šanci na dobrý výkon, pokud máte v trénovací sadě dostatečné množství obrázků. Také tvar dat se liší v závislosti na architektuře/frameworku, který používáme.

Tedy kritický krok předzpracování dat (věčně důležitý krok v každém projektu). Vřele doporučuji projít si knihu „Základy zpracování obrazu v Pythonu“, abyste pochopili více o tom, jak funguje předzpracování obrazových dat.

Ale ještě nejsme úplně u konce. Abychom zjistili, jak si náš model vede na nezobrazených datech (a než jej vystavíme testovací množině), musíme vytvořit validační množinu. To provedeme rozdělením dat trénovací množiny.

Krátce řečeno, model natrénujeme na trénovacích datech a ověříme ho na validačních datech. Jakmile jsme spokojeni s výkonem modelu na validační množině, můžeme jej použít pro vytváření předpovědí na testovacích datech.

Čas potřebný pro tento krok:

Fáze 2: Definování architektury modelu

Jedná se o další klíčový krok v našem procesu tvorby modelu hlubokého učení. Musíme definovat, jak bude náš model vypadat, a to vyžaduje zodpovězení otázek typu:

• Kolik konvolučních vrstev chceme?
• Jaká by měla být aktivační funkce pro každou vrstvu?
• Kolik skrytých jednotek by měla mít každá vrstva?

A mnoho dalších. To jsou v podstatě hyperparametry modelu, které hrají MASIVNÍ roli při rozhodování o tom, jak dobré budou předpovědi.

Jak o těchto hodnotách rozhodujeme? Výborná otázka! Dobrý nápad je vybrat tyto hodnoty na základě existujících výzkumů/studií. Dalším nápadem je experimentovat s hodnotami, dokud nenajdete tu nejlepší, ale to může být poměrně časově náročný proces.

Čas potřebný pro tento krok:

Fáze 3: Trénování modelu

Pro trénování modelu potřebujeme:

• Tréninkové obrázky a jim odpovídající pravdivé značky
• Validační obrázky a jim odpovídající pravdivé značky (tyto značky používáme pouze pro validaci modelu, nikoliv během fáze trénování)

V tomto kroku také definujeme počet epoch. Pro začátek budeme model spouštět po dobu 10 epoch (počet epoch můžete později změnit).

Čas potřebný pro tento krok:

A nyní je čas na předpovědi!

Fáze 4: Odhad výkonu modelu

Nakonec načteme testovací data (obrázky) a i zde projdeme krokem předběžného zpracování. Poté pro tyto obrázky předpovíme třídy pomocí natrénovaného modelu.

Čas potřebný pro tento krok: ~ 1 minuta.

Nastavení zadání problému a pochopení dat

Budeme vybírat opravdu skvělý úkol, abychom pochopili klasifikaci obrázků. Musíme vytvořit model, který dokáže klasifikovat danou sadu obrázků podle oblečení (košile, kalhoty, boty, ponožky atd.). Je to vlastně problém, se kterým se potýká mnoho prodejců e-shopů, což z něj dělá ještě zajímavější problém počítačového vidění.

Tato výzva se jmenuje „Identify the Apparels“ a je jedním z cvičných problémů, které máme na naší platformě DataHack. Musíte se zaregistrovat a stáhnout datovou sadu z výše uvedeného odkazu.

Máme celkem 70 000 obrázků (rozměr 28 x 28), z nichž 60 000 je z trénovací sady a 10 000 z testovací. Tréninkové obrázky jsou předem označeny podle typu oděvu s celkem 10 třídami. Testovací obrázky samozřejmě nejsou označeny. Úkolem je identifikovat typ oděvu přítomný na všech testovacích obrázcích.

Náš model vytvoříme na platformě Google Colab, protože poskytuje bezplatný grafický procesor pro trénování našich modelů.

Kroky k sestavení našeho modelu

Nastal čas nahodit své znalosti jazyka Python a zašpinit si ruce. Konečně jsme u implementační části našeho učení!

1. Nastavení Google Colab
2. Import knihoven
3. Načítání a předběžné zpracování dat – (3 minuty)
4. Vytvoření validační sady

.

5. Definování struktury modelu – (1 min)
6. Trénování modelu – (5 min)
7. Tvorba předpovědí – (1 min)

Podívejme se na jednotlivé kroky podrobněji.

Krok 1: Nastavení Google Colab

Protože importujeme naše data z odkazu na Disk Google, budeme muset do našeho zápisníku Google Colab přidat několik řádků kódu. Vytvořte nový zápisník Python 3 a napište následující bloky kódu:

!pip install PyDrive

Tímto nainstalujete PyDrive. Nyní naimportujeme několik potřebných knihoven:

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

Dále vytvoříme proměnnou drive pro přístup k Disku Google:

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

Pro stažení datové sady použijeme ID souboru nahraného na Disk Google:

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

Nahradíme ‚id‘ ve výše uvedeném kódu ID vašeho souboru. Nyní tento soubor stáhneme a rozbalíme:

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

Tyto bloky kódu musíte spustit při každém spuštění notebooku.

Krok 2 : Import knihoven, které budeme potřebovat ve fázi sestavování modelu.

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

Krok 3: Připomeňte si kroky před zpracováním, které jsme probrali dříve. Budeme je zde používat po načtení dat.

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

Dále načteme všechny trénovací obrázky, uložíme je do seznamu a nakonec tento seznam převedeme na pole 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)

Jelikož se jedná o klasifikační problém více tříd (10 tříd), budeme cílovou proměnnou jednorázově kódovat.

y=train.valuesy = to_categorical(y)

Krok 4: Vytvoření validační množiny z trénovacích dat.

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

Krok 5: Definování struktury modelu.

Vytvoříme jednoduchou architekturu se dvěma konvolučními vrstvami, jednou hustou skrytou vrstvou a výstupní vrstvou.

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ásledující krok je sestavení vytvořeného modelu.

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

Krok 6: Trénování modelu.

V tomto kroku model natrénujeme na obrázcích tréninkové sady a ověříme jej pomocí, hádáte správně, validační sady.

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

Krok 7: Vytváření předpovědí!

Na začátku budeme postupovat podle kroků, které jsme provedli při práci s tréninkovými daty. Načteme testovací obrázky a předpovíme jejich třídy pomocí funkce model.predict_classes().

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

Importujeme testovací soubor:

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

Nyní načteme a uložíme všechny testovací obrázky:

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)

Vytvoříme také odesílací soubor, který nahrajeme na stránku platformy DataHack (abychom viděli, jak si naše výsledky stojí v žebříčku).

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)

Stáhněte si tento ukázkový soubor_cnn.csv a nahrajte ho na stránku soutěže, abyste vygenerovali své výsledky a zkontrolovali své umístění v žebříčku. Získáte tak srovnávací řešení, které vám pomůže začít řešit jakýkoli problém klasifikace obrázků!“

Můžete vyzkoušet techniky ladění hyperparametrů a regularizace, abyste dále zlepšili výkonnost svého modelu. Doporučuji vám, abyste si přečetli tento článek, ve kterém tomuto kroku ladění porozumíte mnohem podrobněji – „Komplexní výukový program pro učení konvolučních neuronových sítí od nuly“.

Podíváme se na jinou výzvu

Vyzkoušejme naše učení na jiné datové sadě. V této části budeme luštit cvičný problém „Identifikace číslic“. Pokračujte a stáhněte si datovou sadu. Než budete pokračovat dále, zkuste ji vyřešit sami. Nástroje k jeho řešení již máte – stačí je jen použít! Vraťte se sem, abyste zkontrolovali své výsledky nebo pokud se v některém bodě zaseknete.

V této úloze musíme určit číslici na daném obrázku. Máme celkem 70 000 obrázků – 49 000 označených v trénovací sadě a zbývajících 21 000 v testovací sadě (testovací obrázky jsou neoznačené). Potřebujeme určit/předpovědět třídu těchto neoznačených obrázků.

Připraveni začít? Úžasné! Vytvořte nový sešit Python 3 a spusťte následující kód:

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

Odesláním tohoto souboru na stránce s cvičnými úlohami získáte docela slušné číslo přesnosti. Je to dobrý začátek, ale vždy je co zlepšovat. Hrajte si dál s hodnotami hyperparametrů a zjistěte, zda můžete náš základní model vylepšit.

Koncové poznámky

Kdo řekl, že modely hlubokého učení vyžadují hodiny nebo dny tréninku. Mým cílem zde bylo ukázat, že lze vymyslet docela slušný model hlubokého učení za dvojnásobně krátkou dobu. Měli byste si podobné výzvy vytipovat a zkusit je nakódovat i ze své strany. Není nad to učit se praxí!“

Špičkoví datoví vědci a analytici mají tyto kódy připravené ještě před začátkem hackathonu. Pomocí těchto kódů vytvářejí předběžné příspěvky, než se ponoří do podrobné analýzy. Jakmile mají srovnávací řešení, začnou svůj model vylepšovat pomocí různých technik.