Avvio rapido di TensorFlow 2 per principianti

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza la fonte su GitHub Scarica taccuino

Questa breve introduzione usa Keras per:

  1. Costruisci una rete neurale che classifica le immagini.
  2. Addestra questa rete neurale.
  3. E, infine, valutare l'accuratezza del modello.

Questo è un file blocco note di Google Colaboratory . I programmi Python vengono eseguiti direttamente nel browser, un ottimo modo per apprendere e utilizzare TensorFlow. Per seguire questo tutorial, esegui il blocco note in Google Colab facendo clic sul pulsante nella parte superiore di questa pagina.

  1. In Colab, connettiti a un runtime Python: in alto a destra nella barra dei menu, seleziona CONNETTI .
  2. Esegui tutte le celle del codice del notebook: seleziona Runtime > Esegui tutto .

Scarica e installa TensorFlow 2. Importa TensorFlow nel tuo programma:

import tensorflow as tf

Caricare e preparare il set di dati MNIST . Converti i campioni da numeri interi a numeri in virgola mobile:

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

Costruisci il modello tf.keras.Sequential impilando i livelli. Scegli un ottimizzatore e una funzione di perdita per l'allenamento:

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

Per ogni esempio il modello restituisce un vettore di punteggi " logits " o " log-odds ", uno per ogni classe.

predictions = model(x_train[:1]).numpy()
predictions
array([[ 8.1478250e-01, -4.9710822e-01, -4.4540316e-04,  8.0338269e-02,
        -1.2498328e-01, -2.8269893e-01,  4.8158792e-01, -2.3113336e-01,
        -6.4444810e-02,  2.9273060e-01]], dtype=float32)

La funzione tf.nn.softmax converte questi log in "probabilità" per ogni classe:

tf.nn.softmax(predictions).numpy()
array([[0.2003022 , 0.05394346, 0.08864142, 0.09609938, 0.07826194,
        0.06684294, 0.14354272, 0.07038016, 0.08314615, 0.11883967]],
      dtype=float32)

La perdita losses.SparseCategoricalCrossentropy prende un vettore di logit e un indice True e restituisce una perdita scalare per ogni esempio.

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

Questa perdita è uguale alla probabilità logaritmica negativa della vera classe: è zero se il modello è sicuro della classe corretta.

Questo modello non addestrato fornisce probabilità vicine a casuali (1/10 per ogni classe), quindi la perdita iniziale dovrebbe essere vicina a -tf.math.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy()
2.7054095
model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Il metodo Model.fit regola i parametri del modello per ridurre al minimo la perdita:

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2913 - accuracy: 0.9147
Epoch 2/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.1418 - accuracy: 0.9584
Epoch 3/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.1058 - accuracy: 0.9681
Epoch 4/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0879 - accuracy: 0.9730
Epoch 5/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0744 - accuracy: 0.9765
<tensorflow.python.keras.callbacks.History at 0x7fc99a051290>

Il metodo Model.evaluate controlla le prestazioni dei modelli, solitamente su un " Set di convalida " o " Set di test ".

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 0s - loss: 0.0737 - accuracy: 0.9784
[0.07365398108959198, 0.9783999919891357]

Il classificatore di immagini è ora addestrato con una precisione del 98% circa su questo set di dati. Per saperne di più, leggi i tutorial di TensorFlow .

Se vuoi che il tuo modello restituisca una probabilità, puoi avvolgere il modello addestrato e allegare il softmax ad esso:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
probability_model(x_test[:5])
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[1.7845143e-09, 6.2416250e-09, 8.8993971e-07, 5.0938579e-05,
        6.9239370e-10, 9.1531788e-08, 3.0702079e-12, 9.9993479e-01,
        1.6381224e-06, 1.1627582e-05],
       [1.6608839e-08, 6.1237602e-04, 9.9933952e-01, 4.5319266e-05,
        4.2082616e-14, 6.8845372e-07, 1.2797722e-08, 1.6431847e-12,
        2.0782168e-06, 2.8262946e-11],
       [1.3514825e-06, 9.9640971e-01, 1.8868307e-04, 2.4645233e-05,
        8.3467271e-04, 1.7597053e-05, 5.1044153e-05, 1.7571129e-03,
        6.8748201e-04, 2.7744498e-05],
       [9.9969614e-01, 3.3471906e-08, 1.3097884e-05, 3.4203765e-08,
        2.6330403e-07, 6.6318894e-06, 2.1209409e-04, 4.3179925e-06,
        1.5615402e-07, 6.7310575e-05],
       [4.4438386e-07, 5.8649330e-09, 6.7045465e-07, 6.9524458e-10,
        9.9840516e-01, 1.0503891e-07, 3.2713297e-07, 3.2584390e-05,
        3.4801921e-08, 1.5606619e-03]], dtype=float32)>