I denne bloggposten skal vi følge opp vår tidligere post, hvor vi demonstrerte hvordan man setter opp en funksjonelt AI-miljø. Som nevnt i posten «Setting a Deep Learning Working Enviroment» skal vi bruke Keras Deep Learning Library.

Jeg er en stor tilhenger av Keras. Det er et høynivå, veldig kraftig, intuitivt og enkelt Python-bibliotek for å bygge nevrale nettverk og implementere deep learning-arkitektur. Vi skal kjøre den oppå TensorFlow (som også ble installert om du fulgte instruksjonene i forrige post).

Et av fokusområdene til Keras sine utviklere er å tillate rask eksperimentering, så data scientists kan gå raskt fra ide til resultat. Kort fortalt: Du kan bruke Keras om du ser etter et bibliotek som:

• Gir deg enkel og rask prototyping (gjennom brukervennlighet, modularitet og utvidelsesmuligheter)
• Støtter både konvolusjonelle nettverk og tilbakevendende nettverk (convolutional / recurrent networks).
• Kjører sømløst på CPU og GPU.

Vil du ha mer informasjon om Keras, kan du besøke nettsidene deres.

I denne posten skal vi demonstrere hvordan man lager dyp læring (deep learning) sitt svar på «Hello World». Vi skal lage vår aller første nevrale nettverk-modell i Python med Keras. Vi skal jobbe med å klassifisere Fashion-MNIST-datasettet, ved å bruke en konvolusjonell nevralt nettverk-arkitektur.

Datasettet Fashion-MNIST kommer fra nettbutikken Zalando, og består av 70.000 merkede bilder. Bildene er artikkelbilder som inneholder ti klasser:

1. T-shirt/top
2. Trouser
3. Pullover
4. Dress
5. Coat
6. Sandal
7. Shirt
8. Sneaker
9. Bag
10. Ankle boot

Vil du vite mer om datasettet kan du lese detaljene på GitHub-sidene deres.

Målet vårt blir å, med få linjer kode, definere og trene en modell som skal klassifisere datasettet med en akseptabel nøyaktighet (akseptabel for en «Hello World»-guide!) uten å bruke så mye tid på å optimalisere modellen.

Vi skal ikke fokusere på gjennomganger av de matematiske detaljene rundt hvordan et dypt nevralt nettverk fungerer. Det betyr ikke at disse detaljene ikke er viktige, tvert i mot; de er så viktige at vi vil gjennomgå dem i en framtidig post.

Slik utforsker du åpen data med R

torsdag 18. oktober 2018

Gjennomgang av guiden

Det å bruke Keras-biblioteket kommer til å forenkle koden vi skal bruke i denne guiden. Selv om koden blir relativt enkel, skal vi gi den en hel del detaljer så du kan tilpasse den, og kanskje bruke den for å lage modeller til dine egne datasett i framtida.

Vi skal dele guiden opp i følgende seksjoner:

1. Laste data
2. Definere modellen
3. Kompilere modellen
4. Tilpasse modellen
5. Evaluere modellen
6. Visualisere forutsigelsene

Etter å ha fulgt instruksjonene i «Setting a deep learning working environment», trenger vi ikke bekymre oss over konfigurasjon eller avhengighetene vi trenger. Vi kan starte med én gang!

Laste data

La oss starte med å importere datasettet vårt. Etter dette skal vi gjøre noen pre-prosesseringer for å forberede dataen for treningen, valideringen og testingen.

For å laste Fashion-MNIST-datasettet bruker vi Keras, og bare én linje med kode. Så skal vi laste trene-og-teste-datasettet. Men før vi gjør dette, må vi importere et par viktige biblioteker:

import numpy as np 
import matplotlib.pyplot as plt 
import tensorflow as tf 

# input image dimensions 
img_rows, img_cols = 28, 28 

# the data, split between train and test sets 
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data() 

Hvordan ser dataen vi nettopp lastet ut? La oss først se på formen til datasettet:

print("x_train shape:", x_train.shape, "y_train shape", y_train.shape) 

Som du ser har vi 60.000 treningsbilder som er 28x28 punkter, sammen med de korresponderende 60.000 merkelappene.

En fin ting med å jobbe med JupyterLab, er visualiseringen. La oss se på hvordan bildene i datasettet ser ut:

fig=plt.figure(figsize=(8, 8)) 
columns = 4
rows = 5  

for i in range(1, columns*rows +1): 
   img = x_train[i] 
   fig.add_subplot(rows, columns, i) 
   ax.set_title(str(y_train[i])) 
   plt.axis('off') 
   plt.imshow(img) 

plt.show()

Da skal du få se noe som dette:

Før vi definerer modellen vår; la oss forberede dataen litt mer ved å normalisere den:

if K.image_data_format() == 'channels_first': 
    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) 
    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) 
    input_shape = (1, img_rows, img_cols) 

else: 
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) 
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) 
    input_shape = (img_rows, img_cols, 1) 

x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

# convert class vectors to binary class matrices 
y_train = keras.utils.to_categorical(y_train, num_classes) 
y_test = keras.utils.to_categorical(y_test, num_classes)

Da er vi klare til å gå videre til å definere modellen.

Definere modellen

La oss definere modellen og starte treningen. Vi har et par valg for å definere modeller med Keras:

1. «Sequential model API»
2. «Functional API»

Vi skal bruke «Sequential model API» i denne guiden. Som du får se, trenger vi bare å definere formen til input-dataen i første lag. I det siste laget får vi et tett lag med «softmax activation», så vi kan klassifisere de 10 kategoriene vi har i datasettet.

num_classes = 10 
model = tf.keras.Sequential() 

model.add(tf.keras.layers.Conv2D(32, kernel_size=(3, 3), 
                activation='relu', 
                input_shape=input_shape)) 

model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu')) 
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2))) 
model.add(tf.keras.layers.Dropout(0.25)) 
model.add(tf.keras.layers.Flatten()) 
model.add(tf.keras.layers.Dense(128, activation='relu')) 
model.add(tf.keras.layers.Dropout(0.5)) 
model.add(tf.keras.layers.Dense(num_classes, activation='softmax')) 

Med dette er vi klare for å kompilere modellen i neste steg.

Kompilere modellen

Dette er steget hvor vi bruker model.compile() for å konfigurere treningsprosessen (før den faktiske treningen). Her kan vi definere «loss»-funksjonen, optimalisereren vi vil bruke og beregningene for evalueringen av modellen.

model.compile(loss=tf.keras.losses.categorical_crossentropy,
              optimizer=tf.keras.optimizers.Adadelta(), 
              metrics=['accuracy']) 

Trene modellen

Nå skal vi trene modellen med en «batch size» på 128, over 20 epoker.

batch_size = 128 
epochs = 12 

model.fit(x_train, y_train, 
         batch_size=batch_size, 
          epochs=epochs, 
          verbose=1, 
          validation_split=0.1) 

Teste nøyaktighet

Og vipps, så har vi en nøyaktighet på over 90 prosent. Du kan teste den slik:

score = model.evaluate(x_test, y_test, verbose=0) 
print('\n', 'Validation accuracy:', score[1]) 

Visualisere forutsigelsene

Til slutt skal vi visualisere forutsigelsene som den trenede modellen vår gjør. For dette kan vi bruke model.predict(data, batch_size=1). I guidens siste visuaslisering skal vi se to farger for bildeemnene. Om vi ser et rødt emne, betyr det at forutsigelsen ikke passet sannheten (det faktiske emnet).

Som du merker, gjorde vi denne guiden som en oppskrift. Vi gravde oss ikke ned i detaljer rundt hvordan algoritmene fungerer.

Det skal vi lære i vår neste bloggpost!

Norske selskaper ansetter egne robot-trenere

onsdag 10. oktober 2018