Zajęcia

Poniższe klasy są dostępne na całym świecie.

  • Zmienne, udostępniane i posiadające odniesienie do tensora.

    Deklaracja

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

  • Klasa zawijająca wskaźnik C do TensorHandle. Ta klasa jest właścicielem TensorHandle i jest odpowiedzialna za jego zniszczenie.

    Deklaracja

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

  • Optymalizator RMSProp.

    Implementuje algorytm optymalizacji RMSProp. RMSProp jest formą stochastycznego opadania gradientu, w której gradienty są dzielone przez średnią kroczącą ich ostatniej wielkości. RMSProp utrzymuje średnią ruchomą kwadratu gradientu dla każdej wagi.

    Bibliografia:

    Deklaracja

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

  • Optymalizator AdaGrad.

    Implementuje algorytm optymalizacji AdaGrad (gradient adaptacyjny). AdaGrad ma szybkości uczenia się specyficzne dla parametrów, które są dostosowywane w zależności od częstotliwości aktualizacji parametrów podczas szkolenia. Parametry, które otrzymują więcej aktualizacji, mają mniejszą szybkość uczenia się.

    AdaGrad indywidualnie dostosowuje szybkość uczenia się wszystkich parametrów modelu, skalując je odwrotnie proporcjonalnie do pierwiastka kwadratowego z bieżącej sumy kwadratów norm gradientu.

    Odniesienie: „Adaptacyjne metody subgradientowe do uczenia się online i optymalizacji stochastycznej” (Duchi i in., 2011)

    Deklaracja

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

  • Optymalizator AdaDelta.

    Implementuje algorytm optymalizacji AdaDelta. AdaDelta to metoda stochastycznego opadania w gradiencie, oparta na informacjach pierwszego rzędu. Dostosowuje tempo uczenia się w oparciu o ruchome okno aktualizacji gradientów, zamiast gromadzić wszystkie przeszłe gradienty. W ten sposób AdaDelta kontynuuje naukę nawet po dokonaniu wielu aktualizacji. Szybciej dostosowuje się do zmieniającej się dynamiki przestrzeni problemowej optymalizacji.

    Odniesienie: „ADADELTA: Metoda adaptacyjnego tempa uczenia się” (Zeiler, 2012)

    Deklaracja

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

  • Optymalizator Adama.

    Implementuje algorytm optymalizacji Adama. Adam to stochastyczna metoda gradientowego opadania, która oblicza indywidualne szybkości uczenia się adaptacyjnego dla różnych parametrów na podstawie szacunków momentów gradientów pierwszego i drugiego rzędu.

    Odniesienie: „Adam: metoda optymalizacji stochastycznej” (Kingma i Ba, 2014).

    Przykłady:

    • Wytrenuj prostego agenta uczenia się przez wzmacnianie:
    ...
// 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)
    ...
    }
}
    • Trenuj generatywną sieć kontradyktoryjną (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)
        }
}

    Deklaracja

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

  • Optymalizator AdaMax.

    Wariant Adama oparty na normie nieskończoności.

    Odniesienie: Sekcja 7 książki „Adam – metoda optymalizacji stochastycznej”

    Deklaracja

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

  • Optymalizator AMSGrad.

    Algorytm ten jest modyfikacją Adama o lepszych właściwościach zbieżności, gdy jest blisko lokalnych optimów.

    Odniesienie: „O zbieżności Adama i później”

    Deklaracja

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

  • Optymalizator RAdam.

    Rectified Adam, odmiana Adama, która wprowadza termin korygujący wariancję adaptacyjnego tempa uczenia się.

    Odniesienie: „O wariancjach adaptacyjnego tempa uczenia się i nie tylko”

    Deklaracja

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

  • Nieskończona sekwencja kolekcji partii próbek odpowiednich do szkolenia DNN, gdy próbki nie mają jednakowej wielkości.

    Partie w każdej epoce:

    • wszystkie mają dokładnie tę samą liczbę próbek.
    • powstają z próbek o podobnej wielkości.
    • rozpocząć od partii, której maksymalna wielkość próbki jest maksymalną wielkością spośród wszystkich próbek użytych w epoce.

    Deklaracja

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

  • Ogólny optymalizator, który powinien być w stanie wyrazić wiele możliwych optymalizacji. Optymalizator składa się z mapowania z ParameterGroup na ParameterGroupOptimizer. Optymalizator ten zawiera także liczbę elementów pracujących w sumie między replikami. Ma to na celu zapewnienie wydajności i zapobieganie wielokrotnym nieefektywnym iteracjom w gradiencie.

    Deklaracja

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

    Optymalizator stochastycznego gradientu opadania (SGD).

    Implementuje algorytm stochastycznego gradientu opadania z obsługą pędu, zaniku szybkości uczenia się i pędu Niestierowa. Pęd i pęd Niestierowa (inaczej metoda przyspieszonego gradientu Niestierowa) to metody optymalizacji pierwszego rzędu, które mogą poprawić prędkość uczenia i współczynnik zbieżności opadania gradientu.

    Bibliografia:

    Deklaracja

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

  • Nieskończona sekwencja kolekcji próbek wsadowych odpowiednich do szkolenia DNN, gdy próbki są jednolite.

    Wszystkie partie w każdej epoce mają dokładnie tę samą wielkość.

    Deklaracja

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

  • Deklaracja

    public class EpochPipelineQueue

  • Stan pętli szkoleniowej na urządzeniu.

    Deklaracja

    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