Волма слой характеристики: Штукатурка гипсовая Волма Слой 30 кг

Содержание влаги в мармеладе во время экспериментов по сушке тонкого слоя было выражено в безразмерной форме как отношение влажности MR с помощью следующего уравнения [32, 33]: — среднее содержание влаги в мармеладе, — исходное значение, — равновесная влажность. Скорость высыхания мармелада была рассчитана с использованием (2.2) [34, 35]

Создание новых слоев и моделей с помощью подкласса

Автор: fchollet
Дата создания: 2019/03/01
Последнее изменение: 2020/04/13
Описание: Полное руководство по написанию объектов Layer и Model с нуля.

Просмотр в Colab • Исходный код GitHub

Настройка

  импортировать тензорный поток как tf
из tenorflow import keras
  

Класс Layer : комбинация состояния (весов) и некоторых вычислений

Одной из центральных абстракций в Керасе является класс Layer .Слой инкапсулирует как состояние («веса» слоя), так и преобразование из входы в выходы («вызов», прямой проход уровня).

Вот плотно связанный слой. У него есть состояние: переменные w и b .

  класс Линейный (keras.layers.Layer):
    def __init __ (self, units = 32, input_dim = 32):
        super (Линейный, сам) .__ init __ ()
        w_init = tf.random_normal_initializer ()
        self.w = tf.Variable (
            начальное_значение = 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 (self, вводы):
        return tf.matmul (входы, self.w) + self.b
  

Вы могли бы использовать слой, вызывая его на некоторых входных данных тензора, как в Python. функция.

  x = tf.ones ((2, 2))
linear_layer = Линейный (4, 2)
y = линейный_уровень (x)
печать (у)
  

  тф.Тенсор (
[[0,01013444 -0,01070027 -0.01888977 0,05208318]
 [0,01013444 -0,01070027 -0,01888977 0,05208318]], shape = (2, 4), dtype = float32)
  

Обратите внимание, что веса w и b автоматически отслеживаются слоем при устанавливается как атрибуты слоя:

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

Обратите внимание, что у вас также есть доступ к более быстрому ярлыку для добавления веса к слою: метод add_weight () :

  класс Linear (keras.Layers.Layer):
    def __init __ (self, units = 32, input_dim = 32):
        super (Линейный, сам) .__ 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 (self, вводы):
        return tf.matmul (входы, self.w) + self.b


х = tf.ones ((2, 2))
linear_layer = Линейный (4, 2)
y = линейный_уровень (x)
печать (у)
  

  тс.Тензор(
[[-0,01331179 -0,00605625 -0,01042787 0,17160884]
 [-0.01331179 -0.00605625 -0.01042787 0.17160884]], shape = (2, 4), dtype = float32)
  

Слои могут иметь нетренируемые веса

Помимо тренируемых отягощений, вы можете добавить к слою необучаемые веса как хорошо. Такие веса не должны приниматься во внимание во время обратное распространение, когда вы тренируете слой.

Вот как добавить и использовать нетренируемый вес:

  класс 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 (self, вводы):
        self.total.assign_add (tf.reduce_sum (входы, ось = 0))
        вернуть self.total


х = tf.ones ((2, 2))
my_sum = ComputeSum (2)
у = моя_сумма (х)
печать (y.numpy ())
у = моя_сумма (х)
печать (y.numpy ())
  

Это часть слоя , весит , но он классифицируется как необучаемый вес:

  print ("веса:", len (my_sum.веса))
print ("необучаемые веса:", len (my_sum.non_trainable_weights))

# Это не входит в тренируемые веса:
print ("trainable_weights:", my_sum.trainable_weights)
  

  весов: 1
нетренируемые веса: 1
trainable_weights: []
  

Лучшая практика: отложить создание веса до тех пор, пока не станет известна форма входных данных

Наш слой Linear выше принял аргумент input_dim , который использовался для вычисления форма грузов w и b in __init __ () :

  класс Linear (keras. Layers.Layer):
    def __init __ (self, units = 32, input_dim = 32):
        super (Линейный, сам) .__ 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 (self, вводы):
        return tf.matmul (входы, self.w) + self.b
  

Во многих случаях вы можете не знать заранее размер ваших входных данных, и вы хотел бы лениво создавать веса, когда это значение станет известно, когда-нибудь после создания экземпляра слоя.

В Keras API мы рекомендуем создавать веса слоев в сборке (self, input_shape) метод вашего слоя. Как это:

  класс Линейный (keras.layers.Layer):
    def __init __ (self, units = 32):
        super (Линейный, сам) .__ init __ ()
        self.units = единицы

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

    вызов def (self, вводы):
        return tf.matmul (входы, self.w) + self.b
  

Метод __call __ () вашего слоя автоматически запустит сборку при первом запуске. это называется. Теперь у вас есть ленивый слой, который проще в использовании:

  # При инстанциации мы не знаем, на каких входах это будет вызвано
linear_layer = Линейный (32)

# Веса слоя создаются динамически при первом вызове слоя
y = линейный_уровень (x)
  

Слои рекурсивно компонуются

Если вы назначаете экземпляр слоя как атрибут другого слоя, внешний слой начнёт отслеживать вес внутреннего слоя.

Мы рекомендуем создавать такие подслои в методе __init __ () (т.к. подслои обычно имеют метод сборки, они будут построены, когда внешний слой строится).

  # Предположим, мы повторно используем класс Linear
# с методом `build`, который мы определили выше.


класс MLPBlock (keras.layers.Layer):
    def __init __ (сам):
        super (MLPBlock, сам) .__ init __ ()
        self.linear_1 = Линейный (32)
        self.linear_2 = Линейный (32)
        я.linear_3 = Линейный (1)

    вызов def (self, вводы):
        x = self.linear_1 (входные данные)
        х = tf.nn.relu (х)
        х = self.linear_2 (х)
        х = tf.nn.relu (х)
        вернуть self.linear_3 (x)


mlp = MLPBlock ()
y = mlp (tf.ones (shape = (3, 64))) # Первый вызов `mlp` создаст веса
print ("веса:", len (mlp.weights))
print ("обучаемые веса:", len (mlp.trainable_weights))
  

  вес: 6
тренируемые веса: 6
  

Метод add_loss ()

При написании метода call () слоя вы можете создавать тензоры потерь, которые вы захотите использовать позже, при написании цикла обучения. Это можно сделать вызов self.add_loss (значение) :

  # Слой, который создает потерю регуляризации активности
класс ActivityRegularizationLayer (keras.layers.Layer):
    def __init __ (self, rate = 1e-2):
        super (ActivityRegularizationLayer, сам) .__ init __ ()
        self.rate = рейтинг

    вызов def (self, вводы):
        self.add_loss (self.rate * tf.reduce_sum (входы))
        возврат входов
  

Эти потери (включая потери, создаваемые любым внутренним слоем) могут быть восстановлены через слой.убытки . Это свойство сбрасывается в начале каждого __call __ () на слой верхнего уровня, так что layer.losses всегда содержит значения потерь созданный во время последнего прямого прохода.

  класс OuterLayer (keras.layers.Layer):
    def __init __ (сам):
        super (OuterLayer, self) .__ init __ ()
        self.activity_reg = ActivityRegularizationLayer (1e-2)

    вызов def (self, вводы):
        return self. activity_reg (входы)


слой = OuterLayer ()
assert len ​​(layer.loss) == 0 # потерь пока нет, так как слой никогда не вызывался

_ = слой (tf.zeros (1, 1))
assert len ​​(layer.losses) == 1 # Мы создали одно значение потерь

# `layer.losses` сбрасывается в начале каждого __call__
_ = слой (tf.zeros (1, 1))
assert len ​​(layer.losses) == 1 # Это потеря, созданная во время вызова выше
  

Кроме того, потеря собственности также содержит на вес любого внутреннего слоя:

  класс OuterLayerWithKernelRegularizer (keras.Layers.Layer):
    def __init __ (сам):
        super (OuterLayerWithKernelRegularizer, сам) .__ init __ ()
        self.dense = keras.layers.Dense (
            32, kernel_regularizer = tf.keras.regularizers.l2 (1e-3)
        )

    вызов def (self, вводы):
        return self.dense (входы)


layer = OuterLayerWithKernelRegularizer ()
_ = слой (tf.zeros ((1, 1)))

# Это `1e-3 * sum (layer.dense.kernel ** 2)`,
# созданный выше `kernel_regularizer`. 
печать (layer.losses)
  

  []
  

Эти потери следует учитывать при написании обучающих циклов, как это:

  # Создать оптимизатор.
optimizer = tf.keras.optimizers.SGD (скорость_учения = 1e-3)
loss_fn = keras.losses.SparseCategoricalCrossentropy (from_logits = True)

# Перебирать пакеты набора данных.
для x_batch_train, y_batch_train в train_dataset:
  с tf.GradientTape () в качестве ленты:
    logits = layer (x_batch_train) # Логиты для этого мини-пакета
    # Значение потерь для этой мини-партии
    loss_value = loss_fn (y_batch_train, логиты)
    # Добавьте дополнительные потери, созданные во время этого прямого прохода:
    loss_value + = сумма (модель.убытки)

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

Подробное руководство по написанию обучающих циклов см. В руководство по написанию цикла обучения с нуля.

Эти потери также работают без проблем с fit () (они автоматически суммируются и добавлен к основному убытку, если есть):

  импортировать numpy как np

входы = keras.Input (shape = (3,))
output = ActivityRegularizationLayer () (входы)
модель = керас.Модель (входы, выходы)

# Если в `compile` передается потеря, то регуляризация
К нему добавляется # убытков
model.compile (optimizer = "adam", loss = "mse")
model.fit (np.random.random ((2, 3)), np.random.random ((2, 3)))

# Также возможно не передавать потери в `compile`,
# поскольку у модели уже есть потери, которые нужно минимизировать, через `add_loss`
# вызов во время прямого прохода!
model.compile (optimizer = "adam")
model.fit (np.random.random ((2, 3)), np.random.random ((2, 3)))
  

  1/1 [==============================] - 0 с 1 мс / шаг - потеря: 0.1555
1/1 [==============================] - 0 с 927 мкс / шаг - потеря: 0,0336

 python.keras.callbacks.History в 0x145bca6d0>
  

Метод add_metric ()

Подобно add_loss () , слои также имеют метод add_metric () для отслеживания скользящего среднего количества во время обучения.

Рассмотрим следующий уровень: уровень «логистической конечной точки». Он принимает в качестве входных данных прогнозы и цели, вычисляет убытки, которые отслеживает. через add_loss () , и вычисляет скаляр точности, который отслеживает через add_metric () .

  класс LogisticEndpoint (keras.layers.Layer):
    def __init __ (self, name = None):
        super (LogisticEndpoint, self) .__ init __ (имя = имя)
        self.loss_fn = keras.losses.BinaryCrossentropy (from_logits = True)
        self.accuracy_fn = keras.metrics.BinaryAccuracy ()

    вызов def (self, target, logits, sample_weights = None):
        # Вычислить значение потери времени на обучение и добавить его
        # на слой с помощью `self. add_loss ()`.
        потеря = self.loss_fn (цели, логиты, выборка_весов)
        я.add_loss (убыток)

        # Зарегистрируйте точность как метрику и добавьте ее
        # на слой с помощью `self.add_metric ()`.
        acc = self.accuracy_fn (цели, логиты, выборка_весов)
        self.add_metric (acc, name = "precision")

        # Возвращает тензор предсказания времени вывода (для `.predict ()`).
        вернуть tf.nn.softmax (логиты)
  

Отслеживаемые таким образом показатели доступны через layer.metrics :

  слой = LogisticEndpoint ()

target = tf.ones ((2, 2))
logits = tf.единицы ((2, 2))
y = слой (цели, логиты)

print ("layer.metrics:", layer.metrics)
print ("текущее значение точности:", float (layer.metrics [0] .result ()))
  

  layer.metrics: [<объект tensorflow.python.keras.metrics.BinaryAccuracy в 0x145bccdd0>]
текущее значение точности: 1.0
  

Как и для add_loss () , эти показатели отслеживаются функцией fit () :

  входов = keras. Input (shape = (3,), name = "inputs")
target = keras.Входные данные (shape = (10,), name = "target")
logits = keras.layers.Dense (10) (входные данные)
прогнозы = LogisticEndpoint (name = "прогнозы") (логиты, цели)

model = keras.Model (входы = [входы, цели], выходы = прогнозы)
model.compile (optimizer = "adam")

data = {
    "входы": np.random.random ((3, 3)),
    "цели": np.random.random ((3, 10)),
}
model.fit (данные)
  

  1/1 [==============================] - 0 с 999 мкс / шаг - потеря: 1,0366 - двоичная_точность: 0,0000 e + 00


  

При желании вы можете включить сериализацию на своих слоях

Если вам нужно, чтобы ваши пользовательские слои можно было сериализовать как часть Функциональная модель, при желании вы можете реализовать get_config () метод:

  класс Линейный (keras.layers.Layer):
    def __init __ (self, units = 32):
        super (Линейный, сам) . __ init __ ()
        self.units = единицы

    def build (self, input_shape):
        self.w = сам.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 (self, вводы):
        return tf.matmul (входы, self.w) + self.b

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


# Теперь вы можете воссоздать слой из его конфигурации:
слой = Линейный (64)
config = layer.get_config ()
печать (конфигурация)
new_layer = Линейный.from_config (конфигурация)
  

Обратите внимание, что метод __init __ () базового класса Layer принимает ключевое слово аргументы, в частности имя и dtype . Это хорошая практика. эти аргументы в родительский класс в __init __ () и включить их в Конфигурация слоя:

  класс Линейный (keras. layers.Layer):
    def __init __ (self, units = 32, ** kwargs):
        super (Линейный, сам) .__ init __ (** kwargs)
        я.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 (self, вводы):
        return tf.matmul (входы, self.w) + self.b

    def get_config (сам):
        config = super (Линейный, сам) .get_config ()
        config.обновление ({"единицы": self.units})
        вернуть конфигурацию


слой = Линейный (64)
config = layer.get_config ()
печать (конфигурация)
new_layer = Linear.from_config (конфигурация)
  

  {'name': 'linear_8', 'trainable': True, 'dtype': 'float32', 'units': 64}
  

Если вам нужна большая гибкость при десериализации слоя из его конфигурации, вы также может переопределить метод класса from_config () . Это база реализация from_config () :

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

Чтобы узнать больше о сериализации и сохранении, см. Полный руководство по сохранению и сериализации моделей.

Привилегированный обучение аргумент в методе call ()

Некоторые слои, в частности слой BatchNormalization и Dropout слой, имеют разное поведение во время обучения и вывода. Для таких слоев, стандартной практикой является предоставление обучающего аргумента (логического) в метод call () .

Выставляя этот аргумент в вызове call () , вы активируете встроенное обучение и циклы оценки (например,г. fit () ), чтобы правильно использовать слой в обучении и вывод.

  класс CustomDropout (keras.layers.Layer):
    def __init __ (self, rate, ** kwargs):
        super (CustomDropout, self) . __ init __ (** kwargs)
        self.rate = рейтинг

    def call (self, inputs, training = None):
        если обучение:
            return tf.nn.dropout (входы, скорость = self.rate)
        возврат входов
  

Привилегированная маска аргумент в методе call ()

Другой привилегированный аргумент, поддерживаемый функцией call () , — это аргумент маски .

Вы найдете его во всех слоях Keras RNN. Маска — это булев тензор (один логическое значение на временной шаг во вводе), используемое для пропуска определенных временных шагов ввода при обработке данных таймсерий.

Keras автоматически передаст правильный аргумент маски в __call __ () для слои, которые его поддерживают, когда маска создается предыдущим слоем. Слои, генерирующие маски: Embedding слой, настроенный с mask_zero = True и Masking layer.

Чтобы узнать больше о маскировании и написании слоев с маскировкой, пожалуйста, проверить руководство «понимание отступов и маскировки».

Модель класс

Как правило, вы будете использовать класс Layer для определения внутренних вычислительных блоков, и будет использовать класс Model для определения внешней модели — объекта, который вы буду тренироваться.

Например, в модели ResNet50 у вас будет несколько блоков ResNet подкласс Layer и одну модель , охватывающую весь ResNet50 сеть.

Класс модели имеет тот же API, что и Layer , со следующими отличиями:

• Предоставляет встроенные циклы обучения, оценки и прогнозирования ( model.fit () , model.evaluate () , model.predict () ).
• Он предоставляет список своих внутренних слоев через свойство model.layers .
• Он предоставляет API сохранения и сериализации ( save () , save_weights () …)

Фактически, класс Layer соответствует тому, что мы упоминаем в литературу как «слой» (как «сверточный слой» или «повторяющийся слой») или как «блок» (например, «блок ResNet» или «начальный блок»).

Между тем, класс модели соответствует тому, что упоминается в литература как «модель» (как в «модели глубокого обучения») или как «сеть» (как в «глубокая нейронная сеть»).

Итак, если вам интересно, «следует ли мне использовать класс Layer или класс Model ?», спросите себя: мне нужно будет на нем звонить по номеру fit () ? Мне нужно будет позвонить по номеру save () в теме? Если да, выберите модель .Если нет (либо потому, что ваш класс — это просто блок в более крупной системе или потому что вы сами пишете обучение и сохраняете код), используйте Layer .

Например, мы могли бы взять наш приведенный выше пример мини-реснета и использовать его для создания модель , которую мы могли бы тренировать с fit () , и которую мы могли бы сэкономить с save_weights () :

  класс ResNet (tf.keras.Model):

    def __init __ (self, num_classes = 1000):
        супер (ResNet, сам). __в этом__()
        self.block_1 = ResNetBlock ()
        self.block_2 = ResNetBlock ()
        self.global_pool = Layers.GlobalAveragePooling2D ()
        self.classifier = Плотный (количество_классов)

    вызов def (self, вводы):
        x = self.block_1 (входы)
        х = self.block_2 (х)
        x = self.global_pool (x)
        вернуть self.classifier (x)


resnet = ResNet ()
набор данных = ...
resnet.fit (набор данных, эпох = 10)
resnet.save (путь к файлу)
  

Собираем все вместе: пример из конца в конец

Вот что вы уже узнали:

• A Layer инкапсулирует состояние (созданное в __init __ () или build () ) и некоторые вычисление (определено в вызове call () ).
• Слои могут рекурсивно вкладываться для создания новых вычислительных блоков большего размера.
Слои
• также могут создавать и отслеживать потери (обычно потери регуляризации). как метрики, через add_loss () и add_metric ()
• Внешний контейнер, то, что вы хотите тренировать, — это модель . Модель является точно так же, как Layer , но с добавленными утилитами обучения и сериализации.

Давайте объединим все это в сквозной пример: мы собираемся для реализации вариационного автоэнкодера (VAE).Обучим его цифрам MNIST.

Наш VAE будет подклассом модели , построенным как вложенная композиция слоев этот подкласс Layer . В нем будет потеря регуляризации (дивергенция KL).

  из слоев импорта tensorflow.keras


класс Sampling (Layers.Layer):
    "" "Использует (z_mean, z_log_var) для выборки z, вектора, кодирующего цифру." ""

    вызов def (self, вводы):
        z_mean, z_log_var = входы
        batch = tf.shape (z_mean) [0]
        dim = tf.форма (z_mean) [1]
        epsilon = tf.keras.backend.random_normal (форма = (партия, тусклый))
        вернуть z_mean + tf.exp (0.5 * z_log_var) * epsilon


класс Encoder (слои.Layer):
    "" "Отображает цифры MNIST в тройку (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.sampling = Выборка ()

    вызов def (self, вводы):
        x = self.dense_proj (входные данные)
        z_mean = self.dense_mean (x)
        z_log_var = self.dense_log_var (x)
        z = self.sampling ((z_mean, z_log_var))
        вернуть z_mean, z_log_var, z


класс Decoder (слои.Layer):
    "" "Преобразует z, вектор закодированных цифр, обратно в читаемую цифру." ""

    def __init __ (self, original_dim, intermediate_dim = 64, name = "decoder", ** kwargs):
        супер (Декодер, сам).__init __ (name = name, ** kwargs)
        self.dense_proj = Layers.Dense (Intermediate_dim, Activation = "relu")
        self.dense_output = Layers. Dense (original_dim, activate = "сигмоид")

    вызов def (self, вводы):
        x = self.dense_proj (входные данные)
        вернуть self.dense_output (x)


класс VariationalAutoEncoder (keras.Model):
    "" "Объединяет кодер и декодер в сквозную модель для обучения." ""

    def __init __ (
        я
        original_dim,
        промежуточный_дим = 64,
        latent_dim = 32,
        name = "автоэнкодер",
        ** kwargs
    ):
        super (VariationalAutoEncoder, сам).__init __ (name = name, ** kwargs)
        self.original_dim = original_dim
        self.encoder = Encoder (latent_dim = latent_dim, intermediate_dim = intermediate_dim)
        self.decoder = Декодер (исходный_дим, промежуточный_дим = промежуточный_дим)

    вызов def (self, вводы):
        z_mean, z_log_var, z = self.encoder (входные данные)
        реконструировано = self.decoder (z)
        # Добавить потерю регуляризации расхождения KL.
        kl_loss = -0,5 * tf.reduce_mean (
            z_log_var - tf.square (z_mean) - tf. exp (z_log_var) + 1
        )
        я.add_loss (kl_loss)
        возвращение реконструировано
  

Напишем простой обучающий цикл на MNIST:

  original_dim = 784
vae = VariationalAutoEncoder (исходный_дим, 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 (размер_буфера = 1024) .batch (64)

эпох = 2

# Перебираем эпохи.
для эпохи в диапазоне (эпох):
    print ("Начало эпохи% d"% (эпоха,))

    # Перебираем пакеты набора данных.
    для шага x_batch_train в enumerate (train_dataset):
        с tf.GradientTape () в качестве ленты:
            реконструировано = vae (x_batch_train)
            # Вычислить потерю реконструкции
            loss = mse_loss_fn (x_batch_train, реконструировано)
            убыток + = сумма (vae. loss) # Добавить потерю регуляризации KLD

        grads = tape.gradient (потеря, vae.trainable_weights)
        optimizer.apply_gradients (zip (grads, vae.trainable_weights))

        loss_metric (убыток)

        если шаг% 100 == 0:
            print ("шаг% d: средняя потеря =% .4f"% (шаг, loss_metric.result ()))
  

  Начало эпохи 0
шаг 0: средний убыток = 0,3577
шаг 100: средняя потеря = 0,1258
шаг 200: средняя потеря = 0,0994
шаг 300: средняя потеря = 0,0893
шаг 400: средняя потеря = 0,0843
шаг 500: средняя потеря = 0.0809
шаг 600: средняя потеря = 0,0788
шаг 700: средняя потеря = 0,0772
шаг 800: средняя потеря = 0,0760
шаг 900: средняя потеря = 0,0750
Начало эпохи 1
шаг 0: средняя потеря = 0,0747
шаг 100: средняя потеря = 0,0740
шаг 200: средняя потеря = 0,0735
шаг 300: средняя потеря = 0,0730
шаг 400: средняя потеря = 0,0727
шаг 500: средняя потеря = 0,0723
шаг 600: средняя потеря = 0,0720
шаг 700: средняя потеря = 0,0717
шаг 800: средняя потеря = 0,0715
шаг 900: средняя потеря = 0,0712
  

Обратите внимание, что, поскольку VAE является подклассом модели , он имеет встроенное обучение. петли.Так что вы могли бы обучить его так:

  vae = VariationalAutoEncoder (784, 64, 32)

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

vae.compile (оптимизатор, loss = tf.keras.losses.MeanSquaredError ())
vae.fit (x_train, x_train, epochs = 2, batch_size = 64)
  

  Эпоха 1/2
938/938 [==============================] - 1 с 1 мс / шаг - потеря: 0,0745
Эпоха 2/2
938/938 [==============================] - 1 с 1 мс / шаг - потеря: 0,0676


  

Помимо объектно-ориентированной разработки: функциональный API

Этот пример был для вас слишком много объектно-ориентированной разработки? Вы также можете строить модели с помощью функционального API. Важно отметить, что выбор того или иного стиля не мешает вам использовать компоненты написано в другом стиле: всегда можно смешать и сопоставить.

Например, в приведенном ниже примере функционального API повторно используется тот же уровень Sampling . мы определили в примере выше:

  original_dim = 784
промежуточный_дим = 64
latent_dim = 32

# Определить модель кодировщика.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 = Выборка () ((z_mean, z_log_var))
кодировщик = tf.keras.Model (входы = исходные_входы, выходы = z, имя = "кодировщик")

# Определить модель декодера.
latent_inputs = tf.keras.Input (shape = (latent_dim,), name = "z_sampling")
x = Layers.Dense (Intermediate_dim, Activation = "relu") (latent_inputs)
выходы = слои.Плотный (исходный_дим, активация = "сигмоид") (х)
decoder = tf.keras.Model (входы = скрытые_входы, выходы = выходы, name = "декодер")

# Определить модель VAE.
выходы = декодер (z)
vae = tf.keras.Model (входы = исходные_входы, выходы = выходы, name = "vae")

# Добавить потерю регуляризации расхождения KL. 
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)

# Поезд.
optimizer = tf.keras.optimizers.Adam (learning_rate = 1e-3)
vae.compile (оптимизатор, loss = tf.keras.losses.MeanSquaredError ())
vae.fit (x_train, x_train, epochs = 3, batch_size = 64)
  

  Эпоха 1/3
938/938 [==============================] - 1 с 1 мс / шаг - потеря: 0,0747
Эпоха 2/3
938/938 [==============================] - 1 с 1 мс / шаг - потеря: 0,0676
Эпоха 3/3
938/938 [==============================] - 1 с 1 мс / шаг - потеря: 0,0676


  

Для получения дополнительной информации обязательно прочтите руководство по функциональному API.

Ур. нет.	Название модели	Уравнение модели	Каталожные номера
(2,1)	Льюис	MR = exp (- узлов )	[474	Страница	MR = exp (- узлов n )	[48]
(2.3)	Измененная страница	MR = α exp [- ( kt n )]	[49]
(2,4)	Overhults	MR = exp [ узлы ) n ]	[50]
(2,5)	Хендерсон и Пабис	MR = α экспл. (- узлы )
(3,1)	Логарифмический	MR = α exp (- узлов ) + c	[39]
(3.2)	Двухчленная экспонента	MR = α exp (- kt ) + b exp (- k 1 t )	[52]
(	Ван и Сингх	MR = 1 + α t +	[49]
(3,4)	Thompson	t = α 1 ln (b) ln (b) 90 ln (MR) 2	[53]
(3.5)	Распределение Вейбулла	MR = α — b exp [- ( узлы n )]	[54]

Уровень 2 — канал передачи данных

Уровень 2 — канал передачи данных Уровень канала передачи данных обеспечивает надежную передачу данных по физическому сетевому каналу. Различные спецификации уровня канала передачи данных определяют различные характеристики сети и протокола, включая физическую адресацию, топологию сети, уведомление об ошибках, последовательность кадров и управление потоком. Уровень канала передачи данных преобразует сообщения сетевого уровня в биты для передачи на физическом уровне.Он форматирует сообщения в фреймы данных и добавляет настраиваемый заголовок, содержащий адреса оборудования источника и назначения. Уровень канала передачи данных отвечает за уникальную идентификацию каждого устройства в локальной сети. Физическая адресация (в отличие от сетевой) определяет способ адресации устройств на уровне канала передачи данных. Топология сети состоит из спецификаций уровня канала данных, которые часто определяют, как устройства должны быть физически соединены, например, в топологии шины или кольца. Уведомление об ошибке предупреждает протоколы верхнего уровня о том, что произошла ошибка передачи, и последовательность кадров данных меняет порядок кадров, которые передаются вне очереди. Управление потоком контролирует передачу данных, чтобы принимающее устройство не было перегружено большим объемом трафика, чем оно может обработать за один раз. Когда пакет пересылается между маршрутизаторами, он формируется с управляющей информацией на уровне канала передачи данных.Информация удаляется на маршрутизаторе назначения, и остается только исходный пакет. Если пакет должен перейти к другому маршрутизатору, процесс кадрирования повторяется, пока он не попадет на принимающий хост. Пакет никогда не изменяется, а только инкапсулируется с управляющей информацией, которая должна быть передана другому типу носителя. IEEE разделил уровень канала передачи данных на два подуровня: Logical Link Control (LLC) и Media Access Control (MAC). MAC (управление доступом к среде) Подуровень управления доступом к среде (MAC) уровня канала данных управляет протокольным доступом к физической сетевой среде. Спецификация MAC IEEE определяет MAC-адреса, которые позволяют нескольким устройствам однозначно идентифицировать друг друга на уровне канала данных. MAC описывает, как станция планирует, передает и принимает данные в совместно используемой среде мультимедиа, обеспечивает надежную передачу информации по каналу связи, синхронизирует передачу данных, распознает ошибки (не исправляет их) и контролирует поток данных. Определяет, как пакеты размещаются на носителе. Здесь определяется физическая адресация, а также локальные топологии. Примером MAC является Ethernet / 802.3 и Token Ring / 802.5 На этом уровне можно использовать дисциплину линии, уведомление об ошибках, упорядоченную доставку кадров и дополнительное управление потоком. В общем, MAC важны только в средах с общей средой, где несколько узлов могут подключаться к одной и той же среде передачи. LLC (управление логической связью) Подуровень управления логическим каналом (LLC) уровня канала данных управляет обменом данными между устройствами по одному каналу сети. Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт