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:
- Anda dapat menyimpan dan mengembalikan nilai variabel Anda menggunakan
tf.train.Checkpoint
. Ini berguna selama pelatihan karena cepat untuk menyimpan dan memulihkan status model. - Anda dapat mengimpor dan mengekspor nilai
tf.Variable
dan grafiktf.function
menggunakantf.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();
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();
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();
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');
Lihat Loop pelatihan dasar dan panduan Keras untuk detail selengkapnya.