Dasar-dasar TensorFlow

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Panduan ini memberikan ikhtisar singkat tentang dasar- dasar TensorFlow . Setiap bagian dari dokumen ini adalah ikhtisar dari topik yang lebih besar—Anda dapat menemukan tautan ke panduan lengkap di akhir setiap bagian.

TensorFlow adalah platform ujung ke ujung untuk pembelajaran mesin. Ini mendukung hal-hal berikut:

  • Komputasi numerik berbasis array multidimensi (mirip dengan NumPy .)
  • GPU dan pemrosesan terdistribusi
  • Diferensiasi otomatis
  • Konstruksi model, pelatihan, dan ekspor
  • Dan banyak lagi

Tensor

TensorFlow beroperasi pada array multidimensi atau tensor yang direpresentasikan sebagai objek tf.Tensor . Berikut adalah tensor dua dimensi:

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'>

Atribut terpenting dari tf.Tensor adalah shape dan dtype :

  • Tensor.shape : memberi tahu Anda ukuran tensor di sepanjang masing-masing sumbunya.
  • Tensor.dtype : memberi tahu Anda jenis semua elemen dalam tensor.

TensorFlow mengimplementasikan operasi matematika standar pada tensor, serta banyak operasi khusus untuk pembelajaran mesin.

Sebagai contoh:

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>

Menjalankan perhitungan besar pada CPU bisa lambat. Jika dikonfigurasi dengan benar, TensorFlow dapat menggunakan perangkat keras akselerator seperti GPU untuk menjalankan operasi dengan sangat cepat.

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

Lihat panduan Tensor untuk detailnya.

Variabel

Objek tf.Tensor normal tidak dapat diubah. Untuk menyimpan bobot model (atau status yang dapat diubah lainnya) di TensorFlow, gunakan 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)>

Lihat panduan Variabel untuk detailnya.

Diferensiasi otomatis

Penurunan gradien dan algoritme terkait adalah landasan pembelajaran mesin modern.

Untuk mengaktifkannya, TensorFlow mengimplementasikan diferensiasi otomatis (autodiff), yang menggunakan kalkulus untuk menghitung gradien. Biasanya Anda akan menggunakan ini untuk menghitung gradien kesalahan atau kerugian model sehubungan dengan bobotnya.

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>

Pada x = 1.0 , y = f(x) = (1**2 + 2*1 - 5) = -2 .

Turunan dari y adalah y' = f'(x) = (2*x + 2) = 4 . TensorFlow dapat menghitung ini secara otomatis:

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>

Contoh sederhana ini hanya mengambil turunan sehubungan dengan skalar tunggal ( x ), tetapi TensorFlow dapat menghitung gradien sehubungan dengan sejumlah tensor non-skalar secara bersamaan.

Lihat panduan Autodiff untuk detailnya.

Grafik dan fungsi tf

Meskipun Anda dapat menggunakan TensorFlow secara interaktif seperti pustaka Python lainnya, TensorFlow juga menyediakan alat untuk:

  • Optimalisasi kinerja : untuk mempercepat pelatihan dan inferensi.
  • Ekspor : sehingga Anda dapat menyimpan model Anda setelah selesai pelatihan.

Ini mengharuskan Anda menggunakan tf.function untuk memisahkan kode murni-TensorFlow Anda dari Python.

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

Saat pertama kali Anda menjalankan tf.function , meskipun dijalankan dengan Python, tf.function menangkap grafik lengkap yang dioptimalkan yang mewakili komputasi TensorFlow yang dilakukan dalam fungsi tersebut.

x = tf.constant([1, 2, 3])
my_func(x)

Tracing.
<tf.Tensor: shape=(), dtype=int32, numpy=6>

Pada panggilan berikutnya, TensorFlow hanya mengeksekusi grafik yang dioptimalkan, melewatkan langkah non-TensorFlow apa pun. Di bawah, perhatikan bahwa my_func tidak mencetak tracing karena print adalah fungsi Python, bukan fungsi TensorFlow.

x = tf.constant([10, 9, 8])
my_func(x)

<tf.Tensor: shape=(), dtype=int32, numpy=27>

Grafik mungkin tidak dapat digunakan kembali untuk input dengan tanda tangan yang berbeda ( shape dan dtype ), jadi grafik baru akan dibuat sebagai gantinya:

x = tf.constant([10.0, 9.1, 8.2], dtype=tf.float32)
my_func(x)

Tracing.
<tf.Tensor: shape=(), dtype=float32, numpy=27.3>

Grafik yang diambil ini memberikan dua manfaat:

  • Dalam banyak kasus mereka memberikan percepatan yang signifikan dalam eksekusi (meskipun bukan contoh sepele ini).
  • Anda dapat mengekspor grafik ini, menggunakan tf.saved_model , untuk dijalankan di sistem lain seperti server atau perangkat seluler , tidak perlu instalasi Python.

Lihat Pengantar grafik untuk lebih jelasnya.

Modul, lapisan, dan model

tf.Module adalah kelas untuk mengelola objek tf.Variable Anda, dan objek tf.function yang beroperasi pada objek tersebut. Kelas tf.Module diperlukan untuk mendukung dua fitur penting:

  1. Anda dapat menyimpan dan mengembalikan nilai variabel Anda menggunakan tf.train.Checkpoint . Ini berguna selama pelatihan karena cepat untuk menyimpan dan memulihkan status model.
  2. Anda dapat mengimpor dan mengekspor nilai tf.Variable dan grafik tf.function menggunakan tf.saved_model . Ini memungkinkan Anda untuk menjalankan model Anda secara independen dari program Python yang membuatnya.

Berikut adalah contoh lengkap mengekspor objek tf.Module sederhana:

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)>

Simpan Module :

save_path = './saved'
tf.saved_model.save(mod, save_path)

INFO:tensorflow:Assets written to: ./saved/assets
2022-01-19 02:29:48.135588: 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 yang dihasilkan tidak bergantung pada kode yang membuatnya. Anda dapat memuat SavedModel dari Python, binding bahasa lain, atau TensorFlow Serving . Anda juga dapat mengonversinya untuk dijalankan dengan TensorFlow Lite atau 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)>

Kelas tf.keras.layers.Layer dan tf.keras.Model dibangun di atas tf.Module yang menyediakan fungsionalitas tambahan dan metode kenyamanan untuk membangun, melatih, dan menyimpan model. Beberapa di antaranya ditunjukkan di bagian berikutnya.

Lihat Pengantar modul untuk detailnya.

Loop pelatihan

Sekarang gabungkan semua ini untuk membangun model dasar dan latih dari awal.

Pertama, buat beberapa contoh data. Ini menghasilkan awan poin yang secara longgar mengikuti kurva kuadrat:

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

Buat model:

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

Tulis loop pelatihan dasar:

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: 16.123
Mean squared error: 0.997
Mean squared error: 0.964
Mean squared error: 0.946
Mean squared error: 0.932
Mean squared error: 0.921
Mean squared error: 0.913
Mean squared error: 0.907
Mean squared error: 0.901
Mean squared error: 0.897

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

Itu berhasil, tetapi ingat bahwa implementasi utilitas pelatihan umum tersedia di modul tf.keras . Jadi pertimbangkan untuk menggunakannya sebelum menulis milik Anda sendiri. Untuk memulainya, metode Model.compile dan Model.fit mengimplementasikan loop pelatihan untuk Anda:

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

Lihat Loop pelatihan dasar dan panduan Keras untuk detail selengkapnya.