Alai

Bevezetés

“Építs mély tanulási modellt néhány perc alatt? Órákba telik a betanítása! Még egy elég jó gépem sincs.” Számtalanszor hallottam már ezt olyan feltörekvő adattudósoktól, akik ódzkodnak attól, hogy mélytanulási modelleket építsenek a saját gépükön.

Nem kell a Google-nek vagy más nagy technológiai cégeknek dolgoznod ahhoz, hogy mélytanulási adathalmazokon dolgozhass! Teljesen lehetséges saját neurális hálózatot építeni az alapoktól kezdve néhány perc alatt anélkül, hogy a Google szervereit kellene bérelned. A Fast.ai diákjai 18 perc alatt terveztek modellt az Imagenet adatkészletre – és valami hasonlót fogok bemutatni ebben a cikkben.

A mélytanulás egy hatalmas terület, ezért kicsit leszűkítjük a fókuszt, és egy képosztályozási feladat megoldásának kihívását vesszük célba. Ráadásul egy nagyon egyszerű mélytanulási architektúrát fogunk használni, amivel elég lenyűgöző pontossági eredményt érünk el.

A Python kódot, amit ebben a cikkben látni fogunk, tekinthetjük a Képosztályozási modellek építésének viszonyítási alapjának. Ha már jól érted a koncepciót, menj előre, és játssz a kóddal, vegyél részt versenyeken, és mássz feljebb a ranglistán!

Ha új vagy a mélytanulásban, és lenyűgöz a számítógépes látás területe (ki nem?!), nézd meg a ‘Computer Vision using Deep Learning’ kurzust. Ez egy átfogó bevezetés ebbe a csodálatos területbe, és felkészít a közeljövőben elkerülhetetlenül hatalmas munkaerőpiacra.

Projekt a képosztályozás alkalmazására

A teljes bevétel több mint 25%-a az e-kereskedelemben a ruházati & kiegészítőknek tulajdonítható. Nagy problémát jelent számukra ezeknek a ruházati cikkeknek a kategorizálása pusztán a képek alapján, különösen akkor, ha a márkák által megadott kategóriák nem következetesek. Ez egy érdekes számítógépes látás problémát vet fel, amely több mélytanulással foglalkozó kutató figyelmét is felkeltette.

A Fashion MNIST egy drop-in helyettesítője a nagyon jól ismert, gépi tanulás hello world – MNIST adatkészletnek, amelyet a ‘Identify the digits’ gyakorló feladatnál lehet ellenőrizni. A képek a számjegyek helyett egyfajta ruházatot mutatnak, pl. póló, nadrág, táska stb. A feladatban használt adathalmazt a Zalando Research hozta létre.

gyakorlat most

Tartalomjegyzék

1. Mi a képosztályozás és felhasználási területei
2. Képadataink szerkezetének felállítása
3. A modellépítés lebontása. Folyamat
4. A problémafelvetés felállítása és az adatok megértése
5. Lépések a képosztályozási modell építéséhez
6. Egy újabb kihívás felvétele

Mi a képosztályozás?

Nézzük meg az alábbi képet:

Az alábbi képet azonnal felismerte – ez egy (flancos) autó. Lépj egy lépést hátra, és elemezd, hogyan jutottál erre a következtetésre – mutattak neked egy képet, és osztályoztad, hogy melyik osztályba tartozik (jelen esetben egy autó). Dióhéjban erről szól a képosztályozás.

Potenciálisan n számú kategória létezik, amelybe egy adott kép besorolható. A képek kézi ellenőrzése és osztályozása nagyon fárasztó folyamat. A feladat szinte lehetetlenné válik, ha hatalmas számú, mondjuk 10 000 vagy akár 100 000 képpel állunk szemben. Milyen hasznos lenne, ha ezt az egész folyamatot automatizálni tudnánk, és gyorsan fel tudnánk címkézni a képeket a megfelelő osztály szerint?

Az önvezető autók remek példa arra, hogy megértsük, hol használják a képosztályozást a való világban. Az autonóm vezetés lehetővé tételéhez olyan képosztályozó modellt építhetünk, amely felismeri a különböző objektumokat, például járműveket, embereket, mozgó tárgyakat stb. az úton. A cikk későbbi részében még néhány további felhasználási esetet fogunk látni, de rengeteg további alkalmazás van körülöttünk. Használd a cikk alatti megjegyzés rovatot, hogy tudasd velem, milyen lehetséges felhasználási esetekkel tudsz előállni!

Most, hogy már tisztában vagyunk a témánkkal, merüljünk el abban, hogyan épül fel egy képosztályozó modell, mik az előfeltételei, és hogyan lehet megvalósítani Pythonban.

Képadataink struktúrájának beállítása

Adatainknak egy bizonyos formátumban kell lenniük ahhoz, hogy egy képosztályozási problémát megoldjunk. Ezt néhány szakaszon belül látni fogjuk a gyakorlatban, de addig is tartsuk szem előtt ezeket a mutatókat.

Két mappának kell lennie, az egyik a gyakorlóhalmaznak, a másik a teszthalmaznak. A tréningkészletben lesz egy .csv fájl és egy képmappa:

• A .csv fájl tartalmazza az összes tréningkép nevét és a hozzájuk tartozó valódi címkéket
• A képmappa tartalmazza az összes tréningképet.

A tesztkészletünkben lévő .csv fájl különbözik a tréningkészletben lévőtől. Ez a tesztkészlet .csv fájl tartalmazza az összes tesztkép nevét, de nincs hozzájuk tartozó címke. Ki tudja találni, hogy miért? A modellünket a gyakorlóhalmazban található képeken fogjuk betanítani, a címkejóslás pedig a tesztkészlet képein fog megtörténni

Ha az adataink nem a fent leírt formátumban vannak, akkor ennek megfelelően kell konvertálnunk őket (különben a jóslatok félresiklanak és meglehetősen használhatatlanok lesznek).

A modellépítés folyamatának lebontása

Mielőtt elmélyednénk a Python-kódban, szánjunk egy percet arra, hogy megértsük, hogyan épül fel jellemzően egy képosztályozó modell. Ezt a folyamatot nagyjából 4 szakaszra oszthatjuk. Mindegyik szakasz végrehajtásához bizonyos mennyiségű időre van szükség:

1. Adatok betöltése és előfeldolgozása – 30% idő
2. Modell architektúra meghatározása – 10% idő
3. Modell betanítása – 50% idő
4. Teljesítménybecslés – 10% idő

Hadd magyarázzam el egy kicsit részletesebben az egyes fenti lépéseket. Ez a rész azért kulcsfontosságú, mert nem minden modell épül fel elsőre. Minden egyes iteráció után vissza kell mennie, finomhangolnia kell a lépéseket, és újra le kell futtatnia. A mögöttes fogalmak alapos ismerete nagyban felgyorsítja az egész folyamatot.

1. szakasz: Az adatok betöltése és előfeldolgozása

A mélytanulási modellek szempontjából az adat aranyat ér. A képosztályozó modellje sokkal nagyobb eséllyel teljesít jól, ha jó mennyiségű kép van a gyakorlóhalmazban. Emellett az adatok alakja az általunk használt architektúrától/keretrendszertől függően változik.

Az adatok kritikus előfeldolgozási lépése (az örökké fontos lépés minden projektben). Nagyon ajánlom, hogy nézze át a ‘A képfeldolgozás alapjai Pythonban’ című könyvet, hogy jobban megértse, hogyan működik az előfeldolgozás a képi adatokkal.

De még nem tartunk itt. Ahhoz, hogy lássuk, hogyan teljesít a modellünk a nem látott adatokon (és mielőtt kitennénk a tesztkészletnek), létre kell hoznunk egy validációs készletet. Ez a gyakorlóhalmaz adatainak particionálásával történik.

Röviden, a modellt a gyakorlóadatokon képezzük ki, és a validációs adatokon validáljuk. Miután elégedettek vagyunk a modell teljesítményével a validációs halmazon, használhatjuk azt a tesztadatokon történő előrejelzések készítéséhez.

Az ehhez a lépéshez szükséges idő:

2. szakasz: A modell architektúrájának meghatározása

Ez egy másik fontos lépés a mélytanulási modellépítési folyamatunkban. Meg kell határoznunk, hogyan fog kinézni a modellünk, és ehhez olyan kérdésekre kell válaszolnunk, mint:

• Hány konvolúciós réteget szeretnénk?
• Milyen legyen az egyes rétegek aktiválási függvénye?
• Hány rejtett egységgel rendelkezzenek az egyes rétegek?

És még sok más. Ezek lényegében a modell hiperparaméterei, amelyek NAGY szerepet játszanak abban, hogy milyen jó lesz a jóslat.

Hogyan döntjük el ezeket az értékeket? Kitűnő kérdés! Jó ötlet, ha ezeket az értékeket a meglévő kutatások/tanulmányok alapján választjuk ki. Egy másik ötlet, hogy addig kísérletezünk az értékekkel, amíg meg nem találjuk a legjobbat, de ez elég időigényes folyamat lehet.

Az ehhez a lépéshez szükséges idő:

3. lépés: A modell képzése

A modell képzéséhez a következőkre van szükségünk:

• Tréning képek és a hozzájuk tartozó valódi címkék
• Hitelesítési képek és a hozzájuk tartozó valódi címkék (ezeket a címkéket csak a modell validálásához használjuk, a képzési fázisban nem)

Ebben a lépésben meghatározzuk az epochák számát is. Kezdetben 10 epochán keresztül futtatjuk a modellt (később módosíthatjuk az epochák számát).

A lépéshez szükséges idő: Mivel a képzéshez a modellnek struktúrákat kell tanulnia, körülbelül 5 percre van szükségünk ehhez a lépéshez.

És most ideje előrejelzéseket készíteni!

4. lépés: A modell teljesítményének becslése

Végül betöltjük a tesztadatokat (képeket), és itt is elvégezzük az előfeldolgozási lépést. Ezután a betanított modell segítségével megjósoljuk ezeknek a képeknek az osztályait.

Az ehhez a lépéshez szükséges idő: ~ 1 perc.

A problémafelvetés felállítása és az adatok megértése

Egy igazán klassz feladatot veszünk fel a képosztályozás megértéséhez. Olyan modellt kell építenünk, amely képes egy adott képhalmazt a ruházat (ing, nadrág, cipő, zokni stb.) szerint osztályozni. Ez tulajdonképpen egy olyan probléma, amellyel sok e-kereskedelmi kiskereskedő szembesül, ami még érdekesebbé teszi a számítógépes látás problémáját.

Ez a kihívás a ‘Ruházat azonosítása’ nevet viseli, és egyike a DataHack platformon található gyakorló problémáinknak. Regisztrálni kell, és le kell tölteni az adathalmazt a fenti linkről.

Ez összesen 70.000 kép (28 x 28 dimenzió), amelyből 60.000 a gyakorlóhalmazból és 10.000 a teszthalmazból származik. A gyakorló képeket előre címkézzük a ruházati típus szerint, összesen 10 osztállyal. A tesztképek természetesen nincsenek címkézve. A kihívás az, hogy azonosítsuk az összes tesztképen szereplő ruházati típust.

Modellünket a Google Colab-on fogjuk felépíteni, mivel ingyenes GPU-t biztosít a modellünk edzéséhez.

Lépések a modellünk felépítéséhez

Ideje beizzítani a Python-képességeinket és bepiszkolni a kezünket. Végre elérkeztünk a tanulásunk implementációs részéhez!

1. A Google Colab beállítása
2. Könyvtárak importálása
3. Adatok betöltése és előfeldolgozása – (3 perc)
4. Hitelesítési halmaz létrehozása

.

5. A modell struktúrájának meghatározása – (1 perc)
6. A modell képzése – (5 perc)
7. Jóslatok készítése – (1 perc)

Nézzük meg az egyes lépéseket részletesen.

1. lépés: A Google Colab beállítása

Mivel az adatainkat egy Google Drive linkről importáljuk, szükségünk lesz néhány sor kódra a Google Colab jegyzetfüzetünkben. Hozzunk létre egy új Python 3 notebookot, és írjuk meg a következő kódblokkokat:

!pip install PyDrive

Ezzel telepítjük a PyDrive-ot. Most importálunk néhány szükséges könyvtárat:

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

A következőkben létrehozunk egy drive változót a Google Drive eléréséhez:

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

Az adatkészlet letöltéséhez a Google Drive-ra feltöltött fájl azonosítóját fogjuk használni:

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

A fenti kódban az ‘id’-t a fájl azonosítójával helyettesítjük. Most töltsük le ezt a fájlt, és csomagoljuk ki:

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

Ezeket a kódblokkokat minden alkalommal le kell futtatnunk, amikor elindítjuk a notebookot.

2. lépés : Importáljuk a könyvtárakat, amelyekre a modellépítési fázisban szükségünk lesz.

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

3. lépés: Idézzük fel a korábban tárgyalt előfeldolgozási lépéseket. Ezeket itt fogjuk használni az adatok betöltése után.

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

A következő lépésben beolvassuk az összes gyakorló képet, egy listában tároljuk őket, és végül ezt a listát numpy tömbtá alakítjuk.

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

Mivel egy többosztályos osztályozási problémáról van szó (10 osztály), ezért a célváltozót egy-hot kódoljuk.

y=train.valuesy = to_categorical(y)

4. lépés: Validációs halmaz létrehozása a képzési adatokból.

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

5. lépés: A modell struktúrájának meghatározása.

Elkészítünk egy egyszerű architektúrát 2 konvolúciós réteggel, egy sűrű rejtett réteggel és egy kimeneti réteggel.

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

A következőkben összeállítjuk az általunk létrehozott modellt.

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

6. lépés: A modell edzése.

Ezzel a lépéssel betanítjuk a modellt a képzési készlet képein, és validáljuk azt, kitaláltad, a validációs készlet segítségével.

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

7. lépés: Előrejelzések készítése!

Először is követjük azokat a lépéseket, amelyeket a képzési adatok kezelésénél végeztünk. Betöltjük a tesztképeket, és a model.predict_classes() függvény segítségével megjósoljuk az osztályaikat.

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

Importáljuk a tesztfájlt:

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

Most beolvassuk és tároljuk az összes tesztképet:

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)

Elkészítünk egy beküldési fájlt is, amelyet feltöltünk a DataHack platform oldalára (hogy megnézzük, hogyan szerepelnek az eredményeink a ranglistán).

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)

Töltse le ezt a sample_cnn.csv fájlt, és töltse fel a verseny oldalára, hogy létrehozza az eredményeit, és ellenőrizze a helyezését a ranglistán. Ez egy összehasonlító megoldást ad, amellyel bármilyen képosztályozási problémához hozzákezdhet!

A modell teljesítményének további javításához kipróbálhatja a hiperparaméterek hangolását és a regularizációs technikákat. Javaslom, hogy olvassa el ezt a cikket, hogy sokkal részletesebben megértse ezt a finomhangolási lépést – “A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch”.

Picking up a Different Challenge

Teszteljük a tanulásunkat egy másik adathalmazon. Ebben a részben a ‘Számjegyek azonosítása’ gyakorlati feladatot fogjuk megfejteni. Menjünk előre, és töltsük le az adathalmazt. Mielőtt továbbmennél, próbáld meg egyedül megoldani. A megoldásához már megvannak az eszközei – csak alkalmaznia kell őket! Gyere vissza ide, ha ellenőrizni szeretnéd az eredményeidet, vagy ha valamikor elakadnál.

Ebben a feladatban egy adott képen lévő számjegyet kell azonosítanunk. Összesen 70 000 képünk van – 49 000 címkézett kép a gyakorlóhalmazban és a maradék 21 000 a teszthalmazban (a tesztképek címkézetlenek). Ezeknek a címkézetlen képeknek az osztályát kell azonosítanunk/megjósolnunk.

Készen állsz a kezdésre? Félelmetes! Hozzon létre egy új Python 3 notebookot, és futtassa a következő kódot:

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

Futtassa ezt a fájlt a gyakorlati feladat oldalon, hogy elég tisztességes pontossági számot kapjon. Ez egy jó kezdet, de mindig van lehetőség a javításra. Játsszon tovább a hiperparaméter-értékekkel, és nézze meg, hogy tud-e javítani az alapmodellünkön.

Végjegyzetek

Ki mondta, hogy a mély tanulási modellek betanításához órákra vagy napokra van szükség? A célom itt az volt, hogy bemutassam, hogy egy elég tisztességes mélytanulási modellt kétszer gyorsabb idő alatt is ki lehet hozni. Vedd fel a hasonló kihívásokat, és próbáld meg a te részedről is kódolni őket. Semmi sem jobb, mint csinálva tanulni!

A legjobb adattudósok és elemzők már azelőtt készen vannak ezekkel a kódokkal, hogy egy Hackathon egyáltalán elkezdődne. Ezeket a kódokat arra használják, hogy korai beadványokat készítsenek, mielőtt belevetnék magukat a részletes elemzésbe. Ha már van egy benchmark megoldásuk, akkor különböző technikák segítségével elkezdik javítani a modelljüket.