สำรวจอัลกอริธึมการเรียนรู้ของเครื่องภายใต้การดูแล

เป้าหมายหลักของการอ่านครั้งนี้คือการทำความเข้าใจวิธีการทางสถิติที่เพียงพอเพื่อให้สามารถใช้ประโยชน์จากอัลกอริธึมการเรียนรู้ของเครื่องในไลบรารี scikit-learn ของ Python แล้วใช้ความรู้นี้เพื่อแก้ปัญหาการเรียนรู้ของเครื่องแบบคลาสสิก

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

ข้อจำกัดความรับผิดชอบบางประการ:

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

ด้วยประการฉะนี้ มาดำดิ่งกันเถอะ!

บทนำอย่างรวดเร็วเกี่ยวกับอัลกอริทึมการเรียนรู้ของเครื่อง

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

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

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

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

น่าเสียดายที่เราไม่มีเวลามากขนาดนั้น เราจึงต้องหาวิธีอื่นในการขุด cryptocurrency อย่างมีประสิทธิภาพ เราเดินทางมาไกลถึงตอนนี้แล้ว?

ประวัติโดยย่อของอัลกอริทึมการเรียนรู้ของเครื่อง

รากฐานของอัลกอริธึมแมชชีนเลิร์นนิงมาจาก Thomas Bayes ซึ่งเป็นนักสถิติชาวอังกฤษที่อาศัยอยู่ในศตวรรษที่ 18 บทความของเขา An Essay Towards Solving a Problem in the Doctrine of Chances เป็น รากฐานของทฤษฎีบทของ Bayes ซึ่งใช้กันอย่างแพร่หลายในด้านสถิติ

ในศตวรรษที่ 19 Pierre-Simon Laplace ได้ตีพิมพ์ Theorie analytique des probabilites ขยายงานของ Bayes และกำหนดสิ่งที่เรารู้ในวันนี้ว่าเป็นทฤษฎีบทของ Bayes ก่อนหน้านั้นไม่นาน Adrien-Marie Legendre ได้อธิบายวิธี "กำลังสองน้อยที่สุด" ซึ่งปัจจุบันใช้กันอย่างแพร่หลายในการเรียนรู้ภายใต้การดูแล

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

แต่แล้วช่วงทศวรรษ 1970 เห็นการมองโลกในแง่ร้ายมากมายเกี่ยวกับแนวคิด AI และด้วยเหตุนี้ เงินทุนจึงลดลง ดังนั้นช่วงนี้จึงเรียกว่า AI ฤดูหนาว การค้นพบการแพร่ระบาดซ้ำอีกครั้งในช่วงทศวรรษ 1980 ทำให้เกิดการฟื้นตัวในการวิจัยแมชชีนเลิร์นนิง และวันนี้ก็เป็นประเด็นร้อนอีกครั้ง

Leo Breiman ตอนปลายแยกความแตกต่างระหว่างกระบวนทัศน์การสร้างแบบจำลองทางสถิติสองแบบ: การสร้างแบบจำลองข้อมูลและการสร้างแบบจำลองอัลกอริธึม “การสร้างแบบจำลองอัลกอริทึม” หมายถึงอัลกอริธึมแมชชีนเลิร์นนิงเช่นฟอ เรสต์สุ่ม

แมชชีนเลิร์นนิงและสถิติเป็นสาขาที่เกี่ยวข้องกันอย่างใกล้ชิด ตามที่ Michael I. Jordan ได้กล่าวไว้ แนวคิดของแมชชีนเลิร์นนิง ตั้งแต่หลักการเกี่ยวกับระเบียบวิธีไปจนถึงเครื่องมือเชิงทฤษฎี มีประวัติมาช้านานในด้านสถิติ นอกจากนี้ เขายังแนะนำ วิทยาศาสตร์ข้อมูล เป็นคำศัพท์สำหรับปัญหาโดยรวมที่ทั้งผู้เชี่ยวชาญด้านแมชชีนเลิร์นนิงและนักสถิติต่างก็ทำงานโดยปริยาย

หมวดหมู่ของอัลกอริทึมการเรียนรู้ของเครื่อง

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

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

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

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

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

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

โมเดลแมชชีนเลิร์นนิงภายใต้การดูแลขั้นพื้นฐาน

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

ในแง่ของฆราวาส นี่หมายความว่าการถดถอยเชิงเส้นคืออัลกอริธึมที่เรียนรู้การพึ่งพาระหว่าง $x$ และ $y$ แต่ละตัวที่รู้จัก ดังนั้นในภายหลังเราสามารถใช้มันเพื่อทำนาย $y$ สำหรับตัวอย่างที่ไม่รู้จักของ $x$

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

ตามที่กล่าวไว้ข้างต้น อัลกอริธึมการเรียนรู้ของเครื่องส่วนใหญ่ทำงานโดยการค้นหาการพึ่งพาทางสถิติในข้อมูลที่ให้ไว้ การพึ่งพาอาศัยกันนี้เรียกว่า สมมติฐาน และมักจะแสดงด้วย $h(\theta)$

ในการหาสมมติฐาน ให้เริ่มต้นด้วยการโหลดและสำรวจข้อมูล

 import matplotlib.pyplot as plt from pandas import read_csv import os # Load data data_path = os.path.join(os.getcwd(), "data/blood-pressure.txt") dataset = read_csv(data_path, delim_whitespace=True) # We have 30 entries in our dataset and four features. The first feature is the ID of the entry. # The second feature is always 1. The third feature is the age and the last feature is the blood pressure. # We will now drop the ID and One feature for now, as this is not important. dataset = dataset.drop(['ID', 'One'], axis=1) # And we will display this graph %matplotlib inline dataset.plot.scatter(x='Age', y='Pressure') # Now, we will assume that we already know the hypothesis and it looks like a straight line h = lambda x: 84 + 1.24 * x # Let's add this line on the chart now ages = range(18, 85) estimated = [] for i in ages: estimated.append(h(i)) plt.plot(ages, estimated, 'b')

[<matplotlib.lines.Line2D at 0x11424b828>]

ในแผนภูมิด้านบน จุดสีน้ำเงินทุกจุดแสดงถึงตัวอย่างข้อมูลของเรา และเส้นสีน้ำเงินคือสมมติฐานที่อัลกอริทึมของเราต้องเรียนรู้ แล้วสมมติฐานนี้คืออะไรกันแน่?

เพื่อแก้ปัญหานี้ เราต้องเรียนรู้การพึ่งพาระหว่าง $x$ และ $y$ ซึ่งเขียนแทนด้วย $y = f(x)$ ดังนั้น $f(x)$ จึงเป็นฟังก์ชันเป้าหมายในอุดมคติ อัลกอริธึมการเรียนรู้ของเครื่องจะพยายามเดาฟังก์ชันสมมติฐาน $h(x)$ ซึ่งเป็นค่าประมาณที่ใกล้เคียงที่สุดของ $f(x)$ ที่ไม่รู้จัก

รูปแบบสมมติฐานที่ง่ายที่สุดที่เป็นไปได้สำหรับปัญหาการถดถอยเชิงเส้นมีลักษณะดังนี้: $h_\theta(x) = \theta_0 + \theta_1 * x$ เรามีตัวแปรสเกลาร์อินพุตเดียว $x$ ซึ่งส่งออกตัวแปรสเกลาร์เดียว $y$ โดยที่ $\theta_0$ และ $\theta_1$ เป็นพารามิเตอร์ที่เราต้องเรียนรู้ กระบวนการปรับเส้นสีน้ำเงินนี้ให้พอดีในข้อมูลเรียกว่า การถดถอยเชิงเส้น สิ่งสำคัญคือต้องเข้าใจว่าเรามีพารามิเตอร์อินพุตเพียงตัวเดียว $x_1$; อย่างไรก็ตาม ฟังก์ชันสมมติฐานจำนวนมากจะรวมหน่วยอคติไว้ด้วย ($x_0$) ดังนั้นสมมติฐานที่ได้จึงมีรูปแบบของ $h_\theta(x) = \theta_0 * x_0 + \theta_1 * x_1$ แต่เราสามารถหลีกเลี่ยงการเขียน $x_0$ ได้เพราะมันจะเท่ากับ 1 เสมอ

กลับมาที่เส้นสีน้ำเงิน สมมติฐานของเราดูเหมือน $h(x) = 84 + 1.24x$ ซึ่งหมายความว่า $\theta_0 = 84$ และ $\theta_1 = 1.24$ เราจะหาค่า $\theta$ เหล่านั้นโดยอัตโนมัติได้อย่างไร

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

\[J(\theta) = \frac{1}{2m}\sum_{i=1}^m(h_\theta(x^{(i)}) - y^{(i)})^2\ ]

ตัวอย่างเช่น สมมติฐานของเราคาดการณ์ว่าสำหรับคนที่อายุ 48 ปี ความดันโลหิตของพวกเขาควรเป็น $h(48) = 84 + 1.24 * 48 = 143mmHg$; อย่างไรก็ตาม ในตัวอย่างการฝึกอบรมของเรา เรามีมูลค่า 130 mmHg$ ดังนั้นข้อผิดพลาดคือ $(143 - 130)^2 = 169$ ตอนนี้ เราต้องคำนวณข้อผิดพลาดนี้สำหรับทุกๆ รายการในชุดข้อมูลการฝึก จากนั้นรวมเข้าด้วยกัน ($\sum_{i=1}^m(h_\theta(x^{(i)}) - y^{(i )})^2$) แล้วเอาค่าเฉลี่ยออกมา

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

 import numpy as np # Let's calculate the cost for the hypothesis above h = lambda x, theta_0, theta_1: theta_0 + theta_1 * x def cost(X, y, t0, t1): m = len(X) # the number of the training samples c = np.power(np.subtract(h(X, t0, t1), y), 2) return (1 / (2 * m)) * sum(c) X = dataset.values[:, 0] y = dataset.values[:, 1] print('J(Theta) = %2.2f' % cost(X, y, 84, 1.24))

J(Theta) = 1901.95

ตอนนี้ เราจำเป็นต้องค้นหาค่าดังกล่าวของ $\theta$ เพื่อให้ ค่าฟังก์ชันต้นทุน ของเรามีค่าน้อยที่สุด แต่เราจะทำอย่างไร?

\[minJ(\theta) = \frac{1}{2m}\sum_{i=1}^m(h_\theta(x^{(i)}) - y^{(i)})^2\ ]

มีอัลกอริธึมที่เป็นไปได้หลายแบบ แต่ที่นิยมที่สุดคือ gradient descent เพื่อให้เข้าใจถึงสัญชาตญาณเบื้องหลังวิธี gradient descent อันดับแรก เรามาลงจุดบนกราฟกันก่อน เพื่อความเรียบง่าย เราจะตั้งสมมติฐานที่ง่ายกว่า $h(\theta) = \theta_1 * x$ ต่อไป เราจะพล็อตแผนภูมิ 2 มิติอย่างง่าย โดยที่ $x$ คือค่าของ $\theta$ และ $y$ เป็นฟังก์ชันต้นทุน ณ จุดนี้

 import matplotlib.pyplot as plt fig = plt.figure() # Generate the data theta_1 = np.arange(-10, 14, 0.1) J_cost = [] for t1 in theta_1: J_cost += [ cost(X, y, 0, t1) ] plt.plot(theta_1, J_cost) plt.xlabel(r'$\theta_1$') plt.ylabel(r'$J(\theta)$') plt.show() 

ฟังก์ชันต้นทุนเป็นแบบนูน ซึ่งหมายความว่าในช่วง $[a, b]$ มีขั้นต่ำเพียงค่าเดียว ซึ่งหมายถึงอีกครั้งว่าพารามิเตอร์ $\theta$ ที่ดีที่สุดอยู่ที่จุดที่ฟังก์ชันต้นทุนน้อยที่สุด

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

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

วิธีการทำงานของอัลกอริทึมคือ:

1. เราเลือกจุดเริ่มต้นแบบสุ่ม (สุ่ม $\theta$)
2. คำนวณอนุพันธ์ของฟังก์ชันต้นทุน ณ จุดนี้
3. ก้าวเล็กๆ ไปทางลาด $\theta_j := \theta_j - \lambda * \frac{\partial}{\partial \theta_j} * J(\theta)$
4. ทำซ้ำขั้นตอนที่ 2-3 จนกว่าเราจะมาบรรจบกัน

ตอนนี้เงื่อนไขการบรรจบกันขึ้นอยู่กับการใช้งานอัลกอริทึม เราอาจหยุดหลังจาก 50 ก้าว หลังจากผ่านเกณฑ์บางอย่าง หรืออย่างอื่น

 import math # Example of the simple gradient descent algorithm taken from Wikipedia cur_x = 2.5 # The algorithm starts at point x gamma = 0.005 # Step size multiplier precision = 0.00001 previous_step_size = cur_x df = lambda x: 2 * x * math.cos(x) # Remember the learning curve and plot it while previous_step_size > precision: prev_x = cur_x cur_x += -gamma * df(prev_x) previous_step_size = abs(cur_x - prev_x) print("The local minimum occurs at %f" % cur_x)

The local minimum occurs at 4.712194

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

 from sklearn.linear_model import LinearRegression # LinearRegression uses the gradient descent method # Our data X = dataset[['Age']] y = dataset[['Pressure']] regr = LinearRegression() regr.fit(X, y) # Plot outputs plt.xlabel('Age') plt.ylabel('Blood pressure') plt.scatter(X, y, color='black') plt.plot(X, regr.predict(X), color='blue') plt.show() plt.gcf().clear() 

<matplotlib.figure.Figure at 0x120fae1d0>

 print( 'Predicted blood pressure at 25 yo = ', regr.predict(25) ) print( 'Predicted blood pressure at 45 yo = ', regr.predict(45) ) print( 'Predicted blood pressure at 27 yo = ', regr.predict(27) ) print( 'Predicted blood pressure at 34.5 yo = ', regr.predict(34.5) ) print( 'Predicted blood pressure at 78 yo = ', regr.predict(78) )

 Predicted blood pressure at 25 yo = [[ 122.98647692]] Predicted blood pressure at 45 yo = [[ 142.40388395]] Predicted blood pressure at 27 yo = [[ 124.92821763]] Predicted blood pressure at 34.5 yo = [[ 132.20974526]] Predicted blood pressure at 78 yo = [[ 174.44260555]]

ประเภทของข้อมูลสถิติ

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

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

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

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

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

การถดถอยโลจิสติก

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

• นี่หมาหรือแมว?
• เนื้องอกนี้เป็นมะเร็งหรือเป็นพิษเป็นภัยหรือไม่?
• ไวน์นี้ดีหรือไม่ดี?
• อีเมลนี้เป็นสแปมหรือไม่?

หรือแม้กระทั่ง:

• ในรูปคือเลขอะไรคะ?
• อีเมลนี้อยู่ในหมวดหมู่ใด

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

ก่อนอื่น เราสามารถนำสมมติฐานเชิงเส้นเดิมกลับมาใช้ใหม่ได้ $h_\theta(x) = \theta^TX$ (อยู่ในรูปแบบเวกเตอร์) ในขณะที่การถดถอยเชิงเส้นอาจแสดงตัวเลขใดๆ ในช่วง $[a, b]$ การถดถอยโลจิสติกสามารถส่งออกค่าได้เฉพาะใน $[-1, 1]$ ซึ่งเป็นความน่าจะเป็นของวัตถุที่อยู่ในหมวดหมู่ที่กำหนดหรือไม่

การใช้ ฟังก์ชัน sigmoid เราสามารถแปลงค่าตัวเลขใดๆ เพื่อแสดงค่าในช่วง $[-1, 1]$

\[f(x) = \frac{1}{1 + e^x}\]

ตอนนี้ แทนที่จะเป็น $x$ เราต้องผ่านสมมติฐานที่มีอยู่ และเราจะได้รับ:

\[f(x) = \frac{1}{1 + e^{\theta_0 + \theta_1 * x_1 + ... + \theta_n * x_n}}\]

หลังจากนั้น เราสามารถใช้เกณฑ์ง่ายๆ โดยบอกว่าถ้าสมมติฐานมากกว่าศูนย์ ค่านี้เป็นค่าจริง มิฉะนั้นจะเป็นเท็จ

\[h_\theta(x) = \begin{cases} 1 & \mbox{if } \theta^TX > 0 \\ 0 & \mbox{else} \end{cases}\]

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

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

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

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

 from sklearn.linear_model import LogisticRegression # Data data_path = os.path.join(os.getcwd(), "data/shuttle-landing-control.csv") dataset = read_csv(data_path, header=None, names=['Auto', 'Stability', 'Error', 'Sign', 'Wind', 'Magnitude', 'Visibility'], na_values='*').fillna(0) # Prepare features X = dataset[['Stability', 'Error', 'Sign', 'Wind', 'Magnitude', 'Visibility']] y = dataset[['Auto']].values.reshape(1, -1)[0] model = LogisticRegression() model.fit(X, y) # For now, we're missing one important concept. We don't know how well our model # works, and because of that, we cannot really improve the performance of our hypothesis. # There are a lot of useful metrics, but for now, we will validate how well # our algorithm performs on the dataset it learned from. "Score of our model is %2.2f%%" % (model.score(X, y) * 100)

Score of our model is 73.33%

การตรวจสอบ?

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

 from sklearn.pipeline import make_pipeline from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression from sklearn.model_selection import cross_val_score # Ground truth function ground_truth = lambda X: np.cos(15 + np.pi * X) # Generate random observations around the ground truth function n_samples = 15 degrees = [1, 4, 30] X = np.linspace(-1, 1, n_samples) y = ground_truth(X) + np.random.randn(n_samples) * 0.1 plt.figure(figsize=(14, 5)) models = {} # Plot all machine learning algorithm models for idx, degree in enumerate(degrees): ax = plt.subplot(1, len(degrees), idx + 1) plt.setp(ax, xticks=(), yticks=()) # Define the model polynomial_features = PolynomialFeatures(degree=degree) model = make_pipeline(polynomial_features, LinearRegression()) models[degree] = model # Train the model model.fit(X[:, np.newaxis], y) # Evaluate the model using cross-validation scores = cross_val_score(model, X[:, np.newaxis], y) X_test = X plt.plot(X_test, model.predict(X_test[:, np.newaxis]), label="Model") plt.scatter(X, y, edgecolor='b', s=20, label="Observations") plt.xlabel("x") plt.ylabel("y") plt.ylim((-2, 2)) plt.title("Degree {}\nMSE = {:.2e}".format( degree, -scores.mean())) plt.show() 

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

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

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

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

ในสื่อการเรียนรู้ คุณมักจะเห็นกราฟคล้ายกับเหล่านี้:

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

 from sklearn.model_selection import learning_curve, ShuffleSplit # Plot learning curves plt.figure(figsize=(20, 5)) for idx, degree in enumerate(models): ax = plt.subplot(1, len(degrees), idx + 1) plt.title("Degree {}".format(degree)) plt.grid() plt.xlabel("Training examples") plt.ylabel("Score") train_sizes = np.linspace(.6, 1.0, 6) # Cross-validation with 100 iterations to get a smoother mean test and training # score curves, each time with 20% of the data randomly selected as a validation set. cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=0) model = models[degree] train_sizes, train_scores, test_scores = learning_curve( model, X[:, np.newaxis], y, cv=cv, train_sizes=train_sizes, n_jobs=4) train_scores_mean = np.mean(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) plt.plot(train_sizes, train_scores_mean, 'o-', color="r", label="Training score") plt.plot(train_sizes, test_scores_mean, 'o-', color="g", label="Test score") plt.legend(loc = "best") plt.show() 

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

ในกราฟอัตราการเรียนรู้ "ปกติ" ตรงกลาง คุณจะเห็นว่าคะแนนการฝึกและเส้นคะแนนการทดสอบมารวมกันได้อย่างไร

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

---

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

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

การตรวจสอบข้าม

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

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

วิธีแก้ไขปัญหานี้คือขั้นตอนที่เรียกว่าการตรวจสอบข้าม ในการตรวจสอบไขว้แบบมาตรฐาน $k$-fold เราแบ่งข้อมูลออกเป็นชุดย่อย $k$ เรียกว่า folds จากนั้น เราฝึกอัลกอริทึมซ้ำๆ บน $k-1$ เท่าในขณะที่ใช้การพับที่เหลือเป็นชุดทดสอบ (เรียกว่า "การพับเก็บ")

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

มีเทคนิคการตรวจสอบไขว้อีกมากมาย เช่น Leave P out , stratified $k$-fold , shuffle and split ฯลฯ แต่สิ่งเหล่านี้อยู่นอกเหนือขอบเขตของบทความนี้

การทำให้เป็นมาตรฐาน

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

เทคนิคการทำให้เป็นมาตรฐานหลักมีสามวิธี: Lasso, Tikhonov และตาข่ายยืดหยุ่น

การทำให้เป็นมาตรฐาน L1 (หรือการทำให้เป็นมาตรฐานแบบ Lasso ) จะเลือกคุณลักษณะบางอย่างเพื่อลดขนาดเป็นศูนย์ เพื่อไม่ให้มีบทบาทใดๆ ในโมเดลสุดท้าย จะเห็นได้ว่า L1 เป็นวิธีการคัดเลือกคุณสมบัติที่สำคัญ

การทำให้เป็นมาตรฐาน L2 (หรือ การทำให้เป็นมาตรฐาน Tikhonov ) จะบังคับให้คุณลักษณะ ทั้งหมด มีขนาดค่อนข้างเล็ก ซึ่งจะทำให้มีอิทธิพลต่อโมเดลน้อยลง

ตาข่ายยืดหยุ่น คือการรวมกันของ L1 และ L2

การทำให้เป็นมาตรฐาน (การปรับคุณสมบัติ)

การปรับขนาดคุณสมบัติยังเป็นขั้นตอนที่สำคัญในขณะประมวลผลข้อมูลล่วงหน้า ชุดข้อมูลของเราอาจมีคุณลักษณะที่มีค่า $[-\infty, \infty]$ และคุณลักษณะอื่นๆ ที่มีขนาดต่างกัน นี่เป็นวิธีการสร้างมาตรฐานช่วงของค่าอิสระ

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

รองรับ Vector Machines

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

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

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

โครงข่ายประสาทเทียม

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

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

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

ไททานิคที่น่าอับอาย

RMS Titanic เป็นเรือโดยสารของอังกฤษที่จมลงในมหาสมุทรแอตแลนติกเหนือเมื่อวันที่ 15 เมษายน พ.ศ. 2455 หลังจากที่ชนกับภูเขาน้ำแข็ง มีลูกเรือและผู้โดยสารประมาณ 2,224 คน และมากกว่า 1,500 คนเสียชีวิต ทำให้เป็นหนึ่งในภัยพิบัติทางทะเลเชิงพาณิชย์ที่ร้ายแรงที่สุดตลอดกาล

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

ชุดข้อมูลของเราจะยืมมาจากแพลตฟอร์มการแข่งขันด้านวิทยาศาสตร์ข้อมูลของ Kaggle

 import os from pandas import read_csv, concat # Load data data_path = os.path.join(os.getcwd(), "data/titanic.csv") dataset = read_csv(data_path, skipinitialspace=True) dataset.head(5)

	รหัสผู้โดยสาร	เอาตัวรอด	พีคลาส	ชื่อ	เพศ	อายุ	SibSp	Parch	ตั๋ว	ค่าโดยสาร	ห้องโดยสาร	ลงมือ
0	1	0	3	บราวด์ คุณโอเว่น แฮร์ริส	ชาย	22.0	1	0	A/5 21171	7.2500	น่าน	ส
1	2	1	1	คัมมิงส์, คุณนายจอห์น แบรดลีย์ (ฟลอเรนซ์ บริกส์...	หญิง	38.0	1	0	พีซี 17599	71.2833	C85	ค
2	3	1	3	ไฮกคิเน็น น.ส.ไลนา	หญิง	26.0	0	0	สโตน/โอ2 3101282	7.9250	น่าน	ส
3	4	1	1	Futrelle, นาง Jacques Heath (Lily May Peel)	หญิง	35.0	1	0	113803	53.1000	C123	ส
4	5	0	3	อัลเลน นายวิลเลียม เฮนรี่	ชาย	35.0	0	0	373450	8.0500	น่าน	ส

ขั้นตอนแรกของเราคือโหลดและสำรวจข้อมูล เรามีบันทึกการทดสอบ 891 รายการ; แต่ละเร็กคอร์ดมีโครงสร้างดังต่อไปนี้:

• PassengerId – ID ของผู้โดยสารบนเครื่อง
• การเอาตัวรอด – ไม่ว่าบุคคลนั้นจะรอดชีวิตจากการชนหรือไม่ก็ตาม
• pclass – ชั้นตั๋ว เช่น 1st, 2nd, 3rd
• เพศ – เพศของผู้โดยสาร: ชายหรือหญิง
• ชื่อ – รวมชื่อเรื่อง
• อายุ – อายุเป็นปี
• sibsp – จำนวนพี่น้อง/คู่สมรสบนเรือไททานิค
• parch – จำนวนผู้ปกครอง/เด็กบนเรือไททานิค
• ตั๋ว – หมายเลขตั๋ว
• ค่าโดยสาร – ค่าโดยสาร
• ห้องโดยสาร – หมายเลขห้องโดยสาร
• embarked – ท่าเรือของ embarkation

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

 import pandas as pd # We need to drop some insignificant features and map the others. # Ticket number and fare should not contribute much to the performance of our models. # Name feature has titles (eg, Mr., Miss, Doctor) included. # Gender is definitely important. # Port of embarkation may contribute some value. # Using port of embarkation may sound counter-intuitive; however, there may # be a higher survival rate for passengers who boarded in the same port. dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+)\.', expand=False) dataset = dataset.drop(['PassengerId', 'Ticket', 'Cabin', 'Name'], axis=1) pd.crosstab(dataset['Title'], dataset['Sex'])

Title \ Sex	หญิง	ชาย
Capt	0	1
Col	0	2
Countess	1	0
สวมใส่	0	1
ดร	1	6
Jonkheer	0	1
ผู้หญิง	1	0
วิชาเอก	0	2
ผู้เชี่ยวชาญ	0	40
นางสาว	182	0
Mlle	2	0
Mme	1	0
นาย	0	517
นาง	125	0
นางสาว	1	0
Rev	0	6
ท่าน	0	1

 # We will replace many titles with a more common name, English equivalent, # or reclassification dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\ 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Other') dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss') dataset['Title'] = dataset['Title'].replace('Ms', 'Miss') dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs') dataset[['Title', 'Survived']].groupby(['Title'], as_index=False).mean()

	ชื่อ	Survived
0	ผู้เชี่ยวชาญ	0.575000
1	นางสาว	0.702703
2	นาย	0.156673
3	นาง	0.793651
4	อื่น	0.347826

 # Now we will map alphanumerical categories to numbers title_mapping = { 'Mr': 1, 'Miss': 2, 'Mrs': 3, 'Master': 4, 'Other': 5 } gender_mapping = { 'female': 1, 'male': 0 } port_mapping = { 'S': 0, 'C': 1, 'Q': 2 } # Map title dataset['Title'] = dataset['Title'].map(title_mapping).astype(int) # Map gender dataset['Sex'] = dataset['Sex'].map(gender_mapping).astype(int) # Map port freq_port = dataset.Embarked.dropna().mode()[0] dataset['Embarked'] = dataset['Embarked'].fillna(freq_port) dataset['Embarked'] = dataset['Embarked'].map(port_mapping).astype(int) # Fix missing age values dataset['Age'] = dataset['Age'].fillna(dataset['Age'].dropna().median()) dataset.head()

	Survived	Pclass	เพศ	อายุ	SibSp	Parch	Fare	Embarked	ชื่อ
0	0	3	0	22.0	1	0	7.2500	0	1
1	1	1	1	38.0	1	0	71.2833	1	3
2	1	3	1	26.0	0	0	7.9250	0	2
3	1	1	1	35.0	1	0	53.1000	0	3
4	0	3	0	35.0	0	0	8.0500	0	1

At this point, we will rank different types of machine learning algorithms in Python by using scikit-learn to create a set of different models. It will then be easy to see which one performs the best.

• Logistic regression with varying numbers of polynomials
• Support vector machine with a linear kernel
• Support vector machine with a polynomial kernel
• Neural network

For every single model, we will use $k$-fold validation.

 from sklearn.model_selection import KFold, train_test_split from sklearn.pipeline import make_pipeline from sklearn.preprocessing import PolynomialFeatures, StandardScaler from sklearn.neural_network import MLPClassifier from sklearn.svm import SVC # Prepare the data X = dataset.drop(['Survived'], axis = 1).values y = dataset[['Survived']].values X = StandardScaler().fit_transform(X) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = None) # Prepare cross-validation (cv) cv = KFold(n_splits = 5, random_state = None) # Performance p_score = lambda model, score: print('Performance of the %s model is %0.2f%%' % (model, score * 100)) # Classifiers names = [ "Logistic Regression", "Logistic Regression with Polynomial Hypotheses", "Linear SVM", "RBF SVM", "Neural Net", ] classifiers = [ LogisticRegression(), make_pipeline(PolynomialFeatures(3), LogisticRegression()), SVC(kernel="linear", C=0.025), SVC(gamma=2, C=1), MLPClassifier(alpha=1), ]

 # iterate over classifiers models = [] trained_classifiers = [] for name, clf in zip(names, classifiers): scores = [] for train_indices, test_indices in cv.split(X): clf.fit(X[train_indices], y[train_indices].ravel()) scores.append( clf.score(X_test, y_test.ravel()) ) min_score = min(scores) max_score = max(scores) avg_score = sum(scores) / len(scores) trained_classifiers.append(clf) models.append((name, min_score, max_score, avg_score)) fin_models = pd.DataFrame(models, columns = ['Name', 'Min Score', 'Max Score', 'Mean Score'])

 fin_models.sort_values(['Mean Score']).head()

	ชื่อ	Min Score	Max Score	Mean Score
2	Linear SVM	0.793296	0.821229	0.803352
0	Logistic Regression	0.826816	0.860335	0.846927
4	Neural Net	0.826816	0.860335	0.849162
1	Logistic Regression with Polynomial Hypotheses	0.854749	0.882682	0.869274
3	RBF SVM	0.843575	0.888268	0.869274

Ok, so our experimental research says that the SVM classifier with a radial basis function (RBF) kernel performs the best. Now, we can serialize our model and re-use it in production applications.

 import pickle svm_model = trained_classifiers[3] data_path = os.path.join(os.getcwd(), "best-titanic-model.pkl") pickle.dump(svm_model, open(data_path, 'wb'))

Machine learning is not complicated, but it's a very broad field of study, and it requires knowledge of math and statistics in order to grasp all of its concepts.

Right now, machine learning and deep learning are among the hottest topics of discussion in Silicon Valley, and are the bread and butter of almost every data science company, mainly because they can automate many repetitive tasks including speech recognition, driving vehicles, financial trading, caring for patients, cooking, marketing, and so on.

Now you can take this knowledge and solve challenges on Kaggle.

This was a very brief introduction to supervised machine learning algorithms. Luckily, there are a lot of online courses and information about machine learning algorithms. I personally would recommend starting with Andrew Ng's course on Coursera.

ทรัพยากร

• Andrew Ng's course on Coursera
• Kaggle datasets
• A deep learning reading list
• A list of free books on machine learning algorithms, data mining, deep learning, and related topics
• บทนำสู่ทฤษฎีแมชชีนเลิร์นนิงและการประยุกต์: การสอนด้วยภาพพร้อมตัวอย่าง