 TensorFlow.org'da görüntüleyin |  Google Colab'da çalıştırın |  Kaynağı GitHub'da görüntüleyin |  Not defterini indir |
TensorFlow'da makine öğrenimi yapmak için büyük olasılıkla bir model tanımlamanız, kaydetmeniz ve geri yüklemeniz gerekir.
Bir model, soyut olarak:
- Tensörler üzerinde bir şey hesaplayan bir işlev ( ileri bir geçiş )
- Eğitime yanıt olarak güncellenebilen bazı değişkenler
Bu kılavuzda, TensorFlow modellerinin nasıl tanımlandığını görmek için Keras yüzeyinin altına ineceksiniz. Bu, TensorFlow'un değişkenleri ve modelleri nasıl topladığına ve bunların nasıl kaydedilip geri yüklendiğine bakar.
Kurmak
import tensorflow as tf
from datetime import datetime
%load_ext tensorboard
TensorFlow'da modelleri ve katmanları tanımlama
Çoğu model katmanlardan yapılmıştır. Katmanlar, yeniden kullanılabilen ve eğitilebilir değişkenlere sahip, bilinen bir matematiksel yapıya sahip fonksiyonlardır. TensorFlow'da, Keras veya Sonnet gibi katmanların ve modellerin çoğu üst düzey uygulaması aynı temel sınıf üzerinde oluşturulur: tf.Module .
İşte bir skaler tensör üzerinde çalışan çok basit bir tf.Module örneği:
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>
Modüller ve buna bağlı olarak katmanlar, "nesneler" için derin öğrenme terminolojisidir: dahili durumları ve bu durumu kullanan yöntemleri vardır.
__call__ ile ilgili bir Python çağrılabilir gibi davranmaktan başka özel bir şey yoktur; modellerinizi dilediğiniz fonksiyonla çağırabilirsiniz.
İnce ayar sırasında katmanları ve değişkenleri dondurma dahil olmak üzere herhangi bir nedenle değişkenlerin eğitilebilirliğini açıp kapatabilirsiniz.
tf.Module alt sınıflandırılarak, bu nesnenin özelliklerine atanan tüm tf.Variable veya tf.Module örnekleri otomatik olarak toplanır. Bu, değişkenleri kaydetmenize ve yüklemenize ve ayrıca tf.Module s koleksiyonları oluşturmanıza olanak tanır.
# 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.
Bu, modüllerden yapılmış iki katmanlı doğrusal katman modelinin bir örneğidir.
İlk önce yoğun (doğrusal) bir katman:
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)
Ardından, iki katman örneği oluşturan ve bunları uygulayan tam model:
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 örnekleri, kendisine atanan tüm tf.Variable veya tf.Module örneklerini yinelemeli olarak otomatik olarak toplayacaktır. Bu, tek bir model örneğiyle tf.Module s koleksiyonlarını yönetmenize ve tüm modelleri kaydetmenize ve yüklemenize olanak tanır.
print("Submodules:", my_model.submodules)
Submodules: (<__main__.Dense object at 0x7f7ab2391290>, <__main__.Dense object at 0x7f7b6869ea10>)yer tutucu10 l10n-yer
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)>
Değişkenler oluşturmak için bekleniyor
Burada, katmana hem girdi hem de çıktı boyutlarını tanımlamanız gerektiğini fark etmiş olabilirsiniz. Bu, w değişkeninin bilinen bir şekle sahip olması ve tahsis edilebilmesi içindir.
Değişken oluşturmayı, modülün belirli bir giriş şekliyle ilk kez çağrılmasına erteleyerek, giriş boyutunu önceden belirtmeniz gerekmez.
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)
Bu esneklik, TensorFlow katmanlarının genellikle hem girdi hem de çıktı boyutundan ziyade tf.keras.layers.Dense olduğu gibi çıktılarının şeklini belirtmesinin gerekmesinin nedenidir.
Ağırlık tasarrufu
Bir tf.Module hem kontrol noktası hem de SavedModel olarak kaydedebilirsiniz.
Kontrol noktaları yalnızca ağırlıklardır (yani, modül ve alt modülleri içindeki değişkenler kümesinin değerleri):
chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
'my_checkpoint'
Kontrol noktaları iki tür dosyadan oluşur: verilerin kendisi ve meta veriler için bir dizin dosyası. İndeks dosyası, gerçekte neyin kaydedildiğini ve kontrol noktalarının numaralandırılmasını takip ederken, kontrol noktası verileri, değişken değerleri ve bunların öznitelik arama yollarını içerir.
ls my_checkpoint*
tutucu18 l10n-yermy_checkpoint.data-00000-of-00001 my_checkpoint.index
Tüm değişkenler koleksiyonunun kaydedildiğinden ve bunları içeren Python nesnesine göre sıralandığından emin olmak için bir kontrol noktasının içine bakabilirsiniz.
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])]
Dağıtılmış (çoklu makine) eğitimi sırasında parçalanabilirler, bu nedenle numaralandırılırlar (örneğin, '00000-of-00001'). Bu durumda olsa da, sadece bir parça var.
Modelleri tekrar yüklediğinizde Python nesnenizdeki değerlerin üzerine yazarsınız.
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)>
Fonksiyonları kaydetme
TensorFlow, TensorFlow Hub'dan eğitimli bir model indirdiğinizde bile, TensorFlow Serving ve TensorFlow Lite tarafından gösterildiği gibi, orijinal Python nesneleri olmadan modelleri çalıştırabilir.
TensorFlow'un Python'da açıklanan hesaplamaları nasıl yapacağını bilmesi gerekir, ancak orijinal kod olmadan . Bunu yapmak için , Grafiklere ve işlevlere giriş kılavuzunda açıklanan bir grafik oluşturabilirsiniz.
Bu grafik , işlevi uygulayan işlemleri veya işlemleri içerir.
Bu kodun grafik olarak çalışması gerektiğini belirtmek için @tf.function dekoratörü ekleyerek yukarıdaki modelde bir grafik tanımlayabilirsiniz.
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")
Yaptığınız modül tam olarak eskisi gibi çalışıyor. İşleve iletilen her benzersiz imza, ayrı bir grafik oluşturur. Ayrıntılar için Grafiklere ve işlevlere giriş kılavuzuna bakın.
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)
Grafiği bir TensorBoard özeti içinde izleyerek görselleştirebilirsiniz.
# 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)
Ortaya çıkan izi görüntülemek için TensorBoard'u başlatın:
#docs_infra: no_execute
%tensorboard --logdir logs/func
SavedModel Oluşturma
Tamamen eğitilmiş modelleri paylaşmanın önerilen yolu SavedModel kullanmaktır. SavedModel , hem işlevler koleksiyonu hem de ağırlıklar koleksiyonu içerir.
Az önce eğittiğiniz modeli aşağıdaki gibi kaydedebilirsiniz:
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
saved_model.pb dosyası, işlevsel tf.Graph açıklayan bir protokol arabelleğidir .
Modeller ve katmanlar, onu oluşturan sınıfın bir örneğini oluşturmadan bu temsilden yüklenebilir. Ölçekte veya uç cihazda hizmet vermek gibi bir Python yorumlayıcıya sahip olmadığınız (veya istemediğiniz) durumlarda veya orijinal Python kodunun mevcut olmadığı veya kullanımının pratik olmadığı durumlarda bu arzu edilir.
Modeli yeni nesne olarak yükleyebilirsiniz:
new_model = tf.saved_model.load("the_saved_model")
Kaydedilmiş bir modelin yüklenmesinden oluşturulan new_model , herhangi bir sınıf bilgisi olmadan dahili bir TensorFlow kullanıcı nesnesidir. SequentialModule türünde değil.
isinstance(new_model, SequentialModule)
False
Bu yeni model, önceden tanımlanmış giriş imzaları üzerinde çalışır. Bu şekilde geri yüklenen bir modele daha fazla imza ekleyemezsiniz.
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)
Böylece SavedModel kullanarak SavedModel ağırlıklarını ve grafiklerini tf.Module kullanarak kaydedebilir ve ardından yeniden yükleyebilirsiniz.
Keras modelleri ve katmanları
Bu noktaya kadar Keras'tan bahsedilmediğini unutmayın. Kendi üst düzey tf.Module üzerine oluşturabilirsiniz ve insanlar buna sahiptir.
Bu bölümde tf.Module nasıl kullandığını inceleyeceksiniz. Keras modellerine ilişkin eksiksiz bir kullanıcı kılavuzu Keras kılavuzunda bulunabilir.
Keras katmanları
tf.keras.layers.Layer , tüm Keras katmanlarının temel sınıfıdır ve tf.Module miras alır.
Yalnızca üst öğeyi değiştirerek ve ardından __call__ call olarak değiştirerek bir modülü Keras katmanına dönüştürebilirsiniz:
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)
Keras katmanlarının, bir sonraki bölümde açıklanan bazı muhasebe işlemlerini yapan ve ardından call() öğesini çağıran kendi __call__ vardır. İşlevsellikte herhangi bir değişiklik fark etmemelisiniz.
simple_layer([[2.0, 2.0, 2.0]])
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[0. , 0.179402, 0. ]], dtype=float32)>
build adımı
Belirtildiği gibi, birçok durumda girdi şeklinden emin olana kadar değişkenler oluşturmak için beklemek uygundur.
Keras katmanları, katmanlarınızı nasıl tanımladığınız konusunda size daha fazla esneklik sağlayan ekstra bir yaşam döngüsü adımıyla birlikte gelir. Bu, build işlevinde tanımlanır.
build tam olarak bir kez çağrılır ve girdinin şekli ile çağrılır. Genellikle değişkenler (ağırlıklar) oluşturmak için kullanılır.
Girişlerinin boyutuna göre esnek olması için yukarıdaki MyDense katmanını yeniden yazabilirsiniz:
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)
Bu noktada model oluşturulmamıştır, dolayısıyla değişken yoktur:
flexible_dense.variables
[]
İşlevi çağırmak, uygun büyüklükteki değişkenleri tahsis eder:
# 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)yer tutucu48 l10n-yer
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)>]
build yalnızca bir kez çağrıldığından, girdi şekli katmanın değişkenleriyle uyumlu değilse girdiler reddedilecektir:
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]
Keras katmanları, aşağıdakiler de dahil olmak üzere çok daha fazla ekstra özelliğe sahiptir:
- Opsiyonel kayıplar
- Metrikler için destek
- Eğitim ve çıkarım kullanımı arasında ayrım yapmak için isteğe bağlı bir
trainingargümanı için yerleşik destek - Python'da model klonlamaya izin vermek için konfigürasyonları doğru bir şekilde saklamanıza izin veren
get_configvefrom_configyöntemleri
Özel katmanlar ve modeller için tam kılavuzda bunlar hakkında bilgi edinin.
Keras modelleri
Modelinizi iç içe Keras katmanları olarak tanımlayabilirsiniz.
Ancak Keras, tf.keras.Model adlı tam özellikli bir model sınıfı da sağlar. tf.keras.layers.Layer devralır, böylece bir Keras modeli kullanılabilir, iç içe yerleştirilebilir ve Keras katmanlarıyla aynı şekilde kaydedilebilir. Keras modelleri, birden fazla makinede eğitmeyi, değerlendirmeyi, yüklemeyi, kaydetmeyi ve hatta eğitmeyi kolaylaştıran ekstra işlevsellik ile birlikte gelir.
SequentialModule yukarıdan hemen hemen aynı kodla tanımlayabilir, yine __call__ call() 'a dönüştürebilir ve üst öğeyi değiştirebilirsiniz:
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)
İzleme değişkenleri ve alt modüller dahil tüm aynı özellikler mevcuttur.
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)>]
yer tutucu56 l10n-yermy_sequential_model.submodules
(<__main__.FlexibleDense at 0x7f7b48525550>, <__main__.FlexibleDense at 0x7f7b48508d10>)
tf.keras.Model geçersiz kılmak, TensorFlow modelleri oluşturmaya yönelik oldukça Pythonic bir yaklaşımdır. Modelleri diğer çerçevelerden taşıyorsanız, bu çok basit olabilir.
Mevcut katmanların ve girdilerin basit birleşimleri olan modeller oluşturuyorsanız, model yeniden yapılandırması ve mimarisiyle ilgili ek özelliklerle birlikte gelen işlevsel API'yi kullanarak zamandan ve yerden tasarruf edebilirsiniz.
İşlevsel API ile aynı model:
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 _________________________________________________________________yer tutucu60 l10n-yer
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)>
Buradaki en büyük fark, girdi şeklinin işlevsel yapım sürecinin bir parçası olarak önceden belirlenmiş olmasıdır. Bu durumda input_shape bağımsız değişkeninin tamamen belirtilmesi gerekmez; bazı boyutları None olarak bırakabilirsiniz.
Keras modellerini kaydetme
Keras modelleri kontrol noktası olabilir ve bu tf.Module ile aynı görünecektir.
Keras modelleri modül oldukları için tf.saved_model.save() ile de kaydedilebilir. Ancak, Keras modellerinin kolaylık yöntemleri ve diğer işlevleri vardır:
my_sequential_model.save("exname_of_file")
INFO:tensorflow:Assets written to: exname_of_file/assets
Aynı kolaylıkla tekrar yüklenebilirler:
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.
SavedModels ayrıca metrik, kayıp ve optimize edici durumlarını da kaydeder.
Bu yeniden yapılandırılmış model kullanılabilir ve aynı veriler üzerinde çağrıldığında aynı sonucu verir:
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)>
Özellik desteği için özel katmanlar için yapılandırma yöntemleri sağlamak da dahil olmak üzere Keras modellerinin kaydedilmesi ve serileştirilmesi hakkında bilinmesi gereken daha çok şey vardır. Kaydetme ve serileştirme kılavuzuna göz atın.
Sıradaki ne
Keras hakkında daha fazla bilgi edinmek istiyorsanız, mevcut Keras kılavuzlarını buradan takip edebilirsiniz.
tf.module üzerine kurulu bir üst düzey API'ye başka bir örnek, sitelerinde ele alınan DeepMind'den Sonnet'tir.