Clases

Las siguientes clases están disponibles a nivel mundial.

  • Una referencia mutable, compartible y propietaria de un tensor.

    Declaración

    public final class Parameter<Scalar> where Scalar : TensorFlowScalar
    extension Parameter: CopyableToDevice

  • Clase que ajusta un puntero C a un TensorHandle. Esta clase posee TensorHandle y es responsable de destruirlo.

    Declaración

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

  • Un optimizador de RMSProp.

    Implementa el algoritmo de optimización RMSProp. RMSProp es una forma de descenso de gradiente estocástico donde los gradientes se dividen por un promedio móvil de su magnitud reciente. RMSProp mantiene un promedio móvil del gradiente al cuadrado para cada peso.

    Referencias:

    Declaración

    public class RMSProp<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Un optimizador de AdaGrad.

    Implementa el algoritmo de optimización AdaGrad (gradiente adaptativo). AdaGrad tiene tasas de aprendizaje específicas de parámetros, que se adaptan en relación con la frecuencia con la que se actualizan los parámetros durante el entrenamiento. Los parámetros que reciben más actualizaciones tienen tasas de aprendizaje más pequeñas.

    AdaGrad adapta individualmente las tasas de aprendizaje de todos los parámetros del modelo al escalarlos inversamente proporcionales a la raíz cuadrada de la suma acumulada de cuadrados de las normas de gradiente.

    Referencia: "Métodos adaptativos de subgradiente para el aprendizaje en línea y la optimización estocástica" (Duchi et al, 2011)

    Declaración

    public class AdaGrad<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Un optimizador AdaDelta.

    Implementa el algoritmo de optimización AdaDelta. AdaDelta es un método de descenso de gradiente estocástico basado en información de primer orden. Adapta las tasas de aprendizaje en función de una ventana móvil de actualizaciones de gradientes, en lugar de acumular todos los gradientes anteriores. Por lo tanto, AdaDelta continúa aprendiendo incluso cuando se han realizado muchas actualizaciones. Se adapta más rápido a la dinámica cambiante del espacio del problema de optimización.

    Referencia: “ADADELTA: Un método de tasa de aprendizaje adaptativo” (Zeiler, 2012)

    Declaración

    public class AdaDelta<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Optimizador de Adam.

    Implementa el algoritmo de optimización de Adam. Adam es un método de descenso de gradiente estocástico que calcula tasas de aprendizaje adaptativo individuales para diferentes parámetros a partir de estimaciones de momentos de primer y segundo orden de los gradientes.

    Referencia: "Adam: un método para la optimización estocástica" (Kingma y Ba, 2014).

    Ejemplos:

    • Entrene un agente de aprendizaje por refuerzo simple:
    ...
// Instantiate an agent's policy - approximated by the neural network (`net`) after defining it 
in advance.
var net = Net(observationSize: Int(observationSize), hiddenSize: hiddenSize, actionCount: actionCount)
// Define the Adam optimizer for the network with a learning rate set to 0.01.
let optimizer = Adam(for: net, learningRate: 0.01)
...
// Begin training the agent (over a certain number of episodes).
while true {
...
    // Implementing the gradient descent with the Adam optimizer:
    // Define the gradients (use withLearningPhase to call a closure under a learning phase).
    let gradients = withLearningPhase(.training) {
        TensorFlow.gradient(at: net) { net -> Tensor<Float> in
            // Return a softmax (loss) function
            return loss = softmaxCrossEntropy(logits: net(input), probabilities: target)
        }
    }
    // Update the differentiable variables of the network (`net`) along the gradients with the Adam 
optimizer.
    optimizer.update(&net, along: gradients)
    ...
    }
}
    • Entrene una red generativa adversaria (GAN):
    ...
// Instantiate the generator and the discriminator networks after defining them.
var generator = Generator()
var discriminator = Discriminator()
// Define the Adam optimizers for each network with a learning rate set to 2e-4 and beta1 - to 0.5.
let adamOptimizerG = Adam(for: generator, learningRate: 2e-4, beta1: 0.5)
let adamOptimizerD = Adam(for: discriminator, learningRate: 2e-4, beta1: 0.5)
...
Start the training loop over a certain number of epochs (`epochCount`).
for epoch in 1...epochCount {
    // Start the training phase.
    ...
    for batch in trainingShuffled.batched(batchSize) {
        // Implementing the gradient descent with the Adam optimizer:
        // 1) Update the generator.
        ...
        let 𝛁generator = TensorFlow.gradient(at: generator) { generator -> Tensor<Float> in
            ...
            return loss
            }
        // Update the differentiable variables of the generator along the gradients (`𝛁generator`) 
        // with the Adam optimizer.
        adamOptimizerG.update(&generator, along: 𝛁generator)

        // 2) Update the discriminator.
        ...
        let 𝛁discriminator = TensorFlow.gradient(at: discriminator) { discriminator -> Tensor<Float> in
            ...
            return loss
        }
        // Update the differentiable variables of the discriminator along the gradients (`𝛁discriminator`) 
        // with the Adam optimizer.
        adamOptimizerD.update(&discriminator, along: 𝛁discriminator)
        }
}

    Declaración

    public class Adam<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Optimizador AdaMax.

    Una variante de Adán basada en la norma del infinito.

    Referencia: Sección 7 de “Adam: un método para la optimización estocástica”

    Declaración

    public class AdaMax<Model: Differentiable & KeyPathIterable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Optimizador AMSGrad.

    Este algoritmo es una modificación de Adam con mejores propiedades de convergencia cuando está cerca de los óptimos locales.

    Referencia: “Sobre la convergencia de Adán y el más allá”

    Declaración

    public class AMSGrad<Model: Differentiable & KeyPathIterable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Optimizador RAdam.

    Adam rectificado, una variante de Adam que introduce un término para rectificar la variación de la tasa de aprendizaje adaptativo.

    Referencia: "Sobre la variación de la tasa de aprendizaje adaptativo y más allá"

    Declaración

    public class RAdam<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Una secuencia infinita de colecciones de lotes de muestras adecuadas para entrenar un DNN cuando las muestras no tienen un tamaño uniforme.

    Los lotes en cada época:

    • todos tienen exactamente el mismo número de muestras.
    • se forman a partir de muestras de tamaño similar.
    • comience con un lote cuyo tamaño máximo de muestra sea el tamaño máximo de todas las muestras utilizadas en la época.

    Declaración

    public final class NonuniformTrainingEpochs<
  Samples: Collection,
  Entropy: RandomNumberGenerator
>: Sequence, IteratorProtocol

  • Optimizador general que debería poder expresar múltiples optimizaciones posibles. El optimizador se compone de una asignación de ParameterGroup a ParameterGroupOptimizer. Este optimizador también contiene la cantidad de elementos que trabajan en una suma de réplicas cruzadas. Esto es por motivos de eficiencia para evitar múltiples iteraciones ineficientes sobre el gradiente.

    Declaración

    public class GeneralOptimizer<Model: EuclideanDifferentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float
  • SGD

    Un optimizador de descenso de gradiente estocástico (SGD).

    Implementa el algoritmo de descenso de gradiente estocástico con soporte para impulso, caída de la tasa de aprendizaje e impulso de Nesterov. El impulso y el impulso de Nesterov (también conocido como método de gradiente acelerado de Nesterov) son métodos de optimización de primer orden que pueden mejorar la velocidad de entrenamiento y la tasa de convergencia del descenso de gradiente.

    Referencias:

    Declaración

    public class SGD<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • Una secuencia infinita de colecciones de muestras por lotes adecuadas para entrenar un DNN cuando las muestras son uniformes.

    Todos los lotes de cada época tienen exactamente el mismo tamaño.

    Declaración

    public final class TrainingEpochs<
  Samples: Collection,
  Entropy: RandomNumberGenerator
>: Sequence, IteratorProtocol

  • Declaración

    public class EpochPipelineQueue

  • El estado de un bucle de entrenamiento en un dispositivo.

    Declaración

    public class ThreadState<Model: Layer, Opt: Optimizer>
where
  Opt.Model == Model, Opt.Scalar == Float, Model.Input == Tensor<Float>,
  Model.Output == Tensor<Float>,
  Model.TangentVector.VectorSpaceScalar == Float