WEBVTT

00:00.300 --> 00:06.270
สวัสดีและยินดีต้อนรับสู่ส่วนที่น่าตื่นเต้นสุด ๆ ของการสร้างสรรค์ของเรา ส่วนที่เราทำให้มันฉลาด

00:06.270 --> 00:13.260
นั่นคือสิ่งที่เกิดขึ้นเมื่อการฝึกอบรม AI จะฝึกความฉลาดของมันเพื่อบรรลุเป้าหมายที่เราต้องการให้สำเร็จ

00:13.260 --> 00:19.020
และในการทำเช่นนี้ เราจะฝึกโครงข่ายประสาทโดยพื้นฐาน ให้แสดงผลการทำนายที่ถูกต้อง จากนั้นทุกอย่างก็พร้อมแล้ว

00:19.020 --> 00:27.510
เพราะสัญญาณเอาท์พุตเหล่านี้จากสมอง มีการส่งสัญญาณที่ถูกต้องไปยังร่างกายแล้ว เพื่อดำเนินการขั้นสุดท้าย

00:27.510 --> 00:32.220
โดยพื้นฐานแล้วตอนนี้สิ่งที่เรากำลังจะทำคือสิ่งที่เราเคยทำมาก่อน

00:32.220 --> 00:37.410
เราแค่จะสุ่มแบทช์จากหน่วยความจำ รับอินพุตของเราจากตัวอย่างเหล่านี้ รับเอาต์พุต

00:37.410 --> 00:42.810
รับเป้าหมาย รับการคาดการณ์ คำนวณพื้นที่สุดท้ายระหว่างการคาดการณ์กับเป้าหมาย จากนั้นดำเนินการถ่ายทอดย้อนหลังด้วยสุ่ม

00:42.810 --> 00:51.660
การลงระดับการไล่ระดับสีเพื่ออัปเดตน้ำหนักตามจำนวนที่ก่อให้เกิดข้อผิดพลาดครั้งล่าสุดนี้

00:51.750 --> 00:53.040
ลองทำทั้งหมดนี้

00:53.040 --> 00:58.140
คุณจะเห็นว่ามันง่ายขนาดไหน เพราะเรามีเครื่องมือทั้งหมดสำหรับใช้งานสิ่งนี้แล้ว

00:58.140 --> 01:04.740
ไม่เพียงแต่เรามีเครื่องมือ PyTorch เช่น Optimizer และฟังก์ชันที่หายไป แต่เรายังมีคลาสทั้งหมดที่เราทำมาก่อน

01:04.740 --> 01:10.530
เช่น สมองของเรา ซึ่งเราจะใช้สำหรับการทำนาย

01:10.530 --> 01:17.640
จากนั้นประสบการณ์ การเล่นซ้ำ การนำไปใช้ การติดตามสิทธิ์ และเครื่องมือทั้งหมดเหล่านี้ที่รวมเข้ากับเครื่องมือ

01:17.640 --> 01:24.360
PyTorch จะทำให้การฝึกอบรมมีประสิทธิภาพสูงสุด และในที่สุดเราจะได้รับ AI ที่ทรงพลัง

01:24.540 --> 01:26.340
เรามาทำให้การฝึกอบรมนี้เกิดขึ้นกันเถอะ

01:26.340 --> 01:28.260
มาทำให้ AI ของเราฉลาดขึ้น

01:28.260 --> 01:33.390
และสิ่งแรกที่เราจะทำในตอนนี้คือรับฟังก์ชันสุดท้ายที่เราจะใช้ในระหว่างการฝึกอบรมเมื่อคำนวณข้อผิดพลาดและเครื่องมือเพิ่มประสิทธิภาพ

01:33.390 --> 01:37.860
นั่นคือสิ่งแรกที่เราจะทำ

01:37.860 --> 01:40.590
เรามาสร้างตัวแปรสำหรับฟังก์ชันสุดท้ายกัน

01:40.590 --> 01:42.390
เราจะเรียกมันว่าการสูญเสีย

01:42.720 --> 01:50.550
และจะเท่ากับฟังก์ชันการสูญเสียของ MSI จากโมดูล RN

01:50.760 --> 01:56.520
และการสูญเสีย MSI นั้น นั่นคือฟังก์ชันสุดท้ายที่เราจะใช้ เพราะโดยพื้นฐานแล้ว การคาดคะเนของเราคือค่า

01:56.520 --> 01:56.910
Q

01:57.120 --> 01:59.940
เรากำลังคาดการณ์ค่า Q ของการกระทำต่างๆ

01:59.940 --> 02:09.060
และเนื่องจากพวกนี้เป็นจำนวนจริง เรากำลังทำโครงข่ายประสาทสำหรับการถดถอย ดังนั้นฟังก์ชันสุดท้ายคือความคลาดเคลื่อนกำลังสองเฉลี่ย

02:09.060 --> 02:12.090
นั่นคือฟังก์ชันสุดท้ายที่เราใช้โดยทั่วไปสำหรับการถดถอย

02:12.420 --> 02:13.020
ไม่เป็นไร.

02:13.020 --> 02:16.290
ตอนนี้เรามีฟังก์ชันสุดท้ายแล้ว มาใช้เครื่องมือเพิ่มประสิทธิภาพของเรากัน

02:16.440 --> 02:21.240
เครื่องมือเพิ่มประสิทธิภาพที่นี่ นั่นคือตัวแปรที่เราสร้างขึ้นสำหรับเครื่องมือเพิ่มประสิทธิภาพ

02:21.240 --> 02:23.940
และเราจะดำเนินการตามปกติ

02:23.940 --> 02:31.950
สำหรับรถยนต์ที่ขับเคลื่อนด้วยตัวเอง Atom Optimizer นั้นเป็นเครื่องมือเพิ่มประสิทธิภาพที่ทรงพลังมาก ที่จะทำงานได้อย่างมหัศจรรย์สำหรับการฝึก

02:31.950 --> 02:36.060
ลองเอาอันนี้ขึ้นไปที่อะตอมนั้นกัน

02:36.780 --> 02:39.990
และจำไว้ว่า นั่นใช่สำหรับรถที่ขับเอง

02:39.990 --> 02:42.930
เราต้องป้อนอาร์กิวเมนต์ที่จำเป็นสองข้อ

02:42.930 --> 02:49.200
อันแรกคืออันที่จะสร้างการเชื่อมต่อระหว่างตัวเพิ่มประสิทธิภาพและพารามิเตอร์ของโครงข่ายประสาทเทียม

02:49.200 --> 02:52.890
นั่นคือน้ำหนักของเซลล์ประสาทในสมองของเรา

02:52.890 --> 02:56.880
และการทำเช่นนี้ เราใช้สมองของเรา ซึ่งเราเรียกว่าซีเอ็นเอ็น

02:56.880 --> 02:59.220
นั่นคือวัตถุที่เราสร้างขึ้นสำหรับสมองของเรา

02:59.220 --> 03:03.210
ดังนั้น CNN จึงไม่จำพารามิเตอร์

03:03.450 --> 03:04.320
เราจะไปที่นั่น.

03:04.320 --> 03:06.120
และวงเล็บบางส่วน

03:06.270 --> 03:11.970
นั่นทำให้การเชื่อมต่อระหว่างเครื่องมือเพิ่มประสิทธิภาพและน้ำหนักของเซลล์ประสาทในสมองของ

03:12.000 --> 03:12.660
AI ของเรา

03:12.690 --> 03:18.870
แล้วอาร์กิวเมนต์ที่สองคืออัตราการเรียนรู้ และนั่นกำหนดโดยข้อผิดพลาด

03:18.870 --> 03:29.340
ดังนั้นที่นี่เราต้องใช้อัตราการเรียนรู้เล็กน้อยเพราะเราไม่ต้องการที่จะมาบรรจบกันเร็วเกินไปและเราต้องการที่จะสำรวจและดังนั้นอัตราการเรียนรู้ที่ดีที่เราสามารถทำได้ที่นี่จึงเป็นอัตราเล็ก

03:29.340 --> 03:33.360
ๆ ที่เป็น 0 01 ที่เปิดอยู่ 1%

03:33.360 --> 03:36.450
ฉันคิดว่ามันเหมือนกับที่เราใช้กับรถยนต์ที่ขับด้วยตนเอง

03:37.390 --> 03:40.570
เอาล่ะ ตอนนี้เรามีฟังก์ชันสุดท้าย ออปติไมเซอร์

03:40.570 --> 03:43.450
ดังนั้นเราเกือบจะพร้อมที่จะเริ่มการวนซ้ำแบบเต็มแล้ว

03:43.450 --> 03:46.060
อันที่จริง เราจะเริ่มการวนซ้ำทั้งหมดในตอนนี้

03:46.060 --> 03:51.250
แต่ก่อนที่เราจะทำ เราจะพิจารณาขนาดของยุคก่อน

03:51.250 --> 03:58.390
เราจะทำการฝึกอบรม AI และด้วยเหตุนี้ ฉันกำลังสร้างตัวแปรใหม่ที่นี่ ซึ่งจะสอดคล้องกับยุคสมัยนี้

03:59.290 --> 04:02.360
และลองตั้งค่าให้เท่ากับ 100

04:02.380 --> 04:04.790
นั่นจะเป็นวิธีที่เพียงพอในการฝึกสายตา

04:04.810 --> 04:11.350
และฉันพนันได้เลยว่า AI จะจัดการไปให้ถึงทางที่ดีที่สุดก่อน 100 เช่น 20 หรือ 30

04:11.380 --> 04:12.010
มาดูกัน.

04:12.010 --> 04:13.870
แต่ตอนนี้ขอ 100 ก่อน

04:13.870 --> 04:16.060
และถ้าเราต้องการ เราจะเพิ่มมัน

04:16.060 --> 04:17.980
แต่ฉันไม่คิดว่าจะมีความจำเป็น

04:18.420 --> 04:18.620
ตกลง.

04:18.640 --> 04:24.580
ดังนั้นเมื่อเรามีจำนวน epochs ของเราแล้ว เราสามารถเริ่มสร้าง for loop นี้ main for loop ของการฝึกอบรม

04:24.580 --> 04:26.880
เมื่อเราฝึก over the epochs

04:26.890 --> 04:31.520
ดังนั้น ตัวแปรแบบวนซ้ำจะเป็นยุค

04:31.540 --> 04:34.450
นั่นคือสิ่งที่เราเลือกสำหรับยุคสมัย

04:34.930 --> 04:44.710
แน่นอนว่า เราจะใช้ฟังก์ชัน range เพื่อบอกว่าเราต้องการเปลี่ยนจากยุคแรกเป็นยุคแรกเป็นจำนวนยุค

04:47.130 --> 04:51.960
บวกหนึ่ง เนื่องจาก โปรดจำไว้ว่า ขอบเขตบนของช่วงจะไม่ถูกรวมอยู่ด้วย

04:51.960 --> 04:58.080
ดังนั้น ถ้าเราต้องการเพิ่มเป็น 100 เราต้องระบุและเป็นกล่องบวกหนึ่งถึง

04:58.080 --> 04:58.920
100

04:59.400 --> 05:00.960
เอาล่ะ คอลิน

05:00.960 --> 05:03.030
และตอนนี้ขอเข้าสู่วง

05:03.600 --> 05:03.930
ไม่เป็นไร.

05:03.930 --> 05:08.550
สิ่งแรกที่เราจะทำคือวิ่ง 200 รอบ 10 ขั้นตอน

05:08.550 --> 05:13.810
ดังนั้นแต่ละยุคจะวิ่ง 200 ครั้ง ต่อจากอีก 10 ก้าว

05:13.830 --> 05:18.420
และเพื่อทำสิ่งนี้ เรามีฟังก์ชันรันสเต็ปจากคลาสรีเพลย์ที่มีประสบการณ์ของเรา

05:18.420 --> 05:23.400
ดังนั้น การใช้ฟังก์ชันนี้ ซึ่งจริงๆ แล้วเป็น method เพราะเราจะได้รับมันจาก

05:23.400 --> 05:30.540
memory object ซึ่งเป็นอ็อบเจ็กต์จาก replay memory class เพื่อสร้าง 200 รัน 10 ขั้นตอนที่เราต้องใช้

05:30.540 --> 05:32.520
memory object

05:33.350 --> 05:36.140
ที่ฉันเตือนว่าเราสร้างขึ้นที่นี่

05:36.140 --> 05:43.520
หน่วยความจำเป็นอ็อบเจ็กต์ของคลาสหน่วยความจำรีเพลย์ที่มีขั้นตอน MN ที่สิบขั้นตอนและความจุ 10,000

05:43.790 --> 05:52.250
เราสร้างอ็อบเจ็กต์นี้และจากอ็อบเจ็กต์นี้ เราทำได้ดี การรัน สเต็ป ฟังก์ชัน รันสเต็ป และเราระบุการรัน

05:52.250 --> 05:56.630
10 ขั้นต่อเนื่องกัน 200 ขั้น

05:56.930 --> 06:00.680
นั่นคือในแต่ละยุคโดยทั่วไปจะวิ่ง 200 ก้าว

06:00.740 --> 06:09.110
และตอนนี้ที่เรามี 200 ขั้นตอนที่ทำงานในแต่ละยุค ก็ถึงเวลาที่จะสุ่มตัวอย่างบางส่วนจากการวิ่งเหล่านี้

06:09.110 --> 06:10.610
และเพื่อสุ่มตัวอย่างแบทช์เหล่านี้

06:10.610 --> 06:16.700
เรามีฟังก์ชันอื่นจากหน่วยความจำของเรา ซึ่งเป็นแบทช์ตัวอย่าง และนั่นจะสร้างแบทช์บางส่วนจากการรัน

06:16.700 --> 06:19.100
200 ครั้งเหล่านี้

06:19.340 --> 06:25.010
แต่จำไว้ว่าแบทช์เหล่านี้เป็นชุดของช่วงการเปลี่ยนภาพตามเวลาเหล่านี้

06:25.010 --> 06:31.640
นั่นคือชุดของขั้นตอนสิบขั้นตอนเมื่อเทียบกับก่อนหน้านี้ โดยที่ชุดงานเป็นเพียงชุดของการเปลี่ยนครั้งเดียวที่นี่

06:31.640 --> 06:37.130
ครั้งนี้จะเป็นแบทช์ 10 ขั้นตอน 10 ทรานสิชั่น และตอนนี้ก็ถึงเวลาที่จะดึงแบทช์สุ่มจากหน่วยความจำของเรา

06:37.130 --> 06:47.060
และเพื่อให้ได้มา เราใช้ฟังก์ชันแบทช์ตัวอย่างที่เราต้องใช้ขนาดแบทช์

06:47.060 --> 06:53.690
และสำหรับขนาดแบทช์ ซึ่งเราสามารถเอา 32 หรือ 64 หรือ 128 ก็ได้

06:54.050 --> 06:57.140
โปรดจำไว้ว่าสำหรับขนาดแบทช์ เป็นเรื่องปกติที่จะใช้

06:57.140 --> 07:03.620
32 นั่นคือสิ่งที่คุณจะเห็นโดยทั่วไปในสถาปัตยกรรมโครงข่ายประสาทเทียมเมื่อทำการเรียนรู้แบบเป็นชุด

07:03.620 --> 07:05.600
แต่ครั้งนี้มันค่อนข้างแตกต่าง

07:05.600 --> 07:11.630
เราแค่สุ่มตัวอย่างเป็นชุดๆ ละ 10 ขั้นตอน ดังนั้นจึงควรเลือกชุดงานที่ใหญ่ขึ้น

07:11.630 --> 07:14.990
นั่นคือเหตุผลที่เราสามารถเอา 64 หรือ 128 ได้

07:14.990 --> 07:17.000
เราจะเอา 128.

07:17.240 --> 07:29.090
และอันที่จริง นี่จะอยู่ในสี่ลูปเพราะเราต้องการรับหลายแบตช์ และเราเอามันกลับมาในฟังก์ชันแบทช์ตัวอย่างนี้

07:29.330 --> 07:38.750
ดังนั้น นี่สำหรับลูปสำหรับแบตช์ในหน่วยความจำ ตัวอย่างแบตช์ 128 หมายความว่าทุกๆ 128 ขั้นตอน

07:38.750 --> 07:47.390
หน่วยความจำของเราจะให้แบตช์ขนาด 128 ซึ่งจะมี 128 ขั้นตอนสุดท้ายที่เพิ่งรันจริง ๆ

07:47.810 --> 07:54.230
เราเพิ่งได้แบตช์ขนาด 128 และการเรียนรู้กำลังจะเกิดขึ้นกับแบตช์เหล่านี้

07:54.230 --> 07:58.700
นอกจากนี้ ภายในกลุ่มเหล่านี้ เราจะมีสิทธิ์ ติดตามการทำงาน คุณรู้ไหม เพื่อเรียนรู้ทุก

07:58.700 --> 07:59.660
ๆ สิบขั้นตอน

08:00.200 --> 08:00.620
ไม่เป็นไร.

08:00.620 --> 08:07.550
ดังนั้นตอนนี้ในลูปนี้ ซึ่งยังคงเกิดขึ้นในยุคหนึ่ง แต่ตอนนี้ เราอยู่ในกลุ่มที่เจาะจง

08:07.670 --> 08:14.300
และตอนนี้ สิ่งแรกที่เราจะทำคือ เราจะได้ข้อมูลและเป้าหมายแยกกัน

08:14.450 --> 08:16.610
และอย่างที่ฉันบอกคุณ มันง่ายมาก

08:16.610 --> 08:21.500
เราสามารถทำได้ด้วยหนึ่งในเครื่องมือที่เรานำมาใช้ ซึ่งก็คือการติดตามการมีสิทธิ์

08:21.500 --> 08:28.160
ดังที่คุณเห็นที่นี่ ฟังก์ชันการติดตามการมีสิทธิ์ใช้แบทช์เป็นอินพุต และตอนนี้เรามีแบทช์และส่งกลับเป็นเอาต์พุต

08:28.160 --> 08:32.270
อินพุต และเป้าหมาย

08:32.270 --> 08:37.640
ดังนั้นตอนนี้ สิ่งที่เราทำได้คือสร้างตัวแปรใหม่ 2 ตัว ซึ่งจะเป็นอินพุตและเป้าหมาย

08:37.640 --> 08:42.290
และทำอินพุตนี้มาที่เป้าหมาย

08:43.220 --> 08:44.000
เท่ากับ

08:44.030 --> 08:48.840
สิ่งที่ส่งคืนฟังก์ชันการติดตามสิทธิ์นี้มีผลกับชุดงาน

08:48.860 --> 08:52.190
ดังนั้นเราจะใช้ฟังก์ชันนี้กับกลุ่มของลูปของเรา

08:52.190 --> 08:55.340
และสิ่งที่เราจะทำก็คือการมีสิทธิ์

08:56.410 --> 09:00.340
การติดตามนำไปใช้กับแบทช์ของลูปของเรา

09:00.640 --> 09:04.210
เอาล่ะ เพื่อให้เราได้รับข้อมูลเข้าและเป้าหมาย

09:04.210 --> 09:08.020
แต่ใน PyTorch มีอะไรอีกมากมายที่เราต้องทำอยู่เสมอ

09:08.020 --> 09:13.510
และแน่นอนว่านี่คือการแปลงอินพุตของโครงข่ายประสาทเทียมและเป้าหมายเป็นตัวแปรการทรมาน

09:13.510 --> 09:15.220
แต่ไม่มีการปล่อย

09:15.220 --> 09:16.140
ไม่มีอะไรใหม่

09:16.150 --> 09:17.430
เรารู้วิธีการทำ

09:17.440 --> 09:18.460
เราสามารถทำได้ด้วยวิธีนี้

09:18.460 --> 09:26.740
เราใช้อินพุตของเรา แล้วก็เป้าหมายของเรา แล้วก็จะเท่ากับอินพุตที่แปรผันได้

09:27.740 --> 09:33.800
นั่นสำหรับอินพุตและตัวแปรเป้าหมาย และสำหรับเป้าหมาย

09:34.070 --> 09:34.880
ไม่เป็นไร.

09:35.210 --> 09:44.130
ดังนั้นอินพุตของสมองจึงถูกแปลงเป็นตัวแปรคบเพลิงและเป้าหมายก็จะถูกแปลงเป็นตัวแปรคบเพลิงด้วย

09:44.150 --> 09:48.530
ตอนนี้เราสามารถรับอินพุตเข้าสู่โครงข่ายประสาทเทียมได้แล้ว

09:48.530 --> 09:50.120
และทำไมเราต้องทำเช่นนี้?

09:50.150 --> 09:55.430
นั่นเป็นเพราะว่าขั้นตอนต่อไปคือการรับการคาดการณ์ที่เรามี ข้อมูลที่เราต้องกำหนดเป้าหมาย

09:55.460 --> 10:02.360
แน่นอน เราต้องการการคาดคะเนของเรา เพราะจากนั้นสิ่งที่เกิดขึ้นคือเราจะคำนวณความสูญเสียระหว่างการคาดคะเนกับเป้าหมาย

10:02.900 --> 10:06.570
ลองรับคำทำนายเหล่านี้เพื่อให้ได้มา

10:06.590 --> 10:07.910
อีกครั้งนี้เป็นเรื่องง่ายมาก

10:07.910 --> 10:16.970
ตอนนี้เราแค่ต้องใช้สมองของเรา ซึ่งก็คือ CNN ซึ่งเป็นโครงข่ายประสาทเทียม และนำไปใช้กับปัจจัยการผลิตของเรา

10:17.240 --> 10:18.140
เราจะไปที่นั่น.

10:18.230 --> 10:23.480
อินพุตจะเข้าสู่โครงข่ายประสาทเทียม และโครงข่ายประสาทเทียมจะส่งออกการคาดการณ์

10:24.150 --> 10:24.870
สมบูรณ์แบบ.

10:24.870 --> 10:28.560
ตอนนี้เรามีการคาดการณ์แล้ว เรามีเป้าหมายเพื่อให้เราขาดทุนได้

10:28.560 --> 10:30.030
และนั่นคือขั้นตอนต่อไป

10:30.210 --> 10:35.070
เราจะแนะนำตัวแปรใหม่เพราะตอนนี้เรากำลังจะได้รับข้อผิดพลาดสุดท้าย ซึ่งแตกต่างจากฟังก์ชันสุดท้าย

10:35.070 --> 10:39.900
เนื่องจากเราใช้ฟังก์ชันสุดท้ายเพื่อรับข้อผิดพลาดสุดท้าย

10:39.930 --> 10:48.960
ข้อผิดพลาดน้อยลงที่นี่และเราจะได้รับด้วยฟังก์ชันสุดท้ายที่ใช้กับการคาดคะเนของเรา

10:49.650 --> 10:51.360
และเป้าหมาย

10:52.170 --> 10:52.980
เราจะไปที่นั่น.

10:53.370 --> 10:55.020
ดูว่าตอนนี้ทุกอย่างราบรื่นแค่ไหน

10:55.050 --> 10:56.160
ทุกอย่างมีเหตุผล

10:56.160 --> 10:58.230
เราได้รับข้อมูลเป้าหมายก่อน

10:58.230 --> 11:00.540
จากนั้นเราก็ได้รับคำทำนาย

11:00.540 --> 11:03.960
และต้องขอบคุณการคาดการณ์และเป้าหมาย เราจึงได้รับข้อผิดพลาดน้อยลง

11:04.990 --> 11:07.200
มีเหตุผลและราบรื่นมาก

11:07.210 --> 11:09.040
และตอนนี้ขั้นตอนต่อไปคืออะไร?

11:09.070 --> 11:10.770
เส้นทางตรรกะเดียวกัน

11:10.780 --> 11:17.080
ตอนนี้เรามีสิ่งสุดท้ายที่เราสามารถย้อนกลับได้ เผยแพร่ข้อผิดพลาดที่น้อยลงนี้กลับเข้าไปในเครือข่ายประสาทเพื่ออัปเดตน้ำหนัก

11:17.080 --> 11:22.150
และเราทำอย่างนั้นด้วยการไล่ระดับสีสุ่มและเพื่อทำการสุ่มตัวอย่างการไล่ระดับสีเราต้องการเครื่องมือเพิ่มประสิทธิภาพของเรา

11:22.150 --> 11:26.290
แต่เราได้มันมาแล้วที่นี่ เครื่องมือเพิ่มประสิทธิภาพอะตอมของเรา

11:26.290 --> 11:29.230
แต่ ณ จุดนี้ จำสิ่งที่เราต้องทำ

11:29.230 --> 11:32.380
เราต้องเริ่มต้นและเริ่มต้นมัน

11:32.380 --> 11:40.780
จำไว้ว่าเราใช้ออบเจ็กต์เครื่องมือเพิ่มประสิทธิภาพของเราแล้วจึงใช้วิธีกริดศูนย์

11:41.460 --> 11:41.920
จากนั้นเราไป

11:41.920 --> 11:45.240
เราไม่ลืมวงเล็บที่เริ่มต้น

11:45.360 --> 11:50.900
และตอนนี้ ขั้นตอนต่อไปคือการกลับเผยแพร่ข้อผิดพลาดสุดท้ายกลับเข้าไปในเครือข่ายประสาท

11:50.910 --> 11:58.960
และเพื่อทำสิ่งนี้โดยที่เรานำข้อผิดพลาดล่าสุดไปปรับใช้กับวิธีการย้อนกลับ

11:58.980 --> 12:02.010
นั่นคือการใช้การขยายพันธุ์ย้อนหลัง

12:02.010 --> 12:09.780
และสุดท้าย เมื่อข้อผิดพลาดล่าสุดกลับมาแพร่กระจายไปยังเครือข่ายใหม่ เราสามารถอัปเดตน้ำหนักด้วยการไล่ระดับสีแบบสุ่มได้

12:10.260 --> 12:17.190
และในการทำเช่นนี้ อย่าลืมว่าเราใช้เครื่องมือเพิ่มประสิทธิภาพของเราแล้วจึงใช้วิธีขั้นตอนนี้

12:17.370 --> 12:18.310
เราจะไปที่นั่น.

12:18.330 --> 12:20.120
ขณะนี้น้ำหนักได้รับการอัปเดตแล้ว

12:20.130 --> 12:25.740
อย่างที่ฉันบอกคุณ ไม่ใช่แค่เราทำไปแล้ว แต่ตอนนี้มันดูเรียบง่ายและเป็นธรรมชาติมาก

12:26.070 --> 12:28.520
ตอนนี้เราจะทำอะไรสนุกๆ กัน

12:28.530 --> 12:36.040
เราจะพิมพ์รางวัลโดยเฉลี่ย ทุกยุคทุกสมัย เพื่อให้เราสามารถติดตามว่า AI ดำเนินไปอย่างไร การฝึกอบรมดำเนินไปอย่างไร

12:36.060 --> 12:40.530
เราต้องการเห็นผลตอบแทนเฉลี่ยที่เพิ่มขึ้นตามขั้นตอนของยุค

12:40.530 --> 12:44.040
และในตอนแรก แน่นอนว่ามีขั้นตอนการสำรวจนี้

12:44.040 --> 12:49.680
ดังนั้นรางวัลเฉลี่ยอาจไม่เพิ่มขึ้นในตอนเริ่มต้น แต่เมื่อถึงขั้นตอนการเอารัดเอาเปรียบ

12:49.680 --> 12:56.190
เราจะเห็นรางวัลเฉลี่ยเพิ่มขึ้นอย่างแน่นอนและจะเพิ่มขึ้นถึงระดับหนึ่ง ซึ่งก็คือเมื่อถึงเสื้อกั๊กให้เร็วที่สุด

12:56.190 --> 12:58.860
เป็นไปได้.

12:59.310 --> 13:01.470
เริ่มจากการพิมพ์กันก่อน

13:01.980 --> 13:07.500
คุณรู้ไหม เราทำสิ่งนี้ในยุคเดียว ดังนั้นเราต้องกลับไปที่ลูปที่นี่ พิมพ์

13:07.500 --> 13:15.270
แล้วเราจะพิมพ์ดีก่อนยุคหนึ่งคอลัมน์ จากนั้นเป็นเปอร์เซ็นต์ se เพราะเราจะแปลงทุกอย่างเป็นสตริงที่

13:15.270 --> 13:16.380
ดีกว่า.

13:16.710 --> 13:21.300
แล้วเราจะบวกรางวัลเฉลี่ย

13:22.540 --> 13:25.300
แล้วเราก็บวกเปอร์เซ็นต์ด้วย

13:25.600 --> 13:27.880
จากนั้นเราจะปิดใบเสนอราคา

13:28.960 --> 13:30.700
แล้วเราบวกเปอร์เซ็นต์

13:30.700 --> 13:36.670
และในอีกด้านหนึ่ง คุณก็รู้ เราป้อนตัวแปรที่จะเป็นบุคคลแรกนี้ นั่นคือ EPC

13:36.670 --> 13:42.940
ที่นี่ และตัวแปรที่สองที่สอดคล้องกับรางวัลเฉลี่ยที่เราจะคำนวณตอนนี้

13:42.940 --> 13:45.670
ดังนั้นตัวแปรรางวัลเฉลี่ยจึงยังไม่มีอยู่

13:45.670 --> 13:47.770
เราจะสร้างมันขึ้นมาทันที

13:48.010 --> 13:52.120
เราจะใช้ยุค STR

13:52.450 --> 13:55.450
แม้ว่ายุคจะเป็นตัวเลข เราจะแปลงสิ่งนั้นเป็นสตริง

13:55.450 --> 13:57.340
ดีกว่าและ.

13:58.030 --> 14:02.080
เราจะเพิ่มดาวที่สามารถเป็นรางวัลเฉลี่ย

14:02.080 --> 14:10.000
ดังนั้นเราจะสร้างตัวแปรที่เราจะเรียกว่ารางวัล VG และตอนนี้เราจะสร้างตัวแปรนี้และคำนวณมัน

14:10.960 --> 14:12.430
ลองทำสิ่งนี้กัน

14:12.430 --> 14:13.930
นั่นคือสิ่งเดียวที่เราต้องทำเหลือ

14:13.930 --> 14:16.090
ยุคที่เรามีอยู่แล้ว

14:16.120 --> 14:20.140
ตอนนี้ มาคำนวณรางวัลเฉลี่ยกัน และเราต้องคำนวณมันตรงนี้

14:20.140 --> 14:28.210
ยังคงอยู่ในวง แต่ออกจากวงวนรอบเพราะตอนนี้เรามีกลุ่มตัวอย่างของเราและเรามีการฝึกอบรมที่เกิดขึ้นในชุดงาน

14:28.210 --> 14:32.080
แต่ตอนนี้การขยายพันธุ์ไปข้างหน้าบวกกับการขยายพันธุ์ย้อนหลังเสร็จสิ้นในชุดงาน

14:32.080 --> 14:38.890
ดังนั้นเราจึงกลับเข้าสู่วงจร epoch และตอนนี้เราสามารถคำนวณรางวัลสะสมที่เราสามารถทำได้กับออบเจกต์

14:38.890 --> 14:44.920
end step ของเรา เนื่องจากออบเจกต์ end step ของเรามีฟังก์ชันนี้

14:44.920 --> 14:51.490
เราจะทำตามขั้นตอนที่ช่วยให้เราได้รับรางวัลสะสมที่เกิดขึ้นในขั้นตอนระหว่างการดำเนินการตามขั้นตอน

14:51.490 --> 15:07.750
ดังนั้นเราจะใช้มันตอนนี้เพื่ออัปเดตรางวัลใหม่ของขั้นตอน จากนั้นเราจะอัปเดตออบเจ็กต์ค่าเฉลี่ยเคลื่อนที่โดยเพิ่มรางวัลสะสมให้กับออบเจ็กต์ค่าเฉลี่ยเคลื่อนที่แล้วคำนวณค่าเฉลี่ยใหม่

15:07.750 --> 15:10.090
และนั่นคือวิธีที่เราจะได้รับรางวัลโดยเฉลี่ย

15:10.480 --> 15:11.500
ลองทำสิ่งนี้กัน

15:11.500 --> 15:14.890
สิ่งแรกที่เราต้องการคือรางวัลที่อัพเดท

15:14.890 --> 15:17.140
เรามาเรียกมันว่ารางวัลกันดีกว่า

15:18.080 --> 15:19.010
ขั้นตอน

15:19.250 --> 15:24.000
แล้วอย่างที่เราพูด เราทำตามขั้นตอน PN

15:24.020 --> 15:30.830
วัตถุซึ่งเป็นตัวเตือนที่สร้างขึ้นที่นี่เป็นวัตถุของคลาส PN Step Progress จากไฟล์เล่นซ้ำประสบการณ์ของเรา

15:30.830 --> 15:33.530
ดังนั้นวัตถุขั้นตอน PN

15:33.920 --> 15:39.710
จากนั้นเราจะเพิ่มขั้นตอนของรางวัลและวงเล็บ

15:39.710 --> 15:43.930
เอาล่ะ เราจะได้รางวัลสะสมใหม่ตามขั้นตอน

15:43.940 --> 15:50.930
เอาล่ะ แต่เราต้องเพิ่มรางวัลสะสมใหม่เหล่านี้ในออบเจกต์ค่าเฉลี่ยเคลื่อนที่ของเรา

15:50.930 --> 15:57.320
และการทำเช่นนี้ เรามีวิธีการ คราวนี้ในคลาสค่าเฉลี่ยเคลื่อนที่ ซึ่งเป็นวิธี ADD นี้

15:57.410 --> 15:58.220
มันง่ายมาก

15:58.220 --> 16:05.330
เราใช้วัตถุเส้นค่าเฉลี่ยเคลื่อนที่ ซึ่งเราสร้างที่นี่ด้วย 100 ขั้นตอน จากนั้นเราจะใช้วิธี

16:05.330 --> 16:13.400
ADD จากนั้นในวิธีโฆษณา เราป้อนขั้นตอนรางวัลของเรา และนี่จะเพิ่มรางวัลของขั้นตอนลงในเส้นค่าเฉลี่ยเคลื่อนที่

16:13.400 --> 16:15.350
.

16:15.950 --> 16:16.340
ไม่เป็นไร.

16:16.340 --> 16:22.220
และสุดท้าย เราสามารถคำนวณรางวัลเฉลี่ยได้ และนั่นก็เป็นตัวแปรเดียวกันตรงนี้

16:22.640 --> 16:26.720
นั่นคือสิ่งที่จะเท่ากับรางวัลเฉลี่ย

16:26.720 --> 16:33.440
และเพื่อให้ได้มันมา เราต้องใช้วิธีค่าเฉลี่ยในครั้งนี้จากวัตถุค่าเฉลี่ยเคลื่อนที่ของเรา

16:33.590 --> 16:42.320
และนั่นคือเราทำดอทเฉลี่ยแบบนั้นเพราะค่าเฉลี่ยเคลื่อนที่ของเราได้รับการอัปเดตแล้วด้วยขั้นตอนรางวัลใหม่ที่เราเพิ่งเพิ่มเข้าไปด้วยวิธีการ

16:42.320 --> 16:45.650
ADD

16:46.350 --> 16:46.930
ยอดเยี่ยม.

16:46.970 --> 16:50.130
ตอนนี้เรามีรางวัลเฉลี่ยแล้ว เราจะได้ใส่ที่นี่

16:50.130 --> 16:53.160
และนี่จะพิมพ์ทุกยุคทุกสมัย

16:53.430 --> 16:53.850
ไม่เป็นไร.

16:53.850 --> 16:54.960
ดังนั้นเราจึงทำเสร็จแล้ว

16:54.960 --> 16:57.150
ฉันรู้สึกตื่นเต้นมากที่ได้เห็นผลลัพธ์

16:57.150 --> 17:01.620
และที่จริงแล้ว ฉันจะทำเซอร์ไพรส์ให้คุณในบทช่วยสอนถัดไปขณะดูผลลัพธ์

17:01.620 --> 17:03.600
มันจึงค่อนข้างจะน่าตื่นเต้น

17:03.600 --> 17:06.960
และตอนนี้ฉันเดาว่าถึงเวลาที่จะเล่นกับ AI และสนุกแล้ว

17:07.620 --> 17:11.380
เอาล่ะ เตรียมกาแฟดีๆ หรือชาดีๆ ให้ตัวเอง

17:11.400 --> 17:16.950
ตอนนี้ได้เวลานั่งบนเก้าอี้อย่างสบายแล้วดูวิดีโอเจ๋ง ๆ ของ AI ที่กำลังเล่น Doom

17:16.980 --> 17:18.750
ลองทำอย่างนั้นในบทช่วยสอนถัดไป

17:18.750 --> 17:20.040
และจนกว่าจะถึงตอนนั้น เพลิดเพลิน

17:20.040 --> 17:20.460
ฉัน.