Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

tf.keras.layers.Layer

TensorFlow 1 versi Lihat sumber di GitHub

Ini adalah kelas dari mana semua lapisan mewarisi.

Mewarisi Dari: Module

Lapisan adalah objek callable yang mengambil sebagai masukan satu atau lebih tensor dan bahwa output satu atau lebih tensor. Ini melibatkan perhitungan, didefinisikan dalam call() metode, dan keadaan (variabel berat badan), didefinisikan baik dalam konstruktor __init__() atau dalam build() metode.

Pengguna hanya akan instantiate lapisan dan kemudian memperlakukannya sebagai callable.

trainable Boolean, apakah variabel layer harus dilatih.
name Nama String lapisan.
dtype The dtype perhitungan lapisan dan bobot (default None cara menggunakan tf.keras.backend.floatx di TensorFlow 2, atau jenis input pertama di TensorFlow 1).
dynamic Set ini untuk True jika lapisan Anda hanya harus dijalankan dengan penuh semangat, dan tidak boleh digunakan untuk menghasilkan grafik statis perhitungan. Ini akan menjadi kasus untuk pohon-RNN atau jaringan rekursif, misalnya, atau umumnya untuk setiap lapisan yang memanipulasi tensor menggunakan aliran kontrol Python. Jika False , kita mengasumsikan bahwa lapisan dapat dengan aman digunakan untuk menghasilkan grafik statis perhitungan.

Kami merekomendasikan bahwa keturunan Layer menerapkan metode berikut:

  • __init__() : atribut Mendefinisikan lapisan kustom, dan menciptakan variabel keadaan lapisan yang tidak bergantung pada bentuk input, menggunakan add_weight() .
  • build(self, input_shape) : Metode ini dapat digunakan untuk membuat bobot yang bergantung pada bentuk (s) dari input (s), menggunakan add_weight() . __call__() secara otomatis akan membangun lapisan (jika belum dibangun belum) dengan memanggil build() .
  • call(self, *args, **kwargs) : Disebut dalam __call__ setelah memastikan build() telah dipanggil. call() melakukan logika menerapkan lapisan ke tensor masukan (yang harus dilalui sebagai argumen). Dua dilindungi argumen kata kunci anda dapat gunakan dalam call() adalah:
    • training (boolean, apakah panggilan dalam modus inferensi atau mode pelatihan)
    • mask (boolean tensor encoding bertopeng timesteps di input, digunakan dalam lapisan RNN)
  • get_config(self) : Mengembalikan kamus yang berisi konfigurasi yang digunakan untuk menginisialisasi lapisan ini. Jika tombol berbeda dari argumen dalam __init__ , kemudian menimpa from_config(self) juga. Metode ini digunakan saat menyimpan lapisan atau model yang mengandung lapisan ini.

contoh:

Berikut adalah contoh dasar: lapisan dengan dua variabel, w dan b , bahwa pengembalian y = w . x + b . Ini menunjukkan bagaimana menerapkan build() dan call() . Variabel ditetapkan sebagai atribut dari lapisan dilacak sebagai bobot (di lapisan 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
 

Perhatikan bahwa metode add_weight() menawarkan jalan pintas untuk membuat bobot:

 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
 

Selain bobot dilatih, diperbarui melalui backpropagation selama pelatihan, lapisan juga dapat memiliki bobot non-dilatih. Bobot ini dimaksudkan untuk diperbarui secara manual selama call() . Berikut adalah contoh lapisan yang menghitung jumlah berjalan dari input:

 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 == []
 

Untuk informasi lebih lanjut tentang membuat lapisan, lihat panduan Menulis lapisan kustom dan model dengan Keras

Tentang lapisan yang dtype atribut:

Setiap lapisan memiliki dtype, yang biasanya merupakan dtype perhitungan layer dan variabel. Dtype Lapisan ini dapat dilihat melalui Layer.dtype properti. Dtype yang ditentukan dengan dtype argumen konstruktor. Dalam TensorFlow 2, default dtype ke tf.keras.backend.floatx() jika tidak ada dtype dilewatkan. floatx() itu sendiri defaultnya "float32". Selain itu, lapisan akan melemparkan masukan mereka untuk dtype lapisan dalam TensorFlow 2. Ketika presisi campuran digunakan, lapisan mungkin memiliki berbagai perhitungan dan variabel dtypes. Lihat tf.keras.mixed_precision.experimental.Policy untuk rincian tentang lapisan dtypes.

name Nama lapisan (string).
dtype The dtype perhitungan lapisan dan bobot. Jika presisi campuran digunakan dengan tf.keras.mixed_precision.experimental.Policy , ini bukan hanya dtype bobot lapisan, seperti perhitungan yang dilakukan dalam dtype yang berbeda.
trainable_weights Daftar variabel untuk dimasukkan dalam backprop.
non_trainable_weights Daftar variabel yang seharusnya tidak dimasukkan dalam backprop.
weights Gabungan dari trainable_weights daftar dan non_trainable_weights (dalam urutan ini).
trainable Apakah lapisan harus dilatih (boolean), yaitu apakah bobot berpotensi-dilatih-nya harus dikembalikan sebagai bagian dari layer.trainable_weights .
input_spec Opsional (daftar) InputSpec objek (s) menentukan kendala pada input yang dapat diterima oleh lapisan.
activity_regularizer Fungsi regularizer opsional untuk output dari lapisan ini.
dynamic Apakah lapisan dinamis (bersemangat-only); diatur dalam konstruktor.
input Memperoleh kembali tensor input (s) dari lapisan.

Hanya berlaku jika lapisan memiliki tepat satu input, yaitu jika terhubung ke satu lapisan yang masuk.

losses Daftar kerugian ditambahkan dengan menggunakan add_loss() API.

Tensor regularisasi variabel diciptakan ketika properti ini diakses, sehingga ingin aman: mengakses losses bawah tf.GradientTape akan menyebarkan gradien kembali ke variabel yang sesuai.

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>]

metrics Daftar metrik menambahkan menggunakan add_metric() API.

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']

output Memperoleh kembali output tensor (s) dari lapisan.

Hanya berlaku jika lapisan memiliki tepat satu output, yaitu jika terhubung ke satu lapisan yang masuk.

supports_masking Apakah lapisan ini mendukung komputasi masker menggunakan compute_mask .

metode

add_loss

Lihat sumber

Menambahkan kerugian tensor (s), berpotensi tergantung pada lapisan input.

Beberapa kerugian (misalnya, kerugian aktivitas regularisasi) mungkin tergantung pada masukan berlalu saat memanggil lapisan. Oleh karena itu, ketika menggunakan kembali lapisan yang sama pada input yang berbeda a dan b , beberapa entri di layer.losses mungkin tergantung pada a dan beberapa di b . Metode ini secara otomatis menyimpan melacak dependensi.

Metode ini dapat digunakan di dalam lapisan subclassed atau model call fungsi, dalam hal losses harus Tensor atau daftar Tensors.

Contoh:

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

Metode ini juga dapat disebut langsung pada Model Fungsional selama konstruksi. Dalam hal ini, setiap Tensors kehilangan diteruskan ke Model ini harus simbolik dan dapat ditelusuri kembali ke model Input s. Kerugian ini menjadi bagian dari topologi model dan dilacak di get_config .

Contoh:

 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.