Kuinka luoda yksinkertainen kuvaluokitus

Kuvaluokitus on hämmästyttävä syvän oppimisen sovellus. Voimme kouluttaa tehokkaan algoritmin suuren kuvajoukon mallintamiseen. Tätä mallia voidaan sitten käyttää luokittelemaan samanlainen mutta tuntematon kuvajoukko.

Kuvaluokituksen sovelluksille ei ole rajoituksia. Voit käyttää sitä seuraavassa sovelluksessasi tai voit käyttää sitä reaalimaailman ongelman ratkaisemiseen. Kaikki riippuu sinusta. Mutta jollekin, joka on melko uusi tälle alueelle, se saattaa tuntua aluksi erittäin haastavalta. Kuinka minun pitäisi saada tietoni? Kuinka minun pitäisi rakentaa malli? Mitä työkaluja minun pitäisi käyttää?

Tässä artikkelissa keskustelemme kaikesta siitä - tietojoukon löytämisestä mallisi kouluttamiseen. Yritän tehdä asioista mahdollisimman yksinkertaisia ​​välttämällä joitain teknisiä yksityiskohtia ( PS: Huomaa, että tämä ei tarkoita, että nämä yksityiskohdat eivät ole tärkeitä. Mainitsen hienoja resursseja, joihin voit viitata saadaksesi lisätietoja näistä aiheista ). Tämän artikkelin tarkoituksena on selittää kuvaluokittelijan rakentamisen perusprosessi, johon keskitymme enemmän täällä.

Rakennamme kuvaluokituksen Fashion-MNIST-tietojoukolle. Fashion-MNIST-tietojoukko on kokoelma Zalandon artikkelikuvia. Se sisältää 60000 kuvaa harjoitusjoukolle ja 10000 kuvaa testijoukon tiedoille ( keskustelemme testi- ja harjoittelutiedoista yhdessä validointiaineiston kanssa myöhemmin ). Nämä kuvat kuuluvat 10 eri luokan tarroihin.

Kirjastojen tuominen

Tavoitteenamme on kouluttaa syvä oppimismalli, joka voi luokitella tietyn kuvajoukon johonkin näistä 10 luokasta. Nyt kun meillä on tietojoukko, meidän pitäisi siirtyä tarvitsemiemme työkalujen pariin. Siellä on monia kirjastoja ja työkaluja, jotka voit valita omien projektivaatimiesi perusteella. Tätä varten pidän kiinni seuraavasta:

  1. Numpy - Python-kirjasto numeerista laskentaa varten
  2. Pandas - Python-kirjaston tietojen käsittely
  3. Matplotlib - Python-kirjaston tietojen visualisointi
  4. Keras - tensorflow- pohjainen Python-kirjasto syvien oppimismallien luomiseen
  5. Jupyter - Suoritan kaiken koodini Jupyter Notebooksissa. Voit asentaa sen linkin kautta. Voit käyttää Google Colabsia myös, jos tarvitset parempaa laskentatehoa.

Näiden neljän lisäksi käytämme myös scikit-learn-ohjelmaa. Näiden kirjastojen tarkoitus tulee selvemmäksi, kun sukellamme koodiin.

Okei! Meillä on työkalut ja kirjastot valmiina. Nyt meidän pitäisi aloittaa koodin asettaminen.

Aloita kaikkien yllä mainittujen kirjastojen tuomisesta. Kirjastojen tuomisen ohella olen myös tuonut joitain erityisiä moduuleja näistä kirjastoista. Anna minun käydä ne läpi yksi kerrallaan.

import numpy as np import pandas as pd import matplotlib.pyplot as plt import keras from sklearn.model_selection import train_test_split from keras.utils import to_categorical from keras.models import Sequential from keras.layers import Conv2D, MaxPooling2D from keras.layers import Dense, Dropout from keras.layers import Flatten, BatchNormalization

train_test_split: Tämä moduuli jakaa harjoitustietojoukon koulutus- ja validointitietoihin. Tämän jaon takana on tarkistaa, onko malli ylisuuri vai ei. Käytämme mallin kouluttamiseen harjoitustietojoukkoa ja sitten verrataan tuloksena olevaa tarkkuutta validointitarkkuuteen. Jos molempien määrien välinen ero on merkittävästi suuri, malli on todennäköisesti liian sopiva. Toistamme mallinrakennusprosessimme ja teemme tarvittavat muutokset matkan varrella. Kun olemme tyytyväisiä koulutukseen ja validointitarkkuuksiin, teemme lopulliset ennusteet testitiedoistamme.

to_categorical: to_categorical on keras-apuohjelma. Sitä käytetään kategoristen tarrojen muuntamiseen yksinkertaisiksi koodauksiksi. Oletetaan, että meillä on kolme tarraa ("omenat", "appelsiinit", "banaanit"), niin yksi kuuma koodaus kullekin näistä olisi [1, 0, 0] -> "omenat", [0, 1, 0] -> "appelsiinit", [0, 0, 1] -> "banaanit".

Loput tuomistamme Keras-moduuleista ovat kääntökerroksia. Keskustelemme konvoluutiokerroksista, kun aloitamme mallimme rakentamisen. Annamme myös nopean katsauksen siihen, mitä kukin näistä kerroksista tekee.

Tietojen esikäsittely

Toistaiseksi siirrämme huomiomme tietojen saamiseen ja analysointiin. Sinun tulisi aina muistaa tietojen esikäsittelyn ja analysoinnin merkitys. Se paitsi antaa sinulle tietoa tiedoista, myös auttaa löytämään epäjohdonmukaisuudet.

Hyvin pieni vaihtelu tiedoissa voi joskus johtaa tuhoisaan tulokseen mallissasi. Tämän vuoksi on tärkeää esikäsitellä tietosi ennen niiden käyttämistä koulutukseen. Joten tämä mielessä aloitetaan tietojen esikäsittely.

train_df = pd.read_csv('./fashion-mnist_train.csv') test_df = pd.read_csv('./fashion-mnist_test.csv')

Ensinnäkin tuodaan tietojoukko ( tässä on linkki tämän tietojoukon lataamiseen järjestelmään ). Kun olet tuonut tietojoukon, suorita seuraava komento.

train_df.head()

Tämä komento näyttää miltä tietosi näyttävät. Seuraava kuvakaappaus näyttää tämän komennon lähdön.

Voimme nähdä, kuinka kuvatietomme tallennetaan pikseliarvojen muodossa. Mutta emme voi syöttää tietoja malliin tässä muodossa. Joten meidän on muunnettava se numpy-matriiseiksi.

train_data = np.array(train_df.iloc[:, 1:]) test_data = np.array(test_df.iloc[:, 1:])

Nyt on aika hankkia tarramme.

train_labels = to_categorical(train_df.iloc[:, 0]) test_labels = to_categorical(test_df.iloc[:, 0])

Täällä voit nähdä, että olemme käyttäneet to_categorical muuntamaan kategoriset tietomme yhdeksi kuumaksi koodaukseksi.

Muotoilemme nyt tiedot uudelleen ja heitämme ne float32- tyyppiin, jotta voimme käyttää niitä kätevästi.

rows, cols = 28, 28 train_data = train_data.reshape(train_data.shape[0], rows, cols, 1) test_data = test_data.reshape(test_data.shape[0], rows, cols, 1) train_data = train_data.astype('float32') test_data = test_data.astype('float32')

Olemme melkein valmista. Lopetetaan vain tietojen esikäsittely normalisoimalla ne. Kuvadatan normalisointi yhdistää kunkin kuvan kaikki pikseliarvot arvoihin välillä 0–1. Tämä auttaa meitä vähentämään tietojen epäjohdonmukaisuuksia. Ennen normalisointia kuvatiedoissa voi olla suuria vaihteluja pikseliarvoissa, mikä voi johtaa epätavalliseen käyttäytymiseen harjoitusprosessin aikana.

train_data /= 255.0 test_data /= 255.0

Konvoluutioiset hermoverkot

Joten tietojen esikäsittely tapahtuu. Nyt voimme aloittaa mallimme rakentamisen. Rakennamme konvoluutiohermoverkon kuvadatan mallintamista varten. CNN: t ovat muunnettuja versioita tavallisista hermoverkoista. Näitä muokataan nimenomaan kuvadataa varten. Kuvien syöttäminen tavallisiin hermoverkkoihin edellyttäisi, että verkossamme on paljon syöttöneuroneja. Esimerkiksi vain 28x28-kokoiselle kuvalle tarvitsisimme 784 syöttöneuronia. Tämä aiheuttaisi valtavan sotkuisen harjoitusparametrien.

CNN: t korjaavat tämän ongelman olettaen jo, että syötteestä tulee kuva. Konvoluutio-hermoverkkojen päätarkoitus on hyödyntää kuvan paikkarakennetta ja poimia siitä korkean tason ominaisuuksia ja sitten harjoittaa näitä ominaisuuksia. Se tekee niin suorittamalla konvoluutiopikselin pikseliarvojen matriisille.

The visualization above shows how convolution operation works. And the Conv2D layer we imported earlier does the same thing. The first matrix (from the left) in the demonstration is the input to the convolutional layer. Then another matrix called "filter" or "kernel" is multiplied (matrix multiplication) to each window of the input matrix. The output of this multiplication is the input to the next layer.

Other than convolutional layers, a typical CNN also has two other types of layers: 1) a  pooling layer, and 2) a fully connected layer.

Pooling layers are used to generalize the output of the convolutional layers. Along with generalizing, it also reduces the number of parameters in the model by down-sampling the output of the convolutional layer.

As we just learned, convolutional layers represent high level features from image data. Fully connected layers use these high level features to train the parameters and to learn to classify those images.

We will also use the Dropout, Batch-normalization and Flatten layers in addition to the layers mentioned above. Flatten layer converts the output of convolutional layers into a one dimensional feature vector. It is important to flatten the outputs because Dense (Fully connected) layers only accept a feature vector as input. Dropout and Batch-normalization layers are for preventing the model from overfitting.

train_x, val_x, train_y, val_y = train_test_split(train_data, train_labels, test_size=0.2) batch_size = 256 epochs = 5 input_shape = (rows, cols, 1)
def baseline_model(): model = Sequential() model.add(BatchNormalization(input_shape=input_shape)) model.add(Conv2D(32, (3, 3), padding="same", activation="relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2,2))) model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(Conv2D(32, (3, 3), padding="same", 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")) return model

The code that you see above is the code for our CNN model. You can structure these layers in many different ways to get good results. There are many popular CNN architectures which give state of the art results. Here, I have just created my own simple architecture for the purpose of this problem. Feel free to try your own and let me know what results you get :)

Training the model

Once you have created the model you can import it and then compile it by using the code below.

model = baseline_model() model.compile(loss='categorical_crossentropy', optimizer="sgd", metrics=['accuracy']) 

model.compile configures the learning process for our model. We have passed it three arguments. These arguments define the loss function for our model, optimizer and metrics.

history = model.fit(train_x, train_y, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(val_x, val_y)) 

And finally by running the code above you can train your model. I am training this model for just five epochs but you can increase the number of epochs. After your training process is completed you can make predictions on the test set by using the following code.

predictions= model.predict(test_data)

Conclusion

Congrats! You did it, you have taken your first step into the amazing world of computer vision.

You have created a your own image classifier. Even though this is a great achievement, we have just scratched the surface.

There is a lot you can do with CNNs. The applications are limitless. I hope that this article helped you to get an understanding of how the process of training these models works.

Muiden tietojoukkojen tekeminen yksin auttaa sinua ymmärtämään tämän vielä paremmin. Olen myös luonut GitHub-arkiston koodille, jota käytin tässä artikkelissa. Joten, jos tämä artikkeli oli hyödyllinen sinulle, ilmoita siitä minulle.

Jos sinulla on kysyttävää tai haluat jakaa omat tulokset tai jos haluat vain sanoa "hei", ota rohkeasti yhteyttä minuun twitterissä, ja yritän tehdä parani auttaakseni sinua. Ja lopuksi kiitos paljon tämän artikkelin lukemisesta! :)