คลาส

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

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

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

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

อ้างอิง:

• “การบรรยาย 6.5 - rmsprop: หารการไล่ระดับสีด้วยค่าเฉลี่ยรันของขนาดล่าสุด” (Tieleman และ Hinton, 2012)
• “การสร้างลำดับด้วยโครงข่ายประสาทเทียมที่เกิดซ้ำ” (Graves, 2013)

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

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

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

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

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

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

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

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

ใช้อัลกอริธึมการปรับให้เหมาะสมของ 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)
        }
}       

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

อ้างอิง:

• “วิธีการประมาณค่าสุ่ม” (Robbins and Monro, 1951)
• “เกี่ยวกับวิธีการประมาณค่าสุ่มของร็อบบินส์และมอนโร” (Wolfowitz, 1952)
• “การประมาณค่าสุ่มสูงสุดของฟังก์ชันการถดถอย” (Kiefer และ Wolfowitz, 1952)
• “วิธีการบางอย่างในการเร่งการบรรจบกันของวิธีการวนซ้ำ” (Polyak, 1964)
• “วิธีการสำหรับปัญหาการลดขนาดนูนที่ไม่มีข้อจำกัดด้วยอัตราการลู่เข้า” (Nesterov, 1983)

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

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

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