Bắt đầu với TensorBoard

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

Trong học máy, để cải thiện điều gì đó, bạn thường cần có khả năng đo lường nó. TensorBoard là một công cụ cung cấp các phép đo và hình ảnh hóa cần thiết trong quy trình làm việc của máy học. Nó cho phép theo dõi các số liệu thử nghiệm như mất mát và độ chính xác, trực quan hóa biểu đồ mô hình, chiếu các phép nhúng vào không gian chiều thấp hơn, v.v.

Phần khởi động nhanh này sẽ hướng dẫn cách nhanh chóng bắt đầu với TensorBoard. Các hướng dẫn còn lại trong trang web này cung cấp thêm chi tiết về các khả năng cụ thể, nhiều trong số đó không được bao gồm ở đây.

# Load the TensorBoard notebook extension
%load_ext tensorboard

import tensorflow as tf
import datetime

# Clear any logs from previous runs
rm -rf ./logs/

Sử dụng MNIST bộ dữ liệu như ví dụ này, chuẩn hóa dữ liệu và viết một chức năng mà tạo ra một mô hình đơn giản Keras để phân loại những hình ảnh thành 10 lớp.

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

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Sử dụng TensorBoard với Keras Model.fit ()

Khi tập luyện với Keras của Model.fit () , thêm các tf.keras.callbacks.TensorBoard callback Đảm bảo rằng các bản ghi được tạo ra và lưu trữ. Thêm vào đó, cho phép biểu đồ tính toán mọi thời đại với histogram_freq=1 (đây là tắt theo mặc định)

Đặt nhật ký vào thư mục con có dấu thời gian để cho phép dễ dàng lựa chọn các lần chạy đào tạo khác nhau.

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

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

model.fit(x=x_train, 
          y=y_train, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])

Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 15s 246us/sample - loss: 0.2217 - accuracy: 0.9343 - val_loss: 0.1019 - val_accuracy: 0.9685
Epoch 2/5
60000/60000 [==============================] - 14s 229us/sample - loss: 0.0975 - accuracy: 0.9698 - val_loss: 0.0787 - val_accuracy: 0.9758
Epoch 3/5
60000/60000 [==============================] - 14s 231us/sample - loss: 0.0718 - accuracy: 0.9771 - val_loss: 0.0698 - val_accuracy: 0.9781
Epoch 4/5
60000/60000 [==============================] - 14s 227us/sample - loss: 0.0540 - accuracy: 0.9820 - val_loss: 0.0685 - val_accuracy: 0.9795
Epoch 5/5
60000/60000 [==============================] - 14s 228us/sample - loss: 0.0433 - accuracy: 0.9862 - val_loss: 0.0623 - val_accuracy: 0.9823
<tensorflow.python.keras.callbacks.History at 0x7fc8a5ee02e8>

Khởi động TensorBoard thông qua dòng lệnh hoặc trong trải nghiệm máy tính xách tay. Hai giao diện nói chung là giống nhau. Trong máy tính xách tay, sử dụng %tensorboard dòng kỳ diệu. Trên dòng lệnh, chạy lệnh tương tự mà không có "%".

%tensorboard --logdir logs/fit

Tổng quan ngắn gọn về các trang tổng quan được hiển thị (các tab trong thanh điều hướng trên cùng):

  • Các vô hướng bảng điều khiển chương trình như thế nào sự mất mát và số liệu thay đổi với mọi thời đại. Bạn cũng có thể sử dụng nó để theo dõi tốc độ đào tạo, tốc độ học tập và các giá trị vô hướng khác.
  • Các bảng điều khiển đồ thị giúp bạn hình dung mô hình của bạn. Trong trường hợp này, biểu đồ Keras của các lớp được hiển thị có thể giúp bạn đảm bảo nó được xây dựng chính xác.
  • Các khoản phân phối và Histograms biểu đồ hiển thị sự phân bố của một tensor theo thời gian. Điều này có thể hữu ích để hình dung các trọng số và thành kiến ​​và xác minh rằng chúng đang thay đổi theo cách mong đợi.

Các plugin TensorBoard bổ sung được tự động bật khi bạn ghi nhật ký các loại dữ liệu khác. Ví dụ, lệnh gọi lại Keras TensorBoard cũng cho phép bạn ghi nhật ký hình ảnh và nhúng. Bạn có thể xem những plugin khác có sẵn trong TensorBoard bằng cách nhấp vào menu thả xuống "không hoạt động" ở phía trên bên phải.

Sử dụng TensorBoard với các phương pháp khác

Khi tập luyện với phương pháp như tf.GradientTape() , sử dụng tf.summary để đăng nhập các thông tin cần thiết.

Sử dụng các dữ liệu tương tự như trên, nhưng chuyển nó sang tf.data.Dataset để tận dụng khả năng Trạm trộn:

train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

train_dataset = train_dataset.shuffle(60000).batch(64)
test_dataset = test_dataset.batch(64)

Mã đào tạo theo quickstart tiên tiến hướng dẫn, nhưng các chương trình như thế nào để đăng nhập số liệu để TensorBoard. Chọn mất mát và tối ưu hóa:

loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

Tạo các chỉ số trạng thái có thể được sử dụng để tích lũy các giá trị trong quá trình đào tạo và ghi lại vào bất kỳ thời điểm nào:

# Define our metrics
train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')

Xác định các chức năng đào tạo và kiểm tra:

def train_step(model, optimizer, x_train, y_train):
  with tf.GradientTape() as tape:
    predictions = model(x_train, training=True)
    loss = loss_object(y_train, predictions)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  train_loss(loss)
  train_accuracy(y_train, predictions)

def test_step(model, x_test, y_test):
  predictions = model(x_test)
  loss = loss_object(y_test, predictions)

  test_loss(loss)
  test_accuracy(y_test, predictions)

Thiết lập người viết tóm tắt để ghi tóm tắt vào đĩa trong một thư mục nhật ký khác:

current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/gradient_tape/' + current_time + '/train'
test_log_dir = 'logs/gradient_tape/' + current_time + '/test'
train_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)

Bắt đầu đào tạo. Sử dụng tf.summary.scalar() để đăng nhập số liệu (lỗ và độ chính xác) trong thời gian đào tạo / thử nghiệm trong phạm vi của các tác giả tóm tắt để viết tóm tắt vào đĩa. Bạn có quyền kiểm soát các chỉ số nào cần ghi lại và tần suất thực hiện. Khác tf.summary chức năng enable log các loại dữ liệu.

model = create_model() # reset our model

EPOCHS = 5

for epoch in range(EPOCHS):
  for (x_train, y_train) in train_dataset:
    train_step(model, optimizer, x_train, y_train)
  with train_summary_writer.as_default():
    tf.summary.scalar('loss', train_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)

  for (x_test, y_test) in test_dataset:
    test_step(model, x_test, y_test)
  with test_summary_writer.as_default():
    tf.summary.scalar('loss', test_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)

  template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
  print (template.format(epoch+1,
                         train_loss.result(), 
                         train_accuracy.result()*100,
                         test_loss.result(), 
                         test_accuracy.result()*100))

  # Reset metrics every epoch
  train_loss.reset_states()
  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()

Epoch 1, Loss: 0.24321186542510986, Accuracy: 92.84333801269531, Test Loss: 0.13006582856178284, Test Accuracy: 95.9000015258789
Epoch 2, Loss: 0.10446818172931671, Accuracy: 96.84833526611328, Test Loss: 0.08867532759904861, Test Accuracy: 97.1199951171875
Epoch 3, Loss: 0.07096975296735764, Accuracy: 97.80166625976562, Test Loss: 0.07875105738639832, Test Accuracy: 97.48999786376953
Epoch 4, Loss: 0.05380449816584587, Accuracy: 98.34166717529297, Test Loss: 0.07712937891483307, Test Accuracy: 97.56999969482422
Epoch 5, Loss: 0.041443776339292526, Accuracy: 98.71833038330078, Test Loss: 0.07514958828687668, Test Accuracy: 97.5

Mở lại TensorBoard, lần này trỏ nó vào thư mục nhật ký mới. Chúng tôi cũng có thể bắt đầu TensorBoard để theo dõi quá trình đào tạo trong khi nó tiến triển.

%tensorboard --logdir logs/gradient_tape

Đó là nó! Bây giờ bạn đã thấy làm thế nào để sử dụng TensorBoard cả thông qua callback Keras và thông qua tf.summary cho các kịch bản tùy chỉnh hơn.

TensorBoard.dev: Lưu trữ và chia sẻ kết quả thử nghiệm ML của bạn

TensorBoard.dev là một dịch vụ công cộng miễn phí cho phép bạn tải lên các bản ghi TensorBoard của bạn và nhận được một permalink có thể chia sẻ với mọi người trong bài báo, bài đăng trên blog, mạng xã hội, vv Điều này có thể cho phép lặp lại tốt hơn và hợp tác.

Để sử dụng TensorBoard.dev, hãy chạy lệnh sau:

!tensorboard dev upload \
  --logdir logs/fit \
  --name "(optional) My latest experiment" \
  --description "(optional) Simple comparison of several hyperparameters" \
  --one_shot

Lưu ý rằng gọi này sử dụng tiền tố chấm than ( ! ) Để gọi vỏ chứ không phải là tiền tố phần trăm ( % ) để gọi sự kỳ diệu colab. Khi gọi lệnh này từ dòng lệnh, không cần tiền tố.

Xem ví dụ ở đây .

Để biết thêm chi tiết về cách sử dụng TensorBoard.dev, xem https://tensorboard.dev/#get-started