ภายในของฉัน การบ้านฉันถูกขอให้ใช้การไล่ระดับสีแบบสุ่มเพื่อแก้ไขปัญหา การถดถอยเชิงเส้น(ถึงแม้ผมจะมีแค่ 200 ตัวอย่างการฝึกก็ตาม) ปัญหาของฉันคือการที่การไล่ระดับสีแบบสุ่มมาบรรจบกันอย่างราบรื่นเกินไป เกือบจะเหมือนกับการไล่ระดับสีแบบกลุ่ม ซึ่งทำให้ฉันมีคำถาม: ทำไมมันดูราบรื่นมาก เมื่อพิจารณาจากข้อเท็จจริงที่ว่ามันมักจะดังกว่ามาก เป็นเพราะฉันใช้กับตัวอย่างเพียง 200 ตัวอย่างใช่ไหม

MSE ที่มีน้ำหนักจากการไล่ระดับสีสุ่ม: 2.78441258841

MSE ที่มีน้ำหนักจากการไล่ระดับโคตร: 2.78412631451 (เหมือนกับ MSE ที่มีน้ำหนักจากสมการปกติ)

Def mserror(y, y_pred): n = y.size diff = y - y_pred diff_squared = diff ** 2 av_er = float(sum(diff_squared))/n กลับ av_er

Def linear_prediction(X, w): กลับจุด (X, np.transpose (w))

Def การไล่ระดับ_descent_step(X, y, w, eta): n = X.shape grad = (2.0/n) * sum(np.transpose(X) * (linear_prediction(X,w) - y), axis = 1) return w - eta * ผู้สำเร็จการศึกษา

Def stochastic_gradient_step(X, y, w, train_ind, eta): n = X.shape grad = (2.0/n) * np.transpose(X) * (linear_prediction(X,w) - y) กลับ w - eta * grad

Def การไล่ระดับสี_descent(X, y, w_init, eta, max_iter): w = w_init ข้อผิดพลาด = error.append(mserror(y, linear_prediction(X,w))) สำหรับฉัน อยู่ในช่วง (max_iter): w = การไล่ระดับสี_descent_step(X, y , w, eta) error.append(mserror(y, linear_prediction(X,w))) ส่งคืน w ข้อผิดพลาด

Def stochastic_gradient_descent(X, y, w_init, eta, max_iter): n = X.shape w = w_init error = error.append(mserror(y, linear_prediction(X,w))) สำหรับ i อยู่ในช่วง (max_iter): Random_ind = np.random.randint(n) w = stochastic_gradient_step(X, y, w, Random_ind, eta) error.append(mserror(y, linear_prediction(X,w))) กลับ w ข้อผิดพลาด

1 คำตอบ

ไม่มีอะไรผิดปกติเกี่ยวกับตารางเวลาของคุณ ควรสังเกตด้วยว่าวิธีการแบบแบตช์ของคุณต้องใช้การวนซ้ำน้อยลงเพื่อมาบรรจบกัน

คุณสามารถปล่อยให้โครงข่ายประสาทเทียม SGD มีมุมมองของคุณเองว่า SGD ควรมีลักษณะอย่างไร โครงข่ายประสาทเทียมส่วนใหญ่เป็นโมเดลที่ซับซ้อนกว่ามาก (ยากต่อการปรับให้เหมาะสม) ซึ่งทำงานได้มากกว่า ปัญหาที่ซับซ้อน- สิ่งนี้ส่งเสริม "ความหยัก" อย่างที่คุณคาดหวัง

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

เป้าหมายคือย่อฟังก์ชัน F ให้เหลือน้อยที่สุดในปริภูมิของจุดที่เป็นไปได้ทั้งหมด กราฟของ F เป็นพื้นผิวพาราโบลาและต้องมีค่าต่ำสุดเพียงค่าเดียว และคำถามเกี่ยวกับวิธีการแก้ไขจุดเพื่อก้าวไปสู่จุดต่ำสุดนี้ได้รับการแก้ไขเมื่อนานมาแล้วในการวิเคราะห์ทางคณิตศาสตร์ ในการทำเช่นนี้คุณจะต้องเคลื่อนที่ไปในทิศทางตรงกันข้าม การไล่ระดับสี- เวกเตอร์ซึ่งมีอนุพันธ์สูงสุด การไล่ระดับสีคำนวณดังนี้:

เหล่านั้น. ในการคำนวณความชัน เราต้องใช้อนุพันธ์ของ ฟังก์ชันที่กำหนดที่จุดที่สอดคล้องกัน (ตัวแปร)

ดังนั้น เพื่อกำหนดวิธีการแก้ไขพิกัดของจุดอย่างถูกต้อง เราต้องคำนวณการไล่ระดับสีและลบเวกเตอร์ที่มีความยาวที่กำหนดไว้ล่วงหน้า (ในกรณีของเรา ความยาวนี้คือขั้นตอนที่กำหนด a) จากเวกเตอร์ของจุดที่มีอยู่:

หากต้องการใช้สิ่งนี้โดยทางโปรแกรม คุณต้องเรียนรู้วิธีแยกฟังก์ชัน F:

ตัวอย่างที่ 1 - อัลกอริธึมการไล่ระดับสีสำหรับหนึ่งจุด

ไล่ระดับโคตร()

• 1. เริ่มต้นด้วยค่าสุ่มขนาดเล็ก
• 2. ทำซ้ำ Number_of_Steps ครั้ง:
  • ก) สำหรับทุกคน ฉันตั้งแต่ 1 ถึง n
  • ข) สำหรับทุกคน เจตั้งแต่ 1 ถึง ม:
    • (ผม) สำหรับทุกคน ฉันตั้งแต่ 1 ถึง n

• 3. ค่าเอาท์พุต

ซึ่งหมายความว่าเราจำเป็นต้องแก้ไขพิกัดของจุดหลังจากตัวอย่างการทดสอบแต่ละครั้งดังนี้:

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

อัลกอริธึมนี้สามารถค้นหาค่าต่ำสุดเฉพาะที่ (พาราโบลาที่เราพิจารณาว่ามีค่าต่ำสุดเฉพาะที่หนึ่งค่า) ข้อแตกต่างคือไม่ได้รวบรวมข้อมูลทั้งหมดจากกรณีทดสอบทั้งหมด แต่จะแก้ไขจุดต่างๆ ทันทีหลังจากแต่ละขั้นตอนการวนซ้ำ

ดังนั้น คุณมีหน้าที่ในการทำนายมูลค่าบางอย่าง เช่น ราคาบ้าน โดยพิจารณาจากขนาดของบ้าน หรือเวลาที่ระบบของคุณในการดำเนินการตามคำขอ คุณไม่มีทางรู้

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

1. การไล่ระดับสีแบบแบทช์
2. โคตรลาดสุ่ม
3. สมการปกติ
4. วิธีของนิวตัน (วิธีของนิวตัน)

วันนี้เราจะพูดถึงการไล่ระดับสีสองประเภท

การไล่ระดับโคตร

การไล่ระดับสีคืออะไร?

ลองนึกภาพบ้าง ฟังก์ชั่นที่ซับซ้อนจากตัวแปรตัวหนึ่ง มีขึ้นมีลงบ้าง ในแต่ละจุดของฟังก์ชันนี้ เราสามารถหาอนุพันธ์ได้:

เส้นสีเขียวแสดงว่า ณ จุดนี้อนุพันธ์จะเป็นค่าบวก เส้นสีแดงจะเป็นค่าลบ

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

หาก ณ จุดของคุณอนุพันธ์เป็นลบ (เส้นสีแดง) นั่นหมายความว่าค่าต่ำสุดอยู่ "ข้างหน้า" ของคุณ และเพื่อที่จะไปถึงจุดนั้น คุณต้องลบออกจากพิกัดอีกครั้ง xมูลค่าของอนุพันธ์ของคุณ ค่าของมันคือลบ ดังนั้น เมื่อลบค่าลบ คุณจะเพิ่มพิกัดได้ x.

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

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

คุณสามารถมองฟังก์ชันนี้เป็น "ถ้วย" ในพื้นที่ 3 มิติ:

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

ฟังก์ชันต้นทุนของเราคือ:

การไล่ระดับสีจะแสดงเป็น และจะคำนวณโดยใช้สูตรต่อไปนี้:

ในอนุพันธ์ย่อยแต่ละตัว เราถือว่ามันเป็นฟังก์ชันของตัวแปรตัวเดียว เราถือว่าตัวแปรอื่นๆ ทั้งหมดเป็นค่าคงที่ ดังนั้นอนุพันธ์ของตัวแปรจะเท่ากับศูนย์:

หลังจากนั้นเราจะอัปเดตแต่ละค่าโดยใช้สูตร:

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

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

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

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

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

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

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

ในรหัสเทียม การไล่ระดับสีแบบสุ่มมีลักษณะดังนี้:

จนกว่าการเปลี่ยนแปลงฟังก์ชันต้นทุนจะมีน้อย: (

สำหรับ j:= 1 ถึง ม. (

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

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

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

• ความหมายของ GS คือคำอธิบายของอัลกอริทึมทั้งหมด
• อัลกอริธึมรูปแบบต่างๆ
• การใช้โค้ด: การเขียนโค้ดใน Phyton

การไล่ระดับโคตรคืออะไร

การไล่ระดับลงเป็นวิธีการค้นหาค่าต่ำสุดของฟังก์ชันการสูญเสีย (ฟังก์ชันนี้มีหลายประเภท) การลดฟังก์ชันใดๆ ให้เหลือน้อยที่สุดหมายถึงการค้นหาหุบเขาที่ลึกที่สุดในฟังก์ชันนั้น โปรดทราบว่าฟังก์ชันนี้ใช้เพื่อควบคุมข้อผิดพลาดในการทำนายแบบจำลอง การเรียนรู้ของเครื่อง- การหาค่าต่ำสุดหมายถึงการได้ค่าน้อยที่สุด ข้อผิดพลาดที่เป็นไปได้หรือปรับปรุงความแม่นยำของแบบจำลอง เราเพิ่มความแม่นยำโดยการวนซ้ำชุดข้อมูลการฝึกในขณะเดียวกันก็ปรับพารามิเตอร์โมเดลของเรา (น้ำหนักและอคติ)

ดังนั้นจึงจำเป็นต้องมีการไล่ระดับสีเพื่อลดฟังก์ชันการสูญเสียให้เหลือน้อยที่สุด

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

การหาค่าต่ำสุดของฟังก์ชัน

ในอนาคตให้พบมากที่สุด ข้อผิดพลาดต่ำ(หุบเขาที่ลึกที่สุด) ในฟังก์ชันการสูญเสีย (ด้วยความเคารพต่อน้ำหนักเดียว) คุณต้องปรับพารามิเตอร์โมเดล เราจะตั้งค่าได้อย่างไร? สิ่งนี้จะช่วยได้ การวิเคราะห์ทางคณิตศาสตร์- จากการวิเคราะห์ เรารู้ว่าความชันของกราฟของฟังก์ชันเป็นอนุพันธ์ของฟังก์ชันเทียบกับตัวแปร ความชันนี้ชี้ไปที่ภาวะซึมเศร้าที่ใกล้ที่สุดเสมอ!

ในรูปเราเห็นกราฟของฟังก์ชันการสูญเสีย (ชื่อ “ข้อผิดพลาด” โดยมีสัญลักษณ์ “J”) ที่มีน้ำหนักหนึ่ง ทีนี้ หากเราคำนวณความชัน (เรียกว่า dJ/dw) ของฟังก์ชันการสูญเสียเทียบกับน้ำหนักหนึ่ง เราจะได้ทิศทางที่เราต้องเคลื่อนที่เพื่อไปยังค่าต่ำสุดเฉพาะจุด ลองจินตนาการดูว่าแบบจำลองของเรามีน้ำหนักเพียงอันเดียว

ฟังก์ชั่นการสูญเสีย

สำคัญ:ขณะที่เราวนซ้ำข้อมูลการฝึก เราจะเพิ่มค่า dJ/dw สำหรับแต่ละน้ำหนักต่อไป เนื่องจากการสูญเสียขึ้นอยู่กับตัวอย่างการฝึกอบรม dJ/dw จึงมีการเปลี่ยนแปลงต่อไป จากนั้นเราจะนำค่าที่รวบรวมมาหารด้วยจำนวนตัวอย่างการฝึกเพื่อให้ได้ค่าเฉลี่ย จากนั้นเราจะใช้ค่าเฉลี่ยนี้ (ของน้ำหนักแต่ละตัว) เพื่อปรับแต่ละน้ำหนัก

โปรดทราบ:ฟังก์ชันการสูญเสียมีไว้เพื่อติดตามข้อผิดพลาดในตัวอย่างการฝึกแต่ละตัวอย่าง ในขณะที่อนุพันธ์ของฟังก์ชันน้ำหนักเดี่ยวสัมพัทธ์คือตำแหน่งที่ต้องเปลี่ยนน้ำหนักเพื่อลดให้เหลือน้อยที่สุดสำหรับตัวอย่างการฝึกนั้น คุณสามารถสร้างแบบจำลองได้โดยไม่ต้องใช้ฟังก์ชันการสูญเสีย แต่คุณจะต้องใช้อนุพันธ์เทียบกับน้ำหนักแต่ละค่า (dJ/dw)

ตอนนี้เราได้กำหนดทิศทางที่เราต้องผลักน้ำหนักแล้ว เราต้องหาวิธีทำ ในที่นี้เราใช้สัมประสิทธิ์อัตราการเรียนรู้ ซึ่งเรียกว่าไฮเปอร์พารามิเตอร์ ไฮเปอร์พารามิเตอร์คือค่าที่โมเดลของคุณต้องการซึ่งเรามีเพียงแนวคิดที่คลุมเครือเท่านั้น โดยปกติแล้วค่าเหล่านี้สามารถเรียนรู้ได้ผ่านการลองผิดลองถูก ไม่เป็นเช่นนั้น: เหมาะกับไฮเปอร์พารามิเตอร์ทั้งหมด ปัจจัยด้านอัตราการเรียนรู้ถือเป็น "ก้าวไปในทิศทางที่ถูกต้อง" ซึ่งทิศทางนั้นมาจาก dJ/dw

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

ข้อมูลเพิ่มเติมเกี่ยวกับการไล่ระดับสี

นอกจากฟังก์ชันการสูญเสียแล้ว การไล่ระดับลงยังต้องการการไล่ระดับสีที่เป็น dJ/dw (อนุพันธ์ของฟังก์ชันการสูญเสียเทียบกับน้ำหนักหนึ่ง ซึ่งดำเนินการกับน้ำหนักทั้งหมด) dJ/dw ขึ้นอยู่กับการเลือกฟังก์ชันการสูญเสียของคุณ ฟังก์ชันการสูญเสียที่พบบ่อยที่สุดคือค่าคลาดเคลื่อนรูทค่าเฉลี่ยกำลังสอง

อนุพันธ์ของฟังก์ชันนี้เทียบกับน้ำหนักใดๆ (สูตรนี้แสดงการคำนวณการไล่ระดับสีสำหรับ):

นี่คือคณิตศาสตร์ทั้งหมดใน GS เมื่อมองดูสิ่งนี้แล้ว เราสามารถพูดได้ว่าโดยพื้นฐานแล้ว GS ไม่มีคณิตศาสตร์มากนัก คณิตศาสตร์เดียวที่มีคือการคูณและการหาร ซึ่งเราจะพูดถึง ซึ่งหมายความว่าการเลือกฟังก์ชันของคุณจะส่งผลต่อการคำนวณการไล่ระดับสีของแต่ละน้ำหนัก

ปัจจัยอัตราการเรียนรู้

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

อย่างไรก็ตาม ปัญหาของโมเดลส่วนใหญ่ก็คืออัตราการเรียนรู้ มาดูนิพจน์ที่อัปเดตสำหรับแต่ละน้ำหนักกัน (j มีตั้งแต่ 0 ถึงจำนวนน้ำหนัก และ Theta-j คือ น้ำหนักที่เจในเวกเตอร์ของน้ำหนัก k จะมีค่าตั้งแต่ 0 ถึงจำนวนออฟเซ็ต โดยที่ B-k คือ ชดเชย kในเวกเตอร์การกระจัด) โดยที่อัลฟ่าคือค่าสัมประสิทธิ์อัตราการเรียนรู้ จากนี้เราสามารถพูดได้ว่าเราคำนวณ dJ/dTheta-j (ความชันของน้ำหนักของ Theta-j) จากนั้นจึงคำนวณขนาดอัลฟาในทิศทางนั้น ดังนั้นเราจึงลงความชัน หากต้องการอัปเดตออฟเซ็ต ให้แทนที่ Theta-j ด้วย B-k

หากขนาดอัลฟ่าของขั้นตอนนี้ใหญ่เกินไป เราจะเกินค่าขั้นต่ำ กล่าวคือ เราจะพลาดค่าขั้นต่ำ หากอัลฟ่ามีขนาดเล็กเกินไป เราจะใช้การวนซ้ำมากเกินไปเพื่อให้ได้ค่าต่ำสุด ดังนั้นอัลฟ่าควรจะเหมาะสม

การใช้การไล่ระดับโคตร

แค่นั้นแหละ. นั่นคือทั้งหมดที่คุณต้องรู้เกี่ยวกับการไล่ระดับสี มาสรุปทุกอย่างด้วยรหัสเทียม

หมายเหตุ: มาตราส่วนที่นี่แสดงเป็นเวกเตอร์ ในโมเดลขนาดใหญ่ พวกมันอาจเป็นเมทริกซ์

จาก i = 0 ถึง “จำนวนตัวอย่างการฝึก”

1. คำนวณความชันของฟังก์ชันการสูญเสียสำหรับตัวอย่างการฝึก i-th สำหรับแต่ละน้ำหนักและอคติ ตอนนี้คุณมีเวกเตอร์ที่เต็มไปด้วยการไล่ระดับสีสำหรับแต่ละน้ำหนักและตัวแปรที่มีการไล่ระดับอคติ

2. เพิ่มการไล่ระดับสีของน้ำหนักที่คำนวณสำหรับเวกเตอร์สะสมที่แยกจากกัน ซึ่งหลังจากที่คุณวนซ้ำผ่านตัวอย่างการฝึกแต่ละรายการแล้ว ควรมีผลรวมของการไล่ระดับสีของน้ำหนักแต่ละอันในการวนซ้ำหลายครั้ง

3. เช่นเดียวกับสถานการณ์ที่มีตาชั่ง ให้เพิ่มการไล่ระดับอคติให้กับตัวแปรสะสม

หลังจากดูตัวอย่างการฝึกอบรมทั้งหมดแล้ว ให้ทำดังต่อไปนี้:

1. หารตัวแปรน้ำหนักและอคติสะสมด้วยจำนวนตัวอย่างการฝึก นี่จะให้ค่าความชันเฉลี่ยสำหรับน้ำหนักทั้งหมด และค่าความชันเฉลี่ยของค่าอคติ เราจะเรียกพวกเขาว่าแบตเตอรี่ที่อัปเดต (RA)

2. จากนั้น ใช้สูตรด้านล่าง อัปเดตน้ำหนักและอคติทั้งหมด แทนที่จะเป็น dJ / dTheta-j คุณจะแทนที่ OA (ตัวสะสมที่อัปเดต) สำหรับน้ำหนักและ OA สำหรับอคติ ทำเช่นเดียวกันกับออฟเซ็ต

นี่เป็นเพียงการทำซ้ำของการไล่ระดับสี

ทำซ้ำขั้นตอนนี้ตั้งแต่ต้นจนจบเพื่อวนซ้ำหลายครั้ง ซึ่งหมายความว่าในการทำซ้ำ GS ครั้งแรก คุณจะต้องทำซ้ำตามตัวอย่างการฝึกอบรมทั้งหมด คำนวณการไล่ระดับสี จากนั้นอัปเดตน้ำหนักและอคติ จากนั้นให้คุณทำเช่นนี้เพื่อทำซ้ำ HS หลายครั้ง

การไล่ระดับแบบต่างๆ

มี 3 ตัวเลือกสำหรับการไล่ระดับสี:

1. มินิแบทช์: ที่นี่ แทนที่จะวนซ้ำตัวอย่างการฝึกทั้งหมดและด้วยการวนซ้ำแต่ละครั้งที่ทำการคำนวณตัวอย่างการฝึกเพียงตัวอย่างเดียว เราจะประมวลผลตัวอย่างการฝึก n ตัวอย่างพร้อมกัน ตัวเลือกนี้เหมาะสำหรับชุดข้อมูลขนาดใหญ่มาก

2.โคตรลาดสุ่ม: ในกรณีนี้ แทนที่จะใช้และวนซ้ำตัวอย่างการฝึกอบรมแต่ละรายการ เราเพียงแค่ใช้ครั้งเดียว มีบางสิ่งที่ควรทราบ:

• ในแต่ละรอบของ GS คุณจะต้องสับเปลี่ยนชุดการฝึกและเลือก ตัวอย่างแบบสุ่มการฝึกอบรม.
• เนื่องจากคุณใช้ตัวอย่างการฝึกอบรมเพียงตัวอย่างเดียว เส้นทางของคุณไปยังจุดต่ำสุดในท้องถิ่นจึงจะมีเสียงดังมาก เช่น คนเมาเหล้าที่ดื่มมาก

3. จีเอส ซีรีส์: นี่คือสิ่งที่เขียนไว้ในส่วนก่อนหน้า วงจรในแต่ละตัวอย่างการเรียนรู้

รูปภาพเปรียบเทียบการตี 3 ครั้งกับค่าขั้นต่ำในท้องถิ่น

ตัวอย่างโค้ดในหลาม

ใช้ได้กับซีรีส์ GS นี่คือลักษณะของบล็อกโค้ดการฝึกใน Python

Def train(X, y, W, B, alpha, max_iters): """ ดำเนินการ GD กับตัวอย่างการฝึกทั้งหมด, X: ชุดข้อมูลการฝึก, y: ป้ายกำกับสำหรับข้อมูลการฝึก, W: เวกเตอร์น้ำหนัก, B: ตัวแปรอคติ, อัลฟา : อัตราการเรียนรู้ max_iters: การวนซ้ำ GD สูงสุด """ dW = 0 # ตัวสะสมการไล่ระดับสีของน้ำหนัก dB = 0 # ตัวสะสมการไล่ระดับสีอคติ m = X.shape # No ตัวอย่างการฝึก i อยู่ในช่วง (max_iters): dW = 0 # การรีเซ็ตตัวสะสม dB = 0 สำหรับ j ที่อยู่ใน range (m): # 1. วนซ้ำตัวอย่างทั้งหมด # 2. คำนวณการไล่ระดับสีของน้ำหนักและอคติใน w_grad และ b_grad, # 3. อัปเดต dW โดยการเพิ่ม w_grad และ dB โดยการเพิ่ม b_grad, W = W - alpha * (dW / m) # อัปเดตน้ำหนัก B = B - alpha * (dB / m) # อัปเดตค่าส่งคืนอคติ W, B # คืนน้ำหนักและอคติที่อัปเดต

แค่นั้นแหละ. ตอนนี้คุณควรมีความเข้าใจเป็นอย่างดีแล้วว่าการไล่ระดับลงคืออะไร

การไล่ระดับสีสุ่มประมาณโดยสูตร:

กล่าวคือ มันคือผลรวมของเวกเตอร์สุ่มทั้งหมดที่มีน้ำหนักเท่ากับการเพิ่มขึ้นของฟังก์ชันที่ถูกย่อให้เล็กสุดในทิศทางสุ่มที่กำหนด

หากเราใช้เวกเตอร์หน่วยเป็นพารามิเตอร์ การประมาณค่านี้ ดังที่เห็นได้ง่ายจาก (3.3.22) จะได้ว่า ค่าที่แน่นอนการไล่ระดับสี

การประมาณค่าความชันที่อธิบายไว้ทั้งสองค่าสามารถนำไปใช้อย่างมีประสิทธิผลกับค่าใดๆ ก็ได้ ซึ่งรวมถึงค่าที่แยกความแตกต่างอย่างมีนัยสำคัญจากวิธีการประมาณค่าที่กำหนดขึ้น (3.3.22) ซึ่งใช้อย่างเคร่งครัดในสถานการณ์เดียวกันนี้ เป็นการยืนยันว่าวิธีการกำหนดที่กำหนดนั้นถูกทำให้เป็นแบบทั่วไป (ดูส่วนท้ายของ ส่วนย่อย 3.3.1 ) ให้เรายกตัวอย่างอื่นของลักษณะทั่วไปดังกล่าว

การค้นหาแบบไล่ระดับ (3.3.21) เป็นกรณีพิเศษตาม อย่างน้อยอัลกอริธึมการค้นหาแบบสุ่มสองแบบ อัลกอริทึมแรก:

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

ตามที่เห็นได้ง่าย เมื่ออัลกอริธึมทั้งสองเสื่อมลงเป็นอัลกอริธึมการค้นหาแบบไล่ระดับ (3.3.21)

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

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

ดังนั้น อัลกอริธึมการค้นหาแบบสุ่มพร้อมกลยุทธ์เชิงเส้น (3.3.12) จึงเป็นแบบจำลองสุ่มของอัลกอริธึมการสืบเชื้อสายที่ชันที่สุด:

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

ตัวดำเนินการขั้นตอนการสุ่มจะแทนที่ตัวดำเนินการการประมาณค่าเกรเดียนต์ที่ยุ่งยาก เช่น ตามสูตร (3.3.22)

คุณลักษณะถัดไปของการค้นหาแบบสุ่มที่แยกแยะความแตกต่างจากวิธีการปกติได้ดีคือความเป็นสากล ซึ่งปรากฏให้เห็นเป็นหลักในอัลกอริธึมการค้นหาแบบสุ่มเฉพาะที่ซึ่งไม่ได้มีวัตถุประสงค์เพื่อค้นหาจุดสุดยอดทั่วโลก ดังนั้น อัลกอริธึมการลงแบบสุ่มสามารถค้นหาจุดสุดขั้วส่วนกลางได้ แต่โดยหลักการแล้ว อัลกอริธึมการลงที่ชันที่สุดตามปกติไม่อนุญาตให้มีความเป็นไปได้นี้ เนื่องจากได้รับการออกแบบมาเพื่อค้นหาจุดสุดยอดเฉพาะจุด

ดังนั้นความเป็นสากลของอัลกอริธึมการค้นหาแบบสุ่มจึงเปรียบเสมือน "พรีเมี่ยม" สำหรับการใช้การสุ่มและบางอย่างเช่น " สมัครฟรี» ไปยังอัลกอริทึม สถานการณ์นี้มีความสำคัญอย่างยิ่งโดยเฉพาะอย่างยิ่งเมื่อปรับออบเจ็กต์ให้เหมาะสมด้วยโครงสร้างที่ไม่รู้จัก เมื่อไม่มีความมั่นใจอย่างสมบูรณ์ในธรรมชาติของปัญหาแบบสุดขั้วเดียว และอาจมีแบบสุดโต่งหลายแบบได้ (แม้ว่าจะไม่ได้คาดหวังก็ตาม) โดยใช้วิธีการในกรณีนี้ การค้นหาทั่วโลกมันจะเป็นความฟุ่มเฟือยที่ไม่ฉลาด วิธีการค้นหาแบบสุ่มในพื้นที่มีความเหมาะสมที่สุดที่นี่ เนื่องจากสามารถแก้ไขปัญหาในท้องถิ่นได้อย่างมีประสิทธิภาพ และโดยหลักการแล้วสามารถแก้ไขปัญหาระดับโลกได้ หากเกิดขึ้น นี่เป็นการค้นหาแบบสุ่มที่มีความน่าเชื่อถือทางจิตวิทยาซึ่งผู้ใช้ให้คุณค่าอย่างสูง

ความเรียบง่ายของอัลกอริธึมของการค้นหาแบบสุ่มทำให้ดึงดูดผู้บริโภคเป็นหลัก ประสบการณ์แสดงให้เห็นว่าอัลกอริธึมการค้นหาแบบสุ่มที่รู้จักนั้นเป็นเพียง "ผืนผ้าใบ" ที่ผู้ใช้ในแต่ละกรณี "รูปแบบการปัก" ของอัลกอริธึมใหม่ที่สะท้อนไม่เพียงแต่รสนิยมและความโน้มเอียงของเขาเท่านั้น (ซึ่งไม่สามารถละเลยได้) แต่ยังรวมถึงข้อมูลเฉพาะเจาะจงด้วย ของออบเจ็กต์ที่ได้รับการปรับให้เหมาะสม อย่างหลังสร้างพื้นฐานที่ดีสำหรับการดำเนินการตามหลักการที่รู้จักกันดีว่าอัลกอริทึมควรได้รับการออกแบบ "สำหรับวัตถุ" ในที่สุด ความเรียบง่ายของอัลกอริธึมของการค้นหาแบบสุ่มจะกำหนดความเรียบง่ายของการนำฮาร์ดแวร์ไปใช้ สิ่งนี้ไม่เพียงทำให้สามารถสร้างเครื่องมือเพิ่มประสิทธิภาพที่เรียบง่าย กะทัดรัด และเชื่อถือได้พร้อมพารามิเตอร์ที่ปรับให้เหมาะสมได้ไม่จำกัดจำนวน แต่ยังทำให้การจัดระเบียบการสังเคราะห์ที่เหมาะสมที่สุดบนคอมพิวเตอร์เป็นเรื่องง่ายอีกด้วย