Trang này được dịch bởi Cloud Translation API.
Switch to English

Điều chỉnh siêu tham số với Bảng điều khiển HParams

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub

Khi xây dựng các mô hình học máy, bạn cần chọn các siêu đường kính khác nhau, chẳng hạn như tỷ lệ bỏ học trong một lớp hoặc tốc độ học tập. Những quyết định này tác động đến các số liệu mô hình, chẳng hạn như độ chính xác. Do đó, một bước quan trọng trong quy trình học máy là xác định các siêu âm tốt nhất cho vấn đề của bạn, thường liên quan đến thử nghiệm. Quá trình này được gọi là "Tối ưu hóa siêu tham số" hoặc "Điều chỉnh siêu tham số".

Bảng điều khiển HParams trong TensorBoard cung cấp một số công cụ để trợ giúp cho quá trình xác định thử nghiệm tốt nhất này hoặc các bộ siêu đường kính hứa hẹn nhất.

Hướng dẫn này sẽ tập trung vào các bước sau:

  1. Thiết lập thử nghiệm và tóm tắt HParams
  2. Thích ứng TensorFlow chạy để ghi lại siêu âm và số liệu
  3. Bắt đầu chạy và đăng nhập tất cả chúng trong một thư mục cha
  4. Trực quan hóa kết quả trong bảng điều khiển HParams của TensorBoard

Bắt đầu bằng cách cài đặt TF 2.0 và tải phần mở rộng máy tính xách tay TensorBoard:

 # Load the TensorBoard notebook extension
%load_ext tensorboard
 
 # Clear any logs from previous runs
!rm -rf ./logs/ 
 

Nhập khẩu TensorFlow và plugin TensorBoard HParams:

 import tensorflow as tf
from tensorboard.plugins.hparams import api as hp
 

Tải xuống tập dữ liệu FashionMNIST và chia tỷ lệ:

 fashion_mnist = tf.keras.datasets.fashion_mnist

(x_train, y_train),(x_test, y_test) = fashion_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/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

1. Cài đặt thử nghiệm và tóm tắt thử nghiệm HParams

Thử nghiệm với ba siêu đường kính trong mô hình:

  1. Số lượng đơn vị trong lớp dày đặc đầu tiên
  2. Tỷ lệ bỏ học trong lớp bỏ học
  3. Trình tối ưu hóa

Liệt kê các giá trị để thử và đăng nhập cấu hình thử nghiệm vào TensorBoard. Bước này là tùy chọn: bạn có thể cung cấp thông tin tên miền để cho phép lọc siêu đường kính chính xác hơn trong giao diện người dùng và bạn có thể chỉ định số liệu nào sẽ được hiển thị.

 HP_NUM_UNITS = hp.HParam('num_units', hp.Discrete([16, 32]))
HP_DROPOUT = hp.HParam('dropout', hp.RealInterval(0.1, 0.2))
HP_OPTIMIZER = hp.HParam('optimizer', hp.Discrete(['adam', 'sgd']))

METRIC_ACCURACY = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
  hp.hparams_config(
    hparams=[HP_NUM_UNITS, HP_DROPOUT, HP_OPTIMIZER],
    metrics=[hp.Metric(METRIC_ACCURACY, display_name='Accuracy')],
  )
 

Nếu bạn chọn bỏ qua bước này, bạn có thể sử dụng một chuỗi ký tự bất cứ nơi nào bạn muốn sử dụng giá trị HParam : ví dụ: hparams['dropout'] thay vì hparams[HP_DROPOUT] .

2. Thích ứng TensorFlow chạy để ghi nhật ký siêu âm và số liệu

Mô hình sẽ khá đơn giản: hai lớp dày đặc với một lớp bỏ giữa chúng. Mã đào tạo sẽ trông quen thuộc, mặc dù các siêu đường kính không còn được mã hóa cứng. Thay vào đó, các siêu đường kính được cung cấp trong một từ điển hparams và được sử dụng trong suốt chức năng đào tạo:

 def train_test_model(hparams):
  model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(hparams[HP_NUM_UNITS], activation=tf.nn.relu),
    tf.keras.layers.Dropout(hparams[HP_DROPOUT]),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax),
  ])
  model.compile(
      optimizer=hparams[HP_OPTIMIZER],
      loss='sparse_categorical_crossentropy',
      metrics=['accuracy'],
  )

  model.fit(x_train, y_train, epochs=1) # Run with 1 epoch to speed things up for demo purposes
  _, accuracy = model.evaluate(x_test, y_test)
  return accuracy
 

Đối với mỗi lần chạy, hãy ghi lại một bản tóm tắt hparams với siêu đường kính và độ chính xác cuối cùng:

 def run(run_dir, hparams):
  with tf.summary.create_file_writer(run_dir).as_default():
    hp.hparams(hparams)  # record the values used in this trial
    accuracy = train_test_model(hparams)
    tf.summary.scalar(METRIC_ACCURACY, accuracy, step=1)
 

Khi đào tạo các mô hình Keras, bạn có thể sử dụng các cuộc gọi lại thay vì viết chúng trực tiếp:

 model.fit(
    ...,
    callbacks=[
        tf.keras.callbacks.TensorBoard(logdir),  # log metrics
        hp.KerasCallback(logdir, hparams),  # log hparams
    ],
)
 

3. Bắt đầu chạy và đăng nhập tất cả chúng trong một thư mục cha

Bây giờ bạn có thể thử nhiều thử nghiệm, đào tạo từng thử nghiệm với một bộ siêu đường kính khác nhau.

Để đơn giản, hãy sử dụng tìm kiếm dạng lưới: thử tất cả các kết hợp của các tham số rời rạc và chỉ giới hạn dưới và trên của tham số có giá trị thực. Đối với các kịch bản phức tạp hơn, có thể hiệu quả hơn khi chọn ngẫu nhiên từng giá trị siêu tham số (đây được gọi là tìm kiếm ngẫu nhiên). Có nhiều phương pháp tiên tiến hơn có thể được sử dụng.

Chạy một vài thử nghiệm, sẽ mất vài phút:

 session_num = 0

for num_units in HP_NUM_UNITS.domain.values:
  for dropout_rate in (HP_DROPOUT.domain.min_value, HP_DROPOUT.domain.max_value):
    for optimizer in HP_OPTIMIZER.domain.values:
      hparams = {
          HP_NUM_UNITS: num_units,
          HP_DROPOUT: dropout_rate,
          HP_OPTIMIZER: optimizer,
      }
      run_name = "run-%d" % session_num
      print('--- Starting trial: %s' % run_name)
      print({h.name: hparams[h] for h in hparams})
      run('logs/hparam_tuning/' + run_name, hparams)
      session_num += 1

 
--- Starting trial: run-0
{'num_units': 16, 'dropout': 0.1, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 62us/sample - loss: 0.6872 - accuracy: 0.7564
10000/10000 [==============================] - 0s 35us/sample - loss: 0.4806 - accuracy: 0.8321
--- Starting trial: run-1
{'num_units': 16, 'dropout': 0.1, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 54us/sample - loss: 0.9428 - accuracy: 0.6769
10000/10000 [==============================] - 0s 36us/sample - loss: 0.6519 - accuracy: 0.7770
--- Starting trial: run-2
{'num_units': 16, 'dropout': 0.2, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 60us/sample - loss: 0.8158 - accuracy: 0.7078
10000/10000 [==============================] - 0s 36us/sample - loss: 0.5309 - accuracy: 0.8154
--- Starting trial: run-3
{'num_units': 16, 'dropout': 0.2, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 50us/sample - loss: 1.1465 - accuracy: 0.6019
10000/10000 [==============================] - 0s 36us/sample - loss: 0.7007 - accuracy: 0.7683
--- Starting trial: run-4
{'num_units': 32, 'dropout': 0.1, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 65us/sample - loss: 0.6178 - accuracy: 0.7849
10000/10000 [==============================] - 0s 38us/sample - loss: 0.4645 - accuracy: 0.8395
--- Starting trial: run-5
{'num_units': 32, 'dropout': 0.1, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 55us/sample - loss: 0.8989 - accuracy: 0.6896
10000/10000 [==============================] - 0s 37us/sample - loss: 0.6335 - accuracy: 0.7853
--- Starting trial: run-6
{'num_units': 32, 'dropout': 0.2, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 64us/sample - loss: 0.6404 - accuracy: 0.7782
10000/10000 [==============================] - 0s 37us/sample - loss: 0.4802 - accuracy: 0.8265
--- Starting trial: run-7
{'num_units': 32, 'dropout': 0.2, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 54us/sample - loss: 0.9633 - accuracy: 0.6703
10000/10000 [==============================] - 0s 36us/sample - loss: 0.6516 - accuracy: 0.7755

4. Trực quan hóa kết quả trong plugin HParams của TensorBoard

Bảng điều khiển HParams có thể được mở. Bắt đầu TensorBoard và nhấp vào "HParams" ở trên cùng.

 %tensorboard --logdir logs/hparam_tuning
 

Ngăn bên trái của bảng điều khiển cung cấp các khả năng lọc đang hoạt động trên tất cả các chế độ xem trong bảng điều khiển HParams:

  • Bộ lọc mà siêu âm / số liệu được hiển thị trong bảng điều khiển
  • Lọc các giá trị siêu tham số / số liệu nào được hiển thị trong bảng điều khiển
  • Lọc về trạng thái chạy (đang chạy, thành công, ...)
  • Sắp xếp theo siêu tham số / số liệu trong chế độ xem bảng
  • Số lượng nhóm phiên sẽ hiển thị (hữu ích cho hiệu suất khi có nhiều thử nghiệm)

Bảng điều khiển HParams có ba chế độ xem khác nhau, với nhiều thông tin hữu ích khác nhau:

  • Chế độ xem bảng liệt kê các lần chạy, siêu âm của chúng và số liệu của chúng.
  • Khung nhìn tọa độ song song hiển thị mỗi lần chạy dưới dạng một đường đi qua một trục cho mỗi siêu đường và số liệu. Nhấp và kéo chuột trên bất kỳ trục nào để đánh dấu một khu vực sẽ chỉ đánh dấu các bước chạy qua nó. Điều này có thể hữu ích để xác định nhóm siêu âm nào là quan trọng nhất. Các trục có thể được sắp xếp lại bằng cách kéo chúng.
  • Khung nhìn Scatter Plot hiển thị các ô so sánh từng siêu tham số / số liệu với từng số liệu. Điều này có thể giúp xác định mối tương quan. Nhấp và kéo để chọn một vùng trong một ô cụ thể và đánh dấu các phiên đó trên các ô khác.

Có thể nhấp vào một hàng của bảng, một đường tọa độ song song và thị trường biểu đồ phân tán để xem một biểu đồ của các số liệu như là một chức năng của các bước đào tạo cho phiên đó (mặc dù trong hướng dẫn này chỉ sử dụng một bước cho mỗi lần chạy).

Để khám phá thêm các khả năng của bảng điều khiển HParams, hãy tải xuống một bộ nhật ký được tạo trước với nhiều thử nghiệm hơn:

 %%bash
wget -q 'https://storage.googleapis.com/download.tensorflow.org/tensorboard/hparams_demo_logs.zip'
unzip -q hparams_demo_logs.zip -d logs/hparam_demo
 

Xem các nhật ký này trong TensorBoard:

 %tensorboard --logdir logs/hparam_demo
 

Bạn có thể thử các chế độ xem khác nhau trong bảng điều khiển HParams.

Ví dụ: bằng cách chuyển đến chế độ xem tọa độ song song và nhấp và kéo trên trục chính xác, bạn có thể chọn các bước chạy với độ chính xác cao nhất. Khi các lần chạy này đi qua 'adam' trong trục tối ưu hóa, bạn có thể kết luận rằng 'adam' hoạt động tốt hơn 'sgd' trong các thử nghiệm này.