Proprio come Tensor
è il nostro elemento fondamentale per il calcolo parallelo accelerato, la maggior parte dei modelli e delle operazioni di machine learning saranno espressi in termini del protocollo Layer
. Layer
definisce un'interfaccia per i tipi che accettano un input differenziabile, lo elaborano e producono un output differenziabile. Un Layer
può contenere stati, ad esempio pesi addestrabili.
Layer
è un perfezionamento del protocollo Module
, in cui Module
definisce il caso più generale in cui l'input del tipo non è necessariamente differenziabile. La maggior parte dei componenti di un modello si occuperà di input differenziabili, ma ci sono casi in cui i tipi potrebbero invece dover conformarsi al Module
.
Se crei un'operazione che non contiene parametri addestrabili al suo interno, ti consigliamo di definirla in termini di ParameterlessLayer
anziché Layer
.
I modelli stessi sono spesso definiti come Layer
e sono regolarmente composti da altri Layer
. Un modello o una subunità che è stata definita come Layer
può essere trattata come qualsiasi altro Layer
, consentendo la costruzione di modelli arbitrariamente complessi da altri modelli o subunità.
Per definire un Layer
personalizzato per un modello o un'operazione di tua scelta, generalmente seguirai un modello simile a questo:
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 ...
}
}
I componenti addestrabili dei Layers
, come pesi e bias, così come altri Layer
, possono essere dichiarati come proprietà. Un inizializzatore personalizzato è una buona posizione per esporre parametri personalizzabili per un modello, ad esempio un numero variabile di livelli o la dimensione di output di un modello di classificazione. Infine, il nucleo del Layer
è callAsFunction()
, dove definirai i tipi per l'input e l'output, nonché la trasformazione che ne accetta uno e restituisce l'altro.
Strati incorporati
Molte operazioni comuni di machine learning sono state incapsulate come Layer
da utilizzare durante la definizione di modelli o sottounità. Di seguito è riportato l'elenco dei layer forniti da Swift per TensorFlow, raggruppati per aree funzionali:
Aumento
Convoluzione
- Conv1D
- Conv2D
- Conv3D
- Denso
- ProfonditàConv2D
- SeparabileConv1D
- SeparabileConv2D
- TraspostoConv1D
- TraspostoConv2D
- TraspostoConv3D
- ZeroPadding1D
- ZeroPadding2D
- ZeroPadding3D
Incorporamento
Morfologico
Normalizzazione
Raggruppamento
- AvgPool1D
- AvgPool2D
- AvgPool3D
- MaxPool1D
- MaxPool2D
- MaxPool3D
- FractionalMaxPool2D
- GlobalAvgPool1D
- GlobalAvgPool2D
- GlobalAvgPool3D
- GlobalMaxPool1D
- GlobalMaxPool2D
- GlobalMaxPool3D
Reti neurali ricorrenti
Rimodellamento
Upsampling
Ottimizzatori
Gli ottimizzatori sono un componente chiave dell'addestramento di un modello di machine learning, aggiornando il modello in base a un gradiente calcolato. Questi aggiornamenti idealmente regoleranno i parametri di un modello in modo tale da addestrare il modello.
Per utilizzare un ottimizzatore, inizializzarlo innanzitutto per un modello di destinazione con parametri di training appropriati:
let optimizer = RMSProp(for: model, learningRate: 0.0001, decay: 1e-6)
Addestra un modello ottenendo un gradiente rispetto all'input e una funzione di perdita, quindi aggiorna il modello lungo quel gradiente utilizzando l'ottimizzatore:
optimizer.update(&model, along: gradients)
Ottimizzatori integrati
Diversi ottimizzatori comuni sono forniti da Swift per TensorFlow. Questi includono quanto segue: