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

Kiến thức cơ bản về TensorFlow

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

Hướng dẫn này cung cấp một cái nhìn tổng quát về cơ bản TensorFlow. Mỗi phần của tài liệu này là tổng quan về một chủ đề lớn hơn — bạn có thể tìm thấy các liên kết đến các hướng dẫn đầy đủ ở cuối mỗi phần.

TensorFlow là một nền tảng end-to-end dành cho học máy. Nó hỗ trợ những điều sau:

  • Đa chiều mảng dựa tính toán số (tương tự như NumPy .)
  • GPU và xử lý phân tán
  • Phân biệt tự động
  • Xây dựng mô hình, đào tạo và xuất khẩu
  • Và hơn thế nữa

Căng thẳng

TensorFlow hoạt động trên các mảng đa chiều hoặc tensors biểu diễn dưới dạng tf.Tensor đối tượng. Đây là một tensor hai chiều:

import tensorflow as tf

x = tf.constant([[1., 2., 3.],
                 [4., 5., 6.]])

print(x)
print(x.shape)
print(x.dtype)
tf.Tensor(
[[1. 2. 3.]
 [4. 5. 6.]], shape=(2, 3), dtype=float32)
(2, 3)
<dtype: 'float32'>

Các thuộc tính quan trọng nhất của một tf.Tensor là nó shapedtype :

  • Tensor.shape : cho bạn biết kích thước của tensor cùng mỗi trục của nó.
  • Tensor.dtype : cho bạn biết loại của tất cả các yếu tố trong tensor.

TensorFlow thực hiện các phép toán tiêu chuẩn trên tensor, cũng như nhiều phép toán chuyên dụng cho học máy.

Ví dụ:

x + x
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[ 2.,  4.,  6.],
       [ 8., 10., 12.]], dtype=float32)>
5 * x
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[ 5., 10., 15.],
       [20., 25., 30.]], dtype=float32)>
x @ tf.transpose(x)
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[14., 32.],
       [32., 77.]], dtype=float32)>
tf.concat([x, x, x], axis=0)
<tf.Tensor: shape=(6, 3), dtype=float32, numpy=
array([[1., 2., 3.],
       [4., 5., 6.],
       [1., 2., 3.],
       [4., 5., 6.],
       [1., 2., 3.],
       [4., 5., 6.]], dtype=float32)>
tf.nn.softmax(x, axis=-1)
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[0.09003057, 0.24472848, 0.6652409 ],
       [0.09003057, 0.24472848, 0.6652409 ]], dtype=float32)>
tf.reduce_sum(x)
<tf.Tensor: shape=(), dtype=float32, numpy=21.0>

Chạy các phép tính lớn trên CPU có thể bị chậm. Khi được cấu hình đúng cách, TensorFlow có thể sử dụng phần cứng tăng tốc như GPU để thực thi các hoạt động rất nhanh chóng.

if tf.config.list_physical_devices('GPU'):
  print("TensorFlow **IS** using the GPU")
else:
  print("TensorFlow **IS NOT** using the GPU")
TensorFlow **IS** using the GPU

Hãy tham khảo những hướng dẫn tensor để biết chi tiết.

Biến

Bình thường tf.Tensor đối tượng là không thay đổi. Để tạ cửa hàng mô hình (hoặc tiểu bang có thể thay đổi khác) trong TensorFlow sử dụng một tf.Variable .

var = tf.Variable([0.0, 0.0, 0.0])
var.assign([1, 2, 3])
<tf.Variable 'UnreadVariable' shape=(3,) dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>
var.assign_add([1, 1, 1])
<tf.Variable 'UnreadVariable' shape=(3,) dtype=float32, numpy=array([2., 3., 4.], dtype=float32)>

Hãy tham khảo những hướng dẫn Variables để biết chi tiết.

Phân biệt tự động

Gradient descent và các thuật toán có liên quan là một nền tảng của máy học hiện đại.

Để thực hiện điều này, TensorFlow thực hiện phân biệt tự động (autodiff), sử dụng phép tính để tính toán độ dốc. Thông thường bạn sẽ sử dụng để tính toán gradient lỗi của mô hình hoặc mất mát đối với trọng lượng của nó.

x = tf.Variable(1.0)

def f(x):
  y = x**2 + 2*x - 5
  return y
f(x)
<tf.Tensor: shape=(), dtype=float32, numpy=-2.0>

Tại x = 1.0 , y = f(x) = (1**2 + 3 - 5) = -2 .

Đạo hàm của yy' = f'(x) = (2*x + 2) = 4 . TensorFlow có thể tự động tính toán điều này:

with tf.GradientTape() as tape:
  y = f(x)

g_x = tape.gradient(y, x)  # g(x) = dy/dx

g_x
<tf.Tensor: shape=(), dtype=float32, numpy=4.0>

Ví dụ đơn giản này chỉ có đạo hàm liên quan đến một vô hướng đơn (với x ), nhưng TensorFlow có thể tính toán gradient đối với bất kỳ số lượng tensors phi vô hướng đồng thời với.

Hãy tham khảo những hướng dẫn Autodiff để biết chi tiết.

Đồ thị và hàm tf.

Mặc dù bạn có thể sử dụng TensorFlow một cách tương tác như bất kỳ thư viện Python nào, nhưng TensorFlow cũng cung cấp các công cụ cho:

  • Hiệu suất tối ưu hóa: để tăng tốc độ đào tạo và suy luận.
  • Xuất khẩu: vì vậy bạn có thể tiết kiệm mô hình của bạn khi đó là đào tạo làm.

Những yêu cầu bạn sử dụng tf.function để tách mã thuần TensorFlow của bạn từ Python.

@tf.function
def my_func(x):
  print('Tracing.\n')
  return tf.reduce_sum(x)

Lần đầu tiên bạn chạy tf.function , mặc dù nó thực hiện bằng Python, nó chụp một hoàn chỉnh, tối ưu hóa đồ thị đại diện cho tính toán TensorFlow thực hiện trong phạm vi chức năng.

x = tf.constant([1, 2, 3])
my_func(x)
Tracing.
<tf.Tensor: shape=(), dtype=int32, numpy=6>

Trong các lần gọi tiếp theo, TensorFlow chỉ thực thi biểu đồ được tối ưu hóa, bỏ qua bất kỳ bước nào không phải TensorFlow. Dưới đây, lưu ý rằng my_func không in truy tìm từ print là một hàm Python, không phải là một chức năng TensorFlow.

x = tf.constant([10, 9, 8])
my_func(x)
<tf.Tensor: shape=(), dtype=int32, numpy=27>

Một đồ thị có thể không được tái sử dụng cho các đầu vào với một chữ ký khác nhau ( shapedtype ), do đó, một biểu đồ mới được tạo ra thay vì:

x = tf.constant([10.0, 9.1, 8.2], dtype=tf.float32)
my_func(x)
Tracing.
<tf.Tensor: shape=(), dtype=float32, numpy=27.3>

Các biểu đồ được chụp này cung cấp hai lợi ích:

  • Trong nhiều trường hợp, chúng cung cấp tốc độ thực thi đáng kể (mặc dù không phải là ví dụ tầm thường này).
  • Bạn có thể xuất các đồ thị, sử dụng tf.saved_model , để chạy trên các hệ thống khác như một máy chủ hoặc một thiết bị di động , không cần cài đặt Python yêu cầu.

Tham khảo Giới thiệu về đồ thị để biết thêm chi tiết.

Mô-đun, lớp và mô hình

tf.Module là một lớp học cho việc quản lý của bạn tf.Variable đối tượng, và tf.function đối tượng hoạt động trên chúng. Các tf.Module lớp là cần thiết để hỗ trợ hai tính năng quan trọng:

  1. Bạn có thể lưu và khôi phục các giá trị của các biến của bạn sử dụng tf.train.Checkpoint . Điều này rất hữu ích trong quá trình đào tạo vì nó nhanh chóng lưu và khôi phục trạng thái của mô hình.
  2. Bạn có thể nhập và xuất tf.Variable giá trị tf.function đồ thị sử dụng tf.saved_model . Điều này cho phép bạn chạy mô hình của mình một cách độc lập với chương trình Python đã tạo ra nó.

Dưới đây là một ví dụ hoàn chỉnh xuất khẩu một đơn giản tf.Module đối tượng:

class MyModule(tf.Module):
  def __init__(self, value):
    self.weight = tf.Variable(value)

  @tf.function
  def multiply(self, x):
    return x * self.weight
mod = MyModule(3)
mod.multiply(tf.constant([1, 2, 3]))
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([3, 6, 9], dtype=int32)>

Save the Module :

save_path = './saved'
tf.saved_model.save(mod, save_path)
INFO:tensorflow:Assets written to: ./saved/assets
2021-12-08 17:13:16.021805: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.

SavedModel kết quả độc lập với mã đã tạo ra nó. Bạn có thể tải một SavedModel từ Python, bindings ngôn ngữ khác, hoặc TensorFlow Phục vụ . Bạn cũng có thể chuyển đổi nó để chạy với TensorFlow Lite hoặc TensorFlow JS .

reloaded = tf.saved_model.load(save_path)
reloaded.multiply(tf.constant([1, 2, 3]))
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([3, 6, 9], dtype=int32)>

Các tf.keras.layers.Layertf.keras.Model lớp xây dựng trên tf.Module cung cấp chức năng và sự tiện lợi thêm phương pháp để xây dựng, đào tạo và tiết kiệm các mô hình. Một số trong số này được chứng minh trong phần tiếp theo.

Tham khảo Giới thiệu về module để biết chi tiết.

Các vòng huấn luyện

Bây giờ hãy tập hợp tất cả những điều này lại với nhau để xây dựng một mô hình cơ bản và đào tạo nó từ đầu.

Đầu tiên, hãy tạo một số dữ liệu ví dụ. Điều này tạo ra một đám mây các điểm theo một đường cong bậc hai một cách lỏng lẻo:

import matplotlib
from matplotlib import pyplot as plt

matplotlib.rcParams['figure.figsize'] = [9, 6]
x = tf.linspace(-2, 2, 201)
x = tf.cast(x, tf.float32)

def f(x):
  y = x**2 + 2*x - 5
  return y

y = f(x) + tf.random.normal(shape=[201])

plt.plot(x.numpy(), y.numpy(), '.', label='Data')
plt.plot(x, f(x),  label='Ground truth')
plt.legend();

png

Tạo một mô hình:

class Model(tf.keras.Model):
  def __init__(self, units):
    super().__init__()
    self.dense1 = tf.keras.layers.Dense(units=units,
                                        activation=tf.nn.relu,
                                        kernel_initializer=tf.random.normal,
                                        bias_initializer=tf.random.normal)
    self.dense2 = tf.keras.layers.Dense(1)

  def call(self, x, training=True):
    # For Keras layers/models, implement `call` instead of `__call__`.
    x = x[:, tf.newaxis]
    x = self.dense1(x)
    x = self.dense2(x)
    return tf.squeeze(x, axis=1)
model = Model(64)
plt.plot(x.numpy(), y.numpy(), '.', label='data')
plt.plot(x, f(x),  label='Ground truth')
plt.plot(x, model(x), label='Untrained predictions')
plt.title('Before training')
plt.legend();

png

Viết một vòng lặp đào tạo cơ bản:

variables = model.variables

optimizer = tf.optimizers.SGD(learning_rate=0.01)

for step in range(1000):
  with tf.GradientTape() as tape:
    prediction = model(x)
    error = (y-prediction)**2
    mean_error = tf.reduce_mean(error)
  gradient = tape.gradient(mean_error, variables)
  optimizer.apply_gradients(zip(gradient, variables))

  if step % 100 == 0:
    print(f'Mean squared error: {mean_error.numpy():0.3f}')
Mean squared error: 19.473
Mean squared error: 1.140
Mean squared error: 1.130
Mean squared error: 1.124
Mean squared error: 1.121
Mean squared error: 1.120
Mean squared error: 1.119
Mean squared error: 1.118
Mean squared error: 1.118
Mean squared error: 1.117
plt.plot(x.numpy(),y.numpy(), '.', label="data")
plt.plot(x, f(x),  label='Ground truth')
plt.plot(x, model(x), label='Trained predictions')
plt.title('After training')
plt.legend();

png

Đó là làm việc, nhưng hãy nhớ rằng việc triển khai các tiện ích đào tạo thông thường có sẵn trong tf.keras module. Vì vậy, hãy cân nhắc sử dụng chúng trước khi viết của riêng bạn. Để bắt đầu, các Model.compileModel.fit phương pháp thực hiện một vòng lặp đào tạo dành cho bạn:

new_model = Model(64)
new_model.compile(
    loss=tf.keras.losses.MSE,
    optimizer=tf.optimizers.SGD(learning_rate=0.01))

history = new_model.fit(x, y,
                        epochs=100,
                        batch_size=32,
                        verbose=0)

model.save('./my_model')
INFO:tensorflow:Assets written to: ./my_model/assets
plt.plot(history.history['loss'])
plt.xlabel('Epoch')
plt.ylim([0, max(plt.ylim())])
plt.ylabel('Loss [Mean Squared Error]')
plt.title('Keras training progress');

png

Tham khảo vòng đào tạo cơ bảnhướng dẫn Keras để biết thêm chi tiết.