tf.keras.experimental.WideDeepModel

Модель Широкая и Глубокая для задач регрессии и классификации.

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

tf.keras.experimental.WideDeepModel(
    linear_model, dnn_model, activation=None, **kwargs
)

Эта модель совместно обучает линейную и глубокую нейронную сеть.

Пример:

linear_model = LinearModel()
dnn_model = keras.Sequential([keras.layers.Dense(units=64),
                             keras.layers.Dense(units=1)])
combined_model = WideDeepModel(linear_model, dnn_model)
combined_model.compile(optimizer=['sgd', 'adam'], 'mse', ['mse'])
# define dnn_inputs and linear_inputs as separate numpy arrays or
# a single numpy array if dnn_inputs is same as linear_inputs.
combined_model.fit([linear_inputs, dnn_inputs], y, epochs)
# or define a single `tf.data.Dataset` that contains a single tensor or
# separate tensors for dnn_inputs and linear_inputs.
dataset = tf.data.Dataset.from_tensors(([linear_inputs, dnn_inputs], y))
combined_model.fit(dataset, epochs)

Как линейная, так и глубокая нейронная сеть могут быть предварительно скомпилированы и обучены по отдельности перед совместным обучением:

Пример:

linear_model = LinearModel()
linear_model.compile('adagrad', 'mse')
linear_model.fit(linear_inputs, y, epochs)
dnn_model = keras.Sequential([keras.layers.Dense(units=1)])
dnn_model.compile('rmsprop', 'mse')
dnn_model.fit(dnn_inputs, y, epochs)
combined_model = WideDeepModel(linear_model, dnn_model)
combined_model.compile(optimizer=['sgd', 'adam'], 'mse', ['mse'])
combined_model.fit([linear_inputs, dnn_inputs], y, epochs)

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
)

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

В этом случае 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 вида: 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 тензора.

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

Примечание: См. эту запись в разделе вопросов и ответов для получения более подробной информации о различиях между методами 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 или руководство по сериализации и сохранению Сериализация и сохранение для получения подробной информации.

Пример:

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. Точки восстановления, сохранённые с помощью Model.save_weights, должны загружаться с помощью Model.load_weights. Точки восстановления, сохранённые с помощью 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. См. руководство по контрольным точкам обучения https://www.tensorflow.org/guide/checkpoint для получения подробной информации о формате 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, который также может быть переопределён.