Giúp bảo vệ Great Barrier Reef với TensorFlow trên Kaggle Tham Challenge

Khởi động nhanh TensorFlow 2 dành cho các chuyên gia

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải xuống sổ ghi chép

Đây là tệp sổ ghi chép của Google Colaboratory . Các chương trình Python được chạy trực tiếp trong trình duyệt — một cách tuyệt vời để học và sử dụng TensorFlow. Để làm theo hướng dẫn này, hãy chạy sổ ghi chép trong Google Colab bằng cách nhấp vào nút ở đầu trang này.

  1. Trong Colab, kết nối với thời gian chạy Python: Ở trên cùng bên phải của thanh menu, chọn KẾT NỐI .
  2. Chạy tất cả các ô mã sổ ghi chép: Chọn Thời gian chạy > Chạy tất cả .

Tải xuống và cài đặt TensorFlow 2. Nhập TensorFlow vào chương trình của bạn:

Nhập TensorFlow vào chương trình của bạn:

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

from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model
TensorFlow version: 2.6.0

Tải và chuẩn bị tập dữ liệu MNIST .

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

# Add a channels dimension
x_train = x_train[..., tf.newaxis].astype("float32")
x_test = x_test[..., tf.newaxis].astype("float32")
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 1s 0us/step
11501568/11490434 [==============================] - 1s 0us/step

Sử dụng tf.data để xử lý hàng loạt và xáo trộn tập dữ liệu:

train_ds = tf.data.Dataset.from_tensor_slices(
    (x_train, y_train)).shuffle(10000).batch(32)

test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

Xây dựng mô hình tf.keras bằng cách sử dụng API phân lớp của mô hình Keras:

class MyModel(Model):
  def __init__(self):
    super(MyModel, self).__init__()
    self.conv1 = Conv2D(32, 3, activation='relu')
    self.flatten = Flatten()
    self.d1 = Dense(128, activation='relu')
    self.d2 = Dense(10)

  def call(self, x):
    x = self.conv1(x)
    x = self.flatten(x)
    x = self.d1(x)
    return self.d2(x)

# Create an instance of the model
model = MyModel()

Chọn một trình tối ưu hóa và chức năng mất để đào tạo:

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

optimizer = tf.keras.optimizers.Adam()

Chọn các chỉ số để đo lường tổn thất và độ chính xác của mô hình. Các chỉ số này tích lũy các giá trị qua các kỷ nguyên và sau đó in ra kết quả tổng thể.

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

Sử dụng tf.GradientTape để huấn luyện mô hình:

@tf.function
def train_step(images, labels):
  with tf.GradientTape() as tape:
    # training=True is only needed if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    predictions = model(images, training=True)
    loss = loss_object(labels, predictions)
  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

  train_loss(loss)
  train_accuracy(labels, predictions)

Kiểm tra mô hình:

@tf.function
def test_step(images, labels):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  predictions = model(images, training=False)
  t_loss = loss_object(labels, predictions)

  test_loss(t_loss)
  test_accuracy(labels, predictions)
EPOCHS = 5

for epoch in range(EPOCHS):
  # Reset the metrics at the start of the next epoch
  train_loss.reset_states()
  train_accuracy.reset_states()
  test_loss.reset_states()
  test_accuracy.reset_states()

  for images, labels in train_ds:
    train_step(images, labels)

  for test_images, test_labels in test_ds:
    test_step(test_images, test_labels)

  print(
    f'Epoch {epoch + 1}, '
    f'Loss: {train_loss.result()}, '
    f'Accuracy: {train_accuracy.result() * 100}, '
    f'Test Loss: {test_loss.result()}, '
    f'Test Accuracy: {test_accuracy.result() * 100}'
  )
Epoch 1, Loss: 0.13439151644706726, Accuracy: 95.98833465576172, Test Loss: 0.06330505013465881, Test Accuracy: 98.02999877929688
Epoch 2, Loss: 0.04413021355867386, Accuracy: 98.63166809082031, Test Loss: 0.0737706869840622, Test Accuracy: 97.57999420166016
Epoch 3, Loss: 0.024562617763876915, Accuracy: 99.1866683959961, Test Loss: 0.04913036897778511, Test Accuracy: 98.5
Epoch 4, Loss: 0.014813972637057304, Accuracy: 99.51499938964844, Test Loss: 0.06434403359889984, Test Accuracy: 98.1199951171875
Epoch 5, Loss: 0.010033201426267624, Accuracy: 99.66999816894531, Test Loss: 0.07429419457912445, Test Accuracy: 98.15999603271484

Bộ phân loại hình ảnh hiện đã được đào tạo để có độ chính xác ~ 98% trên tập dữ liệu này. Để tìm hiểu thêm, hãy đọc hướng dẫn về TensorFlow .