การถดถอยเชิงเส้นโดยใช้วิธี Gratity Descent [อธิบายด้วยตัวอย่างการเข้ารหัส]

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

วิธีการไล่ระดับการลงระดับถูกเลือกใช้ในการทำซ้ำต่างๆ เนื่องจากเทคนิคการเพิ่มประสิทธิภาพที่มีให้ ด้วยอัลกอริธึม เป็นไปได้ที่จะลดขนาด เช่น Logistic regression และ neural network ก่อนเริ่มต้นด้วยการไล่ระดับสี เรามาดูการถดถอยเชิงเส้นกันก่อน

อ่าน: อัลกอริธึมการเรียนรู้ของเครื่องสำหรับวิทยาศาสตร์ข้อมูล

การถดถอยเชิงเส้นคืออะไร?

เป็นแนวทางเชิงเส้นที่ใช้ในการสร้างแบบจำลองความสัมพันธ์ระหว่างตัวแปรตามและตัวแปรอิสระอย่างน้อยหนึ่งตัว ความสัมพันธ์เชิงเส้นตรงระหว่างตัวแปรดังกล่าวจะแสดงในรูปแบบสมการ ay= mx+b

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

Gradient Descent คืออะไร?

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

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

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

สำหรับการประมาณการไล่ระดับสีที่ดีขึ้น ให้ลองใช้โค้ดในตัวอย่าง ทำงานกับ python ด้วยความช่วยเหลือของ NumPy

จากการนำเข้า NumPy *

# y = mx + b

# m คือความชัน b คือจุดตัด y

def compute_error_for_line_given_points(b, m, คะแนน):

TotalError = 0

สำหรับฉันอยู่ในช่วง(0, len(จุด)):

x = คะแนน[i, 0]

y = คะแนน[i, 1]

TotalError += (y – (m * x + b)) ** 2

ส่งคืน TotalError / float(len(points))

def step_gradient(b_current, m_current, คะแนน, อัตราการเรียนรู้):

b_gradient = 0

m_gradient = 0

N = ลอย (len(จุด))

สำหรับฉันอยู่ในช่วง(0, len(จุด)):

x = คะแนน[i, 0]

y = คะแนน[i, 1]

b_gradient += -(2/N) * (y – ((m_current * x) + b_current))

m_gradient += - (2/N) * x * (y – ((m_current * x) + b_current))

new_b = b_current – ​​(อัตราการเรียนรู้ * b_gradient)

new_m = m_current – ​​(อัตราการเรียนรู้ * m_gradient)

กลับ [new_b, new_m]

def gradient_descent_runner (คะแนน, beginning_b, beginning_m, learning_rate, num_iterations):

b = จุดเริ่มต้น_b

m = เริ่มต้น_m

สำหรับฉันอยู่ในช่วง (num_iterations):

b, m = step_gradient(b, m, array(points), learning_rate)

กลับ [b, m]

def รัน ():

คะแนน = genfromtxt("data.csv", delimiter=",")

learning_rate = 0.0001

initial_b = 0 # เริ่มต้นการสกัดกั้น y เดา

initial_m = 0 # เดาความชันเริ่มต้น

num_iterations = 1,000

พิมพ์ “การไล่ระดับเริ่มต้นที่ b = {0}, m = {1}, error = {2}”.format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points))

พิมพ์ “วิ่ง…”

[b, m] = gradient_descent_runner (คะแนน, initial_b, initial_m, learning_rate, num_iterations)

พิมพ์ “หลังจาก {0} วนซ้ำ b = {1}, m = {2}, error = {3}”.format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points))

ถ้า __name__ == '__main__':

วิ่ง()

รหัสอ้างอิง

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

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

initial_b = 0 # เริ่มต้นการสกัดกั้น y เดา

initial_m = 0 # เดาความชันเริ่มต้น

num_iterations = 1,000

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

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

ต้องอ่าน: คำถามสัมภาษณ์เกี่ยวกับการเรียนรู้ของเครื่อง

เคล็ดลับสำหรับการไล่ระดับสี Descent

1. อัตราการเรียนรู้

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

2. วางแผนต้นทุนเฉลี่ย

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

สรุป

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