การเรียนรู้ของเครื่องด้วย Python - คู่มือฉบับย่อ

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

Machine Learning คืออะไร?

Machine Learning (ML) เป็นสาขาวิชาวิทยาการคอมพิวเตอร์ที่ระบบคอมพิวเตอร์สามารถให้ความรู้สึกกับข้อมูลในลักษณะเดียวกับที่มนุษย์ทำ

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

ต้องการแมชชีนเลิร์นนิง

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

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

ทำไมต้องเรียนรู้เกี่ยวกับเครื่องจักร?

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

ขาดความเชี่ยวชาญของมนุษย์

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

สถานการณ์แบบไดนามิก

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

ความยากในการแปลความเชี่ยวชาญเป็นงานด้านการคำนวณ

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

รูปแบบการเรียนรู้ของเครื่อง

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

“ โปรแกรมคอมพิวเตอร์กล่าวกันว่าเรียนรู้จากประสบการณ์ E ที่เกี่ยวข้องกับงานบางประเภท T และการวัดประสิทธิภาพ P ถ้าประสิทธิภาพของงานใน T ตามที่วัดโดย P จะดีขึ้นตามประสบการณ์ E”

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

ML เป็นสาขาหนึ่งของ AI ที่ประกอบด้วยอัลกอริทึมการเรียนรู้ที่ -

• ปรับปรุงประสิทธิภาพ (P)

• ในการดำเนินงานบางอย่าง (T)

• เมื่อเวลาผ่านไปด้วยประสบการณ์ (E)

จากข้อมูลข้างต้นแผนภาพต่อไปนี้แสดงถึงโมเดลการเรียนรู้ของเครื่อง -

ให้เราคุยรายละเอียดเพิ่มเติมตอนนี้ -

งาน (T)

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

งาน T ถูกกล่าวว่าเป็นงานที่ใช้ ML เมื่อเป็นไปตามกระบวนการและระบบจะต้องปฏิบัติตามเพื่อดำเนินการกับจุดข้อมูล ตัวอย่างของงานที่ใช้ ML ได้แก่ Classification, Regression, Structured annotation, Clustering, Transcription เป็นต้น

ประสบการณ์ (E)

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

ประสิทธิภาพ (P)

อัลกอริทึม ML ควรจะทำงานและได้รับประสบการณ์ในช่วงเวลาที่ผ่านไป การวัดที่บอกว่าอัลกอริทึม ML ทำงานตามความคาดหวังหรือไม่คือประสิทธิภาพ (P) โดยพื้นฐานแล้ว P เป็นเมตริกเชิงปริมาณที่บอกว่าโมเดลกำลังปฏิบัติงานอย่างไรโดยใช้ประสบการณ์ E มีเมตริกมากมายที่ช่วยให้เข้าใจประสิทธิภาพของ ML เช่นคะแนนความแม่นยำคะแนน F1 เมทริกซ์ความสับสนความแม่นยำการจำ , ความไว ฯลฯ

ความท้าทายในการเรียนรู้ของเครื่องจักร

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

Quality of data- การมีข้อมูลที่มีคุณภาพดีสำหรับอัลกอริทึม ML ถือเป็นความท้าทายที่ยิ่งใหญ่ที่สุดอย่างหนึ่ง การใช้ข้อมูลคุณภาพต่ำนำไปสู่ปัญหาที่เกี่ยวข้องกับการประมวลผลข้อมูลล่วงหน้าและการแยกคุณลักษณะ

Time-Consuming task - ความท้าทายอีกประการหนึ่งที่ต้องเผชิญกับโมเดล ML คือการใช้เวลาโดยเฉพาะอย่างยิ่งสำหรับการเก็บข้อมูลการดึงคุณสมบัติและการดึงข้อมูล

Lack of specialist persons - เนื่องจากเทคโนโลยี ML ยังอยู่ในช่วงเริ่มต้นการมีทรัพยากรจากผู้เชี่ยวชาญจึงเป็นงานที่ยากลำบาก

No clear objective for formulating business problems - การไม่มีวัตถุประสงค์ที่ชัดเจนและเป้าหมายที่ชัดเจนสำหรับปัญหาทางธุรกิจเป็นอีกหนึ่งความท้าทายที่สำคัญสำหรับ ML เนื่องจากเทคโนโลยีนี้ยังไม่เติบโตเต็มที่

Issue of overfitting & underfitting - หากแบบจำลองมีการติดตั้งมากเกินไปหรือไม่เหมาะสมจะไม่สามารถแสดงปัญหาได้ดี

Curse of dimensionality- ใบหน้าของโมเดล ML ที่ท้าทายอีกประการหนึ่งคือคุณสมบัติของจุดข้อมูลที่มากเกินไป นี่อาจเป็นอุปสรรคที่แท้จริง

Difficulty in deployment - ความซับซ้อนของแบบจำลอง ML ทำให้การนำไปใช้ในชีวิตจริงค่อนข้างยาก

การประยุกต์ใช้การเรียนรู้ของเครื่องจักร

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

• การวิเคราะห์อารมณ์

• การวิเคราะห์ความเชื่อมั่น

• การตรวจจับและป้องกันข้อผิดพลาด

• การพยากรณ์อากาศและการทำนาย

• การวิเคราะห์และพยากรณ์ตลาดหุ้น

• การสังเคราะห์เสียง

• การรู้จำเสียง

• การแบ่งกลุ่มลูกค้า

• การรับรู้วัตถุ

• การตรวจจับการฉ้อโกง

• การป้องกันการฉ้อโกง

• การแนะนำสินค้าให้กับลูกค้าในการซื้อของออนไลน์

ความรู้เบื้องต้นเกี่ยวกับ Python

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

• Python ได้รับการพัฒนาโดย Guido van Rossum ที่ Stichting Mathematisch Centrum ในเนเธอร์แลนด์

• มันถูกเขียนขึ้นในฐานะผู้สืบทอดของภาษาโปรแกรมชื่อ 'ABC'

• เป็นเวอร์ชันแรกที่เปิดตัวในปีพ. ศ.

• Guido van Rossum เลือกชื่อ Python จากรายการทีวีชื่อ Monty Python's Flying Circus

• เป็นภาษาโปรแกรมโอเพนซอร์สซึ่งหมายความว่าเราสามารถดาวน์โหลดและใช้เพื่อพัฒนาโปรแกรมได้อย่างอิสระ ก็สามารถดาวน์โหลดได้จากwww.python.org

• ภาษาโปรแกรม Python มีคุณสมบัติของ Java และ C ทั้งคู่ มีรหัส 'C' ที่สวยงามและในทางกลับกันมีคลาสและวัตถุเช่น Java สำหรับการเขียนโปรแกรมเชิงวัตถุ

• เป็นภาษาที่ตีความหมายซึ่งหมายความว่าซอร์สโค้ดของโปรแกรม Python จะถูกแปลงเป็น bytecode ก่อนแล้วจึงเรียกใช้งานโดยเครื่องเสมือน Python

จุดแข็งและจุดอ่อนของ Python

ภาษาโปรแกรมทุกภาษามีจุดแข็งและจุดอ่อนเช่นกัน Python ก็เช่นกัน

จุดแข็ง

จากการศึกษาและการสำรวจพบว่า Python เป็นภาษาที่สำคัญอันดับ 5 และเป็นภาษายอดนิยมสำหรับการเรียนรู้ของเครื่องและวิทยาศาสตร์ข้อมูล เป็นเพราะจุดแข็งต่อไปนี้ที่ Python มี -

Easy to learn and understand- ไวยากรณ์ของ Python นั้นง่ายกว่า ด้วยเหตุนี้จึงค่อนข้างง่ายแม้กระทั่งสำหรับผู้เริ่มต้นเรียนรู้และเข้าใจภาษา

Multi-purpose language - Python เป็นภาษาโปรแกรมเอนกประสงค์เนื่องจากรองรับการเขียนโปรแกรมเชิงโครงสร้างโปรแกรมเชิงวัตถุและการเขียนโปรแกรมเชิงฟังก์ชัน

Huge number of modules- Python มีโมดูลจำนวนมากสำหรับการเขียนโปรแกรมทุกด้าน โมดูลเหล่านี้สามารถใช้งานได้อย่างง่ายดายดังนั้นจึงทำให้ Python เป็นภาษาที่ขยายได้

Support of open source community- เนื่องจากเป็นภาษาโปรแกรมโอเพ่นซอร์ส Python จึงได้รับการสนับสนุนจากชุมชนนักพัฒนาซอฟต์แวร์ขนาดใหญ่มาก ด้วยเหตุนี้ข้อบกพร่องจึงได้รับการแก้ไขอย่างง่ายดายโดยชุมชน Python ลักษณะนี้ทำให้ Python มีความแข็งแกร่งและปรับตัวได้ดี

Scalability - Python เป็นภาษาโปรแกรมที่ปรับขนาดได้เนื่องจากมีโครงสร้างที่ได้รับการปรับปรุงเพื่อรองรับโปรแกรมขนาดใหญ่มากกว่าเชลล์สคริปต์

ความอ่อนแอ

แม้ว่า Python จะเป็นภาษาโปรแกรมยอดนิยมและมีประสิทธิภาพ แต่ก็มีจุดอ่อนของความเร็วในการดำเนินการที่ช้า

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

การติดตั้ง Python

สำหรับการทำงานใน Python เราต้องทำการติดตั้งก่อน คุณสามารถทำการติดตั้ง Python ได้สองวิธีต่อไปนี้ -

• การติดตั้ง Python ทีละรายการ

• ใช้การแจกจ่าย Python ที่บรรจุไว้ล่วงหน้า - Anaconda

ให้เราคุยรายละเอียดเหล่านี้

การติดตั้ง Python ทีละรายการ

หากคุณต้องการติดตั้ง Python บนคอมพิวเตอร์ของคุณคุณจะต้องดาวน์โหลดเฉพาะรหัสไบนารีที่เกี่ยวข้องกับแพลตฟอร์มของคุณ การแจกจ่าย Python พร้อมใช้งานสำหรับแพลตฟอร์ม Windows, Linux และ Mac

ต่อไปนี้เป็นภาพรวมโดยย่อของการติดตั้ง Python บนแพลตฟอร์มดังกล่าวข้างต้น -

On Unix and Linux platform

ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้เราสามารถติดตั้ง Python บนแพลตฟอร์ม Unix และ Linux -

• ก่อนอื่นไปที่ https://www.python.org/downloads/.

• จากนั้นคลิกที่ลิงค์เพื่อดาวน์โหลดซอร์สโค้ดซิปสำหรับ Unix / Linux

• ตอนนี้ดาวน์โหลดและแตกไฟล์

• ต่อไปเราสามารถแก้ไขไฟล์ Modules / Setup ได้หากต้องการปรับแต่งตัวเลือกบางอย่าง

  • จากนั้นเขียนคำสั่ง run ./configure script

  • make

  • ทำการติดตั้ง

On Windows platform

ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้เราสามารถติดตั้ง Python บนแพลตฟอร์ม Windows -

• ก่อนอื่นไปที่ https://www.python.org/downloads/.

• จากนั้นคลิกที่ลิงค์สำหรับไฟล์ตัวติดตั้ง Windows python-XYZ.msi XYZ เป็นเวอร์ชันที่เราต้องการติดตั้ง

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

On Macintosh platform

สำหรับ Mac OS X, Homebrew แนะนำให้ติดตั้งแพ็คเกจที่ยอดเยี่ยมและใช้งานง่ายในการติดตั้ง Python 3 ในกรณีที่คุณไม่มี Homebrew คุณสามารถติดตั้งได้โดยใช้คำสั่งต่อไปนี้ -

$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"

สามารถอัปเดตได้ด้วยคำสั่งด้านล่าง -

$ brew update

ตอนนี้ในการติดตั้ง Python3 บนระบบของคุณเราจำเป็นต้องรันคำสั่งต่อไปนี้ -

$ brew install python3

การใช้การแจกจ่าย Python ที่บรรจุไว้ล่วงหน้า: Anaconda

Anaconda เป็นชุดรวบรวม Python ซึ่งมีไลบรารีทั้งหมดที่ใช้กันอย่างแพร่หลายใน Data science เราสามารถทำตามขั้นตอนต่อไปนี้เพื่อตั้งค่าสภาพแวดล้อม Python โดยใช้ Anaconda -

Step1- ก่อนอื่นเราต้องดาวน์โหลดแพ็คเกจการติดตั้งที่จำเป็นจากการจัดจำหน่ายของ Anaconda ลิงก์สำหรับเดียวกันคือhttps://www.anaconda.com/distribution/. คุณสามารถเลือกจาก Windows, Mac และ Linux OS ตามความต้องการของคุณ

Step2- จากนั้นเลือกเวอร์ชัน Python ที่คุณต้องการติดตั้งบนเครื่องของคุณ Python เวอร์ชันล่าสุดคือ 3.7 คุณจะได้รับตัวเลือกสำหรับตัวติดตั้งกราฟิก 64 บิตและ 32 บิตทั้งคู่

Step3- หลังจากเลือกเวอร์ชัน OS และ Python แล้วระบบจะดาวน์โหลดตัวติดตั้ง Anaconda บนคอมพิวเตอร์ของคุณ ตอนนี้ดับเบิลคลิกที่ไฟล์และโปรแกรมติดตั้งจะติดตั้งแพ็คเกจ Anaconda

Step4 - สำหรับการตรวจสอบว่าติดตั้งหรือไม่ให้เปิด command prompt แล้วพิมพ์ Python ดังนี้ -

นอกจากนี้คุณยังสามารถตรวจสอบวิดีโอการบรรยายโดยละเอียดได้ที่https://www.tutorialspoint.com/python_essentials_online_training/getting_started_with_anaconda.asp.

ทำไมต้อง Python สำหรับ Data Science

Python เป็นภาษาที่สำคัญอันดับ 5 และเป็นภาษายอดนิยมสำหรับการเรียนรู้ของเครื่องและวิทยาศาสตร์ข้อมูล ต่อไปนี้เป็นคุณสมบัติของ Python ที่ทำให้เป็นตัวเลือกภาษาที่ต้องการสำหรับวิทยาศาสตร์ข้อมูล -

ชุดแพ็คเกจมากมาย

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

สร้างต้นแบบได้ง่าย

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

คุณสมบัติการทำงานร่วมกัน

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

ภาษาเดียวสำหรับหลายโดเมน

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

ส่วนประกอบของ Python ML Ecosystem

ในส่วนนี้ให้เราพูดถึงไลบรารี Data Science หลักบางส่วนที่สร้างส่วนประกอบของระบบนิเวศการเรียนรู้ของ Python Machine ส่วนประกอบที่มีประโยชน์เหล่านี้ทำให้ Python เป็นภาษาที่สำคัญสำหรับ Data Science แม้ว่าจะมีส่วนประกอบดังกล่าวมากมายให้เราพูดถึงส่วนประกอบที่สำคัญบางอย่างของระบบนิเวศ Python ที่นี่ -

Jupyter Notebook

โดยพื้นฐานแล้วโน้ตบุ๊ก Jupyter มีสภาพแวดล้อมการคำนวณแบบโต้ตอบสำหรับการพัฒนาแอปพลิเคชัน Data Science ที่ใช้ Python เดิมเรียกว่าโน้ตบุ๊ก ipython ต่อไปนี้เป็นคุณสมบัติบางอย่างของสมุดบันทึก Jupyter ที่ทำให้เป็นหนึ่งในองค์ประกอบที่ดีที่สุดของระบบนิเวศ Python ML -

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

• ช่วยให้นักวิทยาศาสตร์ข้อมูลสามารถจัดทำเอกสารกระบวนการคิดในขณะที่พัฒนากระบวนการวิเคราะห์

• คุณยังสามารถจับผลลัพธ์เป็นส่วนหนึ่งของสมุดบันทึก

• ด้วยความช่วยเหลือของสมุดบันทึก jupyter เราสามารถแบ่งปันงานของเรากับเพื่อนได้เช่นกัน

การติดตั้งและการดำเนินการ

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

C:\>jupyter notebook

หลังจากกด Enter มันจะเริ่มต้นเซิร์ฟเวอร์โน้ตบุ๊กที่ localhost: 8888 ของคอมพิวเตอร์ของคุณ จะปรากฏในภาพหน้าจอต่อไปนี้ -

หลังจากคลิกแท็บใหม่คุณจะได้รับรายการตัวเลือก เลือก Python 3 และจะนำคุณไปยังสมุดบันทึกใหม่เพื่อเริ่มทำงานในนั้น คุณจะเห็นมันในภาพหน้าจอต่อไปนี้ -

ในทางกลับกันหากคุณใช้การแจกจ่าย Python มาตรฐานสามารถติดตั้งสมุดบันทึก jupyter โดยใช้ตัวติดตั้งแพ็คเกจ python ยอดนิยม pip

pip install jupyter

ประเภทของเซลล์ใน Jupyter Notebook

ต่อไปนี้เป็นเซลล์สามประเภทในสมุดบันทึก jupyter -

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

Markdown cells- เราสามารถใช้เซลล์เหล่านี้เพื่อระบุกระบวนการคำนวณ สามารถมีสิ่งต่างๆเช่นข้อความรูปภาพสมการลาเท็กซ์แท็ก HTML เป็นต้น

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

สำหรับการศึกษารายละเอียดเพิ่มเติมเกี่ยวกับสมุดบันทึก jupyter คุณสามารถไปที่ลิงค์https://www.tutorialspoint.com/jupyter/index.htm.

NumPy

เป็นส่วนประกอบที่มีประโยชน์อีกอย่างหนึ่งที่ทำให้ Python เป็นหนึ่งในภาษายอดนิยมสำหรับ Data Science โดยพื้นฐานแล้วมันย่อมาจาก Numerical Python และประกอบด้วยวัตถุอาร์เรย์หลายมิติ ด้วยการใช้ NumPy เราสามารถดำเนินการที่สำคัญดังต่อไปนี้ -

• การดำเนินการทางคณิตศาสตร์และตรรกะบนอาร์เรย์

• การเปลี่ยนแปลงฟูเรียร์

• การดำเนินการที่เกี่ยวข้องกับพีชคณิตเชิงเส้น

นอกจากนี้เรายังสามารถเห็น NumPy แทน MatLab ได้เนื่องจาก NumPy ส่วนใหญ่จะใช้ร่วมกับ Scipy (Scientific Python) และ Mat-plotlib (plotting library)

Installation and Execution

หากคุณใช้การแจกจ่าย Anaconda คุณไม่จำเป็นต้องติดตั้ง NumPy แยกต่างหากเนื่องจากมีการติดตั้งไว้แล้ว คุณต้องนำเข้าแพ็คเกจไปยังสคริปต์ Python ของคุณด้วยความช่วยเหลือดังต่อไปนี้ -

import numpy as np

ในทางกลับกันหากคุณใช้การกระจาย Python มาตรฐานสามารถติดตั้ง NumPy ได้โดยใช้ตัวติดตั้งแพคเกจ python ยอดนิยม pip

pip install NumPy

สำหรับการศึกษารายละเอียดเพิ่มเติมของ NumPy คุณสามารถไปที่ลิงค์https://www.tutorialspoint.com/numpy/index.htm.

หมีแพนด้า

เป็นอีกหนึ่งไลบรารี Python ที่มีประโยชน์ซึ่งทำให้ Python เป็นหนึ่งในภาษายอดนิยมสำหรับ Data Science โดยทั่วไปแล้วหมีแพนด้าใช้สำหรับการจัดการข้อมูลการโต้เถียงและการวิเคราะห์ ได้รับการพัฒนาโดย Wes McKinney ในปี 2008 ด้วยความช่วยเหลือของ Pandas ในการประมวลผลข้อมูลเราสามารถทำตามห้าขั้นตอนต่อไปนี้ให้สำเร็จ -

• Load

• Prepare

• Manipulate

• Model

• Analyze

การแสดงข้อมูลใน Pandas

การนำเสนอข้อมูลทั้งหมดใน Pandas ทำได้ด้วยความช่วยเหลือของโครงสร้างข้อมูลสามประการต่อไปนี้ -

Series- โดยทั่วไปเป็น ndarray หนึ่งมิติที่มีป้ายกำกับแกนซึ่งหมายความว่ามันเหมือนกับอาร์เรย์ธรรมดาที่มีข้อมูลที่เป็นเนื้อเดียวกัน ตัวอย่างเช่นชุดต่อไปนี้คือชุดของจำนวนเต็ม 1,5,10,15,24,25 ...

1

5

10

15

24

25

28

36

40

89

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

ชื่อ	หมายเลขม้วน	อายุ	เพศ
Aarav	1	15	ชาย
รุนแรง	2	14	ชาย
กณิการ์	3	16	หญิง
Mayank	4	15	ชาย

Panel- เป็นโครงสร้างข้อมูล 3 มิติที่มีข้อมูลที่แตกต่างกัน เป็นเรื่องยากมากที่จะแสดงพาเนลในการแสดงกราฟิก แต่สามารถแสดงเป็นคอนเทนเนอร์ของ DataFrame ได้

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

โครงสร้างข้อมูล	มิติ	คำอธิบาย
ชุด	1-D	ขนาดไม่เปลี่ยนรูปข้อมูลที่เป็นเนื้อเดียวกัน 1 มิติ
DataFrames	2 มิติ	ขนาดข้อมูลที่เปลี่ยนแปลงไม่เหมือนกันในรูปแบบตาราง
แผงหน้าปัด	3 มิติ	อาร์เรย์ที่เปลี่ยนขนาดได้คอนเทนเนอร์ของ DataFrame

เราสามารถเข้าใจโครงสร้างข้อมูลเหล่านี้ได้เนื่องจากโครงสร้างข้อมูลมิติที่สูงกว่าเป็นที่เก็บโครงสร้างข้อมูลมิติที่ต่ำกว่า

การติดตั้งและการดำเนินการ

หากคุณใช้การแจกจ่าย Anaconda ไม่จำเป็นต้องติดตั้ง Pandas แยกต่างหากเนื่องจากมีการติดตั้งไว้แล้ว คุณต้องนำเข้าแพ็คเกจไปยังสคริปต์ Python ของคุณด้วยความช่วยเหลือดังต่อไปนี้ -

import pandas as pd

ในทางกลับกันหากคุณใช้การแจกจ่าย Python มาตรฐาน Pandas สามารถติดตั้งได้โดยใช้ตัวติดตั้งแพ็คเกจ python ยอดนิยม pip

pip install Pandas

หลังจากติดตั้ง Pandas แล้วคุณสามารถนำเข้าสู่สคริปต์ Python ได้ตามที่ทำไว้ข้างต้น

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการสร้างซีรีส์จาก ndarray โดยใช้ Pandas -

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: data = np.array(['g','a','u','r','a','v'])

In [4]: s = pd.Series(data)

In [5]: print (s)

0 g
1 a
2 u
3 r
4 a
5 v

dtype: object

หากต้องการศึกษารายละเอียดเพิ่มเติมเกี่ยวกับ Pandas คุณสามารถไปที่ลิงค์ https://www.tutorialspoint.com/python_pandas/index.htm.

วิทย์ - เรียน

ไลบรารี python ที่มีประโยชน์และสำคัญที่สุดอีกแห่งสำหรับ Data Science และ Machine Learning ใน Python คือ Scikit-learn ต่อไปนี้เป็นคุณสมบัติบางอย่างของ Scikit-learn ที่มีประโยชน์มาก -

• มันถูกสร้างขึ้นบน NumPy, SciPy และ Matplotlib

• เป็นโอเพ่นซอร์สและสามารถนำกลับมาใช้ใหม่ได้ภายใต้ใบอนุญาต BSD

• ทุกคนสามารถเข้าถึงได้และสามารถนำกลับมาใช้ในบริบทต่างๆได้

• อัลกอริทึมการเรียนรู้ของเครื่องที่หลากหลายซึ่งครอบคลุมพื้นที่หลัก ๆ ของ ML เช่นการจัดหมวดหมู่การจัดกลุ่มการถดถอยการลดขนาดการเลือกแบบจำลอง ฯลฯ สามารถใช้งานได้

การติดตั้งและการดำเนินการ

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

from sklearn.datasets import load_breast_cancer

ในทางกลับกันหากคุณใช้การแจกจ่าย Python มาตรฐานและมี NumPy และ SciPy คุณสามารถติดตั้ง Scikit-learn ได้โดยใช้โปรแกรมติดตั้ง python ที่เป็นที่นิยม pip

pip install -U scikit-learn

หลังจากติดตั้ง Scikit-learn คุณสามารถใช้กับสคริปต์ Python ได้ตามที่คุณได้ทำไว้ข้างต้น

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

วิธีการประเภทต่างๆ

ต่อไปนี้เป็นวิธี ML ต่างๆตามหมวดหมู่กว้าง ๆ -

ขึ้นอยู่กับการดูแลของมนุษย์

ในกระบวนการเรียนรู้วิธีการบางอย่างที่ขึ้นอยู่กับการดูแลของมนุษย์มีดังนี้ -

Supervised Learning

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

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

ตัวอย่างเช่นเรามี

x: ตัวแปรอินพุตและ

Y: ตัวแปรเอาต์พุต

ตอนนี้ใช้อัลกอริทึมเพื่อเรียนรู้ฟังก์ชั่นการทำแผนที่จากอินพุตไปยังเอาต์พุตดังนี้ -

Y = f (x)

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

เรียกว่าภายใต้การดูแลเนื่องจากกระบวนการเรียนรู้ทั้งหมดสามารถคิดได้เนื่องจากอยู่ภายใต้การดูแลของครูหรือหัวหน้างาน ตัวอย่างของอัลกอริธึมแมชชีนเลิร์นนิงภายใต้การดูแล ได้แก่Decision tree, Random Forest, KNN, Logistic Regression เป็นต้น

ตามภารกิจ ML อัลกอริทึมการเรียนรู้ภายใต้การดูแลสามารถแบ่งออกเป็นสองชั้นเรียนกว้าง ๆ ดังต่อไปนี้ -

• Classification

• Regression

Classification

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

Regression

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

การเรียนรู้ที่ไม่มีการดูแล

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

ตัวอย่างเช่นสามารถเข้าใจได้ดังนี้ -

สมมติว่าเรามี -

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

ตัวอย่างของอัลกอริทึมการเรียนรู้ของเครื่องที่ไม่ได้รับการดูแล ได้แก่ การจัดกลุ่ม K-mean K-nearest neighbors เป็นต้น

จากงาน ML อัลกอริทึมการเรียนรู้ที่ไม่มีผู้ดูแลสามารถแบ่งออกเป็นชั้นเรียนกว้าง ๆ ดังต่อไปนี้ -

• Clustering

• Association

• การลดขนาด

Clustering

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

Association

วิธี ML ที่ไม่ได้รับการดูแลที่มีประโยชน์อีกวิธีหนึ่งคือ Associationซึ่งใช้ในการวิเคราะห์ชุดข้อมูลขนาดใหญ่เพื่อค้นหารูปแบบที่แสดงถึงความสัมพันธ์ที่น่าสนใจระหว่างรายการต่างๆ เรียกอีกอย่างว่าAssociation Rule Mining หรือ Market basket analysis ซึ่งส่วนใหญ่ใช้ในการวิเคราะห์รูปแบบการจับจ่ายของลูกค้า

Dimensionality Reduction

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

Anomaly Detection

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

การเรียนรู้แบบกึ่งดูแล

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

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

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

การเรียนรู้เสริมแรง

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

• Step1 - ก่อนอื่นเราต้องเตรียมตัวแทนพร้อมชุดกลยุทธ์เบื้องต้น

• Step2 - จากนั้นสังเกตสภาพแวดล้อมและสถานะปัจจุบัน

• Step3 - จากนั้นเลือกนโยบายที่เหมาะสมที่สุดเกี่ยวกับสถานะปัจจุบันของสิ่งแวดล้อมและดำเนินการที่สำคัญ

• Step4 - ตอนนี้ตัวแทนสามารถรับรางวัลหรือบทลงโทษที่สอดคล้องกันได้ตามการดำเนินการในขั้นตอนก่อนหน้า

• Step5 - ตอนนี้เราสามารถอัปเดตกลยุทธ์ได้หากจำเป็น

• Step6 - ในที่สุดให้ทำซ้ำขั้นตอนที่ 2-5 จนกว่าเจ้าหน้าที่จะได้เรียนรู้และนำนโยบายที่เหมาะสมมาใช้

งานที่เหมาะสำหรับการเรียนรู้ของเครื่อง

แผนภาพต่อไปนี้แสดงประเภทของงานที่เหมาะสมกับปัญหา ML ต่างๆ -

ขึ้นอยู่กับความสามารถในการเรียนรู้

ในกระบวนการเรียนรู้ต่อไปนี้เป็นวิธีการบางอย่างที่ขึ้นอยู่กับความสามารถในการเรียนรู้ -

Batch Learning

ในหลาย ๆ กรณีเรามีระบบ Machine Learning แบบ end-to-end ซึ่งเราจำเป็นต้องฝึกโมเดลในคราวเดียวโดยใช้ข้อมูลการฝึกอบรมที่มีอยู่ทั้งหมด วิธีการเรียนรู้แบบนี้เรียกว่าอัลกอริทึมBatch or Offline learning. เรียกว่าการเรียนรู้แบบกลุ่มหรือออฟไลน์เนื่องจากเป็นขั้นตอนเพียงครั้งเดียวและแบบจำลองจะได้รับการฝึกอบรมด้วยข้อมูลในชุดเดียว ต่อไปนี้เป็นขั้นตอนหลักของวิธีการเรียนรู้แบบกลุ่ม -

Step1 - อันดับแรกเราต้องรวบรวมข้อมูลการฝึกอบรมทั้งหมดเพื่อเริ่มฝึกโมเดล

Step2 - ตอนนี้เริ่มการฝึกโมเดลโดยให้ข้อมูลการฝึกอบรมทั้งหมดในครั้งเดียว

Step3 - จากนั้นหยุดกระบวนการเรียนรู้ / ฝึกอบรมเมื่อคุณได้ผลลัพธ์ / ประสิทธิภาพที่น่าพอใจ

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

การเรียนรู้ออนไลน์

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

Step1 - ขั้นแรกเราต้องรวบรวมข้อมูลการฝึกอบรมทั้งหมดสำหรับการเริ่มต้นการฝึกอบรมของโมเดล

Step2 - ตอนนี้เริ่มการฝึกโมเดลด้วยการให้ข้อมูลการฝึกแบบชุดเล็ก ๆ ให้กับอัลกอริทึม

Step3 - ต่อไปเราต้องจัดเตรียมข้อมูลการฝึกอบรมขั้นต่ำหลายขั้นตอนให้กับอัลกอริทึม

Step4 - เนื่องจากจะไม่หยุดเหมือนการเรียนรู้แบบแบทช์ดังนั้นหลังจากให้ข้อมูลการฝึกอบรมทั้งหมดเป็นชุดย่อยแล้วให้จัดเตรียมตัวอย่างข้อมูลใหม่ด้วย

Step5 - สุดท้ายนี้จะเรียนรู้ไปเรื่อย ๆ ตามตัวอย่างข้อมูลใหม่

ขึ้นอยู่กับ Generalization Approach

ในกระบวนการเรียนรู้วิธีการต่อไปนี้เป็นวิธีการที่อยู่บนพื้นฐานของวิธีการทั่วไป -

การเรียนรู้ตามอินสแตนซ์

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

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

การเรียนรู้ตามรูปแบบ

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

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

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

การพิจารณาขณะโหลดข้อมูล CSV

รูปแบบข้อมูล CSV เป็นรูปแบบที่พบบ่อยที่สุดสำหรับข้อมูล ML แต่เราจำเป็นต้องดูแลเกี่ยวกับการปฏิบัติตามข้อควรพิจารณาที่สำคัญในขณะที่โหลดสิ่งเดียวกันลงในโครงการ ML ของเรา -

ส่วนหัวของไฟล์

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

ต่อไปนี้เป็นสองกรณีที่เกี่ยวข้องกับส่วนหัวของไฟล์ CSV ซึ่งต้องพิจารณา -

• Case-I: When Data file is having a file header - จะกำหนดชื่อให้กับแต่ละคอลัมน์ของข้อมูลโดยอัตโนมัติหากไฟล์ข้อมูลมีส่วนหัวของไฟล์

• Case-II: When Data file is not having a file header - เราจำเป็นต้องกำหนดชื่อให้กับแต่ละคอลัมน์ของข้อมูลด้วยตนเองหากไฟล์ข้อมูลไม่มีส่วนหัวของไฟล์

ในทั้งสองกรณีเราต้องระบุสภาพอากาศอย่างชัดเจนว่าไฟล์ CSV ของเรามีส่วนหัวหรือไม่

ความคิดเห็น

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

ตัวคั่น

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

คำคม

ในไฟล์ข้อมูล CSV เครื่องหมายอัญประกาศคู่ (“”) คืออักขระเครื่องหมายคำพูดเริ่มต้น สิ่งสำคัญคือต้องพิจารณาบทบาทของคำพูดในขณะที่อัปโหลดไฟล์ CSV ไปยังโปรเจ็กต์ ML เนื่องจากเรายังสามารถใช้เครื่องหมายคำพูดอื่นที่ไม่ใช่เครื่องหมายคำพูดคู่ แต่ในกรณีที่ใช้เครื่องหมายคำพูดที่แตกต่างจากอักขระมาตรฐานเราจะต้องระบุให้ชัดเจน

วิธีการโหลดไฟล์ข้อมูล CSV

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

โหลด CSV ด้วย Python Standard Library

วิธีแรกและใช้มากที่สุดในการโหลดไฟล์ข้อมูล CSV คือการใช้ไลบรารีมาตรฐาน Python ซึ่งมีโมดูลในตัวที่หลากหลาย ได้แก่ โมดูล csv และฟังก์ชัน reader () ต่อไปนี้เป็นตัวอย่างของการโหลดไฟล์ข้อมูล CSV ด้วยความช่วยเหลือ -

ตัวอย่าง

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

ก่อนอื่นเราต้องนำเข้าโมดูล csv ที่จัดเตรียมโดยไลบรารีมาตรฐาน Python ดังนี้ -

import csv

ต่อไปเราต้องนำเข้าโมดูล Numpy สำหรับการแปลงข้อมูลที่โหลดเป็นอาร์เรย์ NumPy

import numpy as np

ตอนนี้ให้เส้นทางแบบเต็มของไฟล์เก็บไว้ในไดเร็กทอรีท้องถิ่นของเราโดยมีไฟล์ข้อมูล CSV -

path = r"c:\iris.csv"

จากนั้นใช้ฟังก์ชัน csv.reader () เพื่ออ่านข้อมูลจากไฟล์ CSV -

with open(path,'r') as f:
   reader = csv.reader(f,delimiter = ',')
   headers = next(reader)
   data = list(reader)
   data = np.array(data).astype(float)

เราสามารถพิมพ์ชื่อส่วนหัวด้วยสคริปต์บรรทัดต่อไปนี้ -

print(headers)

บรรทัดของสคริปต์ต่อไปนี้จะพิมพ์รูปร่างของข้อมูลเช่นจำนวนแถวและคอลัมน์ในไฟล์ -

print(data.shape)

บรรทัดสคริปต์ถัดไปจะให้ไฟล์ข้อมูลสามบรรทัดแรก -

print(data[:3])

Output

['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
(150, 4)
[  [5.1 3.5 1.4 0.2]
   [4.9 3. 1.4 0.2]
   [4.7 3.2 1.3 0.2]]

โหลด CSV ด้วย NumPy

อีกวิธีหนึ่งในการโหลดไฟล์ข้อมูล CSV คือฟังก์ชัน NumPy และ numpy.loadtxt () ต่อไปนี้เป็นตัวอย่างของการโหลดไฟล์ข้อมูล CSV ด้วยความช่วยเหลือ -

ตัวอย่าง

ในตัวอย่างนี้เราใช้ชุดข้อมูล Pima Indians ที่มีข้อมูลของผู้ป่วยเบาหวาน ชุดข้อมูลนี้เป็นชุดข้อมูลตัวเลขที่ไม่มีส่วนหัว นอกจากนี้ยังสามารถดาวน์โหลดลงในไดเร็กทอรีท้องถิ่นของเรา หลังจากโหลดไฟล์ข้อมูลเราสามารถแปลงเป็นอาร์เรย์ NumPy และใช้สำหรับโครงการ ML ต่อไปนี้เป็นสคริปต์ Python สำหรับโหลดไฟล์ข้อมูล CSV -

from numpy import loadtxt
path = r"C:\pima-indians-diabetes.csv"
datapath= open(path, 'r')
data = loadtxt(datapath, delimiter=",")
print(data.shape)
print(data[:3])

เอาต์พุต

(768, 9)
[  [ 6. 148. 72. 35. 0. 33.6 0.627 50. 1.]
   [ 1. 85. 66. 29. 0. 26.6 0.351 31. 0.]
   [ 8. 183. 64. 0. 0. 23.3 0.672 32. 1.]]

โหลด CSV ด้วย Pandas

อีกวิธีหนึ่งในการโหลดไฟล์ข้อมูล CSV คือฟังก์ชัน Pandas และ pandas.read_csv () นี่คือฟังก์ชั่นที่ยืดหยุ่นมากที่ส่งคืนแพนด้าดาต้าเฟรมซึ่งสามารถใช้ในการพล็อตได้ทันที ต่อไปนี้เป็นตัวอย่างของการโหลดไฟล์ข้อมูล CSV ด้วยความช่วยเหลือ -

ตัวอย่าง

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

Script-1

ต่อไปนี้เป็นสคริปต์ Python สำหรับการโหลดไฟล์ข้อมูล CSV โดยใช้ Pandas บนชุดข้อมูล Iris -

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)
print(data[:3])

Output:

(150, 4)
   sepal_length   sepal_width  petal_length   petal_width
0         5.1     3.5          1.4            0.2
1         4.9     3.0          1.4            0.2
2         4.7     3.2          1.3            0.2

Script-2

ต่อไปนี้เป็นสคริปต์ Python สำหรับโหลดไฟล์ข้อมูล CSV พร้อมกับการระบุชื่อส่วนหัวด้วยโดยใช้ Pandas บนชุดข้อมูล Pima Indians Diabetes

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.shape)
print(data[:3])

Output

(768, 9)
   preg  plas  pres   skin  test   mass    pedi    age   class
0   6    148    72      35    0     33.6   0.627    50      1
1   1    85     66      29    0     26.6   0.351    31      0
2   8    183    64      0     0     23.3   0.672    32      1

ความแตกต่างระหว่างวิธีการข้างต้นที่ใช้สามวิธีในการโหลดไฟล์ข้อมูล CSV สามารถเข้าใจได้ง่ายด้วยความช่วยเหลือของตัวอย่างที่ให้มา

บทนำ

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

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

ในบทนี้ด้วยความช่วยเหลือของการทำตามสูตร Python เราจะทำความเข้าใจกับข้อมูล ML พร้อมสถิติ

ดูข้อมูลดิบ

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

ต่อไปนี้เป็นสคริปต์ Python ที่ใช้งานโดยใช้ฟังก์ชัน head () ของ Pandas DataFrame บนชุดข้อมูลโรคเบาหวาน Pima Indians เพื่อดู 50 แถวแรกเพื่อให้เข้าใจได้ดีขึ้น -

ตัวอย่าง

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.head(50))

เอาต์พุต

preg   plas  pres    skin  test  mass   pedi    age      class
0      6      148     72     35   0     33.6    0.627    50    1
1      1       85     66     29   0     26.6    0.351    31    0
2      8      183     64      0   0     23.3    0.672    32    1
3      1       89     66     23  94     28.1    0.167    21    0
4      0      137     40     35  168    43.1    2.288    33    1
5      5      116     74      0   0     25.6    0.201    30    0
6      3       78     50     32   88    31.0    0.248    26    1
7     10      115      0      0   0     35.3    0.134    29    0
8      2      197     70     45  543    30.5    0.158    53    1
9      8      125     96      0   0     0.0     0.232    54    1
10     4      110     92      0   0     37.6    0.191    30    0
11    10      168     74      0   0     38.0    0.537    34    1
12    10      139     80      0   0     27.1    1.441    57    0
13     1      189     60     23  846    30.1    0.398    59    1
14     5      166     72     19  175    25.8    0.587    51    1
15     7      100      0      0   0     30.0    0.484    32    1
16     0      118     84     47  230    45.8    0.551    31    1
17     7      107     74      0   0     29.6    0.254    31    1
18     1      103     30     38  83     43.3    0.183    33    0
19     1      115     70     30  96     34.6    0.529    32    1
20     3      126     88     41  235    39.3    0.704    27    0
21     8       99     84      0   0     35.4    0.388    50    0
22     7      196     90      0   0     39.8    0.451    41    1
23     9      119     80     35   0     29.0    0.263    29    1
24    11      143     94     33  146    36.6    0.254    51    1
25    10      125     70     26  115    31.1    0.205    41    1
26     7      147     76      0   0     39.4    0.257    43    1
27     1       97     66     15  140    23.2    0.487    22    0
28    13      145     82     19  110    22.2    0.245    57    0
29     5      117     92      0   0     34.1    0.337    38    0
30     5      109     75     26   0     36.0    0.546    60    0
31     3      158     76     36  245    31.6    0.851    28    1
32     3       88     58     11   54    24.8    0.267    22    0
33     6       92     92      0   0     19.9    0.188    28    0
34    10      122     78     31   0     27.6    0.512    45    0
35     4      103     60     33  192    24.0    0.966    33    0
36    11      138     76      0   0     33.2    0.420    35    0
37     9      102     76     37   0     32.9    0.665    46    1
38     2       90     68     42   0     38.2    0.503    27    1
39     4      111     72     47  207    37.1    1.390    56    1
40     3      180     64     25   70    34.0    0.271    26    0
41     7      133     84      0   0     40.2    0.696    37    0
42     7      106     92     18   0     22.7    0.235    48    0
43     9      171    110     24  240    45.4    0.721    54    1
44     7      159     64      0   0     27.4    0.294    40    0
45     0      180     66     39   0     42.0    1.893    25    1
46     1      146     56      0   0     29.7    0.564    29    0
47     2       71     70     27   0     28.0    0.586    22    0
48     7      103     66     32   0     39.1    0.344    31    1
49     7      105      0      0   0     0.0     0.305    24    0

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

การตรวจสอบขนาดของข้อมูล

เป็นแนวทางปฏิบัติที่ดีเสมอที่จะทราบว่าเรามีข้อมูลจำนวนเท่าใดสำหรับโครงการ ML ของเราในแง่ของแถวและคอลัมน์ เหตุผลเบื้องหลังคือ -

• สมมติว่าถ้าเรามีแถวและคอลัมน์มากเกินไปก็ต้องใช้เวลานานในการรันอัลกอริทึมและฝึกโมเดล

• สมมติว่าถ้าเรามีแถวและคอลัมน์น้อยเกินไปเราก็จะไม่มีข้อมูลเพียงพอที่จะฝึกโมเดลได้ดี

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

ตัวอย่าง

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)

เอาต์พุต

(150, 4)

เราสามารถสังเกตได้อย่างง่ายดายจากผลลัพธ์ที่ชุดข้อมูลม่านตาที่เรากำลังจะใช้คือมี 150 แถวและ 4 คอลัมน์

การรับประเภทข้อมูลของแต่ละแอตทริบิวต์

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

ตัวอย่าง

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.dtypes)

เอาต์พุต

sepal_length float64
sepal_width float64
petal_length float64
petal_width float64
dtype: object

จากผลลัพธ์ข้างต้นเราสามารถรับประเภทข้อมูลของแต่ละแอตทริบิวต์ได้อย่างง่ายดาย

สรุปข้อมูลทางสถิติ

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

• Count

• Mean

• ส่วนเบี่ยงเบนมาตรฐาน

• มูลค่าขั้นต่ำ

• ค่าสูงสุด

• 25%

• มัธยฐานคือ 50%

• 75%

ตัวอย่าง

from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
print(data.shape)
print(data.describe())

เอาต์พุต

(768, 9)
         preg      plas       pres      skin      test        mass       pedi      age      class
count 768.00      768.00    768.00     768.00    768.00     768.00     768.00    768.00    768.00
mean    3.85      120.89     69.11      20.54     79.80      31.99       0.47     33.24      0.35
std     3.37       31.97     19.36      15.95    115.24       7.88       0.33     11.76      0.48
min     0.00        0.00      0.00       0.00      0.00       0.00       0.08     21.00      0.00
25%     1.00       99.00     62.00       0.00      0.00      27.30       0.24     24.00      0.00
50%     3.00      117.00     72.00      23.00     30.50      32.00       0.37     29.00      0.00
75%     6.00      140.25     80.00      32.00    127.25      36.60       0.63     41.00      1.00
max    17.00      199.00    122.00      99.00    846.00      67.10       2.42     81.00      1.00

จากผลลัพธ์ข้างต้นเราสามารถสังเกตข้อมูลสรุปทางสถิติของชุดข้อมูล Pima Indian Diabetes พร้อมกับรูปร่างของข้อมูล

การตรวจสอบการกระจายคลาส

สถิติการแจกแจงคลาสมีประโยชน์ในปัญหาการจำแนกประเภทที่เราต้องทราบความสมดุลของค่าคลาส สิ่งสำคัญคือต้องทราบการแจกแจงค่าคลาสเพราะถ้าเรามีการแจกแจงคลาสที่ไม่สมดุลกันเช่นคลาสหนึ่งมีการสังเกตมากกว่าคลาสอื่น ๆ มากก็อาจต้องมีการจัดการพิเศษในขั้นตอนการเตรียมข้อมูลของโปรเจ็กต์ ML ของเรา เราสามารถรับการกระจายคลาสใน Python ได้อย่างง่ายดายด้วยความช่วยเหลือของ Pandas DataFrame

ตัวอย่าง

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
count_class = data.groupby('class').size()
print(count_class)

เอาต์พุต

Class
0 500
1 268
dtype: int64

จากผลลัพธ์ข้างต้นจะเห็นได้ชัดเจนว่าจำนวนการสังเกตที่มีคลาส 0 นั้นมีมากกว่าจำนวนการสังเกตการณ์คลาส 1 เกือบสองเท่า

การตรวจสอบความสัมพันธ์ระหว่างแอตทริบิวต์

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

• Coefficient value = 1 - แสดงถึงความเต็ม positive ความสัมพันธ์ระหว่างตัวแปร

• Coefficient value = -1 - แสดงถึงความเต็ม negative ความสัมพันธ์ระหว่างตัวแปร

• Coefficient value = 0 - แสดงถึง no ความสัมพันธ์ระหว่างตัวแปร

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

ตัวอย่าง

from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
correlations = data.corr(method='pearson')
print(correlations)

เอาต์พุต

preg     plas     pres     skin     test      mass     pedi       age      class
preg     1.00     0.13     0.14     -0.08     -0.07   0.02     -0.03       0.54   0.22
plas     0.13     1.00     0.15     0.06       0.33   0.22      0.14       0.26   0.47
pres     0.14     0.15     1.00     0.21       0.09   0.28      0.04       0.24   0.07
skin    -0.08     0.06     0.21     1.00       0.44   0.39      0.18      -0.11   0.07
test    -0.07     0.33     0.09     0.44       1.00   0.20      0.19      -0.04   0.13
mass     0.02     0.22     0.28     0.39       0.20   1.00      0.14       0.04   0.29
pedi    -0.03     0.14     0.04     0.18       0.19   0.14      1.00       0.03   0.17
age      0.54     0.26     0.24     -0.11     -0.04   0.04      0.03       1.00   0.24
class    0.22     0.47     0.07     0.07       0.13   0.29      0.17       0.24   1.00

เมทริกซ์ในเอาต์พุตด้านบนให้ความสัมพันธ์ระหว่างคู่ทั้งหมดของแอตทริบิวต์ในชุดข้อมูล

ตรวจสอบความเบ้ของการกระจายคุณสมบัติ

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

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

• อัลกอริทึม ML ส่วนใหญ่ถือว่าข้อมูลมีการแจกแจงแบบเกาส์เช่นปกติของข้อมูลโค้งกระดิ่ง

ใน Python เราสามารถคำนวณความเบ้ของแต่ละแอตทริบิวต์โดยใช้ฟังก์ชัน skew () บน Pandas DataFrame

ตัวอย่าง

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
print(data.skew())

เอาต์พุต

preg   0.90
plas   0.17
pres  -1.84
skin   0.11
test   2.27
mass  -0.43
pedi   1.92
age    1.13
class  0.64
dtype: float64

จากเอาต์พุตข้างต้นสามารถสังเกตความเบ้บวกหรือลบได้ หากค่าใกล้เคียงกับศูนย์แสดงว่าเบ้น้อยลง

บทนำ

ในบทที่แล้วเราได้กล่าวถึงความสำคัญของข้อมูลสำหรับอัลกอริทึม Machine Learning พร้อมกับสูตรอาหาร Python บางอย่างเพื่อทำความเข้าใจข้อมูลด้วยสถิติ มีอีกวิธีหนึ่งที่เรียกว่าการแสดงภาพเพื่อทำความเข้าใจข้อมูล

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

พล็อต Univariate: ทำความเข้าใจแอตทริบิวต์อย่างอิสระ

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

ฮิสโตแกรม

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

• มันให้เรานับจำนวนการสังเกตในแต่ละถังที่สร้างขึ้นเพื่อการแสดงภาพ

• จากรูปร่างของถังขยะเราสามารถสังเกตการกระจายได้อย่างง่ายดายเช่นสภาพอากาศเป็นแบบเสียนเอียงหรือเลขชี้กำลัง

• ฮิสโตแกรมยังช่วยให้เราเห็นค่าผิดปกติที่เป็นไปได้

ตัวอย่าง

โค้ดที่แสดงด้านล่างเป็นตัวอย่างของสคริปต์ Python ที่สร้างฮิสโตแกรมของแอตทริบิวต์ของชุดข้อมูล Pima Indian Diabetes ในที่นี้เราจะใช้ฟังก์ชัน hist () บน Pandas DataFrame เพื่อสร้างฮิสโตแกรมและmatplotlib สำหรับการวางแผน

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.hist()
pyplot.show()

เอาต์พุต

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

พล็อตความหนาแน่น

อีกเทคนิคหนึ่งที่ง่ายและรวดเร็วในการกระจายแต่ละแอตทริบิวต์คือ Density plot มันก็เหมือนกับฮิสโตแกรม แต่มีเส้นโค้งเรียบลากผ่านด้านบนของแต่ละถัง เราสามารถเรียกสิ่งเหล่านี้ว่าฮิสโทแกรมแบบนามธรรม

ตัวอย่าง

ในตัวอย่างต่อไปนี้สคริปต์ Python จะสร้าง Density Plots สำหรับการกระจายแอตทริบิวต์ของชุดข้อมูล Pima Indian Diabetes

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.show()

เอาต์พุต

จากผลลัพธ์ข้างต้นสามารถเข้าใจความแตกต่างระหว่าง Density plot และ Histograms ได้อย่างง่ายดาย

พล็อต Box and Whisker

พล็อต Box และ Whisker เรียกสั้น ๆ ว่า boxplots เป็นอีกหนึ่งเทคนิคที่มีประโยชน์ในการตรวจสอบการกระจายของการแจกแจงของแต่ละแอตทริบิวต์ ต่อไปนี้เป็นลักษณะเฉพาะของเทคนิคนี้ -

• มีลักษณะไม่แปรผันและสรุปการแจกแจงของแต่ละแอตทริบิวต์

• มันลากเส้นสำหรับค่ากลางเช่นค่ามัธยฐาน

• มันวาดกรอบประมาณ 25% และ 75%

• นอกจากนี้ยังดึงหนวดซึ่งจะทำให้เรามีความคิดเกี่ยวกับการแพร่กระจายของข้อมูล

• จุดที่อยู่ด้านนอกหนวดหมายถึงค่าที่ผิดปกติ ค่าผิดปกติจะมากกว่าขนาดของการแพร่กระจายข้อมูลกลางถึง 1.5 เท่า

ตัวอย่าง

ในตัวอย่างต่อไปนี้สคริปต์ Python จะสร้าง Density Plots สำหรับการกระจายแอตทริบิวต์ของชุดข้อมูล Pima Indian Diabetes

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='box', subplots=True, layout=(3,3), sharex=False,sharey=False)
pyplot.show()

เอาต์พุต

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

พล็อตหลายตัวแปร: ปฏิสัมพันธ์ระหว่างตัวแปรหลายตัวแปร

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

พล็อตเมทริกซ์สหสัมพันธ์

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

ตัวอย่าง

ในตัวอย่างต่อไปนี้สคริปต์ Python จะสร้างและพล็อตเมทริกซ์สหสัมพันธ์สำหรับชุดข้อมูล Pima Indian Diabetes สามารถสร้างได้ด้วยความช่วยเหลือของฟังก์ชัน corr () บน Pandas DataFrame และลงจุดด้วยความช่วยเหลือของ pyplot

from matplotlib import pyplot
from pandas import read_csv
import numpy
Path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(Path, names=names)
correlations = data.corr()
fig = pyplot.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = numpy.arange(0,9,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
pyplot.show()

เอาต์พุต

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

พล็อต Scatter Matrix

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

ตัวอย่าง

ในตัวอย่างต่อไปนี้สคริปต์ Python จะสร้างและลงจุด Scatter matrix สำหรับชุดข้อมูล Pima Indian Diabetes สามารถสร้างได้ด้วยความช่วยเหลือของฟังก์ชัน scatter_matrix () บน Pandas DataFrame และลงจุดด้วยความช่วยเหลือของ pyplot

from matplotlib import pyplot
from pandas import read_csv
from pandas.tools.plotting import scatter_matrix
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
scatter_matrix(data)
pyplot.show()

เอาต์พุต

บทนำ

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

ทำให้การเตรียมข้อมูลเป็นขั้นตอนที่สำคัญที่สุดในกระบวนการ ML การเตรียมข้อมูลอาจถูกกำหนดเป็นขั้นตอนที่ทำให้ชุดข้อมูลของเราเหมาะสมกับกระบวนการ ML มากขึ้น

ทำไมต้องประมวลผลข้อมูลล่วงหน้า

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

เทคนิคการประมวลผลข้อมูลล่วงหน้า

เรามีเทคนิคการประมวลผลข้อมูลล่วงหน้าต่อไปนี้ที่สามารถนำไปใช้กับชุดข้อมูลเพื่อสร้างข้อมูลสำหรับอัลกอริทึม ML -

การปรับขนาด

ชุดข้อมูลของเราส่วนใหญ่อาจประกอบด้วยแอตทริบิวต์ที่มีมาตราส่วนแตกต่างกัน แต่เราไม่สามารถให้ข้อมูลดังกล่าวแก่อัลกอริทึม ML ได้ดังนั้นจึงต้องมีการปรับขนาดใหม่ การปรับขนาดข้อมูลทำให้แน่ใจว่าแอตทริบิวต์อยู่ในระดับเดียวกัน โดยทั่วไปแอตทริบิวต์จะถูกปรับขนาดให้อยู่ในช่วง 0 และ 1 อัลกอริทึม ML เช่นการไล่ระดับสีและ k-Nearest Neighbours ต้องการข้อมูลที่ปรับขนาด เราสามารถปรับขนาดข้อมูลใหม่ด้วยความช่วยเหลือของคลาส MinMaxScaler ของไลบรารี scikit-learn Python

ตัวอย่าง

ในตัวอย่างนี้เราจะปรับขนาดข้อมูลของชุดข้อมูล Pima Indians Diabetes ที่เราใช้ก่อนหน้านี้ ขั้นแรกข้อมูล CSV จะถูกโหลด (ตามที่ทำในบทก่อนหน้า) จากนั้นด้วยความช่วยเหลือของคลาส MinMaxScaler ข้อมูลนั้นจะถูกปรับขนาดใหม่ในช่วง 0 และ 1

สองสามบรรทัดแรกของสคริปต์ต่อไปนี้เหมือนกับที่เราเขียนในบทก่อนหน้าขณะโหลดข้อมูล CSV

from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

ตอนนี้เราสามารถใช้คลาส MinMaxScaler เพื่อลดขนาดข้อมูลในช่วง 0 และ 1

data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)

เรายังสามารถสรุปข้อมูลสำหรับเอาต์พุตตามที่เราเลือก ที่นี่เรากำลังตั้งค่าความแม่นยำเป็น 1 และแสดง 10 แถวแรกในผลลัพธ์

set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])

เอาต์พุต

Scaled data:
[[0.4 0.7 0.6 0.4 0. 0.5 0.2 0.5 1. ]
[0.1 0.4 0.5 0.3 0. 0.4 0.1 0.2 0. ]
[0.5 0.9 0.5 0. 0. 0.3 0.3 0.2 1. ]
[0.1 0.4 0.5 0.2 0.1 0.4 0. 0. 0. ]
[0. 0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
[0.3 0.6 0.6 0. 0. 0.4 0.1 0.2 0. ]
[0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
[0.6 0.6 0. 0. 0. 0.5 0. 0.1 0. ]
[0.1 1. 0.6 0.5 0.6 0.5 0. 0.5 1. ]
[0.5 0.6 0.8 0. 0. 0. 0.1 0.6 1. ]]

จากผลลัพธ์ข้างต้นข้อมูลทั้งหมดจะถูกปรับขนาดให้อยู่ในช่วง 0 และ 1

Normalization

เทคนิคการประมวลผลข้อมูลที่มีประโยชน์อีกอย่างหนึ่งคือ Normalization สิ่งนี้ใช้เพื่อลดขนาดข้อมูลแต่ละแถวให้มีความยาว 1 ซึ่งส่วนใหญ่มีประโยชน์ในชุดข้อมูลกระจัดกระจายที่เรามีศูนย์จำนวนมาก เราสามารถ rescale ข้อมูลด้วยความช่วยเหลือของ Normalizer class ของ scikit-learn Python library

ประเภทของ Normalization

ในแมชชีนเลิร์นนิงมีเทคนิคก่อนการประมวลผลแบบมาตรฐานสองประเภทดังนี้ -

L1 Normalization

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

Example

ในตัวอย่างนี้เราใช้เทคนิค L1 Normalize เพื่อทำให้ข้อมูลปกติของชุดข้อมูล Pima Indians Diabetes ซึ่งเราใช้ก่อนหน้านี้ ขั้นแรกข้อมูล CSV จะถูกโหลดจากนั้นด้วยความช่วยเหลือของคลาส Normalizer ข้อมูลนั้นจะถูกทำให้เป็นมาตรฐาน

สองสามบรรทัดแรกของสคริปต์ต่อไปนี้เหมือนกับที่เราเขียนในบทก่อนหน้าขณะโหลดข้อมูล CSV

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

ตอนนี้เราสามารถใช้ Normalizer class กับ L1 เพื่อทำให้ข้อมูลเป็นปกติได้

Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)

เรายังสามารถสรุปข้อมูลสำหรับเอาต์พุตตามที่เราเลือก ที่นี่เรากำลังตั้งค่าความแม่นยำเป็น 2 และแสดง 3 แถวแรกในผลลัพธ์

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[[0.02 0.43 0.21 0.1 0. 0.1 0. 0.14 0. ]
[0. 0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
[0.03 0.59 0.21 0. 0. 0.07 0. 0.1 0. ]]

L2 Normalization

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

Example

ในตัวอย่างนี้เราใช้เทคนิค L2 Normalization เพื่อทำให้ข้อมูลปกติของชุดข้อมูล Pima Indians Diabetes ซึ่งเราใช้ก่อนหน้านี้ ขั้นแรกข้อมูล CSV จะถูกโหลด (ตามที่ทำในบทก่อนหน้า) จากนั้นด้วยความช่วยเหลือของคลาส Normalizer ข้อมูลจะถูกทำให้เป็นมาตรฐาน

สองสามบรรทัดแรกของสคริปต์ต่อไปนี้เหมือนกับที่เราเขียนในบทก่อนหน้าขณะโหลดข้อมูล CSV

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

ตอนนี้เราสามารถใช้ Normalizer class กับ L1 เพื่อทำให้ข้อมูลเป็นปกติได้

Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)

เรายังสามารถสรุปข้อมูลสำหรับเอาต์พุตตามที่เราเลือก ที่นี่เรากำลังตั้งค่าความแม่นยำเป็น 2 และแสดง 3 แถวแรกในผลลัพธ์

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[[0.03 0.83 0.4 0.2 0. 0.19 0. 0.28 0.01]
[0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0. ]
[0.04 0.92 0.32 0. 0. 0.12 0. 0.16 0.01]]

ไบนาไรเซชั่น

ตามชื่อที่แนะนำนี่คือเทคนิคที่เราสามารถทำให้ข้อมูลของเราเป็นไบนารีได้ เราสามารถใช้เกณฑ์ไบนารีเพื่อสร้างข้อมูลของเราเป็นไบนารี ค่าที่สูงกว่าค่า threshold นั้นจะถูกแปลงเป็น 1 และต่ำกว่า threshold นั้นจะถูกแปลงเป็น 0 ตัวอย่างเช่นถ้าเราเลือก threshold value = 0.5 ค่าชุดข้อมูลที่อยู่ด้านบนจะกลายเป็น 1 และด้านล่างนี้จะกลายเป็น 0 นั่นคือ ทำไมเราถึงเรียกมันได้binarizing ข้อมูลหรือ thresholdingข้อมูล. เทคนิคนี้มีประโยชน์เมื่อเรามีความน่าจะเป็นในชุดข้อมูลของเราและต้องการแปลงเป็นค่าที่คมชัด

เราสามารถแยกข้อมูลออกเป็นสองส่วนด้วยความช่วยเหลือของคลาส Binarizer ของไลบรารี scikit-learn Python

ตัวอย่าง

ในตัวอย่างนี้เราจะปรับขนาดข้อมูลของชุดข้อมูล Pima Indians Diabetes ที่เราใช้ก่อนหน้านี้ ขั้นแรกข้อมูล CSV จะถูกโหลดจากนั้นด้วยความช่วยเหลือของคลาส Binarizer มันจะถูกแปลงเป็นค่าไบนารีคือ 0 และ 1 ขึ้นอยู่กับค่าเกณฑ์ เรารับ 0.5 เป็นค่าเกณฑ์

สองสามบรรทัดแรกของสคริปต์ต่อไปนี้เหมือนกับที่เราเขียนในบทก่อนหน้าขณะโหลดข้อมูล CSV

from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

ตอนนี้เราสามารถใช้คลาส Binarize เพื่อแปลงข้อมูลเป็นค่าไบนารี

binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)

ที่นี่เรากำลังแสดง 5 แถวแรกในผลลัพธ์

print ("\nBinary data:\n", Data_binarized [0:5])

เอาต์พุต

Binary data:
[[1. 1. 1. 1. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 0. 1. 0. 1. 0.]
[1. 1. 1. 0. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 0. 1. 0.]
[0. 1. 1. 1. 1. 1. 1. 1. 1.]]

การกำหนดมาตรฐาน

อีกหนึ่งเทคนิคการประมวลผลข้อมูลที่มีประโยชน์ซึ่งโดยพื้นฐานแล้วจะใช้เพื่อแปลงแอตทริบิวต์ข้อมูลด้วยการแจกแจงแบบเกาส์เซียน มันแตกต่างระหว่างค่าเฉลี่ยและ SD (Standard Deviation) กับการแจกแจงแบบเกาส์เซียนมาตรฐานโดยมีค่าเฉลี่ย 0 และ SD เท่ากับ 1 เทคนิคนี้มีประโยชน์ในอัลกอริทึม ML เช่นการถดถอยเชิงเส้นการถดถอยโลจิสติกที่ถือว่าการแจกแจงแบบเกาส์เซียนในชุดข้อมูลอินพุตและให้ผลลัพธ์ที่ดีกว่า ผลลัพธ์ที่มีการปรับขนาดข้อมูล เราสามารถสร้างมาตรฐานข้อมูล (ค่าเฉลี่ย = 0 และ SD = 1) ด้วยความช่วยเหลือของคลาส StandardScaler ของไลบรารี scikit-learn Python

ตัวอย่าง

ในตัวอย่างนี้เราจะปรับขนาดข้อมูลของชุดข้อมูล Pima Indians Diabetes ที่เราใช้ก่อนหน้านี้ ขั้นแรกข้อมูล CSV จะถูกโหลดจากนั้นด้วยความช่วยเหลือของคลาส StandardScaler จะถูกแปลงเป็น Gaussian Distribution ด้วยค่าเฉลี่ย = 0 และ SD = 1

สองสามบรรทัดแรกของสคริปต์ต่อไปนี้เหมือนกับที่เราเขียนในบทก่อนหน้าขณะโหลดข้อมูล CSV

from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

ตอนนี้เราสามารถใช้คลาส StandardScaler เพื่อปรับขนาดข้อมูลใหม่

data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)

เรายังสามารถสรุปข้อมูลสำหรับเอาต์พุตตามที่เราเลือก ที่นี่เรากำลังตั้งค่าความแม่นยำเป็น 2 และแสดง 5 แถวแรกในผลลัพธ์

set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])

เอาต์พุต

Rescaled data:
[[ 0.64 0.85 0.15 0.91 -0.69 0.2 0.47 1.43 1.37]
[-0.84 -1.12 -0.16 0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
[ 1.23 1.94 -0.26 -1.29 -0.69 -1.1 0.6 -0.11 1.37]
[-0.84 -1. -0.16 0.15 0.12 -0.49 -0.92 -1.04 -0.73]
[-1.14 0.5 -1.5 0.91 0.77 1.41 5.48 -0.02 1.37]]

การติดฉลากข้อมูล

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

Label Encoding คืออะไร?

ฟังก์ชัน sklearn ส่วนใหญ่คาดหวังว่าข้อมูลที่มีป้ายกำกับตัวเลขแทนที่จะเป็นป้ายคำ ดังนั้นเราต้องแปลงป้ายดังกล่าวเป็นป้ายหมายเลข กระบวนการนี้เรียกว่าการเข้ารหัสฉลาก เราสามารถทำการเข้ารหัสฉลากข้อมูลด้วยความช่วยเหลือของฟังก์ชัน LabelEncoder () ของไลบรารี scikit-learn Python

ตัวอย่าง

ในตัวอย่างต่อไปนี้สคริปต์ Python จะทำการเข้ารหัสฉลาก

ขั้นแรกให้นำเข้าไลบรารี Python ที่จำเป็นดังต่อไปนี้ -

import numpy as np
from sklearn import preprocessing

ตอนนี้เราต้องจัดเตรียมป้ายกำกับการป้อนข้อมูลดังนี้ -

input_labels = ['red','black','red','green','black','yellow','white']

บรรทัดถัดไปของโค้ดจะสร้างตัวเข้ารหัสฉลากและฝึกมัน

encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

บรรทัดถัดไปของสคริปต์จะตรวจสอบประสิทธิภาพโดยการเข้ารหัสรายการลำดับแบบสุ่ม -

test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)

เราสามารถรับรายการค่าที่เข้ารหัสด้วยความช่วยเหลือของสคริปต์ python ต่อไปนี้ -

print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))

เอาต์พุต

Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']

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

ความสำคัญของการเลือกคุณสมบัติข้อมูล

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

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

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

• การดำเนินการเลือกคุณสมบัติก่อนการสร้างแบบจำลองข้อมูลจะลดการติดตั้งมากเกินไป

• การดำเนินการเลือกคุณสมบัติก่อนการสร้างแบบจำลองข้อมูลจะเพิ่มความแม่นยำของแบบจำลอง ML

• การดำเนินการเลือกคุณสมบัติก่อนการสร้างแบบจำลองข้อมูลจะช่วยลดเวลาในการฝึกอบรม

เทคนิคการเลือกคุณสมบัติ

ต่อไปนี้เป็นเทคนิคการเลือกคุณสมบัติอัตโนมัติที่เราสามารถใช้เพื่อจำลองข้อมูล ML ใน Python -

Univariate Selection

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

Example

ในตัวอย่างนี้เราจะใช้ชุดข้อมูล Pima Indians Diabetes เพื่อเลือก 4 คุณลักษณะที่มีคุณสมบัติที่ดีที่สุดด้วยความช่วยเหลือของการทดสอบทางสถิติแบบไคสแควร์

from pandas import read_csv
from numpy import set_printoptions
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

ต่อไปเราจะแยกอาร์เรย์ออกเป็นส่วนประกอบอินพุตและเอาต์พุต -

X = array[:,0:8]
Y = array[:,8]

โค้ดบรรทัดต่อไปนี้จะเลือกคุณลักษณะที่ดีที่สุดจากชุดข้อมูล -

test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X,Y)

เรายังสามารถสรุปข้อมูลสำหรับเอาต์พุตตามที่เราเลือก เรากำลังตั้งค่าความแม่นยำเป็น 2 และแสดงแอตทริบิวต์ข้อมูล 4 รายการพร้อมคุณสมบัติที่ดีที่สุดพร้อมกับคะแนนที่ดีที่สุดของแต่ละแอตทริบิวต์ -

set_printoptions(precision=2)
print(fit.scores_)
featured_data = fit.transform(X)
print ("\nFeatured data:\n", featured_data[0:4])

Output

[ 111.52 1411.89 17.61 53.11 2175.57 127.67 5.39 181.3 ]
Featured data:
[[148. 0. 33.6 50. ]
[ 85. 0. 26.6 31. ]
[183. 0. 23.3 32. ]
[ 89. 94. 28.1 21. ]]

การกำจัดคุณลักษณะแบบวนซ้ำ

ตามชื่อที่แนะนำเทคนิคการเลือกคุณลักษณะ RFE (การกำจัดคุณลักษณะซ้ำ) จะลบแอตทริบิวต์แบบวนซ้ำและสร้างแบบจำลองที่มีคุณลักษณะที่เหลืออยู่ เราสามารถใช้เทคนิคการเลือกคุณสมบัติ RFE ด้วยความช่วยเหลือของคลาส RFE ของไลบรารี scikit-learn Python

ตัวอย่าง

ในตัวอย่างนี้เราจะใช้ RFE กับอัลกอริทึมการถดถอยโลจิสติกเพื่อเลือก 3 คุณลักษณะที่ดีที่สุดที่มีคุณสมบัติที่ดีที่สุดจากชุดข้อมูลโรคเบาหวานของ Pima Indians ถึง

from pandas import read_csv
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

ต่อไปเราจะแยกอาร์เรย์ออกเป็นส่วนประกอบอินพุตและเอาต์พุต -

X = array[:,0:8]
Y = array[:,8]

โค้ดบรรทัดต่อไปนี้จะเลือกคุณลักษณะที่ดีที่สุดจากชุดข้อมูล -

model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Number of Features: %d")
print("Selected Features: %s")
print("Feature Ranking: %s")

เอาต์พุต

Number of Features: 3
Selected Features: [ True False False False False True True False]
Feature Ranking: [1 2 3 5 6 1 1 4]

เราสามารถเห็นในเอาต์พุตด้านบน RFE เลือก preg, mass และ pedi เป็นคุณสมบัติที่ดีที่สุด 3 อันดับแรก มีการทำเครื่องหมายเป็น 1 ในเอาต์พุต

การวิเคราะห์องค์ประกอบหลัก (PCA)

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

ตัวอย่าง

ในตัวอย่างนี้เราจะใช้ PCA เพื่อเลือกส่วนประกอบหลัก 3 อย่างที่ดีที่สุดจากชุดข้อมูล Pima Indians Diabetes

from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

ต่อไปเราจะแยกอาร์เรย์ออกเป็นส่วนประกอบอินพุตและเอาต์พุต -

X = array[:,0:8]
Y = array[:,8]

บรรทัดของโค้ดต่อไปนี้จะดึงคุณสมบัติจากชุดข้อมูล -

pca = PCA(n_components=3)
fit = pca.fit(X)
print("Explained Variance: %s") % fit.explained_variance_ratio_
print(fit.components_)

เอาต์พุต

Explained Variance: [ 0.88854663 0.06159078 0.02579012]
[[ -2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-02
9.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[ 2.26488861e-02 9.72210040e-01 1.41909330e-01 -5.78614699e-02
-9.46266913e-02 4.69729766e-02 8.16804621e-04 1.40168181e-01]
[ -2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-01
2.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]]

เราสามารถสังเกตได้จากผลลัพธ์ข้างต้นว่าส่วนประกอบหลัก 3 ส่วนมีความคล้ายคลึงกับแหล่งข้อมูลเล็กน้อย

ความสำคัญของคุณลักษณะ

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

ตัวอย่าง

ในตัวอย่างนี้เราจะใช้ ExtraTreeClassifier เพื่อเลือกคุณสมบัติจากชุดข้อมูล Pima Indians Diabetes

from pandas import read_csv
from sklearn.ensemble import ExtraTreesClassifier
path = r'C:\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(data, names=names)
array = dataframe.values

ต่อไปเราจะแยกอาร์เรย์ออกเป็นส่วนประกอบอินพุตและเอาต์พุต -

X = array[:,0:8]
Y = array[:,8]

บรรทัดของโค้ดต่อไปนี้จะดึงคุณสมบัติจากชุดข้อมูล -

model = ExtraTreesClassifier()
model.fit(X, Y)
print(model.feature_importances_)

เอาต์พุต

[ 0.11070069 0.2213717 0.08824115 0.08068703 0.07281761 0.14548537 0.12654214 0.15415431]

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

ความรู้เบื้องต้นเกี่ยวกับการจำแนกประเภท

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

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

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

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

ประเภทของผู้เรียนในการจำแนกประเภท

เรามีผู้เรียนสองประเภทตามปัญหาการจำแนกประเภท -

ผู้เรียนขี้เกียจ

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

ผู้เรียนที่กระตือรือร้น

ตรงกันข้ามกับผู้เรียนที่ขี้เกียจผู้เรียนกระตือรือร้นสร้างแบบจำลองการจำแนกโดยไม่ต้องรอให้ข้อมูลการทดสอบปรากฏขึ้นหลังจากจัดเก็บข้อมูลการฝึกอบรม พวกเขาใช้เวลาในการฝึกฝนมากขึ้น แต่ใช้เวลาในการทำนายน้อยลง ตัวอย่างของผู้เรียนที่กระตือรือร้น ได้แก่ ต้นไม้แห่งการตัดสินใจ, Naïve Bayes และ Artificial Neural Networks (ANN)

การสร้างลักษณนามใน Python

Scikit-learn ซึ่งเป็นไลบรารี Python สำหรับการเรียนรู้ของเครื่องสามารถใช้เพื่อสร้างลักษณนามใน Python ขั้นตอนในการสร้างลักษณนามใน Python มีดังต่อไปนี้ -

ขั้นตอนที่ 1: นำเข้าแพ็คเกจ python ที่จำเป็น

สำหรับการสร้างลักษณนามโดยใช้ scikit-learn เราจำเป็นต้องนำเข้า เราสามารถนำเข้าได้โดยใช้สคริปต์ต่อไปนี้ -

import sklearn

ขั้นตอนที่ 2: การนำเข้าชุดข้อมูล

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

from sklearn.datasets import load_breast_cancer

สคริปต์ต่อไปนี้จะโหลดชุดข้อมูล

data = load_breast_cancer()

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

label_names = data['target_names']
   labels = data['target']
   feature_names = data['feature_names']
   features = data['data']

คำสั่งต่อไปนี้จะพิมพ์ชื่อป้ายกำกับ 'malignant' และ 'benign' ในกรณีที่เป็นฐานข้อมูลของเรา

print(label_names)

ผลลัพธ์ของคำสั่งด้านบนคือชื่อของเลเบล -

['malignant' 'benign']

ป้ายกำกับเหล่านี้แมปกับค่าไบนารี 0 และ 1 Malignant มะเร็งแสดงด้วย 0 และ Benign มะเร็งแสดงด้วย 1.

ชื่อคุณลักษณะและค่าคุณลักษณะของป้ายกำกับเหล่านี้สามารถมองเห็นได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -

print(feature_names[0])

ผลลัพธ์ของคำสั่งด้านบนคือชื่อของคุณลักษณะสำหรับ label 0 เช่น Malignant มะเร็ง -

mean radius

ในทำนองเดียวกันชื่อของคุณสมบัติสำหรับฉลากสามารถสร้างได้ดังนี้ -

print(feature_names[1])

ผลลัพธ์ของคำสั่งด้านบนคือชื่อของคุณลักษณะสำหรับ label 1 ie Benign มะเร็ง -

mean texture

เราสามารถพิมพ์คุณสมบัติสำหรับฉลากเหล่านี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -

print(features[0])

สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้ -

[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
4.601e-01 1.189e-01]

เราสามารถพิมพ์คุณสมบัติสำหรับฉลากเหล่านี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -

print(features[1])

สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้ -

[2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
2.750e-01 8.902e-02]

ขั้นตอนที่ 3: การจัดระเบียบข้อมูลลงในชุดการฝึกอบรมและการทดสอบ

เนื่องจากเราจำเป็นต้องทดสอบโมเดลของเรากับข้อมูลที่มองไม่เห็นเราจะแบ่งชุดข้อมูลของเราออกเป็นสองส่วนคือชุดฝึกและชุดทดสอบ เราสามารถใช้ train_test_split () ฟังก์ชั่นของ sklearn python package เพื่อแบ่งข้อมูลออกเป็นชุด ๆ คำสั่งต่อไปนี้จะนำเข้าฟังก์ชัน -

from sklearn.model_selection import train_test_split

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

train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)

ขั้นที่ 4 - การประเมินแบบจำลอง

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

from sklearn.naive_bayes import GaussianNB

ตอนนี้เริ่มต้นโมเดลดังนี้ -

gnb = GaussianNB()

ถัดไปด้วยความช่วยเหลือของคำสั่งต่อไปนี้เราสามารถฝึกโมเดลได้ -

model = gnb.fit(train, train_labels)

ตอนนี้เพื่อวัตถุประสงค์ในการประเมินเราจำเป็นต้องทำการคาดการณ์ สามารถทำได้โดยใช้ฟังก์ชันทำนาย () ดังนี้ -

preds = gnb.predict(test)
print(preds)

สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้ -

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0
1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0
1 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0
1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0
1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0
0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1
0 0 1 1 0 1]

อนุกรมของ 0s และ 1s ข้างต้นในเอาต์พุตเป็นค่าที่คาดการณ์ไว้สำหรับ Malignant และ Benign ชั้นเรียนเนื้องอก

Step5- ค้นหาความถูกต้อง

เราสามารถค้นหาความถูกต้องของการสร้างแบบจำลองในขั้นตอนก่อนหน้าโดยการเปรียบเทียบอาร์เรย์ทั้งสองคือ test_labels และ preds เราจะใช้ฟังก์ชัน precision_score () เพื่อกำหนดความถูกต้อง

from sklearn.metrics import accuracy_score
   print(accuracy_score(test_labels,preds))
   0.951754385965

ผลลัพธ์ข้างต้นแสดงให้เห็นว่าลักษณนามNaïveBayesมีความแม่นยำ 95.17%

เมตริกการประเมินการจำแนกประเภท

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

ต่อไปนี้เป็นเมตริกการประเมินการจำแนกประเภทที่สำคัญซึ่งคุณสามารถเลือกได้ตามชุดข้อมูลและประเภทของปัญหาของคุณ -

เมทริกซ์ความสับสน

เป็นวิธีที่ง่ายที่สุดในการวัดประสิทธิภาพของปัญหาการจำแนกประเภทโดยที่ผลลัพธ์อาจเป็นประเภทของคลาสสองประเภทขึ้นไป เมทริกซ์ความสับสนไม่ใช่อะไรนอกจากตารางที่มีสองมิติ ได้แก่ “ ตามจริง” และ“ คาดการณ์” และนอกจากนี้มิติข้อมูลทั้งสองยังมี“ True Positives (TP)”,“ True Negatives (TN)”,“ False Positives (FP)”,“ False Negatives (FN)” ตามที่แสดงด้านล่าง

• True Positives (TP) - เป็นกรณีที่ทั้งคลาสจริงและคลาสของจุดข้อมูลที่คาดการณ์ไว้คือ 1

• True Negatives (TN) - เป็นกรณีที่ทั้งคลาสจริงและคลาสที่คาดการณ์ไว้ของจุดข้อมูลเป็น 0

• False Positives (FP) - เป็นกรณีที่คลาสจริงของจุดข้อมูลคือ 0 และคลาสของจุดข้อมูลที่คาดการณ์ไว้คือ 1

• False Negatives (FN) - เป็นกรณีที่คลาสจริงของจุดข้อมูลคือ 1 และคลาสของจุดข้อมูลที่คาดการณ์ไว้คือ 0

เราสามารถค้นหาเมทริกซ์ความสับสนได้ด้วยความช่วยเหลือของฟังก์ชันความสับสน _matrix () ของ sklearn ด้วยความช่วยเหลือของสคริปต์ต่อไปนี้เราสามารถค้นหาเมทริกซ์ความสับสนของตัวจำแนกไบนารีที่สร้างไว้ด้านบน -

from sklearn.metrics import confusion_matrix

เอาต์พุต

[[ 73 7]
[ 4 144]]

ความถูกต้อง

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

$$=\frac{+}{+++}$$

สำหรับลักษณนามไบนารีที่สร้างไว้ข้างต้น TP + TN = 73 + 144 = 217 และ TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228

ดังนั้นความแม่นยำ = 217/228 = 0.951754385965 ซึ่งเหมือนกับที่เราคำนวณไว้หลังจากสร้างตัวจำแนกไบนารีของเรา

ความแม่นยำ

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

$$=\frac{}{+FP}$$

สำหรับลักษณนามไบนารีที่สร้างขึ้นข้างต้น TP = 73 และ TP + FP = 73 + 7 = 80

ดังนั้นความแม่นยำ = 73/80 = 0.915

การเรียกคืนหรือความอ่อนไหว

การเรียกคืนอาจกำหนดเป็นจำนวนผลบวกที่ส่งคืนโดยแบบจำลอง ML ของเรา เราสามารถคำนวณได้อย่างง่ายดายโดยเมทริกซ์ความสับสนด้วยความช่วยเหลือของสูตรต่อไปนี้ -

$$=\frac{}{+FN}$$

สำหรับลักษณนามไบนารีที่สร้างไว้ข้างต้น TP = 73 และ TP + FN = 73 + 4 = 77

ดังนั้นความแม่นยำ = 73/77 = 0.94805

ความจำเพาะ

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

$$=\frac{N}{N+FP}$$

สำหรับลักษณนามไบนารีที่สร้างขึ้นข้างต้น TN = 144 และ TN + FP = 144 + 7 = 151

ดังนั้นความแม่นยำ = 144/151 = 0.95364

อัลกอริธึมการจำแนก ML ต่างๆ

ต่อไปนี้เป็นขั้นตอนวิธีการจำแนก ML ที่สำคัญ -

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

• รองรับ Vector Machine (SVM)

• ต้นไม้ตัดสินใจ

• Naïve Bayes

• ป่าสุ่ม

เราจะพูดถึงอัลกอริทึมการจำแนกเหล่านี้ทั้งหมดโดยละเอียดในบทต่อไป

การใช้งาน

การประยุกต์ใช้อัลกอริทึมการจำแนกประเภทที่สำคัญที่สุดบางส่วนมีดังนี้ -

• การรู้จำเสียง

• การจดจำลายมือ

• การระบุไบโอเมตริกซ์

• การจำแนกประเภทเอกสาร

ความรู้เบื้องต้นเกี่ยวกับ Logistic Regression

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

กล่าวง่ายๆคือตัวแปรตามเป็นไบนารีโดยมีรหัสข้อมูลเป็น 1 (ย่อมาจากความสำเร็จ / ใช่) หรือ 0 (ย่อมาจากความล้มเหลว / ไม่ใช่)

ในทางคณิตศาสตร์แบบจำลองการถดถอยโลจิสติกส์ทำนายว่า P (Y = 1) เป็นฟังก์ชันของ X เป็นหนึ่งในอัลกอริทึม ML ที่ง่ายที่สุดที่สามารถใช้สำหรับปัญหาการจำแนกประเภทต่างๆเช่นการตรวจจับสแปมการทำนายโรคเบาหวานการตรวจหามะเร็งเป็นต้น

ประเภทของ Logistic Regression

โดยทั่วไปการถดถอยโลจิสติกหมายถึงการถดถอยโลจิสติกแบบไบนารีที่มีตัวแปรเป้าหมายแบบไบนารี แต่ตัวแปรเป้าหมายยังมีอีกสองประเภทที่สามารถทำนายได้ ตามจำนวนประเภทเหล่านั้นการถดถอยโลจิสติกสามารถแบ่งออกเป็นประเภทต่อไปนี้ -

ไบนารีหรือทวินาม

ในการจำแนกประเภทดังกล่าวตัวแปรตามจะมีเพียง 2 ประเภทที่เป็นไปได้คือ 1 และ 0 ตัวอย่างเช่นตัวแปรเหล่านี้อาจแสดงถึงความสำเร็จหรือความล้มเหลวใช่หรือไม่ใช่ชนะหรือแพ้เป็นต้น

พหุนาม

ในการจำแนกประเภทดังกล่าวตัวแปรตามสามารถมีได้ 3 ประเภทหรือมากกว่าที่ไม่ได้เรียงลำดับหรือประเภทที่ไม่มีนัยสำคัญเชิงปริมาณ ตัวอย่างเช่นตัวแปรเหล่านี้อาจแสดงถึง“ ประเภท A” หรือ“ ประเภท B” หรือ“ ประเภท C”

ลำดับ

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

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

ก่อนที่จะดำดิ่งสู่การใช้การถดถอยโลจิสติกส์เราต้องตระหนักถึงสมมติฐานต่อไปนี้เกี่ยวกับสิ่งเดียวกัน -

• ในกรณีของการถดถอยโลจิสติกแบบไบนารีตัวแปรเป้าหมายจะต้องเป็นไบนารีเสมอและผลลัพธ์ที่ต้องการจะแสดงด้วยปัจจัยระดับ 1

• แบบจำลองไม่ควรมีหลาย collinearity ซึ่งหมายความว่าตัวแปรอิสระจะต้องเป็นอิสระจากกัน

• เราต้องรวมตัวแปรที่มีความหมายไว้ในแบบจำลองของเรา

• เราควรเลือกขนาดตัวอย่างที่ใหญ่สำหรับการถดถอยโลจิสติกส์

แบบจำลองการถดถอยโลจิสติกแบบไบนารี

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

$h_{\theta}{(x)}=g(\theta^{T}x)ℎ 0≤h_{\theta}≤1$

นี่คือฟังก์ชันโลจิสติกส์หรือซิกมอยด์ซึ่งสามารถระบุได้ดังนี้ -

$g(z)= \frac{1}{1+e^{-z}}ℎ =\theta ^{T}$

เส้นโค้งซิกมอยด์สามารถแสดงด้วยความช่วยเหลือของกราฟต่อไปนี้ เราสามารถเห็นค่าของแกน y อยู่ระหว่าง 0 ถึง 1 และข้ามแกนที่ 0.5

ชั้นเรียนสามารถแบ่งออกเป็นบวกหรือลบ ผลลัพธ์จะอยู่ภายใต้ความน่าจะเป็นของคลาสบวกหากอยู่ระหว่าง 0 ถึง 1 สำหรับการนำไปใช้งานของเราเรากำลังตีความผลลัพธ์ของฟังก์ชันสมมติฐานเป็นค่าบวกหากเป็น≥0.5หรือเป็นลบ

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

ℎ = ()

$J(\theta) = \frac{1}{m}.(-y^{T}log(h) - (1 -y)^Tlog(1-h))$

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

สมการการไล่ระดับสีต่อไปนี้บอกเราว่าการสูญเสียจะเปลี่ยนไปอย่างไรหากเราแก้ไขพารามิเตอร์ -

$\frac{()}{\theta_{j}}=\frac{1}{m}X^{T}(()−)$

การใช้งานใน Python

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

ขั้นแรกเราต้องนำเข้าไลบรารีที่จำเป็นดังนี้ -

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets

จากนั้นโหลดชุดข้อมูลม่านตาดังต่อไปนี้ -

iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1

เราสามารถลงจุดข้อมูลการฝึกของเราได้ดังนี้ -

plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();

ต่อไปเราจะกำหนดฟังก์ชัน sigmoid ฟังก์ชันการสูญเสียและการไล่ระดับสีลงดังนี้ -

class LogisticRegression:
   def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
      self.lr = lr
      self.num_iter = num_iter
      self.fit_intercept = fit_intercept
      self.verbose = verbose
   def __add_intercept(self, X):
      intercept = np.ones((X.shape[0], 1))
      return np.concatenate((intercept, X), axis=1)
   def __sigmoid(self, z):
      return 1 / (1 + np.exp(-z))
   def __loss(self, h, y):
      return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
   def fit(self, X, y):
      if self.fit_intercept:
         X = self.__add_intercept(X)

ตอนนี้เริ่มต้นน้ำหนักดังต่อไปนี้ -

self.theta = np.zeros(X.shape[1])
   for i in range(self.num_iter):
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      gradient = np.dot(X.T, (h - y)) / y.size
      self.theta -= self.lr * gradient
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      loss = self.__loss(h, y)
      if(self.verbose ==True and i % 10000 == 0):
         print(f'loss: {loss} \t')

ด้วยความช่วยเหลือของสคริปต์ต่อไปนี้เราสามารถทำนายความน่าจะเป็นของผลลัพธ์ -

def predict_prob(self, X):
   if self.fit_intercept:
      X = self.__add_intercept(X)
   return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
   return self.predict_prob(X).round()

ต่อไปเราสามารถประเมินโมเดลและพล็อตได้ดังนี้ -

model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()

plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');

Multinomial Logistic Regression Model

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

การใช้งานใน Python

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

ขั้นแรกเราต้องนำเข้าไลบรารีที่จำเป็นดังนี้ -

Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split

ต่อไปเราต้องโหลดชุดข้อมูลหลัก -

digits = datasets.load_digits()

ตอนนี้กำหนดคุณสมบัติเมทริกซ์ (X) และเวกเตอร์การตอบสนอง (y) ดังนี้ -

X = digits.data
y = digits.target

ด้วยความช่วยเหลือของโค้ดบรรทัดถัดไปเราสามารถแยก X และ y ออกเป็นชุดการฝึกอบรมและการทดสอบ -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)

ตอนนี้สร้างวัตถุของการถดถอยโลจิสติกดังนี้ -

digreg = linear_model.LogisticRegression()

ตอนนี้ต้องฝึกโมเดลโดยใช้ชุดฝึกดังนี้ -

digreg.fit(X_train, y_train)

จากนั้นทำการคาดคะเนชุดการทดสอบดังนี้ -

y_pred = digreg.predict(X_test)

ถัดไปพิมพ์ความถูกต้องของแบบจำลองดังต่อไปนี้ -

print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)

เอาต์พุต

Accuracy of Logistic Regression model is: 95.6884561891516

จากผลลัพธ์ข้างต้นเราจะเห็นความแม่นยำของแบบจำลองของเราอยู่ที่ประมาณ 96 เปอร์เซ็นต์

ข้อมูลเบื้องต้นเกี่ยวกับ SVM

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

การทำงานของ SVM

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

ต่อไปนี้เป็นแนวคิดที่สำคัญใน SVM -

• Support Vectors- ดาต้าพอยต์ที่อยู่ใกล้กับไฮเปอร์เพลนมากที่สุดเรียกว่าเวกเตอร์สนับสนุน เส้นคั่นจะถูกกำหนดด้วยความช่วยเหลือของจุดข้อมูลเหล่านี้

• Hyperplane - ดังที่เราเห็นในแผนภาพด้านบนมันคือระนาบการตัดสินใจหรือช่องว่างซึ่งแบ่งระหว่างชุดของวัตถุที่มีคลาสต่างกัน

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

เป้าหมายหลักของ SVM คือการแบ่งชุดข้อมูลออกเป็นคลาสเพื่อค้นหาไฮเปอร์เพลนระยะขอบสูงสุด (MMH) และสามารถทำได้ในสองขั้นตอนต่อไปนี้ -

• ขั้นแรก SVM จะสร้างไฮเปอร์เพลนซ้ำ ๆ เพื่อแยกคลาสออกจากกันด้วยวิธีที่ดีที่สุด

• จากนั้นมันจะเลือกไฮเปอร์เพลนที่แยกชั้นเรียนอย่างถูกต้อง

การนำ SVM ไปใช้ใน Python

สำหรับการนำ SVM ไปใช้ใน Python เราจะเริ่มต้นด้วยการนำเข้าไลบรารีมาตรฐานดังนี้ -

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import seaborn as sns; sns.set()

ต่อไปเรากำลังสร้างชุดข้อมูลตัวอย่างโดยมีข้อมูลที่แยกออกได้เชิงเส้นจาก sklearn.dataset.sample_generator สำหรับการจำแนกโดยใช้ SVM -

from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=100, centers=2,
      random_state=0, cluster_std=0.50)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

ต่อไปนี้จะเป็นผลลัพธ์หลังจากสร้างชุดข้อมูลตัวอย่างที่มี 100 ตัวอย่างและ 2 คลัสเตอร์ -

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

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
plt.plot([0.6], [2.1], 'x', color='black', markeredgewidth=4, markersize=12)
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]:
   plt.plot(xfit, m * xfit + b, '-k')
plt.xlim(-1, 3.5);

ผลลัพธ์มีดังนี้ -

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

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

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
   for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
   yfit = m * xfit + b
   plt.plot(xfit, yfit, '-k')
   plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
         color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);

จากภาพด้านบนในเอาต์พุตเราสามารถสังเกต "ระยะขอบ" ภายในตัวจำแนกแบบแยกแยะได้อย่างง่ายดาย SVM จะเลือกบรรทัดที่เพิ่มระยะขอบสูงสุด

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

from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

ผลลัพธ์มีดังนี้ -

SVC(C=10000000000.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
kernel='linear', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)

ตอนนี้เพื่อความเข้าใจที่ดีขึ้นต่อไปนี้จะพล็อตฟังก์ชันการตัดสินใจสำหรับ 2D SVC -

def decision_function(model, ax=None, plot_support=True):
   if ax is None:
      ax = plt.gca()
   xlim = ax.get_xlim()
   ylim = ax.get_ylim()

สำหรับการประเมินโมเดลเราต้องสร้างกริดดังนี้ -

x = np.linspace(xlim[0], xlim[1], 30)
y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)

ต่อไปเราต้องวางแผนขอบเขตการตัดสินใจและระยะขอบดังนี้ -

ax.contour(X, Y, P, colors='k',
   levels=[-1, 0, 1], alpha=0.5,
   linestyles=['--', '-', '--'])

ตอนนี้พล็อตเวกเตอร์สนับสนุนในทำนองเดียวกันดังนี้ -

if plot_support:
   ax.scatter(model.support_vectors_[:, 0],
      model.support_vectors_[:, 1],
      s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)

ตอนนี้ใช้ฟังก์ชั่นนี้ให้เหมาะกับรุ่นของเราดังนี้ -

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

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

model.support_vectors_

ผลลัพธ์มีดังนี้ -

array([[0.5323772 , 3.31338909],
   [2.11114739, 3.57660449],
   [1.46870582, 1.86947425]])

เมล็ด SVM

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

เคอร์เนลเชิงเส้น

สามารถใช้เป็นผลิตภัณฑ์จุดระหว่างข้อสังเกตสองข้อใด ๆ สูตรของเคอร์เนลเชิงเส้นมีดังนี้ -

k (x, x _i ) = ผลรวม (x * x _i )

จากสูตรข้างต้นเราจะเห็นว่าผลคูณระหว่างเวกเตอร์สองตัวบอกว่า & คือผลรวมของการคูณของค่าอินพุตแต่ละคู่

เคอร์เนลพหุนาม

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

K (x, xi) = 1 + ผลรวม (x * xi) ^ d

นี่ d คือระดับของพหุนามซึ่งเราต้องระบุด้วยตนเองในอัลกอริทึมการเรียนรู้

ฟังก์ชัน Radial Basis (RBF)

เคอร์เนล RBF ส่วนใหญ่ใช้ในการจำแนก SVM แม็พพื้นที่ป้อนข้อมูลในพื้นที่มิติไม่ จำกัด สูตรต่อไปนี้อธิบายทางคณิตศาสตร์ -

K (x, xi) = exp (-gamma * sum ((x - xi ^ 2))

ที่นี่แกมมามีค่าตั้งแต่ 0 ถึง 1 เราจำเป็นต้องระบุด้วยตนเองในอัลกอริทึมการเรียนรู้ ค่าเริ่มต้นที่ดีของแกมมาคือ 0.1

ในขณะที่เราใช้ SVM สำหรับข้อมูลที่แยกกันได้เชิงเส้นเราสามารถนำไปใช้ใน Python สำหรับข้อมูลที่แยกออกจากกันไม่ได้เชิงเส้น สามารถทำได้โดยใช้เมล็ด

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างสำหรับการสร้างตัวจำแนก SVM โดยใช้ kernels เราจะใช้ชุดข้อมูลไอริสจาก scikit-learn -

เราจะเริ่มต้นด้วยการนำเข้าแพ็คเกจต่อไปนี้ -

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

ตอนนี้เราต้องโหลดข้อมูลอินพุต -

iris = datasets.load_iris()

จากชุดข้อมูลนี้เราใช้คุณสมบัติสองประการแรกดังนี้ -

X = iris.data[:, :2]
y = iris.target

ต่อไปเราจะพล็อตขอบเขต SVM ด้วยข้อมูลดั้งเดิมดังนี้ -

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
   np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

ตอนนี้เราต้องระบุค่าของพารามิเตอร์การทำให้เป็นมาตรฐานดังนี้ -

C = 1.0

ถัดไปสามารถสร้างวัตถุลักษณนาม SVM ได้ดังนี้ -

Svc_classifier = svm.SVC (เคอร์เนล = 'เชิงเส้น', C = C) .fit (X, y)

Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with linear kernel')

เอาต์พุต

Text(0.5, 1.0, 'Support Vector Classifier with linear kernel')

สำหรับการสร้างตัวแยกประเภท SVM ด้วย rbf เคอร์เนลเราสามารถเปลี่ยนเคอร์เนลเป็น rbf ดังต่อไปนี้ -

Svc_classifier = svm.SVC(kernel='rbf', gamma =‘auto’,C=C).fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with rbf kernel')

เอาต์พุต

Text(0.5, 1.0, 'Support Vector Classifier with rbf kernel')

เราใส่ค่าของแกมมาเป็น 'อัตโนมัติ' แต่คุณสามารถระบุค่าระหว่าง 0 ถึง 1 ได้เช่นกัน

ข้อดีข้อเสียของ SVM Classifiers

ข้อดีของตัวแยกประเภท SVM

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

จุดด้อยของตัวแยกประเภท SVM

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

ข้อมูลเบื้องต้นเกี่ยวกับแผนผังการตัดสินใจ

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

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

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

• Classification decision trees- ในโครงสร้างการตัดสินใจประเภทนี้ตัวแปรการตัดสินใจเป็นแบบเด็ดขาด แผนผังการตัดสินใจข้างต้นเป็นตัวอย่างของแผนผังการตัดสินใจจำแนกประเภท

• Regression decision trees - ในโครงสร้างการตัดสินใจแบบนี้ตัวแปรการตัดสินใจจะต่อเนื่อง

การใช้อัลกอริทึมแผนผังการตัดสินใจ

ดัชนี Gini

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

ค่าดัชนี Gini สูงขึ้นความเป็นเนื้อเดียวกันจะสูงขึ้น ค่าดัชนี Gini ที่สมบูรณ์แบบคือ 0 และแย่ที่สุดคือ 0.5 (สำหรับปัญหา 2 คลาส) ดัชนี Gini สำหรับการแยกสามารถคำนวณได้ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ -

• ขั้นแรกให้คำนวณดัชนี Gini สำหรับโหนดย่อยโดยใช้สูตร p ^ 2 + q ^ 2 ซึ่งเป็นผลรวมของกำลังสองของความน่าจะเป็นสำหรับความสำเร็จและความล้มเหลว

• จากนั้นคำนวณดัชนี Gini สำหรับการแยกโดยใช้คะแนน Gini แบบถ่วงน้ำหนักของแต่ละโหนดของการแยกนั้น

อัลกอริทึม Classification and Regression Tree (CART) ใช้วิธี Gini เพื่อสร้างการแยกไบนารี

แยกการสร้าง

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

• Part1 - การคำนวณคะแนน Gini: เราเพิ่งพูดถึงส่วนนี้ในหัวข้อก่อนหน้านี้

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

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

การสร้างต้นไม้

ดังที่เราทราบว่าต้นไม้มีโหนดรากและโหนดขั้ว หลังจากสร้างโหนดรูทเราสามารถสร้างต้นไม้ได้โดยทำตามสองส่วน -

ส่วนที่ 1: การสร้างโหนดเทอร์มินัล

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

• Maximum Tree Depth- ตามชื่อแนะนำนี่คือจำนวนโหนดสูงสุดในทรีหลังโหนดรูท เราต้องหยุดการเพิ่มโหนดเทอร์มินัลเมื่อต้นไม้มีความลึกสูงสุดเช่นเมื่อต้นไม้มีจำนวนโหนดเทอร์มินัลสูงสุด

• Minimum Node Records- อาจกำหนดเป็นจำนวนขั้นต่ำของรูปแบบการฝึกอบรมที่โหนดหนึ่ง ๆ รับผิดชอบ เราต้องหยุดการเพิ่มโหนดเทอร์มินัลเมื่อทรีมาถึงที่ระเบียนโหนดขั้นต่ำเหล่านี้หรือต่ำกว่าขั้นต่ำนี้

โหนดเทอร์มินัลใช้ในการทำนายขั้นสุดท้าย

Part2: การแยกซ้ำ

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

คาดการณ์

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

เราสามารถคาดคะเนได้โดยใช้ฟังก์ชันเรียกซ้ำดังที่ได้กล่าวมาแล้ว รูทีนการทำนายเดียวกันจะถูกเรียกอีกครั้งโดยใช้โหนดซ้ายหรือโหนดขวาของลูก

สมมติฐาน

ต่อไปนี้เป็นสมมติฐานบางส่วนที่เราสร้างขึ้นในขณะที่สร้างแผนผังการตัดสินใจ -

• ในขณะเตรียมทรีการตัดสินใจชุดการฝึกจะเป็นเสมือนรูทโหนด

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

• ตามค่าของแอตทริบิวต์ระเบียนจะกระจายแบบวนซ้ำ

• วิธีการทางสถิติจะใช้เพื่อวางแอตทริบิวต์ที่ตำแหน่งโหนดใด ๆ เช่นโหนดรูทหรือโหนดภายใน

การใช้งานใน Python

ตัวอย่าง

ในตัวอย่างต่อไปนี้เราจะนำ Decision Tree ลักษณนามมาใช้กับ Pima Indian Diabetes -

ขั้นแรกเริ่มต้นด้วยการนำเข้าแพ็คเกจ python ที่จำเป็น -

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

จากนั้นดาวน์โหลดชุดข้อมูลม่านตาจากเว็บลิงค์ดังต่อไปนี้ -

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv(r"C:\pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()

pregnant    glucose  bp    skin  insulin  bmi   pedigree    age   label
0       6         148      72    35     0       33.6    0.627     50      1
1       1         85       66    29     0       26.6    0.351     31      0
2       8         183      64     0     0       23.3    0.672     32      1
3       1         89       66    23     94      28.1    0.167     21      0
4       0         137      40    35     168     43.1    2.288     33      1

ตอนนี้แยกชุดข้อมูลออกเป็นคุณสมบัติและตัวแปรเป้าหมายดังนี้ -

feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

ต่อไปเราจะแบ่งข้อมูลออกเป็นส่วนรถไฟและการทดสอบ รหัสต่อไปนี้จะแบ่งชุดข้อมูลออกเป็นข้อมูลการฝึกอบรม 70% และข้อมูลการทดสอบ 30% -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)

จากนั้นฝึกโมเดลด้วยความช่วยเหลือของคลาส DecisionTreeClassifier ของ sklearn ดังต่อไปนี้ -

clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)

ในที่สุดเราต้องทำการทำนาย สามารถทำได้ด้วยความช่วยเหลือของสคริปต์ต่อไปนี้ -

y_pred = clf.predict(X_test)

ต่อไปเราจะได้รับคะแนนความแม่นยำเมทริกซ์ความสับสนและรายงานการจำแนกดังนี้ -

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

เอาต์พุต

Confusion Matrix:
[[116 30]
[ 46 39]]
Classification Report:
            precision   recall   f1-score    support
      0       0.72      0.79       0.75     146
      1       0.57      0.46       0.51     85
micro avg     0.67      0.67       0.67     231
macro avg     0.64      0.63       0.63     231
weighted avg  0.66      0.67       0.66     231

Accuracy: 0.670995670995671

การแสดงแผนผังการตัดสินใจ

แผนภูมิการตัดสินใจข้างต้นสามารถมองเห็นได้ด้วยความช่วยเหลือของรหัสต่อไปนี้ -

from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
      filled=True, rounded=True,
      special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('Pima_diabetes_Tree.png')
Image(graph.create_png())

ข้อมูลเบื้องต้นเกี่ยวกับNaïve Bayes Algorithm

อัลกอริทึมNaïve Bayes เป็นเทคนิคการจำแนกตามการใช้ทฤษฎีบทของ Bayes โดยมีสมมติฐานที่ชัดเจนว่าตัวทำนายทั้งหมดเป็นอิสระซึ่งกันและกัน กล่าวง่ายๆว่าข้อสันนิษฐานก็คือการปรากฏตัวของคุณลักษณะในคลาสนั้นไม่ขึ้นอยู่กับการมีอยู่ของคุณสมบัติอื่น ๆ ในคลาสเดียวกัน ตัวอย่างเช่นโทรศัพท์อาจถือได้ว่าฉลาดหากมีหน้าจอสัมผัสสิ่งอำนวยความสะดวกอินเทอร์เน็ตกล้องถ่ายรูปที่ดี ฯลฯ แม้ว่าคุณสมบัติทั้งหมดนี้จะขึ้นอยู่กับกันและกัน แต่ก็มีส่วนร่วมอย่างอิสระต่อความน่าจะเป็นที่โทรศัพท์จะเป็นสมาร์ทโฟน

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

$P(L |features)= \frac{P(L)P(features |L)}{()}$

ที่นี่ (|) คือความน่าจะเป็นหลังของคลาส

() คือความน่าจะเป็นก่อนหน้าของคลาส

(|) คือความเป็นไปได้ซึ่งเป็นความน่าจะเป็นของตัวทำนายที่กำหนด

() คือความน่าจะเป็นก่อนหน้าของตัวทำนาย

การสร้างแบบจำลองโดยใช้Naïve Bayes ใน Python

ไลบรารี Python Scikit learn เป็นไลบรารีที่มีประโยชน์ที่สุดที่ช่วยให้เราสร้างแบบจำลองNaïve Bayes ใน Python เรามีโมเดลNaïve Bayes สามประเภทต่อไปนี้ภายใต้ Scikit Learn Python library -

Gaussian Naïve Bayes

เป็นลักษณนามNaïve Bayes ที่ง่ายที่สุดโดยมีข้อสันนิษฐานว่าข้อมูลจากแต่ละฉลากมาจากการแจกแจงแบบเกาส์เซียนอย่างง่าย

Multinomial Naïve Bayes

ลักษณนามNaïve Bayes ที่มีประโยชน์อีกตัวหนึ่งคือ Multinomial Naïve Bayes ซึ่งคุณสมบัตินี้ถือว่ามาจากการแจกแจงแบบพหุนามแบบง่าย Naïve Bayes แบบนี้เหมาะสมที่สุดสำหรับคุณสมบัติที่แสดงถึงการนับไม่ต่อเนื่อง

Bernoulli Naïve Bayes

โมเดลที่สำคัญอีกแบบคือ Bernoulli Naïve Bayes ซึ่งคุณสมบัติต่างๆจะถือว่าเป็นไบนารี (0s and 1s) การจำแนกข้อความด้วยโมเดล 'ถุงคำ' สามารถประยุกต์ใช้ Bernoulli Naïve Bayes

ตัวอย่าง

ขึ้นอยู่กับชุดข้อมูลของเราเราสามารถเลือกแบบจำลองNaïve Bayes ที่อธิบายข้างต้นได้ ที่นี่เรากำลังใช้แบบจำลอง Gaussian Naïve Bayes ใน Python -

เราจะเริ่มต้นด้วยการนำเข้าที่จำเป็นดังต่อไปนี้ -

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()

ตอนนี้โดยใช้ฟังก์ชัน make_blobs () ของ Scikit learn เราสามารถสร้าง blobs ของจุดด้วยการแจกแจงแบบ Gaussian ได้ดังนี้ -

from sklearn.datasets import make_blobs
X, y = make_blobs(300, 2, centers=2, random_state=2, cluster_std=1.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

ต่อไปสำหรับการใช้โมเดล GaussianNB เราต้องนำเข้าและสร้างวัตถุดังต่อไปนี้ -

from sklearn.naive_bayes import GaussianNB
model_GBN = GaussianNB()
model_GNB.fit(X, y);

ตอนนี้เราต้องทำการทำนาย สามารถทำได้หลังจากสร้างข้อมูลใหม่แล้วดังนี้ -

rng = np.random.RandomState(0)
Xnew = [-6, -14] + [14, 18] * rng.rand(2000, 2)
ynew = model_GNB.predict(Xnew)

ต่อไปเรากำลังวางแผนข้อมูลใหม่เพื่อหาขอบเขต -

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
lim = plt.axis()
plt.scatter(Xnew[:, 0], Xnew[:, 1], c=ynew, s=20, cmap='summer', alpha=0.1)
plt.axis(lim);

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

yprob = model_GNB.predict_proba(Xnew)
yprob[-10:].round(3)

เอาต์พุต

array([[0.998, 0.002],
      [1. , 0. ],
      [0.987, 0.013],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [0. , 1. ],
      [0.986, 0.014]])

ข้อเสียข้อดี

ข้อดี

ต่อไปนี้เป็นข้อดีบางประการของการใช้ลักษณนามของNaïve Bayes -

• การจำแนกประเภทNaïve Bayes ทำได้ง่ายและรวดเร็ว

• มันจะมาบรรจบกันเร็วกว่ารูปแบบการแยกแยะเช่นการถดถอยโลจิสติก

• ต้องใช้ข้อมูลการฝึกอบรมน้อย

• โดยธรรมชาติสามารถปรับขนาดได้สูงหรือจะปรับขนาดเชิงเส้นด้วยจำนวนตัวทำนายและจุดข้อมูล

• สามารถคาดการณ์ความน่าจะเป็นและสามารถจัดการข้อมูลต่อเนื่องและไม่ต่อเนื่องได้

• อัลกอริธึมการจำแนกประเภทNaïve Bayes สามารถใช้กับปัญหาการจำแนกแบบไบนารีและแบบหลายชั้นได้

จุดด้อย

ต่อไปนี้เป็นข้อเสียบางประการของการใช้ตัวแยกประเภทของNaïve Bayes -

• ข้อเสียที่สำคัญที่สุดอย่างหนึ่งของการจำแนกประเภทNaïve Bayes คือความเป็นอิสระของคุณลักษณะที่แข็งแกร่งเพราะในชีวิตจริงแทบจะเป็นไปไม่ได้เลยที่จะมีชุดคุณสมบัติที่ไม่ขึ้นต่อกัน

• อีกปัญหาหนึ่งเกี่ยวกับการจำแนกประเภทNaïve Bayes คือ 'ความถี่ศูนย์' ซึ่งหมายความว่าหากตัวแปรจัดหมวดหมู่มีหมวดหมู่ แต่ไม่พบในชุดข้อมูลการฝึกโมเดลNaïve Bayes จะกำหนดความน่าจะเป็นเป็นศูนย์ให้และจะไม่สามารถสร้าง คาดการณ์.

การประยุกต์ใช้การจำแนกประเภทNaïve Bayes

ต่อไปนี้เป็นแอปพลิเคชันทั่วไปของการจำแนกประเภทNaïve Bayes -

Real-time prediction - เนื่องจากการใช้งานง่ายและการคำนวณที่รวดเร็วจึงสามารถใช้ในการทำนายแบบเรียลไทม์

Multi-class prediction - อัลกอริธึมการจำแนกNaïve Bayes สามารถใช้เพื่อทำนายความน่าจะเป็นหลังของตัวแปรเป้าหมายหลายคลาส

Text classification- เนื่องจากคุณสมบัติของการทำนายหลายชั้นอัลกอริทึมการจำแนกประเภทNaïve Bayes จึงเหมาะอย่างยิ่งสำหรับการจัดประเภทข้อความ นั่นคือเหตุผลที่ใช้ในการแก้ปัญหาเช่นการกรองสแปมและการวิเคราะห์ความรู้สึก

Recommendation system - นอกเหนือจากอัลกอริทึมเช่นการกรองร่วมกันแล้วNaïve Bayes ยังสร้างระบบคำแนะนำซึ่งสามารถใช้เพื่อกรองข้อมูลที่มองไม่เห็นและทำนายสภาพอากาศว่าผู้ใช้ต้องการทรัพยากรที่ระบุหรือไม่

บทนำ

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

การทำงานของอัลกอริทึมป่าสุ่ม

เราสามารถเข้าใจการทำงานของอัลกอริทึม Random Forest ได้ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ -

Step1 - ขั้นแรกเริ่มต้นด้วยการเลือกตัวอย่างสุ่มจากชุดข้อมูลที่กำหนด

Step2- ถัดไปอัลกอริทึมนี้จะสร้างแผนผังการตัดสินใจสำหรับทุกตัวอย่าง จากนั้นจะได้รับผลการทำนายจากต้นไม้การตัดสินใจทุกครั้ง

Step3 - ในขั้นตอนนี้การลงคะแนนจะดำเนินการสำหรับทุกผลการทำนาย

Step4 - ในที่สุดให้เลือกผลการทำนายที่ได้รับการโหวตมากที่สุดเป็นผลการทำนายขั้นสุดท้าย

แผนภาพต่อไปนี้จะแสดงให้เห็นถึงการทำงาน -

การใช้งานใน Python

ขั้นแรกเริ่มต้นด้วยการนำเข้าแพ็คเกจ Python ที่จำเป็น -

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

จากนั้นดาวน์โหลดชุดข้อมูลม่านตาจากเว็บลิงค์ดังต่อไปนี้ -

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

ต่อไปเราต้องกำหนดชื่อคอลัมน์ให้กับชุดข้อมูลดังนี้ -

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

ตอนนี้เราต้องอ่าน dataset ไปยัง dataframe ของแพนด้าดังนี้ -

dataset = pd.read_csv(path, names=headernames)
dataset.head()

	ความยาวของกลีบเลี้ยง	ความกว้างของกลีบเลี้ยง	ความยาวกลีบดอก	ความกว้างกลีบดอก	คลาส
0	5.1	3.5	1.4	0.2	Iris-setosa
1	4.9	3.0	1.4	0.2	Iris-setosa
2	4.7	3.2	1.3	0.2	Iris-setosa
3	4.6	3.1	1.5	0.2	Iris-setosa
4	5.0	3.6	1.4	0.2	Iris-setosa

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

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

ต่อไปเราจะแบ่งข้อมูลออกเป็นส่วนรถไฟและการทดสอบ รหัสต่อไปนี้จะแบ่งชุดข้อมูลออกเป็นข้อมูลการฝึกอบรม 70% และข้อมูลการทดสอบ 30% -

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)

จากนั้นฝึกโมเดลด้วยความช่วยเหลือของคลาส RandomForestClassifier ของ sklearn ดังนี้ -

from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=50)
classifier.fit(X_train, y_train)

ในที่สุดเราต้องทำการทำนาย สามารถทำได้ด้วยความช่วยเหลือของสคริปต์ต่อไปนี้ -

y_pred = classifier.predict(X_test)

จากนั้นพิมพ์ผลลัพธ์ดังนี้ -

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

เอาต์พุต

Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
               precision       recall     f1-score       support
Iris-setosa        1.00         1.00        1.00         14
Iris-versicolor    1.00         0.95        0.97         19
Iris-virginica     0.92         1.00        0.96         12
micro avg          0.98         0.98        0.98         45
macro avg          0.97         0.98        0.98         45
weighted avg       0.98         0.98        0.98         45

Accuracy: 0.9777777777777777

ข้อดีข้อเสียของ Random Forest

ข้อดี

ต่อไปนี้เป็นข้อดีของอัลกอริทึม Random Forest -

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

• ฟอเรสต์แบบสุ่มทำงานได้ดีสำหรับรายการข้อมูลจำนวนมากมากกว่าทรีการตัดสินใจเดียว

• ป่าสุ่มมีความแปรปรวนน้อยกว่าต้นไม้การตัดสินใจเดี่ยว

• ป่าสุ่มมีความยืดหยุ่นสูงและมีความแม่นยำสูงมาก

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

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

จุดด้อย

ต่อไปนี้เป็นข้อเสียของอัลกอริทึม Random Forest -

• ความซับซ้อนเป็นข้อเสียเปรียบหลักของอัลกอริทึมฟอเรสต์แบบสุ่ม

• การสร้างป่าสุ่มนั้นยากและใช้เวลานานกว่าต้นไม้แห่งการตัดสินใจ

• ต้องใช้ทรัพยากรในการคำนวณมากขึ้นเพื่อใช้อัลกอริทึม Random Forest

• ใช้งานง่ายน้อยกว่าในกรณีที่เรามีต้นไม้การตัดสินใจจำนวนมาก

• ขั้นตอนการทำนายโดยใช้ฟอเรสต์แบบสุ่มนั้นใช้เวลานานมากเมื่อเทียบกับอัลกอริทึมอื่น ๆ

ความรู้เบื้องต้นเกี่ยวกับการถดถอย

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

ประเภทของแบบจำลองการถดถอย

แบบจำลองการถดถอยมีสองประเภทดังต่อไปนี้ -

Simple regression model - นี่คือแบบจำลองการถดถอยขั้นพื้นฐานที่สุดซึ่งการคาดการณ์เกิดขึ้นจากคุณลักษณะเดียวที่ไม่แปรผันของข้อมูล

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

สร้าง Regressor ใน Python

โมเดล Regressor ใน Python สามารถสร้างได้เช่นเดียวกับที่เราสร้างลักษณนาม Scikit-learn ซึ่งเป็นไลบรารี Python สำหรับการเรียนรู้ของเครื่องยังสามารถใช้เพื่อสร้าง Regressor ใน Python ได้

ในตัวอย่างต่อไปนี้เราจะสร้างแบบจำลองการถดถอยพื้นฐานที่จะพอดีกับเส้นกับข้อมูลนั่นคือ linear regressor ขั้นตอนที่จำเป็นสำหรับการสร้าง Regressor ใน Python มีดังนี้ -

ขั้นตอนที่ 1: นำเข้าแพ็คเกจ python ที่จำเป็น

สำหรับการสร้าง regressor โดยใช้ scikit-learn เราจำเป็นต้องนำเข้าพร้อมกับแพ็คเกจที่จำเป็นอื่น ๆ เราสามารถนำเข้าโดยใช้สคริปต์ต่อไปนี้ -

import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt

ขั้นตอนที่ 2: การนำเข้าชุดข้อมูล

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

input = r'C:\linear.txt'

ต่อไปเราต้องโหลดข้อมูลนี้ เรากำลังใช้ฟังก์ชัน np.loadtxt เพื่อโหลด

input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]

ขั้นตอนที่ 3: การจัดระเบียบข้อมูลลงในชุดการฝึกอบรมและการทดสอบ

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

training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

ขั้นตอนที่ 4- การประเมินและการทำนายแบบจำลอง

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

reg_linear= linear_model.LinearRegression()

จากนั้นฝึกโมเดลนี้ด้วยตัวอย่างการฝึกดังนี้ -

reg_linear.fit(X_train, y_train)

ในที่สุดเราต้องทำการคาดการณ์ด้วยข้อมูลการทดสอบ

y_test_pred = reg_linear.predict(X_test)

Step5- พล็อตและการสร้างภาพ

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

plt.scatter(X_test, y_test, color='red')
plt.plot(X_test, y_test_pred, color='black', linewidth=2)
plt.xticks(())
plt.yticks(())
plt.show()

เอาต์พุต

ในผลลัพธ์ข้างต้นเราจะเห็นเส้นการถดถอยระหว่างจุดข้อมูล

Step6- Performance computation - เรายังสามารถคำนวณประสิทธิภาพของแบบจำลองการถดถอยของเราด้วยความช่วยเหลือของเมตริกประสิทธิภาพต่างๆดังนี้ -

print("Regressor model performance:")
print("Mean absolute error(MAE) =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error(MSE) =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))

เอาต์พุต

Regressor model performance:
Mean absolute error(MAE) = 1.78
Mean squared error(MSE) = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09

ประเภทของ ML Regression Algorithms

อัลกอริธึมการถดถอย ML ที่มีประโยชน์และเป็นที่นิยมมากที่สุดคืออัลกอริธึมการถดถอยเชิงเส้นซึ่งแบ่งออกเป็นสองประเภท ได้แก่ -

• อัลกอริธึมการถดถอยเชิงเส้นอย่างง่าย

• อัลกอริทึมการถดถอยเชิงเส้นหลายตัว

เราจะพูดถึงเรื่องนี้และนำไปใช้ใน Python ในบทถัดไป

การใช้งาน

การประยุกต์ใช้อัลกอริทึมการถดถอย ML มีดังนี้ -

Forecasting or Predictive analysis- การใช้การถดถอยที่สำคัญอย่างหนึ่งคือการพยากรณ์หรือการวิเคราะห์เชิงทำนาย ตัวอย่างเช่นเราสามารถคาดการณ์ GDP ราคาน้ำมันหรือพูดง่ายๆคือข้อมูลเชิงปริมาณที่เปลี่ยนแปลงไปตามกาลเวลา

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

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

Economics- เป็นเครื่องมือที่ใช้มากที่สุดในทางเศรษฐศาสตร์ เราสามารถใช้การถดถอยเพื่อทำนายอุปทานอุปสงค์การบริโภคการลงทุนสินค้าคงคลังเป็นต้น

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

บทนำสู่ Linear Regression

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

ในทางคณิตศาสตร์ความสัมพันธ์สามารถแสดงได้ด้วยความช่วยเหลือของสมการต่อไปนี้ -

Y = mX + b

ที่นี่ Y คือตัวแปรตามที่เราพยายามทำนาย

X คือตัวแปรตามที่เราใช้ในการทำนาย

m คือ slop ของเส้นถดถอยซึ่งแสดงถึงเอฟเฟกต์ X ที่มีต่อ Y

b คือค่าคงที่หรือที่เรียกว่า Y-intercept ถ้า X = 0 Y จะเท่ากับ b

นอกจากนี้ความสัมพันธ์เชิงเส้นสามารถเป็นบวกหรือลบได้ตามที่อธิบายไว้ด้านล่าง -

ความสัมพันธ์เชิงเส้นเชิงบวก

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

ความสัมพันธ์เชิงเส้นเชิงลบ

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

ประเภทของการถดถอยเชิงเส้น

การถดถอยเชิงเส้นมีสองประเภทต่อไปนี้ -

• การถดถอยเชิงเส้นอย่างง่าย

• การถดถอยเชิงเส้นหลาย ๆ

การถดถอยเชิงเส้นอย่างง่าย (SLR)

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

การใช้งาน Python

เราสามารถใช้ SLR ใน Python ได้สองวิธีวิธีหนึ่งคือการให้ชุดข้อมูลของคุณเองและอื่น ๆ คือการใช้ชุดข้อมูลจากไลบรารี scikit-learn python

Example1 - ในตัวอย่างการใช้งาน Python ต่อไปนี้เรากำลังใช้ชุดข้อมูลของเราเอง

ขั้นแรกเราจะเริ่มต้นด้วยการนำเข้าแพ็คเกจที่จำเป็นดังนี้ -

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

จากนั้นกำหนดฟังก์ชันที่จะคำนวณค่าที่สำคัญสำหรับ SLR -

def coef_estimation(x, y):

บรรทัดสคริปต์ต่อไปนี้จะให้จำนวนการสังเกต n -

n = np.size(x)

ค่าเฉลี่ยของเวกเตอร์ x และ y สามารถคำนวณได้ดังนี้ -

m_x, m_y = np.mean(x), np.mean(y)

เราสามารถหา cross-deviation และ deviation เกี่ยวกับ x ได้ดังนี้ -

SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x

ถัดไปค่าสัมประสิทธิ์การถดถอยเช่น b สามารถคำนวณได้ดังนี้ -

b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)

ต่อไปเราต้องกำหนดฟังก์ชันที่จะพล็อตเส้นการถดถอยและทำนายเวกเตอร์การตอบสนอง -

def plot_regression_line(x, y, b):

บรรทัดสคริปต์ต่อไปนี้จะพล็อตจุดจริงเป็น scatter plot -

plt.scatter(x, y, color = "m", marker = "o", s = 30)

บรรทัดสคริปต์ต่อไปนี้จะทำนายเวกเตอร์การตอบสนอง -

y_pred = b[0] + b[1]*x

บรรทัดสคริปต์ต่อไปนี้จะพล็อตเส้นการถดถอยและจะใส่ป้ายกำกับไว้ -

plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()

ในที่สุดเราต้องกำหนดฟังก์ชัน main () เพื่อให้ชุดข้อมูลและเรียกใช้ฟังก์ชันที่เรากำหนดไว้ข้างต้น -

def main():
   x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
   y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
   b = coef_estimation(x, y)
   print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
   plot_regression_line(x, y, b)
   
if __name__ == "__main__":
main()

เอาต์พุต

Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788

Example2 - ในตัวอย่างการใช้งาน Python ต่อไปนี้เรากำลังใช้ชุดข้อมูลเบาหวานจาก scikit-learn

ขั้นแรกเราจะเริ่มต้นด้วยการนำเข้าแพ็คเกจที่จำเป็นดังนี้ -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

ต่อไปเราจะโหลดชุดข้อมูลเบาหวานและสร้างวัตถุ -

diabetes = datasets.load_diabetes()

ในขณะที่เราใช้ SLR เราจะใช้คุณลักษณะเดียวดังต่อไปนี้ -

X = diabetes.data[:, np.newaxis, 2]

ต่อไปเราต้องแบ่งข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบดังนี้ -

X_train = X[:-30]
X_test = X[-30:]

ต่อไปเราต้องแบ่งเป้าหมายออกเป็นชุดฝึกและชุดทดสอบดังนี้ -

y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]

ตอนนี้ในการฝึกโมเดลเราจำเป็นต้องสร้างวัตถุถดถอยเชิงเส้นดังนี้ -

regr = linear_model.LinearRegression()

จากนั้นฝึกโมเดลโดยใช้ชุดฝึกดังนี้ -

regr.fit(X_train, y_train)

จากนั้นทำการคาดคะเนโดยใช้ชุดการทดสอบดังนี้ -

y_pred = regr.predict(X_test)

ต่อไปเราจะพิมพ์ค่าสัมประสิทธิ์บางอย่างเช่น MSE คะแนนความแปรปรวนเป็นต้นดังต่อไปนี้ -

print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f"
   % mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))

ตอนนี้พล็อตผลลัพธ์ดังนี้ -

plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

เอาต์พุต

Coefficients:
   [941.43097333]
Mean squared error: 3035.06
Variance score: 0.41

การถดถอยเชิงเส้นหลายเส้น (MLR)

มันเป็นส่วนขยายของการถดถอยเชิงเส้นอย่างง่ายที่ทำนายการตอบสนองโดยใช้คุณสมบัติสองอย่างขึ้นไป ในทางคณิตศาสตร์เราสามารถอธิบายได้ดังนี้ -

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

$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}$

ในที่นี้ h (x _i ) คือค่าตอบสนองที่คาดการณ์ไว้และ b ₀ , b ₁ , b ₂ †¦, b _pคือสัมประสิทธิ์การถดถอย

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

$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}+e_{i}$

เรายังสามารถเขียนสมการข้างต้นได้ดังนี้ -

$y_{i}=h(x_{i})+e_{i}$ $e_{i}= y_{i} - h(x_{i})$

การใช้งาน Python

ในตัวอย่างนี้เราจะใช้ชุดข้อมูลที่อยู่อาศัยของบอสตันจาก scikit learn -

ขั้นแรกเราจะเริ่มต้นด้วยการนำเข้าแพ็คเกจที่จำเป็นดังนี้ -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics

จากนั้นโหลดชุดข้อมูลดังนี้ -

boston = datasets.load_boston(return_X_y=False)

บรรทัดสคริปต์ต่อไปนี้จะกำหนดคุณสมบัติเมทริกซ์ X และเวกเตอร์การตอบสนอง Y -

X = boston.data
y = boston.target

จากนั้นแยกชุดข้อมูลออกเป็นชุดการฝึกอบรมและชุดทดสอบดังนี้ -

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)

ตอนนี้สร้างวัตถุถดถอยเชิงเส้นและฝึกโมเดลดังนี้ -

reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
      color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
      color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()

เอาต์พุต

Coefficients:
[-1.16358797e-01 6.44549228e-02 1.65416147e-01 1.45101654e+00
-1.77862563e+01 2.80392779e+00 4.61905315e-02 -1.13518865e+00
3.31725870e-01 -1.01196059e-02 -9.94812678e-01 9.18522056e-03
-7.92395217e-01]
Variance score: 0.709454060230326

สมมติฐาน

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

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

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

Relationship between variables - แบบจำลองการถดถอยเชิงเส้นจะถือว่าความสัมพันธ์ระหว่างตัวแปรตอบสนองและคุณลักษณะต้องเป็นเชิงเส้น

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

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

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

ตัวอย่างเช่นด้านล่างคือแผนภาพที่แสดงระบบการจัดกลุ่มที่จัดกลุ่มข้อมูลที่คล้ายกันในคลัสเตอร์ต่างๆเข้าด้วยกัน -

วิธีการสร้างคลัสเตอร์

ไม่จำเป็นที่จะต้องรวมกลุ่มกันเป็นทรงกลม ต่อไปนี้เป็นวิธีการสร้างคลัสเตอร์อื่น ๆ -

ขึ้นอยู่กับความหนาแน่น

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

ตามลำดับชั้น

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

การแบ่งพาร์ติชัน

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

กริด

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

การวัดประสิทธิภาพการทำคลัสเตอร์

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

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

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

การวิเคราะห์ภาพเงา

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

การวิเคราะห์คะแนน Silhouette

ช่วงคะแนน Silhouette คือ [-1, 1] การวิเคราะห์มีดังนี้ -

• +1 Score - ใกล้ +1 Silhouette score บ่งชี้ว่ากลุ่มตัวอย่างอยู่ห่างจากคลัสเตอร์ใกล้เคียง

• 0 Score - 0 Silhouette score บ่งชี้ว่ากลุ่มตัวอย่างอยู่หรือใกล้กับขอบเขตการตัดสินใจที่แยกสองกลุ่มใกล้เคียงกัน

• -1 Score & ลบ -1 Silhouette score แสดงว่าตัวอย่างถูกกำหนดให้กับคลัสเตอร์ที่ไม่ถูกต้อง

การคำนวณคะแนน Silhouette สามารถทำได้โดยใช้สูตรต่อไปนี้ -

= (-) / (,)

ที่นี่ = หมายถึงระยะทางไปยังจุดในคลัสเตอร์ที่ใกล้ที่สุด

และ = หมายถึงระยะทางภายในคลัสเตอร์ไปยังจุดทั้งหมด

ดัชนี Davis-Bouldin

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

• สภาพอากาศคลัสเตอร์มีระยะห่างจากกันหรือไม่?

• กระจุกดาวหนาแน่นแค่ไหน?

เราสามารถคำนวณดัชนี DB โดยใช้สูตรต่อไปนี้ -

$DB=\frac{1}{n}\displaystyle\sum\limits_{i=1}^n max_{j\neq{i}}\left(\frac{\sigma_{i}+\sigma_{j}}{d(c_{i},c_{j})}\right)$

ที่นี่ = จำนวนคลัสเตอร์

σ _i = ระยะห่างเฉลี่ยของจุดทั้งหมดในคลัสเตอร์จากคลัสเตอร์เซนทรอยด์

น้อยกว่าดัชนี DB โมเดลการทำคลัสเตอร์จะดีกว่า

ดัชนี Dunn

ทำงานเหมือนกับ DB index แต่มีประเด็นต่อไปนี้ซึ่งทั้งสองต่างกัน -

• ดัชนี Dunn พิจารณาเฉพาะกรณีที่เลวร้ายที่สุดนั่นคือคลัสเตอร์ที่อยู่ใกล้กันในขณะที่ดัชนี DB พิจารณาการกระจายและการแยกคลัสเตอร์ทั้งหมดในแบบจำลองการทำคลัสเตอร์

• ดัชนี Dunn จะเพิ่มขึ้นเมื่อประสิทธิภาพเพิ่มขึ้นในขณะที่ดัชนี DB จะดีขึ้นเมื่อคลัสเตอร์มีระยะห่างและหนาแน่น

เราสามารถคำนวณดัชนี Dunn ด้วยความช่วยเหลือของสูตรต่อไปนี้ -

$D=\frac{min_{1\leq i <{j}\leq{n}}P(i,j)}{mix_{1\leq i < k \leq n}q(k)}$

ที่นี่ ,, = แต่ละดัชนีสำหรับคลัสเตอร์

= ระยะห่างระหว่างคลัสเตอร์

q = ระยะห่างภายในคลัสเตอร์

ประเภทของ ML Clustering Algorithms

ต่อไปนี้เป็นอัลกอริธึมการทำคลัสเตอร์ ML ที่สำคัญและมีประโยชน์ที่สุด -

K-mean Clustering

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

Mean-Shift Algorithm

เป็นอีกหนึ่งอัลกอริธึมการจัดกลุ่มที่มีประสิทธิภาพซึ่งใช้ในการเรียนรู้ที่ไม่มีผู้ดูแล ซึ่งแตกต่างจากการจัดกลุ่ม K-mean มันไม่ได้ตั้งสมมติฐานใด ๆ ดังนั้นจึงเป็นอัลกอริทึมที่ไม่ใช่พารามิเตอร์

การจัดกลุ่มตามลำดับชั้น

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

เราจะพูดถึงอัลกอริทึมเหล่านี้ทั้งหมดโดยละเอียดในบทต่อ ๆ ไป

การประยุกต์ใช้การทำคลัสเตอร์

เราพบว่าการจัดกลุ่มมีประโยชน์ในด้านต่อไปนี้ -

Data summarization and compression- การทำคลัสเตอร์ใช้กันอย่างแพร่หลายในพื้นที่ที่เราต้องการการสรุปข้อมูลการบีบอัดและการลดขนาด ตัวอย่าง ได้แก่ การประมวลผลภาพและการหาปริมาณเวกเตอร์

Collaborative systems and customer segmentation - เนื่องจากสามารถใช้การจัดกลุ่มเพื่อค้นหาผลิตภัณฑ์ที่คล้ายกันหรือผู้ใช้ประเภทเดียวกันจึงสามารถใช้ในส่วนของระบบการทำงานร่วมกันและการแบ่งกลุ่มลูกค้า

Serve as a key intermediate step for other data mining tasks- การวิเคราะห์คลัสเตอร์สามารถสร้างข้อมูลสรุปที่กะทัดรัดสำหรับการจำแนกการทดสอบการสร้างสมมติฐาน ด้วยเหตุนี้จึงทำหน้าที่เป็นขั้นตอนกลางที่สำคัญสำหรับงานขุดข้อมูลอื่น ๆ ด้วย

Trend detection in dynamic data - การจัดกลุ่มยังสามารถใช้สำหรับการตรวจจับแนวโน้มในข้อมูลแบบไดนามิกโดยการสร้างกลุ่มต่างๆที่มีแนวโน้มที่คล้ายคลึงกัน

Social network analysis- การจัดกลุ่มสามารถใช้ในการวิเคราะห์เครือข่ายสังคม ตัวอย่างกำลังสร้างลำดับในรูปภาพวิดีโอหรือไฟล์เสียง

Biological data analysis - ยังสามารถใช้การจัดกลุ่มเพื่อสร้างกลุ่มของรูปภาพวิดีโอดังนั้นจึงสามารถใช้ในการวิเคราะห์ข้อมูลทางชีววิทยาได้สำเร็จ

รู้เบื้องต้นเกี่ยวกับ K-Means Algorithm

อัลกอริธึมการจัดกลุ่ม K-mean จะคำนวณเซนทรอยด์และวนซ้ำจนกว่าเราจะพบเซนทรอยด์ที่เหมาะสมที่สุด ถือว่าทราบจำนวนคลัสเตอร์แล้ว เรียกอีกอย่างว่าflat clusteringอัลกอริทึม จำนวนคลัสเตอร์ที่ระบุจากข้อมูลโดยอัลกอริทึมแสดงด้วย 'K' ใน K-mean

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

การทำงานของ K-Means Algorithm

เราสามารถเข้าใจการทำงานของอัลกอริทึมการทำคลัสเตอร์ K-Means ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ -

Step1 - ขั้นแรกเราต้องระบุจำนวนคลัสเตอร์ K ต้องสร้างโดยอัลกอริทึมนี้

Step2- จากนั้นสุ่มเลือกจุดข้อมูล K และกำหนดจุดข้อมูลแต่ละจุดให้กับคลัสเตอร์ กล่าวง่ายๆคือจัดประเภทข้อมูลตามจำนวนจุดข้อมูล

Step3 - ตอนนี้จะคำนวณคลัสเตอร์เซนทรอยด์

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

4.1 - ขั้นแรกให้คำนวณผลรวมของระยะห่างกำลังสองระหว่างจุดข้อมูลและเซนทรอยด์

4.2 - ตอนนี้เราต้องกำหนดจุดข้อมูลแต่ละจุดให้กับคลัสเตอร์ที่อยู่ใกล้กว่าคลัสเตอร์อื่น (เซนทรอยด์)

4.3 - ในที่สุดคำนวณเซนทรอยด์สำหรับคลัสเตอร์โดยการหาค่าเฉลี่ยของจุดข้อมูลทั้งหมดของคลัสเตอร์นั้น

K-mean ดังต่อไปนี้ Expectation-Maximizationแนวทางในการแก้ปัญหา Expectation-step ใช้สำหรับกำหนดจุดข้อมูลให้กับคลัสเตอร์ที่ใกล้เคียงที่สุดและ Maximization-step ใช้สำหรับคำนวณเซนทรอยด์ของแต่ละคลัสเตอร์

ในขณะที่ทำงานกับอัลกอริทึม K-mean เราต้องดูแลสิ่งต่อไปนี้ -

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

• เนื่องจากลักษณะการวนซ้ำของ K-Means และการเริ่มต้นแบบสุ่มของเซนทรอยด์ K-Means อาจติดอยู่ในระดับที่เหมาะสมที่สุดในท้องถิ่นและอาจไม่รวมเข้ากับค่าที่ดีที่สุดในระดับโลก นั่นคือเหตุผลที่แนะนำให้ใช้การเริ่มต้นที่แตกต่างกันของเซนทรอยด์

การใช้งานใน Python

ตัวอย่างสองตัวอย่างต่อไปนี้ของการใช้อัลกอริทึมการทำคลัสเตอร์ K-Means จะช่วยให้เราเข้าใจได้ดีขึ้น -

ตัวอย่าง 1

เป็นตัวอย่างง่ายๆในการทำความเข้าใจว่า k-mean ทำงานอย่างไร ในตัวอย่างนี้เราจะสร้างชุดข้อมูล 2D ที่มี 4 blobs ที่แตกต่างกันก่อนและหลังจากนั้นจะใช้อัลกอริทึม k-mean เพื่อดูผลลัพธ์

ขั้นแรกเราจะเริ่มต้นด้วยการนำเข้าแพ็คเกจที่จำเป็น -

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

รหัสต่อไปนี้จะสร้าง 2D ซึ่งมีสี่ blobs -

from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4, cluster_std=0.60, random_state=0)

ถัดไปรหัสต่อไปนี้จะช่วยให้เราเห็นภาพชุดข้อมูล -

plt.scatter(X[:, 0], X[:, 1], s=20);
plt.show()

จากนั้นสร้างวัตถุ KMeans พร้อมกับระบุจำนวนคลัสเตอร์ฝึกโมเดลและทำการทำนายดังนี้ -

kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)

ตอนนี้ด้วยความช่วยเหลือของโค้ดต่อไปนี้เราสามารถพล็อตและแสดงภาพศูนย์ของคลัสเตอร์ที่เลือกโดยตัวประมาณค่า k-mean Python -

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=20, cmap='summer')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='blue', s=100, alpha=0.9);
plt.show()

ตัวอย่าง 2

ให้เราย้ายไปยังอีกตัวอย่างหนึ่งที่เราจะใช้ K-mean clustering บนชุดข้อมูลตัวเลขอย่างง่าย K-mean จะพยายามระบุตัวเลขที่คล้ายกันโดยไม่ใช้ข้อมูลฉลากดั้งเดิม

ขั้นแรกเราจะเริ่มต้นด้วยการนำเข้าแพ็คเกจที่จำเป็น -

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

จากนั้นโหลดชุดข้อมูลหลักจาก sklearn และสร้างวัตถุขึ้นมา นอกจากนี้เรายังสามารถค้นหาจำนวนแถวและคอลัมน์ในชุดข้อมูลนี้ได้ดังนี้ -

from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape

เอาต์พุต

(1797, 64)

ผลลัพธ์ข้างต้นแสดงให้เห็นว่าชุดข้อมูลนี้มีตัวอย่าง 1797 ตัวอย่างพร้อมฟีเจอร์ 64 รายการ

เราสามารถทำการจัดกลุ่มได้ตามที่เราทำในตัวอย่างที่ 1 ด้านบน -

kmeans = KMeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape

เอาต์พุต

(10, 64)

ผลลัพธ์ข้างต้นแสดงให้เห็นว่า K-mean สร้าง 10 คลัสเตอร์ที่มี 64 คุณสมบัติ

fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
   axi.set(xticks=[], yticks=[])
   axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)

เอาต์พุต

ในผลลัพธ์เราจะได้ภาพต่อไปนี้ที่แสดงศูนย์คลัสเตอร์ที่เรียนรู้ด้วย k-mean

บรรทัดของโค้ดต่อไปนี้จะจับคู่ป้ายกำกับคลัสเตอร์ที่เรียนรู้กับป้ายกำกับที่แท้จริงที่พบในนั้น -

from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
   mask = (clusters == i)
   labels[mask] = mode(digits.target[mask])[0]

ต่อไปตรวจสอบความถูกต้องได้ดังนี้ -

from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)

เอาต์พุต

0.7935447968836951

ผลลัพธ์ข้างต้นแสดงให้เห็นว่าความแม่นยำอยู่ที่ประมาณ 80%

ข้อดีและข้อเสีย

ข้อดี

ต่อไปนี้เป็นข้อดีบางประการของอัลกอริทึมการทำคลัสเตอร์ K-Means -

• เป็นเรื่องง่ายมากที่จะเข้าใจและนำไปใช้

• ถ้าเรามีตัวแปรจำนวนมาก K-mean จะเร็วกว่าการจัดกลุ่มตามลำดับชั้น

• ในการคำนวณซ้ำของเซนทรอยด์อินสแตนซ์สามารถเปลี่ยนคลัสเตอร์ได้

• คลัสเตอร์ที่แน่นกว่านั้นถูกสร้างขึ้นด้วย K-mean เมื่อเทียบกับการทำคลัสเตอร์ตามลำดับชั้น

ข้อเสีย

ต่อไปนี้เป็นข้อเสียบางประการของอัลกอริทึมการทำคลัสเตอร์ K-Means -

• เป็นเรื่องยากเล็กน้อยที่จะคาดเดาจำนวนคลัสเตอร์เช่นค่า k

• เอาต์พุตได้รับผลกระทบอย่างมากจากอินพุตเริ่มต้นเช่นจำนวนคลัสเตอร์ (ค่า k)

• ลำดับของข้อมูลจะมีผลอย่างมากต่อผลลัพธ์สุดท้าย

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

• การทำคลัสเตอร์จะไม่ดีหากคลัสเตอร์มีรูปทรงเรขาคณิตที่ซับซ้อน

การประยุกต์ใช้ K-means Clustering Algorithm

เป้าหมายหลักของการวิเคราะห์คลัสเตอร์คือ -

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

• คลัสเตอร์แล้วคาดการณ์ว่าจะสร้างโมเดลที่แตกต่างกันสำหรับกลุ่มย่อยที่แตกต่างกัน

เพื่อให้บรรลุเป้าหมายดังกล่าวข้างต้นการรวมกลุ่ม K-mean มีประสิทธิภาพดีพอ สามารถใช้ในแอพพลิเคชั่นต่อไปนี้ -

• การแบ่งส่วนตลาด

• การจัดกลุ่มเอกสาร

• การแบ่งส่วนภาพ

• การบีบอัดภาพ

• การแบ่งกลุ่มลูกค้า

• การวิเคราะห์แนวโน้มของข้อมูลแบบไดนามิก

ข้อมูลเบื้องต้นเกี่ยวกับ Mean-Shift Algorithm

ตามที่กล่าวไว้ก่อนหน้านี้เป็นอีกหนึ่งอัลกอริธึมการจัดกลุ่มที่มีประสิทธิภาพซึ่งใช้ในการเรียนรู้ที่ไม่มีผู้ดูแล ซึ่งแตกต่างจาก K-mean clustering ไม่ได้ตั้งสมมติฐานใด ๆ ด้วยเหตุนี้จึงเป็นอัลกอริทึมที่ไม่ใช่พารามิเตอร์

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

ความแตกต่างระหว่างอัลกอริทึม K-Means และ Mean-Shift คือในภายหลังไม่จำเป็นต้องระบุจำนวนคลัสเตอร์ล่วงหน้าเนื่องจากจำนวนคลัสเตอร์จะถูกกำหนดโดยข้อมูลอัลกอริทึม WRT

การทำงานของ Mean-Shift Algorithm

เราสามารถเข้าใจการทำงานของอัลกอริทึมการทำคลัสเตอร์ Mean-Shift ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ -

Step1 - ขั้นแรกเริ่มต้นด้วยจุดข้อมูลที่กำหนดให้กับคลัสเตอร์ของตนเอง

Step2 - ต่อไปอัลกอริทึมนี้จะคำนวณเซนทรอยด์

Step3 - ในขั้นตอนนี้จะมีการอัปเดตตำแหน่งของเซนทรอยด์ใหม่

Step4 - ตอนนี้กระบวนการจะวนซ้ำและย้ายไปยังบริเวณที่มีความหนาแน่นสูงขึ้น

Step5 - ในที่สุดมันจะหยุดลงเมื่อเซนทรอยด์มาถึงตำแหน่งจากที่ที่มันไม่สามารถเคลื่อนที่ต่อไปได้

การใช้งานใน Python

เป็นตัวอย่างง่ายๆในการทำความเข้าใจว่าอัลกอริทึม Mean-Shift ทำงานอย่างไร ในตัวอย่างนี้เราจะสร้างชุดข้อมูล 2D ที่มี 4 blobs ที่แตกต่างกันก่อนและหลังจากนั้นจะใช้อัลกอริทึม Mean-Shift เพื่อดูผลลัพธ์

%matplotlib inline
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
from sklearn.datasets.samples_generator import make_blobs
centers = [[3,3,3],[4,5,5],[3,10,10]]
X, _ = make_blobs(n_samples = 700, centers = centers, cluster_std = 0.5)
plt.scatter(X[:,0],X[:,1])
plt.show()

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 3)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
      marker=".",color='k', s=20, linewidths = 5, zorder=10)
plt.show()

เอาต์พุต

[[ 2.98462798 9.9733794 10.02629344]
[ 3.94758484 4.99122771 4.99349433]
[ 3.00788996 3.03851268 2.99183033]]
Estimated clusters: 3

ข้อดีและข้อเสีย

ข้อดี

ต่อไปนี้เป็นข้อดีบางประการของอัลกอริทึมการทำคลัสเตอร์ Mean-Shift -

• ไม่จำเป็นต้องตั้งสมมติฐานแบบจำลองใด ๆ เช่นเดียวกับในส่วนผสมของ K-mean หรือ Gaussian

• นอกจากนี้ยังสามารถจำลองคลัสเตอร์ที่ซับซ้อนซึ่งมีรูปร่างไม่นูน

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

• ไม่มีปัญหาของ minima ในท้องถิ่นเหมือนใน K-mean

• ไม่มีปัญหาที่เกิดจากค่าผิดปกติ

ข้อเสีย

ต่อไปนี้เป็นข้อเสียบางประการของอัลกอริทึมการทำคลัสเตอร์ Mean-Shift -

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

• เราไม่มีการควบคุมโดยตรงเกี่ยวกับจำนวนคลัสเตอร์ แต่ในบางแอปพลิเคชันเราต้องการคลัสเตอร์จำนวนเฉพาะ

• ไม่สามารถแยกความแตกต่างระหว่างโหมดที่มีความหมายและโหมดไร้ความหมาย

ข้อมูลเบื้องต้นเกี่ยวกับการจัดกลุ่มตามลำดับชั้น

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

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

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

ขั้นตอนในการทำคลัสเตอร์แบบลำดับชั้นแบบ Agglomerative

เราจะอธิบายการจัดกลุ่มตามลำดับชั้นที่ใช้มากที่สุดและมีความสำคัญเช่น agglomerative ขั้นตอนในการดำเนินการเดียวกันมีดังนี้ -

Step1- ถือว่าแต่ละจุดข้อมูลเป็นคลัสเตอร์เดียว ดังนั้นเราจะมีกลุ่ม K พูดตั้งแต่เริ่มต้น จำนวนจุดข้อมูลจะเป็น K เมื่อเริ่มต้น

Step2- ตอนนี้ในขั้นตอนนี้เราจำเป็นต้องสร้างคลัสเตอร์ขนาดใหญ่โดยการรวมจุดข้อมูลตู้เสื้อผ้าสองจุด ซึ่งจะส่งผลให้มีคลัสเตอร์ K-1 ทั้งหมด

Step3- ตอนนี้ในการสร้างกลุ่มเพิ่มเติมเราจำเป็นต้องเข้าร่วมกลุ่มตู้เสื้อผ้าสองกลุ่ม ซึ่งจะส่งผลให้มีคลัสเตอร์ K-2 ทั้งหมด

Step4 - ตอนนี้ในการสร้างคลัสเตอร์ขนาดใหญ่หนึ่งกลุ่มให้ทำซ้ำสามขั้นตอนข้างต้นจนกว่า K จะกลายเป็น 0 เช่นไม่มีจุดข้อมูลให้เข้าร่วมอีกต่อไป

Step5 - ในที่สุดหลังจากสร้างคลัสเตอร์ขนาดใหญ่ 1 กลุ่มแล้ว dendrograms จะถูกใช้เพื่อแบ่งออกเป็นหลายคลัสเตอร์ขึ้นอยู่กับปัญหา

บทบาทของ Dendrograms ใน Agglomerative Hierarchical Clustering

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

ตัวอย่าง 1

เพื่อทำความเข้าใจให้เราเริ่มต้นด้วยการนำเข้าไลบรารีที่จำเป็นดังต่อไปนี้ -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

ต่อไปเราจะพล็อตจุดข้อมูลที่เรานำมาใช้สำหรับตัวอย่างนี้ -

X = np.array([[7,8],[12,20],[17,19],[26,15],[32,37],[87,75],[73,85], [62,80],[73,60],[87,96],])
labels = range(1, 11)
plt.figure(figsize=(10, 7))
plt.subplots_adjust(bottom=0.1)
plt.scatter(X[:,0],X[:,1], label='True Position')
for label, x, y in zip(labels, X[:, 0], X[:, 1]):
   plt.annotate(label,xy=(x, y), xytext=(-3, 3),textcoords='offset points', ha='right', va='bottom')
plt.show()

จากแผนภาพด้านบนจะเห็นได้ง่ายมากว่าเรามีสองคลัสเตอร์ในจุดข้อมูล แต่ในข้อมูลจริงอาจมีคลัสเตอร์ได้หลายพันคลัสเตอร์ ต่อไปเราจะวางแผน dendrograms ของ datapoints ของเราโดยใช้ Scipy library -

from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt
linked = linkage(X, 'single')
labelList = range(1, 11)
plt.figure(figsize=(10, 7))
dendrogram(linked, orientation='top',labels=labelList, distance_sort='descending',show_leaf_counts=True)
plt.show()

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

ต่อไปเราต้องนำเข้าคลาสสำหรับการทำคลัสเตอร์และเรียกเมธอด fit_predict เพื่อทำนายคลัสเตอร์ เรากำลังนำเข้าคลาส AgglomerativeClustering ของไลบรารี sklearn.cluster -

from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
cluster.fit_predict(X)

จากนั้นลงจุดคลัสเตอร์ด้วยความช่วยเหลือของรหัสต่อไปนี้ -

plt.scatter(X[:,0],X[:,1], c=cluster.labels_, cmap='rainbow')

แผนภาพด้านบนแสดงทั้งสองคลัสเตอร์จากจุดข้อมูลของเรา

ตัวอย่าง 2

ตามที่เราเข้าใจแนวคิดของ dendrograms จากตัวอย่างง่ายๆที่กล่าวถึงข้างต้นให้เราไปยังอีกตัวอย่างหนึ่งที่เรากำลังสร้างกลุ่มของจุดข้อมูลในชุดข้อมูลโรคเบาหวานอินเดีย Pima โดยใช้การจัดกลุ่มตามลำดับชั้น -

import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import numpy as np
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
data.shape
(768, 9)
data.head()

slno.	preg	พลาส	ปธน	ผิวหนัง	ทดสอบ	มวล	Pedi	อายุ	ชั้นเรียน
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1

patient_data = data.iloc[:, 3:5].values
import scipy.cluster.hierarchy as shc
plt.figure(figsize=(10, 7))
plt.title("Patient Dendograms")
dend = shc.dendrogram(shc.linkage(data, method='ward'))

from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')
cluster.fit_predict(patient_data)
plt.figure(figsize=(10, 7))
plt.scatter(patient_data[:,0], patient_data[:,1], c=cluster.labels_, cmap='rainbow')

บทนำ

อัลกอริทึม K-near Neighbours (KNN) เป็นอัลกอริทึม ML ที่อยู่ภายใต้การดูแลซึ่งสามารถใช้ได้ทั้งการจำแนกประเภทและปัญหาการทำนายการถดถอย อย่างไรก็ตามส่วนใหญ่จะใช้สำหรับการจำแนกประเภทปัญหาการทำนายในอุตสาหกรรม คุณสมบัติสองประการต่อไปนี้จะกำหนด KNN ได้ดี -

• Lazy learning algorithm - KNN เป็นอัลกอริทึมการเรียนรู้ที่ขี้เกียจเนื่องจากไม่มีขั้นตอนการฝึกอบรมเฉพาะและใช้ข้อมูลทั้งหมดสำหรับการฝึกอบรมในขณะที่จำแนก

• Non-parametric learning algorithm - KNN ยังเป็นอัลกอริธึมการเรียนรู้ที่ไม่ใช่พารามิเตอร์เนื่องจากไม่ได้ถือว่าอะไรเกี่ยวกับข้อมูลพื้นฐาน

การทำงานของ KNN Algorithm

อัลกอริทึม K-near Neighbor (KNN) ใช้ 'คุณลักษณะความคล้ายคลึงกัน' เพื่อทำนายค่าของจุดข้อมูลใหม่ซึ่งหมายความว่าจุดข้อมูลใหม่จะได้รับการกำหนดค่าตามความใกล้เคียงกับจุดในชุดการฝึกอบรม เราสามารถเข้าใจการทำงานของมันได้ด้วยความช่วยเหลือของขั้นตอนต่อไปนี้ -

Step1- สำหรับการใช้อัลกอริทึมใด ๆ เราจำเป็นต้องมีชุดข้อมูล ดังนั้นในขั้นตอนแรกของ KNN เราต้องโหลดการฝึกอบรมและข้อมูลการทดสอบ

Step2- ต่อไปเราต้องเลือกค่า K คือจุดข้อมูลที่ใกล้ที่สุด K สามารถเป็นจำนวนเต็มเท่าใดก็ได้

Step3 - สำหรับแต่ละจุดในข้อมูลการทดสอบให้ทำดังต่อไปนี้ -

3.1- คำนวณระยะห่างระหว่างข้อมูลการทดสอบและข้อมูลการฝึกอบรมแต่ละแถวด้วยความช่วยเหลือของวิธีการใด ๆ ได้แก่ ระยะทางแบบยุคลิดแมนฮัตตันหรือแฮมมิง วิธีการคำนวณระยะทางที่ใช้บ่อยที่สุดคือแบบยุคลิด

3.2 - ตอนนี้ขึ้นอยู่กับค่าระยะทางเรียงลำดับจากน้อยไปมาก

3.3 - จากนั้นจะเลือกแถว K บนสุดจากอาร์เรย์ที่เรียงลำดับ

3.4 - ตอนนี้จะกำหนดคลาสให้กับจุดทดสอบตามคลาสที่พบบ่อยที่สุดของแถวเหล่านี้

Step4 - จบ

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างเพื่อทำความเข้าใจแนวคิดของ K และการทำงานของอัลกอริทึม KNN -

สมมติว่าเรามีชุดข้อมูลที่สามารถลงจุดได้ดังนี้ -

ตอนนี้เราต้องจำแนกจุดข้อมูลใหม่ด้วยจุดสีดำ (ที่จุด 60,60) เป็นชั้นสีน้ำเงินหรือสีแดง เราสมมติว่า K = 3 คือมันจะพบจุดข้อมูลที่ใกล้ที่สุดสามจุด จะแสดงในแผนภาพถัดไป -

เราจะเห็นในแผนภาพด้านบนเพื่อนบ้านที่ใกล้ที่สุดสามจุดของจุดข้อมูลที่มีจุดสีดำ ในสามคนนั้นสองคนอยู่ในคลาสสีแดงดังนั้นจุดสีดำจะถูกกำหนดในคลาสสีแดงด้วย

การใช้งานใน Python

อย่างที่เราทราบกันดีว่าอัลกอริทึม K-near Neighbor (KNN) สามารถใช้ได้ทั้งการจำแนกประเภทและการถดถอย ต่อไปนี้เป็นสูตรอาหารใน Python เพื่อใช้ KNN เป็นตัวจำแนกและ regressor -

KNN เป็นลักษณนาม

ขั้นแรกเริ่มต้นด้วยการนำเข้าแพ็คเกจ python ที่จำเป็น -

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

จากนั้นดาวน์โหลดชุดข้อมูลม่านตาจากเว็บลิงค์ดังต่อไปนี้ -

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

ต่อไปเราต้องกำหนดชื่อคอลัมน์ให้กับชุดข้อมูลดังนี้ -

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

ตอนนี้เราต้องอ่าน dataset ไปยัง dataframe ของแพนด้าดังนี้ -

dataset = pd.read_csv(path, names=headernames)
dataset.head()

slno.	sepal-length	sepal-width	petal-length	petal-width	Class
0	5.1	3.5	1.4	0.2	Iris-setosa
1	4.9	3.0	1.4	0.2	Iris-setosa
2	4.7	3.2	1.3	0.2	Iris-setosa
3	4.6	3.1	1.5	0.2	Iris-setosa
4	5.0	3.6	1.4	0.2	Iris-setosa

Data Preprocessing will be done with the help of following script lines −

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

Next, we will divide the data into train and test split. Following code will split the dataset into 60% training data and 40% of testing data −

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.40)

Next, data scaling will be done as follows −

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Next, train the model with the help of KNeighborsClassifier class of sklearn as follows −

from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=8)
classifier.fit(X_train, y_train)

At last we need to make prediction. It can be done with the help of following script −

y_pred = classifier.predict(X_test)

Next, print the results as follows −

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Output

Confusion Matrix:
[[21 0 0]
[ 0 16 0]
[ 0 7 16]]
Classification Report:
            precision      recall       f1-score       support
Iris-setosa       1.00        1.00         1.00          21
Iris-versicolor   0.70        1.00         0.82          16
Iris-virginica    1.00        0.70         0.82          23
micro avg         0.88        0.88         0.88          60
macro avg         0.90        0.90         0.88          60
weighted avg      0.92        0.88         0.88          60


Accuracy: 0.8833333333333333

KNN as Regressor

First, start with importing necessary Python packages −

import numpy as np
import pandas as pd

Next, download the iris dataset from its weblink as follows −

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

Next, we need to assign column names to the dataset as follows −

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

Now, we need to read dataset to pandas dataframe as follows −

data = pd.read_csv(url, names=headernames)
array = data.values
X = array[:,:2]
Y = array[:,2]
data.shape

output:(150, 5)

Next, import KNeighborsRegressor from sklearn to fit the model −

from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=10)
knnr.fit(X, y)

At last, we can find the MSE as follows −

print ("The MSE is:",format(np.power(y-knnr.predict(X),2).mean()))

Output

The MSE is: 0.12226666666666669

Pros and Cons of KNN

Pros

• It is very simple algorithm to understand and interpret.

• It is very useful for nonlinear data because there is no assumption about data in this algorithm.

• It is a versatile algorithm as we can use it for classification as well as regression.

• It has relatively high accuracy but there are much better supervised learning models than KNN.

Cons

• It is computationally a bit expensive algorithm because it stores all the training data.

• High memory storage required as compared to other supervised learning algorithms.

• Prediction is slow in case of big N.

• It is very sensitive to the scale of data as well as irrelevant features.

Applications of KNN

The following are some of the areas in which KNN can be applied successfully −

Banking System

KNN can be used in banking system to predict weather an individual is fit for loan approval? Does that individual have the characteristics similar to the defaulters one?

Calculating Credit Ratings

KNN algorithms can be used to find an individual’s credit rating by comparing with the persons having similar traits.

Politics

With the help of KNN algorithms, we can classify a potential voter into various classes like “Will Vote”, “Will not Vote”, “Will Vote to Party ‘Congress’, “Will Vote to Party ‘BJP’.

Other areas in which KNN algorithm can be used are Speech Recognition, Handwriting Detection, Image Recognition and Video Recognition.

There are various metrics which we can use to evaluate the performance of ML algorithms, classification as well as regression algorithms. We must carefully choose the metrics for evaluating ML performance because −

• How the performance of ML algorithms is measured and compared will be dependent entirely on the metric you choose.

• How you weight the importance of various characteristics in the result will be influenced completely by the metric you choose.

Performance Metrics for Classification Problems

We have discussed classification and its algorithms in the previous chapters. Here, we are going to discuss various performance metrics that can be used to evaluate predictions for classification problems.

Confusion Matrix

It is the easiest way to measure the performance of a classification problem where the output can be of two or more type of classes. A confusion matrix is nothing but a table with two dimensions viz. “Actual” and “Predicted” and furthermore, both the dimensions have “True Positives (TP)”, “True Negatives (TN)”, “False Positives (FP)”, “False Negatives (FN)” as shown below −

Explanation of the terms associated with confusion matrix are as follows −

• True Positives (TP) − It is the case when both actual class & predicted class of data point is 1.

• True Negatives (TN) − It is the case when both actual class & predicted class of data point is 0.

• False Positives (FP) − It is the case when actual class of data point is 0 & predicted class of data point is 1.

• False Negatives (FN) − It is the case when actual class of data point is 1 & predicted class of data point is 0.

We can use confusion_matrix function of sklearn.metrics to compute Confusion Matrix of our classification model.

Classification Accuracy

It is most common performance metric for classification algorithms. It may be defined as the number of correct predictions made as a ratio of all predictions made. We can easily calculate it by confusion matrix with the help of following formula −

$Accuracy =\frac{TP+TN}{+++}$

We can use accuracy_score function of sklearn.metrics to compute accuracy of our classification model.

Classification Report

This report consists of the scores of Precisions, Recall, F1 and Support. They are explained as follows −

Precision

Precision, used in document retrievals, may be defined as the number of correct documents returned by our ML model. We can easily calculate it by confusion matrix with the help of following formula −

$Precision=\frac{TP}{TP+FP}$

Recall or Sensitivity

Recall may be defined as the number of positives returned by our ML model. We can easily calculate it by confusion matrix with the help of following formula −

$Recall =\frac{TP}{TP+FN}$

Specificity

Specificity, in contrast to recall, may be defined as the number of negatives returned by our ML model. We can easily calculate it by confusion matrix with the help of following formula −

$Specificity =\frac{TN}{TN+FP}$

Support

Support may be defined as the number of samples of the true response that lies in each class of target values.

F1 Score

This score will give us the harmonic mean of precision and recall. Mathematically, F1 score is the weighted average of the precision and recall. The best value of F1 would be 1 and worst would be 0. We can calculate F1 score with the help of following formula −

= ∗ ( ∗ ) / ( + )

F1 score is having equal relative contribution of precision and recall.

We can use classification_report function of sklearn.metrics to get the classification report of our classification model.

AUC (Area Under ROC curve)

AUC (Area Under Curve)-ROC (Receiver Operating Characteristic) is a performance metric, based on varying threshold values, for classification problems. As name suggests, ROC is a probability curve and AUC measure the separability. In simple words, AUC-ROC metric will tell us about the capability of model in distinguishing the classes. Higher the AUC, better the model.

Mathematically, it can be created by plotting TPR (True Positive Rate) i.e. Sensitivity or recall vs FPR (False Positive Rate) i.e. 1-Specificity, at various threshold values. Following is the graph showing ROC, AUC having TPR at y-axis and FPR at x-axis −

We can use roc_auc_score function of sklearn.metrics to compute AUC-ROC.

LOGLOSS (Logarithmic Loss)

It is also called Logistic regression loss or cross-entropy loss. It basically defined on probability estimates and measures the performance of a classification model where the input is a probability value between 0 and 1. It can be understood more clearly by differentiating it with accuracy. As we know that accuracy is the count of predictions (predicted value = actual value) in our model whereas Log Loss is the amount of uncertainty of our prediction based on how much it varies from the actual label. With the help of Log Loss value, we can have more accurate view of the performance of our model. We can use log_loss function of sklearn.metrics to compute Log Loss.

Example

The following is a simple recipe in Python which will give us an insight about how we can use the above explained performance metrics on binary classification model −

from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
from sklearn.metrics import log_loss
X_actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
Y_predic = [1, 0, 1, 1, 1, 0, 1, 1, 0, 0]
results = confusion_matrix(X_actual, Y_predic)
print ('Confusion Matrix :')
print(results)
print ('Accuracy Score is',accuracy_score(X_actual, Y_predic))
print ('Classification Report : ')
print (classification_report(X_actual, Y_predic))
print('AUC-ROC:',roc_auc_score(X_actual, Y_predic))
print('LOGLOSS Value is',log_loss(X_actual, Y_predic))

Output

Confusion Matrix :
[[3 3]
[1 3]]
Accuracy Score is 0.6
Classification Report :
            precision      recall      f1-score       support
      0       0.75          0.50      0.60           6
      1       0.50          0.75      0.60           4
micro avg     0.60          0.60      0.60           10
macro avg     0.62          0.62      0.60           10
weighted avg  0.65          0.60      0.60           10
AUC-ROC:  0.625
LOGLOSS Value is 13.815750437193334

Performance Metrics for Regression Problems

We have discussed regression and its algorithms in previous chapters. Here, we are going to discuss various performance metrics that can be used to evaluate predictions for regression problems.

Mean Absolute Error (MAE)

It is the simplest error metric used in regression problems. It is basically the sum of average of the absolute difference between the predicted and actual values. In simple words, with MAE, we can get an idea of how wrong the predictions were. MAE does not indicate the direction of the model i.e. no indication about underperformance or overperformance of the model. The following is the formula to calculate MAE −

$MAE = \frac{1}{n}\sum|Y -\hat{Y}|$

Here, =Actual Output Values

And $\hat{Y}$= Predicted Output Values.

We can use mean_absolute_error function of sklearn.metrics to compute MAE.

Mean Square Error (MSE)

MSE is like the MAE, but the only difference is that the it squares the difference of actual and predicted output values before summing them all instead of using the absolute value. The difference can be noticed in the following equation −

$MSE = \frac{1}{n}\sum(Y -\hat{Y})$

Here, =Actual Output Values

And $\hat{Y}$ = Predicted Output Values.

We can use mean_squared_error function of sklearn.metrics to compute MSE.

R Squared (R²)

R Squared metric is generally used for explanatory purpose and provides an indication of the goodness or fit of a set of predicted output values to the actual output values. The following formula will help us understanding it −

$R^{2} = 1 -\frac{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\hat{Y_{i}})^2}{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\bar{Y_i)^2}}$

In the above equation, numerator is MSE and the denominator is the variance in values.

We can use r2_score function of sklearn.metrics to compute R squared value.

Example

The following is a simple recipe in Python which will give us an insight about how we can use the above explained performance metrics on regression model −

from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
X_actual = [5, -1, 2, 10]
Y_predic = [3.5, -0.9, 2, 9.9]
print ('R Squared =',r2_score(X_actual, Y_predic))
print ('MAE =',mean_absolute_error(X_actual, Y_predic))
print ('MSE =',mean_squared_error(X_actual, Y_predic))

Output

R Squared = 0.9656060606060606
MAE = 0.42499999999999993
MSE = 0.5674999999999999

Introduction

In order to execute and produce results successfully, a machine learning model must automate some standard workflows. The process of automate these standard workflows can be done with the help of Scikit-learn Pipelines. From a data scientist’s perspective, pipeline is a generalized, but very important concept. It basically allows data flow from its raw format to some useful information. The working of pipelines can be understood with the help of following diagram −

The blocks of ML pipelines are as follows −

Data ingestion − As the name suggests, it is the process of importing the data for use in ML project. The data can be extracted in real time or batches from single or multiple systems. It is one of the most challenging steps because the quality of data can affect the whole ML model.

Data Preparation − After importing the data, we need to prepare data to be used for our ML model. Data preprocessing is one of the most important technique of data preparation.

ML Model Training − Next step is to train our ML model. We have various ML algorithms like supervised, unsupervised, reinforcement to extract the features from data, and make predictions.

Model Evaluation − Next, we need to evaluate the ML model. In case of AutoML pipeline, ML model can be evaluated with the help of various statistical methods and business rules.

ML Model retraining − In case of AutoML pipeline, it is not necessary that the first model is best one. The first model is considered as a baseline model and we can train it repeatably to increase model’s accuracy.

Deployment − At last, we need to deploy the model. This step involves applying and migrating the model to business operations for their use.

Challenges Accompanying ML Pipelines

In order to create ML pipelines, data scientists face many challenges. These challenges fall into the following three categories −

Quality of Data

The success of any ML model depends heavily on the quality of data. If the data we are providing to ML model is not accurate, reliable and robust, then we are going to end with wrong or misleading output.

Data Reliability

Another challenge associated with ML pipelines is the reliability of data we are providing to the ML model. As we know, there can be various sources from which data scientist can acquire data but to get the best results, it must be assured that the data sources are reliable and trusted.

Data Accessibility

To get the best results out of ML pipelines, the data itself must be accessible which requires consolidation, cleansing and curation of data. As a result of data accessibility property, metadata will be updated with new tags.

Modelling ML Pipeline and Data Preparation

Data leakage, happening from training dataset to testing dataset, is an important issue for data scientist to deal with while preparing data for ML model. Generally, at the time of data preparation, data scientist uses techniques like standardization or normalization on entire dataset before learning. But these techniques cannot help us from the leakage of data because the training dataset would have been influenced by the scale of the data in the testing dataset.

By using ML pipelines, we can prevent this data leakage because pipelines ensure that data preparation like standardization is constrained to each fold of our cross-validation procedure.

Example

The following is an example in Python that demonstrate data preparation and model evaluation workflow. For this purpose, we are using Pima Indian Diabetes dataset from Sklearn. First, we will be creating pipeline that standardized the data. Then a Linear Discriminative analysis model will be created and at last the pipeline will be evaluated using 10-fold cross validation.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values

Next, we will create a pipeline with the help of the following code −

estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('lda', LinearDiscriminantAnalysis()))
model = Pipeline(estimators)

At last, we are going to evaluate this pipeline and output its accuracy as follows −

kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7790148448043184

The above output is the summary of accuracy of the setup on the dataset.

Modelling ML Pipeline and Feature Extraction

Data leakage can also happen at feature extraction step of ML model. That is why feature extraction procedures should also be restricted to stop data leakage in our training dataset. As in the case of data preparation, by using ML pipelines, we can prevent this data leakage also. FeatureUnion, a tool provided by ML pipelines can be used for this purpose.

Example

The following is an example in Python that demonstrates feature extraction and model evaluation workflow. For this purpose, we are using Pima Indian Diabetes dataset from Sklearn.

First, 3 features will be extracted with PCA (Principal Component Analysis). Then, 6 features will be extracted with Statistical Analysis. After feature extraction, result of multiple feature selection and extraction procedures will be combined by using

FeatureUnion tool. At last, a Logistic Regression model will be created, and the pipeline will be evaluated using 10-fold cross validation.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values

Next, feature union will be created as follows −

features = []
features.append(('pca', PCA(n_components=3)))
features.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(features)

Next, pipeline will be creating with the help of following script lines −

estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)

At last, we are going to evaluate this pipeline and output its accuracy as follows −

kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7789811066126855

The above output is the summary of accuracy of the setup on the dataset.

Performance Improvement with Ensembles

Ensembles can give us boost in the machine learning result by combining several models. Basically, ensemble models consist of several individually trained supervised learning models and their results are merged in various ways to achieve better predictive performance compared to a single model. Ensemble methods can be divided into following two groups −

Sequential ensemble methods

As the name implies, in these kind of ensemble methods, the base learners are generated sequentially. The motivation of such methods is to exploit the dependency among base learners.

Parallel ensemble methods

As the name implies, in these kind of ensemble methods, the base learners are generated in parallel. The motivation of such methods is to exploit the independence among base learners.

Ensemble Learning Methods

The following are the most popular ensemble learning methods i.e. the methods for combining the predictions from different models −

Bagging

The term bagging is also known as bootstrap aggregation. In bagging methods, ensemble model tries to improve prediction accuracy and decrease model variance by combining predictions of individual models trained over randomly generated training samples. The final prediction of ensemble model will be given by calculating the average of all predictions from the individual estimators. One of the best examples of bagging methods are random forests.

Boosting

In boosting method, the main principle of building ensemble model is to build it incrementally by training each base model estimator sequentially. As the name suggests, it basically combine several week base learners, trained sequentially over multiple iterations of training data, to build powerful ensemble. During the training of week base learners, higher weights are assigned to those learners which were misclassified earlier. The example of boosting method is AdaBoost.

Voting

In this ensemble learning model, multiple models of different types are built and some simple statistics, like calculating mean or median etc., are used to combine the predictions. This prediction will serve as the additional input for training to make the final prediction.

Bagging Ensemble Algorithms

The following are three bagging ensemble algorithms −

Bagged Decision Tree

As we know that bagging ensemble methods work well with the algorithms that have high variance and, in this concern, the best one is decision tree algorithm. In the following Python recipe, we are going to build bagged decision tree ensemble model by using BaggingClassifier function of sklearn with DecisionTreeClasifier (a classification & regression trees algorithm) on Pima Indians diabetes dataset.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

Now, we need to load the Pima diabetes dataset as we did in the previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Next, give the input for 10-fold cross validation as follows −

seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()

We need to provide the number of trees we are going to build. Here we are building 150 trees −

num_trees = 150

Next, build the model with the help of following script −

model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)

Calculate and print the result as follows −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7733766233766234

The output above shows that we got around 77% accuracy of our bagged decision tree classifier model.

Random Forest

It is an extension of bagged decision trees. For individual classifiers, the samples of training dataset are taken with replacement, but the trees are constructed in such a way that reduces the correlation between them. Also, a random subset of features is considered to choose each split point rather than greedily choosing the best split point in construction of each tree.

In the following Python recipe, we are going to build bagged random forest ensemble model by using RandomForestClassifier class of sklearn on Pima Indians diabetes dataset.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Next, give the input for 10-fold cross validation as follows −

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

We need to provide the number of trees we are going to build. Here we are building 150 trees with split points chosen from 5 features −

num_trees = 150
max_features = 5

Next, build the model with the help of following script −

model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)

Calculate and print the result as follows −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7629357484620642

The output above shows that we got around 76% accuracy of our bagged random forest classifier model.

Extra Trees

It is another extension of bagged decision tree ensemble method. In this method, the random trees are constructed from the samples of the training dataset.

In the following Python recipe, we are going to build extra tree ensemble model by using ExtraTreesClassifier class of sklearn on Pima Indians diabetes dataset.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Next, give the input for 10-fold cross validation as follows −

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

We need to provide the number of trees we are going to build. Here we are building 150 trees with split points chosen from 5 features −

num_trees = 150
max_features = 5

Next, build the model with the help of following script −

model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

Calculate and print the result as follows −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7551435406698566

The output above shows that we got around 75.5% accuracy of our bagged extra trees classifier model.

Boosting Ensemble Algorithms

The followings are the two most common boosting ensemble algorithms −

AdaBoost

It is one the most successful boosting ensemble algorithm. The main key of this algorithm is in the way they give weights to the instances in dataset. Due to this the algorithm needs to pay less attention to the instances while constructing subsequent models.

In the following Python recipe, we are going to build Ada Boost ensemble model for classification by using AdaBoostClassifier class of sklearn on Pima Indians diabetes dataset.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Next, give the input for 10-fold cross validation as follows −

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

We need to provide the number of trees we are going to build. Here we are building 150 trees with split points chosen from 5 features −

num_trees = 50

Next, build the model with the help of following script −

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)

Calculate and print the result as follows −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7539473684210527

The output above shows that we got around 75% accuracy of our AdaBoost classifier ensemble model.

Stochastic Gradient Boosting

It is also called Gradient Boosting Machines. In the following Python recipe, we are going to build Stochastic Gradient Boostingensemble model for classification by using GradientBoostingClassifier class of sklearn on Pima Indians diabetes dataset.

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Next, give the input for 10-fold cross validation as follows −

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

We need to provide the number of trees we are going to build. Here we are building 150 trees with split points chosen from 5 features −

num_trees = 50

Next, build the model with the help of following script −

model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)

Calculate and print the result as follows −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7746582365003418

The output above shows that we got around 77.5% accuracy of our Gradient Boosting classifier ensemble model.

Voting Ensemble Algorithms

As discussed, voting first creates two or more standalone models from training dataset and then a voting classifier will wrap the model along with taking the average of the predictions of sub-model whenever needed new data.

In the following Python recipe, we are going to build Voting ensemble model for classification by using VotingClassifier class of sklearn on Pima Indians diabetes dataset. We are combining the predictions of logistic regression, Decision Tree classifier and SVM together for a classification problem as follows −

First, import the required packages as follows −

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier

Now, we need to load the Pima diabetes dataset as did in previous examples −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

จากนั้นให้ป้อนข้อมูลสำหรับการตรวจสอบความถูกต้องข้าม 10 เท่าดังนี้ -

kfold = KFold(n_splits=10, random_state=7)

ต่อไปเราต้องสร้างโมเดลย่อยดังนี้ -

estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))

ตอนนี้สร้างโมเดลชุดการลงคะแนนโดยรวมการคาดการณ์ของโมเดลย่อยที่สร้างไว้ข้างต้น

ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())

เอาต์พุต

0.7382262474367738

ผลลัพธ์ด้านบนแสดงให้เห็นว่าเรามีความแม่นยำประมาณ 74% ของแบบจำลองชุดลักษณนามการลงคะแนนของเรา

การปรับปรุงประสิทธิภาพด้วยการปรับอัลกอริทึม

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

ในที่นี้เราจะพูดถึงวิธีการบางอย่างในการปรับแต่งพารามิเตอร์อัลกอริทึมที่จัดทำโดย Python Scikit-learn

การปรับแต่งพารามิเตอร์การค้นหาตาราง

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

ตัวอย่าง

ในสูตร Python ต่อไปนี้เราจะทำการค้นหาแบบกริดโดยใช้คลาส GridSearchCV ของ sklearn สำหรับการประเมินค่าอัลฟาต่างๆสำหรับอัลกอริธึม Ridge Regression บนชุดข้อมูลเบาหวาน Pima Indians

ขั้นแรกให้นำเข้าแพ็คเกจที่ต้องการดังต่อไปนี้ -

import numpy
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV

ตอนนี้เราต้องโหลดชุดข้อมูล Pima diabetes ตามตัวอย่างก่อนหน้านี้ -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

จากนั้นประเมินค่าอัลฟาต่างๆดังนี้ -

alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0])
param_grid = dict(alpha=alphas)

ตอนนี้เราต้องใช้การค้นหาแบบกริดกับแบบจำลองของเรา -

model = Ridge()
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid.fit(X, Y)

พิมพ์ผลลัพธ์ด้วยบรรทัดสคริปต์ต่อไปนี้ -

print(grid.best_score_)
print(grid.best_estimator_.alpha)

เอาต์พุต

0.2796175593129722
1.0

ผลลัพธ์ข้างต้นทำให้เราได้คะแนนที่เหมาะสมที่สุดและชุดของพารามิเตอร์ในตารางที่ได้คะแนนนั้น ค่าอัลฟาในกรณีนี้คือ 1.0

การปรับแต่งพารามิเตอร์การค้นหาแบบสุ่ม

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

ตัวอย่าง

ในสูตร Python ต่อไปนี้เราจะทำการค้นหาแบบสุ่มโดยใช้คลาส RandomizedSearchCV ของ sklearn สำหรับการประเมินค่าอัลฟาที่แตกต่างกันระหว่าง 0 ถึง 1 สำหรับอัลกอริธึม Ridge Regression บนชุดข้อมูลเบาหวาน Pima Indians

ขั้นแรกให้นำเข้าแพ็คเกจที่ต้องการดังต่อไปนี้ -

import numpy
from pandas import read_csv
from scipy.stats import uniform
from sklearn.linear_model import Ridge
from sklearn.model_selection import RandomizedSearchCV

ตอนนี้เราต้องโหลดชุดข้อมูล Pima diabetes ตามตัวอย่างก่อนหน้านี้ -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

จากนั้นประเมินค่าอัลฟาต่างๆบนอัลกอริทึมการถดถอยสันเขาดังนี้ -

param_grid = {'alpha': uniform()}
model = Ridge()
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=50,
random_state=7)
random_search.fit(X, Y)

พิมพ์ผลลัพธ์ด้วยบรรทัดสคริปต์ต่อไปนี้ -

print(random_search.best_score_)
print(random_search.best_estimator_.alpha)

เอาต์พุต

0.27961712703051084
0.9779895119966027
0.9779895119966027

ผลลัพธ์ข้างต้นทำให้เราได้คะแนนที่เหมาะสมเช่นเดียวกับการค้นหาตาราง