Lớp

Các lớp sau đây có sẵn trên toàn cầu.

  • Một tham chiếu có thể thay đổi, có thể chia sẻ, sở hữu một tensor.

    Tuyên ngôn 

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

  • Lớp gói một con trỏ C vào TensorHandle. Lớp này sở hữu TensorHandle và chịu trách nhiệm phá hủy nó.

    Tuyên ngôn 

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

  • Trình tối ưu hóa RMSProp.

    Triển khai thuật toán tối ưu hóa RMSProp. RMSProp là một dạng giảm độ dốc ngẫu nhiên trong đó độ dốc được chia cho mức trung bình đang chạy của cường độ gần đây của chúng. RMSProp giữ mức trung bình động của gradient bình phương cho mỗi trọng số.

    Tài liệu tham khảo:

    Tuyên ngôn 

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

  • Trình tối ưu hóa AdaGrad.

    Triển khai thuật toán tối ưu hóa AdaGrad (độ dốc thích ứng). AdaGrad có tốc độ học theo tham số cụ thể, được điều chỉnh tương ứng với tần suất cập nhật tham số trong quá trình đào tạo. Các tham số nhận được nhiều cập nhật hơn có tỷ lệ học tập nhỏ hơn.

    AdaGrad điều chỉnh riêng tốc độ học của tất cả các tham số mô hình bằng cách chia tỷ lệ chúng tỷ lệ nghịch với căn bậc hai của tổng bình phương của định mức độ dốc.

    Tham khảo: “Các phương pháp phân cấp thích ứng cho việc học trực tuyến và tối ưu hóa ngẫu nhiên” (Duchi et al, 2011)

    Tuyên ngôn 

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

  • Trình tối ưu hóa AdaDelta.

    Triển khai thuật toán tối ưu hóa AdaDelta. AdaDelta là phương pháp giảm độ dốc ngẫu nhiên dựa trên thông tin thứ tự đầu tiên. Nó điều chỉnh tốc độ học dựa trên cửa sổ chuyển động của các cập nhật độ dốc, thay vì tích lũy tất cả các độ dốc trong quá khứ. Vì vậy, AdaDelta vẫn tiếp tục học hỏi ngay cả khi đã thực hiện nhiều cập nhật. Nó thích ứng nhanh hơn với sự thay đổi động lực của không gian bài toán tối ưu hóa.

    Tham khảo: “ADADELTA: Phương pháp tỷ lệ học tập thích ứng” (Zeiler, 2012)

    Tuyên ngôn 

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

  • Trình tối ưu hóa Adam.

    Triển khai thuật toán tối ưu hóa Adam. Adam là một phương pháp giảm độ dốc ngẫu nhiên để tính toán tốc độ học thích ứng riêng lẻ cho các tham số khác nhau từ ước tính mô men bậc một và bậc hai của độ dốc.

    Tham khảo: “Adam: Phương pháp tối ưu hóa ngẫu nhiên” (Kingma và Ba, 2014).

    Ví dụ:

    • Đào tạo một tác nhân học tăng cường đơn giản:
    ...
// 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)
    ...
    }
}
    • Huấn luyện một mạng lưới đối thủ tổng quát (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)
        }
}

    Tuyên ngôn 

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

  • Trình tối ưu hóa AdaMax.

    Một biến thể của Adam dựa trên chuẩn mực vô cực.

    Tham khảo: Phần 7 của “Adam - Phương pháp tối ưu hóa ngẫu nhiên”

    Tuyên ngôn 

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

  • Trình tối ưu hóa AMSGrad.

    Thuật toán này là sự sửa đổi của Adam với đặc tính hội tụ tốt hơn khi gần với tối ưu cục bộ.

    Tham khảo: “Về sự hội tụ của Adam và thế giới bên kia”

    Tuyên ngôn 

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

  • Trình tối ưu hóa RAdam.

    Đã chỉnh sửa Adam, một biến thể của Adam giới thiệu một thuật ngữ để điều chỉnh phương sai tốc độ học thích ứng.

    Tham khảo: “Về sự khác biệt giữa tỷ lệ học tập thích ứng và xa hơn”

    Tuyên ngôn 

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

  • Một chuỗi vô hạn các bộ sưu tập các lô mẫu phù hợp để huấn luyện DNN khi các mẫu có kích thước không đồng đều.

    Các đợt trong mỗi kỷ nguyên:

    • tất cả đều có số lượng mẫu giống hệt nhau.
    • được hình thành từ các mẫu có kích thước tương tự nhau.
    • bắt đầu với một lô có kích thước mẫu tối đa là kích thước tối đa trên tất cả các mẫu được sử dụng trong kỷ nguyên.

    Tuyên ngôn 

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

  • Trình tối ưu hóa chung có thể thể hiện nhiều tối ưu hóa có thể. Trình tối ưu hóa bao gồm ánh xạ từ ParameterGroup đến ParameterGroupOptimizer. Trình tối ưu hóa này cũng chứa số lượng phần tử hoạt động trong tổng bản sao chéo. Điều này mang lại hiệu quả trong việc ngăn chặn nhiều lần lặp lại không hiệu quả trên gradient.

    Tuyên ngôn 

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

    Trình tối ưu hóa giảm độ dốc ngẫu nhiên (SGD).

    Triển khai thuật toán giảm độ dốc ngẫu nhiên với sự hỗ trợ cho động lượng, giảm tốc độ học tập và động lượng Nesterov. Động lượng và động lượng Nesterov (hay còn gọi là phương pháp tăng tốc độ dốc của Nesterov) là các phương pháp tối ưu hóa bậc nhất có thể cải thiện tốc độ huấn luyện và tốc độ hội tụ của quá trình giảm độ dốc.

    Tài liệu tham khảo:

    Tuyên ngôn 

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

  • Một chuỗi vô hạn các bộ sưu tập mẫu lô phù hợp để huấn luyện DNN khi các mẫu đồng nhất.

    Các lô trong mỗi kỷ nguyên đều có cùng kích thước.

    Tuyên ngôn 

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

  • Tuyên ngôn 

    public class EpochPipelineQueue

  • Trạng thái của vòng lặp huấn luyện trên thiết bị.

    Tuyên ngô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