tf.keras.Model

Model группирует слои в объект с функциями обучения и вывода.

Наследуется от: Layer, Module

tf.keras.Model(
    *args, **kwargs
)

Есть два способа создать экземпляр Model:

1 — С помощью "Функционального API", где вы начинаете с Input, вы цепляете вызовы слоев для указания прямого прохода модели и, наконец, создаете свою модель из входных и выходных данных:

import tensorflow as tf

inputs = tf.keras.Input(shape=(3,))
x = tf.keras.layers.Dense(4, activation=tf.nn.relu)(inputs)
outputs = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

Примечание: Поддерживаются только словари, списки и кортежи тензоров входных данных. Вложенные входные данные не поддерживаются (например, списки списков или словари словарей).

Модель функционального API также можно создать, используя промежуточные тензоры. Это позволяет быстро извлечь подкомпоненты модели.

Пример:

inputs = keras.Input(shape=(None, None, 3))
processed = keras.layers.RandomCrop(width=32, height=32)(inputs)
conv = keras.layers.Conv2D(filters=2, kernel_size=3)(processed)
pooling = keras.layers.GlobalAveragePooling2D()(conv)
feature = keras.layers.Dense(10)(pooling)

full_model = keras.Model(inputs, feature)
backbone = keras.Model(processed, conv)
activations = keras.Model(conv, feature)

Обратите внимание, что модели backbone и activations не создаются с объектами keras.Input, а с тензорами, которые происходят из объектов keras.Inputs. Под капотом, слои и веса будут совместно использоваться между этими моделями, так что пользователь может обучать full_model, и использовать backbone или activations для извлечения признаков. Входные и выходные данные модели также могут быть вложенными структурами тензоров, и созданные модели — это стандартные модели функционального API, которые поддерживают все существующие API.

2 — Наследуя класс Model: в этом случае вы должны определить свои слои в __init__() и реализовать прямой проход модели в call().

import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super().__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)

  def call(self, inputs):
    x = self.dense1(inputs)
    return self.dense2(x)

model = MyModel()

Если вы наследуете Model, вы можете необязательно иметь аргумент training (логический) в call(), который вы можете использовать для указания различного поведения в процессе обучения и вывода:

import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super().__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)
    self.dropout = tf.keras.layers.Dropout(0.5)

  def call(self, inputs, training=False):
    x = self.dense1(inputs)
    if training:
      x = self.dropout(x, training=training)
    return self.dense2(x)

model = MyModel()

После создания модели вы можете настроить модель с потерями и метриками с помощью model.compile(), обучить модель с помощью model.fit(), или использовать модель для предсказания с помощью model.predict().

inputs = tf.keras.layers.Input(shape=(3,))
outputs = tf.keras.layers.Dense(2)(inputs)
model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="Adam", loss="mse", metrics=["mae"])
model.metrics_names
[]

x = np.random.random((2, 3))
y = np.random.randint(0, 2, (2, 2))
model.fit(x, y)
model.metrics_names
['loss', 'mae']

inputs = tf.keras.layers.Input(shape=(3,))
d = tf.keras.layers.Dense(2, name='out')
output_1 = d(inputs)
output_2 = d(inputs)
model = tf.keras.models.Model(
   inputs=inputs, outputs=[output_1, output_2])
model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"])
model.fit(x, (y, y))
model.metrics_names
['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',
'out_1_acc']

Методы

call

Просмотреть исходный код

call(
    inputs, training=None, mask=None
)

Вызывает модель на новых входных данных и возвращает выходные данные как тензоры.

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

Примечание: Этот метод не следует вызывать напрямую. Он предназначен только для переопределения при наследовании от tf.keras.Model. Для вызова модели на входе всегда используйте метод __call__(), т.е. model(inputs), который опирается на базовый метод call().

compile

Просмотреть исходный код

compile(
    optimizer='rmsprop',
    loss=None,
    metrics=None,
    loss_weights=None,
    weighted_metrics=None,
    run_eagerly=None,
    steps_per_execution=None,
    jit_compile=None,
    **kwargs
)

Настраивает модель для обучения.

Пример:

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
              loss=tf.keras.losses.BinaryCrossentropy(),
              metrics=[tf.keras.metrics.BinaryAccuracy(),
                       tf.keras.metrics.FalseNegatives()])

compute_loss

Просмотреть исходный код

compute_loss(
    x=None, y=None, y_pred=None, sample_weight=None
)

Вычислить общую потерю, проверить её и вернуть.

Подклассы могут необязательно переопределить этот метод, чтобы обеспечить пользовательскую логику вычисления потерь.

Пример:

class MyModel(tf.keras.Model):

  def __init__(self, *args, **kwargs):
    super(MyModel, self).__init__(*args, **kwargs)
    self.loss_tracker = tf.keras.metrics.Mean(name='loss')

  def compute_loss(self, x, y, y_pred, sample_weight):
    loss = tf.reduce_mean(tf.math.squared_difference(y_pred, y))
    loss += tf.add_n(self.losses)
    self.loss_tracker.update_state(loss)
    return loss

  def reset_metrics(self):
    self.loss_tracker.reset_states()

  @property
  def metrics(self):
    return [self.loss_tracker]

tensors = tf.random.uniform((10, 10)), tf.random.uniform((10,))
dataset = tf.data.Dataset.from_tensor_slices(tensors).repeat().batch(1)

inputs = tf.keras.layers.Input(shape=(10,), name='my_input')
outputs = tf.keras.layers.Dense(10)(inputs)
model = MyModel(inputs, outputs)
model.add_loss(tf.reduce_sum(outputs))

optimizer = tf.keras.optimizers.SGD()
model.compile(optimizer, loss='mse', steps_per_execution=10)
model.fit(dataset, epochs=2, steps_per_epoch=10)
print('My custom loss: ', model.loss_tracker.result().numpy())

compute_metrics

Просмотреть исходный код

compute_metrics(
    x, y, y_pred, sample_weight
)

Обновить состояния метрик и собрать все метрики для возврата.

Подклассы могут необязательно переопределить этот метод, чтобы предоставить пользовательскую логику обновления и сбора метрик.

Пример:

class MyModel(tf.keras.Sequential):

  def compute_metrics(self, x, y, y_pred, sample_weight):

    # This super call updates `self.compiled_metrics` and returns results
    # for all metrics listed in `self.metrics`.
    metric_results = super(MyModel, self).compute_metrics(
        x, y, y_pred, sample_weight)

    # Note that `self.custom_metric` is not listed in `self.metrics`.
    self.custom_metric.update_state(x, y, y_pred, sample_weight)
    metric_results['custom_metric_name'] = self.custom_metric.result()
    return metric_results

evaluate

Просмотреть исходный код

evaluate(
    x=None,
    y=None,
    batch_size=None,
    verbose='auto',
    sample_weight=None,
    steps=None,
    callbacks=None,
    max_queue_size=10,
    workers=1,
    use_multiprocessing=False,
    return_dict=False,
    **kwargs
)

Возвращает значение потерь и значения метрик для модели в режиме тестирования.

Вычисление выполняется по пакетам (см. аргумент batch_size).

См. обсуждение Unpacking behavior for iterator-like inputs для Model.fit.

fit

Просмотреть исходный код

fit(
    x=None,
    y=None,
    batch_size=None,
    epochs=1,
    verbose='auto',
    callbacks=None,
    validation_split=0.0,
    validation_data=None,
    shuffle=True,
    class_weight=None,
    sample_weight=None,
    initial_epoch=0,
    steps_per_epoch=None,
    validation_steps=None,
    validation_batch_size=None,
    validation_freq=1,
    max_queue_size=10,
    workers=1,
    use_multiprocessing=False
)

Обучает модель на фиксированное количество эпох (итераций по набору данных).

Поведение распаковки для входных данных, похожих на итераторы: Общим шаблоном является передача tf.data.Dataset, генератора или tf.keras.utils.Sequence в аргумент x метода fit, который фактически возвращает не только признаки (x), но также, по желанию, целевые значения (y) и веса образцов. Keras требует, чтобы вывод таких итераторов был однозначным. Итератор должен возвращать кортеж длины 1, 2 или 3, где необязательные второй и третий элементы будут использоваться для y и sample_weight соответственно. Любой другой тип будет обернут в кортеж длиной один, эффективно рассматривая всё как 'x'. При возврате словарей они должны всё ещё придерживаться структуры кортежа верхнего уровня. Например, ({"x0": x0, "x1": x1}, y). Keras не будет пытаться разделить признаки, целевые значения и веса из ключей одного словаря. Заметным неподдерживаемым типом данных является namedtuple. Причина в том, что он ведет себя как упорядоченный тип данных (кортеж) и как тип данных сопоставлений (словарь). Таким образом, при именованном кортеже следующего вида: namedtuple("example_tuple", ["y", "x"]) неясно, следует ли изменять порядок элементов при интерпретации значения. Ещё хуже — кортеж следующего вида: namedtuple("other_tuple", ["x", "y", "z"]), где неясно, был ли кортеж предназначен для распаковки в x, y и sample_weight или для передачи как единственного элемента в x. В результате код обработки данных просто поднимет исключение ValueError, если встретит namedtuple. (Вместе с инструкциями по устранению проблемы.)

get_layer

Просмотр исходного кода

get_layer(
    name=None, index=None
)

Возвращает слой на основе его имени (уникальное) или индекса.

Если name и index указаны, index будет иметь приоритет. Индексы основаны на порядке горизонтального обхода графа (снизу вверх).

load_weights

Просмотр исходного кода

load_weights(
    filepath, by_name=False, skip_mismatch=False, options=None
)

Загружает все весовые коэффициенты слоя, либо из файла весов TensorFlow, либо из HDF5 файла.

Если by_name равно False, весовые коэффициенты загружаются на основе топологии сети. Это означает, что архитектура должна быть такой же, как при сохранении весов. Обратите внимание, что слои, у которых нет весовых коэффициентов, не учитываются при топологическом упорядочении, поэтому добавление или удаление слоев допустимо, если они не имеют весовых коэффициентов.

Если by_name равно True, весовые коэффициенты загружаются в слои только в том случае, если они имеют одинаковое имя. Это полезно для дообучения или трансферного обучения моделей, когда некоторые слои были изменены.

Только топологическая загрузка (by_name=False) поддерживается при загрузке весов из формата TensorFlow. Обратите внимание, что топологическая загрузка немного отличается между форматами TensorFlow и HDF5 для пользовательских классов, наследующих от tf.keras.Model: HDF5 загружает на основе сплющенного списка весов, а формат TensorFlow загружает на основе локальных имён атрибутов, которым слои назначены в конструкторе Model.

make_predict_function

Просмотр исходного кода

make_predict_function(
    force=False
)

Создаёт функцию, выполняющую один шаг вывода.

Этот метод может быть переопределён для поддержки пользовательской логики вывода. Этот метод вызывается методами Model.predict и Model.predict_on_batch.

Обычно этот метод напрямую управляет параметрами tf.function и tf.distribute.Strategy, и делегирует фактическую логику вычисления методу Model.predict_step.

Эта функция кэшируется при первом вызове Model.predict или Model.predict_on_batch. Кэш очищается при вызове Model.compile. Вы можете пропустить кэш и повторно сгенерировать функцию с помощью force=True.

make_test_function

Просмотр исходного кода

make_test_function(
    force=False
)

Создаёт функцию, выполняющую один шаг оценки.

Этот метод может быть переопределён для поддержки пользовательской логики оценки. Этот метод вызывается методами Model.evaluate и Model.test_on_batch.

Обычно этот метод напрямую управляет параметрами tf.function и tf.distribute.Strategy, и делегирует фактическую логику оценки методу Model.test_step.

Эта функция кэшируется при первом вызове Model.evaluate или Model.test_on_batch. Кэш очищается при вызове Model.compile. Вы можете пропустить кэш и повторно сгенерировать функцию с помощью force=True.

make_train_function

Просмотр исходного кода

make_train_function(
    force=False
)

Создаёт функцию, выполняющую один шаг обучения.

Этот метод может быть переопределён для поддержки пользовательской логики обучения. Этот метод вызывается методами Model.fit и Model.train_on_batch.

Обычно этот метод напрямую управляет параметрами tf.function и tf.distribute.Strategy, и делегирует фактическую логику обучения методу Model.train_step.

Эта функция кэшируется при первом вызове Model.fit или Model.train_on_batch. Кэш очищается при вызове Model.compile. Вы можете пропустить кэш и повторно сгенерировать функцию с помощью force=True.

predict

Посмотреть исходный код

predict(
    x,
    batch_size=None,
    verbose='auto',
    steps=None,
    callbacks=None,
    max_queue_size=10,
    workers=1,
    use_multiprocessing=False
)

Генерирует прогнозы вывода для входных образцов.

Вычисления выполняются по частям. Этот метод предназначен для пакетной обработки большого количества входных данных. Он не предназначен для использования внутри циклов, которые итерируют по данным и обрабатывают небольшое количество входных данных за раз.

Для небольшого количества входных данных, которые помещаются в одну партию, используйте напрямую __call__() для более быстрого выполнения, например, model(x), или model(x, training=False) если у вас есть слои, такие как tf.keras.layers.BatchNormalization, которые ведут себя по-разному во время вывода. Вы можете объединить отдельный вызов модели с tf.function для дополнительной производительности внутри внутреннего цикла. Если вам нужен доступ к значениям массива NumPy вместо тензоров после вызова модели, вы можете использовать tensor.numpy() для получения значения массива NumPy для тензора eager.

Также обратите внимание на тот факт, что тестовая ошибка не зависит от регуляризующих слоёв, таких как шум и отбрасывание.

Примечание: См. эту запись FAQ для получения более подробной информации о различиях между методами Model predict() и __call__().

См. обсуждение Unpacking behavior for iterator-like inputs для Model.fit. Обратите внимание, что Model.predict использует те же правила интерпретации, что и Model.fit и Model.evaluate, поэтому входные данные должны быть однозначными для всех трёх методов.

predict_on_batch

Посмотреть исходный код

predict_on_batch(
    x
)

Возвращает прогнозы для одной партии образцов.

predict_step

Посмотреть исходный код

predict_step(
    data
)

Логика для одного шага вывода.

Этот метод может быть переопределён для поддержки пользовательской логики вывода. Этот метод вызывается методом Model.make_predict_function.

Этот метод должен содержать математическую логику для одного шага вывода. Обычно это включает в себя прямой проход.

Подробные сведения о том, как именно выполняется эта логика (например, параметры tf.function и tf.distribute.Strategy), должны быть оставлены методу Model.make_predict_function, который также может быть переопределён.

reset_metrics

Посмотреть исходный код

reset_metrics()

Сбрасывает состояние всех метрик в модели.

Примеры:

inputs = tf.keras.layers.Input(shape=(3,))
outputs = tf.keras.layers.Dense(2)(inputs)
model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="Adam", loss="mse", metrics=["mae"])

x = np.random.random((2, 3))
y = np.random.randint(0, 2, (2, 2))
_ = model.fit(x, y, verbose=0)
assert all(float(m.result()) for m in model.metrics)

model.reset_metrics()
assert all(float(m.result()) == 0 for m in model.metrics)

reset_states

Посмотреть исходный код

reset_states()

save

Посмотреть исходный код

save(
    filepath,
    overwrite=True,
    include_optimizer=True,
    save_format=None,
    signatures=None,
    options=None,
    save_traces=True
)

Сохраняет модель в формате Tensorflow SavedModel или в одном файле HDF5.

Подробности см. в tf.keras.models.save_model или в руководстве по сериализации и сохранению Serialization and Saving guide.

Пример:

from keras.models import load_model

model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'
del model  # deletes the existing model

# returns a compiled model
# identical to the previous one
model = load_model('my_model.h5')

save_spec

Посмотреть исходный код

save_spec(
    dynamic_batch=True
)

Возвращает кортеж tf.TensorSpec входных данных вызова как кортеж (args, kwargs).

Это значение автоматически определяется после первого вызова модели. После этого вы можете использовать его при экспорте модели для обслуживания:

model = tf.keras.Model(...)

@tf.function
def serve(*args, **kwargs):
  outputs = model(*args, **kwargs)
  # Apply postprocessing steps, or add additional outputs.
  ...
  return outputs

# arg_specs is `[tf.TensorSpec(...), ...]`. kwarg_specs, in this example, is
# an empty dict since functional models do not use keyword arguments.
arg_specs, kwarg_specs = model.save_spec()

model.save(path, signatures={
  'serving_default': serve.get_concrete_function(*arg_specs, **kwarg_specs)
})

save_weights

Посмотреть исходный код

save_weights(
    filepath, overwrite=True, save_format=None, options=None
)

Сохраняет все веса слоёв.

Сохранение происходит в формате HDF5 или TensorFlow, в зависимости от аргумента save_format.

При сохранении в формате HDF5 файл весов содержит:

• layer_names (атрибут), список строк (упорядоченные имена слоёв модели).
• Для каждого слоя, группа атрибутов group с именем layer.name
  • Для каждой такой группы слоёв, атрибут группы weight_names, список строк (упорядоченные имена тензоров весов слоя).
  • Для каждого веса слоя, набор данных, хранящий значение веса, с именем, соответствующим тензору веса.

При сохранении в формате TensorFlow все объекты, на которые ссылается сеть, сохраняются в том же формате, что и в tf.train.Checkpoint, включая любые экземпляры Layer или экземпляры Optimizer , присвоенные атрибутам объекта. Для сетей, построенных из входных и выходных данных с помощью tf.keras.Model(inputs, outputs), экземпляры Layer , используемые сетью, отслеживаются/сохраняются автоматически. Для пользовательских классов, унаследованных от tf.keras.Model, экземпляры Layer должны быть присвоены атрибутам объекта, обычно в конструкторе. См. документацию tf.train.Checkpoint и tf.keras.Model для получения дополнительной информации.

Хотя форматы одинаковые, не смешивайте save_weights и tf.train.Checkpoint. Checkpoints, сохранённые с помощью Model.save_weights , должны загружаться с помощью Model.load_weights. Checkpoints, сохранённые с помощью tf.train.Checkpoint.save, должны восстанавливаться с помощью соответствующего tf.train.Checkpoint.restore. Предпочтительнее использовать tf.train.Checkpoint вместо save_weights для сохранения контрольных точек обучения.

Формат TensorFlow сопоставляет объекты и переменные, начиная с корневого объекта, self для save_weights, и жадно подбирает имена атрибутов. Для Model.save это Model, а для Checkpoint.save это Checkpoint даже если у Checkpoint есть присоединённая модель. Это означает, что сохранение tf.keras.Model с помощью save_weights и загрузка в tf.train.Checkpoint с присоединённой Model (или наоборот) не будет соответствовать переменным Model. Для получения подробной информации о формате TensorFlow обратитесь к руководству по контрольным точкам обучения.

summary

Посмотреть исходный код

summary(
    line_length=None,
    positions=None,
    print_fn=None,
    expand_nested=False,
    show_trainable=False
)

Выводит строковый вывод сети.

test_on_batch

Посмотреть исходный код

test_on_batch(
    x, y=None, sample_weight=None, reset_metrics=True, return_dict=False
)

Тестирование модели на одной порции выборок.

test_step

Просмотреть исходный код

test_step(
    data
)

Логика одного шага оценки.

Этот метод может быть переопределён для поддержки пользовательской логики оценки. Этот метод вызывается Model.make_test_function.

Эта функция должна содержать математическую логику одного шага оценки. Обычно это включает прямой проход, вычисление потерь и обновление метрик.

Детали конфигурации способа выполнения этой логики (например, tf.function и tf.distribute.Strategy настройки) должны быть оставлены Model.make_test_function, который также может быть переопределён.

to_json

Просмотреть исходный код

to_json(
    **kwargs
)

Возвращает строку JSON, содержащую конфигурацию сети.

Для загрузки сети из файла сохранения JSON используйте keras.models.model_from_json(json_string, custom_objects={}).

to_yaml

Просмотреть исходный код

to_yaml(
    **kwargs
)

Возвращает строку YAML, содержащую конфигурацию сети.

Примечание: Начиная с TF 2.6, этот метод больше не поддерживается и вызовет RuntimeError.

Для загрузки сети из файла сохранения YAML используйте keras.models.model_from_yaml(yaml_string, custom_objects={}).

custom_objects должен быть словарем, сопоставляющим имена пользовательских потерь/слоёв/и т. д. соответствующим функциям/классам.

train_on_batch

Просмотреть исходный код

train_on_batch(
    x,
    y=None,
    sample_weight=None,
    class_weight=None,
    reset_metrics=True,
    return_dict=False
)

Выполняет одно обновление градиента на одной порции данных.

train_step

Просмотреть исходный код

train_step(
    data
)

Логика одного шага обучения.

Этот метод может быть переопределён для поддержки пользовательской логики обучения. Для конкретных примеров переопределения этого метода см. Настраиваемое поведение в методе fit. Этот метод вызывается Model.make_train_function.

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

Детали конфигурации способа выполнения этой логики (например, tf.function и tf.distribute.Strategy настройки) должны быть оставлены Model.make_train_function, который также может быть переопределён.