tf.keras.layers.Layer

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

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

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

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

• в __init__();
• в необязательном методе build(), который вызывается первым __call__() слоем и предоставляет форму(ы) входных данных, которая(ые) могла(и) быть(и) неизвестны на момент инициализации;
• при первом вызове call(), с некоторыми оговорками, обсуждаемыми ниже.

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

Мы рекомендуем потомкам Layer реализовать следующие методы:

• __init__(): Определяет пользовательские атрибуты слоя и создает веса слоя, которые не зависят от формы входных данных, используя add_weight(), или другое состояние.
• build(self, input_shape): Этот метод может использоваться для создания весов, которые зависят от формы входных данных, используя add_weight(), или другое состояние. __call__() автоматически построит слой (если он еще не построен) вызовом build().
• call(self, inputs, *args, **kwargs): Вызывается в __call__ после того, как будет гарантировано, что build() был вызван. call() выполняет логику применения слоя к inputs. При первом вызове может дополнительно создаваться состояние, которое не могло быть удобно создано в build(); см. строку документации для получения подробной информации. Два зарезервированных именованных аргумента, которые вы можете использовать в call(), это:
  • training (булево значение, указывает ли вызов режим вывода или обучения). Подробнее см. в руководстве по подклассированию слоёв/моделей
  • mask (булевый тензор, кодирующий замаскированные временные шаги на входе, используется в слоях RNN). Подробнее см. в руководстве по подклассированию слоёв/моделей Типичная сигнатура этого метода call(self, inputs), и пользователь может дополнительно добавить training и mask если слой их требует. *args и **kwargs полезны только для будущих расширений, когда планируется добавление дополнительных параметров входных данных.
• 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 == []

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

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(inputs))
    self.add_metric(tf.reduce_sum(inputs), name='metric_2')
    return inputs

Этот метод также можно вызвать напрямую на функциональной модели во время её создания. В этом случае любой тензор, переданный в эту модель, должен быть символическим и должен быть отслеживаем до входных данных модели. Эти метрики становятся частью топологии модели и отслеживаются при сохранении модели с помощью 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.VariableAggregation.NONE,
    **kwargs
)

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

build

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

build(
    input_shape
)

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

Этот метод, который могут переопределять реализаторы подклассов Layer или Model, если им нужна стадия создания состояния между созданием слоя и вызовом слоя. Он вызывается автоматически перед первым выполнением call().

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

call

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

call(
    inputs, *args, **kwargs
)

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

Метод call() не должен создавать состояние (кроме своего первого вызова, заключающего создание переменных или других ресурсов в tf.init_scope()). Рекомендуется создавать состояние в __init__(), или методе build(), который вызывается автоматически перед тем, как call() выполнится первый раз.

compute_mask

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

compute_mask(
    inputs, mask=None
)

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

compute_output_shape

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

compute_output_shape(
    input_shape
)

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

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

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_config() не гарантирует возвращения свежей копии словаря каждый раз при вызове. Звонящие функции должны сделать копию возвращённого словаря, если хотят его изменить.

get_weights

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

get_weights()

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

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

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

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

set_weights

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

set_weights(
    weights
)

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

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

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

layer_a = tf.keras.layers.Dense(1,
  kernel_initializer=tf.constant_initializer(1.))
a_out = layer_a(tf.convert_to_tensor([[1., 2., 3.]]))
layer_a.get_weights()
[array([[1.],
       [1.],
       [1.]], dtype=float32), array([0.], dtype=float32)]
layer_b = tf.keras.layers.Dense(1,
  kernel_initializer=tf.constant_initializer(2.))
b_out = layer_b(tf.convert_to_tensor([[10., 20., 30.]]))
layer_b.get_weights()
[array([[2.],
       [2.],
       [2.]], dtype=float32), array([0.], dtype=float32)]
layer_b.set_weights(layer_a.get_weights())
layer_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 с поддержкой маскирования).
• Если слой не построен, метод вызовет build.