คลาส

คลาสต่อไปนี้มีให้บริการทั่วโลก

  • การอ้างอิงที่ไม่แน่นอน แชร์ได้ และเป็นเจ้าของเทนเซอร์

    คำประกาศ 

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

  • คลาสล้อมตัวชี้ C ไปที่ TensorHandle คลาสนี้เป็นเจ้าของ TensorHandle และมีหน้าที่ทำลายมัน

    คำประกาศ 

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

  • เครื่องมือเพิ่มประสิทธิภาพ RMSProp

    ใช้อัลกอริทึมการปรับให้เหมาะสม RMSProp RMSProp คือรูปแบบหนึ่งของการไล่ระดับสีแบบสุ่ม โดยที่การไล่ระดับสีจะถูกหารด้วยค่าเฉลี่ยรันของขนาดล่าสุด RMSProp เก็บค่าเฉลี่ยเคลื่อนที่ของการไล่ระดับสีกำลังสองสำหรับแต่ละน้ำหนัก

    อ้างอิง:

    คำประกาศ 

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

  • เครื่องมือเพิ่มประสิทธิภาพ AdaGrad

    ใช้อัลกอริธึมการปรับให้เหมาะสมของ AdaGrad (การไล่ระดับสีแบบปรับได้) AdaGrad มีอัตราการเรียนรู้เฉพาะพารามิเตอร์ ซึ่งได้รับการปรับให้สัมพันธ์กับความถี่ที่พารามิเตอร์ได้รับการอัปเดตระหว่างการฝึก พารามิเตอร์ที่ได้รับการอัพเดตมากขึ้นจะมีอัตราการเรียนรู้ที่น้อยลง

    AdaGrad จะปรับอัตราการเรียนรู้ของพารามิเตอร์โมเดลทั้งหมดเป็นรายบุคคล โดยปรับขนาดให้เป็นสัดส่วนผกผันกับรากที่สองของผลรวมกำลังสองของบรรทัดฐานการไล่ระดับสี

    การอ้างอิง: “วิธีการปรับย่อยแบบปรับเปลี่ยนได้สำหรับการเรียนรู้ออนไลน์และการเพิ่มประสิทธิภาพสุ่ม” (Duchi et al, 2011)

    คำประกาศ 

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

  • เครื่องมือเพิ่มประสิทธิภาพ AdaDelta

    ใช้อัลกอริธึมการปรับให้เหมาะสมของ AdaDelta AdaDelta เป็นวิธีการสุ่มไล่ระดับตามข้อมูลลำดับแรก โดยจะปรับอัตราการเรียนรู้ตามหน้าต่างที่เคลื่อนไหวของการอัพเดตการไล่ระดับสี แทนที่จะสะสมการไล่ระดับสีที่ผ่านมาทั้งหมด ดังนั้น AdaDelta จึงเรียนรู้ต่อไปแม้ว่าจะมีการอัพเดตหลายครั้งก็ตาม ปรับให้เข้ากับการเปลี่ยนแปลงไดนามิกของพื้นที่ปัญหาการปรับให้เหมาะสมได้เร็วขึ้น

    อ้างอิง: “ADADELTA: วิธีอัตราการเรียนรู้แบบปรับตัว” (Zeiler, 2012)

    คำประกาศ 

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

  • อดัม ออพติไมเซอร์

    ใช้อัลกอริธึมการปรับให้เหมาะสมของ Adam อดัมเป็นวิธีการสุ่มไล่ระดับที่คำนวณอัตราการเรียนรู้แบบปรับตัวของแต่ละบุคคลสำหรับพารามิเตอร์ที่ต่างกันจากการประมาณค่าโมเมนต์การไล่ระดับสีลำดับที่หนึ่งและที่สอง

    อ้างอิง: “อดัม: วิธีการเพิ่มประสิทธิภาพสุ่ม” (Kingma and Ba, 2014)

    ตัวอย่าง:

    • ฝึกอบรมตัวแทนการเรียนรู้การเสริมกำลังอย่างง่าย:
    ...
// 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)
    ...
    }
}
    • ฝึกอบรมเครือข่ายปฏิปักษ์เชิงสร้างสรรค์ (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)
        }
}

    คำประกาศ 

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

  • เครื่องมือเพิ่มประสิทธิภาพ AdaMax

    ตัวแปรของอดัมที่มีพื้นฐานอยู่บนบรรทัดฐานอันไม่มีที่สิ้นสุด

    อ้างอิง: ส่วนที่ 7 ของ “อดัม - วิธีเพิ่มประสิทธิภาพสุ่ม”

    คำประกาศ 

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

  • เครื่องมือเพิ่มประสิทธิภาพ AMSGrad

    อัลกอริทึมนี้เป็นการดัดแปลง Adam ที่มีคุณสมบัติการลู่เข้าที่ดีขึ้นเมื่อใกล้กับ optima ในพื้นที่

    อ้างอิง: “เรื่องการมาบรรจบกันของอาดัมและอนาคต”

    คำประกาศ 

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

  • โปรแกรมเพิ่มประสิทธิภาพ RAdam

    Rectified Adam ซึ่งเป็นอีกรูปแบบหนึ่งของ Adam ที่แนะนำคำศัพท์เพื่อแก้ไขความแปรปรวนของอัตราการเรียนรู้แบบปรับตัว

    อ้างอิง: “เกี่ยวกับความแปรปรวนของอัตราการเรียนรู้แบบปรับตัวและอื่นๆ”

    คำประกาศ 

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

  • ลำดับการรวบรวมชุดตัวอย่างที่ไม่สิ้นสุดซึ่งเหมาะสำหรับการฝึกอบรม DNN เมื่อตัวอย่างมีขนาดไม่เท่ากัน

    แบทช์ในแต่ละยุค:

    • ทั้งหมดมีจำนวนตัวอย่างเท่ากันทุกประการ
    • เกิดจากตัวอย่างที่มีขนาดใกล้เคียงกัน
    • เริ่มต้นด้วยแบทช์ที่มีขนาดตัวอย่างสูงสุดคือขนาดสูงสุดเหนือตัวอย่างทั้งหมดที่ใช้ในยุคนั้น

    คำประกาศ 

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

  • เครื่องมือเพิ่มประสิทธิภาพทั่วไปที่ควรสามารถแสดงการเพิ่มประสิทธิภาพที่เป็นไปได้หลายประการ เครื่องมือเพิ่มประสิทธิภาพประกอบด้วยการแมปจาก ParameterGroup ไปยัง ParameterGroupOptimizer เครื่องมือเพิ่มประสิทธิภาพนี้ยังมีจำนวนองค์ประกอบที่ทำงานในผลรวมของแบบจำลองข้าม นี่เป็นเพื่อประสิทธิภาพในการป้องกันการวนซ้ำที่ไม่มีประสิทธิภาพหลายครั้งในการไล่ระดับสี

    คำประกาศ 

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

  • เครื่องมือเพิ่มประสิทธิภาพการไล่ระดับสีสุ่ม (SGD)

    ใช้อัลกอริธึมการไล่ระดับสีแบบสุ่มโดยรองรับโมเมนตัม การสลายตัวของอัตราการเรียนรู้ และโมเมนตัม Nesterov โมเมนตัมและโมเมนตัม Nesterov (หรือที่รู้จักในชื่อวิธีการไล่ระดับแบบเร่ง Nesterov) เป็นวิธีการปรับให้เหมาะสมลำดับแรกที่สามารถปรับปรุงความเร็วการฝึกและอัตราการบรรจบกันของการไล่ระดับลง

    อ้างอิง:

    คำประกาศ 

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

  • การรวบรวมตัวอย่างเป็นชุดที่ไม่มีที่สิ้นสุดซึ่งเหมาะสำหรับการฝึกอบรม DNN เมื่อตัวอย่างมีความสม่ำเสมอ

    ชุดงานในแต่ละยุคทั้งหมดมีขนาดเท่ากันทุกประการ

    คำประกาศ 

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

  • คำประกาศ 

    public class EpochPipelineQueue

  • สถานะของลูปการฝึกบนอุปกรณ์

    คำประกาศ 

    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