 Lihat di TensorFlow.org |  Jalankan di Google Colab |  Lihat sumber di GitHub |  Unduh buku catatan |
Untuk melakukan pembelajaran mesin di TensorFlow, Anda mungkin perlu mendefinisikan, menyimpan, dan memulihkan model.
Sebuah model, secara abstrak:
- Fungsi yang menghitung sesuatu pada tensor ( pass forward )
- Beberapa variabel yang dapat diperbarui sebagai respons terhadap pelatihan
Dalam panduan ini, Anda akan pergi ke bawah permukaan Keras untuk melihat bagaimana model TensorFlow didefinisikan. Ini melihat bagaimana TensorFlow mengumpulkan variabel dan model, serta bagaimana mereka disimpan dan dipulihkan.
Mempersiapkan
import tensorflow as tf
from datetime import datetime
%load_ext tensorboard
Mendefinisikan model dan lapisan di TensorFlow
Kebanyakan model terbuat dari lapisan. Lapisan adalah fungsi dengan struktur matematika yang diketahui yang dapat digunakan kembali dan memiliki variabel yang dapat dilatih. Di TensorFlow, sebagian besar implementasi lapisan dan model tingkat tinggi, seperti Keras atau Sonnet , dibangun di atas kelas dasar yang sama: tf.Module .
Berikut adalah contoh tf.Module yang sangat sederhana yang beroperasi pada tensor skalar:
class SimpleModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.a_variable = tf.Variable(5.0, name="train_me")
self.non_trainable_variable = tf.Variable(5.0, trainable=False, name="do_not_train_me")
def __call__(self, x):
return self.a_variable * x + self.non_trainable_variable
simple_module = SimpleModule(name="simple")
simple_module(tf.constant(5.0))
<tf.Tensor: shape=(), dtype=float32, numpy=30.0>
Modul dan, dengan perluasan, lapisan adalah terminologi pembelajaran mendalam untuk "objek": mereka memiliki keadaan internal, dan metode yang menggunakan keadaan itu.
Tidak ada yang istimewa tentang __call__ kecuali untuk bertindak seperti panggilan Python ; Anda dapat memanggil model Anda dengan fungsi apa pun yang Anda inginkan.
Anda dapat mengaktifkan dan menonaktifkan kemampuan melatih variabel untuk alasan apa pun, termasuk membekukan lapisan dan variabel selama fine-tuning.
Dengan tf.Module , setiap tf.Variable atau tf.Module yang ditetapkan ke properti objek ini dikumpulkan secara otomatis. Ini memungkinkan Anda untuk menyimpan dan memuat variabel, dan juga membuat koleksi tf.Module s.
# All trainable variables
print("trainable variables:", simple_module.trainable_variables)
# Every variable
print("all variables:", simple_module.variables)
trainable variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>,) all variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>, <tf.Variable 'do_not_train_me:0' shape=() dtype=float32, numpy=5.0>) 2021-10-26 01:29:45.284549: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
Ini adalah contoh model lapisan linier dua lapis yang terbuat dari modul.
Pertama lapisan padat (linier):
class Dense(tf.Module):
def __init__(self, in_features, out_features, name=None):
super().__init__(name=name)
self.w = tf.Variable(
tf.random.normal([in_features, out_features]), name='w')
self.b = tf.Variable(tf.zeros([out_features]), name='b')
def __call__(self, x):
y = tf.matmul(x, self.w) + self.b
return tf.nn.relu(y)
Dan kemudian model lengkap, yang membuat dua contoh lapisan dan menerapkannya:
class SequentialModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.dense_1 = Dense(in_features=3, out_features=3)
self.dense_2 = Dense(in_features=3, out_features=2)
def __call__(self, x):
x = self.dense_1(x)
return self.dense_2(x)
# You have made a model!
my_model = SequentialModule(name="the_model")
# Call it, with random results
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[7.706234 3.0919805]], shape=(1, 2), dtype=float32)
tf.Module akan secara otomatis mengumpulkan, secara rekursif, setiap tf.Variable atau tf.Module yang ditetapkan padanya. Ini memungkinkan Anda untuk mengelola koleksi tf.Module s dengan satu contoh model, dan menyimpan serta memuat seluruh model.
print("Submodules:", my_model.submodules)
Submodules: (<__main__.Dense object at 0x7f7ab2391290>, <__main__.Dense object at 0x7f7b6869ea10>)
for var in my_model.variables:
print(var, "\n")
<tf.Variable 'b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>
<tf.Variable 'w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 0.05711935, 0.22440144, 0.6370985 ],
[ 0.3136791 , -1.7006774 , 0.7256515 ],
[ 0.16120772, -0.8412193 , 0.5250952 ]], dtype=float32)>
<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>
<tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=
array([[-0.5353216 , 1.2815404 ],
[ 0.62764466, 0.47087234],
[ 2.19187 , 0.45777202]], dtype=float32)>
Menunggu untuk membuat variabel
Anda mungkin telah memperhatikan di sini bahwa Anda harus menentukan ukuran input dan output ke layer. Ini agar variabel w memiliki bentuk yang diketahui dan dapat dialokasikan.
Dengan menunda pembuatan variabel ke pertama kali modul dipanggil dengan bentuk input tertentu, Anda tidak perlu menentukan ukuran input terlebih dahulu.
class FlexibleDenseModule(tf.Module):
# Note: No need for `in_features`
def __init__(self, out_features, name=None):
super().__init__(name=name)
self.is_built = False
self.out_features = out_features
def __call__(self, x):
# Create variables on first call.
if not self.is_built:
self.w = tf.Variable(
tf.random.normal([x.shape[-1], self.out_features]), name='w')
self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
self.is_built = True
y = tf.matmul(x, self.w) + self.b
return tf.nn.relu(y)
# Used in a module
class MySequentialModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.dense_1 = FlexibleDenseModule(out_features=3)
self.dense_2 = FlexibleDenseModule(out_features=2)
def __call__(self, x):
x = self.dense_1(x)
return self.dense_2(x)
my_model = MySequentialModule(name="the_model")
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[4.0598335 0. ]], shape=(1, 2), dtype=float32)
Fleksibilitas inilah yang menyebabkan lapisan TensorFlow sering kali hanya perlu menentukan bentuk outputnya, seperti di tf.keras.layers.Dense , daripada ukuran input dan output.
Menghemat beban
Anda dapat menyimpan tf.Module sebagai pos pemeriksaan dan SavedModel .
Pos pemeriksaan hanyalah bobot (yaitu, nilai himpunan variabel di dalam modul dan submodulnya):
chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
'my_checkpoint'
Pos pemeriksaan terdiri dari dua jenis file: data itu sendiri dan file indeks untuk metadata. File indeks melacak apa yang sebenarnya disimpan dan penomoran pos pemeriksaan, sedangkan data pos pemeriksaan berisi nilai variabel dan jalur pencarian atributnya.
ls my_checkpoint*
my_checkpoint.data-00000-of-00001 my_checkpoint.index
Anda dapat melihat ke dalam pos pemeriksaan untuk memastikan seluruh kumpulan variabel disimpan, diurutkan berdasarkan objek Python yang berisi variabel tersebut.
tf.train.list_variables(chkp_path)
[('_CHECKPOINTABLE_OBJECT_GRAPH', []),
('model/dense_1/b/.ATTRIBUTES/VARIABLE_VALUE', [3]),
('model/dense_1/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 3]),
('model/dense_2/b/.ATTRIBUTES/VARIABLE_VALUE', [2]),
('model/dense_2/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 2])]
Selama pelatihan terdistribusi (multi-mesin) mereka dapat di-sharding, itulah sebabnya mereka diberi nomor (misalnya, '00000-of-00001'). Namun, dalam kasus ini, hanya ada satu pecahan.
Saat Anda memuat kembali model, Anda menimpa nilai dalam objek Python Anda.
new_model = MySequentialModule()
new_checkpoint = tf.train.Checkpoint(model=new_model)
new_checkpoint.restore("my_checkpoint")
# Should be the same result as above
new_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[4.0598335, 0. ]], dtype=float32)>
Menyimpan fungsi
TensorFlow dapat menjalankan model tanpa objek Python asli, seperti yang ditunjukkan oleh TensorFlow Serving dan TensorFlow Lite , bahkan saat Anda mendownload model terlatih dari TensorFlow Hub .
TensorFlow perlu mengetahui cara melakukan komputasi yang dijelaskan dengan Python, tetapi tanpa kode aslinya . Untuk melakukan ini, Anda dapat membuat grafik , yang dijelaskan dalam panduan Pengenalan grafik dan fungsi .
Grafik ini berisi operasi, atau ops , yang mengimplementasikan fungsi tersebut.
Anda dapat mendefinisikan grafik dalam model di atas dengan menambahkan dekorator @tf.function untuk menunjukkan bahwa kode ini harus dijalankan sebagai grafik.
class MySequentialModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.dense_1 = Dense(in_features=3, out_features=3)
self.dense_2 = Dense(in_features=3, out_features=2)
@tf.function
def __call__(self, x):
x = self.dense_1(x)
return self.dense_2(x)
# You have made a model with a graph!
my_model = MySequentialModule(name="the_model")
Modul yang Anda buat bekerja persis sama seperti sebelumnya. Setiap tanda tangan unik yang diteruskan ke fungsi membuat grafik terpisah. Lihat panduan Pengantar grafik dan fungsi untuk detailnya.
print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0.62891716 0. ]], shape=(1, 2), dtype=float32) tf.Tensor( [[[0.62891716 0. ] [0.62891716 0. ]]], shape=(1, 2, 2), dtype=float32)
Anda dapat memvisualisasikan grafik dengan menelusurinya dalam ringkasan TensorBoard.
# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = "logs/func/%s" % stamp
writer = tf.summary.create_file_writer(logdir)
# Create a new model to get a fresh trace
# Otherwise the summary will not see the graph.
new_model = MySequentialModule()
# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True)
tf.profiler.experimental.start(logdir)
# Call only one tf.function when tracing.
z = print(new_model(tf.constant([[2.0, 2.0, 2.0]])))
with writer.as_default():
tf.summary.trace_export(
name="my_func_trace",
step=0,
profiler_outdir=logdir)
tf.Tensor([[0. 0.01750386]], shape=(1, 2), dtype=float32)
Luncurkan TensorBoard untuk melihat jejak yang dihasilkan:
#docs_infra: no_execute
%tensorboard --logdir logs/func
Membuat SavedModel
Cara yang disarankan untuk berbagi model yang sepenuhnya terlatih adalah dengan menggunakan SavedModel . SavedModel berisi kumpulan fungsi dan kumpulan bobot.
Anda dapat menyimpan model yang baru saja Anda latih sebagai berikut:
tf.saved_model.save(my_model, "the_saved_model")
INFO:tensorflow:Assets written to: the_saved_model/assets
# Inspect the SavedModel in the directoryls -l the_saved_model
total 24 drwxr-sr-x 2 kbuilder kokoro 4096 Oct 26 01:29 assets -rw-rw-r-- 1 kbuilder kokoro 14702 Oct 26 01:29 saved_model.pb drwxr-sr-x 2 kbuilder kokoro 4096 Oct 26 01:29 variables
# The variables/ directory contains a checkpoint of the variablesls -l the_saved_model/variables
total 8 -rw-rw-r-- 1 kbuilder kokoro 408 Oct 26 01:29 variables.data-00000-of-00001 -rw-rw-r-- 1 kbuilder kokoro 356 Oct 26 01:29 variables.index
File saved_model.pb adalah buffer protokol yang menjelaskan tf.Graph fungsional.
Model dan lapisan dapat dimuat dari representasi ini tanpa benar-benar membuat turunan dari kelas yang membuatnya. Ini diinginkan dalam situasi di mana Anda tidak memiliki (atau menginginkan) juru bahasa Python, seperti melayani dalam skala besar atau pada perangkat edge, atau dalam situasi di mana kode Python asli tidak tersedia atau praktis untuk digunakan.
Anda dapat memuat model sebagai objek baru:
new_model = tf.saved_model.load("the_saved_model")
new_model , dibuat dari memuat model yang disimpan, adalah objek pengguna TensorFlow internal tanpa pengetahuan kelas apa pun. Ini bukan tipe SequentialModule .
isinstance(new_model, SequentialModule)
False
Model baru ini bekerja pada input signature yang sudah ditentukan. Anda tidak dapat menambahkan lebih banyak tanda tangan ke model yang dipulihkan seperti ini.
print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0.62891716 0. ]], shape=(1, 2), dtype=float32) tf.Tensor( [[[0.62891716 0. ] [0.62891716 0. ]]], shape=(1, 2, 2), dtype=float32)
Jadi, dengan menggunakan SavedModel , Anda dapat menyimpan bobot dan grafik TensorFlow menggunakan tf.Module , lalu memuatnya kembali.
Model dan lapisan keras
Perhatikan bahwa sampai saat ini, tidak disebutkan tentang Keras. Anda dapat membangun API tingkat tinggi Anda sendiri di atas tf.Module , dan orang-orang telah melakukannya.
Di bagian ini, Anda akan memeriksa bagaimana Keras menggunakan tf.Module . Panduan pengguna lengkap untuk model Keras dapat ditemukan di panduan Keras .
Lapisan Keras
tf.keras.layers.Layer adalah kelas dasar dari semua lapisan Keras, dan diwarisi dari tf.Module .
Anda dapat mengonversi modul menjadi lapisan Keras hanya dengan menukar induknya dan kemudian mengubah __call__ menjadi call :
class MyDense(tf.keras.layers.Layer):
# Adding **kwargs to support base Keras layer arguments
def __init__(self, in_features, out_features, **kwargs):
super().__init__(**kwargs)
# This will soon move to the build step; see below
self.w = tf.Variable(
tf.random.normal([in_features, out_features]), name='w')
self.b = tf.Variable(tf.zeros([out_features]), name='b')
def call(self, x):
y = tf.matmul(x, self.w) + self.b
return tf.nn.relu(y)
simple_layer = MyDense(name="simple", in_features=3, out_features=3)
Lapisan keras memiliki __call__ mereka sendiri yang melakukan beberapa pembukuan yang dijelaskan di bagian selanjutnya dan kemudian memanggil call() . Anda seharusnya tidak melihat adanya perubahan fungsi.
simple_layer([[2.0, 2.0, 2.0]])
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[0. , 0.179402, 0. ]], dtype=float32)>
Langkah build
Sebagaimana dicatat, dalam banyak kasus akan lebih mudah untuk menunggu membuat variabel sampai Anda yakin dengan bentuk inputnya.
Lapisan keras hadir dengan langkah siklus hidup ekstra yang memungkinkan Anda lebih fleksibel dalam menentukan lapisan Anda. Ini didefinisikan dalam fungsi build .
build dipanggil tepat satu kali, dan dipanggil dengan bentuk input. Biasanya digunakan untuk membuat variabel (bobot).
Anda dapat menulis ulang lapisan MyDense di atas agar fleksibel dengan ukuran inputnya:
class FlexibleDense(tf.keras.layers.Layer):
# Note the added `**kwargs`, as Keras supports many arguments
def __init__(self, out_features, **kwargs):
super().__init__(**kwargs)
self.out_features = out_features
def build(self, input_shape): # Create the state of the layer (weights)
self.w = tf.Variable(
tf.random.normal([input_shape[-1], self.out_features]), name='w')
self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
def call(self, inputs): # Defines the computation from inputs to outputs
return tf.matmul(inputs, self.w) + self.b
# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)
Pada titik ini, model belum dibangun, jadi tidak ada variabel:
flexible_dense.variables
[]
Memanggil fungsi mengalokasikan variabel berukuran tepat:
# Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))
Model results: tf.Tensor( [[-1.6998017 1.6444504 -1.3103955] [-2.5497022 2.4666753 -1.9655929]], shape=(2, 3), dtype=float32)
flexible_dense.variables
[<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 1.277462 , 0.5399406 , -0.301957 ],
[-1.6277349 , 0.7374014 , -1.7651852 ],
[-0.49962795, -0.45511687, 1.4119445 ]], dtype=float32)>,
<tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]
Karena build hanya dipanggil sekali, input akan ditolak jika bentuk input tidak kompatibel dengan variabel layer:
try:
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
print("Failed:", e)
Failed: In[0] mismatch In[1] shape: 4 vs. 3: [1,4] [3,3] 0 0 [Op:MatMul]
Lapisan keras memiliki lebih banyak fitur tambahan termasuk:
- Kerugian opsional
- Dukungan untuk metrik
- Dukungan bawaan untuk argumen
trainingopsional untuk membedakan antara penggunaan pelatihan dan inferensi -
get_configdanfrom_configmetode yang memungkinkan Anda menyimpan konfigurasi secara akurat untuk memungkinkan kloning model dengan Python
Baca tentang mereka di panduan lengkap untuk lapisan dan model khusus.
Model Keras
Anda dapat mendefinisikan model Anda sebagai lapisan Keras bersarang.
Namun, Keras juga menyediakan kelas model berfitur lengkap yang disebut tf.keras.Model . Ini mewarisi dari tf.keras.layers.Layer , sehingga model Keras dapat digunakan, disarangkan, dan disimpan dengan cara yang sama seperti lapisan Keras. Model Keras hadir dengan fungsionalitas ekstra yang membuatnya mudah untuk dilatih, dievaluasi, dimuat, disimpan, dan bahkan dilatih di banyak mesin.
Anda dapat mendefinisikan SequentialModule dari atas dengan kode yang hampir identik, sekali lagi mengonversi __call__ menjadi call() dan mengubah induknya:
class MySequentialModel(tf.keras.Model):
def __init__(self, name=None, **kwargs):
super().__init__(**kwargs)
self.dense_1 = FlexibleDense(out_features=3)
self.dense_2 = FlexibleDense(out_features=2)
def call(self, x):
x = self.dense_1(x)
return self.dense_2(x)
# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")
# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[5.5604653 3.3511646]], shape=(1, 2), dtype=float32)
Semua fitur yang sama tersedia, termasuk variabel pelacakan dan submodul.
my_sequential_model.variables
[<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 0.05627853, -0.9386015 , -0.77410126],
[ 0.63149 , 1.0802224 , -0.37785745],
[-0.24788402, -1.1076807 , -0.5956209 ]], dtype=float32)>,
<tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
<tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
array([[-0.93912166, 0.77979285],
[ 1.4049559 , -1.9380962 ],
[-2.6039495 , 0.30885765]], dtype=float32)>,
<tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]
my_sequential_model.submodules
(<__main__.FlexibleDense at 0x7f7b48525550>, <__main__.FlexibleDense at 0x7f7b48508d10>)
tf.keras.Model adalah pendekatan yang sangat Pythonic untuk membuat model TensorFlow. Jika Anda memigrasi model dari kerangka kerja lain, ini bisa sangat mudah.
Jika Anda membuat model yang merupakan kumpulan sederhana dari lapisan dan input yang ada, Anda dapat menghemat waktu dan ruang dengan menggunakan API fungsional , yang dilengkapi dengan fitur tambahan seputar rekonstruksi dan arsitektur model.
Berikut adalah model yang sama dengan API fungsional:
inputs = tf.keras.Input(shape=[3,])
x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)
my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)
my_functional_model.summary()
Model: "model" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 3)] 0 _________________________________________________________________ flexible_dense_3 (FlexibleDe (None, 3) 12 _________________________________________________________________ flexible_dense_4 (FlexibleDe (None, 2) 8 ================================================================= Total params: 20 Trainable params: 20 Non-trainable params: 0 _________________________________________________________________
my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[8.219393, 4.511119]], dtype=float32)>
Perbedaan utama di sini adalah bahwa bentuk input ditentukan di depan sebagai bagian dari proses konstruksi fungsional. Argumen input_shape dalam hal ini tidak harus sepenuhnya ditentukan; Anda dapat meninggalkan beberapa dimensi sebagai None .
Menyimpan model Keras
Model keras dapat dicentang, dan itu akan terlihat sama dengan tf.Module .
Model keras juga dapat disimpan dengan tf.saved_model.save() , karena mereka adalah modul. Namun, model Keras memiliki metode kenyamanan dan fungsi lainnya:
my_sequential_model.save("exname_of_file")
INFO:tensorflow:Assets written to: exname_of_file/assets
Sama mudahnya, mereka dapat dimuat kembali:
reconstructed_model = tf.keras.models.load_model("exname_of_file")
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Keras SavedModels juga menyimpan status metrik, kehilangan, dan pengoptimal.
Model yang direkonstruksi ini dapat digunakan dan akan menghasilkan hasil yang sama ketika dipanggil pada data yang sama:
reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[5.5604653, 3.3511646]], dtype=float32)>
Ada lebih banyak yang perlu diketahui tentang penyimpanan dan serialisasi model Keras, termasuk menyediakan metode konfigurasi untuk lapisan khusus untuk dukungan fitur. Lihat panduan untuk menyimpan dan serialisasi .
Apa berikutnya
Jika Anda ingin mengetahui lebih detail tentang Keras, Anda dapat mengikuti panduan Keras yang ada di sini .
Contoh lain dari API tingkat tinggi yang dibangun di atas tf.module adalah Soneta dari DeepMind, yang tercakup di situs mereka .