Author: kanakorn.h

  • วิธีทำให้โปรไฟล์บน Google Scholar เป็น Public

    Google Scholar เป็นบริการหนึ่งของ Google ทำให้เรามีโปรไฟล์ 
    “อีกช่องทางหนึ่ง” เพื่อแสดงผลงานที่ได้รับการเผยแพร่ หรือตีพิมพ์ในที่ต่าง ๆ 

    อ่านเพิ่มเติม https://scholar.google.com/intl/en/scholar/about.html

    ปัญหาอยู่ที่ว่า ในการสร้างครั้งแรกโปรไฟล์ (Profile) ของท่าน จะยังไม่ Public หมายความว่า จากหน้า Google จะค้นหาไม่เจอ Google Scholar Profile ของท่านนั่นเอง ( พอดีมีอาจารย์ท่านหนึ่งถามมา เห็นว่าเป็นประโยชน์ จึงเขียนบันทึกนี้ไว้ให้ )

    วิธีการทำให้เป็น Public Profile

    จากหน้า Profile ของท่าน คลิกที่รูป ดินสอ (Edit) ด้านหลังชื่อ

    คลิก Make my profile public แล้วคลิกปุ่ม Save

    แต่ต้องรอสักหน่อย เคยอ่านเจอมาว่า ใช้เวลาประมาณ 4 weeks กว่าจะค้นหาบน Google เจอ

  • ELK #07 LogStash

    จากที่ได้กล่าวถึงมายาวนานในเรื่อง ELK  และ  ELK #02 ที่ได้กล่าวถึงการติดตั้ง LogStash ไว้เบื้องต้น ในบทความนี้จะมาลงลึก ถึงกระบวนการทำงานของ LogStash ซึ่งเป็นส่วนสำคัญในการเปลี่ยนข้อมูล Unstructured ให้เป็น Structured

    ตอนนี้ เราจะทำงานใน /etc/logstash/conf.d/

    Simple input – output plugin

    สร้างไฟล์ 01-input-file.conf มีเนื้อหาดังนี้

    input {
    	file {
    		path => ["/tmp/input.txt"]
    		mode => "tail"
    		}
    }
    

    ในส่วนนี้ เป็นการกำหนดว่า ให้ LogStash อ่านไฟล์ /tmp/input.txt โดยให้อ่านบรรทัดล่าสุด (ต่อจาก Checkpoint ก่อนหน้า) เข้ามา โดยถ้าไม่กำหนด mode => “tail” ระบบจะอ่านไฟล์ก็ต่อเมื่อ มีการสร้างไฟล์ใหม่เท่านั้น

    สร้างไฟล์ 98-output-file.conf มีเนื้อหาดังนี้

    output {
            file {
                    path => "/tmp/output.txt"
            }
    }
    

    ในส่วนนี้ เป็นการกำหนดว่า ให้ LogStash เขียนไฟล์ /tmp/output.txt

    เมื่อปรับเปลี่ยน configuration ต้องทำการ Restart Service

    service logstash restart
    

    ลองส่งข้อมูลเข้าไปในไฟล์ /tmp/input.txt ด้วยคำสั่ง

    echo "Hello World 1" >> /tmp/input.txt

    ดูผลลัพธ์ใน /tmp/output.txt

    cat /tmp/output.txt
    {"path":"/tmp/input.txt","@version":"1","message":"Hello World 1","@timestamp":"2018-09-11T03:42:33.645Z","host":"elk1"}

    แสดงให้เห็นว่า ระบบ LogStash สามารถรับข้อมูลจากไฟล์ และส่งข้อมูลออกไปยังไฟล์ได้

    Filter Plugin

    ก่อนอื่น Stop Service ด้วยคำสั่ง

    service logstash stop
    

    ในการจัดการข้อมูลก่อนบันทึก เช่นการกรอง การจัดรูปแบบ LogStash ทำงานผ่าน Filter Plugin ซึ่งมีหลายรูปแบบ (https://www.elastic.co/guide/en/logstash/current/filter-plugins.html) แต่ในที่นี้ จะใช้ grok เหมาะกับข้อมูล Unstructured อย่าง syslog เป็นต้น ซึ่งมักจะเป็น Log ที่ให้มนุษย์อ่านได้ง่าย แต่ไม่ค่อยเหมาะสำหรับให้คอมพิวเตอร์เอาไปใช้งานต่อ ซึ่ง LogStash มีไว้ให้แล้วกว่า 120 ตัว

    ตัวอย่าง grok-pattern

    ต่อไป สร้าง 44-filter-basic.conf มีเนื้อหาดังนี้

    filter {
            grok {
                    match => {
                            "message" => "%{IP:ipaddress} %{NUMBER:size}"
                    }
            }
    }
    

    จากนั้น Start Service ด้วยคำสั่ง (รอสักครู่ด้วย)

    service logstash start
    

    แล้วส่งข้อมูลต่อไปนี้ต่อท้ายไฟล์ /tmp/input.txt

    echo "192.168.1.1 120" >> /tmp/input.txt

    และเมื่อดูผลใน /tmp/output.txt จะพบบรรทัดสุดท้าย

    {"message":"192.168.1.1 120","@version":"1","path":"/tmp/input.txt","@timestamp":"2018-09-11T04:56:03.662Z","size":"120","host":"elk1","ipaddress":"192.168.1.1"}

    แสดงให้เห็นว่า สามารถใช้ filter นี้ แยกแยะข้อมูลเบื้องต้นได้

    Example : Postfix Log

    ก่อนอื่น Stop Service ด้วยคำสั่ง

    service logstash stop
    

    เนื่องจาก Log แต่ละชนิด แต่ละซอฟต์แวร์มีความหลากหลายมาก แต่ดีที่มีผู้เชี่ยวชาญเค้าเขียน Pattern เอาไว้ให้ ให้ใช้คำสั่งต่อไปนี้ สร้างไดเรคทอรี่ /etc/logstash/patterns.d/ และ ดาวน์โหลด มาเก็บไว้

    mkdir /etc/logstash/patterns.d
    wget https://raw.githubusercontent.com/logstash-plugins/logstash-patterns-core/master/patterns/grok-patterns -O /etc/logstash/patterns.d/grok-patterns
    wget https://raw.githubusercontent.com/whyscream/postfix-grok-patterns/master/postfix.grok -O /etc/logstash/patterns.d/postfix.grok
    
    

    ในกรณีของ Postfix จากนั้น ดาวน์โหลด Filter Plugin มาเก็บไว้ใน /etc/logstash/conf.d/ ด้วยคำสั่ง

    wget https://raw.githubusercontent.com/whyscream/postfix-grok-patterns/master/50-filter-postfix.conf -O /etc/logstash/conf.d/50-filter-postfix.conf
    

    และ ต้องสร้างอีกไฟล์ เพื่อเตรียมข้อมูล ชื่อ 49-filter-postfix-prepare.conf ใน /etc/logstash/conf.d/ เนื้อหาตามนี้

    filter {
    	grok {
        		match => { "message" => "%{SYSLOGTIMESTAMP} %{SYSLOGHOST} %{DATA:program}(?:\[%{POSINT}\])?: %{GREEDYDATA:message}" }
        		overwrite => "message"
    	}
    }
    

    จากนั้น Start Service ด้วยคำสั่ง (รอสักครู่ด้วย)

    service logstash start
    

    แล้วส่งข้อมูลต่อไปนี้ต่อท้ายไฟล์ /tmp/input.txt

    echo "Sep 11 12:05:26 mailscan postfix/smtp[105836]: 268E04DFFE6: to=, relay=mail.psu.ac.th[192.168.107.11]:25, delay=43, delays=43/0/0.01/0.01, dsn=2.0.0, status=sent (250 2.0.0 Ok: queued as DE294461637)" >> /tmp/input.txt

    และเมื่อดูผลใน /tmp/output.txt จะพบบรรทัดสุดท้าย

    {"program":"postfix/smtp","postfix_delay":43.0,"postfix_dsn":"2.0.0","postfix_relay_port":25,"message":"268E04DFFE6: to=, relay=mail.psu.ac.th[192.168.107.11]:25, delay=43, delays=43/0/0.01/0.01, dsn=2.0.0, status=sent (250 2.0.0 Ok: queued as DE294461637)","path":"/tmp/input.txt","postfix_queueid":"268E04DFFE6","postfix_delay_conn_setup":0.01,"@version":"1","host":"elk1","postfix_to":"xxx.y@psu.ac.th","postfix_relay_hostname":"mail.psu.ac.th","postfix_delay_transmission":0.01,"tags":["_grokparsefailure","_grok_postfix_success"],"postfix_smtp_response":"250 2.0.0 Ok: queued as DE294461637","postfix_delay_before_qmgr":43.0,"postfix_relay_ip":"192.168.107.11","@timestamp":"2018-09-11T07:57:20.354Z","postfix_delay_in_qmgr":0.0,"postfix_status":"sent"}

    แสดงให้เห็นว่า สามารถใช้ filter นี้ แยกแยะข้อมูลเบื้องต้นได้

    From Syslog to ElasticSearch

    จากตัวอย่างข้างต้น เราทำงานกับไฟล์ /tmp/input.txt และ /tmp/output.txt ต่อไปนี้ จะเป็นการ รับ Input จาก syslog จริง ๆ จากเซิร์ฟเวอร์ ผ่าน Filter และส่งผลออกไปเก็บใน ElasticSearch

    ก่อนอื่น Stop Service ด้วยคำสั่ง

    service logstash stop
    

    สร้างไฟล์ 02-input-syslog.conf ไว้ใน /etc/logstash/conf.d/ เนื้อหาดังนี้
    ( เปิดรับ syslog ที่ tcp/5514 )

    input {
            syslog {
                    port => "5514"
            }
    }
    

    สร้างไฟล์ 99-output-elasticsearch.conf ไว้ใน /etc/logstash/conf.d/ เนื้อหาดังนี้
    ( ในที่นี้ ใช้ ElasticSearch บน localhost ที่ tcp/9200 และ ไม่ได้ตั้ง Security ใด ๆ )

    output {
            elasticsearch {
                    hosts => ["localhost:9200"]
            }
    }
    

    จากนั้น Start Service ด้วยคำสั่ง (รอสักครู่ด้วย)

    service logstash start
    

    ที่เซิร์ฟเวอร์ที่จะส่ง Log มาเก็บใน ElasticSearch ผ่าน LogStash ให้แก้ไข /etc/rsyslog.d/50-default.conf ชี้ mail.* ไปยัง LogStash  ที่ tcp/5514

    mail.* @@logstash.ip:5514
    

    หากทุกอย่างเรียบร้อย ก็จะสามารถดูผลจาก Kibana ได้อย่างสวยงาม

    สามารถนำข้อมูลไปใช้วิเคราะห์ได้ต่อไป

  • อย่าเชื่อเครื่องมือมากเกินไป …

    เมื่อเดือนมีนาคม 2561 ผมได้ทำการทดสอบเครื่องมือเจาะระบบ “N”  (ใช้ทดสอบว่าระบบเป้าหมายมีช่องโหว่ใดให้โจมตีบ้าง) ภายใต้ภาระกิจ “Honeypot” เพื่อทดสอบว่า เครื่องมือดังกล่าว สามารถรับรองความปลอดภัยของระบบปฏิบัติการของเครื่องเซิร์ฟเวอร์ ก่อนที่จะอนุญาตให้เข้าถึงได้จากอินเตอร์เน็ตได้หรือไม่

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

    วิธีการทดสอบ

    จัดให้มีเครื่องทดสอบ ชื่อ honeypot.in.psu.ac.th อยู่บน VM และใช้เครื่องมือเจาะระบบ “N” ตรวจสอบ 2 ครั้ง โดยครั้งแรก (Baseline 01) เป็นการติดตั้งระบบปฏิบัติการ Ubuntu 16.04 LTS แบบ Default และ Update ให้เป็นปัจจุบันที่สุด แล้วรีบแจ้งให้ “N” ตรวจสอบ ครั้งที่ 2 (Baseline 02) ทำการติดตั้ง Web Server, PHP, MySQL และติดตั้งช่องโหว่อย่างง่ายที่พัฒนาขึ้นเอง (https://github.com/nagarindkx/honeypot) ลงไป โดยภาพรวมดังภาพที่ 1 แล้วรีบแจ้งให้ “N” ตรวจสอบ

    ภาพที่1: ภาพรวมของ Honeypot

    honeypot.in.psu.ac.th ประกอบด้วยโครงสร้างไฟล์ ดังภาพที่ 2

    ภาพที่ 2: โครงสร้างไฟล์ของ honeypot

    เมื่อคลิก Login with SQL Injection Vulnerable  จะได้ภาพที่ 3 ซึ่งจะส่งไปที่ไฟล์ badform.html โดยในฟอร์มนี้จะมีช่องโหว่ SQL Injection ทำให้สามารถเข้าเป็น admin ได้โดยลองใส่ username/password ดังนี้

    ภาพที่ 3: http://honeypot.in.psu.ac.th/badform.html

    ซึ่งจะได้ผลว่า สามารถเข้าเป็น admin ได้โดยไม่ต้องทราบรหัสผ่านที่แท้จริง แต่อาศัยการเขียน SQL Statement ที่ไม่รัดกุม และไม่ตรวจสอบ Input ก่อน ดังภาพที่ 4

    ภาพที่ 4: ช่องโหว่ SQL Injection

    เมื่อคลิก  Simple Non Persistent XSS   จะได้ภาพที่ 5  ซึ่งจะส่งไปยัง simple.php โดยจะเห็นได้ว่า สามารถใส่ชื่อ นามสกุล ลงไปใน URL ได้เลย ผ่านตัวแปร name  (ต้องลองใช้กับ FireFox ถ้าเป็น Google Chrome จะมี XSS Auditor ไม่ได้รับผลกระทบ)

    ภาพที่ 5: ช่องโหว่ Non Persistent XSS

     

    ช่องโหว่นี้ ทำให้ Hacker นำเว็บไซต์นี้ไป ดักเอา Cookie Session ของผู้อื่น หรือ Session HiJacking ดังภาพที่ 6
    ด้วย URL นี้
    http://honeypot.in.psu.ac.th/simple.php?name=%3Cscript%3Ealert(escape(document.cookie))%3C/script%3E

    ภาพที่ 6: Session HiJacking

    หรือ เปลี่ยนเปลี่ยน URL ที่ “Click to Download” ไห้ยังเว็บไซต์ที่ต้องการได้ เช่นเป็น hacked.com เป็นต้น ดังภาพที่ 7 ด้วย URL นี้
    http://honeypot.in.psu.ac.th/simple.php?name=%3Cscript%3Ewindow.onload=function()%20{%20var%20link=document.getElementsByTagName(%22a%22);%20link[0].href=%27http://hacked.com%27}%3C/script%3E

    ภาพที่ 7: HTML Injection

    เมื่อคลิก Login to Test Permanent XSS จะได้ภาพที่ 8  ซึ่งจะส่งไปยัง goodlogin.php

    ภาพที่ 8:ช่องโหว่ Persistent XSS

    ซึ่ง เป็น Form ที่ป้องกัน SQL Injection และ ไม่ยอมรับ username/password ว่าง หากไม่ทราบรหัสผ่านจริงๆ ก็จะเข้าไม่ได้ ดังภาพที่ 9

    ภาพที่ 9: กรณี Login ไม่สำเร็จ

    หาก Login เป็น user1 สำเร็จ จะสามารถเปลี่ยน Display Name ได้ ดังภาพที่ 10
    ทดลองด้วย

    username: user1
    password: user1123**

    ภาพที่ 10: user1 เมื่อ Login สำเร็จ สามารถเปลี่ยน Display Name ได้

    หาก user1 ต้องการดัก Session HiJack จาก Admin สามารถทำได้โดย แก้ Display Name ดังนี้

    <a href=”#” onclick=alert(escape(document.cookie))>User1</a>

    เมื่อกดปุ่ม Update จะได้ภาพที่ 11

    ภาพที่ 11: user1 วาง Session HiJacking สำเร็จ

    เมื่อ admin เข้ามาในระบบ ด้วย

    username: admin
    password: admin123**

    จะได้ภาพที่ 12

    ภาพที่ 12: admin จะมองเห็นรายชื่อ users ทั้งหมด ในที่จะเห็น user1 ที่มี display name ของตนเองเป็น Link

    เมื่อ admin ติดกับดัก ลองคลิก link ที่เขียนโดย user1 ก็จะเปิดเผย (และสามารถส่ง session กลับไปให้ user1 ได้หลายวิธี) ก็จะได้ผลดังภาพที่ 13

    ภาพที่ 13: แสดง Session ของ Admin ซึ่งในช่วงเวลานั้นๆ user1 สามารถเข้ามาเป็น admin ได้โดยไม่ต้องทราบรหัสผ่านของ admin

    *** และ มี Backdoor ที่อยู่ใน /uploads/ ไฟล์ image.php ที่ ไม่ได้แสดงใน index.php หน้าแรก ซึ่งจะสามารถส่งคำสั่งเข้าไปให้ Execute ได้ เช่น ls -l ดังภาพที่ 14 หรือ แม้แต่ wget ไฟล์จากภายนอกมาไว้ในนี้ได้ เพื่อสร้าง Backdoor ในที่ต่างๆ ซึ่งเรียกว่า Remote Code Execution

    ภาพที่ 14: Backdoor ใน /uploads/image.php ที่ไม่ได้อยู่ใน index.php หน้าแรกของ honeypot

    ผลการทดสอบ

    จากผลการทดสอบด้วย “N” เมื่อ Mon, 12 Mar 2018 13:57:16 ICT ผลดังภาพที่ 15

    ภาพที่ 15: แสดงรายการช่องโหว่ “N”  ตรวจพบ ประกอบด้วย 1 High, 5 Medium Risk

    ผลการทดสอบสามารถสรุปเป็นตารางได้ ดังตารางที่ 1

    ตารางที่ 1: แสดงผลเปรียบเทียบสิ่งที่ honeypot วางไว้ กับสิ่งที่ “N” ตรวจพบ ตามตำแหน่งไฟล์ต่างๆ

    ตำแหน่งไฟล์Honeypot วาง“N” ตรวจพบ
    badform.htmlSQL Injectionยอมรับได้
    – Web Application Potentially Vulnerable to Clickjacking (เป็น Form ที่ยอมให้เว็บอื่นเอาไปใส่ใน iframe ได้)
    login.phpJavaScript Injectionเป็น False Positive
    เพราะ Login Fail

    – CGI Generic SQL Injection (blind)
    – CGI Generic XSS (quick test)
    – CGI Generic Cookie Injection Scripting
    – CGI Generic XSS (comprehensive test)
    – CGI Generic HTML Injections (quick test)
    ยอมรับได้
    – Web Application Potentially Vulnerable to Clickjacking (เป็น Form ที่ยอมให้เว็บอื่นเอาไปใส่ใน iframe ได้)


    ไม่เข้าไปตรวจ JavaScript Injection เพราะไม่ได้ตรวจสอบ SQL Injection จากหน้า badform.html
    simple.phpNon-Persistent XSSยอมรับได้
    – CGI Generic XSS (quick test)
    – CGI Generic Cookie Injection Scripting
    – CGI Generic XSS (comprehensive test)
    – CGI Generic HTML Injections (quick test)
    goodlogin.phpเป็น False Positive เพราะ Login Fail
    – CGI Generic SQL Injection (blind)

    ยอมรับได้
    – Web Application Potentially Vulnerable to Clickjacking (เป็น Form ที่ยอมให้เว็บอื่นเอาไปใส่ใน iframe ได้)
    home.phpPersistent XSSไม่เข้าไปตรวจ เพราะไม่สามารถเดารหัสผ่านที่ถูกต้องได้
    /uploads/image.phpBackdoor (Remote Code Execution)ไม่เข้าไปตรวจ เพราะไม่มี Link จากหน้าแรก

    สรุปผลการทดสอบ

    1. น่าตกใจ ที่ “N” ไม่สามารถตรวจพบ SQL Injection ได้ในหน้า badform.html
    2. “N” ตรวจพบ XSS ในหลายรูปแบบในหน้า simple.php ซึ่งนับว่าดี
    3. “N” ตรวจสอบได้เฉพาะ URL ที่สามารถติดตามไปจากหน้าแรกได้เท่านั้น จะเห็นได้ว่า ไม่สาามารถเข้าไปตรวจสอบ home.php ซึ่งต้องเดารหัสผ่านให้ได้ก่อน และ /uploads/image.php ซึ่งไม่มีการเรียกจากหน้าแรก ซึ่งโดยทางปฏิบัติ Hacker เมื่อเจาะเข้ามาวางไฟล์ได้แล้ว จะเอา URL นั้นไปโพสต์ประกาศในกลุ่ม หรือ บนหน้าเว็บไซต์อื่นๆ เช่น zone-h.org เป็นต้น ทำให้ เราตรวจด้วย “N” ยังไงก็ไม่เจอ แต่ Google ตรวจเจอเพราะไปตรวจสอบเว็บไซต์ของกลุ่ม Hacker อีกที
    4. “N” ทำงานเป็นลำดับ ดังนั้น เมื่อ ไม่ตรวจพบ SQL Injection ในหน้า badform.html ก็ไม่ตรวจ JavaScript Injection ในหน้า login.php
    5. “N” เตือนเรื่องสามารถนำ Form ไปอยู่ใน iframe ของเว็บไซต์อื่นๆได้ ซึ่งนับว่าดี

    อภิปรายผลการทดสอบ

    การมีเครื่องมือในการเจาะระบบอย่าง “N” เป็นเรื่องดี ทำให้สามารถลดงานของผู้ดูแลระบบได้ อย่างน้อยก็เรื่องการตรวจสอบ Version ของ OS, Software ที่ใช้ ว่าได้รับผลกระทบต่อช่องโหว่ที่สำคัญ ซึ่งจะประกาศเป็นเลข CVE เอาไว้แล้ว ทำให้ตรวจสอบภาพรวมๆได้ และตรวจสอบได้ตาม Signature ที่บริษัทเค้ากำหนดมาเท่านั้น

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

  • Kaggle – วิธีการใช้ K-Means บนข้อมูล iris

    ต่อจาก Kaggle – วิธีการใช้ Logistic Regression บนข้อมูล Iris ซึ่งเป็น Machine Learning แบบ Supervised Learning

    คราวนี้ ลองมาดูว่า ถ้า เราไม่รู้ว่า ข้อมูลแบบออกเป็นกี่กลุ่ม จะให้ Machine แบ่งกลุ่มได้อย่างไร หนึ่งในวิธีที่ได้รับความนิยมคือ K-Means Clustering

    มีคลิป ที่อยากให้ลองชม เพื่อความเข้าใจ StatQuest: K-Means Clustering

    เริ่มกันเลย

    1. นำเข้าข้อมูล และ Package ที่ต้องการ
    import pandas as pd
    import numpy as np
    from sklearn.cluster import KMeans
    iris = pd.read_csv('../input/mydata2/4-iris.data')
    data=iris.values
    X=data[:,[0,1]]
    Y = data[:,4]
    
    2. แสดงผลจากข้อมูล 2 มิติ ของ Sepal Length กับ Sepal Width จำแนกสีของจุดที่พลอตตาม Species
    import matplotlib.pyplot as plt
    # Truth
    label = set(iris['species'])
    for i in label:
    	species=iris[iris['species']==i]
    	plt.scatter(species['sepal_length'], species['sepal_width'])
    plt.show()
    
    ผลที่ได้
    3. จากนั้น ลองใช้ K-Means จำแนก Cluster สมมุติเราไม่รู้ว่ามีกี่ชนิด เริ่มต้นจาก 2 ก่อน
    from sklearn.cluster import KMeans
    kmeans = KMeans(n_clusters=2).fit_predict(X)
    kmeans
    ค่า kmeans จะได้ผลประมาณนี้ (คือ สิ่งที่ Machine จำแนกให้)
    4. นำข้อมูลมา Plot
    c=np.insert(X,2,kmeans, axis=1)
    import matplotlib.pyplot as plt
    # Kmeans Predict
    label = set(kmeans)
    for i in label:    
    	species=c[c[:,2]==i]
    	plt.scatter(species[:,0], species[:,1])
    plt.show()
    ผลที่ได้
    5. ลองปรับค่า n_cluster=3
    from sklearn.cluster import KMeans
    kmeans = KMeans(n_clusters=3).fit_predict(X)
    kmeans3
    ผลที่ได้
    5. ลองปรับค่า n_cluster=4
    from sklearn.cluster import KMeans
    kmeans = KMeans(n_clusters=4).fit_predict(X)
    kmeans3
    ผลที่ได้

    จะเห็นได้ว่า K-Means สามารถแบ่งกลุ่มของข้อมูลได้ โดยไม่ต้องอาศัย Label แต่ความถูกต้องอาจจะไม่มากนัก เหมาะสำหรับข้อมูลจำนวนมาก ๆ ที่ต้องการทราบว่า มีการกระจายตัวอย่างไรในเบื้องต้น

    ในเบื้องต้น ก็ขอให้ทราบถึง วิธีการใช้งานคร่าว ๆ ง่าย ๆ ก่อนครับ

  • วิธีเอา Boxbe ออกไปจากชีวิตของคุณ

    Boxbe เป็น Free Service ที่พยายามจะจัดการกับ Spam โดยอยู่บนสมมุติฐานว่า ผู้ที่ไม่อยู่ใน Contact ของเรา หรือ อยู่ใน Guest List นั้น มีแนวโน้มจะเป็น Spam เมื่อมีการส่ง email จากกลุ่มนี้ ก็จะถูกเอาไปอยู่ในกล่องที่เป็น Wait List จึงทำให้กล่อง Inbox ซึ่งเราจะอ่าน email เป็นประจำนั้น มาจากคนที่อยู่ใน Contact เท่านั้น

     

    โดยความตั้งใจ ดูดี แต่ …

     

    คนใน Contact ของเรา เป็น Subset ของ email universe ที่เราจะต้องติดต่อด้วย สำหรับคนที่ไม่ได้ทำธุรกิจติดต่อกับคนที่ไม่เคยรู้จักมาก่อน หรือติดต่อเฉพาะคนในองค์กร ก็พอจะไปได้ แต่ในความเป็นจริง ไม่ใช่ทุกคนที่ต้องการอย่างนั้น

    อีกปัญหาหนึ่งคือ ก่อนหน้านี้ เมื่อมีคนที่ไม่ได้อยู่ใน Contact ของเราติดต่อมา สิ่งที่ Boxbe ทำคือ ส่ง email ตอบกลับไปยังผู้ส่ง ว่า “email ของคุณถูกส่งไปอยู่ใน Wait List” แล้วก็อธิบายด้วยข้อความที่ค่อนข้างสับสน

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

     

    เมื่อคลิก สิ่งที่เกิดขึ้นคือ Boxbe จะพาไปยังหน้า Sign-Up Boxbe (จริง ๆ แล้ว ปุ่มสีน้ำเงิน นั่นก็บอกแล้วว่า เป็นการ Sign-Up) แล้วก็ของ Permission ในการ “Read, send, delete and manage your email”

    และแน่นอน ผู้ใช้ก็กด Allow เป็นธรรมดา หลังจากนั้น …. คุณก็เป็นสมาชิกของ Boxbe ไปโดยไม่รู้ตัว และเกิดปฏิกิริยาลูกโซ่ตามมา คือ คนที่ส่ง email ถึงคุณก็จะได้รับข้อความตอบกลับจาก Boxbe และ คนเหล่านั้นก็ทำอาการเดียวกับคุณ 5555 เข้าใจตรงกันนะ

     

    เอาเป็นว่า มาดูวิธีเอา Boxbe ออกจากชีวิตดีกว่า

    1. อันดับแรก ให้ไป Delete Boxbe Account ก่อน โดยไปที่ https://www.boxbe.com/ แล้วคลิกที่ Sign In หรือ ถ้า Login ค้างอยู่ให้คลิกที่ Dashboard
    2. จากนั้น คลิก Disable Account
    3. แล้วพิมพ์คำว่า Yes แล้วคลิกปุ่ม Close Forever

    ยัง …. ไม่ยังไม่ตาย เพราะตอนที่ Sign Up นั้น เราไปอนุญาตให้ Boxbe เชื่อมต่อกับ Account ของเรา ในตัวอย่างนี้ เป็นกรณีของ Gmail

    1. ไปที่ https://myaccount.google.com/permissions เราจะเจอ Boxbe นั่งยิ้มหวานอยู่
    2.  บรรจงคลิก Boxbe แล้วคลิก Revoke Access
    3. แล้วก็คลิก OK

     

    จบจ้า

     

  • Google Colab – เมื่องานด้าน Data Science ต้องทำงานร่วมกัน

    ก่อนหน้านี้ ได้กล่าวถึง Kaggle

    ในบทความนี้ จะกล่าวถึง Google Colab หรือ ชื่อเต็มคือ Colaboratory ของ Google ซึ่งก็เป็น Jupyter Notebook บน Cloud เช่นกัน แต่มีจุดเด่นเรื่อง การทำงานร่วมกัน ในสไตล์ Google Drive

    1. เริ่มต้นใช้งานได้ที่ https://colab.research.google.com/
    2. อันดับแรกคือ ถ้าอยากเรียนรู้เรื่อง Machine Learning และอยากได้ตัวอย่างเจ๋ง ๆ ไปดูจาก Seedbank (https://tools.google.com/seedbank/)

      มี tensorflow พร้อมใช้งาน ใช้งานร่วมกับ GitHub และ มี Visualization ด้วย matplotlib (แปลกตรงไหน ?)

    3. จุดเด่นคือ สามารถสร้าง Form ได้ !!!

    4. ที่เด่นสุดคือ สามารถใช้ไฟล์จาก Google Drive ได้ !!! เป็นประโยชน์มาก โดยเฉพาะกับมหาวิทยาลัยที่ได้ใช้บริการ G Suite for Education อย่าง ม.สงขลานครินทร์ เพราะ เราจะสามารถใช้พื้นที่ได้ Unlimited !

      แต่!!! สุดท้ายก็มาติดตรงที่ Google Colab นี้ เป็น VM อยู่ใน Google Compute Engine นั่นแหล่ะ แต่เค้าไม่คิดค่าบริการกับเรา ซึ่งของฟรี ก็มีข้อจำกัดอยู่คือ
      พื้นที่
      Google Colab ให้ประมาณ 400 GB

      แต่อย่างน้อย ก็สามารถเชื่อมต่อเอาข้อมูลจาก Google Drive มาได้ง่าย ก็ดีแล้ว แถม Jupyter Notebook ที่สร้างก็สามารถ Save เก็บไว้ใน Google Drive ได้เลย การส่งผลลัพท์ออกไป Google Drive ก็ง่าย

      ในขณะที่ Kaggle มี Quota การสร้าง Dataset ของตนเองได้ไม่เกิน 20 GB

    5. จะมีข้อจำกัดหน่อย ๆ
      CPU
      ให้แค่ 2 Core

      ตรงนี้ Kaggle ดูดีกว่า เพราะให้ถึง 32 Core
    6. การทำงานร่วมกัน แน่นอน Google ก็คือ Google แชร์แบบที่ใช้บน Google Drive ได้เลย ในขณะที่ Kaggle ก็ทำได้ แต่ดูทำงานแยก ๆ กันอยู่
    7. Google Colab ใช้งานร่วมกับ Google BigQuery ได้

      ตรงนี้แหล่ะ ข้อแตกต่าง ถ้าจะทำงานใหญ่ มีข้อมูลเป็น TB ถ้าไม่สร้าง Hadoop ไม่ว่าจะ On-Primes หรือ บน Google Dataproc ก็จะต้องบริหารจัดการในระดับหนึ่ง แต่นี่เรียกตรงจาก Google BigQuery ได้เลย นับว่าดีมาก
    8. มี Widget ทำให้ Jupyter Notebook กลายเป็น Interactive BI ย่อย ๆ ได้
    9. และ ใช้ GPU ได้ ฟรี !!! แต่ต่อเนื่อง 12 ชั่วโมง ถ้าจะใช้นานกว่านั้น ต้องไปใช้ Google Datalab แทน
    10. จากที่ลองใช้มา ก็สะดวกดี

    ลองกันต่อไป

  • วิธีการทำ Group ซ้อน Group ให้สามารถส่งผ่านได้ไปถึงสมาชิกระดับล่างสุด ใน Google Groups

    มีคำถามมาว่า ใช้ Google Groups เช่น all-staffs ซึ่ง มี สมาชิกในนี้เป็น Google Groups ด้วย ชื่อ faculty01, faculty02, faculty03

    แล้ว ภายใต้ faculty01 มี department01, department02 ซึ่ง department01 นั้น จะประกอบด้วย email ของสมาชิก โดยทุก Group ตั้งค่าไว้ว่า ให้เฉพาะ Owner และ Manager เท่านั้นที่มีสิทธิ์ส่ง

    แล้ว … จะทำอย่างไร ให้เมื่อมีคน (ที่ได้รับอนุญาตให้ส่ง) สมมุติชื่อ somchai.jaidee@gmail.com ส่งเข้า all-staffs@groups.google.com แล้ว ผู้รับ ซึ่งอยู่ใน department01 สามารถรับ email ได้ ???

    วิธีการคือ ให้เพิ่ม email address ของ Group ที่เป็น Parent ลงไปใน Child Group เช่น ในที่นี้ เพิ่ม all-staffs@groups.google.com ลงไปเป็นสมาชิกของ faculty01 Group แล้วตั้งค่าให้ Email Delivery เป็น No email และ Posting Permission เป็น Override : member is allowed to post

    และ ทำเช่นนี้กับ faculty02, faculty03 …
    ส่วน department01, department02 ก็ให้เอา faculty02@groups.google.com ไปเป็นสมาชิก และตั้งค่าแบบนี้เช่นกัน

     

  • From LAB to Production – จาก Machine Learning Model สู่ Flask RESTful

    จาก Kaggle – วิธีการใช้ Logistic Regression บนข้อมูล Iris เราได้ Model มาแล้ว แต่ จะนำสู่ Production ได้อย่างไร ?

    ใน Python มี Object Serialization ทำให้สามารถเก็บ Object ที่สร้างขึ้น ไปไว้ในไฟล์ ซึ่ง มีให้ใช้หลายตัว ได้แก่

    1. pickle
    2. cpickle
    3. joblib

    มีคนทำการทดสอบความเร็ว พบว่า cpickle เร็วสุด (https://stackoverflow.com/questions/12615525/what-are-the-different-use-cases-of-joblib-versus-pickle) แต่ในที่นี้ จะใช้ joblib เพราะน่าจะเหมาะกับงานที่ต้องมีการ Load Data ขนาดใหญ่ ใช้งานร่วมกันหลาย Process (เท่าที่เข้าใจครับ)

    การสร้างไฟล์ .pkl บน kaggle ดังนี้

    1. เพิ่มคำสั่งต่อไปนี้ แล้ว กดปุ่ม commit and run ด้านบนขวา
      from sklearn.externals import joblib
      joblib.dump(model, 'myiris.pkl')
    2. กดปุ่ม รูป << ด้าน ซ้ายบน เพื่อกลับไป หน้า Kernel ของเรา คลิกที่ Output จะเห็นไฟล์ ที่เพิ่งสร้าง ให้คลิก Download ไปเก็บไว้ใน Folder ที่จะใช้งาน Productioin

    ต่อไป จะเป็นขั้นตอนการติดตั้ง และการใช้ Flask ซึ่งเป็น Python Microframework  และ ใช้ Flask RESTful เพื่อสร้าง REST API

    1. ใช้คำสั่งต่อไปนี้ ติดตั้ง flask และ flask-resetful
      pip install flask flask-restful
    2. จากนั้น เข้าไปใน folder ที่เราวางไฟล์ myiris.pkl ไว้ แล้ว สร้างไฟล์ iris.py มี Code ดังนี้
      from flask import Flask, request
      from flask_restful import Resource, Api, reqparse
      from sklearn.externals import joblib
      import pandas as pd
      #from sklearn.linear_model import LogisticRegression
      
      app = Flask(__name__)
      api = Api(app)
      
      # Model
      model = joblib.load('myiris.pkl')
      class Iris(Resource):
          def get(self):        
              return { "greeting":"Hello From IRIS Dataset"}
          def post(self):
              parser = reqparse.RequestParser()
              parser.add_argument('sl')
              parser.add_argument('sw')
              parser.add_argument('pl')
              parser.add_argument('pw')
              args = parser.parse_args()        
              x = pd.DataFrame([[ args['sl'],args['sw'], args['pl'],args['pw'] ]] ,\
                  columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'])
              result = model.predict(x)
              return {"result": result[0]}, 201
      api.add_resource(Iris, "/iris")
      app.run(debug=True)
      
    3. จากนั้น ไปที่ Command Prompt พิมพ์คำสั่งต่อไปนี้ เพื่อเรียก Flask ขึ้นมาทำงาน โดยรับ Request ที่ Port 5000
      python iris.py

      ได้ผลดังนี้

    4. หากใช้ Web Browser ติดต่อไปยัง http://localhost:5000/iris จะได้ผลดังนี้
    5. แต่ถ้าใช้ Postman ติดต่อไปยัง http://localhost:5000/iris แล้วส่งตัวแปร ความกว้าง ความยาว ของกลีบดอก ผ่าน POST ไป จะได้ผลการ Classification มาว่าเป็น Species อะไร ดังนี้
    6. จากตัวอย่างนี้ แสดงให้เห็นว่า เราสามารถสร้าง Model จากข้อมูลขนาดใหญ่ แล้วนำออกมาเป็น Pickle แล้วใช้ Flask RESTFul เพื่อรับ Request แล้วตอบกลับเป็น ผลการ Classification ได้ หรือ Prediction ต่าง ๆ ได้

    เดี๋ยวค่อยมาลงรายละเอียดเรื่อง วิธีการใช้งาน Flask และ การใช้ Machine Learning แบบต่าง ๆ กัน

  • Kaggle – วิธีการใช้ Logistic Regression บนข้อมูล Iris

    ข้อมูล Iris Dataset มักจะใช้ในการเริ่มต้นศึกษาการใช้งาน เครื่องมือทาง Data Science โดยเฉพาะ Classification เพราะไม่ซับซ้อน มี 4 ฟิลด์ ที่ใช้เป็น Features และมี 1 ฟิลด์ ที่จะเป็น Class (มี 3 Categories)

    1. เริ่มจาก New Kernel
    2. ในที่นี้ เลือก Notebook
    3. จากนั้น เลือก Add Dataset จากที่เค้ามีให้ หรือ จะ Upload ขึ้นไปก็ได้
    4. จากนั้น ข้อมูลของเราจะมาอยู่ที่  ../input/ ในกรณีเรามีไฟล์ ../input/iris.data
      จาก Code ที่ให้มาในเบื้องต้น ให้กดปุ่ม Shift+Enter หรือ กดเครื่องหมาย Run ด้าน ซ้ายมือ ก็จะได้ผลดังนี้
    5. จากนั้น มาเขียน Code กัน เริ่มจาก Import Package ที่ต้องใช้
      import pandas as pd
      import numpy as np
      import seaborn as sns
      import matplotlib.pyplot as plt
      %matplotlib inline
    6. สร้างตัวแปร iris อ่านข้อมูลจากไฟล์
      iris = pd.read_csv('../input/iris.data')
    7. สำรวจข้อมูลเบื้องต้น
      iris.head()
      iris.info()
      iris.describe()
    8. ลองทำ Data Visualization เบื้องต้น ด้วย pairplot แยกตามสีของ species
      sns.pairplot(iris, hue='species')

      หรือ จะดูเป็น scatterplot

      plt.scatter(iris['sepal_length'], iris['sepal_width'], marker='.', color='r')
      plt.xlabel('Sepal Length')
      plt.ylabel('Sepal Width')

    9. ต่อไป เป็นขั้นตอนการแบ่งข้อมูลออกเป็น 2 ส่วน สำหรับ Train และ Test
      from sklearn.model_selection import train_test_split
      X = iris.drop(['species'], axis=1)
      Y = iris['species']
      X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size=0.3)
    10. จากนั้น Train Model
      from sklearn.linear_model import LogisticRegression
      model = LogisticRegression()
      model.fit(X_train, y_train)

    11. แล้วก็ ตรวจสอบความแม่นยำ Model Evaluation
      prediction = model.predict(X_test)
      from sklearn.metrics import confusion_matrix, classification_report, accuracy_score


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