สวัสดีและยินดีต้อนรับสู่ส่วนที่น่าตื่นเต้นสุด ๆ ของการสร้างสรรค์ของเรา ส่วนที่เราทำให้มันฉลาด
นั่นคือสิ่งที่เกิดขึ้นเมื่อการฝึกอบรม AI จะฝึกความฉลาดของมันเพื่อบรรลุเป้าหมายที่เราต้องการให้สำเร็จ
และในการทำเช่นนี้ เราจะฝึกโครงข่ายประสาทโดยพื้นฐาน ให้แสดงผลการทำนายที่ถูกต้อง จากนั้นทุกอย่างก็พร้อมแล้ว
เพราะสัญญาณเอาท์พุตเหล่านี้จากสมอง มีการส่งสัญญาณที่ถูกต้องไปยังร่างกายแล้ว เพื่อดำเนินการขั้นสุดท้าย
โดยพื้นฐานแล้วตอนนี้สิ่งที่เรากำลังจะทำคือสิ่งที่เราเคยทำมาก่อน
เราแค่จะสุ่มแบทช์จากหน่วยความจำ รับอินพุตของเราจากตัวอย่างเหล่านี้ รับเอาต์พุต
รับเป้าหมาย รับการคาดการณ์ คำนวณพื้นที่สุดท้ายระหว่างการคาดการณ์กับเป้าหมาย จากนั้นดำเนินการถ่ายทอดย้อนหลังด้วยสุ่ม
การลงระดับการไล่ระดับสีเพื่ออัปเดตน้ำหนักตามจำนวนที่ก่อให้เกิดข้อผิดพลาดครั้งล่าสุดนี้
ลองทำทั้งหมดนี้
คุณจะเห็นว่ามันง่ายขนาดไหน เพราะเรามีเครื่องมือทั้งหมดสำหรับใช้งานสิ่งนี้แล้ว
ไม่เพียงแต่เรามีเครื่องมือ PyTorch เช่น Optimizer และฟังก์ชันที่หายไป แต่เรายังมีคลาสทั้งหมดที่เราทำมาก่อน
เช่น สมองของเรา ซึ่งเราจะใช้สำหรับการทำนาย
จากนั้นประสบการณ์ การเล่นซ้ำ การนำไปใช้ การติดตามสิทธิ์ และเครื่องมือทั้งหมดเหล่านี้ที่รวมเข้ากับเครื่องมือ
PyTorch จะทำให้การฝึกอบรมมีประสิทธิภาพสูงสุด และในที่สุดเราจะได้รับ AI ที่ทรงพลัง
เรามาทำให้การฝึกอบรมนี้เกิดขึ้นกันเถอะ
มาทำให้ AI ของเราฉลาดขึ้น
และสิ่งแรกที่เราจะทำในตอนนี้คือรับฟังก์ชันสุดท้ายที่เราจะใช้ในระหว่างการฝึกอบรมเมื่อคำนวณข้อผิดพลาดและเครื่องมือเพิ่มประสิทธิภาพ
นั่นคือสิ่งแรกที่เราจะทำ
เรามาสร้างตัวแปรสำหรับฟังก์ชันสุดท้ายกัน
เราจะเรียกมันว่าการสูญเสีย
และจะเท่ากับฟังก์ชันการสูญเสียของ MSI จากโมดูล RN
และการสูญเสีย MSI นั้น นั่นคือฟังก์ชันสุดท้ายที่เราจะใช้ เพราะโดยพื้นฐานแล้ว การคาดคะเนของเราคือค่า
Q
เรากำลังคาดการณ์ค่า Q ของการกระทำต่างๆ
และเนื่องจากพวกนี้เป็นจำนวนจริง เรากำลังทำโครงข่ายประสาทสำหรับการถดถอย ดังนั้นฟังก์ชันสุดท้ายคือความคลาดเคลื่อนกำลังสองเฉลี่ย
นั่นคือฟังก์ชันสุดท้ายที่เราใช้โดยทั่วไปสำหรับการถดถอย
ไม่เป็นไร.
ตอนนี้เรามีฟังก์ชันสุดท้ายแล้ว มาใช้เครื่องมือเพิ่มประสิทธิภาพของเรากัน
เครื่องมือเพิ่มประสิทธิภาพที่นี่ นั่นคือตัวแปรที่เราสร้างขึ้นสำหรับเครื่องมือเพิ่มประสิทธิภาพ
และเราจะดำเนินการตามปกติ
สำหรับรถยนต์ที่ขับเคลื่อนด้วยตัวเอง Atom Optimizer นั้นเป็นเครื่องมือเพิ่มประสิทธิภาพที่ทรงพลังมาก ที่จะทำงานได้อย่างมหัศจรรย์สำหรับการฝึก
ลองเอาอันนี้ขึ้นไปที่อะตอมนั้นกัน
และจำไว้ว่า นั่นใช่สำหรับรถที่ขับเอง
เราต้องป้อนอาร์กิวเมนต์ที่จำเป็นสองข้อ
อันแรกคืออันที่จะสร้างการเชื่อมต่อระหว่างตัวเพิ่มประสิทธิภาพและพารามิเตอร์ของโครงข่ายประสาทเทียม
นั่นคือน้ำหนักของเซลล์ประสาทในสมองของเรา
และการทำเช่นนี้ เราใช้สมองของเรา ซึ่งเราเรียกว่าซีเอ็นเอ็น
นั่นคือวัตถุที่เราสร้างขึ้นสำหรับสมองของเรา
ดังนั้น CNN จึงไม่จำพารามิเตอร์
เราจะไปที่นั่น.
และวงเล็บบางส่วน
นั่นทำให้การเชื่อมต่อระหว่างเครื่องมือเพิ่มประสิทธิภาพและน้ำหนักของเซลล์ประสาทในสมองของ
AI ของเรา
แล้วอาร์กิวเมนต์ที่สองคืออัตราการเรียนรู้ และนั่นกำหนดโดยข้อผิดพลาด
ดังนั้นที่นี่เราต้องใช้อัตราการเรียนรู้เล็กน้อยเพราะเราไม่ต้องการที่จะมาบรรจบกันเร็วเกินไปและเราต้องการที่จะสำรวจและดังนั้นอัตราการเรียนรู้ที่ดีที่เราสามารถทำได้ที่นี่จึงเป็นอัตราเล็ก
ๆ ที่เป็น 0 01 ที่เปิดอยู่ 1%
ฉันคิดว่ามันเหมือนกับที่เราใช้กับรถยนต์ที่ขับด้วยตนเอง
เอาล่ะ ตอนนี้เรามีฟังก์ชันสุดท้าย ออปติไมเซอร์
ดังนั้นเราเกือบจะพร้อมที่จะเริ่มการวนซ้ำแบบเต็มแล้ว
อันที่จริง เราจะเริ่มการวนซ้ำทั้งหมดในตอนนี้
แต่ก่อนที่เราจะทำ เราจะพิจารณาขนาดของยุคก่อน
เราจะทำการฝึกอบรม AI และด้วยเหตุนี้ ฉันกำลังสร้างตัวแปรใหม่ที่นี่ ซึ่งจะสอดคล้องกับยุคสมัยนี้
และลองตั้งค่าให้เท่ากับ 100
นั่นจะเป็นวิธีที่เพียงพอในการฝึกสายตา
และฉันพนันได้เลยว่า AI จะจัดการไปให้ถึงทางที่ดีที่สุดก่อน 100 เช่น 20 หรือ 30
มาดูกัน.
แต่ตอนนี้ขอ 100 ก่อน
และถ้าเราต้องการ เราจะเพิ่มมัน
แต่ฉันไม่คิดว่าจะมีความจำเป็น
ตกลง.
ดังนั้นเมื่อเรามีจำนวน epochs ของเราแล้ว เราสามารถเริ่มสร้าง for loop นี้ main for loop ของการฝึกอบรม
เมื่อเราฝึก over the epochs
ดังนั้น ตัวแปรแบบวนซ้ำจะเป็นยุค
นั่นคือสิ่งที่เราเลือกสำหรับยุคสมัย
แน่นอนว่า เราจะใช้ฟังก์ชัน range เพื่อบอกว่าเราต้องการเปลี่ยนจากยุคแรกเป็นยุคแรกเป็นจำนวนยุค
บวกหนึ่ง เนื่องจาก โปรดจำไว้ว่า ขอบเขตบนของช่วงจะไม่ถูกรวมอยู่ด้วย
ดังนั้น ถ้าเราต้องการเพิ่มเป็น 100 เราต้องระบุและเป็นกล่องบวกหนึ่งถึง
100
เอาล่ะ คอลิน
และตอนนี้ขอเข้าสู่วง
ไม่เป็นไร.
สิ่งแรกที่เราจะทำคือวิ่ง 200 รอบ 10 ขั้นตอน
ดังนั้นแต่ละยุคจะวิ่ง 200 ครั้ง ต่อจากอีก 10 ก้าว
และเพื่อทำสิ่งนี้ เรามีฟังก์ชันรันสเต็ปจากคลาสรีเพลย์ที่มีประสบการณ์ของเรา
ดังนั้น การใช้ฟังก์ชันนี้ ซึ่งจริงๆ แล้วเป็น method เพราะเราจะได้รับมันจาก
memory object ซึ่งเป็นอ็อบเจ็กต์จาก replay memory class เพื่อสร้าง 200 รัน 10 ขั้นตอนที่เราต้องใช้
memory object
ที่ฉันเตือนว่าเราสร้างขึ้นที่นี่
หน่วยความจำเป็นอ็อบเจ็กต์ของคลาสหน่วยความจำรีเพลย์ที่มีขั้นตอน MN ที่สิบขั้นตอนและความจุ 10,000
เราสร้างอ็อบเจ็กต์นี้และจากอ็อบเจ็กต์นี้ เราทำได้ดี การรัน สเต็ป ฟังก์ชัน รันสเต็ป และเราระบุการรัน
10 ขั้นต่อเนื่องกัน 200 ขั้น
นั่นคือในแต่ละยุคโดยทั่วไปจะวิ่ง 200 ก้าว
และตอนนี้ที่เรามี 200 ขั้นตอนที่ทำงานในแต่ละยุค ก็ถึงเวลาที่จะสุ่มตัวอย่างบางส่วนจากการวิ่งเหล่านี้
และเพื่อสุ่มตัวอย่างแบทช์เหล่านี้
เรามีฟังก์ชันอื่นจากหน่วยความจำของเรา ซึ่งเป็นแบทช์ตัวอย่าง และนั่นจะสร้างแบทช์บางส่วนจากการรัน
200 ครั้งเหล่านี้
แต่จำไว้ว่าแบทช์เหล่านี้เป็นชุดของช่วงการเปลี่ยนภาพตามเวลาเหล่านี้
นั่นคือชุดของขั้นตอนสิบขั้นตอนเมื่อเทียบกับก่อนหน้านี้ โดยที่ชุดงานเป็นเพียงชุดของการเปลี่ยนครั้งเดียวที่นี่
ครั้งนี้จะเป็นแบทช์ 10 ขั้นตอน 10 ทรานสิชั่น และตอนนี้ก็ถึงเวลาที่จะดึงแบทช์สุ่มจากหน่วยความจำของเรา
และเพื่อให้ได้มา เราใช้ฟังก์ชันแบทช์ตัวอย่างที่เราต้องใช้ขนาดแบทช์
และสำหรับขนาดแบทช์ ซึ่งเราสามารถเอา 32 หรือ 64 หรือ 128 ก็ได้
โปรดจำไว้ว่าสำหรับขนาดแบทช์ เป็นเรื่องปกติที่จะใช้
32 นั่นคือสิ่งที่คุณจะเห็นโดยทั่วไปในสถาปัตยกรรมโครงข่ายประสาทเทียมเมื่อทำการเรียนรู้แบบเป็นชุด
แต่ครั้งนี้มันค่อนข้างแตกต่าง
เราแค่สุ่มตัวอย่างเป็นชุดๆ ละ 10 ขั้นตอน ดังนั้นจึงควรเลือกชุดงานที่ใหญ่ขึ้น
นั่นคือเหตุผลที่เราสามารถเอา 64 หรือ 128 ได้
เราจะเอา 128.
และอันที่จริง นี่จะอยู่ในสี่ลูปเพราะเราต้องการรับหลายแบตช์ และเราเอามันกลับมาในฟังก์ชันแบทช์ตัวอย่างนี้
ดังนั้น นี่สำหรับลูปสำหรับแบตช์ในหน่วยความจำ ตัวอย่างแบตช์ 128 หมายความว่าทุกๆ 128 ขั้นตอน
หน่วยความจำของเราจะให้แบตช์ขนาด 128 ซึ่งจะมี 128 ขั้นตอนสุดท้ายที่เพิ่งรันจริง ๆ
เราเพิ่งได้แบตช์ขนาด 128 และการเรียนรู้กำลังจะเกิดขึ้นกับแบตช์เหล่านี้
นอกจากนี้ ภายในกลุ่มเหล่านี้ เราจะมีสิทธิ์ ติดตามการทำงาน คุณรู้ไหม เพื่อเรียนรู้ทุก
ๆ สิบขั้นตอน
ไม่เป็นไร.
ดังนั้นตอนนี้ในลูปนี้ ซึ่งยังคงเกิดขึ้นในยุคหนึ่ง แต่ตอนนี้ เราอยู่ในกลุ่มที่เจาะจง
และตอนนี้ สิ่งแรกที่เราจะทำคือ เราจะได้ข้อมูลและเป้าหมายแยกกัน
และอย่างที่ฉันบอกคุณ มันง่ายมาก
เราสามารถทำได้ด้วยหนึ่งในเครื่องมือที่เรานำมาใช้ ซึ่งก็คือการติดตามการมีสิทธิ์
ดังที่คุณเห็นที่นี่ ฟังก์ชันการติดตามการมีสิทธิ์ใช้แบทช์เป็นอินพุต และตอนนี้เรามีแบทช์และส่งกลับเป็นเอาต์พุต
อินพุต และเป้าหมาย
ดังนั้นตอนนี้ สิ่งที่เราทำได้คือสร้างตัวแปรใหม่ 2 ตัว ซึ่งจะเป็นอินพุตและเป้าหมาย
และทำอินพุตนี้มาที่เป้าหมาย
เท่ากับ
สิ่งที่ส่งคืนฟังก์ชันการติดตามสิทธิ์นี้มีผลกับชุดงาน
ดังนั้นเราจะใช้ฟังก์ชันนี้กับกลุ่มของลูปของเรา
และสิ่งที่เราจะทำก็คือการมีสิทธิ์
การติดตามนำไปใช้กับแบทช์ของลูปของเรา
เอาล่ะ เพื่อให้เราได้รับข้อมูลเข้าและเป้าหมาย
แต่ใน PyTorch มีอะไรอีกมากมายที่เราต้องทำอยู่เสมอ
และแน่นอนว่านี่คือการแปลงอินพุตของโครงข่ายประสาทเทียมและเป้าหมายเป็นตัวแปรการทรมาน
แต่ไม่มีการปล่อย
ไม่มีอะไรใหม่
เรารู้วิธีการทำ
เราสามารถทำได้ด้วยวิธีนี้
เราใช้อินพุตของเรา แล้วก็เป้าหมายของเรา แล้วก็จะเท่ากับอินพุตที่แปรผันได้
นั่นสำหรับอินพุตและตัวแปรเป้าหมาย และสำหรับเป้าหมาย
ไม่เป็นไร.
ดังนั้นอินพุตของสมองจึงถูกแปลงเป็นตัวแปรคบเพลิงและเป้าหมายก็จะถูกแปลงเป็นตัวแปรคบเพลิงด้วย
ตอนนี้เราสามารถรับอินพุตเข้าสู่โครงข่ายประสาทเทียมได้แล้ว
และทำไมเราต้องทำเช่นนี้?
นั่นเป็นเพราะว่าขั้นตอนต่อไปคือการรับการคาดการณ์ที่เรามี ข้อมูลที่เราต้องกำหนดเป้าหมาย
แน่นอน เราต้องการการคาดคะเนของเรา เพราะจากนั้นสิ่งที่เกิดขึ้นคือเราจะคำนวณความสูญเสียระหว่างการคาดคะเนกับเป้าหมาย
ลองรับคำทำนายเหล่านี้เพื่อให้ได้มา
อีกครั้งนี้เป็นเรื่องง่ายมาก
ตอนนี้เราแค่ต้องใช้สมองของเรา ซึ่งก็คือ CNN ซึ่งเป็นโครงข่ายประสาทเทียม และนำไปใช้กับปัจจัยการผลิตของเรา
เราจะไปที่นั่น.
อินพุตจะเข้าสู่โครงข่ายประสาทเทียม และโครงข่ายประสาทเทียมจะส่งออกการคาดการณ์
สมบูรณ์แบบ.
ตอนนี้เรามีการคาดการณ์แล้ว เรามีเป้าหมายเพื่อให้เราขาดทุนได้
และนั่นคือขั้นตอนต่อไป
เราจะแนะนำตัวแปรใหม่เพราะตอนนี้เรากำลังจะได้รับข้อผิดพลาดสุดท้าย ซึ่งแตกต่างจากฟังก์ชันสุดท้าย
เนื่องจากเราใช้ฟังก์ชันสุดท้ายเพื่อรับข้อผิดพลาดสุดท้าย
ข้อผิดพลาดน้อยลงที่นี่และเราจะได้รับด้วยฟังก์ชันสุดท้ายที่ใช้กับการคาดคะเนของเรา
และเป้าหมาย
เราจะไปที่นั่น.
ดูว่าตอนนี้ทุกอย่างราบรื่นแค่ไหน
ทุกอย่างมีเหตุผล
เราได้รับข้อมูลเป้าหมายก่อน
จากนั้นเราก็ได้รับคำทำนาย
และต้องขอบคุณการคาดการณ์และเป้าหมาย เราจึงได้รับข้อผิดพลาดน้อยลง
มีเหตุผลและราบรื่นมาก
และตอนนี้ขั้นตอนต่อไปคืออะไร?
เส้นทางตรรกะเดียวกัน
ตอนนี้เรามีสิ่งสุดท้ายที่เราสามารถย้อนกลับได้ เผยแพร่ข้อผิดพลาดที่น้อยลงนี้กลับเข้าไปในเครือข่ายประสาทเพื่ออัปเดตน้ำหนัก
และเราทำอย่างนั้นด้วยการไล่ระดับสีสุ่มและเพื่อทำการสุ่มตัวอย่างการไล่ระดับสีเราต้องการเครื่องมือเพิ่มประสิทธิภาพของเรา
แต่เราได้มันมาแล้วที่นี่ เครื่องมือเพิ่มประสิทธิภาพอะตอมของเรา
แต่ ณ จุดนี้ จำสิ่งที่เราต้องทำ
เราต้องเริ่มต้นและเริ่มต้นมัน
จำไว้ว่าเราใช้ออบเจ็กต์เครื่องมือเพิ่มประสิทธิภาพของเราแล้วจึงใช้วิธีกริดศูนย์
จากนั้นเราไป
เราไม่ลืมวงเล็บที่เริ่มต้น
และตอนนี้ ขั้นตอนต่อไปคือการกลับเผยแพร่ข้อผิดพลาดสุดท้ายกลับเข้าไปในเครือข่ายประสาท
และเพื่อทำสิ่งนี้โดยที่เรานำข้อผิดพลาดล่าสุดไปปรับใช้กับวิธีการย้อนกลับ
นั่นคือการใช้การขยายพันธุ์ย้อนหลัง
และสุดท้าย เมื่อข้อผิดพลาดล่าสุดกลับมาแพร่กระจายไปยังเครือข่ายใหม่ เราสามารถอัปเดตน้ำหนักด้วยการไล่ระดับสีแบบสุ่มได้
และในการทำเช่นนี้ อย่าลืมว่าเราใช้เครื่องมือเพิ่มประสิทธิภาพของเราแล้วจึงใช้วิธีขั้นตอนนี้
เราจะไปที่นั่น.
ขณะนี้น้ำหนักได้รับการอัปเดตแล้ว
อย่างที่ฉันบอกคุณ ไม่ใช่แค่เราทำไปแล้ว แต่ตอนนี้มันดูเรียบง่ายและเป็นธรรมชาติมาก
ตอนนี้เราจะทำอะไรสนุกๆ กัน
เราจะพิมพ์รางวัลโดยเฉลี่ย ทุกยุคทุกสมัย เพื่อให้เราสามารถติดตามว่า AI ดำเนินไปอย่างไร การฝึกอบรมดำเนินไปอย่างไร
เราต้องการเห็นผลตอบแทนเฉลี่ยที่เพิ่มขึ้นตามขั้นตอนของยุค
และในตอนแรก แน่นอนว่ามีขั้นตอนการสำรวจนี้
ดังนั้นรางวัลเฉลี่ยอาจไม่เพิ่มขึ้นในตอนเริ่มต้น แต่เมื่อถึงขั้นตอนการเอารัดเอาเปรียบ
เราจะเห็นรางวัลเฉลี่ยเพิ่มขึ้นอย่างแน่นอนและจะเพิ่มขึ้นถึงระดับหนึ่ง ซึ่งก็คือเมื่อถึงเสื้อกั๊กให้เร็วที่สุด
เป็นไปได้.
เริ่มจากการพิมพ์กันก่อน
คุณรู้ไหม เราทำสิ่งนี้ในยุคเดียว ดังนั้นเราต้องกลับไปที่ลูปที่นี่ พิมพ์
แล้วเราจะพิมพ์ดีก่อนยุคหนึ่งคอลัมน์ จากนั้นเป็นเปอร์เซ็นต์ se เพราะเราจะแปลงทุกอย่างเป็นสตริงที่
ดีกว่า.
แล้วเราจะบวกรางวัลเฉลี่ย
แล้วเราก็บวกเปอร์เซ็นต์ด้วย
จากนั้นเราจะปิดใบเสนอราคา
แล้วเราบวกเปอร์เซ็นต์
และในอีกด้านหนึ่ง คุณก็รู้ เราป้อนตัวแปรที่จะเป็นบุคคลแรกนี้ นั่นคือ EPC
ที่นี่ และตัวแปรที่สองที่สอดคล้องกับรางวัลเฉลี่ยที่เราจะคำนวณตอนนี้
ดังนั้นตัวแปรรางวัลเฉลี่ยจึงยังไม่มีอยู่
เราจะสร้างมันขึ้นมาทันที
เราจะใช้ยุค STR
แม้ว่ายุคจะเป็นตัวเลข เราจะแปลงสิ่งนั้นเป็นสตริง
ดีกว่าและ.
เราจะเพิ่มดาวที่สามารถเป็นรางวัลเฉลี่ย
ดังนั้นเราจะสร้างตัวแปรที่เราจะเรียกว่ารางวัล VG และตอนนี้เราจะสร้างตัวแปรนี้และคำนวณมัน
ลองทำสิ่งนี้กัน
นั่นคือสิ่งเดียวที่เราต้องทำเหลือ
ยุคที่เรามีอยู่แล้ว
ตอนนี้ มาคำนวณรางวัลเฉลี่ยกัน และเราต้องคำนวณมันตรงนี้
ยังคงอยู่ในวง แต่ออกจากวงวนรอบเพราะตอนนี้เรามีกลุ่มตัวอย่างของเราและเรามีการฝึกอบรมที่เกิดขึ้นในชุดงาน
แต่ตอนนี้การขยายพันธุ์ไปข้างหน้าบวกกับการขยายพันธุ์ย้อนหลังเสร็จสิ้นในชุดงาน
ดังนั้นเราจึงกลับเข้าสู่วงจร epoch และตอนนี้เราสามารถคำนวณรางวัลสะสมที่เราสามารถทำได้กับออบเจกต์
end step ของเรา เนื่องจากออบเจกต์ end step ของเรามีฟังก์ชันนี้
เราจะทำตามขั้นตอนที่ช่วยให้เราได้รับรางวัลสะสมที่เกิดขึ้นในขั้นตอนระหว่างการดำเนินการตามขั้นตอน
ดังนั้นเราจะใช้มันตอนนี้เพื่ออัปเดตรางวัลใหม่ของขั้นตอน จากนั้นเราจะอัปเดตออบเจ็กต์ค่าเฉลี่ยเคลื่อนที่โดยเพิ่มรางวัลสะสมให้กับออบเจ็กต์ค่าเฉลี่ยเคลื่อนที่แล้วคำนวณค่าเฉลี่ยใหม่
และนั่นคือวิธีที่เราจะได้รับรางวัลโดยเฉลี่ย
ลองทำสิ่งนี้กัน
สิ่งแรกที่เราต้องการคือรางวัลที่อัพเดท
เรามาเรียกมันว่ารางวัลกันดีกว่า
ขั้นตอน
แล้วอย่างที่เราพูด เราทำตามขั้นตอน PN
วัตถุซึ่งเป็นตัวเตือนที่สร้างขึ้นที่นี่เป็นวัตถุของคลาส PN Step Progress จากไฟล์เล่นซ้ำประสบการณ์ของเรา
ดังนั้นวัตถุขั้นตอน PN
จากนั้นเราจะเพิ่มขั้นตอนของรางวัลและวงเล็บ
เอาล่ะ เราจะได้รางวัลสะสมใหม่ตามขั้นตอน
เอาล่ะ แต่เราต้องเพิ่มรางวัลสะสมใหม่เหล่านี้ในออบเจกต์ค่าเฉลี่ยเคลื่อนที่ของเรา
และการทำเช่นนี้ เรามีวิธีการ คราวนี้ในคลาสค่าเฉลี่ยเคลื่อนที่ ซึ่งเป็นวิธี ADD นี้
มันง่ายมาก
เราใช้วัตถุเส้นค่าเฉลี่ยเคลื่อนที่ ซึ่งเราสร้างที่นี่ด้วย 100 ขั้นตอน จากนั้นเราจะใช้วิธี
ADD จากนั้นในวิธีโฆษณา เราป้อนขั้นตอนรางวัลของเรา และนี่จะเพิ่มรางวัลของขั้นตอนลงในเส้นค่าเฉลี่ยเคลื่อนที่
.
ไม่เป็นไร.
และสุดท้าย เราสามารถคำนวณรางวัลเฉลี่ยได้ และนั่นก็เป็นตัวแปรเดียวกันตรงนี้
นั่นคือสิ่งที่จะเท่ากับรางวัลเฉลี่ย
และเพื่อให้ได้มันมา เราต้องใช้วิธีค่าเฉลี่ยในครั้งนี้จากวัตถุค่าเฉลี่ยเคลื่อนที่ของเรา
และนั่นคือเราทำดอทเฉลี่ยแบบนั้นเพราะค่าเฉลี่ยเคลื่อนที่ของเราได้รับการอัปเดตแล้วด้วยขั้นตอนรางวัลใหม่ที่เราเพิ่งเพิ่มเข้าไปด้วยวิธีการ
ADD
ยอดเยี่ยม.
ตอนนี้เรามีรางวัลเฉลี่ยแล้ว เราจะได้ใส่ที่นี่
และนี่จะพิมพ์ทุกยุคทุกสมัย
ไม่เป็นไร.
ดังนั้นเราจึงทำเสร็จแล้ว
ฉันรู้สึกตื่นเต้นมากที่ได้เห็นผลลัพธ์
และที่จริงแล้ว ฉันจะทำเซอร์ไพรส์ให้คุณในบทช่วยสอนถัดไปขณะดูผลลัพธ์
มันจึงค่อนข้างจะน่าตื่นเต้น
และตอนนี้ฉันเดาว่าถึงเวลาที่จะเล่นกับ AI และสนุกแล้ว
เอาล่ะ เตรียมกาแฟดีๆ หรือชาดีๆ ให้ตัวเอง
ตอนนี้ได้เวลานั่งบนเก้าอี้อย่างสบายแล้วดูวิดีโอเจ๋ง ๆ ของ AI ที่กำลังเล่น Doom
ลองทำอย่างนั้นในบทช่วยสอนถัดไป
และจนกว่าจะถึงตอนนั้น เพลิดเพลิน
ฉัน.