SW list after install OS

กระทู้นี้ผมจะบันทึกโปรแกรมที่จำเป็นหลังจากการลงระบบปฏิบัติการเสร็จ

  • Google Chrome หรือ Mozilla Firefox ก็ได้
  • แอนตี้ไวรัส Avast ตัวนี้ใช้ฟรีครับ
  • 7zip ตัวนี้ใช้ฟรีครับ เพราะว่า winzip กับ winRaR ต้องเสียเงิน
  • Adobe Acrobat Reader ใช้งานเอกสารพวก pdf
  • VLC โปรแกรมใช้ดูหนังฟังเพลงดูได้ครอบจักรวาล
  • utorrent ใช้โหลดบิท
  • Steam(,Origin,Uplay) โปรแกรมแพลทฟอร์มสำหรับเล่นเกม มีเกมฟรีมากมาย เช่น Dota2, Counter Strike
  • LibreOffice โปรแกรมจัดการเอกสารใช้แทนพวก Microsoft Office ครับ
  • Gimp โปรแกรมตัดต่อรูปภาพครับใช้แทน photoshop ได้
  • OneDrive/Google Drive/Dropbox เลือกสักตัวครับเป็นไดร์ฟออนไลน์ ใช้สำหรับแบ็กอัพข้อมูลก็ได้ครับ
  • Wechat/Skype/QQ/Line ใช้คุยกับเพื่อน

Additional Lists รายการเสริม งานเฉพาะทาง

  • Putty/WinSCP ใช้สำหรับรีโมทคอนโทรลเข้าเซิฟเวอร์ที่เป็นพวกลินุกซ์
  • FileZilla Client ใช้สำหรับอัพโหลด ดาวโหลดข้อมูล ผ่าน FTP server
  • KeePass 2 ใช้สำหรับจัดการพาสเวิร์ด เจนพาสเวิร์ด รีไดเรคไปหน้าลอกอิน
  • Discord ใช้คุยกับเพื่อนตอนเล่นเกม
  • CCleaner ใช้ลบไฟล์ขยะในเครื่อง จัดการรีจิสทรี (Trial)
  • Recuva โปรแกรมกู้ข้อมูล เผื่อเผลอลบโดยไม่ตั้งใจกู้คืนได้ครับ
  • OpenHardwareMonitor ใช้แสดงฐานะต่างๆของเครื่อง CPU RAM VGA แสดงเป็นกราฟ ได้
  • CPUID CPU-Z ใช้ตรวจสอบรายละเอียด CPU RAM และ Benchmark เทียบกับ CPU อื่นๆ
  • Internet Download Manager เร่งสปีดการดาวโหลด กดหยุดแล้วดาวโหลดต่อได้ ดาวโหลดคลิปบนยูทูป
  • Evernote/OneNote จดโน้ต จัดการโน้ต

Tips

  • Window 10 ไม่ต้องลงวินโดว์ใหม่ สามารถสั่งกด Reset ได้เลย
  • เมื่อลงวินโดว์เสร็จ ปรับวันที่ ลงภาษาไทย ลงไดร์ฟเวอร์เสร็จ ลงซอฟท์แวร์เสร็จให้สร้างจุด Restore point เพื่อเกิดปัญหาจะได้ roll back มาที่จุดนี้ได้

Load tweet with TwitterAPI with Python

ไลบรารี่ TwitterAPI เป็นไลบรารี่สำหรับติดต่อกับ Twitter Rest API และ Twitter Stream API ด้วยภาษา Python

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

ติดตั้ง ไลบรารี่ TwitterAPI ผ่านทางคอมมานด์ไลน์ด้วยคำสั่ง  (แต่เนื่องจากต้องใช้ไลบรารี่ requests เลยพ่วงติดตั้งควบคู่กันไปด้วย)

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

จากนั้นเข้าไปที่เว็บ https://apps.twitter.com/ กด Create New APP ใส่รายละเอียด APP และกดสร้าง เราจะได้ คีย์อยู่สี่ชุดใช้ใส่ลงไปในโค้ด คือ consumer_key,consumer_secret,access_token_key,access_token_secret

เราจะเรียกฟังก์ชั่น TwitterRestPager โดยคิวรี่ข้อมูลผ่าน search/tweets มีรายละเอียดการเขียนคิวรี่ตามลิงค์นี้ ตามโค้ดด้านบน คิวรี่คือหาทวีตทั้งหมดที่มี #iphoneX ปรากฏอยู่โดยดึงมาทีละ 100 เรคคอร์ด

จากนั้นทำการเปิดไฟล์ tweet.txt เพื่อใช้เก็บทวีต

ฟังก์ชั่น BMP ใช้ในการแก้ไขบั๊กในกรณีเจอตัวอักษรที่ไม่สามารถแสดงบน console ได้ ให้แสดงเครื่องหมาย ? แทน

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

ตัวอย่างผลลัพธ์ที่แสดงผ่านคอนโซล

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

 

 

 

Cross Validation with K-fold

ปรกติชุดข้อมูลจะถูกแบ่งเป็นสองส่วน คือส่วนที่ใช้สำหรับเทรนโมเดล และส่วนที่เทสโมเดล เช่นแบ่งข้อมูลเป็นส่วนเทรนโมเดลสัก 60% และสำหรับเทสโมเดลอีก 40%

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

การแก้ปัญหา Overfitting ที่มักเห็นได้บ่อยๆคือการทำ K-fold Cross Validation โดยเราจะนำส่วนข้อมูลที่เป็นเทสคงไว้ และจะสนใจเฉพาะส่วนข้อมูลที่ใช้เทรนมาแบ่งเป็นสองส่วน คือส่วนที่ใช้เทรน(Training Folds) และอีกส่วนคือส่วนที่ใช้ในการทำ Validate (Test folds) โดยทำแบบนี้เรื่อยๆจำนวน K รอบโดยมีการผลัดเปลี่ยนกันระหว่างส่วนที่ใช้เทรนนิ่ง(K-1 ชุด)และส่วนที่ใช้ในการ Validation(1 ชุด) ในแต่ละรอบให้วัดค่าความแม่นยำและประสิทธิภาพออกมา(หรือใช้ค่า error ก็ได้) เมื่อทำครบ K รอบให้หาค่าเฉลี่ยความแม่นยำและประสิทธิภาพ(หรือใช้ค่า error ก็ได้)ของทุกรอบเป็นคะแนนแทนการวัดแบบเดิม

Image from https://sebastianraschka.com/faq/docs/evaluate-a-model.html

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

โค้ดด้านล่างจะเป็นการทำ K-fold Cross Validation ด้วย python โดยใช้ library scikit-learn และใช้ดาต้าเซ็ทที่ชื่อว่า Iris เป็นพันธุ์ดอกไม้ โดยมีการวัดกลีบเลี้ยง กลีบเลี้ยงสั้นยาวจะสามารถใช้ระบุสายพันธุ์ได้

เราจะแบ่งเป็นข้อมูลส่วนเทรน 60% และส่วนที่ใช้ในการเทส 40% โดยใช้ ฟังก์ชั่น train_test_split ในการแบ่งข้อมูล จากนั้นทำการเทรนโดยใช้ support vector machine ได้ค่าความแม่นยำและประสิทธิภาพราวๆ 0.96(ได้จากการวัดแบบ F-Score) ซึ่งคะแนนตรงนี้อาจจะไม่ใช่ค่าที่ไว้ใจได้มากนั้นเพราะอาจเกิด overfitting ได้เนื่องจากเราสามารถปรับแต่งพารามิเตอร์ C ได้ซึ่งต้องปรับแบบแมนนวล ปรับให้ผลลัพธ์คะแนนออกมาดีที่สุด

เพื่อหลีกเลี่ยง Overfitting เราจะทำการ แบ่งข้อมูล เพื่อเทรน และหาค่าคะแนน ห้ารอบติดต่อกัน (5-fold cross validation) โดยผลัดกันเป็นส่วนเทรนและส่วนวาลิเดทตามรูปภาพและโค้ดด้านล่าง

YWgro

เมื่อปรับแต่งพารามิเตอร์เสร็จแล้ว จากนั้นรัน k-fold cv เพื่อดูค่าคะแนนเฉลี่ย ถ้ายังไม่ดีพอก็ไปปรับแต่งพารามิเตอร์ใหม่จนกว่าได้ค่าคะแนนเฉลี่ยที่สูงที่สุดที่เราพอใจ ในที่นี้ได้มากสุดราวๆ 95% ซึ่งโมเดลนี้ก็น่าจะ Gerneralize พอที่จะไปทำการเทสกับข้อมูลที่แบ่งไว้ตอนแรก ซึ่งเป็นการทำ final evaluation อีกทีหนึ่ง

Ref:
[1]https://stats.stackexchange.com/questions/1826/cross-validation-in-plain-english
[2] https://sebastianraschka.com/faq/docs/evaluate-a-model.html
[3]http://scikit-learn.org/stable/modules/cross_validation.html

 

Precision and Recall

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

Precisionrecall

จากโมเดลด้านบนจะเห็นได้ว่าเราจะแบ่งประเภทของการจำแนกได้สี่แบบ
True Positives (TP) คือ ทำนายว่าเป็นหมา แล้วหน้าจริงๆก็เป็นหมา
True Negatives(TN) คือ ทำนายว่าไม่เป็นหมา หน้าจริงๆก็ไม่ใช่หมา
False Positives(FP) คือ ทำนายว่าเป็นหมา แต่หน้าจริงๆไม่ใช่หมา
False Negatives(FN) คือ ทำนายว่าไม่เป็นหมา แต่หน้าจริงๆเป็นหมา

การหาความแม่นยำ Precision = TP/(TP+FP) = จากโมเดลด้านบนจะได้ว่า 5/(5+3)=  0.625 ถ้าเต็ม 1 คือมีความแม่นยำสูง

การหาความมีประสิทธิภาพ Recall(หรืออีกชื่อเรียก sensitivity) = TP/(TP+FN) = จากโมเดลด้านบนจะได้ว่า 5/(5+7) =0.4167 ตรงนี้ตีความง่ายๆว่ามีใบหน้าน้องหมามากมายที่ไม่ได้ถูกระบุ การรู้จำหน้าน้องหมาต่ำ
ยังสามารถหาค่าอื่นๆได้อีกเช่น Accuracy, Misclassification Rate เป็นต้น คลิกที่นี่ครับ

มีระบบการวัดการทำงานของโมเดลอันหนึ่งที่เรียกว่า F-score คือระบบการวัดที่ใช้ค่าเฉลี่ยฮาร์โมนิคระหว่าง Precision และ Recall โดยใช้สูตรดังนี้ (2 x Precision x Recall) / (Presision+Recall)

จากโมเดลด้านบนจะได้ว่า F-score = (2 x 0.625 x 0.4167) / (0.625+0.4167) = 0.5 ซึ่งถ้าใกล้ 1 จะถือว่าเป็นโมเดลที่ดี สรุปได้ว่าโมเดลด้านบนนี้ยังทำงานไม่ค่อยดีเท่าไร ต้องมีการปรับแก้โมเดลกันอีกเพื่อการทำงานที่ดียิ่งขึ้น

Ref:
[1] https://en.wikipedia.org/wiki/Confusion_matrix
[2] https://en.wikipedia.org/wiki/Precision_and_recall
[3] https://en.wikipedia.org/wiki/F1_score
[4] http://www.dataschool.io/simple-guide-to-confusion-matrix-terminology/

K Means Clustering with Python

  • K Means เป็นอัลกอริทึม Machine Learning แบบ Unsupervised คือไม่ต้องมีการเทรนจากมนุษย์ก่อน ปรกติ Supervised Machine Learning จะต้องกำหนด Input และ Output เพื่อใช้เทรนโมเดล แต่ K Means นั้นกำหนดเพียง Input อย่างเดียวก็พอ ความสามารถของ K Means นั้นคือการแบ่งกลุ่มข้อมูลหรือที่เรียกว่า Clustering เพื่อแบ่งข้อมูลออกเป็น K กลุ่มตามชื่อของมัน โดนแต่ละกลุ่มจะมีจุดศูนย์กลางข้อมูลเรียก Centroid โดย Centroid นี้เกิดจากค่าเฉลี่ย(Means) ตำแหน่งของข้อมูลทุกตัวในกลุ่มข้อมูล
  • โพสนี้จะเป็นการรีวิวแลปโน้ตและใช้โค้ด python ตัวเดียวกับในเว็บ pythonprogramming.net ในการอธิบาย สาเหตุที่เลือกเว็บนี้เพราะมีการสอนเขียนโปรแกรม python ที่เป็นขั้นเป็นตอนเข้าใจง่ายและไม่ใช้ library ในการเทรนโมเดล เหมือนที่เว็บอื่นทำ ซึ่งจะทำให้เข้าใจในตัว K Means ได้มากกว่า
  • โดยอัลกอริทึม K Means มีขั้นตอนดังนี้
    1. กำหนดก่อนว่าจะแบ่งกี่กลุ่มข้อมูล สมมติแบ่งสองกลุ่มข้อมูล K=2 วางจุด Centroid ไว้ตำแหน่งสุ่มใดๆก็ได้สองจุด หรือจะเลือกข้อมูลสองจุดมาเป็น Centroid ก่อนก็ได้
    2. จากนั้นวัดระยะแบบ Euclidean ระหว่างจุดข้อมูลทั้งหมดกับ Centroid ทั้งสองแล้วดูว่าใกล้กับ Centroid กลุ่มไหน ก็ให้กำหนดข้อมูลให้อยู่กลุ่มข้อมูลชุดนั้น
    3. จากนั้นให้ทำการหาระยะทางเฉลี่ย(Means) ของข้อมูลในกลุ่มทั้งหมดเพื่อหาจุด Centroid ของกลุ่มนั้นใหม่ ถ้า Centroid ไม่เปลี่ยนไปกว่าเดิมให้ทำการหยุด(tol) ตรวจสอบว่าทำครบรอบที่กำหนดแล้วหรือยัง(max_iter) ถ้ายังให้กระโดดไปที่ ข้อ 2

Line 1-12 จะเป็นการ import library ที่ชื่อว่า matplotlib เพื่อใช้ในการวาดกราฟและกำหนดข้อมูลที่ใช้ในการทำ K Means ภาพด้านล่างแสดงข้อมูลหกจุด ถ้ามองด้วยตาเปล่าจะสังเกตุว่าถ้าเราแบ่งข้อมูลเป็นสองชุดจะได้ชุดที่อยู่มุมซ้ายล่างสามจุด กับ ชุดที่อยู่มุมขวาบนสามจุด

figure_1

 

Line 14 เป็นการกำหนดชุดสีให้แต่ละกลุ่มข้อมูล
คลาส K_Means
Line 17-20  กำนหนดคอนสตัคเตอร์ของคลาส K_Means ที่สามารถกำหนดจำนวนคลัสเตอร์ K ค่า tolerance(เปอร์เซนต์การเปลี่ยนแปลงระหว่างค่า centroid เก่าและ centroid ใหม่ ถ้าเปลี่ยนน้อยกว่าค่านี้ให้หยุดการทำงาน) และค่า max_iter (จำนวนรอบในการหา centroid) โดยเมื่อคลาสนี้ถูกสร้างอินสแตนท์จะกำหนดค่าดีฟอล์ท ของ K เป็น 2 ค่า tolerance เป็น 0.001 และค่า max_iter=300
เมธอด fit
Line 22-24 เลือกข้อมูล k จุดเพื่อเป็น centroid เริ่มต้นของแต่กลุ่มข้อมูล
Line 26 ทำการวนซ้ำจนกว่าจะครบจำนวนตาม max_iter
Line 27-29 กำหนดดิกชันนารี่ชื่อ Classifications เพื่อเก็บกลุ่มข้อมูล จำนวน k กลุ่ม สมมติ k=2 ตามโค้ดด้านบน ชุดข้อมูลที่อยู่ในกลุ่มของ centroid แรก จะอยู่ใน Classifications[0] ข้อมูลที่อยู่ในกลุ่มของ centroid ที่สอง จะอยู่ใน Classifications[1]
Line 31-34 นำข้อมูลแต่ละตัว มาหาระยะทางแบบยูคลีเดียน(ใช้คำสั่ง np.linalg.norm)กับ centroid ทั้งหมด แล้วดูว่าใกล้กับ centroid ไหน ให้ทำการเอาข้อมูลตัวนั้นใส่ลงไปในดิกชันนารี่ Classification ตามที่ได้สร้างไว้ใน Line 27-29
Line 36 กำหนดตัวแปร  prev_centroids เพื่อเก็บตำแหน่ง centroid ทั้งหมดเพื่อใช้ในการเปรียบเทียบกับ centroid ชุดใหม่ที่เกิดขึ้นในขั้นตอนต่อไป
Line 38-39 ในแต่ละกลุ่มของดิกชันนารี่ classifications ให้หาค่าเฉลี่ย(np.average)ของข้อมูลทุกตัวในกลุ่มเพื่อกำหนดจุด centroid ของกลุ่มใหม่
Line 41-51 กำหนดตัวแปร optimization ให้เป็น true จากนั้นทำการตรวจสอบว่า centroid ครั้งที่แล้วกับ centroid ปัจจุบัน มีการเปลี่ยนแปลงเกินกว่าค่า tolerance ถ้าใช่ ให้กำหนดตัวแปร optimization ให้เป็น false เพื่อจะได้ขึ้นไปวนลูปใหม่ ถ้าไม่ ให้แสดงว่ามีการเปลี่ยนแปลงระหว่าง centroid เก่าและใหม่น้อยมากในขอบเขตที่ยอมรับได้ ให้ออกจากลูบแม้ว่าจะทำงานไม่ครบรอบตามที่กำหนดไว้ในตัวแปร max_iter ก็ตาม
Line 53-56 เป็นเมธอด predict คือเป็นการเอาข้อมูลที่เป็นในส่วนของการเทสมาทดสอบว่าข้อมูลนั้นๆอยู่ในกลุ่มคลัสเตอร์ใด ต้องทำการเทรนโมเดลก่อน เมธอดนี้ถึงจะทำงานได้ถูกต้อง เมธอดนี้คล้ายคลึงกับ Line 31-33 

ในส่วนของคลาส K_Means ก็จบแต่เพียงเท่านี้

Line 58-80 จะเป็นการสร้างอินสแตนท์ของคลาส K_Means และส่งข้อมูลในตัวแปร X ไปเทรน จากนั้นทำการวาดภาพ โดยกำหนดจุดที่เป็น centroid ของแต่ละกลุ่มข้อมูลให้เป็นสีดำ ส่วนข้อมูลที่อยู่ในตัวแปร X หลังจากเทรนแล้ว จะแบ่งเป็นสองกลุ่มคือสีเขียวและสีแดง แทนด้วยสัญลักษณ์ X

figure_2

 

จากนั้นเราต้องการเทสโดยเอาข้อมูลในตัวแปร unknown มาทำการ predict ผ่านโมเดลที่เทรนแล้วเพื่อดูว่าข้อมูลแต่ละตัวในตัวแปร unknown อยู่ในกลุ่มคลัสเตอร์ใด โดยใช้สีในการบ่งบอกกลุ่มคลัสเตอร์ ตัวแปร unknown จะใช้สัญลักษณ์ * ในการแสดงบนกราฟ

Ref :
[1]https://pythonprogramming.net/k-means-from-scratch-machine-learning-tutorial/
[2]https://pythonprogramming.net/k-means-from-scratch-2-machine-learning-tutorial/?completed=/k-means-from-scratch-machine-learning-tutorial/

Convert Text into vectorial form using TF-IDF

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

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

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

จากนั้นเราจะทำการแปลงแต่ละประโยคให้อยู่ในรูปของ Term Frequency (TF) เข้าไปนับว่าคำใน BoW ของแต่ละประโยคมีความถี่เท่าไรและนำมาหารด้วยจำนวนคำทั้งหมดในประโยคนั้นๆ
TF(w)=f_w/N
โดยที่ f_w  คือความถี่ของคำ w ในประโยค N คือจำนวนคำทั้งหมดในประโยค

สังเกตว่าเราให้คำทุกคำมีค่าน้ำหนักเท่ากัน ถ้าเจอเท่าไรก็นับเท่านั้น สังเกตว่ามีคำบางคำที่พบบ่อยมากๆ และไม่มีนัยยะสำคัญเช่นพวก stop words อาทิเช่น a and the on in at this that ซึ่งเราจะทำการลดค่าน้ำหนักคำที่พบบ่อยเหล่านี้ ตัวอย่างข้างต้นอาจจะเห็นได้ไม่ชัดนักเนื่องจากจำนวนประโยคตัวอย่างค่อนข้างน้อย จะเห็นได้ว่า on เจอในทุกประโยคและไม่มีความสำคัญเท่าไร(ไม่มีลักษณะเด่น) ดังนั้นเราจะใช้เทคนิค ที่ชื่อว่า Inverse Document Frequency(IDF) โดยมีสูตรดังนี้
IDF(w)=log_{10} \frac{M}{K}

โดยที่ M คือ จำนวนประโยคทั้งหมด K คือ จำนวนประโยคทั้งหมดที่มี คำ w ปรากฏอยู่

จะได้ตารางดังนี้

เช่นคำว่า My ปรากฏอยู่ใน 3 ประโยค ในทั้งหมด 4 ประโยค log(4/3) = 0.12494  คำว่า on ปรากฏอยู่ในทั้งหมด 4 ประโยค log(4/4) = 0 สังเกตว่าคำที่พบบ่อยๆจะมีค่า idf เข้าใกล้ 0 แค่คำใดที่พบได้น้อยจะมีค่า idf เข้าใกล้ log(M)

สุดท้าย แต่ละประโยคก็จะเกิดจาก IF(w)\times{IDF(w)}

ตัวอย่างประโยคแรกเมื่อทำการแปลงด้วย tf-idf

สังเกตคำว่า on กับคำว่า eats จะเป็น 0 เพราะเป็นคำที่พบได้ทั่วไป ส่วนคำว่า saturday,fish ค่อนข้างจะมีค่า tf-idf สูงเพราะเป็นคำที่มีลักษณะเด่นและเป็นประโยชน์ของประโยคนี้

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

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

Review : Neural Network Demystified part 1

ซีรีย์ชุดนี้จะเป็นการรีวิวและเป็นการโน้ตแลบเป็นเวอร์ชั่นภาษาไทยจากคลิปวิดีโอจากช่อง Welch Labs เกี่ยวกับ Neural Network ในโพสนี้จะพูดเกี่ยวกับ Data และ Architecture

สมมติให้ตารางค่า X กับ y โดยที่ X เป็น จำนวนชั่วโมงการนอน และจำนวนชั่วโมงการทบทวนก่อนวันสอบ ส่วน y เป็น คะแนนที่ทำได้

Table

 

จากตารางด้านบนจะเห็นได้ว่าเราต้องการจะทำนายว่าถ้าเรานอน 8 ชั่วโมงและทบทวนหนังสือ 3 ชั่วโมง จะได้คะแนนสอบเท่าไร โดยเราจะทำนายโดยใช้ข้อมูลที่มีอยู่ก่อนหน้านี้แล้วก็คือในส่วนของเทรนนิ่ง ลักษณะแบบนี้เรียก machine learning แบบ supervised คือต้องมีการให้ input และ output มาล่วงหน้าเพื่อใช้ในการเทรน

ปัญหานี้เราจะเรียก Regression problem คือค่าที่ทำนายออกมาเป็นค่าแบบ continuous หรือค่าทศนิยม ไม่ใช่ทำนายออกมาว่าเป็นกรุ๊ป A B หรือ C ถ้าแบบนั้นจะเรียก Classifying problem ทีนี้โมเดล Machine Learning มีหลายตัวมากที่สามารถใช้แก้ปัญหาได้ เช่น Support Vector Machine, Guassian Processes, Artificial Neural Network, Random forests, Classification+Regression Trees และอื่นๆอีกมากมาย แต่ในซีรีย์ชุดนี้จะเลือกในส่วนของ Artificial Neural Network(ANN) โครงข่ายประสาทเทียม ซึ่งได้แรงบันดาลใจจากเซลล์ประสาทในสมองของมนุษย์ที่มีส่วนรับและส่งกระแสไฟฟ้าไปยังเซลล์ประสาทตัวอื่นๆ จากภาพด้านล่างเป็นการเปรียบเทียบระหว่างโครงข่ายประสาทของจริงกับของเทียมที่ประสบความสำเร็จในการแก้ปัญหาที่ซับซ้อน เช่นการทำ Image Classification, Natural Language Processing เป็นต้น

Biological vs Artificial Neural Network

 

กลับมาที่ตารางของเรา เราต้องมีการ normalization หรือการ Scaling  ข้อมูลทั้งหมดให้อยู่ในช่วงเดียวกัน ในที่นี้คือ 0 ถึง 1 ซึ่งง่ายสุด โดยคำนวนได้จาก

x_{norm}=\frac{X}{max(X)} และ y_{norm}=\frac{y}{max(y)} โดยที่ max(y) ในที่นี้เท่ากับ 100 คือค่ามากที่สุดของ y ที่เป็นไปได้ ด้านล่างคือโค้ด python ของการกำหนดค่า X และ y และการทำ normalization ตามลำดับ

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

ANN

จากภาพด้านบน เราจะเอาเทรนนิ่งดาต้า(วงกลมสีส้ม) มาทำการเทรนผ่าน ANN ซึ่งประกอบไปด้วย Neuron คือโหนด และ Synapse คือเส้น(edge)ที่ออกจากโหนด ประกอบกันหลายชั้นซึ่งเรียกว่า hidden layers หรือที่เรียกว่า deep learning หน้าที่ของ Synapse คือการนำค่า input มาคูณกับค่า weight แล้วก็ส่งผลลัพธ์ออกมา หน้าที่ของ Neuron จะซับซ้อนกว่า Synapse หน่อยนึงคือจะเป็นการเอาผลลัพธ์จาก Synapse หลายตัวๆมารวมกัน

ANN2และนำมาผ่าน sigmoid activation function  เป็นกราฟรูปตัว s ซึ่งมีค่าเอ้าท์พุตอยู่ในช่วง 0…1 คล้ายๆสเตปฟังก์ชั่นไบนารี่ 0 และ 1 เพื่อเลียนแบบเซลล์ประสาทว่าจะส่งสัญญาณต่อไปนิวรอนตัวถัดไปหรือไหม และค่าที่อยู่ในช่วง 0…1 ยังไปสอดคล้องกับความน่าจะเป็นได้อีกด้วย

จากภาพด้านล่างจะเห็นได้ว่า ถ้าค่าน้อยกว่า -6 จะเข้าใกล้ 0 คือ deactivate ถ้าค่ามากกว่า 6 จะเข้าใกล้ 1 เป็น activate ช่วง -6 ถึง 6 ถือว่าเป็นช่วงที่แคบมากๆที่กราฟจะพลิกจากฝั่ง 0 ไป 1

รวมไปถึงเป็นฟังก์ชั่นที่แปลงจาก linear เป็น non linear ซึ่งสามารถหาอนุพันธุ์ได้ รายละเอียดเชิงลึกอยู่ในกระทู้นี้ครับ (ทุกโหนดใน hidden layer ต้องผ่าน sigmoid function รวมถึงเอ้าพุตy hat อีกด้วย)

ท้ายสุดเมื่อผ่านการคำนวนจาก hidden layer แล้วจะได้เอ้าพุตออกมาเป็น y hat(วงกลมสีเขียว) ซึ่งเป็น y ที่เกิดจากการประมาณ ไม่ใช่ y ตัวเดียวกับที่อยู่ในเทสติ้ง

บทความหน้าในซีรีย์ชุดนี้จะพูดถึง forward propogation ครับ

thanks : Welch Labs ที่ทำคลิปดีๆมาให้เราได้ศึกษากัน

To,CC and BCC when composing email

หลายคนอาจจะสงสัยเวลาเขียนอีเมลจะมีช่อง CC และ BCC ส่วนช่อง To นี่หลายคนคงเข้าใจอยู่แล้ว คือเวลาเขียนอีเมลจะส่งหาใครก็ใส่ในช่อง To ถ้ามีหลายคนก็ใช้คอมม่าคั่นเอา

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

ทีนี้ มีอีกกรณีหนึ่งเป็นการส่งสำเนาอีเมลเหมือนกันแต่เป็นในทางลับคือ ไม่อยากให้ ผู้รับอีเมลด้วยช่อง To และ CC ทราบ ก็ต้องส่งด้วย BCC แม้กระทั่งผู้รับคนอื่นที่อยู่ใน BCC ต่างก็ไม่เห็นกันและกัน ในทางกลับกันผู้รับที่อยู่ในช่อง BCC จะเห็นว่าอีเมลนี้ส่งไปหาใครบ้าง(To และ CC)  และผู้ส่งเท่านั้นที่จะเห็นรายชื่อทั้งหมดในช่อง BCC

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

Ref: https://www.quora.com/What-are-CC-and-BCC-in-Gmail-How-do-I-use-them

 

Betweeness Centrality

ใช้หาว่าใครเป็นศูนย์กลางระหว่างสองกลุ่ม คำนวนได้จาก

C_b(v_i)=\displaystyle\sum_{s\neq t\neq v_i} \frac{\sigma_{st}(v_i)}{\sigma_{st}}

โดยที่ \sigma_{st} คือจำนวนของเส้นทางที่สั้นสุดระหว่างโหนด s ไปโหนด t ส่วน  \sigma_{st}(v_i)  คือจำนวนของเส้นทางที่สั้นสุดระหว่างโหนด s ไปโหนด t แต่ต้องผ่านโหนด v_i

ตัวอย่างfigure_1

จะได้พาททั้งหมดดังนี้

เช่นจะหา C_b(v_2) ทำได้โดย 2\times(\frac{\sigma_{13}(v_2)}{\sigma_{13}}+\frac{\sigma_{14}(v_2)}{\sigma_{14}}+\frac{\sigma_{15}(v_2)}{\sigma_{15}}+\frac{\sigma_{34}(v_2)}{\sigma_{34}}+\frac{\sigma_{35}(v_2)}{\sigma_{35}}+\frac{\sigma_{45}(v_2)}{\sigma_{45}}) สาเหตุที่คูณด้วยสองเพราะว่าเป็นกราฟแบบไม่มีทิศทางดังนั้นจึงมีพาทวิ่งกลับด้วย เช่น จาก 3 ไป 1 จาก 4 ไป 1 จาก 5 ไป 1 เป็นต้น ดังนั้นจะได้

2\sum_{s\neq t \neq v_{i},s<t} \frac{\sigma_{st}(v_i)}{\sigma_{st}}=2\times(\frac{1}{1}+\frac{1}{1}+\frac{2}{2}+\frac{1}{2}+0+0)=7

ถ้าจะเอาไปเทียบกับเครือข่ายสังคมอื่นๆต้อง normalize ก่อน โดยเอาไปหารด้วยค่า max สังเกตจากสมการด้านบนพจน์ที่ 4 หายไปครึ่งหนึ่ง พจน์ที่ 5 กับพจน์ที่ 6 ไม่มี ถ้ามีหมดจะได้ 6 คูณ 2 จะได้ 12  ค่า 12 นี้ก็คือ ทุกพาธจาก s ไป t วิ่งผ่านโหนด 2 หมดซึ่งเป็นค่า max เราเอาค่านี้ไปหาร 7 จะได้ประมาณ 0.5833 จะกล่าวสรุปได้ว่า เมื่อโหนด v_i อยู่ระหว่างเส้นทางที่สั้นที่สุดระหว่าง s กับ t ทุกคู่นั่นคือจะเท่ากับ 1 หรือ \forall(s,t),s\neq t \neq v_{i}\frac{\sigma_{st}(v_i)}{\sigma_{st}}=1 หรือถ้าหาได้ว่าจากโหนด s ไปโหนด t มีกี่คู่ก็ได้ หาได้จากสองเท่าของ combination มี n-1 โหนดเลือก 2 (หรืออีกชื่อไบโนเมียล)2\binom {n-1}{2}=2\times\frac{(n-1)!}{2!((n-1)-2)!}=\frac{(n-1)!}{(n-3)!}=\frac{(n-1)(n-2)(n-3)!}{(n-3)!}=(n-1)(n-2) ดังนั้นจะได้ว่า

C^{norm}_b(v_i)= \frac{C_{b}(v_i)}{2\binom {n-1}{2}} เช่น C^{norm}_b(v_2)= \frac{7}{12}\approx 0.5833

โค้ดโปรแกรม

ผลลัพธ์

สรุป โหนด 2 มีค่า betweeness centrality สูงสุด เป็นตัวเชื่อมระหว่างโหนดต่างๆมากสุด

References
1.Social Media Mining: An Introduction.By Reza Zafarani, Mohammad Ali Abbasi, and Huan Liu.Cambridge University Press, 2014. Draft version: April 20, 2014.
Complete Draft and Slides Available at: http://dmml.asu.edu/smmPage 82-84
2.All shortest Path NetworkX Library at: http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.generic.all_shortest_paths.html
3.Betweeness Centrality NetworkX Library at: http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.centrality.betweenness_centrality.html#networkx.algorithms.centrality.betweenness_centrality

Degree Centrality

เป็นการหาว่าโหนดที่เราสนใจมีความสำคัญเพียงใดใน Social Network โดยดูจากจำนวน degree หรือจำนวนเส้นที่เชื่อมต่อระหว่างโหนดที่เราสนใจกับโหนดอื่นๆ สำหรับกราฟไม่มีทิศทาง(undirected graph) ค่า degree centrality C_d สำหรับโหนด v_i คือ
C_d(v_i)=d_i
โดยที่ d_i คือ degree หรือจำนวน adjacent edge ของโหนด v_i
ถ้าเป็นกราฟแบบมีทิศทาง(directed graph) สามารถเลือกใช้ in-degree หรือ out-degree หรือใช้ทั้งสองร่วมกันก็ได้ โดย
C_d(v_i)=d^{in}_i   ใช้วัดว่าบุคคลนั้นเป็นคนที่ได้รับความนิยมเพียงใดใน Social Network
C_d(v_i)=d^{out}_i ใช้วัดว่าบุคคลนั้นเป็นคนที่ชอบเข้าสังคมเพียงใดใน Social Network
แต่ถ้าไม่สนใจทิศทางก็จะได้ C_d(v_i)=d^{in}_i+d^{out}_i ซึ่งจะเท่ากันกับ degree centrality ของกราฟที่ไม่มีทิศทาง

ถ้าจะเอาค่า degree centrality จากเครือข่ายสังคมหนึ่งไปเทียบกับเครือข่ายสังคมอีกอันหนึ่งจะยังเทียบไม่ได้ เช่นเทียบ twitter กับ facebook  ต้องทำการ normalization ก่อนซึ่งทำได้หลายวิธีดังนี้

  1. หารด้วยจำนวน degree ที่เป็นไปได้มากสุด C^{norm}_d(v_i)=\frac{d_i}{n-1} โดยที่ n คือจำนวนโหนด หรือ
  2. หารด้วยจำนวน degree ที่มากที่สุด C^{max}_d(v_i)=\frac{d_i}{max d_j} หรือ
  3. หารด้วยจำนวนผลรวมของ degree C^{sum}_d(v_i)=\frac{d_i}{\sum_{j} d_j}=\frac{d_i}{2|E|}=\frac{d_i}{2m} โดยที่ |E| หรือ m คือจำนวน edge

ตัวอย่างโปรแกรมหา Degree Centrality
figure_1

เป็นกราฟแบบไม่มีทิศทาง บรรทัดแรกที่ปรินท์คือค่าแบบยังไม่ได้ normalize ส่วนค่าบรรทัดต่อมาเป็นค่าเรียงตั้งแต่โหนด 1 – 8 เป็นค่าที่ nomalize แบบ  C^{norm},C^{max},C^{sum} ตามลำดับ

References
1.Social Media Mining: An Introduction.By Reza Zafarani, Mohammad Ali Abbasi, and Huan Liu.Cambridge University Press, 2014. Draft version: April 20, 2014.
Complete Draft and Slides Available at: http://dmml.asu.edu/smm Page 74-75
2.“Social Network Analysis for Startups by Maksim Tsvetovat and Alexander Kouznetsov (O’Reilly). Copyright 2011 Maksim Tsvetovat and Alexander Kouznetsov, 978-1-449-30646-5.” Page 46-48