Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Camadas personalizadas

Veja no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

Recomendamos usar tf.keras como uma API de alto nível para construir redes neurais. Dito isso, a maioria das APIs do TensorFlow pode ser usada com execução rápida.

import tensorflow as tf
print(tf.config.list_physical_devices('GPU'))
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

Camadas: conjuntos comuns de operações úteis

Na maioria das vezes, ao escrever código para modelos de aprendizado de máquina, você deseja operar em um nível mais alto de abstração do que operações individuais e manipulação de variáveis ​​individuais.

Muitos modelos de aprendizado de máquina podem ser expressos como a composição e o empilhamento de camadas relativamente simples, e o TensorFlow fornece um conjunto de muitas camadas comuns e maneiras fáceis de escrever suas próprias camadas específicas do aplicativo do zero ou como a composição de camadas existentes.

O TensorFlow inclui a API Keras completa no pacote tf.keras, e as camadas Keras são muito úteis ao criar seus próprios modelos.

# In the tf.keras.layers package, layers are objects. To construct a layer,
# simply construct the object. Most layers take as a first argument the number
# of output dimensions / channels.
layer = tf.keras.layers.Dense(100)
# The number of input dimensions is often unnecessary, as it can be inferred
# the first time the layer is used, but it can be provided if you want to
# specify it manually, which is useful in some complex models.
layer = tf.keras.layers.Dense(10, input_shape=(None, 5))

A lista completa de camadas pré-existentes pode ser vista na documentação . Inclui Dense (uma camada totalmente conectada), Conv2D, LSTM, BatchNormalization, Dropout e muitos outros.

# To use a layer, simply call it.
layer(tf.zeros([10, 5]))
<tf.Tensor: shape=(10, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>
# Layers have many useful methods. For example, you can inspect all variables
# in a layer using `layer.variables` and trainable variables using
# `layer.trainable_variables`. In this case a fully-connected layer
# will have variables for weights and biases.
layer.variables
[<tf.Variable 'dense_1/kernel:0' shape=(5, 10) dtype=float32, numpy=
 array([[ 0.23931128, -0.35447165, -0.09866846, -0.21435553,  0.30993396,
          0.12939054,  0.32952148,  0.15316409, -0.24020499, -0.14377776],
        [-0.58758354, -0.17689753, -0.12298965, -0.52167857, -0.53910273,
         -0.05996823,  0.5304331 ,  0.08700156, -0.2717192 , -0.54143935],
        [-0.29657045,  0.30838162, -0.2584419 ,  0.544849  , -0.24524784,
         -0.37161082,  0.35867715,  0.50317436,  0.14259934,  0.5063301 ],
        [-0.5704792 , -0.382418  , -0.15623882, -0.07497388, -0.16307682,
          0.20676267, -0.23887128, -0.56966513, -0.2137106 , -0.5280915 ],
        [-0.61984897,  0.6323913 ,  0.54486364, -0.11561352, -0.5456628 ,
          0.280694  ,  0.47461778,  0.21258783, -0.10627949, -0.2540871 ]],
       dtype=float32)>,
 <tf.Variable 'dense_1/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>]
# The variables are also accessible through nice accessors
layer.kernel, layer.bias
(<tf.Variable 'dense_1/kernel:0' shape=(5, 10) dtype=float32, numpy=
 array([[ 0.23931128, -0.35447165, -0.09866846, -0.21435553,  0.30993396,
          0.12939054,  0.32952148,  0.15316409, -0.24020499, -0.14377776],
        [-0.58758354, -0.17689753, -0.12298965, -0.52167857, -0.53910273,
         -0.05996823,  0.5304331 ,  0.08700156, -0.2717192 , -0.54143935],
        [-0.29657045,  0.30838162, -0.2584419 ,  0.544849  , -0.24524784,
         -0.37161082,  0.35867715,  0.50317436,  0.14259934,  0.5063301 ],
        [-0.5704792 , -0.382418  , -0.15623882, -0.07497388, -0.16307682,
          0.20676267, -0.23887128, -0.56966513, -0.2137106 , -0.5280915 ],
        [-0.61984897,  0.6323913 ,  0.54486364, -0.11561352, -0.5456628 ,
          0.280694  ,  0.47461778,  0.21258783, -0.10627949, -0.2540871 ]],
       dtype=float32)>,
 <tf.Variable 'dense_1/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>)

Implementando camadas personalizadas

A melhor maneira de implementar sua própria camada é estender a classe tf.keras.Layer e implementar:

  1. __init__ , onde você pode fazer todas as inicializações independentes de entrada
  2. build , onde você conhece as formas dos tensores de entrada e pode fazer o resto da inicialização
  3. call , onde você faz o cálculo de encaminhamento

Observe que você não precisa esperar até que o build seja chamado para criar suas variáveis, você também pode criá-las em __init__ . No entanto, a vantagem de criá-los na build é que permite a criação tardia de variáveis ​​com base na forma das entradas nas quais a camada operará. Por outro lado, criar variáveis ​​em __init__ significaria que as formas necessárias para criar as variáveis ​​precisariam ser especificadas explicitamente.

class MyDenseLayer(tf.keras.layers.Layer):
  def __init__(self, num_outputs):
    super(MyDenseLayer, self).__init__()
    self.num_outputs = num_outputs

  def build(self, input_shape):
    self.kernel = self.add_weight("kernel",
                                  shape=[int(input_shape[-1]),
                                         self.num_outputs])

  def call(self, inputs):
    return tf.matmul(inputs, self.kernel)

layer = MyDenseLayer(10)
_ = layer(tf.zeros([10, 5])) # Calling the layer `.builds` it.
print([var.name for var in layer.trainable_variables])
['my_dense_layer/kernel:0']

O código geral é mais fácil de ler e manter se usar camadas padrão sempre que possível, pois outros leitores estarão familiarizados com o comportamento das camadas padrão. Se você quiser usar uma camada que não está presente em tf.keras.layers , considere preencher um problema no github ou, melhor ainda, enviar-nos um pull request!

Modelos: compondo camadas

Muitas coisas interessantes semelhantes a camadas em modelos de aprendizado de máquina são implementadas compondo camadas existentes. Por exemplo, cada bloco residual em uma resnet é uma composição de convoluções, normalizações em lote e um atalho. As camadas podem ser aninhadas dentro de outras camadas.

Normalmente, você herda de keras.Model quando precisa dos métodos de modelo como: Model.fit , Model.evaluate e Model.save (consulte Camadas e modelos personalizados do Keras para obter detalhes).

Um outro recurso fornecido pelo keras.Model (em vez de keras.layers.Layer ) é que, além de rastrear variáveis, um keras.Model também rastreia suas camadas internas, tornando-as mais fáceis de inspecionar.

Por exemplo, aqui está um bloco ResNet:

class ResnetIdentityBlock(tf.keras.Model):
  def __init__(self, kernel_size, filters):
    super(ResnetIdentityBlock, self).__init__(name='')
    filters1, filters2, filters3 = filters

    self.conv2a = tf.keras.layers.Conv2D(filters1, (1, 1))
    self.bn2a = tf.keras.layers.BatchNormalization()

    self.conv2b = tf.keras.layers.Conv2D(filters2, kernel_size, padding='same')
    self.bn2b = tf.keras.layers.BatchNormalization()

    self.conv2c = tf.keras.layers.Conv2D(filters3, (1, 1))
    self.bn2c = tf.keras.layers.BatchNormalization()

  def call(self, input_tensor, training=False):
    x = self.conv2a(input_tensor)
    x = self.bn2a(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2b(x)
    x = self.bn2b(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2c(x)
    x = self.bn2c(x, training=training)

    x += input_tensor
    return tf.nn.relu(x)


block = ResnetIdentityBlock(1, [1, 2, 3])
_ = block(tf.zeros([1, 2, 3, 3]))
block.layers
[<keras.layers.convolutional.Conv2D at 0x7f7a5c447dd0>,
 <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7f7a66009a10>,
 <keras.layers.convolutional.Conv2D at 0x7f7a66009fd0>,
 <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7f7a5c3912d0>,
 <keras.layers.convolutional.Conv2D at 0x7f7a5c448cd0>,
 <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7f7a5c391d90>]
len(block.variables)
18
block.summary()
Model: "resnet_identity_block"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              multiple                  4         
_________________________________________________________________
batch_normalization (BatchNo multiple                  4         
_________________________________________________________________
conv2d_1 (Conv2D)            multiple                  4         
_________________________________________________________________
batch_normalization_1 (Batch multiple                  8         
_________________________________________________________________
conv2d_2 (Conv2D)            multiple                  9         
_________________________________________________________________
batch_normalization_2 (Batch multiple                  12        
=================================================================
Total params: 41
Trainable params: 29
Non-trainable params: 12
_________________________________________________________________

Na maioria das vezes, no entanto, os modelos que compõem muitas camadas simplesmente chamam uma camada após a outra. Isso pode ser feito em muito pouco código usando tf.keras.Sequential :

my_seq = tf.keras.Sequential([tf.keras.layers.Conv2D(1, (1, 1),
                                                    input_shape=(
                                                        None, None, 3)),
                             tf.keras.layers.BatchNormalization(),
                             tf.keras.layers.Conv2D(2, 1,
                                                    padding='same'),
                             tf.keras.layers.BatchNormalization(),
                             tf.keras.layers.Conv2D(3, (1, 1)),
                             tf.keras.layers.BatchNormalization()])
my_seq(tf.zeros([1, 2, 3, 3]))
<tf.Tensor: shape=(1, 2, 3, 3), dtype=float32, numpy=
array([[[[0., 0., 0.],
         [0., 0., 0.],
         [0., 0., 0.]],

        [[0., 0., 0.],
         [0., 0., 0.],
         [0., 0., 0.]]]], dtype=float32)>
my_seq.summary()
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_3 (Conv2D)            (None, None, None, 1)     4         
_________________________________________________________________
batch_normalization_3 (Batch (None, None, None, 1)     4         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, None, None, 2)     4         
_________________________________________________________________
batch_normalization_4 (Batch (None, None, None, 2)     8         
_________________________________________________________________
conv2d_5 (Conv2D)            (None, None, None, 3)     9         
_________________________________________________________________
batch_normalization_5 (Batch (None, None, None, 3)     12        
=================================================================
Total params: 41
Trainable params: 29
Non-trainable params: 12
_________________________________________________________________

Próximos passos

Agora você pode voltar ao notebook anterior e adaptar o exemplo de regressão linear para usar camadas e modelos para melhor estruturar.