tf.keras.layers.Layer

Это класс, от которого наследуются все слои.

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

tf.keras.layers.Layer(
    trainable=True, name=None, dtype=None, dynamic=False, **kwargs
)

Слой — это вызываемый объект, который принимает на вход один или несколько тензоров и возвращает один или несколько тензоров. Он включает в себя вычисления, определённые в методе call(), и состояние (переменные весов), определённые либо в конструкторе __init__(), либо в методе build().

Пользователи просто инициализируют слой и затем используют его как вызываемый объект.

Рекомендуется, чтобы потомки Layer реализовывали следующие методы:

• __init__(): Определяет пользовательские атрибуты слоя и создаёт переменные состояния слоя, которые не зависят от формы входных данных, используя add_weight().
• build(self, input_shape): Этот метод может использоваться для создания весов, которые зависят от формы входных данных, используя add_weight(). __call__() автоматически построит слой (если он ещё не построен), вызвав build().
• call(self, *args, **kwargs): Вызывается в __call__ после того, как будет гарантировано, что build() был вызван. call() выполняет логику применения слоя к входным тензорам (которые должны передаваться как аргументы). Два зарезервированных ключевых аргумента, которые вы можете использовать по желанию в call(), это:
  • training (булево значение, указывающее, находится ли вызов в режиме предсказания или обучения)
  • mask (булевый тензор, кодирующий замаскированные временные шаги на входе, используемый в слоях RNN)
• get_config(self): Возвращает словарь, содержащий конфигурацию, используемую для инициализации этого слоя. Если ключи отличаются от аргументов в __init__, тогда переопределите также from_config(self). Этот метод используется при сохранении слоя или модели, содержащей этот слой.

Примеры:

Вот базовый пример: слой с двумя переменными, w и b, возвращающий y = w . x + b. Он демонстрирует, как реализовать build() и call(). Переменные, установленные в качестве атрибутов слоя, отслеживаются как веса слоёв (в layer.weights).

class SimpleDense(Layer):

  def __init__(self, units=32):
      super(SimpleDense, self).__init__()
      self.units = units

  def build(self, input_shape):  # Create the state of the layer (weights)
    w_init = tf.random_normal_initializer()
    self.w = tf.Variable(
        initial_value=w_init(shape=(input_shape[-1], self.units),
                             dtype='float32'),
        trainable=True)
    b_init = tf.zeros_initializer()
    self.b = tf.Variable(
        initial_value=b_init(shape=(self.units,), dtype='float32'),
        trainable=True)

  def call(self, inputs):  # Defines the computation from inputs to outputs
      return tf.matmul(inputs, self.w) + self.b

# Instantiates the layer.
linear_layer = SimpleDense(4)

# This will also call `build(input_shape)` and create the weights.
y = linear_layer(tf.ones((2, 2)))
assert len(linear_layer.weights) == 2

# These weights are trainable, so they're listed in `trainable_weights`:
assert len(linear_layer.trainable_weights) == 2

Обратите внимание, что метод add_weight() предлагает сокращённый способ создания весов:

class SimpleDense(Layer):

  def __init__(self, units=32):
      super(SimpleDense, 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(). Вот пример слоя, вычисляющего текущую сумму своих входов:

class ComputeSum(Layer):

  def __init__(self, input_dim):
      super(ComputeSum, self).__init__()
      # Create a non-trainable weight.
      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

my_sum = ComputeSum(2)
x = tf.ones((2, 2))

y = my_sum(x)
print(y.numpy())  # [2. 2.]

y = my_sum(x)
print(y.numpy())  # [4. 4.]

assert my_sum.weights == [my_sum.total]
assert my_sum.non_trainable_weights == [my_sum.total]
assert my_sum.trainable_weights == []

Для получения дополнительной информации о создании слоёв см. руководство Создание пользовательских слоёв и моделей с помощью Keras

class MyLayer(tf.keras.layers.Layer):
  def call(self, inputs):
    self.add_loss(tf.abs(tf.reduce_mean(inputs)))
    return inputs
l = MyLayer()
l(np.ones((10, 1)))
l.losses
[1.0]

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Activity regularization.
len(model.losses)
0
model.add_loss(tf.abs(tf.reduce_mean(x)))
len(model.losses)
1

inputs = tf.keras.Input(shape=(10,))
d = tf.keras.layers.Dense(10, kernel_initializer='ones')
x = d(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Weight regularization.
model.add_loss(lambda: tf.reduce_mean(d.kernel))
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=1.0>]

input = tf.keras.layers.Input(shape=(3,))
d = tf.keras.layers.Dense(2)
output = d(input)
d.add_metric(tf.reduce_max(output), name='max')
d.add_metric(tf.reduce_min(output), name='min')
[m.name for m in d.metrics]
['max', 'min']

Методы

add_loss

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

add_loss(
    losses, **kwargs
)

Добавляет тензор(ы) потерь, потенциально зависящие от входных данных слоя.

Некоторые потери (например, потери регуляризации активности) могут зависеть от входных данных, передаваемых при вызове слоя. Следовательно, при повторном использовании одного и того же слоя с разными входными данными a и b, некоторые элементы в layer.losses могут зависеть от a, а некоторые — от b. Этот метод автоматически отслеживает зависимости.

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

Пример:

class MyLayer(tf.keras.layers.Layer):
  def call(self, inputs):
    self.add_loss(tf.abs(tf.reduce_mean(inputs)))
    return inputs

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

Пример:

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Activity regularization.
model.add_loss(tf.abs(tf.reduce_mean(x)))

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

Пример:

inputs = tf.keras.Input(shape=(10,))
d = tf.keras.layers.Dense(10)
x = d(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Weight regularization.
model.add_loss(lambda: tf.reduce_mean(d.kernel))

add_metric

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

add_metric(
    value, name=None, **kwargs
)

Добавляет метрический тензор в слой.

Этот метод может использоваться внутри метода call() подклассированного слоя или модели.

class MyMetricLayer(tf.keras.layers.Layer):
  def __init__(self):
    super(MyMetricLayer, self).__init__(name='my_metric_layer')
    self.mean = tf.keras.metrics.Mean(name='metric_1')

  def call(self, inputs):
    self.add_metric(self.mean(x))
    self.add_metric(tf.reduce_sum(x), name='metric_2')
    return inputs

Этот метод также может быть вызван напрямую на функциональной модели во время её построения. В этом случае любой тензор, переданный этой модели, должен быть символьным и должен быть прослеживаем до входных данных модели Input. Эти метрики становятся частью топологии модели и отслеживаются при сохранении модели с помощью save().

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
model.add_metric(math_ops.reduce_sum(x), name='metric_1')

Примечание: Вызов add_metric() с результатом объекта метрики на функциональной модели, как показано в примере ниже, не поддерживается. Это связано с тем, что мы не можем проследить тензор результата метрики до входных данных модели.

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
model.add_metric(tf.keras.metrics.Mean()(x), name='metric_1')

add_weight

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

add_weight(
    name=None, shape=None, dtype=None, initializer=None, regularizer=None,
    trainable=None, constraint=None, use_resource=None,
    synchronization=tf.VariableSynchronization.AUTO,
    aggregation=tf.compat.v1.VariableAggregation.NONE, **kwargs
)

Добавляет новую переменную в слой.

build

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

build(
    input_shape
)

Создаёт переменные слоя (необязательно, для реализации подклассов).

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

Обычно используется для создания весов подклассов Layer.

call

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

call(
    inputs, **kwargs
)

Здесь находится логика слоя.

Обратите внимание, что метод call() в tf.keras немного отличается от API keras. В API keras вы можете передать поддержку маскирования для слоёв как дополнительные аргументы. В то время как tf.keras имеет метод compute_mask() для поддержки маскирования.

compute_mask

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

compute_mask(
    inputs, mask=None
)

Вычисляет тензор маски выходных данных.

compute_output_shape

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

compute_output_shape(
    input_shape
)

Вычисляет форму выходного тензора слоя.

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

compute_output_signature

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

compute_output_signature(
    input_signature
)

Вычисляет форму выходного тензора слоя на основе входных данных.

В отличие от объекта TensorShape, объект TensorSpec содержит как информацию о форме, так и о типе данных для тензора. Этот метод позволяет слоям предоставлять информацию о типе данных вывода, если она отличается от типа данных входа. Для любого слоя, который не реализует эту функцию, фреймворк будет использовать compute_output_shape, и предполагать, что тип данных выхода совпадает с типом данных входа.

count_params

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

count_params()

Подсчитывает общее количество скаляров, составляющих веса.

from_config

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

@classmethod
from_config(
    config
)

Создаёт слой по его конфигурации.

Этот метод — обратный get_config, позволяющий восстановить тот же слой по словарю конфигурации. Он не обрабатывает связность слоёв (обрабатывается Network), ни веса (обрабатывается set_weights).

get_config

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

get_config()

Возвращает конфигурацию слоя.

Конфигурация слоя — словарь Python (сериализуемый), содержащий конфигурацию слоя. Тот же слой можно пересоздать позже (без его обученных весов) из этой конфигурации.

Конфигурация слоя не включает информацию о связности, а также имя класса слоя. Это обрабатывается Network (слой абстракции выше).

get_weights

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

get_weights()

Возвращает текущие веса слоя.

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

Например, слой Dense возвращает список из двух значений — весов на выходной сигнал и смещение. Их можно использовать для установки весов другого слоя Dense:

a = tf.keras.layers.Dense(1,
  kernel_initializer=tf.constant_initializer(1.))
a_out = a(tf.convert_to_tensor([[1., 2., 3.]]))
a.get_weights()
[array([[1.],
       [1.],
       [1.]], dtype=float32), array([0.], dtype=float32)]
b = tf.keras.layers.Dense(1,
  kernel_initializer=tf.constant_initializer(2.))
b_out = b(tf.convert_to_tensor([[10., 20., 30.]]))
b.get_weights()
[array([[2.],
       [2.],
       [2.]], dtype=float32), array([0.], dtype=float32)]
b.set_weights(a.get_weights())
b.get_weights()
[array([[1.],
       [1.],
       [1.]], dtype=float32), array([0.], dtype=float32)]

set_weights

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

set_weights(
    weights
)

Устанавливает веса слоя из массивов Numpy.

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

Например, слой Dense возвращает список из двух значений — весов на выходной сигнал и смещения. Их можно использовать для установки весов другого слоя Dense:

a = tf.keras.layers.Dense(1,
  kernel_initializer=tf.constant_initializer(1.))
a_out = a(tf.convert_to_tensor([[1., 2., 3.]]))
a.get_weights()
[array([[1.],
       [1.],
       [1.]], dtype=float32), array([0.], dtype=float32)]
b = tf.keras.layers.Dense(1,
  kernel_initializer=tf.constant_initializer(2.))
b_out = b(tf.convert_to_tensor([[10., 20., 30.]]))
b.get_weights()
[array([[2.],
       [2.],
       [2.]], dtype=float32), array([0.], dtype=float32)]
b.set_weights(a.get_weights())
b.get_weights()
[array([[1.],
       [1.],
       [1.]], dtype=float32), array([0.], dtype=float32)]

__call__

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

__call__(
    *args, **kwargs
)

Оборачивает call, применяя предобработку и пост-обработку.

Примечание:

• Следующие необязательные именованные аргументы зарезервированы для конкретных применений:
  • training: Логический скалярный тензор Python, обозначающий, предназначен ли call для обучения или вывода.
  • mask: Логическая маска ввода.
• Если метод call слоя принимает аргумент mask (как некоторые слои Keras), его значение по умолчанию будет установлено в маску, сгенерированную для inputs предыдущим слоем (если input был получен из слоя, который сгенерировал соответствующую маску, то есть если он был получен из слоя Keras с поддержкой маскирования).