Trả lời cho sự kiện TensorFlow Everywhere tại địa phương của bạn ngay hôm nay!
Trang này được dịch bởi Cloud Translation API.
Switch to English

Các vòng đào tạo cơ bản

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

Trong các hướng dẫn trước, bạn đã học về tensor , biến , băng gradientmô-đun . Trong hướng dẫn này, bạn sẽ lắp tất cả những thứ này lại với nhau để đào tạo các mô hình.

TensorFlow cũng bao gồm API tf.Keras , một API mạng nơ-ron cấp cao cung cấp các thông tin tóm tắt hữu ích để giảm bớt phần viết sẵn. Tuy nhiên, trong hướng dẫn này, bạn sẽ sử dụng các lớp cơ bản.

Thiết lập

import tensorflow as tf

Giải quyết vấn đề học máy

Giải quyết vấn đề học máy thường bao gồm các bước sau:

  • Lấy dữ liệu đào tạo.
  • Xác định mô hình.
  • Xác định một hàm mất mát.
  • Chạy qua dữ liệu đào tạo, tính toán tổn thất từ ​​giá trị lý tưởng
  • Tính toán độ dốc cho sự mất mát đó và sử dụng trình tối ưu hóa để điều chỉnh các biến cho phù hợp với dữ liệu.
  • Đánh giá kết quả của bạn.

Với mục đích minh họa, trong hướng dẫn này, bạn sẽ phát triển một mô hình tuyến tính đơn giản, $ f (x) = x * W + b $, có hai biến: $ W $ (trọng số) và $ b $ (độ lệch).

Đây là bài toán cơ bản nhất của máy học: Cho $ x $ và $ y $, cố gắng tìm độ dốc và độ lệch của một đường thông qua hồi quy tuyến tính đơn giản .

Dữ liệu

Học có giám sát sử dụng đầu vào (thường được ký hiệu là x ) và đầu ra (ký hiệu là y , thường được gọi là nhãn ). Mục đích là học từ các đầu vào và đầu ra được ghép nối để bạn có thể dự đoán giá trị của đầu ra từ đầu vào.

Mỗi đầu vào dữ liệu của bạn, trong TensorFlow, hầu như luôn được biểu thị bằng một tensor và thường là một vectơ. Trong đào tạo có giám sát, đầu ra (hoặc giá trị bạn muốn dự đoán) cũng là một tensor.

Dưới đây là một số dữ liệu được tổng hợp bằng cách thêm nhiễu Gaussian (Bình thường) vào các điểm dọc theo một đường.

# The actual line
TRUE_W = 3.0
TRUE_B = 2.0

NUM_EXAMPLES = 1000

# A vector of random x values
x = tf.random.normal(shape=[NUM_EXAMPLES])

# Generate some noise
noise = tf.random.normal(shape=[NUM_EXAMPLES])

# Calculate y
y = x * TRUE_W + TRUE_B + noise
# Plot all the data
import matplotlib.pyplot as plt

plt.scatter(x, y, c="b")
plt.show()

png

Các hàng căng thường được tập hợp lại với nhau theo lô , hoặc các nhóm đầu vào và đầu ra xếp chồng lên nhau. Theo dõi có thể mang lại một số lợi ích đào tạo và hoạt động tốt với các máy gia tốc và tính toán vectơ. Với mức độ nhỏ của tập dữ liệu này, bạn có thể coi toàn bộ tập dữ liệu là một lô duy nhất.

Xác định mô hình

Sử dụng tf.Variable để biểu diễn tất cả các trọng số trong một mô hình. Một tf.Variable lưu trữ một giá trị và cung cấp giá trị này ở dạng tensor khi cần thiết. Xem hướng dẫn biến để biết thêm chi tiết.

Sử dụng tf.Module để đóng gói các biến và tính toán. Bạn có thể sử dụng bất kỳ đối tượng Python nào, nhưng bằng cách này, nó có thể được lưu dễ dàng.

Ở đây, bạn xác định cả wb là các biến.

class MyModel(tf.Module):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # Initialize the weights to `5.0` and the bias to `0.0`
    # In practice, these should be randomly initialized
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def __call__(self, x):
    return self.w * x + self.b

model = MyModel()

# List the variables tf.modules's built-in variable aggregation.
print("Variables:", model.variables)

# Verify the model works
assert model(3.0).numpy() == 15.0
Variables: (<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>, <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=5.0>)

Các biến ban đầu được thiết lập ở đây một cách cố định, nhưng Keras đi kèm với bất kỳ hành một số initalizers bạn có thể sử dụng, có hoặc không có phần còn lại của Keras.

Xác định một hàm mất mát

Hàm tổn thất đo lường mức độ đầu ra của một mô hình cho một đầu vào nhất định phù hợp với đầu ra mục tiêu. Mục đích là để giảm thiểu sự khác biệt này trong quá trình đào tạo. Xác định tổn thất L2 tiêu chuẩn, còn được gọi là lỗi "bình phương trung bình":

# This computes a single loss value for an entire batch
def loss(target_y, predicted_y):
  return tf.reduce_mean(tf.square(target_y - predicted_y))

Trước khi đào tạo mô hình, bạn có thể hình dung giá trị tổn thất bằng cách vẽ biểu đồ dự đoán của mô hình bằng màu đỏ và dữ liệu đào tạo màu xanh lam:

plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(y, model(x)).numpy())

png

Current loss: 8.718583

Xác định vòng lặp đào tạo

Vòng lặp đào tạo bao gồm lặp lại ba nhiệm vụ theo thứ tự:

  • Gửi một loạt đầu vào thông qua mô hình để tạo đầu ra
  • Tính toán tổn thất bằng cách so sánh kết quả đầu ra với đầu ra (hoặc nhãn)
  • Sử dụng băng gradient để tìm các gradient
  • Tối ưu hóa các biến với các gradient đó

Đối với ví dụ này, bạn có thể đào tạo mô hình bằng cách sử dụng gradient descent .

Có nhiều biến thể của lược đồ giảm độ dốc được ghi lại trong tf.keras.optimizers . Nhưng với tinh thần xây dựng từ những nguyên tắc đầu tiên, ở đây bạn sẽ tự thực hiện phép toán cơ bản với sự trợ giúp củatf.GradientTape để phân biệt tự động và tf.assign_sub để giảm giá trị (kết hợp tf.assigntf.sub ):

# Given a callable model, inputs, outputs, and a learning rate...
def train(model, x, y, learning_rate):

  with tf.GradientTape() as t:
    # Trainable variables are automatically tracked by GradientTape
    current_loss = loss(y, model(x))

  # Use GradientTape to calculate the gradients with respect to W and b
  dw, db = t.gradient(current_loss, [model.w, model.b])

  # Subtract the gradient scaled by the learning rate
  model.w.assign_sub(learning_rate * dw)
  model.b.assign_sub(learning_rate * db)

Để xem qua quá trình huấn luyện, bạn có thể gửi cùng một lô x an y qua vòng lặp huấn luyện và xem Wb phát triển như thế nào.

model = MyModel()

# Collect the history of W-values and b-values to plot later
Ws, bs = [], []
epochs = range(10)

# Define a training loop
def training_loop(model, x, y):

  for epoch in epochs:
    # Update the model with the single giant batch
    train(model, x, y, learning_rate=0.1)

    # Track this before I update
    Ws.append(model.w.numpy())
    bs.append(model.b.numpy())
    current_loss = loss(y, model(x))

    print("Epoch %2d: W=%1.2f b=%1.2f, loss=%2.5f" %
          (epoch, Ws[-1], bs[-1], current_loss))
print("Starting: W=%1.2f b=%1.2f, loss=%2.5f" %
      (model.w, model.b, loss(y, model(x))))

# Do the training
training_loop(model, x, y)

# Plot it
plt.plot(epochs, Ws, "r",
         epochs, bs, "b")

plt.plot([TRUE_W] * len(epochs), "r--",
         [TRUE_B] * len(epochs), "b--")

plt.legend(["W", "b", "True W", "True b"])
plt.show()
Starting: W=5.00 b=0.00, loss=8.71858
Epoch  0: W=4.61 b=0.38, loss=6.01671
Epoch  1: W=4.30 b=0.69, loss=4.26722
Epoch  2: W=4.05 b=0.94, loss=3.13440
Epoch  3: W=3.84 b=1.14, loss=2.40089
Epoch  4: W=3.68 b=1.30, loss=1.92594
Epoch  5: W=3.55 b=1.43, loss=1.61840
Epoch  6: W=3.44 b=1.54, loss=1.41926
Epoch  7: W=3.36 b=1.62, loss=1.29032
Epoch  8: W=3.29 b=1.69, loss=1.20683
Epoch  9: W=3.23 b=1.74, loss=1.15277

png

# Visualize how the trained model performs
plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(model(x), y).numpy())

png

Current loss: 1.152767

Giải pháp tương tự, nhưng với Keras

Sẽ rất hữu ích khi đối chiếu đoạn mã trên với đoạn mã tương đương trong Keras.

Việc xác định mô hình trông giống hệt nhau nếu bạn phân lớp tf.keras.Model . Hãy nhớ rằng các mô hình Keras cuối cùng kế thừa từ mô-đun.

class MyModelKeras(tf.keras.Model):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # Initialize the weights to `5.0` and the bias to `0.0`
    # In practice, these should be randomly initialized
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def __call__(self, x, **kwargs):
    return self.w * x + self.b

keras_model = MyModelKeras()

# Reuse the training loop with a Keras model
training_loop(keras_model, x, y)

# You can also save a checkpoint using Keras's built-in support
keras_model.save_weights("my_checkpoint")
Epoch  0: W=4.61 b=0.38, loss=6.01671
Epoch  1: W=4.30 b=0.69, loss=4.26722
Epoch  2: W=4.05 b=0.94, loss=3.13440
Epoch  3: W=3.84 b=1.14, loss=2.40089
Epoch  4: W=3.68 b=1.30, loss=1.92594
Epoch  5: W=3.55 b=1.43, loss=1.61840
Epoch  6: W=3.44 b=1.54, loss=1.41926
Epoch  7: W=3.36 b=1.62, loss=1.29032
Epoch  8: W=3.29 b=1.69, loss=1.20683
Epoch  9: W=3.23 b=1.74, loss=1.15277

Thay vì viết các vòng huấn luyện mới mỗi khi bạn tạo một mô hình, bạn có thể sử dụng các tính năng tích hợp của Keras làm lối tắt. Điều này có thể hữu ích khi bạn không muốn viết hoặc gỡ lỗi các vòng huấn luyện Python.

Nếu bạn làm như vậy, bạn sẽ cần sử dụng model.compile() để đặt các tham số và model.fit() để huấn luyện. Có thể ít mã hơn để sử dụng các triển khai Keras của mất L2 và giảm độ dốc, một lần nữa như một phím tắt. Keras lỗ và bộ tối ưu hóa cũng có thể được sử dụng bên ngoài các chức năng tiện lợi này, và ví dụ trước có thể đã sử dụng chúng.

keras_model = MyModelKeras()

# compile sets the training paramaeters
keras_model.compile(
    # By default, fit() uses tf.function().  You can
    # turn that off for debugging, but it is on now.
    run_eagerly=False,

    # Using a built-in optimizer, configuring as an object
    optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),

    # Keras comes with built-in MSE error
    # However, you could use the loss function
    # defined above
    loss=tf.keras.losses.mean_squared_error,
)

Keras fit mong đợi dữ liệu theo lô hoặc một tập dữ liệu hoàn chỉnh dưới dạng một mảng NumPy. Mảng NumPy được cắt nhỏ thành các lô và mặc định có kích thước lô là 32.

Trong trường hợp này, để phù hợp với hành vi của vòng lặp viết tay, bạn nên chuyển x vào dưới dạng một lô duy nhất có kích thước 1000.

print(x.shape[0])
keras_model.fit(x, y, epochs=10, batch_size=1000)
1000
Epoch 1/10
1/1 [==============================] - 0s 331ms/step - loss: 8.7186
Epoch 2/10
1/1 [==============================] - 0s 2ms/step - loss: 6.0167
Epoch 3/10
1/1 [==============================] - 0s 2ms/step - loss: 4.2672
Epoch 4/10
1/1 [==============================] - 0s 2ms/step - loss: 3.1344
Epoch 5/10
1/1 [==============================] - 0s 2ms/step - loss: 2.4009
Epoch 6/10
1/1 [==============================] - 0s 2ms/step - loss: 1.9259
Epoch 7/10
1/1 [==============================] - 0s 2ms/step - loss: 1.6184
Epoch 8/10
1/1 [==============================] - 0s 2ms/step - loss: 1.4193
Epoch 9/10
1/1 [==============================] - 0s 2ms/step - loss: 1.2903
Epoch 10/10
1/1 [==============================] - 0s 2ms/step - loss: 1.2068

<tensorflow.python.keras.callbacks.History at 0x7ff25edcf748>

Lưu ý rằng Keras in ra sự mất mát sau khi đào tạo, không phải trước đó, vì vậy tổn thất đầu tiên có vẻ thấp hơn, nhưng về cơ bản điều này cho thấy hiệu suất đào tạo giống nhau.

Bước tiếp theo

Trong hướng dẫn này, bạn đã thấy cách sử dụng các lớp cốt lõi của tensor, biến, mô-đun và băng gradient để xây dựng và đào tạo một mô hình, cũng như cách những ý tưởng đó ánh xạ với Keras.

Tuy nhiên, đây là một vấn đề cực kỳ đơn giản. Để có phần giới thiệu thiết thực hơn, hãy xem Hướng dẫn đào tạo tùy chỉnh .

Để biết thêm về cách sử dụng các vòng huấn luyện Keras tích hợp, hãy xem hướng dẫn này . Để biết thêm về các vòng huấn luyện và Keras, hãy xem hướng dẫn này . Để viết các vòng huấn luyện phân tán tùy chỉnh, hãy xem hướng dẫn này .