Sådan oprettes en simpel billedklasser

Billedklassifikation er en fantastisk anvendelse af dyb læring. Vi kan træne en stærk algoritme til at modellere et stort billedsæt. Denne model kan derefter bruges til at klassificere et lignende, men ukendt sæt af billeder.

Der er ingen grænse for anvendelserne af billedklassificering. Du kan bruge den i din næste app, eller du kan bruge den til at løse et problem i den virkelige verden. Det er alt op til dig. Men for en person, der er ret ny på dette område, kan det i første omgang virke meget udfordrende. Hvordan skal jeg få mine data? Hvordan skal jeg bygge min model? Hvilke værktøjer skal jeg bruge?

I denne artikel vil vi diskutere alt dette - fra at finde et datasæt til at træne din model. Jeg vil forsøge at gøre tingene så enkle som muligt ved at undgå nogle tekniske detaljer ( PS: Vær opmærksom på, at dette ikke betyder, at disse detaljer ikke er vigtige. Jeg vil nævne nogle gode ressourcer, som du kan henvise til for at lære mere om disse emner ). Formålet med denne artikel er at forklare den grundlæggende proces med at opbygge en billedklasser, og det er det, vi vil fokusere mere på her.

Vi vil opbygge en billedklasser til Fashion-MNIST-datasættet. Mode-MNIST-datasættet er en samling af Zalandos artikelbilleder. Den indeholder 60.000 billeder til træningssættet og 10.000 billeder til testsættets data ( vi vil diskutere test- og træningsdatasættene sammen med valideringsdatasættet senere ). Disse billeder tilhører etiketterne i 10 forskellige klasser.

Importerer biblioteker

Vores mål er at træne en dyb læringsmodel, der kan klassificere et givet sæt billeder i en af ​​disse 10 klasser. Nu hvor vi har vores datasæt, skal vi gå videre til de værktøjer, vi har brug for. Der er mange biblioteker og værktøjer derude, som du kan vælge ud fra dine egne projektkrav. Til denne vil jeg holde mig til følgende:

  1. Numpy - Python-bibliotek til numerisk beregning
  2. Pandaer - manipulation af Python-biblioteksdata
  3. Matplotlib - Python-biblioteksdatavisualisering
  4. Keras - Python-bibliotek baseret på tensorflow til oprettelse af modeller for dyb læring
  5. Jupyter - Jeg kører al min kode på Jupyter Notebooks. Du kan installere det via linket. Du kan også bruge Google Colabs, hvis du har brug for bedre beregningskraft.

Sammen med disse fire vil vi også bruge scikit-learning. Formålet med disse biblioteker bliver mere klart, når vi dykker ned i koden.

Okay! Vi har vores værktøjer og biblioteker klar. Nu skal vi begynde at opsætte vores kode.

Start med at importere alle de ovennævnte biblioteker. Sammen med import af biblioteker har jeg også importeret nogle specifikke moduler fra disse biblioteker. Lad mig gennemgå dem en efter en.

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: Dette modul opdeler træningsdatasættet i trænings- og valideringsdata. Årsagen til denne opdeling er at kontrollere, om vores model er overmontering eller ej. Vi bruger et træningsdatasæt til at træne vores model, og derefter sammenligner vi den resulterende nøjagtighed med valideringsnøjagtighed. Hvis forskellen mellem begge mængder er signifikant stor, er vores model sandsynligvis overmontering. Vi gentager gennem vores modelbygningsproces og foretager de nødvendige ændringer undervejs. Når vi er tilfredse med vores trænings- og valideringsnøjagtigheder, forudsiger vi endelige forudsigelser på vores testdata.

to_categorical: to_categorical er et keras-værktøj. Det bruges til at konvertere de kategoriske etiketter til en-hot-kodning. Lad os sige, at vi har tre etiketter ("æbler", "appelsiner", "bananer"), så en varm kodning for hver af disse ville være [1, 0, 0] -> "æbler", [0, 1, 0] -> "appelsiner", [0, 0, 1] -> "bananer".

Resten af ​​de Keras-moduler, vi har importeret, er sammenfoldningslag. Vi vil diskutere sammenfoldelseslag, når vi begynder at opbygge vores model. Vi vil også give et hurtigt blik på, hvad hvert af disse lag gør.

Forbehandling af data

For nu vil vi flytte vores opmærksomhed mod at få vores data og analysere dem. Du skal altid huske vigtigheden af ​​forbehandling og analyse af dataene. Det giver dig ikke kun indsigt i dataene, men hjælper også med at finde uoverensstemmelser.

En meget lille variation i data kan nogle gange føre til et ødelæggende resultat for din model. Dette gør det vigtigt at forbehandle dine data, før du bruger dem til træning. Så med det i tankerne, lad os starte forbehandling af data.

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

Lad os først og fremmest importere vores datasæt ( Her er linket til at downloade dette datasæt på dit system ). Når du har importeret datasættet, skal du køre følgende kommando.

train_df.head()

Denne kommando viser dig, hvordan dine data ser ud. Følgende skærmbillede viser output fra denne kommando.

Vi kan se, hvordan vores billeddata lagres i form af pixelværdier. Men vi kan ikke føje data til vores model i dette format. Så vi bliver nødt til at konvertere det til dumme matrixer.

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

Nu er det tid til at få vores etiketter.

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

Her kan du se, at vi har brugt to_categorical til at konvertere vores kategoriske data til en hot kodning.

Vi vil nu omforme dataene og kaste dem i float32- typen, så vi kan bruge dem bekvemt.

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

Vi er næsten færdige. Lad os bare afslutte forbehandlingen af ​​vores data ved at normalisere dem. Normalisering af billeddata kortlægger alle pixelværdierne i hvert billede til værdierne mellem 0 og 1. Dette hjælper os med at reducere inkonsekvenser i data. Før normalisering kan billeddataene have store variationer i pixelværdier, hvilket kan føre til usædvanlig adfærd under træningsprocessen.

train_data /= 255.0 test_data /= 255.0

Konvolutionsneurale netværk

Så forbehandling af data er færdig. Nu kan vi begynde at opbygge vores model. Vi bygger et Convolutional Neural Network til modellering af billeddataene. CNN'er er modificerede versioner af almindelige neurale netværk. Disse er modificeret specielt til billeddata. Fodring af billeder til almindelige neurale netværk vil kræve, at vores netværk har et stort antal inputneuroner. For eksempel bare for et 28x28 billede ville vi kræve 784 inputneuroner. Dette ville skabe et enormt rod af træningsparametre.

CNN'er løser dette problem ved allerede at antage, at inputen bliver et billede. Hovedformålet med nedbrydningsneurale netværk er at drage fordel af billedets rumlige struktur og at trække funktioner på højt niveau ud af det og derefter træne på disse funktioner. Det gør det ved at udføre en konvolutionsoperation på matrixen af ​​pixelværdier.

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.

At arbejde med andre datasæt alene hjælper dig med at forstå dette endnu bedre. Jeg har også oprettet et GitHub-lager for den kode, jeg brugte i denne artikel. Så hvis denne artikel var nyttig for dig, så lad mig det vide.

Hvis du har spørgsmål, eller du vil dele dine egne resultater, eller hvis du bare vil sige "hej", er du velkommen til at slå mig op på twitter, så prøver jeg at gøre mit bedste for at hjælpe dig. Og endelig mange tak for at have læst denne artikel !! :)