Panduan memulai TensorFlow 2 untuk pemula

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Pengenalan singkat ini menggunakan Keras untuk:

  1. Muat set data bawaan.
  2. Bangun model pembelajaran mesin jaringan saraf yang mengklasifikasikan gambar.
  3. Latih jaringan saraf ini.
  4. Mengevaluasi keakuratan model.

Tutorial ini adalah buku catatan Google Colaboratory . Program Python dijalankan langsung di browser—cara yang bagus untuk mempelajari dan menggunakan TensorFlow. Untuk mengikuti tutorial ini, jalankan notebook di Google Colab dengan mengklik tombol di bagian atas halaman ini.

  1. Di Colab, sambungkan ke runtime Python: Di kanan atas bilah menu, pilih CONNECT .
  2. Jalankan semua sel kode buku catatan: Pilih Waktu Proses > Jalankan semua .

Siapkan TensorFlow

Impor TensorFlow ke dalam program Anda untuk memulai:

import tensorflow as tf
print("TensorFlow version:", tf.__version__)
TensorFlow version: 2.8.0-rc1

Jika Anda mengikuti lingkungan pengembangan Anda sendiri, bukan Colab , lihat panduan penginstalan untuk menyiapkan TensorFlow untuk pengembangan.

Muat kumpulan data

Muat dan siapkan kumpulan data MNIST . Konversikan data sampel dari bilangan bulat ke bilangan floating-point:

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

Buat model pembelajaran mesin

Bangun model tf.keras.Sequential dengan menumpuk lapisan.

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

Untuk setiap contoh, model mengembalikan vektor logit atau skor peluang log , satu untuk setiap kelas.

predictions = model(x_train[:1]).numpy()
predictions
array([[ 0.2760778 , -0.39324787, -0.17098302,  1.2016621 , -0.03416392,
         0.5461229 , -0.7203061 , -0.41886678, -0.59480035, -0.7580608 ]],
      dtype=float32)

Fungsi tf.nn.softmax mengonversi log ini menjadi probabilitas untuk setiap kelas:

tf.nn.softmax(predictions).numpy()
array([[0.11960829, 0.06124588, 0.0764901 , 0.30181262, 0.08770514,
        0.15668967, 0.04416083, 0.05969675, 0.05006609, 0.04252464]],
      dtype=float32)

Tentukan fungsi kerugian untuk pelatihan menggunakan losses.SparseCategoricalCrossentropy , yang mengambil vektor logit dan indeks True dan mengembalikan kerugian skalar untuk setiap contoh.

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

Kerugian ini sama dengan probabilitas log negatif dari kelas sebenarnya: Kerugiannya adalah nol jika model yakin dengan kelas yang benar.

Model tidak terlatih ini memberikan probabilitas mendekati acak (1/10 untuk setiap kelas), jadi kerugian awal harus mendekati -tf.math.log(1/10) ~= 2.3 .

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

Sebelum Anda memulai pelatihan, konfigurasikan dan kompilasi model menggunakan Keras Model.compile . Setel kelas optimizer ke adam , setel loss ke fungsi loss_fn yang Anda tetapkan sebelumnya, dan tentukan metrik yang akan dievaluasi untuk model dengan menyetel parameter metrics ke accuracy .

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

Latih dan evaluasi model Anda

Gunakan metode Model.fit untuk menyesuaikan parameter model Anda dan meminimalkan kerugian:

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2950 - accuracy: 0.9143
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1451 - accuracy: 0.9567
Epoch 3/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.1080 - accuracy: 0.9668
Epoch 4/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0906 - accuracy: 0.9717
Epoch 5/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0749 - accuracy: 0.9761
<keras.callbacks.History at 0x7f062c606850>

Metode Model.evaluate memeriksa kinerja model, biasanya pada " Validation-set " atau " Test-set ".

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 1s - loss: 0.0783 - accuracy: 0.9755 - 588ms/epoch - 2ms/step
[0.07825208455324173, 0.9754999876022339]

Pengklasifikasi gambar sekarang dilatih untuk akurasi ~98% pada dataset ini. Untuk mempelajari lebih lanjut, baca tutorial TensorFlow .

Jika Anda ingin model Anda mengembalikan probabilitas, Anda dapat membungkus model yang dilatih, dan melampirkan softmax ke dalamnya:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
probability_model(x_test[:5])
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[2.72807270e-08, 2.42517650e-08, 7.75602894e-06, 1.28684027e-04,
        7.66215633e-11, 3.54162950e-07, 3.04894151e-14, 9.99857187e-01,
        2.32766553e-08, 5.97762892e-06],
       [7.37396704e-08, 4.73638036e-04, 9.99523997e-01, 7.20633352e-07,
        4.54133671e-17, 1.42298268e-06, 5.96959016e-09, 1.23534145e-13,
        7.77225608e-08, 6.98619169e-16],
       [1.95462448e-07, 9.99295831e-01, 1.02249986e-04, 1.86699708e-05,
        5.65737491e-06, 1.12115902e-06, 5.32719559e-06, 5.22767776e-04,
        4.79981136e-05, 1.76624681e-07],
       [9.99649286e-01, 1.80224735e-09, 3.73612856e-05, 1.52324446e-07,
        1.30824594e-06, 2.82781020e-05, 6.99703523e-05, 3.30940424e-07,
        2.13184350e-07, 2.13106396e-04],
       [1.53770895e-06, 1.72272063e-08, 1.98980865e-06, 3.97882580e-08,
        9.97192323e-01, 1.10544443e-05, 1.54713348e-06, 2.81727880e-05,
        3.48721733e-06, 2.75991508e-03]], dtype=float32)>

Kesimpulan

Selamat! Anda telah melatih model pembelajaran mesin menggunakan set data bawaan menggunakan Keras API.

Untuk lebih banyak contoh penggunaan Keras, lihat tutorialnya . Untuk mempelajari lebih lanjut tentang membangun model dengan Keras, baca panduannya . Jika Anda ingin mempelajari lebih lanjut tentang memuat dan menyiapkan data, lihat tutorial tentang memuat data gambar atau memuat data CSV .