การเขียนไปป์ไลน์
การเรียนรู้ของคอมพิวเตอร์ แมชชีนเลิร์นนิ่ง ตอนที่ 4
สวัสดีครับ ในบทเรียนนี้เราจะมาทบทวนถึงสิ่งที่ได้เรียนรู้ไปแล้วในบทเรียนก่อนหน้านี้ ประการแรกคือเราจะเขียนโค้ดโปรแกรมบนพื้นฐานของไปป์ไลน์ สำหรับการเรียนรู้ของคอมพิวเตอร์แบบมีการสอน หรือ Suppervised learning
และจะแสดงให้เห็นว่าการแยกแยะด้วยหลายวิธี (Multiple Classifiers) สามารถจัดการกับปัญหาเดียวกันได้อย่างไร
จากนั้นเราจะมาสร้าง เครื่องมือการทำนายเล็กๆ สักอันหนึ่งกัน เพื่อให้เข้าใจถึงขั้นตอนวิธีหรือ อัลกอริธึมในการเรียนรู้บางสิ่งบางอย่างจากข้อมูลที่ใช้สอนคอมพิวเตอร์ เนื่องจากดูเหมือนเป็นการใช้เวทมนตร์ แต่ไม่ใช่
เพื่อความเข้าใจ เราลองมาพิจารณาตัวอย่างง่ายๆ กัน สมมติว่าเราต้องเขียนโปรแกรมเพื่อเป็นเครื่องมือในการแยกแยะอีเมล์ที่เป็นสแปม ออกจากอีเมล์ปกติ
ซึ่งมันเป็นเพียงฟังก์ชั่น หรือความสามารถในการเลเบล หรือระบุว่าอีเมล์ที่ได้รับเข้ามาแต่ละฉบับนั้น เป็นอีเมล์สแปม หรือเป็นอีเมล์ปกติ นั่นเอง
ซึ่งในขั้นตอนนี้สมมติว่าเราได้รวบรวมเซ็ตข้อมูลไว้เรียบร้อยแล้ว
และในขั้นตอนนี้เราพร้อมที่จะสอนคอมพิวเตอร์ให้เรียนรู้แล้ว หรือสอนให้กับโมเดล
แต่ก่อนที่เราจะทำการประมวลผลตามขั้นตอนของการทำแมชชีนเลิร์นนิ่ง มีคำถามอยู่ประการหนึ่งที่เราต้องตอบให้ได้ก่อน คำถามนั้นก็คือ ความแม่นยำในการแยกแยะอีเมล์ ที่คุณต้องการเป็นเท่าไร จากข้อมูลที่ใช้สอนคอมพิวเตอร์
สิ่งที่ดีที่สุดที่เราสามารถทำได้ คือเราต้องการยืนยันให้ได้ว่าโมเดลที่เราสร้างขึ้นนั้นสามารถทำงานได้เป็นอย่างดี ก่อนที่จะนำโมเดลที่เราพัฒนาขึ้นไปใช้งานจริง และแน่นอนเราสามารถทดลองโมเดลของเรา เพื่อยืนยันความถูกต้อง
วิธีการแรกคือเราต้องแบ่งเซ็ตข้อมูลที่มีอยู่ออกเป็นสองส่วน ซึ่งเราเรียกข้อมูลที่ถูกแบ่งออกเป็นสองส่วนนี้ว่า ข้อมูลสำหรับสอนคอมพิวเตอร์ (Training data) และข้อมูลที่ใช้ทดสอบ (Testing data) โดยเราจะใช้ข้อมูลสำหรับสอนคอมพิวเตอร์หรือสอนโมเดลของเรา และทดสอบความถูกต้องแม่นยำของความสามารถของโมเดลในการแยกแยะข้อมูลใหม่ที่คอมพิวเตอร์หรือโมเดลที่พัฒนาขึ้นไม่เคยรู้จักมาก่อน
สิ่งที่ได้กล่าวมานั้นเป็นรูปแบบในการทำแมชชีนเลิร์นนิ่งมาตรฐาน ถัดไปเราจะมาทดลองเขียนโค้ดโปรแกรม และศึกษาว่ามันทำงานอย่างไร
ก่อนอื่นเราต้องเริ่มต้นด้วยการนำเข้า เซ็ตข้อมูล จาก sklean ก่อน ดังนี้
ในบทเรียนนี้ เราจะใช้เซ็ตข้อมูล iris อีกครั้ง เนื่องจากเราได้ดาวน์โหลดมาใช้งานแล้ว จากตอนที่ 2 แต่สิ่งที่เรายังไม่ได้พบก็คือ การเรียนใช้ฟีทเจอร์หรือคุณสมบัติ x และเลเบล (label) y ซึ่งเป็นคำตอบที่ต้องการ
เพราะเหตุใดจึงใช้ x และ y
หากเราคิดถึงการแยกแยะ (เครื่องมือ/โปรแกรม เพื่อทำการแยกแยะ ข้อมูล) หรือคลาสสิฟายเออร์ (Classifier) ซึ่งมันก็คือฟังก์ชั่น หรือความสามารถในการทำงานอย่างใดอย่างหนึ่งนั่นเอง
ในมุมมองระดับสูง เรากำหนดให้ x เป็นอินพุทหรือข้อมูลนำเข้า และ y ก็คือเลเบลหรือผลลัพท์ ซึ่งได้อธิบายไปแล้วก่อนหน้า
หลังจากเราได้นำเข้าเซ็ตข้อมูล สิ่งแรกที่เราต้องทำก็คือ แบ่งเซ็ตข้อมูลออกเป็นสองส่วน คือ ข้อมูลสำหรับสอน (Train) และข้อมูลสำหรับทดสอบ (Test) โดยสามารถนำเข้าได้จากเครื่องมือที่มีไว้ให้ และมีกฏไวยกรณ์ที่ชัดเจน
ก่อนอื่นเราลองมาพิจารณา ค่า x และ y ที่กำหนดขึ้นไว้ในบรรทัดที่ 4 และ 5
หรือฟีทเจอร์ (คุณสมบัติของข้อมูล) และ เลเบล (ผลลัพท์) และการแบ่งส่วนเซ็ตข้อมูล ออกเป็นสองเซ็ต
กำหนดให้ X_train และ y_train คือฟีทเจอร์และเลเบล ตามลำดับ สำหรับเซ็ตข้อมูลเพื่อใช้สอน
และสำหรับ X_test และ y_test คือฟีทเจอร์และเบล สำหรับเซ็ตข้อมูลที่ใช้ในการทดสอบ
ดังที่ได้กล่าวไปแล้ว เราต้องการข้อมูลจำนวนครึ่งหนึ่งของข้อมูลทั้งหมดเพื่อใช้ในการทดสอบ
เมื่อเรามีข้อมุลทั้งสิ้นจำนวน 150 ตัวอย่าง ในเซ็ตข้อมูล Iris ดังนั้นเราจึงแบ่งข้อมูลเพื่อใช้สอนระบบมาไว้เป็นจำนวน 75 รายการ และที่เหลืออีก 75 รายการไว้ใช้สำหรับการทดสอบความถูกต้องแม่นยำของโมเดลที่เราพัฒนาขึ้น
ถัดไปเราจะมาทำความเข้าใจกับเครื่องมือในการแยกแยะ หรือคลาสสิฟายเออร์ เราใช้ประเภทที่แตกต่างกันสองประเภท เพื่อแสดงให้เห็นถึงความสามารถในการทำงานเดียวกันเพื่อบรรลุเป้าหมายเดียวกัน
เริ่มต้นด้วยต้นไม้ตัดสินใจ (decision tree) ที่เราได้รู้จักกันไปในบทก่อนหน้านี้แล้ว ซึ่งเราสามารถเขียนโปรแกรมด้วยคำสั่งจำนวนเพียงสองบรรทัด ก็คือ ข้อกำหนดของการแยกแยะ
ถัดไปเราจะทำการสอนเครื่องมือในการแยกแยะหรือคลาสสิฟายเออร์ ด้วยข้อมูลสำหรับสอน เมื่อเสร็จสิ้นจากขั้นตอนนี้แล้ว คลาสสิฟายเออร์ก็พร้อมที่จะนำไปใช้ในการแยกแยะข้อมูล
ในบรรทัดถัดไป เราเรียกว่า predict method หรือเมทธอดที่ทำหน้าทำนายผล โดยเราใช้มันเพื่อแยะแยะข้อมูลแต่ละรายการที่ใช้ในการทดสอบ
จากนั้นเราจะมาดูว่าความถูกต้องในการแยกแยะข้อมูลแต่ละรายการในเซ็ตข้อมูลนั้น แม่นยำเพียงไร
หากมองย้อนไปที่โค้ดโปรแกรมบรรทัดก่อนหน้าซึ่งเราได้กำหนดเลเบลที่ถูกต้องไว้ให้กับข้อมูลที่ใช้ในการทดสอบแล้ว ก็คือ X_test และ y_test ในการคำนวณผลความถูกต้องแม่นยำนั้นเราจะทำการเปรียบเทียบผลการทำนาย กับเลเบล ซึ่งเป็นคำตอบที่ถูกต้อง ว่าผลการทำนายกับผลลัพท์ที่ถูกต้องจากเลเบล นั้นมีมากน้อยเพียงไร และทำการแจกแจงคะแนนเพื่อให้สามารถเข้าใจได้ง่ายขึ้น ทั้งนี้ scikit-learn ได้จัดเตรียมไลบรารี่ไว้ให้เราสามารถนำมาใช้ได้ทันที ดังนี้
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, predictions))
จากนั้นลองทดสอบให้โปรแกรมทำการประมวลผล จะได้ผลลัพท์ดังนี้
ผลลัพท์ที่ได้คือ 0.9733333333 ซึ่งมีค่าเข้าใกล้ 1 หากคิดเป็นร้อยละจะเท่ากับ 97.3333 เปอร์เซ็นต์ ซึ่งในเรื่องของการยอมรับความแม่นยำแล้ว ต้องพิจาณาขึ้นอยู่กับกรณีหรือข้อมูลที่เราสนใจ บางกรณีต้องการความแม่นยำถูกต้อง 100 เปอร์เซ็นต์ บางกรณีอาจยอมให้ผิดพลาดได้บ้างโดยกำหนดความผิดพลาดไว้ไม่เกินร้อยละ 5 นั่นหมายถึงผลการทำนายต้องถูกต้องมากกว่าร้อยละ 95 ดังเช่นกรณีนี้ ได้ความถูกต้องถึง 97.33 ก็จะยอมรับโมเดลนี้และสามารถนำไปใช้จริงได้ นอกจากนี้ในบางกรณีอาจกำหนดความผิดพลาดไว้ได้ไม่เกินร้อยละ 10 หรือ 20 ก็ได้ขึ้นอยู่กับเซ็ตข้อมูลและเป้าหมายในการทดลองนั้น
ทั้งนี้หากเราทดลองโดยใช้เครื่องคอมพิวเตอร์ในการประมวลผลต่างเครื่องกัน อาจได้ผลลัพท์ตัวเลขที่แตกต่างกันไปบ้างเล็กน้อย ขึ้นอยู่กับการสุ่มรายการข้อมูลที่ใช้ในการสอนกับการทดสอบ ที่แตกต่างกัน
นอกจากนี้ เรายังสามารถเปลี่ยนอัลกอริธึมในการแยกแยะ ในบรรทัดที่ 11 และ 12 ได้
โดยเราอาจเปลี่ยนอัลกอริธึมจาก Decision Tree หรือต้นไม้ตัดสินใจ ไปเป็น K Nearest Neighbor (วัดค่าความใกล้เคียงกับเป้าหมาย K) จากนั้นให้ทดลองสั่งให้โปรแกรมทำการประมวลผล และนำผลลัพท์ที่ได้มาเปรียบเทียบกับการแยกแยะด้วยต้นไม้ตัดสินใจ ที่ได้ดำเนินการไว้แล้วก่อนหน้า ก็จะทำให้เราสามารถระบุได้ว่าโมเดลในการแยกแยะแบบใดเหมาะกับเซ็ตข้อมูล และเป้าหมายในการทำแมชชีนเลิร์นนิ่งครั้งนี้
จากผลลัพท์ที่ได้ พบว่าในการสอนและทดสอบ เซ็ตข้อมูลนี้เมื่อใช้ขั้นตอนวิธีหรืออัลกอริธึมในการแยกแยะที่แตกต่างกัน จะได้ผลลัพท์ความแม่นยำในการทำนายที่แตกต่างกันด้วย โดยเมื่อใช้ขั้นตอวิธีแบบ ต้นไม้ตัดสินใจ จะได้ความแม่นยำที่ 97.33 เปอร์เซ็นต์ แต่เมื่อเปลี่ยนมาใช้ ขั้นตอนวิธิีแบบ K Nearest Neighbor จะได้ค่าความแม่นยำในการทำนายที่ 96.00 เปอร์เซ็นต์ ซึ่งต่ำกว่า เราจึงสรุปได้ว่าควรใช้ขั้นตอนวิธีแบบต้นไม้ตัดสินใจกับเซ็ตข้อมูลนี้ จะเหมาะสมมากกว่า อย่างไรก็ตามยังมีขั้นตอนวิธีอีกหลากหลายวิธีในการทำแมชชีนเลิร์นนิ่งให้เราเลือกใช้ ซึ่งแน่นอนเราต้องมาเรียนรู้รายละเอียดของขั้นตอนวิธีหรืออัลกอริธึม ที่แตกต่างกันเหล่านั้น เพื่อให้สามารถเลือกใช้งานได้อย่างเหมาะสมต่อไป
ถัดไปเราจะกลับมาทำความเข้าใจกับ การเรียนรู้จากข้อมูล ให้เข้าใจมากขึ้น ก่อนหน้านี้เราได้กล่าวถึง ฟีทเจอร์ X และ เลเบล y ไว้ว่า x คืออินพุทหรือค่าที่นำเข้าสู่โปรแกรมเพื่อประมวลผล และ y คือผลลัพท์ที่ได้
โดยที่ def classify() ก็คือฟังก์ชั่น ซึ่งเราทราบกันดีว่าใน การเรียนรู้ของคอมพิวเตอร์แบบมีการสอน หรือ Suppervised learning นั้น เราไม่ต้องการที่จะเขียนโปรแกรมเพื่อทำการแยกแยะเอง แต่เราต้องการขั้นตอนวิธีหรืออัลกอริธึม เพื่อทำการเรียนรู้จากข้อมูลที่ใช้สอน (training data) นั่นหมายถึงการเรียนรู้ฟังก์ชั่น ใช่หรือไม่
ฟังก์ชั่นก็คือการจับคุ่ระหว่างอินพุทกับ เอ้าท์พุท หรือข้อมูลนำเข้ากับผลลัพท์ นั่นเอง
จากภาพแสดงแกน x และ y เรามาพิจารณาฟังก์ชั่นที่เราเคยเห็นกันมาก่อนแล้ว กำหนดให้
y = mx + b ซึ่งเป็นสมการเส้นตรง โดยมีพารามิเตอร์อยู่สองตัวคือ
m เป็นพารามิเตอร์กำหนดค่าความชัน โดยที่
b เป็นพารามิเตอร์กำหนดจุดตัดของเส้นกับแกน y
เราสามารถพล็อตเส้นที่เกิดจากฟังก์ชั่นนี้โดยเปลี่ยแปลงค่าของ x และ y
ในการสอนคอมพิวเตอร์แบบ Supervised learning นั้น ฟังก์ชั่นสำหรับแยกแยะ จำเป็นต้องมีพารามิเตอร์เช่นเดียวกัน โดยที่ อินพุท x คือฟีทเจอร์หรือคุณสมบัติของข้อมูลตัวอย่างที่ใช้สอนคอมพิวเตอร์ในการแยกแยะ
และเอ้าพุท y คือเลเบลหรือผลลัพท์ที่ต้องการ เช่น อีเมล์ฉบับนั้นเป็นสแปม หรือไม่เป็นสแปม หรือ ดอกไม้นั้นเป็นดอกไม้ประเภทอะไร
หากเราลองพิจารณาโครงสร้างของฟังก์ชั่น ว่าคล้ายคลึงกับอะไร
นั่นคือส่วนที่เราต้องเขียนโปรแกรมเพื่อให้สามารถทำงานได้ตามขั้นตอนวิธีหรืออัลกอริธึมที่เราต้องการนั่นเอง กล่าวคือให้โปรแกรมรู้จักการเรียนรู้ และสิ่งที่เราต้องทำความเข้าใจเพิ่มขึ้นคือ เราจะไม่เริ่มต้นจากการมุ่งเป้าไปที่ฟังก์ชั่นจะต้องมีหน้าตาหรือโครงร่างอย่างไร โดยเราจะมองว่าฟังก์ชั่นนั้นยังกลวงๆ อยู่ แต่เราจะเริ่มต้นด้วย โมเดล หรือรูปแบบ โดยเราอาจมองว่าโมเดลคือ เครื่องมือต้นแบบ หรือกฏเกณฑ์ ที่กำหนดโครงสร้างของฟังก์ชั่นที่เราต้องการ
โดยทั่วไปแล้ว โมเดลจะมีพารามิเตอร์อยู่หลายตัว ที่เราสามารถปรับแต่งพารามิเตอร์เหล่านั้นได้จากข้อมูลที่ใช้สอน (training data)
เราลองมาดูตัวอย่างเพื่อทำความเข้าใจกับกระบวนการทำงานการปรับแต่งพารามิเตอร์จากข้อมูลสอน กัน
จากเซ็ตข้อมูลตัวอย่าง ซึ่งเราต้องการแยกแยะประเภทของข้อมูลแต่ละรายการเหล่านั้น
สมมติว่าเราสนใจในการแยกแยะ ระหว่าง จุดสีแดงกับจุดสีเขียว เราจะตีเส้นกราฟ เพื่อแบ่งข้อมูลจุดแดงกับจุดเขียวออกจากกันได้อย่างไร ในการแบ่งข้อมูลนี้ เรามีเพียงฟีทเจอร์หรือคุณสมบัติ 2 ประการเท่านั้น ที่สามารถใช้ได้ ก็คือค่าของแกน x และค่าของแกน y นั่นเอง
หากเราต้องการแยกแยะหรือบอกให้ได้ว่า จุดสีเทา ที่เกิดขึ้นใหม่นั้น ควรเป็นสีแดงหรือสีเขียว (แน่นอนหากมนษย์มองด้วยตาเปล่าเราก็จะสามารถบอกได้ในทันทีว่าควรเป็นสีเขียว เนื่องจากตำแหน่งที่จุดสีเทาอยู่นั้น อยู่ในกลุ่มเดียวกับสีเขียว แล้วถ้าเป็นคอมพิวเตอร์จะต้องมีกระบวนการคิดอย่างไร)
เราต้องการฟังก์ชั่น เพื่อทำหน้าที่นี้ เนื่องจากจุดสีเทาที่เกิดขึ้นใหม่ คอมพิวเตอร์ไม่รู็จักมาก่อน การจะบอกว่ามันควรจะเป็นสีเขียวหรือสีแดงจึงเป็นหน้าที่ของฟังก์ชั่น
ในความเป็นจริงเราอาจมีข้อมูลจำนวนมากที่ต้องแยกแยะ ดังเช่นจุดเขียวอ่อน และแดงอ่อน ซึ่งเป็นจุดหรือข้อมูลที่ไม่อยู่ในชุดข้อมูลที่เราใช้สอนคอมพิวเตอร์ ดังนั้นคอมพิวเตอร์โดยเครื่องมือในการแยกแยะหรือคลาสสิฟายเออร์ ยังไม่เคยเห็นหรือรู้จักข้อมูลเขียวอ่อนและแดงอ่อนเหล่านี้มาก่อน แล้วจะทำนายว่าข้อมูลเหล่านี้ควรเป็นสีแดงหรือเขียวได้อย่างไร
เราลองจินตนาการว่า หากเราสามารถขีดเส้นแบ่งข้อมูลทั้งสองส่วนออกจากกัน เราก็จะสามารถบอกได้ว่าข้อมูลที่อยู่ฝั่งซ้ายของเส้นควรเป็นสีเขียว และข้อมูลที่อยู่ฝั่งขวาของเส้นควรเป็นสีแดง ซึ่งเส้นแบ่งนี้เป็นเส้นที่สามารถทำหน้าที่แยกแยะได้นั่นเอง
แน่นอนว่าแล้วเราจะเขียนเส้นแบ่งที่ทำหน้าที่แยกแยะได้นี้ อย่างไร
วิธีการหนึ่งที่เราสามารถใช้ได้คือการใช้ข้อมูลสอน ในการปรับแต่งพารามิเตอร์ของเส้นแยกแยะนี้ หรือโมเดลนี้นั่นเอง
ซึ่งโมเดลที่เราเลือกใช้นี้เป็นโมเดลเส้นตรงอย่างง่าย
จากโมเดลเส้นตรงนี้ กำหนดให้มี 2 พารามิเตอร์ ซึ่งเราสามารถปรับแต่งได้คือ m และ b ด้วยการปรับแต่งค่าทั้งสอง เราก็จะสามารถปรับเปลี่ยน มุมเอียง และตำแหน่งของเส้นตรงนี้ได้
อย่างไรก็ตาม เราจะเรียนรู้เพื่อสามารถกำหนดเส้นตรงที่มีมุมเอียงและตำแหน่งได้อย่างถูกต้อง หรือสามารถทำหน้าที่แยกแยะได้อย่างถูกต้องได้อย่างไร
วิธีการหนึ่งที่เราสามารถเรียนรู้ได้คือ เราสามารถปรับแต่งเส้นตรงนี้ ได้จากการเรียนรู้ด้วยข้อมูลที่ใช้สอนคอมพิวเตอร์
ตัวอย่างเช่น เราจะเริ่มต้นด้วยการสุ่มเส้นตรงขึ้นมาหนึ่งเส้นก่อน และทำการแยกแยะตัวอย่างในเซ็ตข้อมูล รายการแรก
หากเส้นตรงที่เราสุ่มขึ้นมานั้น สามารถแยกแยะข้อมูลรายการแรกนั้นได้อย่างถูกต้อง ก็ไม่จำเป็นต้องปรับแต่งเส้นตรงนั้น
จากนั้นให้ทำเช่นนี้กับข้อมูลรายการถัดไป
แน่นอนหากเส้นตรงที่เราสุ่มขึ้นมานั้น ไม่สามารถแยกแยะข้อมูลลำดับที่สองได้อย่างถูกต้อง โดยดูจากเลเบลของข้อมูลนั้น ก็จำเป็นต้องปรับแต่งเส้นตรงเพื่อให้สามารถทำหน้าที่แยกแยะข้อมูลทั้งสองได้อย่างถูกต้อง
ด้วยการปรับแต่งค่าพารามิเตอร์ ทำให้ตำแหน่งของเส้นเลื่อนขึ้นบนไป และสามารถทำหน้าที่แยกแยะข้อมูลทั้งสองได้อย่างถูกต้อง
ดังนั้นด้วยวิธีการ ใช้ข้อมูลสอนให้กับคอมพิวเตอร์เรียนรู้ ในการปรับแต่งโมเดล จึงเป็นวิธีการที่เหมาะสมวิธีหนึ่ง
ต่อไปเราลองมาเรียนรู้เครื่องมือเฉพาะเครื่องมือหนึ่ง เรียกว่า เทนเซอร์โฟลว เพลย์กราวด์ (Tensorflow / playground) หรือสนามทดลองของเทนเซอร์โฟลว จากตัวอย่างนี้เป็นการทดลองด้วย เครือข่ายประสาทเทียม หรือนิวรอนเน็ตเวิร์ค (Neuron Network) ที่เราสามารถทดลองงานของเราบนเว็บเบราเซอร์ได้
หากเราได้ทดลองใช้งาน จะเห็นได้ว่าเป็นเครื่องมือที่น่าตื่นเต้นมาก
ในสนามทดลองนี้ มีเซ็ตข้อมูลให้เราทดลองใช้อย่างหลากหลาย ลองดูตัวอย่างง่ายๆ เช่น เราสามารถใช้เส้นตรงในการแยกแยะข้อมูล
ในขณะที่เซ็ตข้อมูล บางเซ็ตมีความสลับซับซ้อนมาก เราสามารถทดลองปรับแต่งโมเดลนิวรอนเน็ตเวิร์คให้สามารถแยกแยะข้อมูลในเซ็ตที่มีความสลับซับซ้อนได้
หลังจากเราได้ทดลองแล้ว จะพบว่านิวรอนเน็ตเวิร์คเป็นโมเดลที่สามารถทำหน้าที่แยกแยะข้อมูลที่มีความสลับซับซ้อนได้เป็นอย่างดี แตกต่างจากฟังก์ชั่นเส้นตรง หรือวิธีการของต้นไม้ตัดสินใจ
แต่ในหลักการพื้นฐานแล้ว มีแนวคิดเดียวกัน
หลังจากเราได้เรียนรู้ในบทเรียนนี้แล้ว คงสามารถตอบได้ว่าการทำ ไปป์ไลน์คืออะไร และมีรายละเอียดและวิธีทำอย่างไร ขอบคุณครับ แล้วพบกันใหม่ในบทเรียนถัดไป
โดย ผศ. ณัฏฐ์ โอธนาทรัพย์
สาขาวิชาวิศวกรรมคอมพิวเตอร์ คณะวิศวกรรมศาสตร์ มหาวิทยาลัยเอเชียอาคเนย์
By Asst., Prof. Nuth OTANASAP
Department of Computer Engineering, Faculty of Engineering,
Southeast Asia University, Bangkok 10160 THA
ไม่มีความคิดเห็น:
แสดงความคิดเห็น