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

Об атрибуте dtype слоя:

Каждый слой имеет тип данных, который обычно является типом данных вычислений и переменных слоя. Тип данных слоя можно получить с помощью свойства Layer.dtype. Тип данных задаётся аргументом конструктора dtype. В TensorFlow 2 тип данных по умолчанию — tf.keras.backend.floatx(), если не указан другой тип. floatx() по умолчанию равен "float32". Кроме того, слои преобразуют свои входные данные в тип данных слоя в TensorFlow 2. При использовании смешанной точности слои могут иметь разные типы данных вычислений и переменных. Подробнее о типах данных слоёв см. tf.keras.mixed_precision.experimental.Policy.

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.
model.add_loss(tf.abs(tf.reduce_mean(x)))
model.losses
[<tf.Tensor 'Abs:0' shape=() dtype=float32>]

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 = metrics_module.Mean(name='metric_1')

  def call(self, inputs):
    self.add_metric(self.mean(x))
    self.add_metric(math_ops.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, partitioner=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, позволяя восстановить тот же слой из словаря конфигурации. Он не обрабатывает соединение слоёв (обрабатывается сетью) или веса (обрабатывается 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 с поддержкой маскирования).