Klasifikacija slika nevjerojatna je primjena dubokog učenja. Možemo osposobiti snažni algoritam za modeliranje velikog skupa podataka o slici. Tada se ovaj model može koristiti za klasifikaciju sličnog, ali nepoznatog skupa slika.
Nema ograničenja za primjenu klasifikacije slika. Možete ga koristiti u svojoj sljedećoj aplikaciji ili možete riješiti neki stvarni problem. To sve ovisi o vama. Ali nekome tko je prilično nov u ovom carstvu, u početku bi se moglo činiti vrlo izazovnim. Kako bih trebao dobiti svoje podatke? Kako bih trebao izgraditi svoj model? Koje alate trebam koristiti?
U ovom ćemo članku razgovarati o svemu tome - od pronalaska skupa podataka do obuke vašeg modela. Pokušat ću stvari učiniti što jednostavnijima izbjegavajući neke tehničke detalje ( PS: Imajte na umu da to ne znači da ti detalji nisu važni. Spomenut ću neke sjajne resurse na koje možete uputiti kako biste saznali više o tim temama ). Svrha ovog članka je objasniti osnovni postupak izgradnje klasifikatora slika i na to ćemo se ovdje više usredotočiti.
Izgradit ćemo klasifikator slika za skup podataka Fashion-MNIST. Skup podataka Fashion-MNIST zbirka je slika Zalandovih članaka. Sadrži 60 000 slika za set treninga i 10 000 slika za podatke testnog skupa ( kasnije ćemo razgovarati o skupovima podataka o testiranju i treningu zajedno s podacima o provjeri ). Ove slike pripadaju oznakama 10 različitih klasa.
Uvoz knjižnica
Cilj nam je osposobiti model dubokog učenja koji može klasificirati zadani skup slika u jedan od ovih 10 razreda. Sad kad imamo svoj skup podataka, trebali bismo prijeći na alate koji su nam potrebni. Postoji mnogo knjižnica i alata koje možete odabrati na temelju vlastitih projektnih zahtjeva. Za ovaj ću se držati sljedećeg:
- Numpy - Python biblioteka za numeričko računanje
- Pandas - Manipulacija podacima Python biblioteke
- Matplotlib - Vizualizacija podataka Python biblioteke
- Keras - Python knjižnica zasnovana na tensorflowu za stvaranje modela dubokog učenja
- Jupyter - Pokrenut ću sav svoj kod na Jupyter bilježnicama. Možete ga instalirati putem veze. Google Colabs možete koristiti i ako vam je potrebna bolja računarska snaga.
Uz ovu četvoricu koristit ćemo i scikit-learn. Svrha ovih knjižnica postat će jasnija kad zaronimo u kod.
U redu! Pripremili smo svoje alate i knjižnice. Sada bismo trebali započeti s postavljanjem našeg koda.
Počnite s uvozom svih gore spomenutih knjižnica. Zajedno s uvozom knjižnica iz tih sam knjižnica uvezao i neke specifične module. Dopustite mi da ih prođem jedan po jedan.
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, BatchNormalizationtrain_test_split: Ovaj modul dijeli skup podataka o treningu na podatke o treningu i provjeri valjanosti. Razlog za ovu podjelu je provjera je li naš model previše opremljen ili nije. Za obuku našeg modela koristimo skup podataka za obuku, a zatim ćemo usporediti rezultirajuću točnost s točnošću provjere valjanosti. Ako je razlika između obje količine znatno velika, tada je naš model vjerojatno previše opremljen. Ponovit ćemo kroz naš postupak izrade modela i usput unoseći potrebne promjene. Jednom kada budemo zadovoljni preciznošću treninga i provjere valjanosti, donijet ćemo konačna predviđanja na temelju podataka testa.
to_categorical: to_categorical je keras uslužni program. Koristi se za pretvaranje kategorijskih oznaka u jedno vruće kodiranje. Recimo da imamo tri oznake ("jabuke", "naranče", "banane"), tada bi jedno vruće kodiranje za svaku od njih bilo [1, 0, 0] -> "jabuke", [0, 1, 0] -> "naranče", [0, 0, 1] -> "banane".
Ostatak Kerasovih modula koje smo uvezli konvolucijski su slojevi. Razgovarat ćemo o konvolucijskim slojevima kad započnemo graditi svoj model. Također ćemo na brzinu pogledati što svaki od ovih slojeva radi.
Predobrada podataka
Za sada ćemo svoju pozornost usmjeriti na dobivanje naših podataka i njihovu analizu. Uvijek biste se trebali sjetiti važnosti prethodne obrade i analize podataka. Ne samo da vam daje uvid u podatke, već pomaže i u pronalaženju nedosljednosti.
Vrlo male varijacije podataka ponekad mogu dovesti do pogubnih rezultata za vaš model. Zbog toga je važno unaprijed obraditi vaše podatke prije nego što ih upotrijebite za trening. Dakle, imajući to na umu, krenimo s predobradom podataka.
train_df = pd.read_csv('./fashion-mnist_train.csv') test_df = pd.read_csv('./fashion-mnist_test.csv')Prije svega uvezimo svoj skup podataka ( ovdje je veza za preuzimanje ovog skupa podataka u vaš sustav ). Nakon što uvezete skup podataka, pokrenite sljedeću naredbu.
train_df.head()Ova naredba će vam pokazati kako izgledaju vaši podaci. Sljedeća snimka zaslona prikazuje izlaz ove naredbe.
Možemo vidjeti kako se naši slikovni podaci pohranjuju u obliku vrijednosti piksela. Ali ne možemo u ovaj format unositi podatke u naš model. Dakle, morat ćemo ga pretvoriti u numpy nizove.
train_data = np.array(train_df.iloc[:, 1:]) test_data = np.array(test_df.iloc[:, 1:])Sada je vrijeme da nabavimo naše etikete.
train_labels = to_categorical(train_df.iloc[:, 0]) test_labels = to_categorical(test_df.iloc[:, 0])Ovdje možete vidjeti da smo koristili to_categorical za pretvaranje naših kategorijskih podataka u jedno vruće kodiranje.
Sada ćemo preoblikovati podatke i prebaciti ih u tip float32 kako bismo ih mogli ugodno koristiti.
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')Skoro smo gotovi. Završimo samo obradu podataka normaliziranjem. Normalizacijom slikovnih podataka mapirat će se sve vrijednosti piksela na svakoj slici na vrijednosti između 0 i 1. To nam pomaže smanjiti nedosljednosti u podacima. Prije normalizacije, slikovni podaci mogu imati velike razlike u vrijednostima piksela što može dovesti do nekih neobičnih ponašanja tijekom procesa treninga.
train_data /= 255.0 test_data /= 255.0Konvolucijske neuronske mreže
Dakle, izvršena je predobrada podataka. Sada možemo početi graditi svoj model. Izgradit ćemo Konvolucijsku neuronsku mrežu za modeliranje podataka o slici. CNN-ovi su modificirane verzije redovnih neuronskih mreža. Oni su posebno prilagođeni za slikovne podatke. Hranjenje slika redovitim neuronskim mrežama zahtijevalo bi da naša mreža ima velik broj ulaznih neurona. Na primjer, samo za sliku veličine 28x28 trebali bismo 784 ulazna neurona. To bi stvorilo ogroman nered u parametrima treninga.
CNN-ovi rješavaju taj problem pretpostavljajući da će ulaz biti slika. Glavna svrha konvolucijskih neuronskih mreža je iskoristiti prostornu strukturu slike i iz nje izvući značajke visoke razine, a zatim trenirati na tim značajkama. To čini izvođenjem operacije konvolucije na matrici vrijednosti piksela.
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 modelThe 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.
Working on other datasets on your own will help you understand this even better. I have also created a GitHub repository for the code I used in this article. So, if this article was useful for you please let me know.
If you have any questions or you want to share your own results or if you just want to say "hi", feel free to hit me up on twitter, and I'll try to do my best to help you. And finally Thanks a lot for reading this article!! :)