Google I/O bir tamamlamadır! TensorFlow oturumlarını takip edin Oturumları görüntüleyin

Modüllere, katmanlara ve modellere giriş

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))
tutucu2 l10n-yer
<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)
tutucu4 l10n-yer
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]])))
tutucu7 l10n-yer
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]])))
-yer tutucu14 l10n-yer
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)
tutucu16 l10n-yer
'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-yer
my_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)
tutucu20 l10n-yer
[('_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]]))
tutucu22 l10n-yer
<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]]]))
tutucu25 l10n-yer
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)
tutucu27 l10n-yer
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

TensorBoard'daki grafiğin ekran görüntüsü

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 directory
ls -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 variables
ls -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)
tutucu37 l10n-yer
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]]]))
tutucu39 l10n-yer
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]])
tutucu42 l10n-yer
<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
tutucu45 l10n-yer
[]

İş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)
tutucu51 l10n-yer
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 training argü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_config ve from_config yö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]])))
tutucu53 l10n-yer
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-yer
my_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")
tutucu63 l10n-yer
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")
tutucu65 l10n-yer
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]]))
tutucu67 l10n-yer
<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.