Alt sınıflama yoluyla yeni Katmanlar ve Modeller oluşturma

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

Kurmak

import tensorflow as tf
from tensorflow import keras

Layer sınıfı: durumu (ağırlıklar) kombinasyonu ve bir hesaplama

Keras merkezi soyutlama biri Layer sınıfı. Bir katman hem bir durumu (katmanın "ağırlıkları") hem de girdilerden çıktılara bir dönüşümü ("çağrı", katmanın ileri geçişi) kapsar.

İşte yoğun bağlantılı bir katman. Değişkenler: Bu durumu vardır w ve b .

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super(Linear, self).__init__()
        w_init = tf.random_normal_initializer()
        self.w = tf.Variable(
            initial_value=w_init(shape=(input_dim, units), dtype="float32"),
            trainable=True,
        )
        b_init = tf.zeros_initializer()
        self.b = tf.Variable(
            initial_value=b_init(shape=(units,), dtype="float32"), trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

Bir Python işlevi gibi, bazı tensör girişlerinde çağırarak bir katman kullanırsınız.

x = tf.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)
tf.Tensor(
[[ 0.03029768 -0.05972501  0.00586849 -0.1109921 ]
 [ 0.03029768 -0.05972501  0.00586849 -0.1109921 ]], shape=(2, 4), dtype=float32)

Ağırlıklar bu Not w ve b otomatik tabaka özellikler olarak ayarlandıktan sonra tabaka ile takip edilir:

assert linear_layer.weights == [linear_layer.w, linear_layer.b]

: Ayrıca bir katmana ağırlık eklemek için hızlı bir kısayol erişimi Not add_weight() yöntemi:

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super(Linear, self).__init__()
        self.w = self.add_weight(
            shape=(input_dim, units), initializer="random_normal", trainable=True
        )
        self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b


x = tf.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)
tf.Tensor(
[[ 0.05004499  0.01081884 -0.12212791  0.01023131]
 [ 0.05004499  0.01081884 -0.12212791  0.01023131]], shape=(2, 4), dtype=float32)

Katmanlar eğitilemez ağırlıklara sahip olabilir

Eğitilebilir ağırlıkların yanı sıra, bir katmana eğitilemez ağırlıklar da ekleyebilirsiniz. Bu tür ağırlıklar, katmanı eğitirken geri yayılım sırasında dikkate alınmamalıdır.

Eğitilebilir olmayan bir ağırlığı nasıl ekleyeceğiniz ve kullanacağınız aşağıda açıklanmıştır:

class ComputeSum(keras.layers.Layer):
    def __init__(self, input_dim):
        super(ComputeSum, self).__init__()
        self.total = tf.Variable(initial_value=tf.zeros((input_dim,)), trainable=False)

    def call(self, inputs):
        self.total.assign_add(tf.reduce_sum(inputs, axis=0))
        return self.total


x = tf.ones((2, 2))
my_sum = ComputeSum(2)
y = my_sum(x)
print(y.numpy())
y = my_sum(x)
print(y.numpy())
[2. 2.]
[4. 4.]

Bu bir parçası layer.weights ama olmayan bir eğitilebilir ağırlık olarak sınıflandırılan:

print("weights:", len(my_sum.weights))
print("non-trainable weights:", len(my_sum.non_trainable_weights))

# It's not included in the trainable weights:
print("trainable_weights:", my_sum.trainable_weights)
weights: 1
non-trainable weights: 1
trainable_weights: []

En iyi uygulama: girdilerin şekli bilinene kadar ağırlık oluşturmayı ertelemek

Bizim Linear tabaka üzerinde bir aldı input_dim ağırlıkları şeklini hesaplamak için kullanılmıştır bağımsız değişken w ve b olarak __init__() :

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super(Linear, self).__init__()
        self.w = self.add_weight(
            shape=(input_dim, units), initializer="random_normal", trainable=True
        )
        self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

Çoğu durumda, girdilerinizin boyutunu önceden bilemeyebilirsiniz ve bu değer bilindiğinde, katmanı somutlaştırdıktan bir süre sonra tembelce ağırlıklar oluşturmak istersiniz.

Keras API, biz katman ağırlıkları oluşturmaya tavsiye build(self, inputs_shape) katmanınıza yöntemi. Bunun gibi:

class Linear(keras.layers.Layer):
    def __init__(self, units=32):
        super(Linear, self).__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

__call__() katmanınıza yöntemi otomatik build denir ilk kez çalışır. Artık tembel ve dolayısıyla kullanımı daha kolay bir katmanınız var:

# At instantiation, we don't know on what inputs this is going to get called
linear_layer = Linear(32)

# The layer's weights are created dynamically the first time the layer is called
y = linear_layer(x)

Katmanlar yinelemeli olarak birleştirilebilir

Bir Katman örneğini başka bir Katmanın özelliği olarak atarsanız, dış katman, iç katmanın ağırlıklarını izlemeye başlar.

Biz bu tür alt katmanlar oluşturarak tavsiye __init__() (alt katmanları tipik bir yapı yöntemine sahip olacağından, bunlar dış katman inşa aldığında inşa edilecek) yöntemini.

# Let's assume we are reusing the Linear class
# with a `build` method that we defined above.


class MLPBlock(keras.layers.Layer):
    def __init__(self):
        super(MLPBlock, self).__init__()
        self.linear_1 = Linear(32)
        self.linear_2 = Linear(32)
        self.linear_3 = Linear(1)

    def call(self, inputs):
        x = self.linear_1(inputs)
        x = tf.nn.relu(x)
        x = self.linear_2(x)
        x = tf.nn.relu(x)
        return self.linear_3(x)


mlp = MLPBlock()
y = mlp(tf.ones(shape=(3, 64)))  # The first call to the `mlp` will create the weights
print("weights:", len(mlp.weights))
print("trainable weights:", len(mlp.trainable_weights))
weights: 6
trainable weights: 6

add_loss() metodu

Yazarken call() bir katmanın yöntemini, size eğitim döngü yazarken daha sonra kullanmak istediğiniz edeceği kaybı tensörleri oluşturabilir. Bu arayarak yapılabilir olduğunu self.add_loss(value) :

# A layer that creates an activity regularization loss
class ActivityRegularizationLayer(keras.layers.Layer):
    def __init__(self, rate=1e-2):
        super(ActivityRegularizationLayer, self).__init__()
        self.rate = rate

    def call(self, inputs):
        self.add_loss(self.rate * tf.reduce_sum(inputs))
        return inputs

(Herhangi bir iç tabaka ile oluşturulanlar dahil olmak üzere), bu kayıplar ile alınabilir layer.losses . Bu özellik her başlangıcında sıfırlanır __call__() böylece, üst düzey katmana layer.losses daima son ileriye geçiş sırasında oluşturulan kayıp değerleri içerir.

class OuterLayer(keras.layers.Layer):
    def __init__(self):
        super(OuterLayer, self).__init__()
        self.activity_reg = ActivityRegularizationLayer(1e-2)

    def call(self, inputs):
        return self.activity_reg(inputs)


layer = OuterLayer()
assert len(layer.losses) == 0  # No losses yet since the layer has never been called

_ = layer(tf.zeros(1, 1))
assert len(layer.losses) == 1  # We created one loss value

# `layer.losses` gets reset at the start of each __call__
_ = layer(tf.zeros(1, 1))
assert len(layer.losses) == 1  # This is the loss created during the call above

Buna ek olarak, loss özelliği de bir iç katmanın ağırlıkları için oluşturulan düzenlilestirme kayıplarını içerir:

class OuterLayerWithKernelRegularizer(keras.layers.Layer):
    def __init__(self):
        super(OuterLayerWithKernelRegularizer, self).__init__()
        self.dense = keras.layers.Dense(
            32, kernel_regularizer=tf.keras.regularizers.l2(1e-3)
        )

    def call(self, inputs):
        return self.dense(inputs)


layer = OuterLayerWithKernelRegularizer()
_ = layer(tf.zeros((1, 1)))

# This is `1e-3 * sum(layer.dense.kernel ** 2)`,
# created by the `kernel_regularizer` above.
print(layer.losses)
[<tf.Tensor: shape=(), dtype=float32, numpy=0.0016696099>]

Bu kayıplar, aşağıdaki gibi eğitim döngüleri yazılırken dikkate alınmalıdır:

# Instantiate an optimizer.
optimizer = tf.keras.optimizers.SGD(learning_rate=1e-3)
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# Iterate over the batches of a dataset.
for x_batch_train, y_batch_train in train_dataset:
  with tf.GradientTape() as tape:
    logits = layer(x_batch_train)  # Logits for this minibatch
    # Loss value for this minibatch
    loss_value = loss_fn(y_batch_train, logits)
    # Add extra losses created during this forward pass:
    loss_value += sum(model.losses)

  grads = tape.gradient(loss_value, model.trainable_weights)
  optimizer.apply_gradients(zip(grads, model.trainable_weights))

Eğitim döngüler yazma konusunda detaylı bir kılavuz için, bkz sıfırdan bir eğitim döngü yazma kılavuzuna .

Bu kayıplar da ile sorunsuz çalışacak fit() (varsa bunlar otomatik ana kaybına toplanır ve ekledi olsun):

import numpy as np

inputs = keras.Input(shape=(3,))
outputs = ActivityRegularizationLayer()(inputs)
model = keras.Model(inputs, outputs)

# If there is a loss passed in `compile`, the regularization
# losses get added to it
model.compile(optimizer="adam", loss="mse")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))

# It's also possible not to pass any loss in `compile`,
# since the model already has a loss to minimize, via the `add_loss`
# call during the forward pass!
model.compile(optimizer="adam")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))
1/1 [==============================] - 0s 103ms/step - loss: 0.3750
1/1 [==============================] - 0s 44ms/step - loss: 0.0230
<keras.callbacks.History at 0x7fd0f80b3290>

add_metric() metodu

Benzer için add_loss() , tabakalar da bir bilgisi add_metric() eğitimi sırasında bir miktar hareketli ortalama izleme için bir yöntem.

Şu katmanı göz önünde bulundurun: bir "lojistik uç nokta" katmanı. Girişler tahminler & hedefler, bunun aracılığıyla izleyen bir kayıp hesaplar gibi sürer add_loss() ve bunun aracılığıyla izleyen bir doğruluk sayıl, hesaplar add_metric() .

class LogisticEndpoint(keras.layers.Layer):
    def __init__(self, name=None):
        super(LogisticEndpoint, self).__init__(name=name)
        self.loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
        self.accuracy_fn = keras.metrics.BinaryAccuracy()

    def call(self, targets, logits, sample_weights=None):
        # Compute the training-time loss value and add it
        # to the layer using `self.add_loss()`.
        loss = self.loss_fn(targets, logits, sample_weights)
        self.add_loss(loss)

        # Log accuracy as a metric and add it
        # to the layer using `self.add_metric()`.
        acc = self.accuracy_fn(targets, logits, sample_weights)
        self.add_metric(acc, name="accuracy")

        # Return the inference-time prediction tensor (for `.predict()`).
        return tf.nn.softmax(logits)

Bu şekilde takip Metrik yoluyla erişilebilir layer.metrics :

layer = LogisticEndpoint()

targets = tf.ones((2, 2))
logits = tf.ones((2, 2))
y = layer(targets, logits)

print("layer.metrics:", layer.metrics)
print("current accuracy value:", float(layer.metrics[0].result()))
layer.metrics: [<keras.metrics.BinaryAccuracy object at 0x7fd1b0214810>]
current accuracy value: 1.0

Sadece için benzeri add_loss() bu ölçümler tarafından izlenir fit() :

inputs = keras.Input(shape=(3,), name="inputs")
targets = keras.Input(shape=(10,), name="targets")
logits = keras.layers.Dense(10)(inputs)
predictions = LogisticEndpoint(name="predictions")(logits, targets)

model = keras.Model(inputs=[inputs, targets], outputs=predictions)
model.compile(optimizer="adam")

data = {
    "inputs": np.random.random((3, 3)),
    "targets": np.random.random((3, 10)),
}
model.fit(data)
1/1 [==============================] - 0s 242ms/step - loss: 0.9954 - binary_accuracy: 0.0000e+00
<keras.callbacks.History at 0x7fd0f80b3110>

İsteğe bağlı olarak katmanlarınızda serileştirmeyi etkinleştirebilirsiniz

Eğer bir parçası olarak seri hale getirilebilir olması için özel katmanlar gerekiyorsa Fonksiyonel modelin , isteğe bağlı olarak bir uygulayabilirsiniz get_config() yöntemini:

class Linear(keras.layers.Layer):
    def __init__(self, units=32):
        super(Linear, self).__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        return {"units": self.units}


# Now you can recreate the layer from its config:
layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)
{'units': 64}

O Not __init__() baz yöntemi Layer sınıfında özellikle bir de, bazı anahtar kelime argüman alır name ve dtype . Bu içinde üst sınıfa bu argümanları geçmek iyi bir uygulamadır __init__() ve katman config dahil etmek:

class Linear(keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super(Linear, self).__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super(Linear, self).get_config()
        config.update({"units": self.units})
        return config


layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)
{'name': 'linear_8', 'trainable': True, 'dtype': 'float32', 'units': 64}

Onun yapılandırmasındaki tabakasını deserializing yaparken daha fazla esneklik gerekiyorsa, ayrıca geçersiz kılabilir from_config() sınıfı yöntemini. Bu taban uygulamasıdır from_config() :

def from_config(cls, config):
  return cls(**config)

Serileştirme ve kaydetme hakkında daha fazla bilgi edinmek için komple bkz tasarrufu ve modelleri seri için rehber .

İmtiyazlı training içinde argüman call() yöntemiyle

Bazı katmanlar, özellikle BatchNormalization katmanı ve Dropout tabakası, eğitim ve çıkarsama sırasında farklı davranışlara sahip. Örneğin katman için, bir açığa standart bir uygulamadır training içinde (boolean) argüman call() yöntemiyle.

Bu argüman teşhir ederek call() , yerleşik eğitim ve değerlendirme döngüler (örneğin etkinleştirmek fit() doğru bir şekilde çalışma ve çıkarım katmanı kullanmak için).

class CustomDropout(keras.layers.Layer):
    def __init__(self, rate, **kwargs):
        super(CustomDropout, self).__init__(**kwargs)
        self.rate = rate

    def call(self, inputs, training=None):
        if training:
            return tf.nn.dropout(inputs, rate=self.rate)
        return inputs

İmtiyazlı mask içinde argüman call() yöntemiyle

Tarafından desteklenen diğer ayrıcalıklı argüman call() olan mask argüman.

Bunu tüm Keras RNN katmanlarında bulacaksınız. Maske, zaman serisi verilerini işlerken belirli giriş zaman adımlarını atlamak için kullanılan bir boole tensörüdür (girişteki zaman adımı başına bir boole değeri).

Keras otomatik olarak doğru geçecek mask için bağımsız değişkeni __call__() bir maske önceki tabaka ile üretildiğinde, bu destek katmanları. Maske üreten tabakalardır Embedding ile yapılandırılmış tabaka mask_zero=True ve Masking tabakası.

Daha maskeleme ve nasıl yazmaya özellikli maskeleme katmanları hakkında bilgi edinmek için rehber kontrol edin "dolgu anlamak ve maskeleme" .

Model sınıfı

Genel olarak, kullanmak olacaktır Layer iç hesaplama blokları tanımlama sınıf ve kullanır Model dış modeli tanımlamak için sınıf - antrenman nesneyi.

Örneğin, bir ResNet50 modelinde, sen sınıflara birkaç ResNet blokları olurdu Layer ve tek Model tüm ResNet50 ağını kapsayan.

Model sınıfı ile aynı API vardır Layer , aşağıda farklılıklar:

  • Bu yerleşik açığa eğitim, değerlendirme ve öngörü döngüler ( model.fit() , model.evaluate() , model.predict() ).
  • Bu yoluyla, iç katman listesi ortaya model.layers özelliği.
  • Bu tasarruf ve seri hale API'leri ortaya ( save() , save_weights() ...)

Etkin bir şekilde, Layer ne "blok ResNet" de olduğu gibi (( "kıvrım tabaka" ya da "tekrarlayan tabaka" olduğu gibi) ya da bir "blok" olarak bir "kat" olarak literatürde bakın veya "Başlangıç blok" sınıf karşılık ).

Bu arada, Model ( "derin sinir ağı" gibi) ( "derin öğrenme modelinin" de olduğu gibi) ya da bir "ağ" olarak, bir "model" olarak literatürde adlandırılan sınıf denk gelmektedir.

Eğer merak ediyorsanız eğer öyleyse, "kullanmalıyım Layer sınıf veya Model sınıfı?" Diye sorun: çağrı gerekir fit() Üzerinde? Aramaya gerekecek mi save() üzerinde? Eğer öyleyse, ile gitmek Model . Değilse (ya da sınıf daha büyük sisteminde sadece bir blok ya da çünkü eğitim yazma ve kodu kendiniz tasarruf çünkü), kullanım Layer .

Mesela, bizim mini resnet örneği yukarıda almak ve bir inşa için kullanabilir Model biz eğitebilmeyi fit() ve biz birlikte kurtarabilecek save_weights() :

class ResNet(tf.keras.Model):

    def __init__(self, num_classes=1000):
        super(ResNet, self).__init__()
        self.block_1 = ResNetBlock()
        self.block_2 = ResNetBlock()
        self.global_pool = layers.GlobalAveragePooling2D()
        self.classifier = Dense(num_classes)

    def call(self, inputs):
        x = self.block_1(inputs)
        x = self.block_2(x)
        x = self.global_pool(x)
        return self.classifier(x)


resnet = ResNet()
dataset = ...
resnet.fit(dataset, epochs=10)
resnet.save(filepath)

Hepsini bir araya getirmek: uçtan uca bir örnek

İşte şimdiye kadar öğrendikleriniz:

  • Bir Layer bir durum (oluşturulan kapsül __init__() ya da build() ) ve bazı hesaplama (tanımlanmış call() ).
  • Katmanlar, yeni, daha büyük hesaplama blokları oluşturmak için özyinelemeli olarak iç içe yerleştirilebilir.
  • Oluşturabilir Katmanlar ve parça kayıpları (genellikle düzenlileştirme kayıpları) yanı sıra ölçümlerini aracılığıyla add_loss() ve add_metric()
  • Dış kap, alıştırma yapmak istediğiniz şey, bir olduğunu Model . Bir Model sadece gibidir Layer , ancak ilave eğitim ve seri ekipmana sahip.

Tüm bunları uçtan uca bir örnekte bir araya getirelim: Variational AutoEncoder (VAE) uygulayacağız. MNIST rakamlarıyla eğiteceğiz.

Bizim VAE bir alt sınıfı olacaktır Model alt sınıf olduğunu tabakaların iç içe geçmiş bir kompozisyon olarak inşa Layer . Bir düzenleme kaybı (KL sapması) içerecektir.

from tensorflow.keras import layers


class Sampling(layers.Layer):
    """Uses (z_mean, z_log_var) to sample z, the vector encoding a digit."""

    def call(self, inputs):
        z_mean, z_log_var = inputs
        batch = tf.shape(z_mean)[0]
        dim = tf.shape(z_mean)[1]
        epsilon = tf.keras.backend.random_normal(shape=(batch, dim))
        return z_mean + tf.exp(0.5 * z_log_var) * epsilon


class Encoder(layers.Layer):
    """Maps MNIST digits to a triplet (z_mean, z_log_var, z)."""

    def __init__(self, latent_dim=32, intermediate_dim=64, name="encoder", **kwargs):
        super(Encoder, self).__init__(name=name, **kwargs)
        self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
        self.dense_mean = layers.Dense(latent_dim)
        self.dense_log_var = layers.Dense(latent_dim)
        self.sampling = Sampling()

    def call(self, inputs):
        x = self.dense_proj(inputs)
        z_mean = self.dense_mean(x)
        z_log_var = self.dense_log_var(x)
        z = self.sampling((z_mean, z_log_var))
        return z_mean, z_log_var, z


class Decoder(layers.Layer):
    """Converts z, the encoded digit vector, back into a readable digit."""

    def __init__(self, original_dim, intermediate_dim=64, name="decoder", **kwargs):
        super(Decoder, self).__init__(name=name, **kwargs)
        self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
        self.dense_output = layers.Dense(original_dim, activation="sigmoid")

    def call(self, inputs):
        x = self.dense_proj(inputs)
        return self.dense_output(x)


class VariationalAutoEncoder(keras.Model):
    """Combines the encoder and decoder into an end-to-end model for training."""

    def __init__(
        self,
        original_dim,
        intermediate_dim=64,
        latent_dim=32,
        name="autoencoder",
        **kwargs
    ):
        super(VariationalAutoEncoder, self).__init__(name=name, **kwargs)
        self.original_dim = original_dim
        self.encoder = Encoder(latent_dim=latent_dim, intermediate_dim=intermediate_dim)
        self.decoder = Decoder(original_dim, intermediate_dim=intermediate_dim)

    def call(self, inputs):
        z_mean, z_log_var, z = self.encoder(inputs)
        reconstructed = self.decoder(z)
        # Add KL divergence regularization loss.
        kl_loss = -0.5 * tf.reduce_mean(
            z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1
        )
        self.add_loss(kl_loss)
        return reconstructed

MNIST üzerinde basit bir eğitim döngüsü yazalım:

original_dim = 784
vae = VariationalAutoEncoder(original_dim, 64, 32)

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
mse_loss_fn = tf.keras.losses.MeanSquaredError()

loss_metric = tf.keras.metrics.Mean()

(x_train, _), _ = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(60000, 784).astype("float32") / 255

train_dataset = tf.data.Dataset.from_tensor_slices(x_train)
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

epochs = 2

# Iterate over epochs.
for epoch in range(epochs):
    print("Start of epoch %d" % (epoch,))

    # Iterate over the batches of the dataset.
    for step, x_batch_train in enumerate(train_dataset):
        with tf.GradientTape() as tape:
            reconstructed = vae(x_batch_train)
            # Compute reconstruction loss
            loss = mse_loss_fn(x_batch_train, reconstructed)
            loss += sum(vae.losses)  # Add KLD regularization loss

        grads = tape.gradient(loss, vae.trainable_weights)
        optimizer.apply_gradients(zip(grads, vae.trainable_weights))

        loss_metric(loss)

        if step % 100 == 0:
            print("step %d: mean loss = %.4f" % (step, loss_metric.result()))
Start of epoch 0
step 0: mean loss = 0.3729
step 100: mean loss = 0.1265
step 200: mean loss = 0.0996
step 300: mean loss = 0.0895
step 400: mean loss = 0.0844
step 500: mean loss = 0.0810
step 600: mean loss = 0.0789
step 700: mean loss = 0.0773
step 800: mean loss = 0.0761
step 900: mean loss = 0.0751
Start of epoch 1
step 0: mean loss = 0.0748
step 100: mean loss = 0.0741
step 200: mean loss = 0.0736
step 300: mean loss = 0.0731
step 400: mean loss = 0.0728
step 500: mean loss = 0.0724
step 600: mean loss = 0.0721
step 700: mean loss = 0.0718
step 800: mean loss = 0.0715
step 900: mean loss = 0.0713

VAE sınıflara beri unutmayın Model , bu yerleşik özellikleri eğitim döngüler. Yani onu şu şekilde de eğitebilirdin:

vae = VariationalAutoEncoder(784, 64, 32)

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)

vae.compile(optimizer, loss=tf.keras.losses.MeanSquaredError())
vae.fit(x_train, x_train, epochs=2, batch_size=64)
Epoch 1/2
938/938 [==============================] - 3s 3ms/step - loss: 0.0747
Epoch 2/2
938/938 [==============================] - 2s 3ms/step - loss: 0.0676
<keras.callbacks.History at 0x7fcd2ad6bed0>

Nesneye yönelik geliştirmenin ötesinde: İşlevsel API

Bu örnek sizin için çok fazla nesne yönelimli geliştirme miydi? Ayrıca kullanarak model oluşturabilir Fonksiyonel API . Daha da önemlisi, bir stil veya diğerini seçmek, diğer stilde yazılmış bileşenlerden yararlanmanızı engellemez: her zaman karıştırıp eşleştirebilirsiniz.

Örneğin, tekrar kullanım altında fonksiyonel API örnek, aynı Sampling tabakası biz, örneğin, yukarıda tanımlanan:

original_dim = 784
intermediate_dim = 64
latent_dim = 32

# Define encoder model.
original_inputs = tf.keras.Input(shape=(original_dim,), name="encoder_input")
x = layers.Dense(intermediate_dim, activation="relu")(original_inputs)
z_mean = layers.Dense(latent_dim, name="z_mean")(x)
z_log_var = layers.Dense(latent_dim, name="z_log_var")(x)
z = Sampling()((z_mean, z_log_var))
encoder = tf.keras.Model(inputs=original_inputs, outputs=z, name="encoder")

# Define decoder model.
latent_inputs = tf.keras.Input(shape=(latent_dim,), name="z_sampling")
x = layers.Dense(intermediate_dim, activation="relu")(latent_inputs)
outputs = layers.Dense(original_dim, activation="sigmoid")(x)
decoder = tf.keras.Model(inputs=latent_inputs, outputs=outputs, name="decoder")

# Define VAE model.
outputs = decoder(z)
vae = tf.keras.Model(inputs=original_inputs, outputs=outputs, name="vae")

# Add KL divergence regularization loss.
kl_loss = -0.5 * tf.reduce_mean(z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1)
vae.add_loss(kl_loss)

# Train.
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
vae.compile(optimizer, loss=tf.keras.losses.MeanSquaredError())
vae.fit(x_train, x_train, epochs=3, batch_size=64)
Epoch 1/3
938/938 [==============================] - 3s 3ms/step - loss: 0.0749
Epoch 2/3
938/938 [==============================] - 2s 3ms/step - loss: 0.0676
Epoch 3/3
938/938 [==============================] - 2s 3ms/step - loss: 0.0675
<keras.callbacks.History at 0x7fcd2b3a37d0>

Daha fazla bilgi için, okumak için emin olun Fonksiyonel API kılavuzu .