Aiuto proteggere la Grande Barriera Corallina con tensorflow sul Kaggle Join Sfida

Avvio rapido di TensorFlow 2 per principianti

Visualizza su TensorFlow.org Visualizza la fonte su GitHub Scarica taccuino

Questa breve introduzione utilizza Keras a:

  1. Carica un set di dati predefinito.
  2. Crea un modello di apprendimento automatico della rete neurale che classifica le immagini.
  3. Addestra questa rete neurale.
  4. Valutare l'accuratezza del modello.

Questo tutorial è un Google Colaboratory notebook. 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, connettersi a un runtime di Python: In alto a destra della barra dei menu, selezionare CONNECT.
  2. Eseguire tutte le cellule del codice notebook: Selezionare Runtime> Esegui tutti.

Configura TensorFlow

Importa TensorFlow nel tuo programma per iniziare:

import tensorflow as tf
print("TensorFlow version:", tf.__version__)
TensorFlow version: 2.6.0

Se si sta seguendo insieme nel proprio ambiente di sviluppo, piuttosto che Colab , consultare la guida di installazione per l'impostazione tensorflow per lo sviluppo.

Carica un set di dati

Caricare e preparare il set di dati MNIST . Converti i dati di esempio da numeri interi a numeri a 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
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step

Costruisci un modello di apprendimento automatico

Costruire un tf.keras.Sequential modello impilando strati.

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 logit o log-odds colonne sonore, uno per ogni classe.

predictions = model(x_train[:1]).numpy()
predictions
array([[ 0.74148655, -0.39261633,  0.08016336, -0.46431944,  0.21458861,
         0.31183302,  0.7555975 ,  0.80728006, -0.6296631 , -0.4926056 ]],
      dtype=float32)

La tf.nn.softmax funzione converte questi logit di probabilità per ciascuna classe:

tf.nn.softmax(predictions).numpy()
array([[0.16651046, 0.05356818, 0.08594736, 0.04986165, 0.09831339,
        0.10835411, 0.16887674, 0.1778342 , 0.04226285, 0.04847102]],
      dtype=float32)

Definire una funzione di perdita per la formazione utilizzando losses.SparseCategoricalCrossentropy , che prende un vettore di logit e un True indice 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: la perdita è zero se il modello è sicuro della classe corretta.

Questo modello non addestrato dà probabilità vicino al casuale (1/10 per ogni classe), in modo che la perdita iniziale dovrebbe essere vicino a -tf.math.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy()
2.2223506

Prima di iniziare la formazione, configurare e compilare il modello utilizzando Keras Model.compile . Impostare l' optimizer di classe a adam , impostare la loss al loss_fn funzione definita in precedenza, e specificare una metrica da valutare per il modello impostando i metrics parametro accuracy .

model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Allena e valuta il tuo modello

Utilizzare il Model.fit metodo per regolare i parametri del modello e ridurre al minimo la perdita:

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2956 - accuracy: 0.9137
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1430 - accuracy: 0.9572
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1059 - accuracy: 0.9682
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0870 - accuracy: 0.9736
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0732 - accuracy: 0.9774
<keras.callbacks.History at 0x7fabfe6f6cd0>

Il Model.evaluate metodo controlla le prestazioni modelli, di solito su un " Validation-set " o " Test-set ".

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 0s - loss: 0.0771 - accuracy: 0.9756
[0.07707860320806503, 0.975600004196167]

Il classificatore di immagini è ora addestrato con una precisione del 98% circa su questo set di dati. Per ulteriori informazioni, leggere i tutorials 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([[9.35628634e-07, 1.90160367e-08, 2.08603578e-05, 3.36712168e-04,
        3.99928729e-10, 3.29815066e-07, 1.11730861e-12, 9.99547541e-01,
        5.78590800e-07, 9.29015441e-05],
       [9.06768847e-08, 1.75887300e-03, 9.98239040e-01, 1.42416525e-06,
        2.24498985e-14, 1.93019602e-07, 4.19461571e-07, 1.78353019e-14,
        1.09490275e-08, 3.30677152e-15],
       [1.80358853e-07, 9.99705374e-01, 4.36524460e-05, 7.87066620e-06,
        6.60410151e-05, 1.29832119e-06, 2.66996949e-06, 5.51502962e-05,
        1.15344104e-04, 2.45894512e-06],
       [9.99937892e-01, 1.82150364e-10, 2.67099913e-05, 1.87603248e-07,
        2.81131548e-07, 1.86480634e-06, 2.33697901e-05, 1.97653662e-07,
        3.29448504e-08, 9.38197445e-06],
       [1.53162068e-06, 2.57238808e-09, 2.05853598e-06, 2.75526531e-07,
        9.93477166e-01, 2.57349512e-07, 3.59538944e-06, 9.20545644e-05,
        1.77590653e-06, 6.42123120e-03]], dtype=float32)>

Conclusione

Congratulazioni! Hai addestrato un modello di apprendimento macchina utilizzando un set di dati precompilati utilizzando il Keras API.

Per ulteriori esempi di utilizzo Keras, controllare le esercitazioni . Per ulteriori informazioni sulla creazione di modelli con Keras, leggere le guide . Se volete saperne di più su di carico e la preparazione dei dati, vedere le esercitazioni su caricamento dei dati immagine o CSV caricamento dei dati .