AI พร้อม Python - คู่มือฉบับย่อ
นับตั้งแต่มีการประดิษฐ์คอมพิวเตอร์หรือเครื่องจักรความสามารถในการทำงานต่าง ๆ ได้รับการเติบโตอย่างทวีคูณ มนุษย์ได้พัฒนาพลังของระบบคอมพิวเตอร์ในแง่ของโดเมนการทำงานที่หลากหลายความเร็วที่เพิ่มขึ้นและการลดขนาดตามเวลา
สาขาวิทยาศาสตร์คอมพิวเตอร์ชื่อปัญญาประดิษฐ์มุ่งสร้างคอมพิวเตอร์หรือเครื่องจักรที่ฉลาดเหมือนมนุษย์
แนวคิดพื้นฐานของปัญญาประดิษฐ์ (AI)
John McCarthy บิดาแห่งปัญญาประดิษฐ์กล่าวว่า“ วิทยาศาสตร์และวิศวกรรมในการสร้างเครื่องจักรอัจฉริยะโดยเฉพาะโปรแกรมคอมพิวเตอร์อัจฉริยะ”
ปัญญาประดิษฐ์เป็นวิธีการสร้างคอมพิวเตอร์หุ่นยนต์ที่ควบคุมด้วยคอมพิวเตอร์หรือซอฟต์แวร์ที่คิดอย่างชาญฉลาดในลักษณะเดียวกับที่มนุษย์ฉลาดคิด AI ทำได้โดยการศึกษาวิธีคิดของสมองมนุษย์และวิธีที่มนุษย์เรียนรู้ตัดสินใจและทำงานในขณะที่พยายามแก้ปัญหาจากนั้นใช้ผลการศึกษานี้เป็นพื้นฐานในการพัฒนาซอฟต์แวร์และระบบอัจฉริยะ
ในขณะที่ใช้ประโยชน์จากพลังของระบบคอมพิวเตอร์ความอยากรู้อยากเห็นของมนุษย์ทำให้เขาสงสัยว่า“ เครื่องจักรสามารถคิดและทำตัวเหมือนมนุษย์ได้หรือไม่”
ดังนั้นการพัฒนา AI จึงเริ่มต้นด้วยความตั้งใจที่จะสร้างความฉลาดที่คล้ายกันในเครื่องจักรที่เราพบและถือว่ามีความเป็นมนุษย์สูง
ความจำเป็นของการเรียนรู้ AI
อย่างที่เราทราบกันดีว่า AI ใฝ่หาการสร้างเครื่องจักรที่ฉลาดเหมือนมนุษย์ มีเหตุผลมากมายที่เราควรศึกษา AI เหตุผลมีดังนี้ -
AI สามารถเรียนรู้ผ่านข้อมูล
ในชีวิตประจำวันของเราเราจัดการกับข้อมูลจำนวนมากและสมองของมนุษย์ไม่สามารถติดตามข้อมูลจำนวนมากได้ นั่นคือเหตุผลที่เราต้องทำให้สิ่งต่างๆเป็นไปโดยอัตโนมัติ สำหรับการทำงานอัตโนมัติเราต้องศึกษา AI เพราะสามารถเรียนรู้จากข้อมูลและสามารถทำงานซ้ำ ๆ ได้อย่างแม่นยำและไม่เหนื่อย
AI สามารถสอนตัวเองได้
จำเป็นมากที่ระบบควรสอนตัวเองเนื่องจากข้อมูลมีการเปลี่ยนแปลงอยู่ตลอดเวลาและความรู้ที่ได้มาจากข้อมูลดังกล่าวจะต้องได้รับการปรับปรุงอย่างต่อเนื่อง เราสามารถใช้ AI เพื่อตอบสนองจุดประสงค์นี้ได้เนื่องจากระบบที่เปิดใช้งาน AI สามารถสอนตัวเองได้
AI สามารถตอบสนองแบบเรียลไทม์
ปัญญาประดิษฐ์ด้วยความช่วยเหลือของโครงข่ายประสาทเทียมสามารถวิเคราะห์ข้อมูลได้ลึกขึ้น เนื่องจากความสามารถนี้ AI สามารถคิดและตอบสนองต่อสถานการณ์ที่เป็นไปตามเงื่อนไขแบบเรียลไทม์
AI บรรลุความแม่นยำ
ด้วยความช่วยเหลือของเครือข่ายประสาทเทียมที่ล้ำลึก AI สามารถบรรลุความแม่นยำอย่างมาก AI ช่วยในด้านการแพทย์ในการวินิจฉัยโรคเช่นมะเร็งจาก MRI ของผู้ป่วย
AI สามารถจัดระเบียบข้อมูลเพื่อให้ได้ประโยชน์สูงสุด
ข้อมูลเป็นทรัพย์สินทางปัญญาสำหรับระบบที่ใช้อัลกอริทึมการเรียนรู้ด้วยตนเอง เราต้องการ AI ในการจัดทำดัชนีและจัดระเบียบข้อมูลในลักษณะที่ให้ผลลัพธ์ที่ดีที่สุดเสมอ
ทำความเข้าใจกับข่าวกรอง
AI สามารถสร้างระบบอัจฉริยะได้ เราจำเป็นต้องเข้าใจแนวคิดของความฉลาดเพื่อที่สมองของเราจะสามารถสร้างระบบความฉลาดอื่นได้เช่นเดียวกับตัวมันเอง
Intelligence คืออะไร?
ความสามารถของระบบในการคำนวณเหตุผลรับรู้ความสัมพันธ์และการเปรียบเทียบเรียนรู้จากประสบการณ์จัดเก็บและดึงข้อมูลจากหน่วยความจำแก้ปัญหาเข้าใจความคิดที่ซับซ้อนใช้ภาษาธรรมชาติอย่างคล่องแคล่วจำแนกสรุปและปรับสถานการณ์ใหม่
ประเภทของข่าวกรอง
ตามที่โฮเวิร์ดการ์ดเนอร์นักจิตวิทยาพัฒนาการชาวอเมริกันได้อธิบายไว้ว่าหน่วยสืบราชการลับมีหลายรูปแบบ -
ซีเนียร์ No | ข่าวกรองและคำอธิบาย | ตัวอย่าง |
---|---|---|
1 | Linguistic intelligence ความสามารถในการพูดรับรู้และใช้กลไกของการออกเสียง (เสียงพูด) ไวยากรณ์ (ไวยากรณ์) และความหมาย (ความหมาย) |
ผู้บรรยาย, Orators |
2 | Musical intelligence ความสามารถในการสร้างสื่อสารและเข้าใจความหมายที่เกิดจากเสียงความเข้าใจระดับเสียงจังหวะ |
นักดนตรีนักร้องนักแต่งเพลง |
3 | Logical-mathematical intelligence ความสามารถในการใช้และเข้าใจความสัมพันธ์ในกรณีที่ไม่มีการกระทำหรือวัตถุ ยังเป็นความสามารถในการเข้าใจความคิดที่ซับซ้อนและเป็นนามธรรม |
นักคณิตศาสตร์นักวิทยาศาสตร์ |
4 | Spatial intelligence ความสามารถในการรับรู้ข้อมูลภาพหรือเชิงพื้นที่เปลี่ยนแปลงและสร้างภาพใหม่โดยไม่ต้องอ้างอิงถึงวัตถุสร้างภาพ 3 มิติและเพื่อเคลื่อนย้ายและหมุน |
ผู้อ่านแผนที่นักบินอวกาศนักฟิสิกส์ |
5 | Bodily-Kinesthetic intelligence ความสามารถในการใช้ร่างกายทั้งหมดหรือบางส่วนในการแก้ปัญหาหรือผลิตภัณฑ์แฟชั่นควบคุมทักษะยนต์ที่ละเอียดและหยาบและจัดการกับวัตถุ |
ผู้เล่นนักเต้น |
6 | Intra-personal intelligence ความสามารถในการแยกแยะระหว่างความรู้สึกเจตนาและแรงจูงใจของตนเอง |
กัวตัมพุทธะ |
7 | Interpersonal intelligence ความสามารถในการรับรู้และสร้างความแตกต่างท่ามกลางความรู้สึกความเชื่อและความตั้งใจของคนอื่น |
นักสื่อสารมวลชนผู้สัมภาษณ์ |
คุณสามารถพูดได้ว่าเครื่องจักรหรือระบบมีความฉลาดเทียมเมื่อมีความฉลาดอย่างน้อยหนึ่งอย่างหรือทั้งหมดอยู่ในนั้น
Intelligence ประกอบด้วยอะไรบ้าง?
ความฉลาดนั้นจับต้องไม่ได้ ประกอบด้วย -
- Reasoning
- Learning
- การแก้ปัญหา
- Perception
- ความฉลาดทางภาษา
ให้เราดูส่วนประกอบทั้งหมดสั้น ๆ -
การใช้เหตุผล
เป็นชุดของกระบวนการที่ช่วยให้เราสามารถจัดเตรียมพื้นฐานสำหรับการตัดสินการตัดสินใจและการคาดคะเน มีสองประเภทกว้าง ๆ -
การให้เหตุผลโดยอุปนัย | การให้เหตุผลแบบนิรนัย |
---|---|
ดำเนินการสังเกตเฉพาะเพื่อสร้างข้อความทั่วไปอย่างกว้าง ๆ | เริ่มต้นด้วยคำชี้แจงทั่วไปและตรวจสอบความเป็นไปได้ในการบรรลุข้อสรุปเชิงตรรกะที่เฉพาะเจาะจง |
แม้ว่าสถานที่ทั้งหมดจะเป็นจริงในคำแถลง แต่การให้เหตุผลแบบอุปนัยก็ช่วยให้ข้อสรุปเป็นเท็จได้ | หากสิ่งที่เป็นจริงในชั้นเรียนโดยทั่วไปก็เป็นความจริงสำหรับสมาชิกทุกคนในชั้นเรียนนั้น |
Example - "นิต้าเป็นครูนิต้าตั้งใจเรียนเพราะฉะนั้นครูทุกคนตั้งใจเรียน" | Example - "ผู้หญิงทุกคนที่อายุมากกว่า 60 ปีเป็นยายชาลินีอายุ 65 ปีดังนั้นชาลินีจึงเป็นยาย" |
การเรียนรู้ - ล
ความสามารถในการเรียนรู้นั้นมีอยู่ในมนุษย์สัตว์บางชนิดและระบบที่เปิดใช้งาน AI การเรียนรู้แบ่งออกเป็นดังนี้ -
การเรียนรู้ด้วยเสียง
เป็นการเรียนรู้โดยการฟังและการได้ยิน ตัวอย่างเช่นนักเรียนฟังเสียงบรรยายที่บันทึกไว้
การเรียนรู้เป็นตอน ๆ
เรียนรู้โดยการจดจำลำดับเหตุการณ์ที่ได้พบเห็นหรือมีประสบการณ์ นี่เป็นเส้นตรงและเป็นระเบียบ
การเรียนรู้ด้วยมอเตอร์
เป็นการเรียนรู้โดยการเคลื่อนไหวของกล้ามเนื้ออย่างแม่นยำ ตัวอย่างเช่นการหยิบสิ่งของการเขียนเป็นต้น
การเรียนรู้เชิงสังเกต
เรียนรู้โดยการดูและเลียนแบบผู้อื่น ตัวอย่างเช่นเด็กพยายามเรียนรู้โดยเลียนแบบพ่อแม่
การเรียนรู้เชิงรับรู้
เป็นการเรียนรู้ที่จะรับรู้สิ่งเร้าที่เราเคยเห็นมาก่อน ตัวอย่างเช่นการระบุและจัดประเภทของวัตถุและสถานการณ์
การเรียนรู้เชิงสัมพันธ์
มันเกี่ยวข้องกับการเรียนรู้ที่จะแยกความแตกต่างระหว่างสิ่งเร้าต่างๆบนพื้นฐานของคุณสมบัติเชิงสัมพันธ์มากกว่าคุณสมบัติที่แน่นอน ตัวอย่างเช่นการใส่เกลือ 'น้อยกว่า' ในเวลาปรุงมันฝรั่งที่มีรสเค็มเมื่อปรุงด้วยการเติมเกลือหนึ่งช้อนโต๊ะ
Spatial Learning - เป็นการเรียนรู้ผ่านสิ่งเร้าทางสายตาเช่นภาพสีแผนที่ ฯลฯ ตัวอย่างเช่นบุคคลสามารถสร้างแผนงานในใจก่อนที่จะไปตามถนนจริง
Stimulus-Response Learning- เป็นการเรียนรู้ที่จะแสดงพฤติกรรมเฉพาะเมื่อมีสิ่งกระตุ้นบางอย่างเกิดขึ้น ตัวอย่างเช่นสุนัขยกหูขึ้นเมื่อได้ยินเสียงกริ่งประตู
การแก้ปัญหา
เป็นกระบวนการที่คนรับรู้และพยายามหาทางออกที่ต้องการจากสถานการณ์ปัจจุบันโดยใช้เส้นทางบางอย่างซึ่งถูกขัดขวางโดยอุปสรรคที่ทราบหรือไม่รู้จัก
การแก้ปัญหายังรวมถึง decision makingซึ่งเป็นกระบวนการในการเลือกทางเลือกที่เหมาะสมที่สุดจากทางเลือกหลายทางเพื่อไปสู่เป้าหมายที่ต้องการ
การรับรู้
เป็นกระบวนการในการรับตีความคัดเลือกและจัดระเบียบข้อมูลทางประสาทสัมผัส
การรับรู้ถือว่า sensing. ในมนุษย์การรับรู้ได้รับความช่วยเหลือจากอวัยวะรับสัมผัส ในโดเมนของ AI กลไกการรับรู้จะทำให้ข้อมูลที่เซ็นเซอร์ได้รับมารวมกันในลักษณะที่มีความหมาย
ความฉลาดทางภาษา
เป็นความสามารถในการใช้เข้าใจพูดและเขียนภาษาพูดและภาษาเขียน เป็นสิ่งสำคัญในการสื่อสารระหว่างบุคคล
สิ่งที่เกี่ยวข้องกับ AI
ปัญญาประดิษฐ์เป็นพื้นที่การศึกษามากมาย สาขาวิชานี้ช่วยในการค้นหาวิธีแก้ปัญหาในโลกแห่งความเป็นจริง
ตอนนี้ให้เราดูสาขาการศึกษาต่างๆภายใน AI -
การเรียนรู้ของเครื่อง
เป็นหนึ่งในสาขา AI ที่ได้รับความนิยมมากที่สุด แนวคิดพื้นฐานของเอกสารนี้คือการทำให้แมชชีนเลิร์นนิงจากข้อมูลซึ่งมนุษย์สามารถเรียนรู้จากประสบการณ์ของเขา / เธอได้ ประกอบด้วยแบบจำลองการเรียนรู้บนพื้นฐานของการคาดการณ์ที่สามารถทำได้โดยใช้ข้อมูลที่ไม่รู้จัก
ตรรกะ
เป็นสาขาการศึกษาที่สำคัญอีกแขนงหนึ่งซึ่งใช้ตรรกะทางคณิตศาสตร์ในการสั่งงานโปรแกรมคอมพิวเตอร์ ประกอบด้วยกฎและข้อเท็จจริงเพื่อดำเนินการจับคู่รูปแบบการวิเคราะห์ความหมาย ฯลฯ
กำลังค้นหา
สาขาวิชานี้ใช้โดยทั่วไปในเกมเช่นหมากรุก, tic-tac-toe อัลกอริทึมการค้นหาเป็นทางออกที่ดีที่สุดหลังจากค้นหาพื้นที่ค้นหาทั้งหมด
โครงข่ายประสาทเทียม
นี่คือเครือข่ายของระบบคอมพิวเตอร์ที่มีประสิทธิภาพซึ่งเป็นธีมหลักที่ยืมมาจากการเปรียบเทียบเครือข่ายประสาททางชีววิทยา ANN สามารถใช้ในวิทยาการหุ่นยนต์การรู้จำเสียงการประมวลผลคำพูด ฯลฯ
อัลกอริทึมทางพันธุกรรม
ขั้นตอนวิธีทางพันธุกรรมช่วยในการแก้ปัญหาด้วยความช่วยเหลือของโปรแกรมมากกว่าหนึ่งโปรแกรม ผลลัพธ์จะขึ้นอยู่กับการเลือกสิ่งที่เหมาะสมที่สุด
การเป็นตัวแทนความรู้
เป็นสาขาวิชาด้วยความช่วยเหลือซึ่งเราสามารถแสดงข้อเท็จจริงด้วยวิธีที่เครื่องจักรที่เข้าใจได้กับเครื่องจักร ยิ่งแสดงความรู้ได้อย่างมีประสิทธิภาพ ระบบก็จะยิ่งฉลาดมากขึ้น
การประยุกต์ใช้ AI
ในส่วนนี้เราจะเห็นช่องต่างๆที่ AI รองรับ -
การเล่นเกม
AI มีบทบาทสำคัญในเกมเชิงกลยุทธ์เช่นหมากรุกโป๊กเกอร์ทิคแทคโทเป็นต้นซึ่งเครื่องจักรสามารถคิดตำแหน่งที่เป็นไปได้จำนวนมากโดยอาศัยความรู้เชิงฮิวริสติก
การประมวลผลภาษาธรรมชาติ
เป็นไปได้ที่จะโต้ตอบกับคอมพิวเตอร์ที่เข้าใจภาษาธรรมชาติที่มนุษย์พูด
ระบบผู้เชี่ยวชาญ
มีแอพพลิเคชั่นบางตัวที่รวมเครื่องจักรซอฟต์แวร์และข้อมูลพิเศษเพื่อให้เหตุผลและให้คำปรึกษา พวกเขาให้คำอธิบายและคำแนะนำแก่ผู้ใช้
วิชั่นซิสเต็มส์
ระบบเหล่านี้เข้าใจตีความและเข้าใจอินพุตภาพบนคอมพิวเตอร์ ตัวอย่างเช่น,
เครื่องบินสอดแนมถ่ายภาพซึ่งใช้เพื่อหาข้อมูลเชิงพื้นที่หรือแผนที่ของพื้นที่
แพทย์ใช้ระบบผู้เชี่ยวชาญทางคลินิกในการวินิจฉัยผู้ป่วย
ตำรวจใช้ซอฟต์แวร์คอมพิวเตอร์ที่สามารถจดจำใบหน้าของอาชญากรพร้อมกับภาพที่จัดเก็บไว้โดยศิลปินนิติเวช
การรู้จำเสียง
ระบบอัจฉริยะบางระบบสามารถได้ยินและเข้าใจภาษาในรูปประโยคและความหมายในขณะที่มนุษย์พูดคุยกัน สามารถจัดการกับสำเนียงที่แตกต่างกันคำแสลงเสียงในพื้นหลังการเปลี่ยนแปลงของเสียงของมนุษย์เนื่องจากความเย็น ฯลฯ
การจดจำลายมือ
ซอฟต์แวร์จดจำลายมือจะอ่านข้อความที่เขียนบนกระดาษด้วยปากกาหรือบนหน้าจอด้วยสไตลัส สามารถจดจำรูปร่างของตัวอักษรและแปลงเป็นข้อความที่แก้ไขได้
หุ่นยนต์อัจฉริยะ
หุ่นยนต์สามารถทำงานที่มนุษย์มอบให้ได้ พวกเขามีเซ็นเซอร์เพื่อตรวจจับข้อมูลทางกายภาพจากโลกแห่งความจริงเช่นแสงความร้อนอุณหภูมิการเคลื่อนไหวเสียงกระแทกและแรงกด พวกเขามีโปรเซสเซอร์ที่มีประสิทธิภาพเซ็นเซอร์หลายตัวและหน่วยความจำขนาดใหญ่เพื่อแสดงข้อมูลอัจฉริยะ นอกจากนี้พวกเขายังสามารถเรียนรู้จากความผิดพลาดและปรับตัวเข้ากับสภาพแวดล้อมใหม่ได้
การสร้างแบบจำลองทางปัญญา: การจำลองขั้นตอนการคิดของมนุษย์
การสร้างแบบจำลองความรู้ความเข้าใจโดยพื้นฐานแล้วเป็นสาขาการศึกษาภายในวิทยาศาสตร์คอมพิวเตอร์ที่เกี่ยวข้องกับการศึกษาและจำลองกระบวนการคิดของมนุษย์ งานหลักของ AI คือการทำให้เครื่องจักรคิดเหมือนมนุษย์ คุณลักษณะที่สำคัญที่สุดของกระบวนการคิดของมนุษย์คือการแก้ปัญหา นั่นคือเหตุผลที่การสร้างแบบจำลององค์ความรู้ไม่มากก็น้อยพยายามที่จะเข้าใจว่ามนุษย์สามารถแก้ปัญหาได้อย่างไร หลังจากนั้นโมเดลนี้สามารถใช้กับแอปพลิเคชัน AI ต่างๆเช่นการเรียนรู้ของเครื่องหุ่นยนต์การประมวลผลภาษาธรรมชาติเป็นต้นต่อไปนี้เป็นแผนภาพระดับความคิดที่แตกต่างกันของสมองมนุษย์ -
ตัวแทนและสิ่งแวดล้อม
ในส่วนนี้เราจะเน้นไปที่ตัวแทนและสภาพแวดล้อมและความช่วยเหลือเหล่านี้ในปัญญาประดิษฐ์อย่างไร
ตัวแทน
ตัวแทนคืออะไรก็ได้ที่สามารถรับรู้สภาพแวดล้อมของมันผ่านเซ็นเซอร์และกระทำต่อสภาพแวดล้อมนั้นผ่านเอฟเฟกต์
ก human agent มีอวัยวะรับความรู้สึกเช่นตาหูจมูกลิ้นและผิวหนังขนานกับเซ็นเซอร์และอวัยวะอื่น ๆ เช่นมือขาปากสำหรับเอฟเฟกต์
ก robotic agent แทนที่กล้องและตัวค้นหาระยะอินฟราเรดสำหรับเซ็นเซอร์และมอเตอร์และตัวกระตุ้นต่างๆสำหรับเอฟเฟกต์
ก software agent ได้เข้ารหัสบิตสตริงเป็นโปรแกรมและการดำเนินการ
สิ่งแวดล้อม
บางโปรแกรมทำงานในไฟล์ artificial environment จำกัด เฉพาะอินพุตแป้นพิมพ์ฐานข้อมูลระบบไฟล์คอมพิวเตอร์และเอาต์พุตอักขระบนหน้าจอ
ในทางตรงกันข้ามตัวแทนซอฟต์แวร์บางตัว (หุ่นยนต์ซอฟต์แวร์หรือซอฟต์บอท) มีอยู่ในโดเมนซอฟต์บอทที่สมบูรณ์และไม่ จำกัด เครื่องจำลองมีไฟล์very detailed, complex environment. ตัวแทนซอฟต์แวร์จำเป็นต้องเลือกจากการดำเนินการที่หลากหลายแบบเรียลไทม์ softbot ได้รับการออกแบบมาเพื่อสแกนการตั้งค่าออนไลน์ของลูกค้าและแสดงรายการที่น่าสนใจให้กับลูกค้าที่ทำงานในไฟล์real เช่นเดียวกับ artificial สิ่งแวดล้อม.
ในบทนี้เราจะเรียนรู้วิธีเริ่มต้นกับ Python นอกจากนี้เรายังจะเข้าใจว่า Python ช่วยสำหรับปัญญาประดิษฐ์ได้อย่างไร
ทำไมต้อง Python สำหรับ AI
ปัญญาประดิษฐ์ถือเป็นเทคโนโลยีที่ได้รับความนิยมในอนาคต มีแอปพลิเคชั่นจำนวนมากที่สร้างขึ้นแล้ว ด้วยเหตุนี้ บริษัท และนักวิจัยจำนวนมากจึงให้ความสนใจ แต่คำถามหลักที่เกิดขึ้นคือภาษาโปรแกรมเหล่านี้สามารถพัฒนาแอพพลิเคชั่น AI เหล่านี้ได้ มีภาษาโปรแกรมต่างๆเช่น Lisp, Prolog, C ++, Java และ Python ซึ่งสามารถใช้สำหรับการพัฒนาแอปพลิเคชันของ AI ในหมู่พวกเขาภาษาโปรแกรม Python ได้รับความนิยมอย่างมากโดยมีสาเหตุดังนี้ -
ไวยากรณ์ที่เรียบง่ายและการเข้ารหัสน้อย
Python เกี่ยวข้องกับการเข้ารหัสน้อยมากและไวยากรณ์ที่เรียบง่ายท่ามกลางภาษาโปรแกรมอื่น ๆ ซึ่งสามารถใช้สำหรับการพัฒนาแอปพลิเคชัน AI เนื่องจากคุณสมบัตินี้การทดสอบจึงง่ายขึ้นและเราสามารถมุ่งเน้นไปที่การเขียนโปรแกรมได้มากขึ้น
ไลบรารี Inbuilt สำหรับโครงการ AI
ข้อได้เปรียบที่สำคัญสำหรับการใช้ Python สำหรับ AI คือมาพร้อมกับไลบรารี inbuilt Python มีไลบรารีสำหรับโครงการ AI เกือบทุกประเภท ตัวอย่างเช่น,NumPy, SciPy, matplotlib, nltk, SimpleAI เป็นไลบรารีในตัวที่สำคัญของ Python
Open source- Python เป็นภาษาโปรแกรมโอเพ่นซอร์ส ทำให้เป็นที่นิยมอย่างแพร่หลายในชุมชน
Can be used for broad range of programming- Python สามารถใช้สำหรับงานการเขียนโปรแกรมที่หลากหลายเช่นเชลล์สคริปต์ขนาดเล็กไปจนถึงเว็บแอปพลิเคชันขององค์กร นี่เป็นอีกเหตุผลหนึ่งที่ Python เหมาะสำหรับโครงการ AI
คุณสมบัติของ Python
Python เป็นภาษาสคริปต์ระดับสูงที่ตีความโต้ตอบและเชิงวัตถุ Python ออกแบบมาให้อ่านง่าย ใช้คำหลักภาษาอังกฤษบ่อยครั้งเมื่อภาษาอื่นใช้เครื่องหมายวรรคตอนและมีโครงสร้างทางไวยากรณ์น้อยกว่าภาษาอื่น ๆ คุณสมบัติของ Python มีดังต่อไปนี้ -
Easy-to-learn- Python มีคีย์เวิร์ดไม่กี่คำโครงสร้างที่เรียบง่ายและไวยากรณ์ที่กำหนดไว้อย่างชัดเจน ซึ่งจะช่วยให้นักเรียนสามารถเลือกภาษาได้อย่างรวดเร็ว
Easy-to-read - รหัส Python มีความชัดเจนมากขึ้นและมองเห็นได้ด้วยตา
Easy-to-maintain - ซอร์สโค้ดของ Python นั้นค่อนข้างดูแลรักษาง่าย
A broad standard library - ไลบรารีจำนวนมากของ Python สามารถพกพาได้และใช้งานข้ามแพลตฟอร์มได้บน UNIX, Windows และ Macintosh
Interactive Mode - Python รองรับโหมดอินเทอร์แอกทีฟซึ่งช่วยให้สามารถทดสอบและแก้จุดบกพร่องของโค้ดได้
Portable - Python สามารถทำงานบนแพลตฟอร์มฮาร์ดแวร์ที่หลากหลายและมีอินเทอร์เฟซเดียวกันในทุกแพลตฟอร์ม
Extendable- เราสามารถเพิ่มโมดูลระดับต่ำให้กับล่าม Python ได้ โมดูลเหล่านี้ช่วยให้โปรแกรมเมอร์สามารถเพิ่มหรือปรับแต่งเครื่องมือเพื่อให้มีประสิทธิภาพมากขึ้น
Databases - Python มีอินเทอร์เฟซสำหรับฐานข้อมูลเชิงพาณิชย์ที่สำคัญทั้งหมด
GUI Programming - Python รองรับแอพพลิเคชั่น GUI ที่สามารถสร้างและพอร์ตไปยังการโทรระบบไลบรารีและระบบ windows จำนวนมากเช่น Windows MFC, Macintosh และระบบ X Window ของ Unix
Scalable - Python มีโครงสร้างที่ดีกว่าและรองรับโปรแกรมขนาดใหญ่มากกว่าเชลล์สคริปต์
คุณสมบัติที่สำคัญของ Python
ตอนนี้ให้เราพิจารณาคุณสมบัติที่สำคัญต่อไปนี้ของ Python -
สนับสนุนวิธีการเขียนโปรแกรมเชิงฟังก์ชันและโครงสร้างเช่นเดียวกับ OOP
สามารถใช้เป็นภาษาสคริปต์หรือสามารถคอมไพล์เป็นไบต์โค้ดเพื่อสร้างแอปพลิเคชันขนาดใหญ่
ให้ประเภทข้อมูลไดนามิกระดับสูงมากและรองรับการตรวจสอบประเภทไดนามิก
รองรับการเก็บขยะอัตโนมัติ
สามารถรวมเข้ากับ C, C ++, COM, ActiveX, CORBA และ Java ได้อย่างง่ายดาย
การติดตั้ง Python
การแจกจ่าย Python พร้อมใช้งานสำหรับแพลตฟอร์มจำนวนมาก คุณต้องดาวน์โหลดเฉพาะรหัสไบนารีที่ใช้กับแพลตฟอร์มของคุณและติดตั้ง Python
หากไม่มีรหัสไบนารีสำหรับแพลตฟอร์มของคุณคุณต้องมีคอมไพเลอร์ C เพื่อคอมไพล์ซอร์สโค้ดด้วยตนเอง การรวบรวมซอร์สโค้ดให้ความยืดหยุ่นมากขึ้นในแง่ของการเลือกคุณสมบัติที่คุณต้องการในการติดตั้งของคุณ
นี่คือภาพรวมโดยย่อของการติดตั้ง Python บนแพลตฟอร์มต่างๆ -
การติดตั้ง Unix และ Linux
ทำตามขั้นตอนเหล่านี้เพื่อติดตั้ง Python บนเครื่อง Unix / Linux
เปิดเว็บเบราว์เซอร์และไปที่ https://www.python.org/downloads
ไปที่ลิงค์เพื่อดาวน์โหลดซอร์สโค้ดซิปสำหรับ Unix / Linux
ดาวน์โหลดและแตกไฟล์
การแก้ไขไฟล์Modules / Setupหากคุณต้องการปรับแต่งตัวเลือกบางอย่าง
เรียกใช้. / กำหนดค่าสคริปต์
make
ทำการติดตั้ง
สิ่งนี้จะติดตั้ง Python ที่ตำแหน่งมาตรฐาน / usr / local / bin และไลบรารีที่/ usr / local / lib / pythonXXโดยที่ XX คือเวอร์ชันของ Python
การติดตั้ง Windows
ทำตามขั้นตอนเหล่านี้เพื่อติดตั้ง Python บนเครื่อง Windows
เปิดเว็บเบราว์เซอร์และไปที่ https://www.python.org/downloads
ไปที่ลิงค์สำหรับไฟล์ตัวติดตั้ง Windows python-XYZ .msi โดยที่ XYZ คือเวอร์ชันที่คุณต้องติดตั้ง
ในการใช้โปรแกรมติดตั้งpython-XYZ .msi นี้ระบบ Windows ต้องรองรับ Microsoft Installer 2.0 บันทึกไฟล์ตัวติดตั้งลงในเครื่องของคุณจากนั้นเรียกใช้เพื่อดูว่าเครื่องของคุณรองรับ MSI หรือไม่
เรียกใช้ไฟล์ที่ดาวน์โหลด สิ่งนี้จะแสดงวิซาร์ดการติดตั้ง Python ซึ่งใช้งานง่ายมาก เพียงยอมรับการตั้งค่าเริ่มต้นและรอจนกว่าการติดตั้งจะเสร็จสิ้น
การติดตั้ง Macintosh
หากคุณใช้ Mac OS X ขอแนะนำให้คุณใช้ Homebrew เพื่อติดตั้ง Python 3 เป็นโปรแกรมติดตั้งแพ็คเกจที่ยอดเยี่ยมสำหรับ Mac OS X และใช้งานง่ายมาก หากคุณไม่มี Homebrew คุณสามารถติดตั้งได้โดยใช้คำสั่งต่อไปนี้ -
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"
เราสามารถอัปเดตตัวจัดการแพ็คเกจด้วยคำสั่งด้านล่าง -
$ brew update
ตอนนี้รันคำสั่งต่อไปนี้เพื่อติดตั้ง Python3 บนระบบของคุณ -
$ brew install python3
การตั้งค่า PATH
โปรแกรมและไฟล์ปฏิบัติการอื่น ๆ อาจอยู่ในไดเร็กทอรีจำนวนมากดังนั้นระบบปฏิบัติการจึงจัดเตรียมพา ธ การค้นหาที่แสดงรายการไดเร็กทอรีที่ OS ค้นหาไฟล์ปฏิบัติการ
พา ธ ถูกเก็บไว้ในตัวแปรสภาพแวดล้อมซึ่งเป็นสตริงที่มีชื่อดูแลโดยระบบปฏิบัติการ ตัวแปรนี้มีข้อมูลที่พร้อมใช้งานสำหรับเชลล์คำสั่งและโปรแกรมอื่น ๆ
ตัวแปรพา ธ ถูกตั้งชื่อเป็น PATH ใน Unix หรือ Path ใน Windows (Unix ขึ้นอยู่กับตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ Windows ไม่ใช่)
ใน Mac OS โปรแกรมติดตั้งจะจัดการกับรายละเอียดเส้นทาง ในการเรียกใช้ตัวแปล Python จากไดเร็กทอรีใด ๆ คุณต้องเพิ่มไดเร็กทอรี Python ในพา ธ ของคุณ
การตั้งค่า Path ที่ Unix / Linux
ในการเพิ่มไดเร็กทอรี Python ไปยังพา ธ สำหรับเซสชันเฉพาะใน Unix -
ในเชลล์ csh
ประเภท setenv PATH "$PATH:/usr/local/bin/python" แล้วกด Enter.
ใน bash shell (Linux)
ประเภท export ATH = "$PATH:/usr/local/bin/python" แล้วกด Enter.
ในเปลือก sh หรือ ksh
ประเภท PATH = "$PATH:/usr/local/bin/python" แล้วกด Enter.
Note - / usr / local / bin / python คือพา ธ ของไดเร็กทอรี Python
การตั้งค่าเส้นทางที่ Windows
ในการเพิ่มไดเร็กทอรี Python ไปยังพา ธ สำหรับเซสชันเฉพาะใน Windows -
At the command prompt - ประเภท path %path%;C:\Python แล้วกด Enter.
Note - C: \ Python คือพา ธ ของไดเร็กทอรี Python
กำลังรัน Python
ตอนนี้ให้เราดูวิธีต่างๆในการเรียกใช้ Python วิธีต่างๆอธิบายไว้ด้านล่าง -
ล่ามแบบโต้ตอบ
เราสามารถเริ่ม Python จาก Unix, DOS หรือระบบอื่น ๆ ที่มีตัวแปลบรรทัดคำสั่งหรือหน้าต่างเชลล์
ป้อน python ที่บรรทัดคำสั่ง
เริ่มเขียนโค้ดได้ทันทีในล่ามโต้ตอบ
$python # Unix/Linux
หรือ
python% # Unix/Linux
หรือ
C:> python # Windows/DOS
นี่คือรายการของตัวเลือกบรรทัดคำสั่งทั้งหมดที่มี -
ส. | ตัวเลือกและคำอธิบาย |
---|---|
1 | -d มีเอาต์พุตการดีบัก |
2 | -o สร้าง bytecode ที่ปรับให้เหมาะสม (ส่งผลให้เกิดไฟล์. pyo) |
3 | -S อย่าเรียกใช้ไซต์นำเข้าเพื่อค้นหาเส้นทาง Python เมื่อเริ่มต้น |
4 | -v เอาต์พุต Verbose (การติดตามโดยละเอียดเกี่ยวกับคำสั่งการนำเข้า) |
5 | -x ปิดใช้งานข้อยกเว้นในตัวตามคลาส (เพียงใช้สตริง) ล้าสมัยเริ่มต้นด้วยเวอร์ชัน 1.6 |
6 | -c cmd เรียกใช้สคริปต์ Python ที่ส่งเป็นสตริง cmd |
7 | File เรียกใช้สคริปต์ Python จากไฟล์ที่กำหนด |
สคริปต์จากบรรทัดคำสั่ง
สคริปต์ Python สามารถดำเนินการได้ที่บรรทัดคำสั่งโดยเรียกใช้ตัวแปลในแอปพลิเคชันของคุณดังต่อไปนี้ -
$python script.py # Unix/Linux
หรือ,
python% script.py # Unix/Linux
หรือ,
C:> python script.py # Windows/DOS
Note - ตรวจสอบให้แน่ใจว่าโหมดการอนุญาตไฟล์อนุญาตให้ดำเนินการได้
สภาพแวดล้อมการพัฒนาแบบบูรณาการ
คุณสามารถเรียกใช้ Python จากสภาพแวดล้อม Graphical User Interface (GUI) ได้เช่นกันหากคุณมีแอปพลิเคชัน GUI บนระบบของคุณที่รองรับ Python
Unix - IDLE เป็น Unix IDE แรกสำหรับ Python
Windows - PythonWin เป็นอินเทอร์เฟซ Windows ตัวแรกสำหรับ Python และเป็น IDE ที่มี GUI
Macintosh - Python เวอร์ชัน Macintosh พร้อมกับ IDLE IDE สามารถดาวน์โหลดได้จากเว็บไซต์หลักซึ่งสามารถดาวน์โหลดได้ทั้งไฟล์ MacBinary หรือ BinHex'd
หากคุณไม่สามารถตั้งค่าสภาพแวดล้อมได้อย่างเหมาะสมคุณสามารถขอความช่วยเหลือจากผู้ดูแลระบบของคุณ ตรวจสอบให้แน่ใจว่าสภาพแวดล้อม Python ได้รับการตั้งค่าอย่างเหมาะสมและทำงานได้ดีอย่างสมบูรณ์
เรายังสามารถใช้แพลตฟอร์ม Python อื่นที่เรียกว่า Anaconda ประกอบด้วยแพ็คเกจ data science ยอดนิยมหลายร้อยแพ็คเกจ conda และตัวจัดการสภาพแวดล้อมเสมือนสำหรับ Windows, Linux และ MacOS คุณสามารถดาวน์โหลดได้ตามระบบปฏิบัติการของคุณจากลิงค์https://www.anaconda.com/download/.
สำหรับบทช่วยสอนนี้เราใช้ Python 3.6.3 เวอร์ชันบน MS Windows
การเรียนรู้หมายถึงการได้มาซึ่งความรู้หรือทักษะจากการศึกษาหรือประสบการณ์ จากนี้เราสามารถกำหนดการเรียนรู้ของเครื่อง (ML) ได้ดังนี้ -
อาจถูกกำหนดให้เป็นสาขาวิทยาศาสตร์คอมพิวเตอร์โดยเฉพาะอย่างยิ่งการประยุกต์ใช้ปัญญาประดิษฐ์ซึ่งช่วยให้ระบบคอมพิวเตอร์สามารถเรียนรู้กับข้อมูลและปรับปรุงจากประสบการณ์โดยไม่ต้องมีการตั้งโปรแกรมไว้อย่างชัดเจน
โดยพื้นฐานแล้วจุดสนใจหลักของการเรียนรู้ของเครื่องคือการอนุญาตให้คอมพิวเตอร์เรียนรู้โดยอัตโนมัติโดยไม่มีการแทรกแซงจากมนุษย์ ตอนนี้คำถามเกิดขึ้นว่าการเรียนรู้ดังกล่าวสามารถเริ่มต้นและทำได้อย่างไร? สามารถเริ่มต้นด้วยการสังเกตข้อมูล ข้อมูลอาจเป็นตัวอย่างคำแนะนำหรือประสบการณ์ตรงได้เช่นกัน จากนั้นบนพื้นฐานของอินพุตนี้เครื่องจะตัดสินใจได้ดีขึ้นโดยมองหารูปแบบบางอย่างในข้อมูล
ประเภทของ Machine Learning (ML)
อัลกอริทึมการเรียนรู้ของเครื่องช่วยให้ระบบคอมพิวเตอร์เรียนรู้โดยไม่ต้องมีการตั้งโปรแกรมไว้อย่างชัดเจน อัลกอริทึมเหล่านี้แบ่งออกเป็นภายใต้การดูแลหรือไม่ได้รับการดูแล ตอนนี้ให้เราดูอัลกอริทึมบางส่วน -
อัลกอริทึมการเรียนรู้ของเครื่องภายใต้การดูแล
นี่คืออัลกอริทึมการเรียนรู้ของเครื่องที่ใช้บ่อยที่สุด เรียกว่าภายใต้การดูแลเนื่องจากกระบวนการของอัลกอริทึมการเรียนรู้จากชุดข้อมูลการฝึกอบรมสามารถคิดได้ว่าเป็นครูที่ดูแลกระบวนการเรียนรู้ ในอัลกอริทึม ML ประเภทนี้จะทราบผลลัพธ์ที่เป็นไปได้อยู่แล้วและข้อมูลการฝึกอบรมจะระบุคำตอบที่ถูกต้องด้วย สามารถเข้าใจได้ดังนี้ -
สมมติว่าเรามีตัวแปรอินพุต x และตัวแปรเอาต์พุต y และเราใช้อัลกอริทึมเพื่อเรียนรู้ฟังก์ชันการทำแผนที่จากอินพุตไปยังเอาต์พุตเช่น -
Y = f(x)
ตอนนี้เป้าหมายหลักคือการประมาณฟังก์ชันการทำแผนที่ให้ดีเมื่อเรามีข้อมูลอินพุตใหม่ (x) เราสามารถคาดเดาตัวแปรเอาต์พุต (Y) สำหรับข้อมูลนั้นได้
ปัญหาการเอนเอียงที่ได้รับการดูแลเป็นหลักแบ่งออกเป็นปัญหาสองประเภทต่อไปนี้ -
Classification - ปัญหาเรียกว่าปัญหาการจัดหมวดหมู่เมื่อเรามีผลลัพธ์ที่จัดหมวดหมู่เช่น "ดำ" "การสอน" "ไม่ใช่การสอน" เป็นต้น
Regression - ปัญหาเรียกว่าปัญหาการถดถอยเมื่อเรามีผลลัพธ์มูลค่าจริงเช่น "ระยะทาง" "กิโลกรัม" เป็นต้น
ต้นไม้การตัดสินใจฟอเรสต์สุ่ม knn การถดถอยโลจิสติกเป็นตัวอย่างของอัลกอริทึมการเรียนรู้ของเครื่องที่อยู่ภายใต้การดูแล
อัลกอริทึมการเรียนรู้ของเครื่องที่ไม่ได้รับการดูแล
ตามชื่อที่แนะนำอัลกอริธึมแมชชีนเลิร์นนิงประเภทนี้ไม่มีหัวหน้างานคอยให้คำแนะนำใด ๆ นั่นคือเหตุผลที่อัลกอริทึมการเรียนรู้ของเครื่องที่ไม่ได้รับการดูแลมีความสอดคล้องอย่างใกล้ชิดกับสิ่งที่บางคนเรียกว่าปัญญาประดิษฐ์ที่แท้จริง สามารถเข้าใจได้ดังนี้ -
สมมติว่าเรามีตัวแปรอินพุต x จากนั้นจะไม่มีตัวแปรเอาต์พุตที่เกี่ยวข้องเนื่องจากมีอยู่ในอัลกอริทึมการเรียนรู้ภายใต้การดูแล
พูดง่ายๆก็คือเราสามารถพูดได้ว่าในการเรียนรู้ที่ไม่มีผู้ดูแลจะไม่มีคำตอบที่ถูกต้องและไม่มีครูคอยชี้แนะ อัลกอริทึมช่วยในการค้นพบรูปแบบที่น่าสนใจในข้อมูล
ปัญหาการเรียนรู้ที่ไม่ได้รับการดูแลสามารถแบ่งออกเป็นปัญหาสองประเภทต่อไปนี้ -
Clustering- ในปัญหาการจัดกลุ่มเราจำเป็นต้องค้นหาการจัดกลุ่มโดยธรรมชาติในข้อมูล ตัวอย่างเช่นการจัดกลุ่มลูกค้าตามพฤติกรรมการซื้อ
Association- ปัญหาเรียกว่าปัญหาการเชื่อมโยงเนื่องจากปัญหาประเภทนี้ต้องการการค้นพบกฎที่อธิบายข้อมูลส่วนใหญ่ของเรา ตัวอย่างเช่นการค้นหาลูกค้าที่ซื้อทั้งสองอย่างx และ y.
K-mean สำหรับการทำคลัสเตอร์อัลกอริทึม Apriori สำหรับการเชื่อมโยงเป็นตัวอย่างของอัลกอริทึมการเรียนรู้ของเครื่องที่ไม่ได้รับการดูแล
อัลกอริธึมการเรียนรู้ของเครื่องเสริมแรง
อัลกอริธึมการเรียนรู้ของเครื่องประเภทนี้ใช้น้อยมาก อัลกอริทึมเหล่านี้ฝึกระบบเพื่อทำการตัดสินใจเฉพาะ โดยทั่วไปเครื่องจะสัมผัสกับสภาพแวดล้อมที่มันฝึกฝนตัวเองอย่างต่อเนื่องโดยใช้วิธีการลองผิดลองถูก อัลกอริทึมเหล่านี้เรียนรู้จากประสบการณ์ที่ผ่านมาและพยายามรวบรวมความรู้ที่ดีที่สุดเท่าที่จะเป็นไปได้เพื่อทำการตัดสินใจที่ถูกต้อง Markov Decision Process เป็นตัวอย่างของอัลกอริธึมการเรียนรู้ของเครื่องที่เสริมกำลัง
อัลกอริทึมการเรียนรู้ของเครื่องที่พบบ่อยที่สุด
ในส่วนนี้เราจะเรียนรู้เกี่ยวกับอัลกอริทึมการเรียนรู้ของเครื่องที่พบบ่อยที่สุด อัลกอริทึมอธิบายไว้ด้านล่าง -
การถดถอยเชิงเส้น
เป็นหนึ่งในอัลกอริทึมที่เป็นที่รู้จักมากที่สุดในด้านสถิติและการเรียนรู้ของเครื่อง
แนวคิดพื้นฐาน - การถดถอยเชิงเส้นส่วนใหญ่เป็นแบบจำลองเชิงเส้นที่ถือว่าความสัมพันธ์เชิงเส้นระหว่างตัวแปรอินพุตกล่าวว่า x และตัวแปรเอาต์พุตเดี่ยวกล่าวว่า y กล่าวอีกนัยหนึ่งเราสามารถพูดได้ว่า y สามารถคำนวณได้จากการรวมเชิงเส้นของตัวแปรอินพุต x ความสัมพันธ์ระหว่างตัวแปรสามารถกำหนดได้โดยการกำหนดเส้นที่ดีที่สุด
ประเภทของการถดถอยเชิงเส้น
การถดถอยเชิงเส้นมีสองประเภทต่อไปนี้ -
Simple linear regression - อัลกอริธึมการถดถอยเชิงเส้นเรียกว่าการถดถอยเชิงเส้นอย่างง่ายหากมีตัวแปรอิสระเพียงตัวแปรเดียว
Multiple linear regression - อัลกอริทึมการถดถอยเชิงเส้นเรียกว่าการถดถอยเชิงเส้นหลายตัวแปรหากมีตัวแปรอิสระมากกว่าหนึ่งตัวแปร
การถดถอยเชิงเส้นส่วนใหญ่ใช้ในการประมาณค่าจริงตามตัวแปรต่อเนื่อง ตัวอย่างเช่นยอดขายรวมของร้านค้าในหนึ่งวันตามมูลค่าจริงสามารถประมาณได้โดยการถดถอยเชิงเส้น
การถดถอยโลจิสติก
เป็นอัลกอริทึมการจำแนกประเภทและเรียกอีกอย่างว่า logit การถดถอย
การถดถอยโลจิสติกส่วนใหญ่เป็นอัลกอริธึมการจำแนกประเภทที่ใช้ในการประมาณค่าที่ไม่ต่อเนื่องเช่น 0 หรือ 1 จริงหรือเท็จใช่หรือไม่ใช่ตามชุดของตัวแปรอิสระที่กำหนด โดยทั่วไปจะทำนายความน่าจะเป็นดังนั้นผลลัพธ์ของมันจึงอยู่ระหว่าง 0 ถึง 1
ต้นไม้ตัดสินใจ
แผนผังการตัดสินใจคืออัลกอริทึมการเรียนรู้ภายใต้การดูแลซึ่งส่วนใหญ่ใช้สำหรับปัญหาการจำแนกประเภท
โดยทั่วไปจะเป็นลักษณนามที่แสดงเป็นพาร์ติชันแบบเรียกซ้ำตามตัวแปรอิสระ ต้นไม้การตัดสินใจมีโหนดซึ่งเป็นรูปแบบของต้นไม้ที่รูท ต้นไม้ที่ถูกรูทเป็นต้นไม้ที่มีโหนดที่เรียกว่า "ราก" รูทไม่มีขอบขาเข้าและโหนดอื่น ๆ ทั้งหมดมีขอบขาเข้าเดียว โหนดเหล่านี้เรียกว่าใบไม้หรือโหนดการตัดสินใจ ตัวอย่างเช่นพิจารณาโครงสร้างการตัดสินใจต่อไปนี้เพื่อดูว่าบุคคลนั้นเหมาะสมหรือไม่
รองรับ Vector Machine (SVM)
ใช้สำหรับทั้งการจำแนกประเภทและปัญหาการถดถอย แต่ส่วนใหญ่จะใช้สำหรับปัญหาการจำแนกประเภท แนวคิดหลักของ SVM คือการพล็อตรายการข้อมูลแต่ละรายการเป็นจุดในปริภูมิ n มิติโดยค่าของแต่ละคุณลักษณะเป็นค่าของพิกัดเฉพาะ นี่คือคุณสมบัติที่เราจะมี ต่อไปนี้เป็นการแสดงกราฟิกอย่างง่ายเพื่อให้เข้าใจแนวคิดของ SVM -
ในแผนภาพด้านบนเรามีคุณสมบัติสองประการดังนั้นก่อนอื่นเราต้องพล็อตตัวแปรทั้งสองนี้ในพื้นที่สองมิติโดยแต่ละจุดมีสองพิกัดเรียกว่าเวกเตอร์สนับสนุน เส้นแบ่งข้อมูลออกเป็นสองกลุ่มที่แตกต่างกัน บรรทัดนี้จะเป็นลักษณนาม
Naïve Bayes
นอกจากนี้ยังเป็นเทคนิคการจัดหมวดหมู่ ตรรกะเบื้องหลังเทคนิคการจำแนกประเภทนี้คือการใช้ทฤษฎีบทของเบย์ในการสร้างตัวแยกประเภท สมมติฐานคือตัวทำนายมีความเป็นอิสระ กล่าวง่ายๆก็คือถือว่าการมีอยู่ของคุณลักษณะเฉพาะในชั้นเรียนนั้นไม่เกี่ยวข้องกับการมีอยู่ของคุณลักษณะอื่นใด ด้านล่างนี้คือสมการสำหรับทฤษฎีบทเบย์ -
$$ P \ left (\ frac {A} {B} \ right) = \ frac {P \ left (\ frac {B} {A} \ right) P \ left (A \ right)} {P \ left ( B \ right)} $$
แบบจำลองNaïve Bayes นั้นสร้างได้ง่ายและมีประโยชน์อย่างยิ่งสำหรับชุดข้อมูลขนาดใหญ่
K- เพื่อนบ้านที่ใกล้ที่สุด (KNN)
ใช้สำหรับการจำแนกประเภทและการถดถอยของปัญหา มีการใช้กันอย่างแพร่หลายในการแก้ปัญหาการจำแนกประเภท แนวคิดหลักของอัลกอริทึมนี้คือใช้ในการจัดเก็บเคสที่มีอยู่ทั้งหมดและจำแนกเคสใหม่โดยคะแนนเสียงข้างมากของ k เพื่อนบ้าน จากนั้นกรณีจะถูกกำหนดให้กับคลาสซึ่งพบมากที่สุดในบรรดาเพื่อนบ้านที่ใกล้ที่สุด K วัดโดยฟังก์ชันระยะทาง ฟังก์ชั่นระยะทางสามารถเป็นระยะทางแบบยุคลิด, มิงโควสกีและแฮมมิง พิจารณาสิ่งต่อไปนี้เพื่อใช้ KNN -
KNN เชิงคำนวณมีราคาแพงกว่าอัลกอริทึมอื่น ๆ ที่ใช้สำหรับปัญหาการจำแนกประเภท
การทำให้เป็นมาตรฐานของตัวแปรที่จำเป็นอย่างอื่นตัวแปรช่วงที่สูงกว่าอาจทำให้เกิดอคติได้
ใน KNN เราจำเป็นต้องทำงานในขั้นตอนก่อนการประมวลผลเช่นการกำจัดเสียงรบกวน
K-mean Clustering
ตามชื่อที่แนะนำมันถูกใช้เพื่อแก้ปัญหาการทำคลัสเตอร์ โดยพื้นฐานแล้วเป็นการเรียนรู้ประเภทหนึ่งโดยไม่มีผู้ดูแล ตรรกะหลักของอัลกอริทึมการทำคลัสเตอร์ K-Means คือการจำแนกชุดข้อมูลผ่านคลัสเตอร์จำนวนหนึ่ง ทำตามขั้นตอนเหล่านี้เพื่อสร้างคลัสเตอร์โดย K-mean -
K-mean เลือกจำนวนจุด k สำหรับแต่ละคลัสเตอร์ที่เรียกว่าเซนทรอยด์
ตอนนี้แต่ละจุดข้อมูลจะสร้างคลัสเตอร์ที่มีเซนทรอยด์ใกล้เคียงที่สุดนั่นคือ k คลัสเตอร์
ตอนนี้จะพบเซนทรอยด์ของแต่ละคลัสเตอร์ตามสมาชิกคลัสเตอร์ที่มีอยู่
เราจำเป็นต้องทำซ้ำขั้นตอนเหล่านี้จนกว่าการบรรจบกันจะเกิดขึ้น
ป่าสุ่ม
เป็นอัลกอริทึมการจำแนกประเภทภายใต้การดูแล ข้อได้เปรียบของอัลกอริธึมฟอเรสต์แบบสุ่มคือสามารถใช้ได้ทั้งการจำแนกประเภทและการถดถอยของปัญหา โดยทั่วไปแล้วจะเป็นการรวบรวมต้นไม้การตัดสินใจ (เช่นป่าไม้) หรือคุณสามารถพูดได้ว่าทั้งมวลของต้นไม้แห่งการตัดสินใจ แนวคิดพื้นฐานของป่าสุ่มคือต้นไม้แต่ละชนิดให้การจำแนกประเภทและป่าจะเลือกการจำแนกประเภทที่ดีที่สุดจากพวกมัน สิ่งต่อไปนี้เป็นข้อดีของอัลกอริทึม Random Forest -
ลักษณนามฟอเรสต์แบบสุ่มสามารถใช้สำหรับงานการจำแนกประเภทและการถดถอย
พวกเขาสามารถจัดการกับค่าที่ขาดหายไป
มันจะไม่พอดีกับโมเดลแม้ว่าเราจะมีต้นไม้ในป่ามากกว่านี้ก็ตาม
เราได้ศึกษาอัลกอริธึมแมชชีนเลิร์นนิงภายใต้การควบคุมดูแลแล้ว อัลกอริทึมเหล่านี้ต้องการข้อมูลที่จัดรูปแบบเพื่อเริ่มกระบวนการฝึกอบรม เราต้องจัดเตรียมหรือจัดรูปแบบข้อมูลด้วยวิธีใดวิธีหนึ่งเพื่อให้สามารถส่งเป็นอินพุตไปยังอัลกอริทึม ML ได้
บทนี้มุ่งเน้นไปที่การเตรียมข้อมูลสำหรับอัลกอริทึมการเรียนรู้ของเครื่อง
การประมวลผลข้อมูลล่วงหน้า
ในชีวิตประจำวันของเราเราจัดการกับข้อมูลมากมาย แต่ข้อมูลนี้อยู่ในรูปแบบดิบ ในการให้ข้อมูลเป็นอินพุตของอัลกอริทึมการเรียนรู้ของเครื่องเราจำเป็นต้องแปลงเป็นข้อมูลที่มีความหมาย นั่นคือจุดที่การประมวลผลข้อมูลล่วงหน้าเป็นภาพ พูดง่ายๆก็คือเราสามารถพูดได้ว่าก่อนที่จะให้ข้อมูลกับอัลกอริทึมการเรียนรู้ของเครื่องเราจำเป็นต้องประมวลผลข้อมูลล่วงหน้า
ขั้นตอนการประมวลผลข้อมูลล่วงหน้า
ทำตามขั้นตอนเหล่านี้เพื่อประมวลผลข้อมูลล่วงหน้าใน Python -
Step 1 − Importing the useful packages - หากเราใช้ Python นี่จะเป็นขั้นตอนแรกในการแปลงข้อมูลให้อยู่ในรูปแบบที่แน่นอนเช่นการประมวลผลล่วงหน้า สามารถทำได้ดังนี้ -
import numpy as np
import sklearn.preprocessing
ที่นี่เราได้ใช้สองแพ็คเกจต่อไปนี้ -
NumPy - โดยทั่วไปแล้ว NumPy เป็นแพ็คเกจการประมวลผลอาร์เรย์วัตถุประสงค์ทั่วไปที่ออกแบบมาเพื่อจัดการอาร์เรย์หลายมิติขนาดใหญ่ของเร็กคอร์ดโดยพลการโดยไม่ต้องเสียความเร็วมากเกินไปสำหรับอาร์เรย์หลายมิติขนาดเล็ก
Sklearn.preprocessing - แพ็คเกจนี้มีฟังก์ชั่นยูทิลิตี้ทั่วไปมากมายและคลาสหม้อแปลงเพื่อเปลี่ยนเวกเตอร์คุณสมบัติดิบให้เป็นตัวแทนที่เหมาะสำหรับอัลกอริทึมการเรียนรู้ของเครื่อง
Step 2 − Defining sample data - หลังจากนำเข้าแพ็กเกจเราจำเป็นต้องกำหนดข้อมูลตัวอย่างบางส่วนเพื่อให้เราสามารถใช้เทคนิคการประมวลผลล่วงหน้ากับข้อมูลนั้นได้ ตอนนี้เราจะกำหนดข้อมูลตัวอย่างต่อไปนี้ -
input_data = np.array([2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8])
Step3 − Applying preprocessing technique - ในขั้นตอนนี้เราจำเป็นต้องใช้เทคนิคก่อนการประมวลผลใด ๆ
ส่วนต่อไปนี้อธิบายถึงเทคนิคการประมวลผลข้อมูลล่วงหน้า
เทคนิคการประมวลผลข้อมูลล่วงหน้า
เทคนิคสำหรับการประมวลผลข้อมูลล่วงหน้าอธิบายไว้ด้านล่าง -
ไบนาไรเซชั่น
นี่คือเทคนิคก่อนการประมวลผลที่ใช้เมื่อเราต้องการแปลงค่าตัวเลขเป็นค่าบูลีน เราสามารถใช้เมธอด inbuilt เพื่อแยกข้อมูลอินพุตออกเป็นสองส่วนโดยใช้ 0.5 เป็นค่า threshold ด้วยวิธีต่อไปนี้ -
data_binarized = preprocessing.Binarizer(threshold = 0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)
หลังจากรันโค้ดด้านบนแล้วเราจะได้ผลลัพธ์ต่อไปนี้ค่าทั้งหมดที่สูงกว่า 0.5 (ค่าเกณฑ์) จะถูกแปลงเป็น 1 และค่าทั้งหมดที่ต่ำกว่า 0.5 จะถูกแปลงเป็น 0
Binarized data
[[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]]
หมายถึงการกำจัด
เป็นอีกหนึ่งเทคนิคก่อนการประมวลผลทั่วไปที่ใช้ในการเรียนรู้ของเครื่อง โดยทั่วไปจะใช้เพื่อกำจัดค่าเฉลี่ยจากเวกเตอร์คุณลักษณะเพื่อให้ทุกคุณลักษณะมีศูนย์กลางอยู่ที่ศูนย์ เรายังสามารถลบอคติออกจากคุณลักษณะในเวกเตอร์คุณลักษณะ สำหรับการใช้เทคนิคการประมวลผลก่อนการลบค่าเฉลี่ยกับข้อมูลตัวอย่างเราสามารถเขียนโค้ด Python ที่แสดงด้านล่าง รหัสจะแสดงค่าเฉลี่ยและค่าเบี่ยงเบนมาตรฐานของข้อมูลอินพุต -
print("Mean = ", input_data.mean(axis = 0))
print("Std deviation = ", input_data.std(axis = 0))
เราจะได้ผลลัพธ์ต่อไปนี้หลังจากเรียกใช้โค้ดด้านบน -
Mean = [ 1.75 -1.275 2.2]
Std deviation = [ 2.71431391 4.20022321 4.69414529]
ตอนนี้โค้ดด้านล่างจะลบค่าเฉลี่ยและค่าเบี่ยงเบนมาตรฐานของข้อมูลอินพุต -
data_scaled = preprocessing.scale(input_data)
print("Mean =", data_scaled.mean(axis=0))
print("Std deviation =", data_scaled.std(axis = 0))
เราจะได้ผลลัพธ์ต่อไปนี้หลังจากเรียกใช้โค้ดด้านบน -
Mean = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Std deviation = [ 1. 1. 1.]
การปรับขนาด
เป็นอีกหนึ่งเทคนิคการประมวลผลข้อมูลล่วงหน้าที่ใช้ในการปรับขนาดเวกเตอร์คุณลักษณะ จำเป็นต้องมีการปรับขนาดของเวกเตอร์คุณลักษณะเนื่องจากค่าของทุกคุณลักษณะอาจแตกต่างกันไประหว่างค่าสุ่มจำนวนมาก กล่าวอีกนัยหนึ่งเราสามารถพูดได้ว่าการปรับขนาดมีความสำคัญเนื่องจากเราไม่ต้องการให้คุณลักษณะใด ๆ มีขนาดใหญ่หรือเล็กในเชิงสังเคราะห์ ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้เราสามารถทำการปรับขนาดข้อมูลอินพุตของเราได้เช่นเวกเตอร์คุณลักษณะ -
# Min max scaling
data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)
เราจะได้ผลลัพธ์ต่อไปนี้หลังจากเรียกใช้โค้ดด้านบน -
Min max scaled data
[ [ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0. 99029126 0. ]]
Normalization
เป็นอีกหนึ่งเทคนิคการประมวลผลข้อมูลล่วงหน้าที่ใช้ในการปรับเปลี่ยนเวกเตอร์คุณลักษณะ การปรับเปลี่ยนประเภทดังกล่าวจำเป็นในการวัดเวกเตอร์คุณลักษณะในมาตราส่วนทั่วไป สิ่งต่อไปนี้คือการทำให้เป็นมาตรฐานสองประเภทซึ่งสามารถใช้ในการเรียนรู้ของเครื่อง -
L1 Normalization
นอกจากนี้ยังเรียกว่า Least Absolute Deviations. การนอร์มัลไลเซชันประเภทนี้จะปรับเปลี่ยนค่าเพื่อให้ผลรวมของค่าสัมบูรณ์เป็น 1 ในแต่ละแถวเสมอ สามารถนำไปใช้กับข้อมูลอินพุตด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
# Normalize data
data_normalized_l1 = preprocessing.normalize(input_data, norm = 'l1')
print("\nL1 normalized data:\n", data_normalized_l1)
บรรทัดด้านบนของโค้ดจะสร้างผลลัพธ์ต่อไปนี้ & miuns;
L1 normalized data:
[[ 0.22105263 -0.2 0.57894737]
[ -0.2027027 0.32432432 0.47297297]
[ 0.03571429 -0.56428571 0.4 ]
[ 0.42142857 0.16428571 -0.41428571]]
L2 Normalization
นอกจากนี้ยังเรียกว่า least squares. การนอร์มัลไลเซชันประเภทนี้จะแก้ไขค่าเพื่อให้ผลรวมของกำลังสองเป็น 1 ในแต่ละแถวเสมอ สามารถนำไปใช้กับข้อมูลอินพุตด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
# Normalize data
data_normalized_l2 = preprocessing.normalize(input_data, norm = 'l2')
print("\nL2 normalized data:\n", data_normalized_l2)
บรรทัดโค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้ -
L2 normalized data:
[[ 0.33946114 -0.30713151 0.88906489]
[ -0.33325106 0.53320169 0.7775858 ]
[ 0.05156558 -0.81473612 0.57753446]
[ 0.68706914 0.26784051 -0.6754239 ]]
การติดฉลากข้อมูล
เราทราบแล้วว่าข้อมูลในรูปแบบหนึ่งจำเป็นสำหรับอัลกอริทึมการเรียนรู้ของเครื่อง ข้อกำหนดที่สำคัญอีกประการหนึ่งคือข้อมูลต้องได้รับการติดฉลากอย่างถูกต้องก่อนที่จะส่งเป็นอินพุตของอัลกอริทึมการเรียนรู้ของเครื่อง ตัวอย่างเช่นหากเราพูดถึงการจัดหมวดหมู่ข้อมูลมีป้ายกำกับจำนวนมาก ป้ายกำกับเหล่านั้นอยู่ในรูปของคำตัวเลข ฯลฯ ฟังก์ชันที่เกี่ยวข้องกับการเรียนรู้ของเครื่องในsklearnคาดว่าข้อมูลจะต้องมีป้ายกำกับตัวเลข ดังนั้นหากข้อมูลอยู่ในรูปแบบอื่นก็จะต้องถูกแปลงเป็นตัวเลข กระบวนการเปลี่ยนป้ายคำให้เป็นรูปแบบตัวเลขนี้เรียกว่าการเข้ารหัสฉลาก
ขั้นตอนการเข้ารหัสฉลาก
ทำตามขั้นตอนเหล่านี้เพื่อเข้ารหัสป้ายกำกับข้อมูลใน Python -
Step1 − Importing the useful packages
ถ้าเราใช้ Python นี่จะเป็นขั้นตอนแรกในการแปลงข้อมูลให้อยู่ในรูปแบบที่แน่นอนนั่นคือการประมวลผลล่วงหน้า สามารถทำได้ดังนี้ -
import numpy as np
from sklearn import preprocessing
Step 2 − Defining sample labels
หลังจากนำเข้าแพ็กเกจเราจำเป็นต้องกำหนดป้ายกำกับตัวอย่างเพื่อที่เราจะสามารถสร้างและฝึกตัวเข้ารหัสฉลากได้ ตอนนี้เราจะกำหนดป้ายกำกับตัวอย่างต่อไปนี้ -
# Sample input labels
input_labels = ['red','black','red','green','black','yellow','white']
Step 3 − Creating & training of label encoder object
ในขั้นตอนนี้เราต้องสร้างตัวเข้ารหัสฉลากและฝึกมัน รหัส Python ต่อไปนี้จะช่วยในการทำสิ่งนี้ -
# Creating the label encoder
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)
ต่อไปนี้จะเป็นผลลัพธ์หลังจากรันโค้ด Python ด้านบน -
LabelEncoder()
Step4 − Checking the performance by encoding random ordered list
ขั้นตอนนี้สามารถใช้เพื่อตรวจสอบประสิทธิภาพโดยการเข้ารหัสรายการที่เรียงลำดับแบบสุ่ม สามารถเขียนโค้ด Python ต่อไปนี้เพื่อทำเช่นเดียวกัน -
# encoding a set of labels
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
ฉลากจะได้รับการพิมพ์ดังนี้ -
Labels = ['green', 'red', 'black']
ตอนนี้เราสามารถรับรายการค่าที่เข้ารหัสเช่นป้ายคำที่แปลงเป็นตัวเลขได้ดังนี้ -
print("Encoded values =", list(encoded_values))
ค่าที่เข้ารหัสจะได้รับการพิมพ์ดังนี้ -
Encoded values = [1, 2, 0]
Step 5 − Checking the performance by decoding a random set of numbers −
ขั้นตอนนี้สามารถใช้เพื่อตรวจสอบประสิทธิภาพโดยการถอดรหัสชุดตัวเลขแบบสุ่ม สามารถเขียนโค้ด Python ต่อไปนี้เพื่อทำเช่นเดียวกัน -
# decoding a set of values
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)
print("\nEncoded values =", encoded_values)
ตอนนี้ค่าที่เข้ารหัสจะถูกพิมพ์ออกมาดังนี้ -
Encoded values = [3, 0, 4, 1]
print("\nDecoded labels =", list(decoded_list))
ตอนนี้ค่าที่ถอดรหัสจะได้รับการพิมพ์ดังนี้ -
Decoded labels = ['white', 'black', 'yellow', 'green']
ติดป้ายกำกับ v / s ข้อมูลที่ไม่มีป้ายกำกับ
ข้อมูลที่ไม่มีป้ายกำกับส่วนใหญ่ประกอบด้วยตัวอย่างของวัตถุตามธรรมชาติหรือที่มนุษย์สร้างขึ้นซึ่งหาได้ง่ายจากโลก ซึ่งรวมถึงเสียงวิดีโอภาพถ่ายบทความข่าว ฯลฯ
ในทางกลับกันข้อมูลที่มีป้ายกำกับจะใช้ชุดข้อมูลที่ไม่มีป้ายกำกับและเพิ่มข้อมูลแต่ละส่วนที่ไม่มีป้ายกำกับด้วยแท็กหรือป้ายกำกับหรือคลาสที่มีความหมาย ตัวอย่างเช่นถ้าเรามีรูปถ่ายก็สามารถใส่ป้ายกำกับได้ตามเนื้อหาของรูปถ่ายนั่นคือรูปเด็กผู้ชายหรือเด็กผู้หญิงหรือสัตว์หรืออะไรก็ได้ การติดฉลากข้อมูลจำเป็นต้องอาศัยความเชี่ยวชาญของมนุษย์หรือการตัดสินใจเกี่ยวกับข้อมูลที่ไม่มีป้ายกำกับ
มีหลายสถานการณ์ที่ข้อมูลที่ไม่มีป้ายกำกับมีอยู่มากมายและหาได้ง่าย แต่ข้อมูลที่มีป้ายกำกับมักต้องใช้บุคคล / ผู้เชี่ยวชาญในการใส่คำอธิบายประกอบ การเรียนรู้แบบกึ่งมีผู้ดูแลพยายามรวมข้อมูลที่มีป้ายกำกับและไม่มีป้ายกำกับเพื่อสร้างแบบจำลองที่ดีขึ้น
ในบทนี้เราจะมุ่งเน้นไปที่การใช้การเรียนรู้ภายใต้การดูแล - การจำแนกประเภท
เทคนิคการจำแนกประเภทหรือแบบจำลองพยายามหาข้อสรุปจากค่าที่สังเกตได้ ในปัญหาการจัดหมวดหมู่เรามีผลลัพธ์ที่จัดหมวดหมู่เช่น“ ดำ” หรือ“ ขาว” หรือ“ การสอน” และ“ ไม่ใช่การสอน” ในขณะที่สร้างโมเดลการจำแนกเราจำเป็นต้องมีชุดข้อมูลการฝึกอบรมที่มีจุดข้อมูลและป้ายกำกับที่เกี่ยวข้อง ตัวอย่างเช่นหากเราต้องการตรวจสอบว่าภาพนั้นเป็นของรถยนต์หรือไม่ สำหรับการตรวจสอบสิ่งนี้เราจะสร้างชุดข้อมูลการฝึกอบรมโดยมีสองคลาสที่เกี่ยวข้องกับ "รถ" และ "ไม่มีรถ" จากนั้นเราต้องฝึกโมเดลโดยใช้ตัวอย่างการฝึกอบรม รูปแบบการจำแนกประเภทส่วนใหญ่จะใช้ในการจดจำใบหน้าการระบุสแปมและอื่น ๆ
ขั้นตอนในการสร้างลักษณนามใน Python
สำหรับการสร้างลักษณนามใน Python เราจะใช้ Python 3 และ Scikit-learn ซึ่งเป็นเครื่องมือสำหรับการเรียนรู้ของเครื่อง ทำตามขั้นตอนเหล่านี้เพื่อสร้างลักษณนามใน Python -
ขั้นตอนที่ 1 - นำเข้า Scikit-learn
นี่เป็นขั้นตอนแรกสำหรับการสร้างลักษณนามใน Python ในขั้นตอนนี้เราจะติดตั้งแพ็คเกจ Python ที่เรียกว่า Scikit-learn ซึ่งเป็นหนึ่งในโมดูลการเรียนรู้ของเครื่องที่ดีที่สุดใน Python คำสั่งต่อไปนี้จะช่วยเรานำเข้าแพ็คเกจ -
Import Sklearn
ขั้นตอนที่ 2 - นำเข้าชุดข้อมูลของ Scikit-learn
ในขั้นตอนนี้เราสามารถเริ่มทำงานกับชุดข้อมูลสำหรับโมเดลแมชชีนเลิร์นนิงของเราได้ ที่นี่เราจะใช้the ฐานข้อมูลการวินิจฉัยมะเร็งเต้านมวิสคอนซิน ชุดข้อมูลประกอบด้วยข้อมูลต่างๆเกี่ยวกับเนื้องอกมะเร็งเต้านมและฉลากการจำแนกประเภทของmalignant หรือ benign. ชุดข้อมูลมี 569 อินสแตนซ์หรือข้อมูลเกี่ยวกับเนื้องอก 569 ชิ้นและมีข้อมูลเกี่ยวกับคุณลักษณะหรือคุณลักษณะ 30 อย่างเช่นรัศมีของเนื้องอกพื้นผิวความเรียบเนียนและพื้นที่ ด้วยความช่วยเหลือของคำสั่งต่อไปนี้เราสามารถนำเข้าชุดข้อมูลมะเร็งเต้านมของ Scikit-learn -
from sklearn.datasets import load_breast_cancer
ตอนนี้คำสั่งต่อไปนี้จะโหลดชุดข้อมูล
data = load_breast_cancer()
ต่อไปนี้เป็นรายการคีย์พจนานุกรมที่สำคัญ -
- ชื่อป้ายกำกับการจำแนก (target_names)
- ป้ายกำกับจริง (เป้าหมาย)
- ชื่อแอตทริบิวต์ / คุณลักษณะ (feature_names)
- แอตทริบิวต์ (ข้อมูล)
ตอนนี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้เราสามารถสร้างตัวแปรใหม่สำหรับชุดข้อมูลที่สำคัญแต่ละชุดและกำหนดข้อมูลได้ กล่าวอีกนัยหนึ่งเราสามารถจัดระเบียบข้อมูลด้วยคำสั่งต่อไปนี้ -
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
ตอนนี้เพื่อให้ชัดเจนขึ้นเราสามารถพิมพ์ฉลากคลาสฉลากของอินสแตนซ์ข้อมูลแรกชื่อคุณลักษณะและค่าของคุณลักษณะด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
print(label_names)
คำสั่งดังกล่าวจะพิมพ์ชื่อคลาสที่ร้ายกาจและอ่อนโยนตามลำดับ แสดงเป็นผลลัพธ์ด้านล่าง -
['malignant' 'benign']
ตอนนี้คำสั่งด้านล่างจะแสดงว่ามีการแมปกับค่าไบนารี 0 และ 1 ในที่นี้ 0 หมายถึงมะเร็งร้ายและ 1 หมายถึงมะเร็งที่อ่อนโยน คุณจะได้รับผลลัพธ์ต่อไปนี้ -
print(labels[0])
0
คำสั่งสองคำสั่งด้านล่างนี้จะสร้างชื่อคุณลักษณะและค่าคุณลักษณะ
print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
4.60100000e-01 1.18900000e-01]
จากผลลัพธ์ข้างต้นเราจะเห็นว่าอินสแตนซ์ข้อมูลแรกเป็นเนื้องอกมะเร็งซึ่งมีรัศมี 1.7990000e + 01
ขั้นตอนที่ 3 - จัดระเบียบข้อมูลเป็นชุด
ในขั้นตอนนี้เราจะแบ่งข้อมูลของเราออกเป็นสองส่วนคือชุดฝึกและชุดทดสอบ การแบ่งข้อมูลออกเป็นชุดมีความสำคัญมากเพราะเราต้องทดสอบโมเดลของเรากับข้อมูลที่มองไม่เห็น ในการแบ่งข้อมูลออกเป็นชุด sklearn มีฟังก์ชันที่เรียกว่าtrain_test_split()ฟังก์ชัน ด้วยความช่วยเหลือของคำสั่งต่อไปนี้เราสามารถแบ่งข้อมูลในชุดเหล่านี้ -
from sklearn.model_selection import train_test_split
คำสั่งดังกล่าวจะนำเข้าไฟล์ train_test_splitฟังก์ชั่นจาก sklearn และคำสั่งด้านล่างจะแบ่งข้อมูลออกเป็นข้อมูลการฝึกอบรมและการทดสอบ ในตัวอย่างด้านล่างนี้เรากำลังใช้ข้อมูล 40% สำหรับการทดสอบและข้อมูลที่เหลือจะใช้สำหรับการฝึกโมเดล
train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)
ขั้นตอนที่ 4 - การสร้างแบบจำลอง
ในขั้นตอนนี้เราจะสร้างแบบจำลองของเรา เราจะใช้อัลกอริทึมNaïve Bayes ในการสร้างแบบจำลอง คำสั่งต่อไปนี้สามารถใช้เพื่อสร้างแบบจำลอง -
from sklearn.naive_bayes import GaussianNB
คำสั่งดังกล่าวจะนำเข้าโมดูล GaussianNB ตอนนี้คำสั่งต่อไปนี้จะช่วยคุณเริ่มต้นโมเดล
gnb = GaussianNB()
เราจะฝึกโมเดลโดยปรับให้พอดีกับข้อมูลโดยใช้ gnb.fit ()
model = gnb.fit(train, train_labels)
ขั้นตอนที่ 5 - การประเมินโมเดลและความแม่นยำ
ในขั้นตอนนี้เราจะประเมินแบบจำลองโดยทำการคาดคะเนข้อมูลการทดสอบของเรา จากนั้นเราจะพบความแม่นยำของมันด้วย สำหรับการทำนายเราจะใช้ฟังก์ชัน Predict () คำสั่งต่อไปนี้จะช่วยคุณทำสิ่งนี้ -
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]
ชุด 0 และ 1 ข้างต้นเป็นค่าที่คาดการณ์ไว้สำหรับชั้นเนื้องอก - ร้ายและไม่เป็นพิษเป็นภัย
ตอนนี้โดยการเปรียบเทียบสองอาร์เรย์คือ test_labels และ predsเราสามารถค้นหาความแม่นยำของแบบจำลองของเราได้ เราจะใช้ไฟล์accuracy_score()ฟังก์ชันเพื่อกำหนดความถูกต้อง พิจารณาคำสั่งต่อไปนี้สำหรับสิ่งนี้ -
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
ผลลัพธ์แสดงให้เห็นว่าลักษณนามNaïveBayesมีความแม่นยำ 95.17%
ด้วยวิธีนี้ด้วยความช่วยเหลือของขั้นตอนข้างต้นเราสามารถสร้างลักษณนามของเราใน Python
Building Classifier ใน Python
ในส่วนนี้เราจะเรียนรู้วิธีการสร้างลักษณนามใน Python
ลักษณนามNaïve Bayes
Naïve Bayes เป็นเทคนิคการจำแนกประเภทที่ใช้ในการสร้างลักษณนามโดยใช้ทฤษฎีบทเบย์ สมมติฐานคือตัวทำนายมีความเป็นอิสระ กล่าวง่ายๆก็คือถือว่าการมีอยู่ของคุณลักษณะเฉพาะในชั้นเรียนนั้นไม่เกี่ยวข้องกับการมีอยู่ของคุณลักษณะอื่นใด สำหรับการสร้างลักษณนามNaïve Bayes เราจำเป็นต้องใช้ python library ที่เรียกว่า scikit learn โมเดลNaïve Bayes มีสามประเภทGaussian, Multinomial and Bernoulli ภายใต้แพ็คเกจการเรียนรู้ scikit
ในการสร้างโมเดลลักษณนามการเรียนรู้ของเครื่องNaïve Bayes เราต้องมีสิ่งต่อไปนี้ & ลบ
ชุดข้อมูล
เราจะใช้ชุดข้อมูลที่ชื่อว่าBreast Cancer Wisconsin Diagnostic Database ชุดข้อมูลประกอบด้วยข้อมูลต่างๆเกี่ยวกับเนื้องอกมะเร็งเต้านมและฉลากการจำแนกประเภทของmalignant หรือ benign. ชุดข้อมูลมี 569 อินสแตนซ์หรือข้อมูลเกี่ยวกับเนื้องอก 569 ชิ้นและมีข้อมูลเกี่ยวกับคุณลักษณะหรือคุณลักษณะ 30 อย่างเช่นรัศมีของเนื้องอกพื้นผิวความเรียบเนียนและพื้นที่ เราสามารถนำเข้าชุดข้อมูลนี้จากแพ็คเกจ sklearn
Naïve Bayes Model
สำหรับการสร้างลักษณนามNaïve Bayes เราต้องการแบบจำลองNaïve Bayes อย่างที่บอกไปก่อนหน้านี้มีชื่อรุ่นNaïve Bayes อยู่สามประเภทGaussian, Multinomial และ Bernoulliภายใต้แพ็คเกจการเรียนรู้ scikit ในตัวอย่างต่อไปนี้เราจะใช้แบบจำลอง Gaussian Naïve Bayes
ด้วยการใช้ข้างต้นเราจะสร้างแบบจำลองการเรียนรู้ของเครื่อง Na useve Bayes เพื่อใช้ข้อมูลเนื้องอกในการทำนายว่าเนื้องอกเป็นมะเร็งหรือไม่เป็นพิษ
ในการเริ่มต้นเราต้องติดตั้งโมดูล sklearn สามารถทำได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
Import Sklearn
ตอนนี้เราต้องนำเข้าชุดข้อมูลที่ชื่อว่า Breast Cancer Wisconsin Diagnostic Database
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']
ตอนนี้เพื่อให้ชัดเจนขึ้นเราสามารถพิมพ์ฉลากคลาสฉลากของอินสแตนซ์ข้อมูลแรกชื่อคุณลักษณะและค่าของคุณลักษณะได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
print(label_names)
คำสั่งดังกล่าวจะพิมพ์ชื่อคลาสที่ร้ายกาจและอ่อนโยนตามลำดับ แสดงเป็นผลลัพธ์ด้านล่าง -
['malignant' 'benign']
ตอนนี้คำสั่งที่ระบุด้านล่างจะแสดงว่ามีการแมปกับค่าไบนารี 0 และ 1 ในที่นี้ 0 หมายถึงมะเร็งร้ายและ 1 หมายถึงมะเร็งที่ไม่เป็นพิษเป็นภัย แสดงเป็นผลลัพธ์ด้านล่าง -
print(labels[0])
0
คำสั่งสองคำสั่งต่อไปนี้จะสร้างชื่อคุณลักษณะและค่าคุณลักษณะ
print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
4.60100000e-01 1.18900000e-01]
จากผลลัพธ์ข้างต้นเราจะเห็นว่าอินสแตนซ์ข้อมูลแรกเป็นเนื้องอกมะเร็งซึ่งรัศมีหลักคือ 1.7990000e + 01
สำหรับการทดสอบโมเดลของเรากับข้อมูลที่มองไม่เห็นเราจำเป็นต้องแยกข้อมูลของเราออกเป็นข้อมูลการฝึกอบรมและการทดสอบ สามารถทำได้ด้วยความช่วยเหลือของรหัสต่อไปนี้ -
from sklearn.model_selection import train_test_split
คำสั่งดังกล่าวจะนำเข้าไฟล์ train_test_splitฟังก์ชั่นจาก sklearn และคำสั่งด้านล่างจะแบ่งข้อมูลออกเป็นข้อมูลการฝึกอบรมและการทดสอบ ในตัวอย่างด้านล่างเราใช้ 40% ของข้อมูลสำหรับการทดสอบและข้อมูลการปรับปรุงจะถูกใช้สำหรับการฝึกโมเดล
train, test, train_labels, test_labels =
train_test_split(features,labels,test_size = 0.40, random_state = 42)
ตอนนี้เรากำลังสร้างโมเดลด้วยคำสั่งต่อไปนี้ -
from sklearn.naive_bayes import GaussianNB
คำสั่งดังกล่าวจะนำเข้าไฟล์ GaussianNBโมดูล. ตอนนี้ด้วยคำสั่งที่ระบุด้านล่างเราจำเป็นต้องเริ่มต้นโมเดล
gnb = GaussianNB()
เราจะฝึกโมเดลโดยปรับให้พอดีกับข้อมูลโดยใช้ gnb.fit().
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]
ชุด 0 และ 1 ข้างต้นเป็นค่าที่คาดการณ์ไว้สำหรับชั้นเนื้องอกเช่นมะเร็งและไม่เป็นพิษเป็นภัย
ตอนนี้โดยการเปรียบเทียบสองอาร์เรย์คือ test_labels และ predsเราสามารถค้นหาความแม่นยำของแบบจำลองของเราได้ เราจะใช้ไฟล์accuracy_score()ฟังก์ชันเพื่อกำหนดความถูกต้อง พิจารณาคำสั่งต่อไปนี้ -
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
ผลลัพธ์แสดงให้เห็นว่าลักษณนามNaïveBayesมีความแม่นยำ 95.17%
นั่นคือลักษณนามแมชชีนเลิร์นนิงตามแบบจำลองNaïve Bayse Gaussian
รองรับ Vector Machines (SVM)
โดยพื้นฐานแล้ว Support vector machine (SVM) เป็นอัลกอริธึมการเรียนรู้ของเครื่องที่อยู่ภายใต้การดูแลซึ่งสามารถใช้ได้ทั้งการถดถอยและการจำแนกประเภท แนวคิดหลักของ SVM คือการพล็อตรายการข้อมูลแต่ละรายการเป็นจุดในปริภูมิ n มิติโดยค่าของแต่ละคุณลักษณะเป็นค่าของพิกัดเฉพาะ นี่คือคุณสมบัติที่เราจะมี ต่อไปนี้เป็นการแสดงกราฟิกอย่างง่ายเพื่อให้เข้าใจแนวคิดของ SVM -
ในแผนภาพด้านบนเรามีคุณสมบัติสองประการ ดังนั้นก่อนอื่นเราต้องพล็อตตัวแปรทั้งสองนี้ในพื้นที่สองมิติโดยแต่ละจุดมีสองพิกัดเรียกว่าเวกเตอร์สนับสนุน เส้นแบ่งข้อมูลออกเป็นสองกลุ่มที่แตกต่างกัน บรรทัดนี้จะเป็นลักษณนาม
ที่นี่เราจะสร้างตัวจำแนก SVM โดยใช้ชุดข้อมูล scikit-learn และ iris ห้องสมุด Scikitlearn มีไฟล์sklearn.svmโมดูลและจัดเตรียม sklearn.svm.svc สำหรับการจำแนกประเภท ลักษณนาม SVM เพื่อทำนายคลาสของพืชไอริสตามคุณสมบัติ 4 ประการดังแสดงด้านล่าง
ชุดข้อมูล
เราจะใช้ชุดข้อมูลไอริสซึ่งมี 3 คลาสละ 50 อินสแตนซ์โดยแต่ละคลาสหมายถึงพืชไอริสชนิดหนึ่ง แต่ละอินสแตนซ์มีคุณสมบัติสี่ประการ ได้แก่ ความยาวกลีบเลี้ยงความกว้างของกลีบเลี้ยงความยาวกลีบดอกและความกว้างของกลีบดอก ลักษณนาม SVM เพื่อทำนายคลาสของพืชไอริสตามคุณสมบัติ 4 ประการดังแสดงด้านล่าง
เคอร์เนล
เป็นเทคนิคที่ SVM ใช้ โดยพื้นฐานแล้วนี่คือฟังก์ชันที่ใช้พื้นที่อินพุตมิติต่ำและเปลี่ยนเป็นพื้นที่มิติที่สูงขึ้น จะแปลงปัญหาที่ไม่สามารถแยกออกเป็นปัญหาที่แยกออกจากกันได้ ฟังก์ชันเคอร์เนลสามารถเป็นฟังก์ชันใดก็ได้ระหว่าง linear, polynomial, rbf และ sigmoid ในตัวอย่างนี้เราจะใช้เคอร์เนลเชิงเส้น
ให้เรานำเข้าแพ็คเกจต่อไปนี้ -
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
เราจะพล็อตขอบเขตเครื่องเวกเตอร์สนับสนุนด้วยข้อมูลต้นฉบับ เรากำลังสร้างตาข่ายเพื่อลงจุด
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_classifier.SVC(kernel='linear',
C=C, decision_function_shape = 'ovr').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('SVC with linear kernel')
การถดถอยโลจิสติก
โดยพื้นฐานแล้วแบบจำลองการถดถอยโลจิสติกเป็นหนึ่งในสมาชิกของกลุ่มอัลกอริธึมการจำแนกประเภทภายใต้การดูแล การถดถอยโลจิสติกจะวัดความสัมพันธ์ระหว่างตัวแปรตามและตัวแปรอิสระโดยการประมาณความน่าจะเป็นโดยใช้ฟังก์ชันโลจิสติกส์
ที่นี่ถ้าเราพูดถึงตัวแปรตามและตัวแปรอิสระตัวแปรตามคือตัวแปรคลาสเป้าหมายที่เราจะทำนายและอีกด้านหนึ่งตัวแปรอิสระคือคุณสมบัติที่เราจะใช้ในการทำนายคลาสเป้าหมาย
ในการถดถอยโลจิสติกการประมาณความน่าจะเป็นหมายถึงการทำนายโอกาสที่จะเกิดเหตุการณ์ ตัวอย่างเช่นเจ้าของร้านต้องการทำนายว่าลูกค้าที่เข้ามาในร้านจะซื้อ play station (เป็นต้น) หรือไม่ จะมีคุณสมบัติหลายอย่างของลูกค้า - เพศอายุ ฯลฯ ซึ่งจะสังเกตได้จากผู้ดูแลร้านเพื่อทำนายความเป็นไปได้ที่จะเกิดขึ้นเช่นซื้อเครื่องเล่นหรือไม่ ฟังก์ชันโลจิสติกคือเส้นโค้งซิกมอยด์ที่ใช้ในการสร้างฟังก์ชันด้วยพารามิเตอร์ต่างๆ
ข้อกำหนดเบื้องต้น
ก่อนสร้างลักษณนามโดยใช้การถดถอยโลจิสติกเราจำเป็นต้องติดตั้งแพ็คเกจ Tkinter ในระบบของเรา สามารถติดตั้งได้จากhttps://docs.python.org/2/library/tkinter.html.
ตอนนี้ด้วยความช่วยเหลือของรหัสที่ระบุด้านล่างเราสามารถสร้างลักษณนามโดยใช้การถดถอยโลจิสติก -
ขั้นแรกเราจะนำเข้าบางแพ็คเกจ -
import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt
ตอนนี้เราต้องกำหนดข้อมูลตัวอย่างซึ่งสามารถทำได้ดังนี้ -
X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
[3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])
ต่อไปเราต้องสร้างลักษณนามการถดถอยโลจิสติกซึ่งสามารถทำได้ดังนี้ -
Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)
สุดท้าย แต่ไม่ท้ายสุดเราต้องฝึกลักษณนามนี้ -
Classifier_LR.fit(X, y)
ทีนี้เราจะเห็นภาพผลลัพธ์ได้อย่างไร? สามารถทำได้โดยสร้างฟังก์ชันชื่อ Logistic_visualize () -
Def Logistic_visualize(Classifier_LR, X, y):
min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0
ในบรรทัดด้านบนเรากำหนดค่าต่ำสุดและสูงสุด X และ Y ที่จะใช้ในตารางตาข่าย นอกจากนี้เราจะกำหนดขนาดขั้นตอนสำหรับการลงจุดตารางตาข่าย
mesh_step_size = 0.02
ให้เรากำหนดตารางตาข่ายของค่า X และ Y ดังต่อไปนี้ -
x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
np.arange(min_y, max_y, mesh_step_size))
ด้วยความช่วยเหลือของรหัสต่อไปนี้เราสามารถเรียกใช้ลักษณนามบนตารางตาข่าย -
output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black',
linewidth=1, cmap = plt.cm.Paired)
โค้ดบรรทัดต่อไปนี้จะระบุขอบเขตของพล็อต
plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()
ตอนนี้หลังจากรันโค้ดแล้วเราจะได้ผลลัพธ์ต่อไปนี้ลักษณนามการถดถอยโลจิสติกส์ -
ลักษณนามทรีการตัดสินใจ
แผนผังการตัดสินใจเป็นผังงานต้นไม้ไบนารีที่แต่ละโหนดแยกกลุ่มการสังเกตตามตัวแปรคุณลักษณะบางอย่าง
ที่นี่เรากำลังสร้างลักษณนาม Decision Tree สำหรับทำนายเพศชายหรือเพศหญิง เราจะใช้ชุดข้อมูลขนาดเล็กมากซึ่งมี 19 ตัวอย่าง ตัวอย่างเหล่านี้จะประกอบด้วยคุณสมบัติสองประการ - "ความสูง" และ "ความยาวของผม"
ข้อกำหนดเบื้องต้น
สำหรับการสร้างลักษณนามต่อไปนี้เราจำเป็นต้องติดตั้ง pydotplus และ graphviz. โดยทั่วไปแล้ว graphviz เป็นเครื่องมือสำหรับการวาดภาพกราฟิกโดยใช้ไฟล์ dot และpydotplusเป็นโมดูลสำหรับภาษา Dot ของ Graphviz สามารถติดตั้งด้วยตัวจัดการแพ็คเกจหรือ pip
ตอนนี้เราสามารถสร้างลักษณนามทรีการตัดสินใจได้โดยใช้รหัส Python ต่อไปนี้ -
ในการเริ่มต้นให้เรานำเข้าไลบรารีที่สำคัญบางส่วนดังนี้ -
import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections
ตอนนี้เราต้องจัดเตรียมชุดข้อมูลดังนี้ -
X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]
Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']
X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)
หลังจากจัดเตรียมชุดข้อมูลแล้วเราจำเป็นต้องใส่แบบจำลองซึ่งสามารถทำได้ดังนี้ -
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)
การทำนายสามารถทำได้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
prediction = clf.predict([[133,37]])
print(prediction)
เราสามารถเห็นภาพแผนผังการตัดสินใจด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)
for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))
for edge in edges: edges[edge].sort()
for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')
มันจะให้การคาดการณ์สำหรับรหัสข้างต้นเป็น [‘Woman’] และสร้างแผนผังการตัดสินใจต่อไปนี้ -
เราสามารถเปลี่ยนค่าของคุณสมบัติในการทำนายเพื่อทดสอบได้
ลักษณนามป่าสุ่ม
อย่างที่เราทราบกันดีว่าวิธีการทั้งมวลเป็นวิธีการที่รวมโมเดลการเรียนรู้ของเครื่องเข้ากับโมเดลการเรียนรู้ของเครื่องที่มีประสิทธิภาพมากขึ้น Random Forest ซึ่งเป็นกลุ่มของต้นไม้แห่งการตัดสินใจเป็นหนึ่งในนั้น จะดีกว่าโครงสร้างการตัดสินใจเพียงครั้งเดียวเนื่องจากในขณะที่รักษาอำนาจในการคาดการณ์ไว้ก็สามารถลดความเหมาะสมมากเกินไปโดยการหาค่าเฉลี่ยของผลลัพธ์ ที่นี่เราจะนำแบบจำลองฟอเรสต์สุ่มไปใช้กับชุดข้อมูลการเรียนรู้มะเร็งของ scikit
นำเข้าแพ็คเกจที่จำเป็น -
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np
ตอนนี้เราต้องจัดเตรียมชุดข้อมูลซึ่งสามารถทำได้ดังนี้ & ลบ
cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)
หลังจากจัดเตรียมชุดข้อมูลแล้วเราจำเป็นต้องใส่แบบจำลองซึ่งสามารถทำได้ดังนี้ -
forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)
ตอนนี้รับความแม่นยำในการฝึกอบรมและชุดย่อยการทดสอบ: ถ้าเราจะเพิ่มจำนวนตัวประมาณค่าความแม่นยำของชุดทดสอบก็จะเพิ่มขึ้นด้วย
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))
เอาต์พุต
Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965
ตอนนี้เช่นเดียวกับต้นไม้ตัดสินใจป่าสุ่มมี feature_importanceโมดูลซึ่งจะให้มุมมองของน้ำหนักคุณลักษณะได้ดีกว่าโครงสร้างการตัดสินใจ สามารถพล็อตและเห็นภาพได้ดังนี้ -
n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()
ประสิทธิภาพของลักษณนาม
หลังจากใช้อัลกอริธึมแมชชีนเลิร์นนิงแล้วเราจำเป็นต้องค้นหาว่าโมเดลมีประสิทธิภาพเพียงใด เกณฑ์ในการวัดประสิทธิภาพอาจขึ้นอยู่กับชุดข้อมูลและเมตริก สำหรับการประเมินอัลกอริทึมการเรียนรู้ของเครื่องที่แตกต่างกันเราสามารถใช้เมตริกประสิทธิภาพที่แตกต่างกันได้ ตัวอย่างเช่นสมมติว่าหากมีการใช้ลักษณนามเพื่อแยกความแตกต่างระหว่างรูปภาพของวัตถุต่าง ๆ เราสามารถใช้เมตริกประสิทธิภาพการจัดหมวดหมู่เช่นความแม่นยำเฉลี่ย AUC เป็นต้นหรือในอีกแง่หนึ่งเมตริกที่เราเลือกเพื่อประเมินโมเดลการเรียนรู้ของเครื่องคือ สำคัญมากเนื่องจากการเลือกเมตริกมีผลต่อการวัดและเปรียบเทียบประสิทธิภาพของอัลกอริทึมการเรียนรู้ของเครื่อง ต่อไปนี้เป็นเมตริกบางส่วน -
เมทริกซ์ความสับสน
โดยทั่วไปจะใช้สำหรับปัญหาการจำแนกประเภทที่เอาต์พุตอาจเป็นคลาสสองประเภทขึ้นไป เป็นวิธีที่ง่ายที่สุดในการวัดประสิทธิภาพของลักษณนาม เมทริกซ์ความสับสนโดยพื้นฐานแล้วเป็นตารางที่มีสองมิติคือ "ตามจริง" และ "คาดการณ์" มิติข้อมูลทั้งสองมี“ True Positives (TP)”,“ True Negatives (TN)”,“ False Positives (FP)”,“ False Negatives (FN)”
ในเมทริกซ์ความสับสนด้านบน 1 คือคลาสบวกและ 0 สำหรับคลาสลบ
ต่อไปนี้เป็นคำศัพท์ที่เกี่ยวข้องกับ Confusion matrix -
True Positives − TPs คือกรณีที่คลาสจริงของจุดข้อมูลคือ 1 และการคาดการณ์ก็คือ 1 เช่นกัน
True Negatives − TN เป็นกรณีที่คลาสจริงของจุดข้อมูลคือ 0 และการทำนายเป็น 0 ด้วย
False Positives − FPs คือกรณีที่คลาสจริงของจุดข้อมูลคือ 0 และการคาดการณ์ก็คือ 1 เช่นกัน
False Negatives − FN เป็นกรณีที่คลาสจริงของจุดข้อมูลคือ 1 และการคาดการณ์เป็น 0 เช่นกัน
ความถูกต้อง
เมทริกซ์ความสับสนนั้นไม่ได้เป็นตัวชี้วัดประสิทธิภาพเช่นนี้ แต่เมทริกซ์ประสิทธิภาพเกือบทั้งหมดจะขึ้นอยู่กับเมทริกซ์ความสับสน หนึ่งในนั้นคือความถูกต้อง ในปัญหาการจำแนกประเภทอาจกำหนดเป็นจำนวนการคาดคะเนที่ถูกต้องซึ่งทำโดยแบบจำลองมากกว่าการคาดคะเนทุกประเภท สูตรการคำนวณความแม่นยำมีดังนี้ -
$$ ความแม่นยำ = \ frac {TP + TN} {TP + FP + FN + TN} $$
ความแม่นยำ
ส่วนใหญ่จะใช้ในการดึงเอกสาร อาจกำหนดเป็นจำนวนเอกสารที่ส่งคืนถูกต้อง ต่อไปนี้เป็นสูตรคำนวณความแม่นยำ -
$$ แม่นยำ = \ frac {TP} {TP + FP} $$
การเรียกคืนหรือความอ่อนไหว
อาจกำหนดเป็นจำนวนผลบวกที่โมเดลส่งกลับมา ต่อไปนี้เป็นสูตรคำนวณการเรียกคืน / ความไวของแบบจำลอง -
$$ Recall = \ frac {TP} {TP + FN} $$
ความจำเพาะ
อาจกำหนดเป็นจำนวนเชิงลบที่โมเดลส่งคืน มันตรงข้ามกับการจำ ต่อไปนี้เป็นสูตรคำนวณความจำเพาะของแบบจำลอง -
$$ ความจำเพาะ = \ frac {TN} {TN + FP} $$
ปัญหาความไม่สมดุลของคลาส
ความไม่สมดุลของคลาสคือสถานการณ์ที่จำนวนการสังเกตของคลาสหนึ่งต่ำกว่าคลาสอื่นอย่างมีนัยสำคัญ ตัวอย่างเช่นปัญหานี้มีความโดดเด่นในสถานการณ์ที่เราจำเป็นต้องระบุโรคที่หายากธุรกรรมหลอกลวงในธนาคารเป็นต้น
ตัวอย่างคลาสที่ไม่สมดุล
ให้เราพิจารณาตัวอย่างของชุดข้อมูลการตรวจจับการฉ้อโกงเพื่อทำความเข้าใจแนวคิดของคลาสที่ไม่สมดุล -
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%
วิธีการแก้
Balancing the classes’ทำหน้าที่เป็นวิธีแก้ปัญหาสำหรับชั้นเรียนที่ไม่สมดุล วัตถุประสงค์หลักของการปรับสมดุลของคลาสคือการเพิ่มความถี่ของคลาสของชนกลุ่มน้อยหรือลดความถี่ของคลาสส่วนใหญ่ ต่อไปนี้เป็นแนวทางในการแก้ปัญหาความไม่สมดุลของคลาส -
การสุ่มตัวอย่างซ้ำ
การสุ่มตัวอย่างซ้ำเป็นชุดวิธีการที่ใช้ในการสร้างชุดข้อมูลตัวอย่างขึ้นใหม่ทั้งชุดฝึกและชุดทดสอบ ทำการสุ่มตัวอย่างซ้ำเพื่อปรับปรุงความแม่นยำของแบบจำลอง ต่อไปนี้เป็นเทคนิคการสุ่มตัวอย่างซ้ำบางส่วน -
Random Under-Sampling- เทคนิคนี้มีจุดมุ่งหมายเพื่อสร้างสมดุลของการกระจายชั้นเรียนโดยการสุ่มกำจัดตัวอย่างชั้นเรียนส่วนใหญ่ สิ่งนี้จะทำจนกว่าอินสแตนซ์คลาสส่วนใหญ่และคลาสส่วนน้อยจะสมดุลกัน
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%
ในกรณีนี้เราจะนำตัวอย่าง 10% โดยไม่มีการเปลี่ยนจากอินสแตนซ์ที่ไม่ใช่การฉ้อโกงจากนั้นรวมเข้ากับอินสแตนซ์การฉ้อโกง -
การสังเกตที่ไม่เป็นการฉ้อโกงหลังจากการสุ่มภายใต้การสุ่มตัวอย่าง = 10% ของ 4950 = 495
การสังเกตการณ์ทั้งหมดหลังจากรวมเข้ากับการสังเกตการณ์หลอกลวง = 50 + 495 = 545
ดังนั้นตอนนี้อัตราเหตุการณ์สำหรับชุดข้อมูลใหม่หลังจากอยู่ภายใต้การสุ่มตัวอย่าง = 9%
ข้อได้เปรียบหลักของเทคนิคนี้คือสามารถลดเวลาในการทำงานและปรับปรุงการจัดเก็บ แต่ในอีกด้านหนึ่งก็สามารถทิ้งข้อมูลที่เป็นประโยชน์ในขณะที่ลดจำนวนตัวอย่างข้อมูลการฝึกอบรม
Random Over-Sampling - เทคนิคนี้มีจุดมุ่งหมายเพื่อสร้างสมดุลของการกระจายคลาสโดยการเพิ่มจำนวนอินสแตนซ์ในคลาสของชนกลุ่มน้อยโดยการจำลองแบบ
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%
ในกรณีที่เราจำลองการสังเกตการณ์หลอกลวง 50 ครั้ง 30 ครั้งการสังเกตการณ์ที่ฉ้อโกงหลังจากจำลองแบบการสังเกตการณ์ของชนกลุ่มน้อยจะเท่ากับ 1,500 จากนั้นการสังเกตการณ์ทั้งหมดในข้อมูลใหม่หลังจากการสุ่มตัวอย่างเกินจะเท่ากับ 4950 + 1500 = 6450 ดังนั้นอัตราเหตุการณ์สำหรับชุดข้อมูลใหม่ จะเป็น 1500/6450 = 23%
ข้อได้เปรียบหลักของวิธีนี้คือจะไม่มีการสูญเสียข้อมูลที่เป็นประโยชน์ แต่ในทางกลับกันก็มีโอกาสที่จะสวมใส่มากเกินไปเนื่องจากเป็นการจำลองเหตุการณ์ของชนกลุ่มน้อย
เทคนิคทั้งมวล
วิธีการนี้โดยทั่วไปใช้เพื่อแก้ไขอัลกอริทึมการจำแนกที่มีอยู่เพื่อให้เหมาะสมกับชุดข้อมูลที่ไม่สมดุล ในวิธีนี้เราสร้างตัวจำแนกสองขั้นตอนจากข้อมูลเดิมจากนั้นจึงรวมการคาดการณ์ ลักษณนามฟอเรสต์แบบสุ่มเป็นตัวอย่างของลักษณนามตามทั้งมวล
การถดถอยเป็นเครื่องมือทางสถิติและการเรียนรู้ของเครื่องที่สำคัญที่สุดอย่างหนึ่ง เราคงไม่ผิดหากจะบอกว่าเส้นทางของการเรียนรู้ของเครื่องเริ่มต้นจากการถดถอย อาจถูกกำหนดให้เป็นเทคนิคพาราเมตริกที่ช่วยให้เราสามารถตัดสินใจโดยอาศัยข้อมูลหรือกล่าวอีกนัยหนึ่งช่วยให้เราทำการคาดการณ์จากข้อมูลโดยเรียนรู้ความสัมพันธ์ระหว่างตัวแปรอินพุตและเอาต์พุต ที่นี่ตัวแปรเอาต์พุตขึ้นอยู่กับตัวแปรอินพุตเป็นจำนวนจริงที่มีมูลค่าต่อเนื่อง ในการถดถอยความสัมพันธ์ระหว่างตัวแปรอินพุตและเอาต์พุตมีความสำคัญและช่วยให้เราเข้าใจว่าค่าของตัวแปรเอาต์พุตเปลี่ยนแปลงไปอย่างไรเมื่อมีการเปลี่ยนแปลงตัวแปรอินพุต การถดถอยมักใช้ในการทำนายราคาเศรษฐศาสตร์การเปลี่ยนแปลงและอื่น ๆ
การสร้าง Regressors ใน Python
ในส่วนนี้เราจะได้เรียนรู้วิธีการสร้างตัวถอยหลังแบบเดี่ยวและแบบหลายตัวแปร
Linear Regressor / ตัวควบคุมตัวแปรเดียว
ให้เราสำคัญแพ็คเกจที่จำเป็นบางอย่าง -
import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
ตอนนี้เราจำเป็นต้องให้ข้อมูลอินพุตและเราได้บันทึกข้อมูลของเราไว้ในไฟล์ชื่อ linear.txt
input = 'D:/ProgramData/linear.txt'
เราจำเป็นต้องโหลดข้อมูลนี้โดยใช้ไฟล์ np.loadtxt ฟังก์ชัน
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
ขั้นตอนต่อไปคือการฝึกโมเดล ให้เราฝึกอบรมและทดสอบตัวอย่าง
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:]
ตอนนี้เราจำเป็นต้องสร้างวัตถุตัวถอยหลังเชิงเส้น
reg_linear = linear_model.LinearRegression()
ฝึกวัตถุด้วยตัวอย่างการฝึกอบรม
reg_linear.fit(X_train, y_train)
เราจำเป็นต้องทำการคาดคะเนด้วยข้อมูลการทดสอบ
y_test_pred = reg_linear.predict(X_test)
ตอนนี้วางแผนและแสดงภาพข้อมูล
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()
เอาต์พุต
ตอนนี้เราสามารถคำนวณประสิทธิภาพของการถดถอยเชิงเส้นได้ดังนี้ -
print("Performance of Linear regressor:")
print("Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =", 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))
เอาต์พุต
ประสิทธิภาพของ Linear Regressor -
Mean absolute error = 1.78
Mean squared error = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09
ในโค้ดด้านบนเราได้ใช้ข้อมูลขนาดเล็กนี้ หากคุณต้องการชุดข้อมูลขนาดใหญ่คุณสามารถใช้ sklearn.dataset เพื่อนำเข้าชุดข้อมูลที่ใหญ่ขึ้น
2,4.82.9,4.72.5,53.2,5.56,57.6,43.2,0.92.9,1.92.4,
3.50.5,3.41,40.9,5.91.2,2.583.2,5.65.1,1.54.5,
1.22.3,6.32.1,2.8
Regressor หลายตัวแปร
ขั้นแรกให้เรานำเข้าแพ็คเกจที่จำเป็นบางอย่าง -
import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
ตอนนี้เราจำเป็นต้องให้ข้อมูลอินพุตและเราได้บันทึกข้อมูลของเราไว้ในไฟล์ชื่อ linear.txt
input = 'D:/ProgramData/Mul_linear.txt'
เราจะโหลดข้อมูลนี้โดยใช้ไฟล์ np.loadtxt ฟังก์ชัน
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
ขั้นตอนต่อไปคือการฝึกโมเดล เราจะให้การฝึกอบรมและการทดสอบตัวอย่าง
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:]
ตอนนี้เราจำเป็นต้องสร้างวัตถุตัวถอยหลังเชิงเส้น
reg_linear_mul = linear_model.LinearRegression()
ฝึกวัตถุด้วยตัวอย่างการฝึกอบรม
reg_linear_mul.fit(X_train, y_train)
ในที่สุดเราต้องทำการคาดการณ์ด้วยข้อมูลการทดสอบ
y_test_pred = reg_linear_mul.predict(X_test)
print("Performance of Linear regressor:")
print("Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =", 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))
เอาต์พุต
ประสิทธิภาพของ Linear Regressor -
Mean absolute error = 0.6
Mean squared error = 0.65
Median absolute error = 0.41
Explain variance score = 0.34
R2 score = 0.33
ตอนนี้เราจะสร้างพหุนามดีกรี 10 และฝึกตัวถอยหลัง เราจะจัดเตรียมจุดข้อมูลตัวอย่าง
polynomial = PolynomialFeatures(degree = 10)
X_train_transformed = polynomial.fit_transform(X_train)
datapoint = [[2.23, 1.35, 1.12]]
poly_datapoint = polynomial.fit_transform(datapoint)
poly_linear_model = linear_model.LinearRegression()
poly_linear_model.fit(X_train_transformed, y_train)
print("\nLinear regression:\n", reg_linear_mul.predict(datapoint))
print("\nPolynomial regression:\n", poly_linear_model.predict(poly_datapoint))
เอาต์พุต
การถดถอยเชิงเส้น -
[2.40170462]
การถดถอยพหุนาม -
[1.8697225]
ในโค้ดด้านบนเราได้ใช้ข้อมูลขนาดเล็กนี้ หากคุณต้องการชุดข้อมูลขนาดใหญ่คุณสามารถใช้ sklearn.dataset เพื่อนำเข้าชุดข้อมูลที่ใหญ่ขึ้น
2,4.8,1.2,3.22.9,4.7,1.5,3.62.5,5,2.8,23.2,5.5,3.5,2.16,5,
2,3.27.6,4,1.2,3.23.2,0.9,2.3,1.42.9,1.9,2.3,1.22.4,3.5,
2.8,3.60.5,3.4,1.8,2.91,4,3,2.50.9,5.9,5.6,0.81.2,2.58,
3.45,1.233.2,5.6,2,3.25.1,1.5,1.2,1.34.5,1.2,4.1,2.32.3,
6.3,2.5,3.22.1,2.8,1.2,3.6
ในบทนี้เราจะเน้นการเขียนโปรแกรมเชิงตรรกะและวิธีการช่วยในปัญญาประดิษฐ์
เรารู้อยู่แล้วว่าตรรกะคือการศึกษาหลักการของการใช้เหตุผลที่ถูกต้องหรือพูดง่ายๆก็คือการศึกษาสิ่งที่เกิดขึ้นหลังจากอะไร ตัวอย่างเช่นหากสองคำสั่งเป็นจริงเราสามารถอนุมานคำสั่งที่สามจากคำสั่งนั้นได้
แนวคิด
Logic Programming คือการรวมกันของสองคำตรรกะและการเขียนโปรแกรม Logic Programming เป็นกระบวนทัศน์ในการเขียนโปรแกรมซึ่งปัญหาจะแสดงเป็นข้อเท็จจริงและกฎเกณฑ์โดยคำสั่งของโปรแกรม แต่อยู่ในระบบของตรรกะที่เป็นทางการ เช่นเดียวกับกระบวนทัศน์การเขียนโปรแกรมอื่น ๆ เช่นเชิงวัตถุการใช้งานการประกาศและขั้นตอนเป็นต้นนอกจากนี้ยังเป็นวิธีเฉพาะในการเข้าถึงการเขียนโปรแกรม
วิธีแก้ปัญหาเกี่ยวกับการเขียนโปรแกรมลอจิก
Logic Programming ใช้ข้อเท็จจริงและกฎเกณฑ์ในการแก้ปัญหา นั่นคือเหตุผลที่พวกเขาเรียกว่า Building Block ของ Logic Programming ต้องระบุเป้าหมายสำหรับทุกโปรแกรมในการเขียนโปรแกรมลอจิก เพื่อให้เข้าใจว่าปัญหาสามารถแก้ไขได้อย่างไรในการเขียนโปรแกรมลอจิกเราจำเป็นต้องรู้เกี่ยวกับหน่วยการสร้าง - ข้อเท็จจริงและกฎ -
ข้อเท็จจริง
จริงๆแล้วโปรแกรมลอจิกทุกโปรแกรมต้องการข้อเท็จจริงเพื่อให้สามารถบรรลุเป้าหมายที่กำหนดได้ ข้อเท็จจริงโดยทั่วไปคือข้อความที่เป็นจริงเกี่ยวกับโปรแกรมและข้อมูล ตัวอย่างเช่นเดลีเป็นเมืองหลวงของอินเดีย
กฎ
จริงๆแล้วกฎเป็นข้อ จำกัด ที่ช่วยให้เราสามารถสรุปเกี่ยวกับโดเมนปัญหาได้ กฎที่เขียนโดยทั่วไปเป็นข้อตรรกะเพื่อแสดงข้อเท็จจริงต่างๆ ตัวอย่างเช่นหากเรากำลังสร้างเกมใด ๆ ก็ต้องกำหนดกฎทั้งหมด
กฎมีความสำคัญมากในการแก้ปัญหาใน Logic Programming กฎเป็นข้อสรุปเชิงตรรกะซึ่งสามารถแสดงข้อเท็จจริงได้ ต่อไปนี้เป็นไวยากรณ์ของกฎ -
A∶− B1, B2, ... , B n .
ที่นี่ A คือหัวและ B1, B2, ... Bn คือร่างกาย
ตัวอย่างเช่น - บรรพบุรุษ (X, Y): - พ่อ (X, Y)
บรรพบุรุษ (X, Z): - พ่อ (X, Y) บรรพบุรุษ (Y, Z)
สามารถอ่านได้ว่าสำหรับ X และ Y ทุกตัวถ้า X เป็นพ่อของ Y และ Y เป็นบรรพบุรุษของ Z X คือบรรพบุรุษของ Z สำหรับ X และ Y ทุกตัว X คือบรรพบุรุษของ Z ถ้า X คือ พ่อของ Y และ Y เป็นบรรพบุรุษของ Z
การติดตั้งแพ็คเกจที่มีประโยชน์
สำหรับการเริ่มต้นการเขียนโปรแกรมลอจิกใน Python เราจำเป็นต้องติดตั้งสองแพ็คเกจต่อไปนี้ -
Kanren
ช่วยให้เราสามารถลดความซับซ้อนของวิธีการสร้างโค้ดสำหรับตรรกะทางธุรกิจได้ ช่วยให้เราสามารถแสดงตรรกะในแง่ของกฎและข้อเท็จจริง คำสั่งต่อไปนี้จะช่วยคุณติดตั้ง kanren -
pip install kanren
SymPy
SymPy เป็นไลบรารี Python สำหรับคณิตศาสตร์สัญลักษณ์ มีจุดมุ่งหมายเพื่อให้เป็นระบบพีชคณิตคอมพิวเตอร์ที่มีคุณสมบัติครบถ้วน (CAS) ในขณะที่รักษารหัสให้เรียบง่ายที่สุดเท่าที่จะเป็นไปได้เพื่อให้เข้าใจง่ายและขยายได้ง่าย คำสั่งต่อไปนี้จะช่วยคุณติดตั้ง SymPy -
pip install sympy
ตัวอย่างการเขียนโปรแกรมลอจิก
ต่อไปนี้เป็นตัวอย่างบางส่วนที่สามารถแก้ไขได้โดยการเขียนโปรแกรมลอจิก -
การจับคู่นิพจน์ทางคณิตศาสตร์
จริงๆแล้วเราสามารถค้นหาค่าที่ไม่รู้จักได้โดยใช้การเขียนโปรแกรมตรรกะอย่างมีประสิทธิภาพ รหัส Python ต่อไปนี้จะช่วยให้คุณจับคู่นิพจน์ทางคณิตศาสตร์ -
พิจารณานำเข้าแพ็คเกจต่อไปนี้ก่อน -
from kanren import run, var, fact
from kanren.assoccomm import eq_assoccomm as eq
from kanren.assoccomm import commutative, associative
เราจำเป็นต้องกำหนดการดำเนินการทางคณิตศาสตร์ที่เราจะใช้ -
add = 'add'
mul = 'mul'
ทั้งการบวกและการคูณเป็นกระบวนการสื่อสาร ดังนั้นเราจำเป็นต้องระบุและสามารถทำได้ดังนี้ -
fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)
จำเป็นต้องกำหนดตัวแปร สามารถทำได้ดังนี้ -
a, b = var('a'), var('b')
เราจำเป็นต้องจับคู่นิพจน์กับรูปแบบเดิม เรามีรูปแบบดั้งเดิมดังต่อไปนี้ซึ่งโดยพื้นฐานแล้ว (5 + a) * b -
Original_pattern = (mul, (add, 5, a), b)
เรามีสองนิพจน์ต่อไปนี้เพื่อจับคู่กับรูปแบบดั้งเดิม -
exp1 = (mul, 2, (add, 3, 1))
exp2 = (add,5,(mul,8,1))
สามารถพิมพ์เอาต์พุตได้ด้วยคำสั่งต่อไปนี้ -
print(run(0, (a,b), eq(original_pattern, exp1)))
print(run(0, (a,b), eq(original_pattern, exp2)))
หลังจากรันโค้ดนี้เราจะได้ผลลัพธ์ต่อไปนี้ -
((3,2))
()
ผลลัพธ์แรกแสดงถึงค่าสำหรับ a และ b. นิพจน์แรกตรงกับรูปแบบดั้งเดิมและส่งคืนค่าสำหรับa และ b แต่นิพจน์ที่สองไม่ตรงกับรูปแบบเดิมจึงไม่มีการส่งคืน
กำลังตรวจหา Prime Numbers
ด้วยความช่วยเหลือของการเขียนโปรแกรมตรรกะเราสามารถค้นหาจำนวนเฉพาะจากรายการตัวเลขและยังสามารถสร้างจำนวนเฉพาะได้ รหัส Python ที่ระบุด้านล่างจะค้นหาจำนวนเฉพาะจากรายการตัวเลขและจะสร้างจำนวนเฉพาะ 10 ตัวแรก
ให้เราพิจารณาการนำเข้าแพ็คเกจต่อไปนี้ก่อน -
from kanren import isvar, run, membero
from kanren.core import success, fail, goaleval, condeseq, eq, var
from sympy.ntheory.generate import prime, isprime
import itertools as it
ตอนนี้เราจะกำหนดฟังก์ชันที่เรียกว่า prime_check ซึ่งจะตรวจสอบจำนวนเฉพาะตามตัวเลขที่กำหนดเป็นข้อมูล
def prime_check(x):
if isvar(x):
return condeseq([(eq,x,p)] for p in map(prime, it.count(1)))
else:
return success if isprime(x) else fail
ตอนนี้เราต้องประกาศตัวแปรที่จะใช้ -
x = var()
print((set(run(0,x,(membero,x,(12,14,15,19,20,21,22,23,29,30,41,44,52,62,65,85)),
(prime_check,x)))))
print((run(10,x,prime_check(x))))
ผลลัพธ์ของโค้ดด้านบนจะเป็นดังนี้ -
{19, 23, 29, 41}
(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
การแก้ปริศนา
การเขียนโปรแกรมลอจิกสามารถใช้เพื่อแก้ปัญหาต่างๆเช่น 8-puzzle, Zebra puzzle, Sudoku, N-queen เป็นต้นต่อไปนี้เราจะยกตัวอย่างของตัวต่อ Zebra ที่แตกต่างกันซึ่งมีดังต่อไปนี้ -
There are five houses.
The English man lives in the red house.
The Swede has a dog.
The Dane drinks tea.
The green house is immediately to the left of the white house.
They drink coffee in the green house.
The man who smokes Pall Mall has birds.
In the yellow house they smoke Dunhill.
In the middle house they drink milk.
The Norwegian lives in the first house.
The man who smokes Blend lives in the house next to the house with cats.
In a house next to the house where they have a horse, they smoke Dunhill.
The man who smokes Blue Master drinks beer.
The German smokes Prince.
The Norwegian lives next to the blue house.
They drink water in a house next to the house where they smoke Blend.
เรากำลังแก้ปัญหาสำหรับคำถามนี้ who owns zebra ด้วยความช่วยเหลือของ Python
ให้เรานำเข้าแพ็คเกจที่จำเป็น -
from kanren import *
from kanren.core import lall
import time
ตอนนี้เราต้องกำหนดสองฟังก์ชัน - left() และ next() เพื่อตรวจสอบว่าบ้านใครเหลืออยู่หรือข้างบ้านใคร -
def left(q, p, list):
return membero((q,p), zip(list, list[1:]))
def next(q, p, list):
return conde([left(q, p, list)], [left(p, q, list)])
ตอนนี้เราจะประกาศตัวแปรบ้านดังนี้ -
houses = var()
เราจำเป็นต้องกำหนดกฎด้วยความช่วยเหลือของแพ็คเกจ lall ดังนี้
มีบ้าน 5 หลัง -
rules_zebraproblem = lall(
(eq, (var(), var(), var(), var(), var()), houses),
(membero,('Englishman', var(), var(), var(), 'red'), houses),
(membero,('Swede', var(), var(), 'dog', var()), houses),
(membero,('Dane', var(), 'tea', var(), var()), houses),
(left,(var(), var(), var(), var(), 'green'),
(var(), var(), var(), var(), 'white'), houses),
(membero,(var(), var(), 'coffee', var(), 'green'), houses),
(membero,(var(), 'Pall Mall', var(), 'birds', var()), houses),
(membero,(var(), 'Dunhill', var(), var(), 'yellow'), houses),
(eq,(var(), var(), (var(), var(), 'milk', var(), var()), var(), var()), houses),
(eq,(('Norwegian', var(), var(), var(), var()), var(), var(), var(), var()), houses),
(next,(var(), 'Blend', var(), var(), var()),
(var(), var(), var(), 'cats', var()), houses),
(next,(var(), 'Dunhill', var(), var(), var()),
(var(), var(), var(), 'horse', var()), houses),
(membero,(var(), 'Blue Master', 'beer', var(), var()), houses),
(membero,('German', 'Prince', var(), var(), var()), houses),
(next,('Norwegian', var(), var(), var(), var()),
(var(), var(), var(), var(), 'blue'), houses),
(next,(var(), 'Blend', var(), var(), var()),
(var(), var(), 'water', var(), var()), houses),
(membero,(var(), var(), var(), 'zebra', var()), houses)
)
ตอนนี้เรียกใช้ตัวแก้ปัญหาด้วยข้อ จำกัด ก่อนหน้านี้ -
solutions = run(0, houses, rules_zebraproblem)
ด้วยความช่วยเหลือของรหัสต่อไปนี้เราสามารถดึงเอาท์พุทจากตัวแก้ -
output_zebra = [house for house in solutions[0] if 'zebra' in house][0][0]
รหัสต่อไปนี้จะช่วยพิมพ์โซลูชัน -
print ('\n'+ output_zebra + 'owns zebra.')
ผลลัพธ์ของโค้ดด้านบนจะเป็นดังนี้ -
German owns zebra.
อัลกอริธึมการเรียนรู้ของเครื่องที่ไม่ได้รับการดูแลไม่มีหัวหน้างานคอยให้คำแนะนำใด ๆ นั่นคือเหตุผลที่พวกเขามีความสอดคล้องอย่างใกล้ชิดกับสิ่งที่บางคนเรียกว่าปัญญาประดิษฐ์ที่แท้จริง
ในการเรียนรู้ที่ไม่มีผู้ดูแลจะไม่มีคำตอบที่ถูกต้องและไม่มีครูคอยชี้แนะ อัลกอริทึมจำเป็นต้องค้นพบรูปแบบที่น่าสนใจในข้อมูลเพื่อการเรียนรู้
Clustering คืออะไร?
โดยพื้นฐานแล้วเป็นวิธีการเรียนรู้ที่ไม่มีการดูแลและเป็นเทคนิคทั่วไปสำหรับการวิเคราะห์ข้อมูลทางสถิติที่ใช้ในหลายสาขา การจัดกลุ่มส่วนใหญ่เป็นงานในการแบ่งชุดการสังเกตออกเป็นส่วนย่อยที่เรียกว่าคลัสเตอร์ในลักษณะที่การสังเกตในคลัสเตอร์เดียวกันมีความคล้ายคลึงกันในแง่หนึ่งและแตกต่างจากการสังเกตในกลุ่มอื่น พูดง่ายๆเราสามารถพูดได้ว่าเป้าหมายหลักของการจัดกลุ่มคือการจัดกลุ่มข้อมูลบนพื้นฐานของความเหมือนและความไม่เหมือนกัน
ตัวอย่างเช่นแผนภาพต่อไปนี้แสดงประเภทข้อมูลที่คล้ายกันในคลัสเตอร์ต่างๆ -
อัลกอริทึมสำหรับการทำคลัสเตอร์ข้อมูล
ต่อไปนี้เป็นอัลกอริทึมทั่วไปบางส่วนสำหรับการจัดกลุ่มข้อมูล -
K-mean อัลกอริทึม
K-mean clustering algorithm เป็นหนึ่งในอัลกอริทึมที่รู้จักกันดีสำหรับการทำคลัสเตอร์ข้อมูล เราต้องสมมติว่าทราบจำนวนคลัสเตอร์แล้ว เรียกอีกอย่างว่าการทำคลัสเตอร์แบบแบน เป็นอัลกอริธึมการทำคลัสเตอร์ซ้ำ ต้องปฏิบัติตามขั้นตอนด้านล่างสำหรับอัลกอริทึมนี้ -
Step 1 - เราจำเป็นต้องระบุจำนวน K กลุ่มย่อยที่ต้องการ
Step 2- แก้ไขจำนวนคลัสเตอร์และสุ่มกำหนดจุดข้อมูลแต่ละจุดให้กับคลัสเตอร์ หรือกล่าวอีกนัยหนึ่งเราต้องจัดประเภทข้อมูลของเราตามจำนวนคลัสเตอร์
ในขั้นตอนนี้ควรคำนวณคลัสเตอร์เซนทรอยด์
เนื่องจากนี่เป็นอัลกอริทึมแบบวนซ้ำเราจึงจำเป็นต้องอัปเดตตำแหน่งของ K centroids ทุกครั้งที่ทำซ้ำจนกว่าเราจะพบ global optima หรือกล่าวอีกนัยหนึ่งว่าเซนทรอยด์ไปถึงตำแหน่งที่เหมาะสมที่สุด
โค้ดต่อไปนี้จะช่วยในการใช้อัลกอริทึมการทำคลัสเตอร์ K-mean ใน Python เราจะใช้โมดูล Scikit-learn
ให้เรานำเข้าแพ็คเกจที่จำเป็น -
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
บรรทัดของโค้ดต่อไปนี้จะช่วยในการสร้างชุดข้อมูลสองมิติที่มีสี่ blobs โดยใช้ make_blob จาก sklearn.dataset แพ็คเกจ
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples = 500, centers = 4,
cluster_std = 0.40, random_state = 0)
เราสามารถเห็นภาพชุดข้อมูลโดยใช้รหัสต่อไปนี้ -
plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()
ที่นี่เรากำลังเริ่มต้น kmeans ให้เป็นอัลกอริทึม KMeans โดยมีพารามิเตอร์ที่ต้องการคือจำนวนคลัสเตอร์ (n_clusters)
kmeans = KMeans(n_clusters = 4)
เราจำเป็นต้องฝึกโมเดล K-mean ด้วยข้อมูลอินพุต
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')
centers = kmeans.cluster_centers_
รหัสที่ระบุด้านล่างจะช่วยให้เราวางแผนและเห็นภาพสิ่งที่ค้นพบของเครื่องตามข้อมูลของเราและการประกอบตามจำนวนคลัสเตอร์ที่จะพบ
plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()
ค่าเฉลี่ยกะอัลกอริทึม
เป็นอีกหนึ่งอัลกอริธึมการจัดกลุ่มที่ได้รับความนิยมและมีประสิทธิภาพที่ใช้ในการเรียนรู้ มันไม่ได้ตั้งสมมติฐานใด ๆ ด้วยเหตุนี้จึงเป็นอัลกอริทึมที่ไม่ใช่พารามิเตอร์ เรียกอีกอย่างว่าการจัดกลุ่มตามลำดับชั้นหรือการวิเคราะห์คลัสเตอร์กะค่าเฉลี่ย ขั้นตอนต่อไปนี้จะเป็นขั้นตอนพื้นฐานของอัลกอริทึมนี้ -
ก่อนอื่นเราต้องเริ่มต้นด้วยจุดข้อมูลที่กำหนดให้กับคลัสเตอร์ของตนเอง
ตอนนี้มันคำนวณเซนทรอยด์และอัปเดตตำแหน่งของเซนทรอยด์ใหม่
โดยการทำซ้ำขั้นตอนนี้เราจะเคลื่อนเข้าใกล้จุดสูงสุดของคลัสเตอร์ไปยังบริเวณที่มีความหนาแน่นสูงขึ้น
อัลกอริทึมนี้จะหยุดในขั้นตอนที่เซนทรอยด์ไม่เคลื่อนไหวอีกต่อไป
ด้วยความช่วยเหลือของโค้ดต่อไปนี้เรากำลังใช้อัลกอริทึมการทำคลัสเตอร์ Mean Shift ใน Python เราจะใช้โมดูล Scikit-learn
ให้เรานำเข้าแพ็คเกจที่จำเป็น -
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
รหัสต่อไปนี้จะช่วยในการสร้างชุดข้อมูลสองมิติที่มีสี่จุดโดยใช้ make_blob จาก sklearn.dataset แพ็คเกจ
from sklearn.datasets.samples_generator import make_blobs
เราสามารถแสดงภาพชุดข้อมูลด้วยรหัสต่อไปนี้
centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()
ตอนนี้เราต้องฝึกโมเดลคลัสเตอร์ Mean Shift ด้วยข้อมูลอินพุต
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_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2
รหัสที่ระบุด้านล่างนี้จะช่วยในการวางแผนและแสดงภาพการค้นพบของเครื่องโดยอิงจากข้อมูลของเราและการประกอบตามจำนวนคลัสเตอร์ที่จะพบ
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 = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()
การวัดประสิทธิภาพการทำคลัสเตอร์
ข้อมูลในโลกแห่งความเป็นจริงไม่ได้ถูกจัดเป็นคลัสเตอร์ที่มีลักษณะเฉพาะตามธรรมชาติ ด้วยเหตุนี้จึงไม่ง่ายที่จะเห็นภาพและวาดการอนุมาน นั่นคือเหตุผลที่เราต้องวัดประสิทธิภาพการทำคลัสเตอร์รวมถึงคุณภาพของมัน สามารถทำได้ด้วยความช่วยเหลือของการวิเคราะห์ภาพเงา
การวิเคราะห์ภาพเงา
วิธีนี้สามารถใช้ตรวจสอบคุณภาพของการทำคลัสเตอร์โดยการวัดระยะห่างระหว่างคลัสเตอร์ โดยทั่วไปจะมีวิธีประเมินพารามิเตอร์เช่นจำนวนคลัสเตอร์โดยให้คะแนนเงา คะแนนนี้เป็นเมตริกที่วัดว่าแต่ละจุดในคลัสเตอร์หนึ่งอยู่ใกล้กับคะแนนในคลัสเตอร์ใกล้เคียงมากเพียงใด
การวิเคราะห์คะแนนเงา
คะแนนมีช่วง [-1, 1] ต่อไปนี้คือการวิเคราะห์คะแนนนี้ -
Score of +1 - คะแนนใกล้ +1 แสดงว่ากลุ่มตัวอย่างอยู่ห่างจากคลัสเตอร์ใกล้เคียง
Score of 0 - คะแนน 0 บ่งชี้ว่ากลุ่มตัวอย่างอยู่ในหรือใกล้กับขอบเขตการตัดสินใจระหว่างสองกลุ่มใกล้เคียง
Score of -1 - คะแนนติดลบแสดงว่าตัวอย่างถูกกำหนดให้กับคลัสเตอร์ที่ไม่ถูกต้อง
การคำนวณคะแนน Silhouette
ในส่วนนี้เราจะเรียนรู้วิธีการคำนวณคะแนนเงา
คะแนน Silhouette สามารถคำนวณได้โดยใช้สูตรต่อไปนี้ -
$$ คะแนนภาพเงา = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$
นี่คือระยะห่างเฉลี่ยไปยังจุดในคลัสเตอร์ที่ใกล้ที่สุดซึ่งจุดข้อมูลไม่ได้เป็นส่วนหนึ่งของ และคือระยะทางภายในคลัสเตอร์เฉลี่ยไปยังจุดทั้งหมดในคลัสเตอร์ของตนเอง
สำหรับการค้นหาจำนวนคลัสเตอร์ที่เหมาะสมที่สุดเราจำเป็นต้องเรียกใช้อัลกอริทึมการทำคลัสเตอร์อีกครั้งโดยการนำเข้าไฟล์ metrics โมดูลจาก sklearnแพ็คเกจ ในตัวอย่างต่อไปนี้เราจะเรียกใช้อัลกอริทึมการทำคลัสเตอร์ K-mean เพื่อค้นหาจำนวนคลัสเตอร์ที่เหมาะสมที่สุด -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
ด้วยความช่วยเหลือของรหัสต่อไปนี้เราจะสร้างชุดข้อมูลสองมิติที่มีสี่ blobs โดยใช้ make_blob จาก sklearn.dataset แพ็คเกจ
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples = 500, centers = 4, cluster_std = 0.40, random_state = 0)
เริ่มต้นตัวแปรตามที่แสดง -
scores = []
values = np.arange(2, 10)
เราจำเป็นต้องทำซ้ำแบบจำลอง K-mean ผ่านค่าทั้งหมดและต้องฝึกด้วยข้อมูลอินพุต
for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)
ตอนนี้ประมาณคะแนนเงาสำหรับโมเดลการทำคลัสเตอร์ปัจจุบันโดยใช้เมตริกระยะทางแบบยุคลิด -
score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))
โค้ดบรรทัดต่อไปนี้จะช่วยในการแสดงจำนวนคลัสเตอร์และคะแนน Silhouette
print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)
คุณจะได้รับผลลัพธ์ต่อไปนี้ -
Number of clusters = 9
Silhouette score = 0.340391138371
num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)
ตอนนี้ผลลัพธ์สำหรับจำนวนคลัสเตอร์ที่เหมาะสมที่สุดจะเป็นดังนี้ -
Optimal number of clusters = 2
ค้นหาเพื่อนบ้านที่ใกล้ที่สุด
หากเราต้องการสร้างระบบผู้แนะนำเช่นระบบผู้แนะนำภาพยนตร์เราจำเป็นต้องเข้าใจแนวคิดในการค้นหาเพื่อนบ้านที่ใกล้ที่สุด เป็นเพราะระบบผู้แนะนำใช้แนวคิดของเพื่อนบ้านที่ใกล้ที่สุด
concept of finding nearest neighborsอาจถูกกำหนดให้เป็นกระบวนการค้นหาจุดที่ใกล้เคียงที่สุดกับจุดอินพุตจากชุดข้อมูลที่กำหนด การใช้อัลกอริทึม KNN) K- เพื่อนบ้านที่ใกล้ที่สุด) คือการสร้างระบบการจำแนกประเภทที่จำแนกจุดข้อมูลบนความใกล้เคียงของจุดข้อมูลอินพุตไปยังคลาสต่างๆ
รหัส Python ที่ระบุด้านล่างช่วยในการค้นหาเพื่อนบ้านที่ใกล้ที่สุด K ของชุดข้อมูลที่กำหนด -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดงด้านล่าง ที่นี่เรากำลังใช้ไฟล์NearestNeighbors โมดูลจาก sklearn แพ็คเกจ
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
ตอนนี้ให้เรากำหนดข้อมูลอินพุต -
A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4], [4.8, 1.9],
[8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1], [4.4, 2.9],])
ตอนนี้เราต้องกำหนดเพื่อนบ้านที่ใกล้ที่สุด -
k = 3
เราต้องให้ข้อมูลการทดสอบจากเพื่อนบ้านที่ใกล้ที่สุด -
test_data = [3.3, 2.9]
โค้ดต่อไปนี้สามารถแสดงภาพและพล็อตข้อมูลอินพุตที่กำหนดโดยเรา -
plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')
ตอนนี้เราต้องสร้าง K ใกล้เคียงที่สุด วัตถุยังต้องได้รับการฝึกฝน
knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])
ตอนนี้เราสามารถพิมพ์ K เพื่อนบ้านที่ใกล้ที่สุดได้ดังนี้
print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
print(str(rank) + " is", A[index])
เราสามารถเห็นภาพเพื่อนบ้านที่อยู่ใกล้ที่สุดพร้อมกับจุดข้อมูลทดสอบ
plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color = 'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
marker = 'x', s = 100, color = 'k')
plt.show()
เอาต์พุต
K Nearest Neighbors
1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]
K- ลักษณนามเพื่อนบ้านที่ใกล้ที่สุด
ลักษณนาม K-Nearest Neighbours (KNN) คือรูปแบบการจำแนกประเภทที่ใช้อัลกอริทึมเพื่อนบ้านที่ใกล้ที่สุดเพื่อจำแนกจุดข้อมูลที่กำหนด เราได้ใช้อัลกอริทึม KNN ในส่วนสุดท้ายแล้วตอนนี้เรากำลังจะสร้างตัวจำแนก KNN โดยใช้อัลกอริทึมนั้น
แนวคิดของ KNN Classifier
แนวคิดพื้นฐานของการจำแนกเพื่อนบ้านที่ใกล้ที่สุด K คือการหาจำนวนที่กำหนดไว้ล่วงหน้านั่นคือ 'k' - ของตัวอย่างการฝึกอบรมที่อยู่ใกล้กับตัวอย่างใหม่มากที่สุดซึ่งจะต้องถูกจัดประเภท ตัวอย่างใหม่จะได้รับฉลากจากเพื่อนบ้านเอง ตัวแยกประเภท KNN มีค่าคงที่ที่ผู้ใช้กำหนดไว้สำหรับจำนวนเพื่อนบ้านที่ต้องกำหนด สำหรับระยะทางระยะทางแบบยุคลิดมาตรฐานเป็นทางเลือกที่พบบ่อยที่สุด KNN Classifier ทำงานโดยตรงกับตัวอย่างที่เรียนรู้แทนที่จะสร้างกฎสำหรับการเรียนรู้ อัลกอริทึม KNN เป็นหนึ่งในอัลกอริทึมการเรียนรู้ของเครื่องที่ง่ายที่สุด ประสบความสำเร็จอย่างมากในการจำแนกประเภทและปัญหาการถดถอยจำนวนมากเช่นการจดจำตัวอักษรหรือการวิเคราะห์ภาพ
Example
เรากำลังสร้างตัวจำแนก KNN เพื่อจดจำตัวเลข สำหรับสิ่งนี้เราจะใช้ชุดข้อมูล MNIST เราจะเขียนโค้ดนี้ใน Jupyter Notebook
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดงด้านล่าง
ที่นี่เรากำลังใช้ไฟล์ KNeighborsClassifier โมดูลจาก sklearn.neighbors แพ็คเกจ -
from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np
รหัสต่อไปนี้จะแสดงภาพของตัวเลขเพื่อตรวจสอบว่าเราต้องทดสอบภาพใด -
def Image_display(i):
plt.imshow(digit['images'][i],cmap = 'Greys_r')
plt.show()
ตอนนี้เราต้องโหลดชุดข้อมูล MNIST จริงๆแล้วมีทั้งหมด 1797 ภาพ แต่เราใช้ 1600 ภาพแรกเป็นตัวอย่างการฝึกและอีก 197 ภาพที่เหลือจะถูกเก็บไว้เพื่อการทดสอบ
digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])
ตอนนี้ในการแสดงภาพเราสามารถดูผลลัพธ์ได้ดังนี้ -
Image_display(0)
การแสดงภาพ (0)
ภาพ 0 แสดงดังนี้ -
Image_display (9)
ภาพที่ 9 ปรากฏดังนี้ -
digit.keys ()
ตอนนี้เราจำเป็นต้องสร้างชุดข้อมูลการฝึกอบรมและการทดสอบและจัดหาชุดข้อมูลการทดสอบให้กับตัวจำแนกประเภท KNN
train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)
ผลลัพธ์ต่อไปนี้จะสร้างตัวสร้างลักษณนามเพื่อนบ้านที่ใกล้ที่สุด K -
KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
weights = 'uniform')
เราจำเป็นต้องสร้างตัวอย่างการทดสอบโดยระบุหมายเลขใด ๆ ที่มากกว่า 1600 ซึ่งเป็นตัวอย่างการฝึกอบรม
test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)
Image_display (6)
ภาพที่ 6 ปรากฏดังนี้ -
ตอนนี้เราจะคาดการณ์ข้อมูลการทดสอบดังนี้ -
KNN.predict(test1)
โค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้ -
array([6])
ตอนนี้พิจารณาสิ่งต่อไปนี้ -
digit['target_names']
โค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้ -
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Natural Language Processing (NLP) หมายถึงวิธี AI ในการสื่อสารกับระบบอัจฉริยะโดยใช้ภาษาธรรมชาติเช่นภาษาอังกฤษ
จำเป็นต้องมีการประมวลผลภาษาธรรมชาติเมื่อคุณต้องการให้ระบบอัจฉริยะเช่นหุ่นยนต์ทำงานตามคำแนะนำของคุณเมื่อคุณต้องการฟังการตัดสินใจจากระบบผู้เชี่ยวชาญทางคลินิกตามบทสนทนาเป็นต้น
สาขา NLP เกี่ยวข้องกับการทำให้คอมพิวเตอร์ทำงานผิดพลาดด้วยภาษาธรรมชาติที่มนุษย์ใช้ อินพุตและเอาต์พุตของระบบ NLP สามารถ -
- Speech
- ข้อความที่เขียน
ส่วนประกอบของ NLP
ในส่วนนี้เราจะเรียนรู้เกี่ยวกับส่วนประกอบต่างๆของ NLP NLP มีสององค์ประกอบ ส่วนประกอบอธิบายไว้ด้านล่าง -
การเข้าใจภาษาธรรมชาติ (NLU)
มันเกี่ยวข้องกับงานต่อไปนี้ -
การจับคู่ข้อมูลที่ป้อนในภาษาธรรมชาติให้เป็นการนำเสนอที่เป็นประโยชน์
การวิเคราะห์แง่มุมต่างๆของภาษา
การสร้างภาษาธรรมชาติ (NLG)
เป็นกระบวนการสร้างวลีและประโยคที่มีความหมายในรูปแบบของภาษาธรรมชาติจากการแสดงภายใน มันเกี่ยวข้องกับ -
Text planning - รวมถึงการดึงเนื้อหาที่เกี่ยวข้องจากฐานความรู้
Sentence planning - ซึ่งรวมถึงการเลือกคำที่ต้องการการสร้างวลีที่มีความหมายการตั้งค่าเสียงของประโยค
Text Realization - นี่คือการแมปแผนประโยคเป็นโครงสร้างประโยค
ความยากลำบากใน NLU
NLU มีรูปแบบและโครงสร้างที่สมบูรณ์มาก อย่างไรก็ตามมันมีความคลุมเครือ อาจมีระดับความคลุมเครือที่แตกต่างกัน -
ความไม่ชัดเจนของคำศัพท์
มันอยู่ในระดับดั้งเดิมมากเช่นระดับคำ ตัวอย่างเช่นการปฏิบัติต่อคำว่า“ board” เป็นคำนามหรือคำกริยา?
ความไม่ชัดเจนของระดับไวยากรณ์
สามารถแยกวิเคราะห์ประโยคได้หลายวิธี ตัวอย่างเช่น“ เขาเลี้ยงด้วงด้วยหมวกสีแดง” - เขาใช้หมวกในการยกด้วงหรือเขายกด้วงที่มีฝาสีแดง?
ความคลุมเครือในการอ้างอิง
อ้างถึงบางสิ่งโดยใช้สรรพนาม ตัวอย่างเช่น Rima ไปที่ Gauri เธอบอกว่า“ ฉันเหนื่อย” - ใครกันแน่ที่เหนื่อย?
คำศัพท์ NLP
ตอนนี้ให้เราดูคำศัพท์ที่สำคัญบางประการในคำศัพท์ NLP
Phonology - เป็นการศึกษาการจัดระบบเสียงอย่างเป็นระบบ
Morphology - เป็นการศึกษาการสร้างคำจากหน่วยความหมายดั้งเดิม
Morpheme - เป็นหน่วยความหมายดั้งเดิมในภาษา
Syntax- หมายถึงการจัดเรียงคำเพื่อสร้างประโยค นอกจากนี้ยังเกี่ยวข้องกับการกำหนดบทบาทโครงสร้างของคำในประโยคและในวลี
Semantics - เกี่ยวข้องกับความหมายของคำและวิธีการรวมคำให้เป็นวลีและประโยคที่มีความหมาย
Pragmatics - เกี่ยวข้องกับการใช้และทำความเข้าใจประโยคในสถานการณ์ต่างๆและผลกระทบของการตีความประโยค
Discourse - เกี่ยวข้องกับการที่ประโยคก่อนหน้าจะมีผลต่อการตีความของประโยคถัดไปอย่างไร
World Knowledge - รวมถึงความรู้ทั่วไปเกี่ยวกับโลก
ขั้นตอนใน NLP
ส่วนนี้แสดงขั้นตอนต่างๆใน NLP
การวิเคราะห์คำศัพท์
เกี่ยวข้องกับการระบุและวิเคราะห์โครงสร้างของคำ พจนานุกรมของภาษาหมายถึงการรวบรวมคำและวลีในภาษา การวิเคราะห์คำศัพท์คือการแบ่งส่วน txt ทั้งหมดออกเป็นย่อหน้าประโยคและคำ
การวิเคราะห์วากยสัมพันธ์ (การแยกวิเคราะห์)
มันเกี่ยวข้องกับการวิเคราะห์คำในประโยคสำหรับไวยากรณ์และการจัดเรียงคำในลักษณะที่แสดงความสัมพันธ์ระหว่างคำ ประโยคเช่น“ The school going to boy” ถูกปฏิเสธโดยเครื่องวิเคราะห์ไวยากรณ์ภาษาอังกฤษ
การวิเคราะห์ความหมาย
มันดึงความหมายที่แน่นอนหรือความหมายตามพจนานุกรมจากข้อความ ข้อความถูกตรวจสอบความหมาย ทำได้โดยการแมปโครงสร้างวากยสัมพันธ์และอ็อบเจ็กต์ในโดเมนงาน เครื่องวิเคราะห์ความหมายไม่สนใจประโยคเช่น“ ไอศกรีมร้อน”
การรวมวาทกรรม
ความหมายของประโยคใด ๆ ขึ้นอยู่กับความหมายของประโยคก่อนหน้านั้น นอกจากนี้ยังนำมาซึ่งความหมายของประโยคที่ประสบความสำเร็จในทันที
การวิเคราะห์เชิงปฏิบัติ
ระหว่างนี้สิ่งที่พูดจะถูกตีความอีกครั้งว่ามันหมายถึงอะไร มันเกี่ยวข้องกับการได้มาซึ่งแง่มุมของภาษาซึ่งต้องการความรู้ในโลกแห่งความเป็นจริง
ในบทนี้เราจะเรียนรู้วิธีการเริ่มต้นใช้งานแพ็คเกจชุดเครื่องมือภาษาธรรมชาติ
ข้อกำหนดเบื้องต้น
หากเราต้องการสร้างแอปพลิเคชันด้วยการประมวลผลภาษาธรรมชาติการเปลี่ยนแปลงในบริบทจะทำให้ยากที่สุด ปัจจัยบริบทมีอิทธิพลต่อวิธีที่เครื่องเข้าใจประโยคใดประโยคหนึ่ง ดังนั้นเราต้องพัฒนาแอปพลิเคชันภาษาธรรมชาติโดยใช้วิธีการเรียนรู้ของเครื่องเพื่อให้เครื่องเข้าใจวิธีที่มนุษย์สามารถเข้าใจบริบทได้
ในการสร้างแอปพลิเคชันดังกล่าวเราจะใช้แพ็คเกจ Python ที่เรียกว่า NLTK (Natural Language Toolkit Package)
การนำเข้า NLTK
เราจำเป็นต้องติดตั้ง NLTK ก่อนใช้งาน สามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install nltk
ในการสร้างแพ็คเกจ conda สำหรับ NLTK ให้ใช้คำสั่งต่อไปนี้ -
conda install -c anaconda nltk
หลังจากติดตั้งแพ็คเกจ NLTK แล้วเราจำเป็นต้องนำเข้าผ่านพรอมต์คำสั่ง python เราสามารถนำเข้าได้โดยเขียนคำสั่งต่อไปนี้ในพรอมต์คำสั่ง Python -
>>> import nltk
กำลังดาวน์โหลดข้อมูลของ NLTK
หลังจากนำเข้า NLTK แล้วเราจำเป็นต้องดาวน์โหลดข้อมูลที่ต้องการ สามารถทำได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ในพรอมต์คำสั่ง Python -
>>> nltk.download()
การติดตั้งแพ็คเกจที่จำเป็นอื่น ๆ
สำหรับการสร้างแอปพลิเคชันการประมวลผลภาษาธรรมชาติโดยใช้ NLTK เราจำเป็นต้องติดตั้งแพ็คเกจที่จำเป็น แพ็คเกจมีดังนี้ -
เกนซิม
เป็นไลบรารีการสร้างแบบจำลองทางความหมายที่มีประสิทธิภาพซึ่งมีประโยชน์สำหรับแอปพลิเคชันมากมาย เราสามารถติดตั้งได้โดยดำเนินการคำสั่งต่อไปนี้ -
pip install gensim
รูปแบบ
จะใช้ในการทำ gensimแพคเกจทำงานอย่างถูกต้อง เราสามารถติดตั้งได้โดยดำเนินการคำสั่งต่อไปนี้
pip install pattern
แนวคิดของ Tokenization, Stemming และ Lemmatization
ในส่วนนี้เราจะทำความเข้าใจว่าอะไรคือโทเค็นการกำหนดต้นกำเนิดและการให้คำนาม
Tokenization
มันอาจถูกกำหนดให้เป็นกระบวนการทำลายข้อความที่กำหนดเช่นลำดับอักขระเป็นหน่วยเล็ก ๆ ที่เรียกว่าโทเค็น โทเค็นอาจเป็นคำตัวเลขหรือเครื่องหมายวรรคตอน เรียกอีกอย่างว่าการแบ่งส่วนคำ ต่อไปนี้เป็นตัวอย่างง่ายๆของโทเค็น -
Input - มะม่วงกล้วยสับปะรดและแอปเปิ้ลล้วนเป็นผลไม้
Output -
ขั้นตอนการทำลายข้อความที่กำหนดสามารถทำได้ด้วยความช่วยเหลือของการค้นหาขอบเขตของคำ การสิ้นสุดของคำและจุดเริ่มต้นของคำใหม่เรียกว่าขอบเขตของคำ ระบบการเขียนและโครงสร้างการพิมพ์ของคำมีอิทธิพลต่อขอบเขต
ในโมดูล Python NLTK เรามีแพ็คเกจต่างๆที่เกี่ยวข้องกับโทเค็นซึ่งเราสามารถใช้เพื่อแบ่งข้อความออกเป็นโทเค็นได้ตามความต้องการของเรา บางส่วนของแพ็คเกจมีดังนี้ -
sent_tokenize แพ็คเกจ
ตามชื่อที่แนะนำแพ็คเกจนี้จะแบ่งข้อความที่ป้อนออกเป็นประโยค เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.tokenize import sent_tokenize
word_tokenize แพ็คเกจ
แพ็คเกจนี้แบ่งข้อความที่ป้อนเป็นคำ เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.tokenize import word_tokenize
แพ็คเกจ WordPunctTokenizer
แพ็คเกจนี้แบ่งข้อความที่ป้อนออกเป็นคำและเครื่องหมายวรรคตอน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.tokenize import WordPuncttokenizer
Stemming
ในขณะที่ทำงานกับคำเราพบรูปแบบต่างๆมากมายเนื่องจากเหตุผลทางไวยากรณ์ แนวคิดของรูปแบบที่นี่หมายความว่าเราต้องจัดการกับรูปแบบต่างๆของคำเดียวกันเช่นdemocracy, democratic, และ democratization. จำเป็นมากที่เครื่องจักรจะต้องเข้าใจว่าคำต่างๆเหล่านี้มีรูปแบบฐานเดียวกัน ด้วยวิธีนี้การแยกรูปแบบฐานของคำในขณะที่เราวิเคราะห์ข้อความจะมีประโยชน์
เราสามารถบรรลุสิ่งนี้ได้โดยการสกัดกั้น ด้วยวิธีนี้เราสามารถพูดได้ว่าการแยกคำเป็นกระบวนการฮิวริสติกในการแยกรูปแบบฐานของคำโดยการตัดส่วนท้ายของคำออก
ในโมดูล Python NLTK เรามีแพ็คเกจต่างๆที่เกี่ยวข้องกับการหยุดชะงัก แพคเกจเหล่านี้สามารถใช้เพื่อรับรูปแบบพื้นฐานของคำ แพ็คเกจเหล่านี้ใช้อัลกอริทึม บางส่วนของแพ็คเกจมีดังนี้ -
แพ็คเกจ PorterStemmer
แพคเกจ Python นี้ใช้อัลกอริทึมของ Porter เพื่อแยกรูปแบบพื้นฐาน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.stem.porter import PorterStemmer
ตัวอย่างเช่นถ้าเราจะให้คำ ‘writing’ ในฐานะที่เป็นข้อมูลในการทำให้เกิดสิ่งนี้เราจะได้คำนั้น ‘write’ หลังจากหยุดชะงัก
แพ็คเกจ LancasterStemmer
แพคเกจ Python นี้จะใช้อัลกอริทึมของ Lancaster เพื่อแยกรูปแบบฐาน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.stem.lancaster import LancasterStemmer
ตัวอย่างเช่นถ้าเราจะให้คำ ‘writing’ ในฐานะที่เป็นข้อมูลในการทำให้เกิดสิ่งนี้เราจะได้คำนั้น ‘write’ หลังจากหยุดชะงัก
แพ็คเกจ SnowballStemmer
แพคเกจ Python นี้จะใช้อัลกอริทึมของสโนว์บอลเพื่อแยกรูปแบบพื้นฐาน เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.stem.snowball import SnowballStemmer
ตัวอย่างเช่นถ้าเราจะให้คำ ‘writing’ ในฐานะที่เป็นข้อมูลในการทำให้เกิดสิ่งนี้เราจะได้คำนั้น ‘write’ หลังจากหยุดชะงัก
อัลกอริทึมทั้งหมดนี้มีระดับความเข้มงวดที่แตกต่างกัน ถ้าเราเปรียบเทียบสเต็มเมอร์ทั้งสามนี้แล้วพอร์เตอร์สเตมเมอร์นั้นเข้มงวดน้อยที่สุดและแลงคาสเตอร์เข้มงวดที่สุด สโนว์บอลสเตมเมอร์ใช้งานได้ดีทั้งในด้านความเร็วและความเข้มงวด
Lemmatization
นอกจากนี้เรายังสามารถแยกรูปแบบฐานของคำได้โดยใช้การย่อขนาด โดยพื้นฐานแล้วจะทำงานนี้ด้วยการใช้คำศัพท์และการวิเคราะห์ทางสัณฐานวิทยาของคำโดยปกติมีจุดมุ่งหมายเพื่อลบคำลงท้ายที่ผันแปรเท่านั้น รูปแบบฐานของคำใด ๆ ที่เรียกว่า lemma
ความแตกต่างที่สำคัญระหว่างการสะกดคำและการย่อคือการใช้คำศัพท์และการวิเคราะห์ทางสัณฐานวิทยาของคำ ความแตกต่างอีกประการหนึ่งคือการหยุดคำที่เกี่ยวข้องกันโดยทั่วไปส่วนใหญ่จะยุบคำที่เกี่ยวข้องกับรากศัพท์ในขณะที่การย่อขนาดโดยทั่วไปจะยุบเฉพาะรูปแบบการผันคำที่ต่างกัน ตัวอย่างเช่นหากเราให้คำที่เห็นเป็นคำที่ป้อนการสะกดคำอาจส่งคืนคำว่า "s" แต่การสร้างคำอธิบายจะพยายามส่งคืนคำว่าเห็นหรือเห็นขึ้นอยู่กับว่าการใช้โทเค็นเป็นคำกริยาหรือคำนาม
ในโมดูล Python NLTK เรามีแพ็คเกจต่อไปนี้ที่เกี่ยวข้องกับกระบวนการสร้างคำศัพท์ซึ่งเราสามารถใช้เพื่อรับรูปแบบพื้นฐานของคำ -
แพ็คเกจ WordNetLemmatizer
แพคเกจ Python นี้จะดึงรูปแบบพื้นฐานของคำขึ้นอยู่กับว่าใช้เป็นคำนามหรือเป็นคำกริยา เราสามารถนำเข้าแพ็คเกจนี้ด้วยความช่วยเหลือของรหัส Python ต่อไปนี้ -
from nltk.stem import WordNetLemmatizer
Chunking: แบ่งข้อมูลออกเป็นชิ้น ๆ
เป็นกระบวนการสำคัญอย่างหนึ่งในการประมวลผลภาษาธรรมชาติ งานหลักของการแยกชิ้นส่วนคือการระบุส่วนของคำพูดและวลีสั้น ๆ เช่นวลีคำนาม เราได้ศึกษาขั้นตอนการสร้างโทเค็นการสร้างโทเค็นแล้ว Chunking โดยพื้นฐานแล้วคือการติดฉลากของโทเค็นเหล่านั้น กล่าวอีกนัยหนึ่งการแบ่งส่วนจะแสดงให้เราเห็นโครงสร้างของประโยค
ในส่วนต่อไปนี้เราจะเรียนรู้เกี่ยวกับประเภทต่างๆของ Chunking
ประเภทของก้อน
มีสองประเภทของ chunking ประเภทมีดังนี้ -
เป็นก้อนขึ้น
ในกระบวนการของการแยกชิ้นส่วนวัตถุสิ่งของ ฯลฯ จะเคลื่อนไปสู่ความเป็นสากลมากขึ้นและภาษาก็มีความเป็นนามธรรมมากขึ้น โอกาสในการตกลงมีมากขึ้น ในกระบวนการนี้เราย่อ ตัวอย่างเช่นหากเราจะถามคำถามที่ว่า“ รถยนต์เพื่อวัตถุประสงค์อะไร”? เราอาจได้รับคำตอบว่า "ขนส่ง"
ลดจำนวนลง
ในกระบวนการของการแยกชิ้นส่วนวัตถุสิ่งของ ฯลฯ จะเคลื่อนไปสู่ความเฉพาะเจาะจงมากขึ้นและภาษาได้รับการเจาะมากขึ้น โครงสร้างที่ลึกกว่าจะถูกตรวจสอบเป็นชิ้น ๆ ในขั้นตอนนี้เราจะซูมเข้าตัวอย่างเช่นถ้าเราสรุปคำถาม "บอกเฉพาะเกี่ยวกับรถ"? เราจะได้รับข้อมูลชิ้นเล็ก ๆ เกี่ยวกับรถ
Example
ในตัวอย่างนี้เราจะทำ Noun-Phrase chunking ซึ่งเป็นหมวดหมู่ของ chunking ซึ่งจะค้นหาวลีคำนามในประโยคโดยใช้โมดูล NLTK ใน Python -
Follow these steps in python for implementing noun phrase chunking −
Step 1- ในขั้นตอนนี้เราต้องกำหนดไวยากรณ์สำหรับการแยกชิ้นส่วน มันจะประกอบด้วยกฎที่เราต้องปฏิบัติตาม
Step 2- ในขั้นตอนนี้เราต้องสร้างตัวแยกวิเคราะห์แบบก้อน มันจะแยกวิเคราะห์ไวยากรณ์และให้ผลลัพธ์
Step 3 - ในขั้นตอนสุดท้ายนี้ผลลัพธ์จะถูกสร้างในรูปแบบต้นไม้
ให้เรานำเข้าแพ็คเกจ NLTK ที่จำเป็นดังต่อไปนี้ -
import nltk
ตอนนี้เราต้องกำหนดประโยค ในที่นี้ DT หมายถึงดีเทอร์มิแนนต์ VBP หมายถึงคำกริยา JJ หมายถึงคำคุณศัพท์ IN หมายถึงคำบุพบทและ NN หมายถึงคำนาม
sentence=[("a","DT"),("clever","JJ"),("fox","NN"),("was","VBP"),
("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]
ตอนนี้เราต้องให้ไวยากรณ์ ในที่นี้เราจะให้ไวยากรณ์ในรูปแบบของนิพจน์ทั่วไป
grammar = "NP:{<DT>?<JJ>*<NN>}"
เราจำเป็นต้องกำหนด parser ซึ่งจะแยกวิเคราะห์ไวยากรณ์
parser_chunking = nltk.RegexpParser(grammar)
parser จะแยกวิเคราะห์ประโยคดังนี้ -
parser_chunking.parse(sentence)
ต่อไปเราต้องได้รับผลลัพธ์ ผลลัพธ์ถูกสร้างขึ้นในตัวแปรอย่างง่ายที่เรียกว่าoutput_chunk.
Output_chunk = parser_chunking.parse(sentence)
เมื่อดำเนินการตามรหัสต่อไปนี้เราสามารถวาดผลลัพธ์ของเราในรูปแบบของต้นไม้
output.draw()
Bag of Word (BoW) รุ่น
Bag of Word (BoW) ซึ่งเป็นแบบจำลองในการประมวลผลภาษาธรรมชาติโดยทั่วไปจะใช้เพื่อแยกคุณสมบัติจากข้อความเพื่อให้ข้อความสามารถใช้ในการสร้างแบบจำลองในอัลกอริทึมการเรียนรู้ของเครื่อง
ตอนนี้คำถามเกิดขึ้นว่าทำไมเราต้องดึงคุณสมบัติออกจากข้อความ เป็นเพราะอัลกอริทึมการเรียนรู้ของเครื่องไม่สามารถทำงานกับข้อมูลดิบและต้องการข้อมูลตัวเลขเพื่อให้สามารถดึงข้อมูลที่มีความหมายออกมาได้ การแปลงข้อมูลข้อความเป็นข้อมูลตัวเลขเรียกว่าการแยกคุณลักษณะหรือการเข้ารหัสคุณลักษณะ
มันทำงานอย่างไร
นี่เป็นวิธีที่ง่ายมากสำหรับการแยกคุณสมบัติออกจากข้อความ สมมติว่าเรามีเอกสารข้อความและต้องการแปลงเป็นข้อมูลตัวเลขหรือพูดว่าต้องการดึงคุณลักษณะออกจากนั้นก่อนอื่นแบบจำลองนี้จะดึงคำศัพท์จากคำทั้งหมดในเอกสาร จากนั้นโดยใช้เมทริกซ์คำศัพท์เอกสารมันจะสร้างแบบจำลอง ด้วยวิธีนี้ BoW จึงแสดงเอกสารเป็นถุงคำเท่านั้น ข้อมูลใด ๆ เกี่ยวกับลำดับหรือโครงสร้างของคำในเอกสารจะถูกทิ้ง
แนวคิดของเมทริกซ์ระยะเอกสาร
อัลกอริทึม BoW สร้างแบบจำลองโดยใช้เมทริกซ์คำศัพท์ของเอกสาร ตามชื่อที่แนะนำเมทริกซ์คำศัพท์ของเอกสารคือเมทริกซ์ของจำนวนคำต่างๆที่เกิดขึ้นในเอกสาร ด้วยความช่วยเหลือของเมทริกซ์นี้เอกสารข้อความสามารถแสดงเป็นชุดค่าผสมที่ถ่วงน้ำหนักของคำต่างๆ ด้วยการตั้งค่าขีด จำกัด และเลือกคำที่มีความหมายมากขึ้นเราสามารถสร้างฮิสโตแกรมของคำทั้งหมดในเอกสารที่สามารถใช้เป็นเวกเตอร์คุณลักษณะได้ ต่อไปนี้เป็นตัวอย่างเพื่อทำความเข้าใจแนวคิดของเมทริกซ์ระยะเอกสาร -
Example
สมมติว่าเรามีสองประโยคต่อไปนี้ -
Sentence 1 - เรากำลังใช้โมเดล Bag of Words
Sentence 2 - แบบจำลอง Bag of Words ใช้สำหรับการแยกคุณสมบัติ
ตอนนี้เมื่อพิจารณาสองประโยคนี้เรามี 13 คำที่แตกต่างกันดังต่อไปนี้ -
- we
- are
- using
- the
- bag
- of
- words
- model
- is
- used
- for
- extracting
- features
ตอนนี้เราต้องสร้างฮิสโตแกรมสำหรับแต่ละประโยคโดยใช้จำนวนคำในแต่ละประโยค -
Sentence 1 - [1,1,1,1,1,1,1,1,0,0,0,0,0,0]
Sentence 2 - [0,0,0,1,1,1,1,1,1,1,1,1,1]
ด้วยวิธีนี้เรามีเวกเตอร์คุณลักษณะที่แยกออกมาแล้ว เวกเตอร์คุณลักษณะแต่ละตัวมีขนาด 13 มิติเนื่องจากเรามีคำที่แตกต่างกัน 13 คำ
แนวคิดของสถิติ
แนวคิดของสถิติเรียกว่า TermFrequency-Inverse Document Frequency (tf-idf) ทุกคำมีความสำคัญในเอกสาร สถิติช่วยให้เราเข้าใจความสำคัญของทุกคำ
ระยะความถี่ (tf)
เป็นการวัดความถี่ที่คำแต่ละคำปรากฏในเอกสาร สามารถหาได้โดยการหารจำนวนคำแต่ละคำด้วยจำนวนคำทั้งหมดในเอกสารที่กำหนด
ความถี่เอกสารผกผัน (idf)
เป็นการวัดความแตกต่างของคำในเอกสารนี้ในชุดเอกสารที่กำหนด สำหรับการคำนวณ idf และการสร้างเวกเตอร์คุณลักษณะที่โดดเด่นเราจำเป็นต้องลดน้ำหนักของคำที่เกิดขึ้นบ่อยเช่นและเพิ่มน้ำหนักให้กับคำที่หายาก
การสร้างแบบจำลองถุงคำใน NLTK
ในส่วนนี้เราจะกำหนดชุดของสตริงโดยใช้ CountVectorizer เพื่อสร้างเวกเตอร์จากประโยคเหล่านี้
ให้เรานำเข้าแพ็คเกจที่จำเป็น -
from sklearn.feature_extraction.text import CountVectorizer
ตอนนี้กำหนดชุดของประโยค
Sentences = ['We are using the Bag of Word model', 'Bag of Word model is
used for extracting the features.']
vectorizer_count = CountVectorizer()
features_text = vectorizer.fit_transform(Sentences).todense()
print(vectorizer.vocabulary_)
โปรแกรมด้านบนจะสร้างผลลัพธ์ตามที่แสดงด้านล่าง แสดงว่าเรามี 13 คำที่แตกต่างกันในสองประโยคข้างต้น -
{'we': 11, 'are': 0, 'using': 10, 'the': 8, 'bag': 1, 'of': 7,
'word': 12, 'model': 6, 'is': 5, 'used': 9, 'for': 4, 'extracting': 2, 'features': 3}
นี่คือเวกเตอร์คุณลักษณะ (ข้อความเป็นรูปแบบตัวเลข) ซึ่งสามารถใช้สำหรับการเรียนรู้ของเครื่อง
แก้ไขปัญหา
ในส่วนนี้เราจะแก้ปัญหาที่เกี่ยวข้องเล็กน้อย
การทำนายหมวดหมู่
ในชุดเอกสารไม่เพียง แต่คำ แต่หมวดหมู่ของคำก็สำคัญเช่นกัน ข้อความในหมวดหมู่ใดที่มีคำใดคำหนึ่งตกอยู่ ตัวอย่างเช่นเราต้องการคาดคะเนว่าประโยคใดเป็นของอีเมลหมวดหมู่ข่าวสารกีฬาคอมพิวเตอร์ ฯลฯ ในตัวอย่างต่อไปนี้เราจะใช้ tf-idf เพื่อกำหนดเวกเตอร์คุณลักษณะเพื่อค้นหาหมวดหมู่ของเอกสาร เราจะใช้ข้อมูลจาก 20 กลุ่มข่าวชุดข้อมูลของ sklearn
เราจำเป็นต้องนำเข้าแพ็คเกจที่จำเป็น -
from sklearn.datasets import fetch_20newsgroups
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer
กำหนดแผนที่หมวดหมู่ เราใช้ห้าหมวดหมู่ที่แตกต่างกันชื่อศาสนารถยนต์กีฬาอิเล็กทรอนิกส์และอวกาศ
category_map = {'talk.religion.misc':'Religion','rec.autos''Autos',
'rec.sport.hockey':'Hockey','sci.electronics':'Electronics', 'sci.space': 'Space'}
สร้างชุดฝึก -
training_data = fetch_20newsgroups(subset = 'train',
categories = category_map.keys(), shuffle = True, random_state = 5)
สร้างเวกเตอร์การนับและแยกคำที่นับ -
vectorizer_count = CountVectorizer()
train_tc = vectorizer_count.fit_transform(training_data.data)
print("\nDimensions of training data:", train_tc.shape)
หม้อแปลง tf-idf ถูกสร้างขึ้นดังนี้ -
tfidf = TfidfTransformer()
train_tfidf = tfidf.fit_transform(train_tc)
ตอนนี้กำหนดข้อมูลการทดสอบ -
input_data = [
'Discovery was a space shuttle',
'Hindu, Christian, Sikh all are religions',
'We must have to drive safely',
'Puck is a disk made of rubber',
'Television, Microwave, Refrigrated all uses electricity'
]
ข้อมูลข้างต้นจะช่วยให้เราฝึกตัวแยกประเภท Multinomial Naive Bayes -
classifier = MultinomialNB().fit(train_tfidf, training_data.target)
แปลงข้อมูลอินพุตโดยใช้ตัวนับเวกเตอร์ -
input_tc = vectorizer_count.transform(input_data)
ตอนนี้เราจะแปลงข้อมูลเวกเตอร์โดยใช้หม้อแปลง tfidf -
input_tfidf = tfidf.transform(input_tc)
เราจะทำนายประเภทผลลัพธ์ -
predictions = classifier.predict(input_tfidf)
ผลลัพธ์ถูกสร้างขึ้นดังนี้ -
for sent, category in zip(input_data, predictions):
print('\nInput Data:', sent, '\n Category:', \
category_map[training_data.target_names[category]])
ตัวทำนายหมวดหมู่จะสร้างผลลัพธ์ต่อไปนี้ -
Dimensions of training data: (2755, 39297)
Input Data: Discovery was a space shuttle
Category: Space
Input Data: Hindu, Christian, Sikh all are religions
Category: Religion
Input Data: We must have to drive safely
Category: Autos
Input Data: Puck is a disk made of rubber
Category: Hockey
Input Data: Television, Microwave, Refrigrated all uses electricity
Category: Electronics
ตัวค้นหาเพศ
ในคำชี้แจงปัญหานี้ลักษณนามจะได้รับการฝึกฝนเพื่อค้นหาเพศ (ชายหรือหญิง) โดยการระบุชื่อ เราจำเป็นต้องใช้ฮิวริสติกเพื่อสร้างเวกเตอร์คุณลักษณะและฝึกลักษณนาม เราจะใช้ข้อมูลที่มีป้ายกำกับจากแพ็คเกจ scikit-learn ต่อไปนี้เป็นรหัส Python เพื่อสร้างตัวค้นหาเพศ -
ให้เรานำเข้าแพ็คเกจที่จำเป็น -
import random
from nltk import NaiveBayesClassifier
from nltk.classify import accuracy as nltk_accuracy
from nltk.corpus import names
ตอนนี้เราต้องแยกตัวอักษร N สุดท้ายออกจากคำที่ป้อน ตัวอักษรเหล่านี้จะทำหน้าที่เป็นคุณสมบัติ -
def extract_features(word, N = 2):
last_n_letters = word[-N:]
return {'feature': last_n_letters.lower()}
if __name__=='__main__':
สร้างข้อมูลการฝึกอบรมโดยใช้ชื่อที่มีป้ายกำกับ (ชายและหญิง) ที่มีอยู่ใน NLTK -
male_list = [(name, 'male') for name in names.words('male.txt')]
female_list = [(name, 'female') for name in names.words('female.txt')]
data = (male_list + female_list)
random.seed(5)
random.shuffle(data)
ตอนนี้ข้อมูลการทดสอบจะถูกสร้างขึ้นดังนี้ -
namesInput = ['Rajesh', 'Gaurav', 'Swati', 'Shubha']
กำหนดจำนวนตัวอย่างที่ใช้ในการฝึกและทดสอบด้วยรหัสต่อไปนี้
train_sample = int(0.8 * len(data))
ตอนนี้เราต้องวนซ้ำตามความยาวที่แตกต่างกันเพื่อให้สามารถเปรียบเทียบความแม่นยำได้ -
for i in range(1, 6):
print('\nNumber of end letters:', i)
features = [(extract_features(n, i), gender) for (n, gender) in data]
train_data, test_data = features[:train_sample],
features[train_sample:]
classifier = NaiveBayesClassifier.train(train_data)
ความถูกต้องของลักษณนามสามารถคำนวณได้ดังนี้ -
accuracy_classifier = round(100 * nltk_accuracy(classifier, test_data), 2)
print('Accuracy = ' + str(accuracy_classifier) + '%')
ตอนนี้เราสามารถทำนายผลลัพธ์ -
for name in namesInput:
print(name, '==>', classifier.classify(extract_features(name, i)))
โปรแกรมข้างต้นจะสร้างผลลัพธ์ต่อไปนี้ -
Number of end letters: 1
Accuracy = 74.7%
Rajesh -> female
Gaurav -> male
Swati -> female
Shubha -> female
Number of end letters: 2
Accuracy = 78.79%
Rajesh -> male
Gaurav -> male
Swati -> female
Shubha -> female
Number of end letters: 3
Accuracy = 77.22%
Rajesh -> male
Gaurav -> female
Swati -> female
Shubha -> female
Number of end letters: 4
Accuracy = 69.98%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female
Number of end letters: 5
Accuracy = 64.63%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female
ในผลลัพธ์ข้างต้นเราจะเห็นว่าความแม่นยำของตัวอักษรปิดท้ายจำนวนสูงสุดคือสองตัวและจะลดลงเมื่อจำนวนอักษรปิดท้ายเพิ่มขึ้น
การสร้างแบบจำลองหัวข้อ: การระบุรูปแบบในข้อมูลข้อความ
เราทราบดีว่าโดยทั่วไปเอกสารจะถูกจัดกลุ่มเป็นหัวข้อต่างๆ บางครั้งเราจำเป็นต้องระบุรูปแบบในข้อความที่สอดคล้องกับหัวข้อใดหัวข้อหนึ่ง เทคนิคการทำเช่นนี้เรียกว่าการสร้างแบบจำลองหัวข้อ กล่าวอีกนัยหนึ่งเราสามารถพูดได้ว่าการสร้างแบบจำลองหัวข้อเป็นเทคนิคในการเปิดเผยธีมนามธรรมหรือโครงสร้างที่ซ่อนอยู่ในชุดเอกสารที่กำหนด
เราสามารถใช้เทคนิคการสร้างแบบจำลองหัวข้อในสถานการณ์ต่อไปนี้ -
การจัดประเภทข้อความ
ด้วยความช่วยเหลือของการสร้างแบบจำลองหัวข้อสามารถปรับปรุงการจัดประเภทได้เนื่องจากจัดกลุ่มคำที่คล้ายกันเข้าด้วยกันแทนที่จะใช้คำแต่ละคำแยกกันเป็นคุณลักษณะ
ระบบผู้แนะนำ
ด้วยความช่วยเหลือของการสร้างแบบจำลองหัวข้อเราสามารถสร้างระบบผู้แนะนำโดยใช้มาตรการความคล้ายคลึงกัน
อัลกอริทึมสำหรับการสร้างแบบจำลองหัวข้อ
การสร้างแบบจำลองหัวข้อสามารถทำได้โดยใช้อัลกอริทึม อัลกอริทึมมีดังนี้ -
การจัดสรร Dirichlet แฝง (LDA)
อัลกอริทึมนี้เป็นที่นิยมมากที่สุดสำหรับการสร้างแบบจำลองหัวข้อ ใช้โมเดลกราฟิกที่น่าจะเป็นในการใช้การสร้างแบบจำลองหัวข้อ เราจำเป็นต้องนำเข้าแพ็คเกจ gensim ใน Python เพื่อใช้ LDA sl algorithm
การวิเคราะห์ความหมายแฝง (LDA) หรือการจัดทำดัชนีความหมายแฝง (LSI)
อัลกอริทึมนี้ขึ้นอยู่กับพีชคณิตเชิงเส้น โดยทั่วไปจะใช้แนวคิดของ SVD (Singular Value Decomposition) บนเมทริกซ์คำศัพท์ของเอกสาร
การแยกตัวประกอบเมทริกซ์ที่ไม่ใช่เชิงลบ (NMF)
นอกจากนี้ยังขึ้นอยู่กับพีชคณิตเชิงเส้น
อัลกอริทึมที่กล่าวถึงข้างต้นทั้งหมดสำหรับการสร้างแบบจำลองหัวข้อจะมีไฟล์ number of topics เป็นพารามิเตอร์ Document-Word Matrix เป็นอินพุตและ WTM (Word Topic Matrix) & TDM (Topic Document Matrix) เป็นเอาต์พุต
การทำนายลำดับถัดไปในลำดับการป้อนข้อมูลที่กำหนดเป็นอีกแนวคิดที่สำคัญในการเรียนรู้ของเครื่อง บทนี้ให้คำอธิบายโดยละเอียดเกี่ยวกับการวิเคราะห์ข้อมูลอนุกรมเวลา
บทนำ
ข้อมูลอนุกรมเวลาหมายถึงข้อมูลที่อยู่ในชุดของช่วงเวลาเฉพาะ หากเราต้องการสร้างการคาดคะเนตามลำดับในแมชชีนเลิร์นนิงเราจะต้องจัดการกับข้อมูลและเวลาตามลำดับ ข้อมูลอนุกรมเป็นนามธรรมของข้อมูลตามลำดับ การจัดลำดับข้อมูลเป็นคุณลักษณะที่สำคัญของข้อมูลแบบลำดับ
แนวคิดพื้นฐานของการวิเคราะห์ลำดับหรือการวิเคราะห์อนุกรมเวลา
การวิเคราะห์ลำดับหรือการวิเคราะห์อนุกรมเวลาคือการทำนายลำดับถัดไปในลำดับอินพุตที่กำหนดตามที่สังเกตก่อนหน้านี้ การทำนายอาจเป็นอะไรก็ได้ที่อาจเกิดขึ้นถัดไป: สัญลักษณ์ตัวเลขสภาพอากาศในวันถัดไปคำพูดถัดไปเป็นต้นการวิเคราะห์ลำดับมีประโยชน์มากในการใช้งานเช่นการวิเคราะห์ตลาดหุ้นการพยากรณ์อากาศและคำแนะนำผลิตภัณฑ์
Example
พิจารณาตัวอย่างต่อไปนี้เพื่อทำความเข้าใจการทำนายตามลำดับ ที่นี่A,B,C,D คือค่าที่กำหนดและคุณต้องทำนายค่า E โดยใช้แบบจำลองการทำนายลำดับ
การติดตั้งแพ็คเกจที่มีประโยชน์
สำหรับการวิเคราะห์ข้อมูลอนุกรมเวลาโดยใช้ Python เราจำเป็นต้องติดตั้งแพ็คเกจต่อไปนี้ -
หมีแพนด้า
Pandas เป็นไลบรารีที่ได้รับอนุญาต BSD แบบโอเพนซอร์สซึ่งมีประสิทธิภาพสูงใช้งานง่ายโครงสร้างข้อมูลและเครื่องมือวิเคราะห์ข้อมูลสำหรับ Python คุณสามารถติดตั้ง Pandas ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install pandas
หากคุณใช้ Anaconda และต้องการติดตั้งโดยใช้ไฟล์ conda ตัวจัดการแพ็คเกจจากนั้นคุณสามารถใช้คำสั่งต่อไปนี้ -
conda install -c anaconda pandas
อืม
เป็นไลบรารีที่ได้รับอนุญาตจาก BSD แบบโอเพนซอร์สซึ่งประกอบด้วยอัลกอริทึมและโมเดลที่เรียบง่ายเพื่อเรียนรู้ Hidden Markov Models (HMM) ใน Python คุณสามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install hmmlearn
หากคุณใช้ Anaconda และต้องการติดตั้งโดยใช้ไฟล์ conda ตัวจัดการแพ็คเกจจากนั้นคุณสามารถใช้คำสั่งต่อไปนี้ -
conda install -c omnia hmmlearn
PyStruct
เป็นห้องสมุดการเรียนรู้และการทำนายที่มีโครงสร้าง อัลกอริทึมการเรียนรู้ที่ใช้ใน PyStruct มีชื่อเช่นฟิลด์สุ่มตามเงื่อนไข (CRF), Maximum-Margin Markov Random Networks (M3N) หรือเครื่องเวกเตอร์สนับสนุนโครงสร้าง คุณสามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install pystruct
CVXOPT
ใช้สำหรับการเพิ่มประสิทธิภาพนูนตามภาษาโปรแกรม Python นอกจากนี้ยังเป็นชุดซอฟต์แวร์ฟรี คุณสามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install cvxopt
หากคุณใช้ Anaconda และต้องการติดตั้งโดยใช้ไฟล์ conda ตัวจัดการแพ็คเกจจากนั้นคุณสามารถใช้คำสั่งต่อไปนี้ -
conda install -c anaconda cvdoxt
หมีแพนด้า: การจัดการการแบ่งส่วนและการแยกสถิติจากข้อมูลอนุกรมเวลา
หมีแพนด้าเป็นเครื่องมือที่มีประโยชน์มากหากคุณต้องทำงานกับข้อมูลอนุกรมเวลา ด้วยความช่วยเหลือของ Pandas คุณสามารถทำสิ่งต่อไปนี้ -
สร้างช่วงวันที่โดยใช้ไฟล์ pd.date_range แพ็คเกจ
จัดทำดัชนีแพนด้าด้วยวันที่โดยใช้ pd.Series แพ็คเกจ
ทำการสุ่มตัวอย่างซ้ำโดยใช้ไฟล์ ts.resample แพ็คเกจ
เปลี่ยนความถี่
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงให้คุณจัดการและแบ่งส่วนข้อมูลอนุกรมเวลาโดยใช้ Pandas โปรดทราบว่าที่นี่เรากำลังใช้ข้อมูล Monthly Arctic Oscillation ซึ่งสามารถดาวน์โหลดได้จากmonth.ao.index.b50.current.asciiและสามารถแปลงเป็นรูปแบบข้อความสำหรับการใช้งานของเราได้
การจัดการข้อมูลอนุกรมเวลา
สำหรับการจัดการข้อมูลอนุกรมเวลาคุณจะต้องทำตามขั้นตอนต่อไปนี้ -
ขั้นตอนแรกเกี่ยวข้องกับการนำเข้าแพ็คเกจต่อไปนี้ -
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
จากนั้นกำหนดฟังก์ชันที่จะอ่านข้อมูลจากไฟล์อินพุตดังที่แสดงในโค้ดที่ระบุด้านล่าง -
def read_data(input_file):
input_data = np.loadtxt(input_file, delimiter = None)
ตอนนี้แปลงข้อมูลนี้เป็นอนุกรมเวลา สำหรับสิ่งนี้ให้สร้างช่วงวันที่ของอนุกรมเวลาของเรา ในตัวอย่างนี้เราเก็บข้อมูลหนึ่งเดือนเป็นความถี่ ไฟล์ของเรามีข้อมูลซึ่งเริ่มตั้งแต่เดือนมกราคม 1950
dates = pd.date_range('1950-01', periods = input_data.shape[0], freq = 'M')
ในขั้นตอนนี้เราสร้างข้อมูลอนุกรมเวลาด้วยความช่วยเหลือของ Pandas Series ดังที่แสดงด้านล่าง -
output = pd.Series(input_data[:, index], index = dates)
return output
if __name__=='__main__':
ป้อนเส้นทางของไฟล์อินพุตดังที่แสดงไว้ที่นี่ -
input_file = "/Users/admin/AO.txt"
ตอนนี้แปลงคอลัมน์เป็นรูปแบบไทม์ซีรีย์ดังที่แสดงไว้ที่นี่ -
timeseries = read_data(input_file)
สุดท้ายลงจุดและแสดงภาพข้อมูลโดยใช้คำสั่งที่แสดง -
plt.figure()
timeseries.plot()
plt.show()
คุณจะสังเกตเห็นแปลงดังที่แสดงในภาพต่อไปนี้ -
การแบ่งข้อมูลอนุกรมเวลา
Slicing เกี่ยวข้องกับการดึงข้อมูลเฉพาะบางส่วนของอนุกรมเวลา ในตัวอย่างนี้เรากำลังแบ่งส่วนข้อมูลในช่วงปี 1980 ถึง 1990 เท่านั้นสังเกตโค้ดต่อไปนี้ที่ทำงานนี้ -
timeseries['1980':'1990'].plot()
<matplotlib.axes._subplots.AxesSubplot at 0xa0e4b00>
plt.show()
เมื่อคุณรันโค้ดสำหรับการแบ่งส่วนข้อมูลอนุกรมเวลาคุณสามารถสังเกตกราฟต่อไปนี้ดังที่แสดงในภาพที่นี่ -
การดึงข้อมูลสถิติจากข้อมูลอนุกรมเวลา
คุณจะต้องดึงข้อมูลสถิติบางอย่างจากข้อมูลที่กำหนดในกรณีที่คุณต้องการสรุปที่สำคัญบางอย่าง ค่าเฉลี่ยความแปรปรวนสหสัมพันธ์ค่าสูงสุดและค่าต่ำสุดเป็นสถิติดังกล่าว คุณสามารถใช้รหัสต่อไปนี้หากคุณต้องการดึงสถิติดังกล่าวจากข้อมูลอนุกรมเวลาที่กำหนด -
ค่าเฉลี่ย
คุณสามารถใช้ไฟล์ mean() ฟังก์ชันสำหรับค้นหาค่าเฉลี่ยดังแสดงที่นี่ -
timeseries.mean()
จากนั้นผลลัพธ์ที่คุณจะสังเกตเห็นจากตัวอย่างที่กล่าวถึงคือ -
-0.11143128165238671
ขีดสุด
คุณสามารถใช้ไฟล์ max() ฟังก์ชันสำหรับการค้นหาค่าสูงสุดดังที่แสดงไว้ที่นี่ -
timeseries.max()
จากนั้นผลลัพธ์ที่คุณจะสังเกตเห็นจากตัวอย่างที่กล่าวถึงคือ -
3.4952999999999999
ขั้นต่ำ
คุณสามารถใช้ฟังก์ชัน min () เพื่อค้นหาค่าต่ำสุดดังที่แสดงไว้ที่นี่ -
timeseries.min()
จากนั้นผลลัพธ์ที่คุณจะสังเกตเห็นจากตัวอย่างที่กล่าวถึงคือ -
-4.2656999999999998
รับทุกอย่างพร้อมกัน
หากคุณต้องการคำนวณสถิติทั้งหมดในแต่ละครั้งคุณสามารถใช้ไฟล์ describe() ฟังก์ชันดังแสดงที่นี่ -
timeseries.describe()
จากนั้นผลลัพธ์ที่คุณจะสังเกตเห็นจากตัวอย่างที่กล่าวถึงคือ -
count 817.000000
mean -0.111431
std 1.003151
min -4.265700
25% -0.649430
50% -0.042744
75% 0.475720
max 3.495300
dtype: float64
การสุ่มตัวอย่างซ้ำ
คุณสามารถสุ่มตัวอย่างข้อมูลตามความถี่เวลาอื่นได้ พารามิเตอร์สองตัวสำหรับการสุ่มตัวอย่างซ้ำคือ -
- ช่วงเวลา
- Method
สุ่มตัวอย่างซ้ำด้วยค่าเฉลี่ย ()
คุณสามารถใช้รหัสต่อไปนี้เพื่อสุ่มตัวอย่างข้อมูลด้วยวิธี mean () ซึ่งเป็นวิธีเริ่มต้น -
timeseries_mm = timeseries.resample("A").mean()
timeseries_mm.plot(style = 'g--')
plt.show()
จากนั้นคุณสามารถสังเกตกราฟต่อไปนี้เป็นผลลัพธ์ของการสุ่มตัวอย่างใหม่โดยใช้ค่าเฉลี่ย () -
สุ่มตัวอย่างซ้ำด้วยค่ามัธยฐาน ()
คุณสามารถใช้รหัสต่อไปนี้เพื่อสุ่มตัวอย่างข้อมูลโดยใช้ไฟล์ median()วิธีการ -
timeseries_mm = timeseries.resample("A").median()
timeseries_mm.plot()
plt.show()
จากนั้นคุณสามารถสังเกตกราฟต่อไปนี้เป็นผลลัพธ์ของการสุ่มตัวอย่างซ้ำด้วยค่ามัธยฐาน () -
ค่าเฉลี่ยการหมุน
คุณสามารถใช้รหัสต่อไปนี้เพื่อคำนวณค่าเฉลี่ยการเคลื่อนที่ (เคลื่อนที่) -
timeseries.rolling(window = 12, center = False).mean().plot(style = '-g')
plt.show()
จากนั้นคุณสามารถสังเกตกราฟต่อไปนี้เป็นผลลัพธ์ของค่าเฉลี่ยการหมุน (เคลื่อนที่) -
การวิเคราะห์ข้อมูลตามลำดับโดย Hidden Markov Model (HMM)
HMM เป็นแบบจำลองทางสถิติที่ใช้กันอย่างแพร่หลายสำหรับข้อมูลที่มีความต่อเนื่องและความสามารถในการขยายเช่นการวิเคราะห์ตลาดหุ้นแบบอนุกรมเวลาการตรวจสุขภาพและการรู้จำเสียง ส่วนนี้จะอธิบายรายละเอียดเกี่ยวกับการวิเคราะห์ข้อมูลตามลำดับโดยใช้ Hidden Markov Model (HMM)
แบบจำลอง Markov ที่ซ่อนอยู่ (HMM)
HMM เป็นแบบจำลองสุ่มซึ่งสร้างขึ้นจากแนวคิดของห่วงโซ่ Markov ตามสมมติฐานที่ว่าความน่าจะเป็นของสถิติในอนาคตขึ้นอยู่กับสถานะของกระบวนการปัจจุบันเท่านั้นแทนที่จะเป็นสถานะใด ๆ ที่นำหน้า ตัวอย่างเช่นเมื่อทอยเหรียญเราไม่สามารถพูดได้ว่าผลของการโยนครั้งที่ห้าจะเป็นหัว เนื่องจากเหรียญไม่มีหน่วยความจำใด ๆ และผลลัพธ์ถัดไปไม่ได้ขึ้นอยู่กับผลลัพธ์ก่อนหน้านี้
ในทางคณิตศาสตร์ HMM ประกอบด้วยตัวแปรต่อไปนี้ -
รัฐ (S)
เป็นชุดของสถานะที่ซ่อนอยู่หรือสถานะแฝงที่มีอยู่ใน HMM แสดงโดย S.
สัญลักษณ์เอาต์พุต (O)
เป็นชุดของสัญลักษณ์เอาต์พุตที่เป็นไปได้ที่มีอยู่ใน HMM แสดงโดย O.
เมทริกซ์ความน่าจะเป็นของการเปลี่ยนสถานะ (A)
มันเป็นความน่าจะเป็นของการเปลี่ยนสถานะจากสถานะหนึ่งไปเป็นอีกสถานะหนึ่ง แสดงโดย A.
เมทริกซ์ความน่าจะเป็นการปล่อยการสังเกต (B)
เป็นความน่าจะเป็นของการเปล่ง / สังเกตสัญลักษณ์ในสถานะใดสถานะหนึ่ง แสดงโดย B.
เมทริกซ์ความน่าจะเป็นก่อนหน้า (Π)
เป็นความน่าจะเป็นของการเริ่มต้นที่สถานะใดสถานะหนึ่งจากสถานะต่างๆของระบบ แสดงโดยΠ
ดังนั้น HMM อาจถูกกำหนดเป็น = (S,O,A,B,),
ที่ไหน
- S = {s1,s2,…,sN} เป็นชุดของ N สถานะที่เป็นไปได้
- O = {o1,o2,…,oM} เป็นชุดของสัญลักษณ์การสังเกตที่เป็นไปได้ M
- A คือไฟล์ NN เมทริกซ์ความน่าจะเป็นของการเปลี่ยนสถานะ (TPM)
- B คือไฟล์ NM การสังเกตหรือเมทริกซ์ความน่าจะเป็นการปล่อย (EPM)
- πคือเวกเตอร์การแจกแจงความน่าจะเป็นสถานะเริ่มต้น N มิติ
ตัวอย่าง: การวิเคราะห์ข้อมูลตลาดหุ้น
ในตัวอย่างนี้เราจะวิเคราะห์ข้อมูลของตลาดหุ้นทีละขั้นตอนเพื่อให้เข้าใจว่า HMM ทำงานกับข้อมูลลำดับหรืออนุกรมเวลาอย่างไร โปรดทราบว่าเรากำลังใช้ตัวอย่างนี้ใน Python
นำเข้าแพ็คเกจที่จำเป็นดังแสดงด้านล่าง -
import datetime
import warnings
ตอนนี้ใช้ข้อมูลตลาดหุ้นจาก matpotlib.finance ตามที่แสดงไว้ที่นี่ -
import numpy as np
from matplotlib import cm, pyplot as plt
from matplotlib.dates import YearLocator, MonthLocator
try:
from matplotlib.finance import quotes_historical_yahoo_och1
except ImportError:
from matplotlib.finance import (
quotes_historical_yahoo as quotes_historical_yahoo_och1)
from hmmlearn.hmm import GaussianHMM
โหลดข้อมูลจากวันที่เริ่มต้นและวันที่สิ้นสุดเช่นระหว่างวันที่ระบุสองวันดังที่แสดงไว้ที่นี่ -
start_date = datetime.date(1995, 10, 10)
end_date = datetime.date(2015, 4, 25)
quotes = quotes_historical_yahoo_och1('INTC', start_date, end_date)
ในขั้นตอนนี้เราจะแยกคำพูดปิดทุกวัน สำหรับสิ่งนี้ให้ใช้คำสั่งต่อไปนี้ -
closing_quotes = np.array([quote[2] for quote in quotes])
ตอนนี้เราจะแยกปริมาณการซื้อขายหุ้นทุกวัน สำหรับสิ่งนี้ให้ใช้คำสั่งต่อไปนี้ -
volumes = np.array([quote[5] for quote in quotes])[1:]
ที่นี่ให้ใช้เปอร์เซ็นต์ความแตกต่างของราคาปิดหุ้นโดยใช้รหัสที่แสดงด้านล่าง -
diff_percentages = 100.0 * np.diff(closing_quotes) / closing_quotes[:-]
dates = np.array([quote[0] for quote in quotes], dtype = np.int)[1:]
training_data = np.column_stack([diff_percentages, volumes])
ในขั้นตอนนี้ให้สร้างและฝึก HMM Gaussian สำหรับสิ่งนี้ให้ใช้รหัสต่อไปนี้ -
hmm = GaussianHMM(n_components = 7, covariance_type = 'diag', n_iter = 1000)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
hmm.fit(training_data)
ตอนนี้สร้างข้อมูลโดยใช้แบบจำลอง HMM โดยใช้คำสั่งที่แสดง -
num_samples = 300
samples, _ = hmm.sample(num_samples)
สุดท้ายในขั้นตอนนี้เราจะวางแผนและแสดงภาพเปอร์เซ็นต์ความแตกต่างและปริมาณของหุ้นที่ซื้อขายเป็นผลลัพธ์ในรูปแบบของกราฟ
ใช้รหัสต่อไปนี้เพื่อลงจุดและแสดงภาพเปอร์เซ็นต์ความแตกต่าง -
plt.figure()
plt.title('Difference percentages')
plt.plot(np.arange(num_samples), samples[:, 0], c = 'black')
ใช้รหัสต่อไปนี้เพื่อลงจุดและแสดงภาพปริมาณหุ้นที่ซื้อขาย -
plt.figure()
plt.title('Volume of shares')
plt.plot(np.arange(num_samples), samples[:, 1], c = 'black')
plt.ylim(ymin = 0)
plt.show()
ในบทนี้เราจะเรียนรู้เกี่ยวกับการรู้จำเสียงโดยใช้ AI กับ Python
การพูดเป็นวิธีการสื่อสารขั้นพื้นฐานที่สุดของมนุษย์ในวัยผู้ใหญ่ เป้าหมายพื้นฐานของการประมวลผลคำพูดคือการสร้างปฏิสัมพันธ์ระหว่างมนุษย์กับเครื่องจักร
ระบบประมวลผลคำพูดมีสามงานหลัก -
First, การรู้จำเสียงที่ทำให้เครื่องสามารถจับคำวลีและประโยคที่เราพูดได้
Second, การประมวลผลภาษาธรรมชาติเพื่อให้เครื่องเข้าใจสิ่งที่เราพูดและ
Thirdการสังเคราะห์เสียงเพื่อให้เครื่องสามารถพูดได้
บทนี้เน้นที่ speech recognition, กระบวนการทำความเข้าใจคำพูดที่มนุษย์พูด. โปรดจำไว้ว่าสัญญาณเสียงพูดถูกจับด้วยความช่วยเหลือของไมโครโฟนจากนั้นระบบจะต้องเข้าใจ
การสร้าง Speech Recognizer
Speech Recognition หรือ Automatic Speech Recognition (ASR) เป็นศูนย์กลางของความสนใจสำหรับโครงการ AI เช่นหุ่นยนต์ หากไม่มี ASR จะไม่สามารถจินตนาการถึงหุ่นยนต์ที่มีความรู้ความเข้าใจโต้ตอบกับมนุษย์ได้ อย่างไรก็ตามการสร้างโปรแกรมจดจำเสียงนั้นไม่ใช่เรื่องง่าย
ความยากลำบากในการพัฒนาระบบรู้จำเสียง
การพัฒนาระบบจดจำเสียงพูดคุณภาพสูงเป็นปัญหาที่ยากมาก ความยากของเทคโนโลยีการรู้จำเสียงสามารถจำแนกได้อย่างกว้าง ๆ ตามมิติต่างๆตามที่กล่าวไว้ด้านล่าง -
Size of the vocabulary- ขนาดของคำศัพท์มีผลต่อความง่ายในการพัฒนา ASR พิจารณาขนาดของคำศัพท์ต่อไปนี้เพื่อความเข้าใจที่ดีขึ้น
คำศัพท์ขนาดเล็กประกอบด้วย 2-100 คำเช่นในระบบเมนูเสียง
คำศัพท์ขนาดกลางประกอบด้วยคำหลาย 100 ถึง 1,000 คำเช่นในงานการดึงฐานข้อมูล
คำศัพท์ขนาดใหญ่ประกอบด้วยคำหลาย 10,000 คำเช่นเดียวกับงานเขียนตามคำบอกทั่วไป
Channel characteristics- คุณภาพช่องยังเป็นมิติที่สำคัญ ตัวอย่างเช่นคำพูดของมนุษย์มีแบนด์วิดท์สูงพร้อมช่วงความถี่เต็มในขณะที่เสียงพูดทางโทรศัพท์ประกอบด้วยแบนด์วิดท์ต่ำและมีช่วงความถี่ที่ จำกัด สังเกตว่ามันยากกว่าในช่วงหลัง
Speaking mode- ความง่ายในการพัฒนา ASR ยังขึ้นอยู่กับโหมดการพูดนั่นคือการพูดนั้นอยู่ในโหมดคำแยกหรือโหมดคำที่เชื่อมต่อหรือในโหมดการพูดต่อเนื่อง สังเกตว่าคำพูดต่อเนื่องนั้นยากที่จะจดจำ
Speaking style- คำพูดในการอ่านอาจอยู่ในรูปแบบที่เป็นทางการหรือเกิดขึ้นเองและเป็นการสนทนาในรูปแบบสบาย ๆ อย่างหลังยากที่จะรับรู้
Speaker dependency- เสียงพูดอาจขึ้นอยู่กับลำโพงปรับลำโพงหรือลำโพงอิสระ ลำโพงอิสระเป็นสิ่งที่ยากที่สุดในการสร้าง
Type of noise- เสียงรบกวนเป็นอีกปัจจัยที่ควรพิจารณาในขณะที่พัฒนา ASR อัตราส่วนสัญญาณต่อเสียงรบกวนอาจอยู่ในช่วงต่างๆขึ้นอยู่กับสภาพแวดล้อมอะคูสติกที่สังเกตได้น้อยกว่าเมื่อเทียบกับเสียงพื้นหลังที่มากขึ้น -
หากอัตราส่วนสัญญาณต่อเสียงรบกวนมากกว่า 30dB ถือว่าเป็นช่วงที่สูง
หากอัตราส่วนสัญญาณต่อเสียงรบกวนอยู่ระหว่าง 30dB ถึง 10db จะถือว่าเป็น SNR ขนาดกลาง
หากอัตราส่วนสัญญาณต่อเสียงรบกวนน้อยกว่า 10dB จะถือว่าเป็นช่วงต่ำ
Microphone characteristics- คุณภาพของไมโครโฟนอาจดีปานกลางหรือต่ำกว่าค่าเฉลี่ย นอกจากนี้ระยะห่างระหว่างปากกับไมโครโฟนอาจแตกต่างกันไป ปัจจัยเหล่านี้ควรได้รับการพิจารณาสำหรับระบบการรับรู้
โปรดทราบว่าขนาดของคำศัพท์ที่ใหญ่ขึ้นการจดจำก็จะยากขึ้น
ตัวอย่างเช่นประเภทของเสียงพื้นหลังเช่นเสียงที่อยู่นิ่งเสียงที่ไม่ใช่ของมนุษย์เสียงพูดในพื้นหลังและเสียงรบกวนจากลำโพงอื่น ๆ ก็มีส่วนทำให้ปัญหานั้นยากขึ้น
แม้จะมีปัญหาเหล่านี้นักวิจัยได้ทำงานมากมายในแง่มุมต่างๆของการพูดเช่นการทำความเข้าใจสัญญาณเสียงผู้พูดและการระบุสำเนียง
คุณจะต้องทำตามขั้นตอนด้านล่างเพื่อสร้างโปรแกรมจดจำเสียง -
การแสดงสัญญาณเสียง - อ่านจากไฟล์และดำเนินการกับมัน
นี่เป็นขั้นตอนแรกในการสร้างระบบรู้จำเสียงเนื่องจากจะช่วยให้เข้าใจว่าสัญญาณเสียงมีโครงสร้างอย่างไร ขั้นตอนทั่วไปบางประการที่สามารถปฏิบัติตามเพื่อทำงานกับสัญญาณเสียงมีดังนี้ -
การบันทึก
เมื่อคุณต้องอ่านสัญญาณเสียงจากไฟล์ให้บันทึกโดยใช้ไมโครโฟนในตอนแรก
การสุ่มตัวอย่าง
เมื่อบันทึกด้วยไมโครโฟนสัญญาณจะถูกจัดเก็บในรูปแบบดิจิทัล แต่ในการดำเนินการกับมันเครื่องต้องการให้อยู่ในรูปแบบตัวเลขที่ไม่ต่อเนื่อง ดังนั้นเราควรทำการสุ่มตัวอย่างที่ความถี่หนึ่งและแปลงสัญญาณให้อยู่ในรูปตัวเลขที่ไม่ต่อเนื่อง การเลือกความถี่สูงสำหรับการสุ่มตัวอย่างหมายความว่าเมื่อมนุษย์ฟังสัญญาณพวกเขารู้สึกว่าเป็นสัญญาณเสียงต่อเนื่อง
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงวิธีการวิเคราะห์สัญญาณเสียงแบบขั้นตอนโดยใช้ Python ซึ่งเก็บไว้ในไฟล์ ความถี่ของสัญญาณเสียงนี้คือ 44,100 HZ
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดงไว้ที่นี่ -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
ตอนนี้อ่านไฟล์เสียงที่เก็บไว้ มันจะคืนค่าสองค่าคือความถี่ในการสุ่มตัวอย่างและสัญญาณเสียง ระบุเส้นทางของไฟล์เสียงที่จัดเก็บดังแสดงที่นี่ -
frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")
แสดงพารามิเตอร์เช่นความถี่การสุ่มตัวอย่างของสัญญาณเสียงประเภทข้อมูลของสัญญาณและระยะเวลาโดยใช้คำสั่งที่แสดง -
print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] /
float(frequency_sampling), 2), 'seconds')
ขั้นตอนนี้เกี่ยวข้องกับการปรับสัญญาณให้เป็นปกติดังที่แสดงด้านล่าง -
audio_signal = audio_signal / np.power(2, 15)
ในขั้นตอนนี้เรากำลังดึงค่า 100 แรกจากสัญญาณนี้เพื่อให้เห็นภาพ ใช้คำสั่งต่อไปนี้เพื่อจุดประสงค์นี้ -
audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)
ตอนนี้ให้เห็นภาพสัญญาณโดยใช้คำสั่งด้านล่าง -
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()
คุณจะสามารถดูกราฟเอาต์พุตและข้อมูลที่แยกออกมาสำหรับสัญญาณเสียงด้านบนดังที่แสดงในภาพที่นี่
Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds
การกำหนดลักษณะของสัญญาณเสียง: การเปลี่ยนเป็นโดเมนความถี่
การกำหนดลักษณะของสัญญาณเสียงเกี่ยวข้องกับการแปลงสัญญาณโดเมนเวลาเป็นโดเมนความถี่และการทำความเข้าใจส่วนประกอบความถี่โดย นี่เป็นขั้นตอนที่สำคัญเนื่องจากให้ข้อมูลจำนวนมากเกี่ยวกับสัญญาณ คุณสามารถใช้เครื่องมือทางคณิตศาสตร์เช่น Fourier Transform เพื่อทำการแปลงนี้
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงทีละขั้นตอนวิธีกำหนดลักษณะสัญญาณโดยใช้ Python ซึ่งเก็บไว้ในไฟล์ โปรดทราบว่าที่นี่เรากำลังใช้เครื่องมือทางคณิตศาสตร์ Fourier Transform เพื่อแปลงเป็นโดเมนความถี่
นำเข้าแพ็คเกจที่จำเป็นดังแสดงที่นี่ -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
ตอนนี้อ่านไฟล์เสียงที่เก็บไว้ มันจะคืนค่าสองค่าคือความถี่ในการสุ่มตัวอย่างและสัญญาณเสียง ระบุเส้นทางของไฟล์เสียงที่จัดเก็บดังแสดงในคำสั่งที่นี่ -
frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")
ในขั้นตอนนี้เราจะแสดงพารามิเตอร์เช่นความถี่ในการสุ่มตัวอย่างของสัญญาณเสียงประเภทข้อมูลของสัญญาณและระยะเวลาโดยใช้คำสั่งที่ระบุด้านล่าง -
print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] /
float(frequency_sampling), 2), 'seconds')
ในขั้นตอนนี้เราต้องทำให้สัญญาณเป็นปกติดังที่แสดงในคำสั่งต่อไปนี้ -
audio_signal = audio_signal / np.power(2, 15)
ขั้นตอนนี้เกี่ยวข้องกับการแยกความยาวและความยาวครึ่งหนึ่งของสัญญาณ ใช้คำสั่งต่อไปนี้เพื่อจุดประสงค์นี้ -
length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)
ตอนนี้เราจำเป็นต้องใช้เครื่องมือทางคณิตศาสตร์เพื่อเปลี่ยนเป็นโดเมนความถี่ เรากำลังใช้การแปลงฟูเรียร์
signal_frequency = np.fft.fft(audio_signal)
ตอนนี้ทำการ normalization ของสัญญาณโดเมนความถี่และยกกำลังสอง -
signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2
จากนั้นแยกความยาวและความยาวครึ่งหนึ่งของสัญญาณแปลงความถี่ -
len_fts = len(signal_frequency)
โปรดทราบว่าสัญญาณที่เปลี่ยนรูปฟูเรียร์จะต้องได้รับการปรับเปลี่ยนสำหรับกรณีคู่และแบบคี่
if length_signal % 2:
signal_frequency[1:len_fts] *= 2
else:
signal_frequency[1:len_fts-1] *= 2
ตอนนี้แยกกำลังเป็นเดซิบาล (dB) -
signal_power = 10 * np.log10(signal_frequency)
ปรับความถี่เป็น kHz สำหรับแกน X -
x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0
ตอนนี้ให้เห็นภาพลักษณะของสัญญาณดังนี้ -
plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()
คุณสามารถสังเกตกราฟผลลัพธ์ของโค้ดด้านบนดังแสดงในภาพด้านล่าง -
การสร้างสัญญาณเสียงแบบโมโนโทน
สองขั้นตอนที่คุณเห็นจนถึงตอนนี้มีความสำคัญในการเรียนรู้เกี่ยวกับสัญญาณ ตอนนี้ขั้นตอนนี้จะเป็นประโยชน์หากคุณต้องการสร้างสัญญาณเสียงด้วยพารามิเตอร์ที่กำหนดไว้ล่วงหน้า โปรดทราบว่าขั้นตอนนี้จะบันทึกสัญญาณเสียงในไฟล์เอาต์พุต
ตัวอย่าง
ในตัวอย่างต่อไปนี้เราจะสร้างสัญญาณเสียงเดียวโดยใช้ Python ซึ่งจะถูกเก็บไว้ในไฟล์ สำหรับสิ่งนี้คุณจะต้องทำตามขั้นตอนต่อไปนี้ -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write
ระบุไฟล์ที่ควรบันทึกไฟล์เอาต์พุต
output_file = 'audio_signal_generated.wav'
ตอนนี้ระบุพารามิเตอร์ที่คุณเลือกตามที่แสดง -
duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi
ในขั้นตอนนี้เราสามารถสร้างสัญญาณเสียงดังที่แสดง -
t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)
ตอนนี้บันทึกไฟล์เสียงในไฟล์เอาต์พุต -
write(output_file, frequency_sampling, signal_scaled)
แยก 100 ค่าแรกสำหรับกราฟของเราดังที่แสดง -
audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)
ตอนนี้ให้เห็นภาพสัญญาณเสียงที่สร้างขึ้นดังนี้ -
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()
คุณสามารถสังเกตพล็อตดังแสดงในรูปที่ให้ไว้ที่นี่ -
คุณลักษณะการแยกจากเสียงพูด
นี่เป็นขั้นตอนที่สำคัญที่สุดในการสร้างโปรแกรมจดจำเสียงเพราะหลังจากแปลงสัญญาณเสียงพูดเป็นโดเมนความถี่แล้วเราจะต้องแปลงเป็นเวกเตอร์คุณลักษณะที่ใช้งานได้ เราสามารถใช้เทคนิคการแยกคุณลักษณะต่างๆเช่น MFCC, PLP, PLP-RASTA เป็นต้นเพื่อจุดประสงค์นี้
ตัวอย่าง
ในตัวอย่างต่อไปนี้เราจะแยกคุณสมบัติจากสัญญาณทีละขั้นตอนโดยใช้ Python โดยใช้เทคนิค MFCC
นำเข้าแพ็คเกจที่จำเป็นดังแสดงที่นี่ -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank
ตอนนี้อ่านไฟล์เสียงที่เก็บไว้ มันจะคืนค่าสองค่า - ความถี่ในการสุ่มตัวอย่างและสัญญาณเสียง ระบุเส้นทางของไฟล์เสียงที่จัดเก็บ
frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")
โปรดทราบว่าที่นี่เรากำลังนำตัวอย่าง 15,000 ตัวอย่างแรกมาวิเคราะห์
audio_signal = audio_signal[:15000]
ใช้เทคนิค MFCC และดำเนินการคำสั่งต่อไปนี้เพื่อแยกคุณสมบัติ MFCC -
features_mfcc = mfcc(audio_signal, frequency_sampling)
ตอนนี้พิมพ์พารามิเตอร์ MFCC ดังที่แสดง -
print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])
ตอนนี้พล็อตและแสดงภาพคุณสมบัติ MFCC โดยใช้คำสั่งที่ระบุด้านล่าง -
features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')
ในขั้นตอนนี้เราทำงานร่วมกับคุณสมบัติธนาคารตัวกรองดังที่แสดง -
แยกคุณสมบัติของธนาคารตัวกรอง -
filterbank_features = logfbank(audio_signal, frequency_sampling)
ตอนนี้พิมพ์พารามิเตอร์ filterbank
print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])
ตอนนี้พล็อตและเห็นภาพคุณสมบัติของ filterbank
filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()
จากขั้นตอนข้างต้นคุณสามารถสังเกตผลลัพธ์ต่อไปนี้: รูปที่ 1 สำหรับ MFCC และรูปที่ 2 สำหรับ Filter Bank
การรับรู้คำพูด
การรู้จำเสียงหมายความว่าเมื่อมนุษย์กำลังพูดเครื่องจักรจะเข้าใจมัน ที่นี่เราใช้ Google Speech API ใน Python เพื่อให้มันเกิดขึ้น เราจำเป็นต้องติดตั้งแพ็คเกจต่อไปนี้สำหรับสิ่งนี้ -
Pyaudio - สามารถติดตั้งโดยใช้ pip install Pyaudio คำสั่ง
SpeechRecognition - สามารถติดตั้งแพ็คเกจนี้ได้โดยใช้ pip install SpeechRecognition.
Google-Speech-API - สามารถติดตั้งได้โดยใช้คำสั่ง pip install google-api-python-client.
ตัวอย่าง
สังเกตตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเกี่ยวกับการจดจำคำพูด -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import speech_recognition as sr
สร้างวัตถุตามที่แสดงด้านล่าง -
recording = sr.Recognizer()
ตอนนี้ Microphone() โมดูลจะรับเสียงเป็นอินพุต -
with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
print("Please Say something:")
audio = recording.listen(source)
ตอนนี้ Google API จะจดจำเสียงและให้ผลลัพธ์
try:
print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
print(e)
คุณสามารถดูผลลัพธ์ต่อไปนี้ -
Please Say Something:
You said:
ตัวอย่างเช่นถ้าคุณพูดว่า tutorialspoint.comจากนั้นระบบจะจดจำได้อย่างถูกต้องดังนี้ -
tutorialspoint.com
การค้นหาแบบฮิวริสติกมีบทบาทสำคัญในปัญญาประดิษฐ์ ในบทนี้คุณจะได้เรียนรู้โดยละเอียดเกี่ยวกับเรื่องนี้
แนวคิดของ Heuristic Search ใน AI
ฮิวริสติกเป็นกฎง่ายๆที่นำเราไปสู่ทางออกที่น่าจะเป็นไปได้ ปัญหาส่วนใหญ่ในปัญญาประดิษฐ์มีลักษณะชี้แจงและมีวิธีแก้ไขที่เป็นไปได้มากมาย คุณไม่ทราบแน่ชัดว่าโซลูชันใดถูกต้องและการตรวจสอบโซลูชันทั้งหมดจะมีราคาแพงมาก
ดังนั้นการใช้ฮิวริสติกจะทำให้การค้นหาวิธีแก้ปัญหาแคบลงและกำจัดตัวเลือกที่ไม่ถูกต้อง วิธีการใช้ฮิวริสติกเพื่อนำไปสู่การค้นหาในพื้นที่การค้นหาเรียกว่า Heuristic Search เทคนิคฮิวริสติกมีประโยชน์มากเนื่องจากสามารถเพิ่มการค้นหาได้เมื่อคุณใช้
ความแตกต่างระหว่าง Uninformed และ Informed Search
กลยุทธ์การควบคุมหรือเทคนิคการค้นหามีสองประเภท: ไม่รู้และแจ้งให้ทราบ มีการอธิบายรายละเอียดตามที่ระบุไว้ที่นี่ -
การค้นหาที่ไม่มีข้อมูล
เรียกอีกอย่างว่ากลยุทธ์การค้นหาคนตาบอดหรือการควบคุมคนตาบอด ตั้งชื่อเช่นนี้เนื่องจากมีข้อมูลเกี่ยวกับนิยามปัญหาเท่านั้นและไม่มีข้อมูลเพิ่มเติมอื่น ๆ เกี่ยวกับสถานะ เทคนิคการค้นหาแบบนี้จะค้นหาพื้นที่ของรัฐทั้งหมดเพื่อรับโซลูชัน Breadth First Search (BFS) และ Depth First Search (DFS) เป็นตัวอย่างของการค้นหาที่ไม่มีข้อมูล
การค้นหาข้อมูล
เรียกอีกอย่างว่าการค้นหาฮิวริสติกหรือกลยุทธ์การควบคุมฮิวริสติก ได้รับการตั้งชื่อเช่นนี้เนื่องจากมีข้อมูลเพิ่มเติมเกี่ยวกับรัฐ ข้อมูลเพิ่มเติมนี้มีประโยชน์ในการคำนวณค่ากำหนดระหว่างโหนดลูกเพื่อสำรวจและขยาย จะมีฟังก์ชันฮิวริสติกที่เกี่ยวข้องกับแต่ละโหนด Best First Search (BFS), A *, ค่าเฉลี่ยและการวิเคราะห์เป็นตัวอย่างของการค้นหาข้อมูล
ปัญหาความพึงพอใจของข้อ จำกัด (CSPs)
Constraint หมายถึงข้อ จำกัด หรือข้อ จำกัด ใน AI ปัญหาความพึงพอใจที่มีข้อ จำกัด เป็นปัญหาที่ต้องแก้ไขภายใต้ข้อ จำกัด บางประการ ต้องมุ่งเน้นที่จะไม่ละเมิดข้อ จำกัด ในขณะที่แก้ปัญหาดังกล่าว ในที่สุดเมื่อเราไปถึงโซลูชันสุดท้าย CSP จะต้องปฏิบัติตามข้อ จำกัด
ปัญหาในโลกแห่งความจริงแก้ไขได้โดยความพึงพอใจข้อ จำกัด
ส่วนก่อนหน้านี้เกี่ยวข้องกับการสร้างปัญหาความพึงพอใจที่มีข้อ จำกัด ตอนนี้ให้เรานำสิ่งนี้ไปใช้กับปัญหาในโลกแห่งความจริงด้วย ตัวอย่างบางส่วนของปัญหาในโลกแห่งความเป็นจริงที่แก้ไขโดยความพึงพอใจมีดังนี้ -
การแก้ความสัมพันธ์พีชคณิต
ด้วยความช่วยเหลือของปัญหาความพึงพอใจที่มีข้อ จำกัด เราสามารถแก้ความสัมพันธ์เกี่ยวกับพีชคณิตได้ ในตัวอย่างนี้เราจะพยายามแก้ความสัมพันธ์พีชคณิตอย่างง่ายa*2 = b. มันจะคืนค่าของa และ b ภายในช่วงที่เราจะกำหนด
หลังจากเสร็จสิ้นโปรแกรม Python นี้คุณจะสามารถเข้าใจพื้นฐานของการแก้ปัญหาด้วยความพึงพอใจที่ จำกัด
โปรดทราบว่าก่อนเขียนโปรแกรมเราต้องติดตั้งแพ็คเกจ Python ที่เรียกว่า python-constraint คุณสามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install python-constraint
ขั้นตอนต่อไปนี้จะแสดงโปรแกรม Python สำหรับการแก้ปัญหาความสัมพันธ์พีชคณิตโดยใช้ข้อ จำกัด -
นำเข้าไฟล์ constraint แพคเกจโดยใช้คำสั่งต่อไปนี้ -
from constraint import *
ตอนนี้สร้างวัตถุของโมดูลชื่อ problem() ดังแสดงด้านล่าง -
problem = Problem()
ตอนนี้กำหนดตัวแปร โปรดทราบว่าที่นี่เรามีตัวแปร a และ b สองตัวและเรากำลังกำหนด 10 เป็นช่วงซึ่งหมายความว่าเราได้คำตอบภายใน 10 ตัวเลขแรก
problem.addVariable('a', range(10))
problem.addVariable('b', range(10))
จากนั้นกำหนดข้อ จำกัด เฉพาะที่เราต้องการใช้กับปัญหานี้ สังเกตว่าที่นี่เรากำลังใช้ข้อ จำกัดa*2 = b.
problem.addConstraint(lambda a, b: a * 2 == b)
ตอนนี้สร้างวัตถุของ getSolution() โมดูลโดยใช้คำสั่งต่อไปนี้ -
solutions = problem.getSolutions()
สุดท้ายพิมพ์ผลลัพธ์โดยใช้คำสั่งต่อไปนี้ -
print (solutions)
คุณสามารถสังเกตผลลัพธ์ของโปรแกรมข้างต้นได้ดังนี้ -
[{'a': 4, 'b': 8}, {'a': 3, 'b': 6}, {'a': 2, 'b': 4}, {'a': 1, 'b': 2}, {'a': 0, 'b': 0}]
จัตุรัสวิเศษ
สี่เหลี่ยมวิเศษคือการจัดเรียงของตัวเลขที่แตกต่างกันโดยทั่วไปคือจำนวนเต็มในตารางสี่เหลี่ยมซึ่งตัวเลขในแต่ละแถวและในแต่ละคอลัมน์และตัวเลขในแนวทแยงทั้งหมดจะรวมกันเป็นจำนวนเดียวกันเรียกว่า "ค่าคงที่เวทย์มนตร์" .
ต่อไปนี้คือการดำเนินการตามขั้นตอนของโค้ด Python อย่างง่ายสำหรับการสร้างสี่เหลี่ยมวิเศษ -
กำหนดฟังก์ชันชื่อ magic_squareดังที่แสดงด้านล่าง -
def magic_square(matrix_ms):
iSize = len(matrix_ms[0])
sum_list = []
รหัสต่อไปนี้แสดงรหัสสำหรับแนวตั้งของสี่เหลี่ยม -
for col in range(iSize):
sum_list.append(sum(row[col] for row in matrix_ms))
รหัสต่อไปนี้แสดงรหัสสำหรับแนวนอนของสี่เหลี่ยม -
sum_list.extend([sum (lines) for lines in matrix_ms])
รหัสต่อไปนี้แสดงรหัสสำหรับแนวนอนของสี่เหลี่ยม -
dlResult = 0
for i in range(0,iSize):
dlResult +=matrix_ms[i][i]
sum_list.append(dlResult)
drResult = 0
for i in range(iSize-1,-1,-1):
drResult +=matrix_ms[i][i]
sum_list.append(drResult)
if len(set(sum_list))>1:
return False
return True
ตอนนี้ให้ค่าของเมทริกซ์และตรวจสอบผลลัพธ์ -
print(magic_square([[1,2,3], [4,5,6], [7,8,9]]))
คุณสามารถสังเกตได้ว่าผลลัพธ์จะเป็นอย่างไร False เนื่องจากผลรวมไม่ถึงตัวเลขเดียวกัน
print(magic_square([[3,9,2], [3,5,7], [9,1,6]]))
คุณสามารถสังเกตได้ว่าผลลัพธ์จะเป็นอย่างไร True เนื่องจากผลรวมเป็นจำนวนเดียวกันนั่นคือ 15 ที่นี่.
มีการเล่นเกมด้วยกลยุทธ์ ผู้เล่นหรือทีมทุกคนจะต้องวางกลยุทธ์ก่อนที่จะเริ่มเกมและพวกเขาจะต้องเปลี่ยนหรือสร้างกลยุทธ์ใหม่ตามสถานการณ์ปัจจุบันในเกม
อัลกอริทึมการค้นหา
คุณจะต้องพิจารณาเกมคอมพิวเตอร์ด้วยกลยุทธ์เดียวกันกับข้างต้น โปรดทราบว่าอัลกอริทึมการค้นหาเป็นสิ่งที่กำหนดกลยุทธ์ในเกมคอมพิวเตอร์
มันทำงานอย่างไร
เป้าหมายของอัลกอริทึมการค้นหาคือการค้นหาชุดการเคลื่อนไหวที่เหมาะสมที่สุดเพื่อให้สามารถไปถึงจุดหมายสุดท้ายและชนะ อัลกอริทึมเหล่านี้ใช้ชุดเงื่อนไขที่ชนะซึ่งแตกต่างกันไปในทุกเกมเพื่อค้นหาการเคลื่อนไหวที่ดีที่สุด
เห็นภาพเกมคอมพิวเตอร์เป็นต้นไม้ เรารู้ว่าต้นไม้มีโหนด เริ่มจากรูทเราสามารถมาที่โหนดสุดท้ายที่ชนะ แต่ด้วยการเคลื่อนไหวที่เหมาะสมที่สุด นั่นคือการทำงานของอัลกอริทึมการค้นหา ทุกโหนดในทรีดังกล่าวแสดงถึงสถานะในอนาคต อัลกอริทึมการค้นหาจะค้นหาผ่านโครงสร้างนี้เพื่อทำการตัดสินใจในแต่ละขั้นตอนหรือโหนดของเกม
การค้นหาแบบผสมผสาน
ข้อเสียที่สำคัญของการใช้อัลกอริทึมการค้นหาคือมีลักษณะที่ละเอียดถี่ถ้วนซึ่งเป็นสาเหตุที่พวกเขาสำรวจพื้นที่ค้นหาทั้งหมดเพื่อค้นหาวิธีแก้ปัญหาที่นำไปสู่การสิ้นเปลืองทรัพยากร มันจะยุ่งยากกว่านี้หากอัลกอริทึมเหล่านี้จำเป็นต้องค้นหาพื้นที่การค้นหาทั้งหมดเพื่อค้นหาโซลูชันสุดท้าย
เพื่อขจัดปัญหาดังกล่าวเราสามารถใช้การค้นหาแบบผสมผสานซึ่งใช้ฮิวริสติกเพื่อสำรวจพื้นที่ค้นหาและลดขนาดโดยกำจัดการเคลื่อนไหวที่ผิดพลาดที่อาจเกิดขึ้นได้ ดังนั้นอัลกอริทึมดังกล่าวสามารถประหยัดทรัพยากรได้ อัลกอริทึมบางอย่างที่ใช้ฮิวริสติกเพื่อค้นหาพื้นที่และบันทึกทรัพยากรจะกล่าวถึงที่นี่ -
Minimax Algorithm
เป็นกลยุทธ์ที่ใช้ในการค้นหาแบบผสมผสานที่ใช้ฮิวริสติกเพื่อเร่งกลยุทธ์การค้นหา แนวคิดของกลยุทธ์ Minimax สามารถเข้าใจได้ด้วยตัวอย่างของเกมผู้เล่นสองคนซึ่งผู้เล่นแต่ละคนพยายามที่จะคาดเดาการเคลื่อนไหวครั้งต่อไปของฝ่ายตรงข้ามและพยายามลดฟังก์ชันนั้นให้น้อยที่สุด นอกจากนี้เพื่อที่จะชนะผู้เล่นจะพยายามเพิ่มฟังก์ชันของตัวเองให้สูงสุดตามสถานการณ์ปัจจุบันเสมอ
ฮิวริสติกมีบทบาทสำคัญในกลยุทธ์ประเภทนี้เช่น Minimax ทุกโหนดของต้นไม้จะมีฟังก์ชันฮิวริสติกที่เกี่ยวข้อง ตามฮิวริสติกนั้นจะต้องใช้การตัดสินใจที่จะก้าวไปสู่โหนดที่จะเป็นประโยชน์ต่อพวกเขามากที่สุด
การตัดแต่งอัลฟ่า - เบต้า
ปัญหาหลักของขั้นตอนวิธี Minimax คือสามารถสำรวจส่วนต่างๆของต้นไม้ที่ไม่เกี่ยวข้องซึ่งนำไปสู่การสูญเสียทรัพยากร ดังนั้นจึงต้องมีกลยุทธ์ในการตัดสินใจว่าส่วนใดของต้นไม้ที่เกี่ยวข้องและส่วนใดไม่เกี่ยวข้องและปล่อยให้ส่วนที่ไม่เกี่ยวข้องไม่ได้รับการสำรวจ การตัดแต่งอัลฟ่า - เบต้าเป็นกลยุทธ์ประเภทหนึ่ง
เป้าหมายหลักของอัลกอริธึมการตัดแต่งอัลฟ่า - เบต้าคือการหลีกเลี่ยงการค้นหาส่วนต่างๆของต้นไม้ที่ไม่มีวิธีแก้ปัญหาใด ๆ แนวคิดหลักของการตัดแต่งกิ่งอัลฟ่า - เบต้าคือการใช้ขอบเขตสองชื่อAlphaขอบเขตล่างสูงสุดและ Betaขอบเขตบนขั้นต่ำ พารามิเตอร์ทั้งสองนี้เป็นค่าที่ จำกัด ชุดของโซลูชันที่เป็นไปได้ จะเปรียบเทียบค่าของโหนดปัจจุบันกับค่าของพารามิเตอร์อัลฟาและเบต้าเพื่อให้สามารถย้ายไปยังส่วนของต้นไม้ที่มีโซลูชันและทิ้งส่วนที่เหลือ
อัลกอริทึม Negamax
อัลกอริทึมนี้ไม่แตกต่างจากขั้นตอนวิธี Minimax แต่มีการนำไปใช้งานที่สง่างามกว่า ข้อเสียเปรียบหลักของการใช้ขั้นตอนวิธี Minimax คือเราจำเป็นต้องกำหนดฟังก์ชันฮิวริสติกสองฟังก์ชันที่แตกต่างกัน ความเชื่อมโยงระหว่างฮิวริสติกเหล่านี้คือยิ่งสถานะของเกมดีขึ้นสำหรับผู้เล่นคนหนึ่งผู้เล่นคนอื่นก็ยิ่งแย่ลง ในอัลกอริทึม Negamax การทำงานแบบเดียวกันของฟังก์ชันฮิวริสติกสองฟังก์ชันทำได้โดยใช้ฟังก์ชันฮิวริสติกเพียงฟังก์ชันเดียว
การสร้างบอทเพื่อเล่นเกม
สำหรับการสร้างบอทเพื่อเล่นเกมผู้เล่นสองคนใน AI เราจำเป็นต้องติดตั้งไฟล์ easyAIห้องสมุด. เป็นกรอบปัญญาประดิษฐ์ที่ให้ฟังก์ชันทั้งหมดในการสร้างเกมที่มีผู้เล่นสองคน คุณสามารถดาวน์โหลดได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install easyAI
บอทเพื่อเล่นเหรียญยืนสุดท้าย
ในเกมนี้จะมีกองเหรียญ ผู้เล่นแต่ละคนจะต้องใช้เหรียญจำนวนหนึ่งจากกองนั้น เป้าหมายของเกมคือหลีกเลี่ยงการรับเหรียญสุดท้ายในกอง เราจะใช้คลาสLastCoinStanding สืบทอดมาจาก TwoPlayersGame คลาสของ easyAIห้องสมุด. รหัสต่อไปนี้แสดงรหัส Python สำหรับเกมนี้ -
นำเข้าแพ็คเกจที่ต้องการตามที่แสดง -
from easyAI import TwoPlayersGame, id_solve, Human_Player, AI_Player
from easyAI.AI import TT
ตอนนี้สืบทอดคลาสจาก TwoPlayerGame คลาสเพื่อจัดการการทำงานทั้งหมดของเกม -
class LastCoin_game(TwoPlayersGame):
def __init__(self, players):
ตอนนี้กำหนดผู้เล่นและผู้เล่นที่จะเริ่มเกม
self.players = players
self.nplayer = 1
ตอนนี้กำหนดจำนวนเหรียญในเกมที่นี่เราใช้ 15 เหรียญสำหรับเกม
self.num_coins = 15
กำหนดจำนวนเหรียญสูงสุดที่ผู้เล่นสามารถเคลื่อนย้ายได้
self.max_coins = 4
ตอนนี้มีบางสิ่งที่ต้องกำหนดดังที่แสดงในรหัสต่อไปนี้ กำหนดการเคลื่อนไหวที่เป็นไปได้
def possible_moves(self):
return [str(a) for a in range(1, self.max_coins + 1)]
กำหนดการกำจัดเหรียญ
def make_move(self, move):
self.num_coins -= int(move)
กำหนดผู้ที่หยิบเหรียญสุดท้าย
def win_game(self):
return self.num_coins <= 0
กำหนดเวลาที่จะหยุดเกมนั่นคือเมื่อมีคนชนะ
def is_over(self):
return self.win()
กำหนดวิธีคำนวณคะแนน
def score(self):
return 100 if self.win_game() else 0
กำหนดจำนวนเหรียญที่เหลืออยู่ในกอง
def show(self):
print(self.num_coins, 'coins left in the pile')
if __name__ == "__main__":
tt = TT()
LastCoin_game.ttentry = lambda self: self.num_coins
การแก้เกมด้วยการบล็อกรหัสต่อไปนี้ -
r, d, m = id_solve(LastCoin_game,
range(2, 20), win_score=100, tt=tt)
print(r, d, m)
การตัดสินใจว่าใครจะเป็นคนเริ่มเกม
game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()
คุณสามารถค้นหาผลลัพธ์ต่อไปนี้และการเล่นง่ายๆของเกมนี้ -
d:2, a:0, m:1
d:3, a:0, m:1
d:4, a:0, m:1
d:5, a:0, m:1
d:6, a:100, m:4
1 6 4
15 coins left in the pile
Move #1: player 1 plays 4 :
11 coins left in the pile
Player 2 what do you play ? 2
Move #2: player 2 plays 2 :
9 coins left in the pile
Move #3: player 1 plays 3 :
6 coins left in the pile
Player 2 what do you play ? 1
Move #4: player 2 plays 1 :
5 coins left in the pile
Move #5: player 1 plays 4 :
1 coins left in the pile
Player 2 what do you play ? 1
Move #6: player 2 plays 1 :
0 coins left in the pile
บอทเพื่อเล่น Tic Tac Toe
Tic-Tac-Toe เป็นเกมที่คุ้นเคยและเป็นที่นิยมมากที่สุดเกมหนึ่ง ให้เราสร้างเกมนี้โดยใช้ไฟล์easyAIไลบรารีใน Python รหัสต่อไปนี้คือรหัส Python ของเกมนี้ -
นำเข้าแพ็คเกจตามที่แสดง -
from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player
สืบทอดคลาสจาก TwoPlayerGame คลาสเพื่อจัดการการทำงานทั้งหมดของเกม -
class TicTacToe_game(TwoPlayersGame):
def __init__(self, players):
ตอนนี้กำหนดผู้เล่นและผู้เล่นที่จะเริ่มเกม -
self.players = players
self.nplayer = 1
กำหนดประเภทของกระดาน -
self.board = [0] * 9
ตอนนี้มีบางสิ่งที่จะกำหนดดังต่อไปนี้ -
กำหนดการเคลื่อนไหวที่เป็นไปได้
def possible_moves(self):
return [x + 1 for x, y in enumerate(self.board) if y == 0]
กำหนดการเคลื่อนไหวของผู้เล่น -
def make_move(self, move):
self.board[int(move) - 1] = self.nplayer
ในการเพิ่ม AI ให้กำหนดเวลาที่ผู้เล่นทำการเคลื่อนไหว -
def umake_move(self, move):
self.board[int(move) - 1] = 0
กำหนดเงื่อนไขการแพ้ว่าฝ่ายตรงข้ามมีสามคนในบรรทัด
def condition_for_lose(self):
possible_combinations = [[1,2,3], [4,5,6], [7,8,9],
[1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]
return any([all([(self.board[z-1] == self.nopponent)
for z in combination]) for combination in possible_combinations])
กำหนดการตรวจสอบการจบเกม
def is_over(self):
return (self.possible_moves() == []) or self.condition_for_lose()
แสดงตำแหน่งปัจจุบันของผู้เล่นในเกม
def show(self):
print('\n'+'\n'.join([' '.join([['.', 'O', 'X'][self.board[3*j + i]]
for i in range(3)]) for j in range(3)]))
คำนวณคะแนน
def scoring(self):
return -100 if self.condition_for_lose() else 0
กำหนดวิธีการหลักเพื่อกำหนดอัลกอริทึมและเริ่มเกม -
if __name__ == "__main__":
algo = Negamax(7)
TicTacToe_game([Human_Player(), AI_Player(algo)]).play()
คุณสามารถดูผลลัพธ์ต่อไปนี้และการเล่นง่ายๆของเกมนี้ -
. . .
. . .
. . .
Player 1 what do you play ? 1
Move #1: player 1 plays 1 :
O . .
. . .
. . .
Move #2: player 2 plays 5 :
O . .
. X .
121
. . .
Player 1 what do you play ? 3
Move #3: player 1 plays 3 :
O . O
. X .
. . .
Move #4: player 2 plays 2 :
O X O
. X .
. . .
Player 1 what do you play ? 4
Move #5: player 1 plays 4 :
O X O
O X .
. . .
Move #6: player 2 plays 8 :
O X O
O X .
. X .
เครือข่ายประสาทเทียมเป็นอุปกรณ์คอมพิวเตอร์แบบขนานที่พยายามสร้างแบบจำลองคอมพิวเตอร์ของสมอง วัตถุประสงค์หลักเบื้องหลังคือการพัฒนาระบบเพื่อทำงานด้านการคำนวณต่างๆได้เร็วกว่าระบบแบบเดิม งานเหล่านี้ ได้แก่ การจดจำรูปแบบและการจำแนกประเภทการประมาณค่าการเพิ่มประสิทธิภาพและการจัดกลุ่มข้อมูล
โครงข่ายประสาทเทียมคืออะไร (ANN)
โครงข่ายประสาทเทียม (ANN) เป็นระบบคอมพิวเตอร์ที่มีประสิทธิภาพซึ่งมีธีมหลักที่ยืมมาจากการเปรียบเทียบเครือข่ายประสาททางชีววิทยา ANN ยังมีชื่อเป็นระบบประสาทเทียมระบบประมวลผลแบบกระจายขนานและระบบ Connectionist ANN ได้รับชุดอุปกรณ์จำนวนมากที่เชื่อมต่อกันในบางรูปแบบเพื่อให้สามารถสื่อสารระหว่างกันได้ หน่วยเหล่านี้เรียกอีกอย่างว่าnodes หรือ neuronsเป็นโปรเซสเซอร์อย่างง่ายที่ทำงานแบบขนาน
เซลล์ประสาททุกเซลล์เชื่อมต่อกับเซลล์ประสาทอื่น ๆ ผ่านทาง connection link. ลิงค์เชื่อมต่อแต่ละลิงค์เกี่ยวข้องกับน้ำหนักที่มีข้อมูลเกี่ยวกับสัญญาณอินพุต นี่เป็นข้อมูลที่มีประโยชน์ที่สุดสำหรับเซลล์ประสาทในการแก้ปัญหาโดยเฉพาะเนื่องจากweightโดยปกติจะกระตุ้นหรือยับยั้งสัญญาณที่กำลังสื่อสาร เซลล์ประสาทแต่ละเซลล์มีสถานะภายในซึ่งเรียกว่าactivation signal. สัญญาณเอาท์พุตซึ่งสร้างขึ้นหลังจากรวมสัญญาณอินพุตและกฎการเปิดใช้งานอาจถูกส่งไปยังหน่วยอื่น
หากคุณต้องการที่จะศึกษาเครือข่ายประสาทในรายละเอียดแล้วคุณสามารถทำตามลิงค์ - โครงข่ายประสาทเทียม
การติดตั้งแพ็คเกจที่มีประโยชน์
สำหรับการสร้างเครือข่ายประสาทเทียมใน Python เราสามารถใช้แพ็คเกจที่มีประสิทธิภาพสำหรับเครือข่ายประสาทที่เรียกว่า NeuroLab. เป็นไลบรารีของอัลกอริทึมเครือข่ายประสาทพื้นฐานที่มีการกำหนดค่าเครือข่ายที่ยืดหยุ่นและอัลกอริทึมการเรียนรู้สำหรับ Python คุณสามารถติดตั้งแพ็คเกจนี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ในพรอมต์คำสั่ง -
pip install NeuroLab
หากคุณใช้สภาพแวดล้อม Anaconda ให้ใช้คำสั่งต่อไปนี้เพื่อติดตั้ง NeuroLab -
conda install -c labfabulous neurolab
การสร้างโครงข่ายประสาทเทียม
ในส่วนนี้ให้เราสร้างเครือข่ายประสาทเทียมใน Python โดยใช้แพ็คเกจ NeuroLab
ตัวจำแนกตาม Perceptron
Perceptrons เป็นส่วนประกอบสำคัญของ ANN หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับ Perceptron คุณสามารถไปที่ลิงค์ - artificial_neural_network
ต่อไปนี้คือการดำเนินการตามขั้นตอนของรหัส Python สำหรับการสร้างตัวจำแนกตาม Perceptron ของเครือข่ายประสาทเทียม -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import matplotlib.pyplot as plt
import neurolab as nl
ป้อนค่าอินพุต โปรดทราบว่านี่เป็นตัวอย่างของการเรียนรู้ภายใต้การดูแลดังนั้นคุณจะต้องระบุค่าเป้าหมายด้วย
input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]
สร้างเครือข่ายด้วย 2 อินพุตและ 1 เซลล์ประสาท -
net = nl.net.newp([[0, 1],[0, 1]], 1)
ตอนนี้ฝึกเครือข่าย ที่นี่เราใช้กฎเดลต้าในการฝึกอบรม
error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)
ตอนนี้ให้เห็นภาพผลลัพธ์และพล็อตกราฟ -
plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()
คุณสามารถดูกราฟต่อไปนี้ที่แสดงความคืบหน้าของการฝึกโดยใช้เมตริกข้อผิดพลาด -
โครงข่ายประสาทชั้นเดียว
ในตัวอย่างนี้เรากำลังสร้างเครือข่ายประสาทชั้นเดียวที่ประกอบด้วยเซลล์ประสาทอิสระที่ทำหน้าที่ป้อนข้อมูลเพื่อสร้างผลลัพธ์ โปรดทราบว่าเรากำลังใช้ไฟล์ข้อความชื่อneural_simple.txt เป็นข้อมูลของเรา
นำเข้าแพ็คเกจที่มีประโยชน์ดังที่แสดง -
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
โหลดชุดข้อมูลดังนี้ -
input_data = np.loadtxt(“/Users/admin/neural_simple.txt')
ต่อไปนี้เป็นข้อมูลที่เราจะใช้ โปรดทราบว่าในข้อมูลนี้สองคอลัมน์แรกคือคุณลักษณะและสองคอลัมน์สุดท้ายคือป้ายกำกับ
array([[2. , 4. , 0. , 0. ],
[1.5, 3.9, 0. , 0. ],
[2.2, 4.1, 0. , 0. ],
[1.9, 4.7, 0. , 0. ],
[5.4, 2.2, 0. , 1. ],
[4.3, 7.1, 0. , 1. ],
[5.8, 4.9, 0. , 1. ],
[6.5, 3.2, 0. , 1. ],
[3. , 2. , 1. , 0. ],
[2.5, 0.5, 1. , 0. ],
[3.5, 2.1, 1. , 0. ],
[2.9, 0.3, 1. , 0. ],
[6.5, 8.3, 1. , 1. ],
[3.2, 6.2, 1. , 1. ],
[4.9, 7.8, 1. , 1. ],
[2.1, 4.8, 1. , 1. ]])
ตอนนี้แยกสี่คอลัมน์ออกเป็น 2 คอลัมน์ข้อมูลและ 2 ป้ายกำกับ -
data = input_data[:, 0:2]
labels = input_data[:, 2:]
พล็อตข้อมูลอินพุตโดยใช้คำสั่งต่อไปนี้ -
plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')
ตอนนี้กำหนดค่าต่ำสุดและสูงสุดสำหรับแต่ละมิติดังที่แสดงไว้ที่นี่ -
dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()
จากนั้นกำหนดจำนวนเซลล์ประสาทในชั้นผลลัพธ์ดังนี้ -
nn_output_layer = labels.shape[1]
ตอนนี้กำหนดเครือข่ายประสาทชั้นเดียว -
dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)
ฝึกโครงข่ายประสาทด้วยจำนวนยุคและอัตราการเรียนรู้ดังที่แสดง -
error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)
ตอนนี้ให้เห็นภาพและวางแผนความคืบหน้าการฝึกอบรมโดยใช้คำสั่งต่อไปนี้ -
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()
ตอนนี้ใช้จุดข้อมูลทดสอบในลักษณนามด้านบน -
print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
print(item, '-->', neural_net.sim([item])[0])
คุณสามารถค้นหาผลการทดสอบดังที่แสดงไว้ที่นี่ -
[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]
คุณสามารถดูกราฟต่อไปนี้เป็นผลลัพธ์ของโค้ดที่กล่าวถึงจนถึงตอนนี้ -
เครือข่ายประสาทหลายชั้น
ในตัวอย่างนี้เรากำลังสร้างเครือข่ายประสาทเทียมแบบหลายชั้นที่ประกอบด้วยเลเยอร์มากกว่าหนึ่งชั้นเพื่อดึงรูปแบบพื้นฐานในข้อมูลการฝึกอบรม เครือข่ายประสาทหลายชั้นนี้จะทำงานเหมือนตัวรีเครสเซอร์ เราจะสร้างจุดข้อมูลตามสมการ: y = 2x 2 +8
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
สร้างจุดข้อมูลตามสมการที่กล่าวถึงข้างต้น -
min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)
ตอนนี้จัดรูปแบบชุดข้อมูลนี้ใหม่ดังนี้ -
data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)
แสดงภาพและพล็อตชุดข้อมูลอินพุตโดยใช้คำสั่งต่อไปนี้ -
plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')
ตอนนี้สร้างเครือข่ายประสาทที่มีสองชั้นที่ซ่อนอยู่ด้วย neurolab ด้วย ten เซลล์ประสาทในชั้นแรกที่ซ่อนอยู่ six ในเลเยอร์ที่ซ่อนอยู่ที่สองและ one ในเลเยอร์เอาต์พุต
neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])
ตอนนี้ใช้อัลกอริธึมการฝึกไล่ระดับสี -
neural_net.trainf = nl.train.train_gd
ตอนนี้ฝึกอบรมเครือข่ายโดยมีเป้าหมายในการเรียนรู้จากข้อมูลที่สร้างขึ้นด้านบน -
error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)
ตอนนี้เรียกใช้เครือข่ายประสาทบนจุดข้อมูลการฝึกอบรม -
output = neural_net.sim(data)
y_pred = output.reshape(num_points)
ตอนนี้งานพล็อตและการสร้างภาพ -
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')
ตอนนี้เราจะวางแผนผลลัพธ์จริงกับผลลัพธ์ที่คาดการณ์ไว้ -
x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()
จากคำสั่งข้างต้นคุณสามารถสังเกตกราฟดังที่แสดงด้านล่าง -
ในบทนี้คุณจะได้เรียนรู้รายละเอียดเกี่ยวกับแนวคิดการเสริมสร้างการเรียนรู้ใน AI ด้วย Python
พื้นฐานของการเรียนรู้การเสริมแรง
การเรียนรู้ประเภทนี้ใช้เพื่อเสริมสร้างหรือเสริมสร้างเครือข่ายโดยอาศัยข้อมูลของนักวิจารณ์ นั่นคือเครือข่ายที่ได้รับการฝึกอบรมภายใต้การเรียนรู้แบบเสริมกำลังได้รับข้อเสนอแนะจากสิ่งแวดล้อม อย่างไรก็ตามข้อเสนอแนะนั้นได้รับการประเมินและไม่ได้ให้คำแนะนำเช่นเดียวกับในกรณีของการเรียนรู้ภายใต้การดูแล จากความคิดเห็นนี้เครือข่ายจะทำการปรับเปลี่ยนน้ำหนักเพื่อให้ได้ข้อมูลนักวิจารณ์ที่ดีขึ้นในอนาคต
กระบวนการเรียนรู้นี้คล้ายกับการเรียนรู้ภายใต้การดูแล แต่เราอาจมีข้อมูลน้อยมาก รูปต่อไปนี้แสดงแผนภาพบล็อกของการเรียนรู้การเสริมแรง -
Building Blocks: สภาพแวดล้อมและตัวแทน
สภาพแวดล้อมและตัวแทนเป็นส่วนประกอบหลักของการเรียนรู้การเสริมกำลังใน AI ส่วนนี้จะกล่าวถึงรายละเอียด -
ตัวแทน
ตัวแทนคืออะไรก็ได้ที่สามารถรับรู้สภาพแวดล้อมของมันผ่านเซ็นเซอร์และกระทำต่อสภาพแวดล้อมนั้นผ่านเอฟเฟกต์
ก human agent มีอวัยวะรับความรู้สึกเช่นตาหูจมูกลิ้นและผิวหนังขนานกับเซ็นเซอร์และอวัยวะอื่น ๆ เช่นมือขาปากสำหรับเอฟเฟกต์
ก robotic agent แทนที่กล้องและตัวค้นหาระยะอินฟราเรดสำหรับเซ็นเซอร์และมอเตอร์และตัวกระตุ้นต่างๆสำหรับเอฟเฟกต์
ก software agent ได้เข้ารหัสบิตสตริงเป็นโปรแกรมและการดำเนินการ
คำศัพท์ของตัวแทน
คำศัพท์ต่อไปนี้ใช้บ่อยกว่าในการเรียนรู้แบบเสริมกำลังใน AI -
Performance Measure of Agent - เป็นเกณฑ์ที่กำหนดว่าตัวแทนประสบความสำเร็จเพียงใด
Behavior of Agent - เป็นการกระทำที่ตัวแทนดำเนินการหลังจากลำดับการรับรู้ใด ๆ ที่กำหนด
Percept - เป็นอินพุตการรับรู้ของตัวแทนในอินสแตนซ์ที่กำหนด
Percept Sequence - เป็นประวัติศาสตร์ของทุกสิ่งที่ตัวแทนได้รับรู้จนถึงปัจจุบัน
Agent Function - เป็นแผนที่จากลำดับศีลไปสู่การกระทำ
สิ่งแวดล้อม
บางโปรแกรมทำงานในไฟล์ artificial environment จำกัด เฉพาะอินพุตแป้นพิมพ์ฐานข้อมูลระบบไฟล์คอมพิวเตอร์และเอาต์พุตอักขระบนหน้าจอ
ในทางตรงกันข้ามตัวแทนซอฟต์แวร์บางตัวเช่นซอฟต์แวร์โรบ็อตหรือซอฟต์บอตมีอยู่ในโดเมน softbot ที่สมบูรณ์และไม่ จำกัด เครื่องจำลองมีไฟล์very detailedและ complex environment. ตัวแทนซอฟต์แวร์จำเป็นต้องเลือกจากการดำเนินการที่หลากหลายแบบเรียลไทม์
ตัวอย่างเช่น softbot ที่ออกแบบมาเพื่อสแกนการตั้งค่าออนไลน์ของลูกค้าและแสดงรายการที่น่าสนใจให้กับลูกค้าทำงานในไฟล์ real เช่นเดียวกับ artificial สิ่งแวดล้อม.
คุณสมบัติของสิ่งแวดล้อม
สภาพแวดล้อมมีคุณสมบัติหลายเท่าดังที่กล่าวไว้ด้านล่าง -
Discrete/Continuous- หากมีสถานะของสภาพแวดล้อมที่แตกต่างและกำหนดไว้อย่างชัดเจนจำนวน จำกัด สภาพแวดล้อมจะไม่ต่อเนื่องมิฉะนั้นจะเกิดขึ้นอย่างต่อเนื่อง ตัวอย่างเช่นหมากรุกเป็นสภาพแวดล้อมที่ไม่ต่อเนื่องและการขับขี่เป็นสภาพแวดล้อมที่ต่อเนื่อง
Observable/Partially Observable- หากเป็นไปได้ที่จะกำหนดสถานะที่สมบูรณ์ของสิ่งแวดล้อมในแต่ละช่วงเวลาจากการรับรู้สิ่งนั้นจะสังเกตได้ มิฉะนั้นจะสังเกตได้เพียงบางส่วนเท่านั้น
Static/Dynamic- หากสภาพแวดล้อมไม่เปลี่ยนแปลงในขณะที่ตัวแทนกำลังทำหน้าที่แสดงว่าเป็นแบบคงที่ มิฉะนั้นจะเป็นแบบไดนามิก
Single agent/Multiple agents - สภาพแวดล้อมอาจมีเอเจนต์อื่นซึ่งอาจเหมือนหรือต่างกันกับเอเจนต์
Accessible/Inaccessible- หากอุปกรณ์รับความรู้สึกของตัวแทนสามารถเข้าถึงสถานะที่สมบูรณ์ของสภาพแวดล้อมตัวแทนนั้นสามารถเข้าถึงสภาพแวดล้อมได้ มิฉะนั้นจะไม่สามารถเข้าถึงได้
Deterministic/Non-deterministic- หากสภาวะต่อไปของสิ่งแวดล้อมถูกกำหนดโดยสถานะปัจจุบันและการกระทำของตัวแทนอย่างสมบูรณ์สภาพแวดล้อมจะถูกกำหนด มิฉะนั้นจะไม่ถูกกำหนด
Episodic/Non-episodic- ในสภาพแวดล้อมที่เป็นฉาก ๆ แต่ละตอนประกอบด้วยตัวแทนรับรู้แล้วแสดง คุณภาพของการกระทำขึ้นอยู่กับตอนนั้น ๆ ตอนต่อมาไม่ได้ขึ้นอยู่กับการกระทำในตอนก่อนหน้า สภาพแวดล้อมแบบเป็นตอนนั้นง่ายกว่ามากเพราะตัวแทนไม่จำเป็นต้องคิดล่วงหน้า
การสร้างสภาพแวดล้อมด้วย Python
สำหรับการสร้างตัวแทนการเรียนรู้การเสริมแรงเราจะใช้ OpenAI Gym แพ็คเกจที่สามารถติดตั้งได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install gym
มีสภาพแวดล้อมที่หลากหลายในโรงยิม OpenAI ซึ่งสามารถใช้เพื่อวัตถุประสงค์ต่างๆ มีไม่กี่คนCartpole-v0, Hopper-v1และ MsPacman-v0. พวกเขาต้องการเครื่องยนต์ที่แตกต่างกัน เอกสารรายละเอียดของOpenAI Gym สามารถพบได้ใน https://gym.openai.com/docs/#environments.
รหัสต่อไปนี้แสดงตัวอย่างของรหัส Python สำหรับสภาพแวดล้อม cartpole-v0 -
import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
env.render()
env.step(env.action_space.sample())
คุณสามารถสร้างสภาพแวดล้อมอื่น ๆ ในลักษณะเดียวกันได้
การสร้างตัวแทนการเรียนรู้ด้วย Python
สำหรับการสร้างตัวแทนการเรียนรู้การเสริมแรงเราจะใช้ OpenAI Gym แพคเกจตามที่แสดง -
import gym
env = gym.make('CartPole-v0')
for _ in range(20):
observation = env.reset()
for i in range(100):
env.render()
print(observation)
action = env.action_space.sample()
observation, reward, done, info = env.step(action)
if done:
print("Episode finished after {} timesteps".format(i+1))
break
สังเกตว่าเสารถเข็นสามารถทรงตัวได้เอง
บทนี้จะกล่าวถึงอัลกอริทึมทางพันธุกรรมของ AI โดยละเอียด
Genetic Algorithms คืออะไร?
Genetic Algorithms (GAs) เป็นอัลกอริธึมที่ใช้การค้นหาตามแนวคิดของการคัดเลือกโดยธรรมชาติและพันธุศาสตร์ GAs เป็นชุดย่อยของสาขาการคำนวณที่ใหญ่กว่าที่เรียกว่า Evolutionary Computation
GAs ได้รับการพัฒนาโดย John Holland และนักศึกษาและเพื่อนร่วมงานของเขาที่ University of Michigan โดยเฉพาะอย่างยิ่ง David E. Goldberg ตั้งแต่นั้นมาได้มีการพยายามแก้ไขปัญหาการเพิ่มประสิทธิภาพต่างๆโดยประสบความสำเร็จในระดับสูง
ใน GAs เรามีแนวทางแก้ไขที่เป็นไปได้สำหรับปัญหาที่กำหนด จากนั้นวิธีแก้ปัญหาเหล่านี้จะผ่านการรวมตัวกันใหม่และการกลายพันธุ์ (เช่นเดียวกับในพันธุศาสตร์ตามธรรมชาติ) สร้างลูกใหม่และกระบวนการนี้จะทำซ้ำหลายชั่วอายุคน แต่ละคน (หรือวิธีการแก้ปัญหาของผู้สมัคร) จะได้รับการกำหนดค่าสมรรถภาพ (ตามค่าฟังก์ชันวัตถุประสงค์) และบุคคลที่เหมาะสมจะได้รับโอกาสในการผสมพันธุ์และให้ผลผลิตสูงขึ้นfitterบุคคล ซึ่งสอดคล้องกับทฤษฎีดาร์วินของSurvival of the Fittest.
ดังนั้นจึงช่วยให้ evolving บุคคลที่ดีขึ้นหรือแนวทางแก้ไขในช่วงหลายชั่วอายุคนจนกว่าจะถึงเกณฑ์หยุด
อัลกอริทึมทางพันธุกรรมมีลักษณะสุ่มอย่างเพียงพอ แต่ทำงานได้ดีกว่าการค้นหาในพื้นที่แบบสุ่มมาก (ซึ่งเราแค่ลองใช้วิธีการแก้ปัญหาแบบสุ่มติดตามสิ่งที่ดีที่สุดจนถึงตอนนี้) เนื่องจากใช้ประโยชน์จากข้อมูลในอดีตเช่นกัน
วิธีใช้ GA สำหรับปัญหาการเพิ่มประสิทธิภาพ
การเพิ่มประสิทธิภาพเป็นการดำเนินการเพื่อให้การออกแบบสถานการณ์ทรัพยากรและระบบมีประสิทธิภาพมากที่สุด แผนภาพบล็อกต่อไปนี้แสดงกระบวนการเพิ่มประสิทธิภาพ -
ขั้นตอนของกลไก GA สำหรับกระบวนการเพิ่มประสิทธิภาพ
ต่อไปนี้เป็นลำดับขั้นตอนของกลไก GA เมื่อใช้สำหรับการเพิ่มประสิทธิภาพของปัญหา
ขั้นตอนที่ 1 - สร้างประชากรเริ่มต้นแบบสุ่ม
ขั้นตอนที่ 2 - เลือกโซลูชันเริ่มต้นที่มีค่าสมรรถภาพที่ดีที่สุด
ขั้นตอนที่ 3 - รวมโซลูชันที่เลือกใหม่โดยใช้ตัวดำเนินการการกลายพันธุ์และครอสโอเวอร์
ขั้นตอนที่ 4 - ใส่ลูกหลานเข้าไปในประชากร
ขั้นตอนที่ 5 - ตอนนี้หากตรงตามเงื่อนไขการหยุดให้ส่งคืนโซลูชันพร้อมค่าความฟิตที่ดีที่สุด จากนั้นไปที่ขั้นตอนที่ 2
การติดตั้งแพ็คเกจที่จำเป็น
สำหรับการแก้ปัญหาโดยใช้ Genetic Algorithms ใน Python เราจะใช้แพ็คเกจที่มีประสิทธิภาพสำหรับ GA ที่เรียกว่า DEAP. เป็นคลังกรอบการคำนวณเชิงวิวัฒนาการใหม่สำหรับการสร้างต้นแบบและการทดสอบความคิดอย่างรวดเร็ว เราสามารถติดตั้งแพ็คเกจนี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ใน command prompt -
pip install deap
หากคุณกำลังใช้ anaconda จากนั้นสามารถใช้คำสั่งต่อไปนี้เพื่อติดตั้ง deap -
conda install -c conda-forge deap
การนำโซลูชันไปใช้โดยใช้อัลกอริทึมทางพันธุกรรม
ส่วนนี้จะอธิบายถึงการนำโซลูชันไปใช้โดยใช้ Genetic Algorithms
การสร้างรูปแบบบิต
ตัวอย่างต่อไปนี้แสดงวิธีการสร้างสตริงบิตที่จะมี 15 สตริงโดยยึดตาม One Max ปัญหา.
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import random
from deap import base, creator, tools
กำหนดฟังก์ชันการประเมิน เป็นขั้นตอนแรกในการสร้างอัลกอริทึมทางพันธุกรรม
def eval_func(individual):
target_sum = 15
return len(individual) - abs(sum(individual) - target_sum),
ตอนนี้สร้างกล่องเครื่องมือด้วยพารามิเตอร์ที่ถูกต้อง -
def create_toolbox(num_bits):
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
เริ่มต้นกล่องเครื่องมือ
toolbox = base.Toolbox()
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.attr_bool, num_bits)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
ลงทะเบียนผู้ดำเนินการประเมิน -
toolbox.register("evaluate", eval_func)
ตอนนี้ลงทะเบียนตัวดำเนินการครอสโอเวอร์ -
toolbox.register("mate", tools.cxTwoPoint)
ลงทะเบียนตัวดำเนินการกลายพันธุ์ -
toolbox.register("mutate", tools.mutFlipBit, indpb = 0.05)
กำหนดผู้ดำเนินการผสมพันธุ์ -
toolbox.register("select", tools.selTournament, tournsize = 3)
return toolbox
if __name__ == "__main__":
num_bits = 45
toolbox = create_toolbox(num_bits)
random.seed(7)
population = toolbox.population(n = 500)
probab_crossing, probab_mutating = 0.5, 0.2
num_generations = 10
print('\nEvolution process starts')
ประเมินประชากรทั้งหมด -
fitnesses = list(map(toolbox.evaluate, population))
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
print('\nEvaluated', len(population), 'individuals')
สร้างและทำซ้ำหลายชั่วอายุคน -
for g in range(num_generations):
print("\n- Generation", g)
การเลือกบุคคลรุ่นต่อไป -
offspring = toolbox.select(population, len(population))
ตอนนี้โคลนบุคคลที่เลือก -
offspring = list(map(toolbox.clone, offspring))
ใช้ครอสโอเวอร์และการกลายพันธุ์กับลูกหลาน -
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < probab_crossing:
toolbox.mate(child1, child2)
ลบค่าสมรรถภาพของเด็ก
del child1.fitness.values
del child2.fitness.values
ตอนนี้ใช้การกลายพันธุ์ -
for mutant in offspring:
if random.random() < probab_mutating:
toolbox.mutate(mutant)
del mutant.fitness.values
ประเมินบุคคลที่มีสมรรถภาพไม่ถูกต้อง -
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitnesses = map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
print('Evaluated', len(invalid_ind), 'individuals')
ตอนนี้แทนที่ประชากรด้วยบุคคลรุ่นต่อไป -
population[:] = offspring
พิมพ์สถิติสำหรับคนรุ่นปัจจุบัน -
fits = [ind.fitness.values[0] for ind in population]
length = len(population)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
print('Min =', min(fits), ', Max =', max(fits))
print('Average =', round(mean, 2), ', Standard deviation =',
round(std, 2))
print("\n- Evolution ends")
พิมพ์ผลลัพธ์สุดท้าย -
best_ind = tools.selBest(population, 1)[0]
print('\nBest individual:\n', best_ind)
print('\nNumber of ones:', sum(best_ind))
Following would be the output:
Evolution process starts
Evaluated 500 individuals
- Generation 0
Evaluated 295 individuals
Min = 32.0 , Max = 45.0
Average = 40.29 , Standard deviation = 2.61
- Generation 1
Evaluated 292 individuals
Min = 34.0 , Max = 45.0
Average = 42.35 , Standard deviation = 1.91
- Generation 2
Evaluated 277 individuals
Min = 37.0 , Max = 45.0
Average = 43.39 , Standard deviation = 1.46
… … … …
- Generation 9
Evaluated 299 individuals
Min = 40.0 , Max = 45.0
Average = 44.12 , Standard deviation = 1.11
- Evolution ends
Best individual:
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1,
1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0,
1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1]
Number of ones: 15
ปัญหาการถดถอยสัญลักษณ์
เป็นปัญหาหนึ่งที่รู้จักกันดีในการเขียนโปรแกรมทางพันธุกรรม ปัญหาการถดถอยเชิงสัญลักษณ์ทั้งหมดใช้การกระจายข้อมูลโดยพลการและพยายามปรับให้พอดีกับข้อมูลที่ถูกต้องที่สุดด้วยสูตรสัญลักษณ์ โดยปกติการวัดเช่น RMSE (Root Mean Square Error) จะใช้ในการวัดสมรรถภาพของแต่ละบุคคล มันเป็นปัญหาการถอยหลังแบบคลาสสิกและที่นี่เรากำลังใช้สมการ5x3-6x2+8x=1. เราจำเป็นต้องทำตามขั้นตอนทั้งหมดตามตัวอย่างข้างต้น แต่ส่วนหลักคือการสร้างชุดดั้งเดิมเนื่องจากเป็นองค์ประกอบพื้นฐานสำหรับแต่ละบุคคลเพื่อให้การประเมินเริ่มต้นได้ ที่นี่เราจะใช้ชุดดั้งเดิมของคลาสสิก
รหัส Python ต่อไปนี้อธิบายรายละเอียดนี้ -
import operator
import math
import random
import numpy as np
from deap import algorithms, base, creator, tools, gp
def division_operator(numerator, denominator):
if denominator == 0:
return 1
return numerator / denominator
def eval_func(individual, points):
func = toolbox.compile(expr=individual)
return math.fsum(mse) / len(points),
def create_toolbox():
pset = gp.PrimitiveSet("MAIN", 1)
pset.addPrimitive(operator.add, 2)
pset.addPrimitive(operator.sub, 2)
pset.addPrimitive(operator.mul, 2)
pset.addPrimitive(division_operator, 2)
pset.addPrimitive(operator.neg, 1)
pset.addPrimitive(math.cos, 1)
pset.addPrimitive(math.sin, 1)
pset.addEphemeralConstant("rand101", lambda: random.randint(-1,1))
pset.renameArguments(ARG0 = 'x')
creator.create("FitnessMin", base.Fitness, weights = (-1.0,))
creator.create("Individual",gp.PrimitiveTree,fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)
toolbox.expr)
toolbox.register("population",tools.initRepeat,list, toolbox.individual)
toolbox.register("compile", gp.compile, pset = pset)
toolbox.register("evaluate", eval_func, points = [x/10. for x in range(-10,10)])
toolbox.register("select", tools.selTournament, tournsize = 3)
toolbox.register("mate", gp.cxOnePoint)
toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
toolbox.register("mutate", gp.mutUniform, expr = toolbox.expr_mut, pset = pset)
toolbox.decorate("mate", gp.staticLimit(key = operator.attrgetter("height"), max_value = 17))
toolbox.decorate("mutate", gp.staticLimit(key = operator.attrgetter("height"), max_value = 17))
return toolbox
if __name__ == "__main__":
random.seed(7)
toolbox = create_toolbox()
population = toolbox.population(n = 450)
hall_of_fame = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda x: x.fitness.values)
stats_size = tools.Statistics(len)
mstats = tools.MultiStatistics(fitness=stats_fit, size = stats_size)
mstats.register("avg", np.mean)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
probab_crossover = 0.4
probab_mutate = 0.2
number_gen = 10
population, log = algorithms.eaSimple(population, toolbox,
probab_crossover, probab_mutate, number_gen,
stats = mstats, halloffame = hall_of_fame, verbose = True)
โปรดทราบว่าขั้นตอนพื้นฐานทั้งหมดจะเหมือนกับที่ใช้ในขณะสร้างรูปแบบบิต โปรแกรมนี้จะให้ผลลัพธ์เป็น min, max, std (ค่าเบี่ยงเบนมาตรฐาน) หลังจาก 10 ชั่วอายุคน
การมองเห็นของคอมพิวเตอร์เกี่ยวข้องกับการสร้างแบบจำลองและการจำลองการมองเห็นของมนุษย์โดยใช้ซอฟต์แวร์คอมพิวเตอร์และฮาร์ดแวร์ ในบทนี้คุณจะได้เรียนรู้โดยละเอียดเกี่ยวกับเรื่องนี้
วิสัยทัศน์คอมพิวเตอร์
การมองเห็นด้วยคอมพิวเตอร์เป็นระเบียบวินัยที่ศึกษาวิธีสร้างใหม่ขัดขวางและทำความเข้าใจฉาก 3 มิติจากภาพ 2 มิติในแง่ของคุณสมบัติของโครงสร้างที่มีอยู่ในฉาก
ลำดับชั้นของวิสัยทัศน์คอมพิวเตอร์
การมองเห็นคอมพิวเตอร์แบ่งออกเป็นสามประเภทพื้นฐานดังต่อไปนี้ -
Low-level vision - ประกอบด้วยภาพกระบวนการสำหรับการแยกคุณลักษณะ
Intermediate-level vision - รวมถึงการจดจำวัตถุและการตีความฉาก 3 มิติ
High-level vision - รวมถึงคำอธิบายแนวความคิดของฉากเช่นกิจกรรมความตั้งใจและพฤติกรรม
Computer Vision Vs Image Processing
การประมวลผลภาพศึกษาภาพไปสู่การแปลงภาพ อินพุตและเอาต์พุตของการประมวลผลภาพมีทั้งรูปภาพ
การมองเห็นด้วยคอมพิวเตอร์คือการสร้างคำอธิบายที่ชัดเจนและมีความหมายของวัตถุทางกายภาพจากภาพของมัน ผลลัพธ์ของการมองเห็นด้วยคอมพิวเตอร์คือคำอธิบายหรือการตีความโครงสร้างในฉาก 3 มิติ
การใช้งาน
Computer Vision ค้นหาแอปพลิเคชันในช่องต่อไปนี้ -
Robotics
การแปลกำหนดตำแหน่งหุ่นยนต์โดยอัตโนมัติ
Navigation
หลีกเลี่ยงอุปสรรค
การประกอบ (การเจาะรูการเชื่อมการทาสี)
การจัดการ (เช่นหุ่นยนต์บังคับ PUMA)
Human Robot Interaction (HRI): หุ่นยนต์อัจฉริยะเพื่อโต้ตอบและให้บริการผู้คน
Medicine
การจำแนกประเภทและการตรวจหา (เช่นการจำแนกรอยโรคหรือเซลล์และการตรวจหาเนื้องอก)
การแบ่งส่วน 2D / 3D
การสร้างอวัยวะใหม่ของมนุษย์ 3 มิติ (MRI หรืออัลตราซาวนด์)
การผ่าตัดด้วยหุ่นยนต์นำทางด้วยสายตา
Security
- ไบโอเมตริกซ์ (ม่านตาพิมพ์ลายนิ้วมือจดจำใบหน้า)
- การเฝ้าระวัง - ตรวจจับกิจกรรมหรือพฤติกรรมที่น่าสงสัยบางอย่าง
Transportation
- รถยนต์ที่เป็นอิสระ
- ความปลอดภัยเช่นการตรวจสอบความระมัดระวังของผู้ขับขี่
Industrial Automation Application
- การตรวจสอบอุตสาหกรรม (การตรวจจับข้อบกพร่อง)
- Assembly
- การอ่านฉลากบาร์โค้ดและแพ็คเกจ
- การจัดเรียงวัตถุ
- ความเข้าใจเอกสาร (เช่น OCR)
การติดตั้งแพ็คเกจที่มีประโยชน์
สำหรับ Computer vision ด้วย Python คุณสามารถใช้ไลบรารียอดนิยมที่เรียกว่า OpenCV(วิสัยทัศน์คอมพิวเตอร์โอเพ่นซอร์ส) เป็นไลบรารีของฟังก์ชันการเขียนโปรแกรมที่มุ่งเป้าไปที่การมองเห็นของคอมพิวเตอร์แบบเรียลไทม์เป็นหลัก มันเขียนด้วยภาษา C ++ และอินเทอร์เฟซหลักอยู่ใน C ++ คุณสามารถติดตั้งแพ็คเกจนี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -
pip install opencv_python-X.X-cp36-cp36m-winX.whl
ในที่นี้ X แสดงถึงเวอร์ชันของ Python ที่ติดตั้งบนเครื่องของคุณเช่นเดียวกับ win32 หรือ 64 บิตที่คุณมี
หากคุณกำลังใช้ไฟล์ anaconda จากนั้นใช้คำสั่งต่อไปนี้เพื่อติดตั้ง OpenCV -
conda install -c conda-forge opencv
การอ่านการเขียนและการแสดงภาพ
แอปพลิเคชัน CV ส่วนใหญ่จำเป็นต้องรับภาพเป็นอินพุตและสร้างภาพเป็นเอาต์พุต ในส่วนนี้คุณจะได้เรียนรู้วิธีการอ่านและเขียนไฟล์ภาพด้วยความช่วยเหลือของฟังก์ชันต่างๆที่ OpenCV มีให้
ฟังก์ชัน OpenCV สำหรับการอ่านการแสดงการเขียนไฟล์ภาพ
OpenCV มีฟังก์ชันต่อไปนี้สำหรับวัตถุประสงค์นี้ -
imread() function- นี่คือฟังก์ชันสำหรับอ่านรูปภาพ OpenCV imread () รองรับรูปแบบภาพต่างๆเช่น PNG, JPEG, JPG, TIFF เป็นต้น
imshow() function- เป็นฟังก์ชันสำหรับแสดงภาพในหน้าต่าง หน้าต่างจะพอดีกับขนาดภาพโดยอัตโนมัติ OpenCV imshow () รองรับรูปแบบภาพต่างๆเช่น PNG, JPEG, JPG, TIFF เป็นต้น
imwrite() function- นี่คือฟังก์ชั่นสำหรับเขียนภาพ OpenCV imwrite () รองรับรูปแบบภาพต่างๆเช่น PNG, JPEG, JPG, TIFF เป็นต้น
ตัวอย่าง
ตัวอย่างนี้แสดงโค้ด Python สำหรับการอ่านรูปภาพในรูปแบบเดียวโดยแสดงในหน้าต่างและเขียนรูปภาพเดียวกันในรูปแบบอื่น พิจารณาขั้นตอนที่แสดงด้านล่าง -
นำเข้าแพ็คเกจ OpenCV ตามที่แสดง -
import cv2
ตอนนี้สำหรับการอ่านภาพใดภาพหนึ่งให้ใช้ฟังก์ชัน imread () -
image = cv2.imread('image_flower.jpg')
สำหรับการแสดงภาพให้ใช้ไฟล์ imshow()ฟังก์ชัน ชื่อของหน้าต่างที่คุณสามารถเห็นภาพได้คือimage_flower.
cv2.imshow('image_flower',image)
cv2.destroyAllwindows()
ตอนนี้เราสามารถเขียนภาพเดียวกันในรูปแบบอื่น ๆ พูด. png โดยใช้ฟังก์ชัน imwrite () -
cv2.imwrite('image_flower.png',image)
ผลลัพธ์ที่เป็นจริงหมายความว่าภาพถูกเขียนเป็นไฟล์. png ได้สำเร็จในโฟลเดอร์เดียวกัน
True
หมายเหตุ - ฟังก์ชัน destroyallWindows () เพียงแค่ทำลายหน้าต่างทั้งหมดที่เราสร้างขึ้น
การแปลงพื้นที่สี
ใน OpenCV ภาพจะไม่ถูกจัดเก็บโดยใช้สี RGB แบบเดิม แต่จะถูกจัดเก็บในลำดับย้อนกลับเช่นในลำดับ BGR ดังนั้นรหัสสีเริ่มต้นขณะอ่านภาพคือ BGR cvtColor() ฟังก์ชันการแปลงสีในการแปลงภาพจากรหัสสีหนึ่งไปเป็นรหัสสีอื่น ๆ
ตัวอย่าง
ลองพิจารณาตัวอย่างนี้เพื่อแปลงภาพจาก BGR เป็นโทนสีเทา
นำเข้าไฟล์ OpenCV แพคเกจตามที่แสดง -
import cv2
ตอนนี้สำหรับการอ่านภาพใดภาพหนึ่งให้ใช้ฟังก์ชัน imread () -
image = cv2.imread('image_flower.jpg')
ทีนี้ถ้าเราเห็นภาพนี้โดยใช้ไฟล์ imshow() จากนั้นเราจะเห็นว่าภาพนี้อยู่ใน BGR
cv2.imshow('BGR_Penguins',image)
ตอนนี้ใช้ cvtColor() เพื่อแปลงภาพนี้เป็นโทนสีเทา
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
cv2.imshow('gray_penguins',image)
การตรวจจับขอบ
มนุษย์หลังจากเห็นภาพร่างคร่าวๆแล้วสามารถจดจำวัตถุหลายประเภทและท่าทางของพวกมันได้อย่างง่ายดาย นั่นคือเหตุผลที่ขอบมีบทบาทสำคัญในชีวิตของมนุษย์เช่นเดียวกับการประยุกต์ใช้การมองเห็นด้วยคอมพิวเตอร์ OpenCV มีฟังก์ชันที่เรียกว่าง่ายและมีประโยชน์Canny()สำหรับตรวจจับขอบ
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงการระบุขอบที่ชัดเจน
นำเข้าแพ็กเกจ OpenCV ดังภาพ -
import cv2
import numpy as np
ตอนนี้สำหรับการอ่านภาพใดภาพหนึ่งให้ใช้ไฟล์ imread() ฟังก์ชัน
image = cv2.imread('Penguins.jpg')
ตอนนี้ใช้ไฟล์ Canny () ฟังก์ชันสำหรับตรวจจับขอบของภาพที่อ่านแล้ว
cv2.imwrite(‘edges_Penguins.jpg’,cv2.Canny(image,200,300))
ตอนนี้สำหรับการแสดงภาพที่มีขอบให้ใช้ฟังก์ชัน imshow ()
cv2.imshow(‘edges’, cv2.imread(‘‘edges_Penguins.jpg’))
โปรแกรม Python นี้จะสร้างภาพชื่อ edges_penguins.jpg ด้วยการตรวจจับขอบ
การตรวจจับใบหน้า
การตรวจจับใบหน้าเป็นหนึ่งในแอพพลิเคชั่นที่น่าสนใจของการมองเห็นด้วยคอมพิวเตอร์ซึ่งทำให้สมจริงและล้ำยุคยิ่งขึ้น OpenCV มีสิ่งอำนวยความสะดวกในตัวเพื่อทำการตรวจจับใบหน้า เราจะใช้ไฟล์Haar ลักษณนามน้ำตกสำหรับการตรวจจับใบหน้า
ข้อมูล Haar Cascade
เราต้องการข้อมูลเพื่อใช้ลักษณนาม Haar cascade คุณสามารถค้นหาข้อมูลนี้ได้ในแพ็คเกจ OpenCV ของเรา หลังจากติดตั้ง OpenCv แล้วคุณจะเห็นชื่อโฟลเดอร์haarcascades. จะมีไฟล์. xml สำหรับแอปพลิเคชันอื่น ตอนนี้คัดลอกทั้งหมดเพื่อการใช้งานที่แตกต่างกันแล้ววางในโฟลเดอร์ใหม่ภายใต้โครงการปัจจุบัน
Example
ต่อไปนี้เป็นรหัส Python โดยใช้ Haar Cascade เพื่อตรวจจับใบหน้าของ Amitabh Bachan ที่แสดงในภาพต่อไปนี้ -
นำเข้าไฟล์ OpenCV แพคเกจตามที่แสดง -
import cv2
import numpy as np
ตอนนี้ใช้ไฟล์ HaarCascadeClassifier สำหรับตรวจจับใบหน้า -
face_detection=
cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/
haarcascade_frontalface_default.xml')
ตอนนี้สำหรับการอ่านภาพใดภาพหนึ่งให้ใช้ไฟล์ imread() ฟังก์ชัน -
img = cv2.imread('AB.jpg')
ตอนนี้แปลงเป็นโทนสีเทาเพราะจะรับภาพสีเทา -
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ตอนนี้ใช้ face_detection.detectMultiScaleทำการตรวจจับใบหน้าจริง
faces = face_detection.detectMultiScale(gray, 1.3, 5)
ตอนนี้วาดสี่เหลี่ยมผืนผ้ารอบ ๆ ใบหน้าทั้งหมด -
for (x,y,w,h) in faces:
img = cv2.rectangle(img,(x,y),(x+w, y+h),(255,0,0),3)
cv2.imwrite('Face_AB.jpg',img)
โปรแกรม Python นี้จะสร้างภาพชื่อ Face_AB.jpg ด้วยการตรวจจับใบหน้าดังที่แสดง
การตรวจจับดวงตา
การตรวจจับดวงตาเป็นอีกหนึ่งแอพพลิเคชั่นที่น่าสนใจสำหรับการมองเห็นด้วยคอมพิวเตอร์ซึ่งทำให้สมจริงและล้ำยุค OpenCV มีสิ่งอำนวยความสะดวกในตัวเพื่อทำการตรวจจับดวงตา เราจะใช้ไฟล์Haar cascade ลักษณนามสำหรับการตรวจจับดวงตา
ตัวอย่าง
ตัวอย่างต่อไปนี้ให้รหัส Python โดยใช้ Haar Cascade เพื่อตรวจจับใบหน้าของ Amitabh Bachan ที่ให้ไว้ในภาพต่อไปนี้ -
นำเข้าแพ็กเกจ OpenCV ดังภาพ -
import cv2
import numpy as np
ตอนนี้ใช้ไฟล์ HaarCascadeClassifier สำหรับตรวจจับใบหน้า -
eye_cascade = cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/haarcascade_eye.xml')
ตอนนี้สำหรับการอ่านภาพใดภาพหนึ่งให้ใช้ไฟล์ imread() ฟังก์ชัน
img = cv2.imread('AB_Eye.jpg')
ตอนนี้แปลงเป็นโทนสีเทาเพราะจะรับภาพสีเทา -
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ตอนนี้ด้วยความช่วยเหลือของ eye_cascade.detectMultiScaleทำการตรวจจับใบหน้าจริง
eyes = eye_cascade.detectMultiScale(gray, 1.03, 5)
ตอนนี้วาดสี่เหลี่ยมผืนผ้ารอบ ๆ ใบหน้าทั้งหมด -
for (ex,ey,ew,eh) in eyes:
img = cv2.rectangle(img,(ex,ey),(ex+ew, ey+eh),(0,255,0),2)
cv2.imwrite('Eye_AB.jpg',img)
โปรแกรม Python นี้จะสร้างภาพชื่อ Eye_AB.jpg ด้วยการตรวจจับดวงตาดังภาพ -
โครงข่ายประสาทเทียม (ANN) เป็นระบบคอมพิวเตอร์ที่มีประสิทธิภาพซึ่งมีธีมหลักที่ยืมมาจากการเปรียบเทียบเครือข่ายประสาททางชีววิทยา โครงข่ายประสาทเทียมเป็นแบบจำลองประเภทหนึ่งสำหรับการเรียนรู้ของเครื่อง ในช่วงกลางทศวรรษที่ 1980 และต้นทศวรรษที่ 1990 ความก้าวหน้าทางสถาปัตยกรรมที่สำคัญเกิดขึ้นในโครงข่ายประสาทเทียม ในบทนี้คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับ Deep Learning ซึ่งเป็นแนวทางของ AI
การเรียนรู้เชิงลึกเกิดขึ้นจากการเติบโตของการคำนวณในช่วงทศวรรษที่ผ่านมาในฐานะคู่แข่งที่จริงจังในสาขานี้ ดังนั้นการเรียนรู้เชิงลึกจึงเป็นการเรียนรู้ของเครื่องโดยเฉพาะซึ่งอัลกอริทึมได้รับแรงบันดาลใจจากโครงสร้างและหน้าที่ของสมองมนุษย์
การเรียนรู้ของเครื่อง v / s การเรียนรู้เชิงลึก
การเรียนรู้เชิงลึกเป็นเทคนิคการเรียนรู้ของเครื่องที่ทรงพลังที่สุดในปัจจุบัน มันมีพลังมากเพราะพวกเขาเรียนรู้วิธีที่ดีที่สุดในการแสดงปัญหาในขณะที่เรียนรู้วิธีแก้ปัญหา การเปรียบเทียบการเรียนรู้เชิงลึกและการเรียนรู้ของเครื่องแสดงไว้ด้านล่าง -
การพึ่งพาข้อมูล
จุดแรกของความแตกต่างขึ้นอยู่กับประสิทธิภาพของ DL และ ML เมื่อขนาดของข้อมูลเพิ่มขึ้น เมื่อข้อมูลมีขนาดใหญ่อัลกอริทึมการเรียนรู้เชิงลึกจะทำงานได้ดีมาก
การพึ่งพาเครื่องจักร
อัลกอริธึมการเรียนรู้เชิงลึกจำเป็นต้องใช้เครื่องจักรระดับไฮเอนด์เพื่อให้ทำงานได้อย่างสมบูรณ์ ในทางกลับกันอัลกอริทึมการเรียนรู้ของเครื่องสามารถทำงานบนเครื่องระดับล่างได้เช่นกัน
คุณสมบัติการสกัด
อัลกอริธึมการเรียนรู้เชิงลึกสามารถดึงคุณลักษณะระดับสูงและพยายามเรียนรู้จากสิ่งเดียวกันได้เช่นกัน ในทางกลับกันผู้เชี่ยวชาญจะต้องระบุคุณลักษณะส่วนใหญ่ที่ดึงมาจากการเรียนรู้ของเครื่อง
เวลาดำเนินการ
เวลาดำเนินการขึ้นอยู่กับพารามิเตอร์จำนวนมากที่ใช้ในอัลกอริทึม การเรียนรู้เชิงลึกมีพารามิเตอร์มากกว่าอัลกอริทึมการเรียนรู้ของเครื่อง ดังนั้นเวลาดำเนินการของอัลกอริทึม DL โดยเฉพาะเวลาฝึกอบรมจึงมากกว่าอัลกอริทึม ML มาก แต่เวลาในการทดสอบอัลกอริทึม DL น้อยกว่าอัลกอริทึม ML
แนวทางในการแก้ปัญหา
การเรียนรู้เชิงลึกช่วยแก้ปัญหาแบบ end-to-end ในขณะที่การเรียนรู้ของเครื่องใช้วิธีการแก้ปัญหาแบบดั้งเดิมเช่นการแยกย่อยออกเป็นส่วน ๆ
Convolutional Neural Network (CNN)
โครงข่ายประสาทเทียมนั้นเหมือนกับโครงข่ายประสาททั่วไปเพราะประกอบด้วยเซลล์ประสาทที่มีน้ำหนักและอคติที่สามารถเรียนรู้ได้ โครงข่ายประสาทเทียมธรรมดาจะไม่สนใจโครงสร้างของข้อมูลอินพุตและข้อมูลทั้งหมดจะถูกแปลงเป็นอาร์เรย์ 1-D ก่อนที่จะป้อนเข้าในเครือข่าย กระบวนการนี้เหมาะกับข้อมูลทั่วไปอย่างไรก็ตามหากข้อมูลมีรูปภาพกระบวนการอาจยุ่งยาก
CNN แก้ปัญหานี้ได้อย่างง่ายดาย ต้องคำนึงถึงโครงสร้าง 2 มิติของภาพเมื่อประมวลผลซึ่งช่วยให้สามารถดึงคุณสมบัติเฉพาะของภาพออกมาได้ ด้วยวิธีนี้เป้าหมายหลักของ CNN คือการเปลี่ยนจากข้อมูลรูปภาพดิบในเลเยอร์อินพุตไปยังคลาสที่ถูกต้องในเลเยอร์เอาต์พุต ความแตกต่างเพียงอย่างเดียวระหว่าง NN ธรรมดาและ CNN คือในการจัดการข้อมูลอินพุตและในประเภทของเลเยอร์
ภาพรวมสถาปัตยกรรมของ CNN
ในทางสถาปัตยกรรมเครือข่ายประสาทเทียมทั่วไปได้รับอินพุตและแปลงผ่านชุดของเลเยอร์ที่ซ่อนอยู่ ทุกชั้นเชื่อมต่อกับชั้นอื่น ๆ ด้วยความช่วยเหลือของเซลล์ประสาท ข้อเสียเปรียบหลักของโครงข่ายประสาทเทียมทั่วไปคือไม่สามารถปรับขนาดได้ดีจนเต็มภาพ
สถาปัตยกรรมของ CNN มีเซลล์ประสาทเรียงกันเป็น 3 มิติเรียกว่าความกว้างความสูงและความลึก เซลล์ประสาทแต่ละเซลล์ในชั้นปัจจุบันเชื่อมต่อกับส่วนเล็ก ๆ ของเอาต์พุตจากชั้นก่อนหน้า คล้ายกับการซ้อนทับไฟล์×กรองภาพอินพุต มันใช้Mตัวกรองเพื่อให้แน่ใจว่าได้รับรายละเอียดทั้งหมด เหล่านี้M ฟิลเตอร์เป็นตัวแยกคุณสมบัติที่ดึงคุณสมบัติต่างๆเช่นขอบมุม ฯลฯ
เลเยอร์ที่ใช้สร้าง CNN
เลเยอร์ต่อไปนี้ใช้เพื่อสร้าง CNN -
Input Layer - ใช้ข้อมูลภาพดิบตามที่เป็นจริง
Convolutional Layer- เลเยอร์นี้เป็นส่วนประกอบหลักของ CNN ที่ทำหน้าที่คำนวณส่วนใหญ่ ชั้นนี้จะคำนวณการเปลี่ยนแปลงระหว่างเซลล์ประสาทและแพทช์ต่างๆในอินพุต
Rectified Linear Unit Layer- ใช้ฟังก์ชันการเปิดใช้งานกับเอาต์พุตของเลเยอร์ก่อนหน้า เพิ่มความไม่เป็นเชิงเส้นให้กับเครือข่ายเพื่อให้สามารถสรุปได้ดีกับฟังก์ชันประเภทใด ๆ
Pooling Layer- การรวมกลุ่มช่วยให้เราเก็บเฉพาะส่วนที่สำคัญเมื่อเราก้าวหน้าในเครือข่าย เลเยอร์พูลทำงานอย่างอิสระในทุกส่วนความลึกของอินพุตและปรับขนาดเชิงพื้นที่ ใช้ฟังก์ชัน MAX
Fully Connected layer/Output layer - เลเยอร์นี้คำนวณคะแนนผลลัพธ์ในชั้นสุดท้าย ผลลัพธ์ที่ได้มีขนาด×× โดยที่ L คือคลาสชุดข้อมูลการฝึกอบรมตัวเลข
การติดตั้งแพ็คเกจ Python ที่มีประโยชน์
คุณสามารถใช้ได้ Kerasซึ่งเป็น API เครือข่ายประสาทเทียมระดับสูงเขียนด้วย Python และสามารถทำงานบน TensorFlow, CNTK หรือ Theno เข้ากันได้กับ Python 2.7-3.6 คุณสามารถเรียนรู้เพิ่มเติมได้จากhttps://keras.io/.
ใช้คำสั่งต่อไปนี้เพื่อติดตั้ง keras -
pip install keras
บน conda คุณสามารถใช้คำสั่งต่อไปนี้ -
conda install –c conda-forge keras
การสร้าง Linear Regressor โดยใช้ ANN
ในส่วนนี้คุณจะได้เรียนรู้วิธีสร้างตัวถอยหลังเชิงเส้นโดยใช้โครงข่ายประสาทเทียม คุณสามารถใช้ได้KerasRegressorเพื่อให้บรรลุเป้าหมายนี้ ในตัวอย่างนี้เรากำลังใช้ชุดข้อมูลราคาบ้านของบอสตันที่มีตัวเลข 13 ตัวสำหรับคุณสมบัติในบอสตัน รหัส Python สำหรับสิ่งเดียวกันจะแสดงที่นี่ -
นำเข้าแพ็คเกจที่จำเป็นทั้งหมดตามที่แสดง -
import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
ตอนนี้โหลดชุดข้อมูลของเราซึ่งบันทึกไว้ในไดเร็กทอรีท้องถิ่น
dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values
ตอนนี้แบ่งข้อมูลออกเป็นตัวแปรอินพุตและเอาต์พุตเช่น X และ Y -
X = dataset[:,0:13]
Y = dataset[:,13]
เนื่องจากเราใช้โครงข่ายประสาทพื้นฐานกำหนดแบบจำลอง -
def baseline_model():
ตอนนี้สร้างแบบจำลองดังนี้ -
model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal',
activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))
จากนั้นรวบรวมแบบจำลอง -
model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor
ตอนนี้แก้ไขเมล็ดพันธุ์แบบสุ่มสำหรับการทำซ้ำดังนี้ -
seed = 7
numpy.random.seed(seed)
วัตถุ Keras wrapper สำหรับใช้ใน scikit-learn เรียกว่าเป็นตัวประมาณค่าการถดถอย KerasRegressor. ในส่วนนี้เราจะประเมินโมเดลนี้ด้วยชุดข้อมูลที่เป็นมาตรฐาน
estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))
ผลลัพธ์ของโค้ดที่แสดงด้านบนจะเป็นการประมาณประสิทธิภาพของโมเดลในปัญหาสำหรับข้อมูลที่มองไม่เห็น จะเป็นค่าความคลาดเคลื่อนกำลังสองเฉลี่ยรวมทั้งค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานในทั้ง 10 เท่าของการประเมินผลการตรวจสอบความถูกต้อง
Image Classifier: การประยุกต์ใช้ Deep Learning
Convolutional Neural Networks (CNNs) แก้ปัญหาการจำแนกประเภทรูปภาพนั่นคือคลาสที่อิมเมจอินพุตเป็นของ คุณสามารถใช้ Keras deep learning library โปรดทราบว่าเรากำลังใช้ชุดข้อมูลการฝึกและทดสอบภาพแมวและสุนัขจากลิงค์ต่อไปนี้https://www.kaggle.com/c/dogs-vs-cats/data.
นำเข้าไลบรารี Keras และแพ็คเกจที่สำคัญดังที่แสดง -
แพ็คเกจต่อไปนี้เรียกว่า sequential จะเริ่มต้นเครือข่ายประสาทเทียมเป็นเครือข่ายตามลำดับ
from keras.models import Sequential
แพ็คเกจต่อไปนี้เรียกว่า Conv2D ใช้ในการดำเนินการ Convolution ขั้นตอนแรกของ CNN
from keras.layers import Conv2D
แพ็คเกจต่อไปนี้เรียกว่า MaxPoling2D ใช้ในการดำเนินการรวมขั้นตอนที่สองของ CNN
from keras.layers import MaxPooling2D
แพ็คเกจต่อไปนี้เรียกว่า Flatten คือกระบวนการแปลงอาร์เรย์ 2 มิติที่เป็นผลลัพธ์ทั้งหมดให้เป็นเวกเตอร์เชิงเส้นที่ยาวต่อเนื่องกัน
from keras.layers import Flatten
แพ็คเกจต่อไปนี้เรียกว่า Dense ใช้เพื่อทำการเชื่อมต่อเครือข่ายประสาทเทียมขั้นตอนที่สี่ของ CNN
from keras.layers import Dense
ตอนนี้สร้างวัตถุของคลาสตามลำดับ
S_classifier = Sequential()
ตอนนี้ขั้นตอนต่อไปคือการเข้ารหัสส่วน Convolution
S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
ที่นี่ relu คือฟังก์ชัน rectifier
ตอนนี้ขั้นตอนต่อไปของ CNN คือการดำเนินการร่วมกันบนแผนที่คุณลักษณะที่เป็นผลลัพธ์หลังจากส่วนการแปลง
S-classifier.add(MaxPooling2D(pool_size = (2, 2)))
ตอนนี้แปลงภาพรวมทั้งหมดเป็นเวกเตอร์ต่อเนื่องโดยใช้การยกยอ -
S_classifier.add(Flatten())
จากนั้นสร้างเลเยอร์ที่เชื่อมต่ออย่างสมบูรณ์
S_classifier.add(Dense(units = 128, activation = 'relu'))
นี่คือจำนวนหน่วยที่ซ่อนอยู่ 128 หน่วย เป็นเรื่องธรรมดาที่จะกำหนดจำนวนหน่วยที่ซ่อนอยู่เป็นพลังของ 2
ตอนนี้เริ่มต้นชั้นเอาต์พุตดังนี้ -
S_classifier.add(Dense(units = 1, activation = 'sigmoid'))
ตอนนี้รวบรวม CNN เราได้สร้าง -
S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
ที่นี่พารามิเตอร์เครื่องมือเพิ่มประสิทธิภาพคือการเลือกอัลกอริทึมการสืบเชื้อสายสุ่มสุ่มพารามิเตอร์การสูญเสียคือการเลือกฟังก์ชันการสูญเสียและพารามิเตอร์เมตริกคือการเลือกเมตริกประสิทธิภาพ
ตอนนี้ทำการขยายภาพจากนั้นให้พอดีกับภาพกับโครงข่ายประสาทเทียม -
train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set =
train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size =
(64, 64),batch_size = 32,class_mode = 'binary')
test_set =
test_datagen.flow_from_directory('test_set',target_size =
(64, 64),batch_size = 32,class_mode = 'binary')
ตอนนี้ปรับข้อมูลให้พอดีกับแบบจำลองที่เราสร้างขึ้น -
classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs =
25,validation_data = test_set,validation_steps = 2000)
ที่นี่ steps_per_epoch มีจำนวนภาพการฝึกอบรม
ขณะนี้โมเดลได้รับการฝึกฝนแล้วเราสามารถใช้เพื่อการทำนายได้ดังนี้ -
from keras.preprocessing import image
test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg',
target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = classifier.predict(test_image)
training_set.class_indices
if result[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'