Assim como Tensor
é nosso alicerce fundamental para computação paralela acelerada, a maioria dos modelos e operações de aprendizado de máquina serão expressos em termos do protocolo Layer
. Layer
define uma interface para tipos que recebem uma entrada diferenciável, processam-na e produzem uma saída diferenciável. Uma Layer
pode conter estados, como pesos treináveis.
Layer
é um refinamento do protocolo Module
, com Module
definindo o caso mais geral onde a entrada para o tipo não é necessariamente diferenciável. A maioria dos componentes de um modelo lidará com entradas diferenciáveis, mas há casos em que os tipos podem precisar estar em conformidade com Module
.
Se você criar uma operação que não possui parâmetros treináveis, você desejará defini-la em termos de ParameterlessLayer
em vez de Layer
.
Os próprios modelos são frequentemente definidos como Layer
s e são regularmente compostos de outros Layer
s. Um modelo ou subunidade definido como Layer
pode ser tratado como qualquer outro Layer
, permitindo a construção de modelos arbitrariamente complexos a partir de outros modelos ou subunidades.
Para definir uma Layer
personalizada para um modelo ou operação própria, você geralmente seguirá um modelo semelhante a este:
public struct MyModel: Layer {
// Define your layers or other properties here.
// A custom initializer may be desired to configure the model.
public init() {}
@differentiable
public func callAsFunction(_ input: Tensor<Float>) -> Tensor<Float> {
// Define the sequence of operations performed on model input to arrive at the output.
return ...
}
}
Componentes treináveis de Layers
, como pesos e desvios, bem como outros Layer
s, podem ser declarados como propriedades. Um inicializador personalizado é um bom lugar para expor parâmetros personalizáveis para um modelo, como um número variável de camadas ou o tamanho de saída de um modelo de classificação. Por fim, o núcleo da Layer
é callAsFunction()
, onde você definirá os tipos de entrada e saída, bem como a transformação que recebe uma e retorna a outra.
Camadas integradas
Muitas operações comuns de aprendizado de máquina foram encapsuladas como Layer
s para você usar ao definir modelos ou subunidades. A seguir está uma lista das camadas fornecidas pelo Swift para TensorFlow, agrupadas por áreas funcionais:
Aumento
Convolução
- Conv1D
- Conv2D
- Conv3D
- Denso
- ProfundidadeConv2D
- SeparávelConv1D
- SeparávelConv2D
- TranspostaConv1D
- TranspostoConv2D
- TranspostoConv3D
- ZeroPadding1D
- ZeroPadding2D
- ZeroPadding3D
Incorporação
Morfológico
Normalização
Agrupamento
- PoolMéd.1D
- PoolMéd.2D
- MédiaPool3D
- MaxPool1D
- MaxPool2D
- MaxPool3D
- FracionárioMaxPool2D
- PoolMédiaGlobal1D
- GlobalAvgPool2D
- GlobalAvgPool3D
- GlobalMaxPool1D
- GlobalMaxPool2D
- GlobalMaxPool3D
Redes neurais recorrentes
Remodelando
Aumento da resolução
Otimizadores
Os otimizadores são um componente chave no treinamento de um modelo de aprendizado de máquina, atualizando o modelo com base em um gradiente calculado. Idealmente, essas atualizações ajustarão os parâmetros de um modelo de forma a treiná-lo.
Para usar um otimizador, primeiro inicialize-o para um modelo de destino com parâmetros de treinamento apropriados:
let optimizer = RMSProp(for: model, learningRate: 0.0001, decay: 1e-6)
Treine um modelo obtendo um gradiente em relação à entrada e uma função de perda e, em seguida, atualize o modelo ao longo desse gradiente usando seu otimizador:
optimizer.update(&model, along: gradients)
Otimizadores integrados
Vários otimizadores comuns são fornecidos pelo Swift para TensorFlow. Isso inclui o seguinte: