Category: Machine Learning

  • python #07 Sentiment Analysis – IMDB

    ต่อจาก python #06 – Sentiment Analysis ด้วย Keras + Tensorflow เนื่องจากเรา Train โมเดล ด้วย ประโยคเพียง 9 ประโยค ซึ่งประกอบด้วยคำ 19 คำ เมื่อถูกทดสอบด้วยคำที่ “ไม่เคยเจอมาก่อน” ก็จะไม่สามารถวิเคราะห์ได้ถูกต้องนัก ยิ่ง ถ้าเจอกับประโยคที่ ไม่มีคำที่เคยเจออยู่เลย ก็จะได้ Zero Vector ไปเลย (ในทางเทคนิค สามารถตั้งค่าห้ Unknown Word มี Index = 1 ได้)

    แก้ไขอย่างไร ?

    ตอนนี้ เปรียบเหมือนโมเดลเป็นเด็กเล็ก รู้จักคำแค่ 19 คำ พอมีคำใหม่ ๆ มาก็จะไม่เข้าใจ วิธีการคือ ต้องสอนคำใหม่ ๆ และรูปแบบประโยคใหม่ ๆ ให้เค้า … แล้วจะหามาจากไหนหล่ะ ??

    IMDB Movie reviews sentiment classification

    เป็น Dataset การรีวิวภาพยนต์ 25,000 รายการ มี Label เป็น Positive/Negative รายละเอียดตามนี้

    https://keras.io/datasets/#imdb-movie-reviews-sentiment-classification

    เริ่มต้นใช้งาน

    [ดู Jupyter Notebook ]

    ทำตามตัวอย่างของ Keras ซึ่งมีข้อสังเกตว่า oov_char หรือ เมื่อเจอคำที่ไม่เคยรู้จักมากก่อน (Out-Of-Vocab) จะแทนค่าด้วย 2 และ index_from เริ่มจาก 3 (0,1 จะไม่ใช้ ส่วน 2 แทนคำที่ไม่รู้จัก ดังนั้น index แรกของคำที่ใช้คือ 3) จะเป็นคำที่พบ “มากที่สุด” ไล่ตามลำดับไป (ยิ่งตัวเลข index มาก ยิ่งมีการใช้น้อย)

    สำรวจข้อมูล

    พบว่า ถ้าเอาคำทั้งหมดจากรีวิวทั้งหมดมา จะมีคำทั้งหมด 88,584 คำ และ ประโยคที่มีความยาวสูงสุดคือ 2,494 คำ

    Idea of Reverse IMDB word index Source: Source: https://jamesmccaffrey.wordpress.com/2018/04/27/inspecting-the-imdb-dataset-reverse-mapping-the-index-values/imdb_review_index_to_words/

    แล้ว ส่วนใหญ่รีวิวจะมีความยาวกี่คำ ?
    Idea จาก http://www.awesomestats.in/python-dl-imdb-classification-1/

    ถ้าเอา ค่า Mean + 2 SD ก็จะพบว่า ความยาวประมาณ 591 คำ

    ข้อมูลจะอยู่ในรูป Sequence หรือ Vector of Integer แล้ว

    ต่อไป ก็ Pad ข้อมูล และ Truncate ให้อยู่ในความยาวที่กำหนด (ในที่นี้คือ most_sentence_len = 591)

    ข้อมูลหน้าตาประมาณนี้

    แบบที่ 1 ใช้ข้อมูลทั้งหมด

    ทดลองใช้ คำทั้งหมดในจากข้อมูล IMDB (88,584 คำ) และ ใช้ความยาวประโยค 591 คำ

    ผลที่ได้ ไม่ค่อยดี

    แบบที่ 2

    กำหนดให้ Vocab ที่รู้จัก เป็น 500 คำแรกที่ใช้มากที่สุด และกำหนดความยาวประโยคสูงสุด 100 คำ


    ผลที่ได้ ดูดีขึ้น
    (สังเกต Param ใน Embedding Layer = 16,000 และ เวลที่ใช้ต่อ Epoch ประมาณ 60-70 วินาที)

    วัด Accuracy ตอน Train ได้ 76.86% โดย Test Dataset ประมาณ 76.79% ก็ถือว่า พอดี

    แบบที่ 3

    กำหนดให้ Vocab ที่รู้จัก เป็น 50,000 คำแรกที่ใช้มากที่สุด และกำหนดความยาวประโยคสูงสุด 100 คำ

    ผลที่ได้ ดูดีขึ้น
    (สังเกต Param ใน Embedding Layer = 1,600,000 และ เวลที่ใช้ต่อ Epoch ประมาณ 80 วินาที)

    ตอน Train ได้ Accuracy ถึง 94.46% แต่ ตอน Test แต่แค่ 78.12% อย่างนี้เรียกว่า “Overfit”

    สรุปคร่าว ๆ

    จะเห็นได้ว่า การสร้าง Deep Neural Network ด้วย Keras นั้น ไม่ยาก แต่การปรับค่า Hyper parameter ต่าง ๆ นี่แหล่ะ เป็นศิลปะ

    หวังว่าจะเป็นประโยชน์ครับ

  • python #06 – Sentiment Analysis ด้วย Keras + Tensorflow

    บทความนี้กล่าวแบบทางเทคนิค ไม่เน้นวิชาการ ทฤษฏีมากนัก

    Sentiment Analysis เป็นตัวอย่างที่ดีของการเริ่มต้นทำงานด้าน NLP (Natural Language Processing) เริ่มจากหาตัวอย่างประโยค (Inputs) และเป้าหมาย (Labels) แยกคำจากประโยค (Tokenization) แปลงให้เป็นตัวเลข (Word Representation) แล้วสอน NN (Train) วัดผล (Test/Evaluate) แล้วนำไปใช้ โดยป้อนประโยคเข้าไป แล้วดูว่า โมเดลของเราจะจัดให้เป็น Labels ใด (ในตัวอย่างนี้จะเป็น Multiclass (Multinomial) Classification)

    ดู Jupyter Notebook

    Input

    สมมุติเรามีตัวอย่างประโยคประมาณนี้
    แบ่งเป็น Positive, Neutral, Negative เพื่อไว้ใส่เพิ่มเติมได้ แล้วเอามารวมกันเป็น data โดยแปลงเป็น Numpy Array เพื่อสะดวกในการ Tokenization ต่อไป

    Tokenization

    ใน Keras มีเครื่องมือให้แล้ว คือ Tokenizer ใน Keras Text Preprocessing fit_on_texts ทำหน้าที่ แปลงข้อมูล “หลาย ๆ ประโยค” จาก data ในคอลัมน์ 0 ให้เป็นคำ ๆ โดยแยกคำด้วย “เว้นวรรค” และกำหนด Index ให้แต่ละคำ (word_index) โดย “เรียงตามความถี่” จะสังเกตุว่า คำว่า i , it อยู่อันดับ 1, 2 ตามลำดับ (และจะเห็นว่า มีการแปลงเป็น lower ทั้งหมด)

    One-hot Encode สำหรับค่า labels

    keras มี to_categorical method ทำหน้าที่เปลี่ยน Integer เป็น One-hot Encode ดังตัวอย่างด้านล่าง ในการแปลงกลับ ใช้ argmax method ของ Numpy

    เตรียมประโยค ให้เป็น Sequence ที่มีความยาวเท่ากัน

    การนำข้อมูลเข้าสู่ NN ต้องเตรียม Array ที่มีขนาดเท่า ๆ กัน ดังตัวอย่าง
    ในที่นี้ใช้ texts_to_sequences แปลง ประโยค ให้เป็น Sequence (Array of Integer)
    จากนั้น หาความยาวของประโยค และหาค่าสูงสูด (maxlen) — มีทั้งข้อดีข้อเสีย
    แล้ว เติมเต็ม (Padding) ให้ทุกประโยค มีความยาวเท่ากัน โดยเติม 0 ข้างท้าย (padding=’post’)

    Word Embeding

    Word Embedding เป็น “หนึ่งในหลายวิธี” ของการแปลง คำ เป็น เวคเตอร์ของจำนวนจริง (vector of real number) จะเห็นได้ว่าตัวแปร x ข้างต้น เป็นจำนวนเต็ม (Integer) มีมิติเดียว ส่วน Word Embedding จะแปลง คำ ๆ นี้ (แทนด้วย) เป็นเวคเตอร์หลายมิติตามต้องการ (output_dim) โดยคำนวนจาก input_dim=จำนวนคำทั้งหมด (vocab_size) และ input_length=ความยาวของประโยคสูงสุด (maxlen)

    ตัวอย่างต่อไปนี้ แปลง x จำนวน 9 ประโยค เป็น Word Embedding ซึ่งกำหนด input_dim=vocab_size, input_length=maxlen (ในที่นี้คือ 6) และ ต้องการแสดง Word Embedding เป็น Vector 2 มิติ (output_dim=2)

    จะเห็นได้ว่า ผลจาก Word Embedding จะได้ Array ขนาด 9 x 6 x 2 นั่นคือ ได้ เวคเตอร์ของแต่ละคำมี 2 มิติ แต่ละประโยคมี 6 คำ และ มีทั้งหมด 9 ประโยค (ตัวอย่างข้างต้น แสดงตัวอย่างแรก คือ จาก [ 1 8 2 0 0 0] )

    ถ้าลองเปลี่ยน output_dim = 16 จะได้ผลดังนี้

    วิธีการนี้ ทำให้สามารถคำนวณว่า คำใด มีความสัมพันธ์กันขนาดใดได้ เช่น king – man + woman = ?? ซึ่งมนุษย์เราจะตอบว่า queen เป็นต้น

    Source: https://towardsdatascience.com/deep-learning-4-embedding-layers-f9a02d55ac12

    ลองใช้ Flattern และ Dense

    จาก python #03 – Train/Validation/Test and Accuracy Assessment with Confusion Matrix ได้กล่าวถึง Layer แบบ Fully-Connected หรือที่เรียกว่า Dense มาแล้ว ตอนนี้จะเอามาต่อกับ Embedding Layer แต่ เนื่องจาก Dimension ที่ออกจาก Embedding Layer เป็นแบบ 3D จึงต้องนำมาแผ่ หรือที่เรียกว่า Flattern ก่อน

    ผลที่ได้คือ

    ซึ่ง … ดูไม่ดีเลย

    LSTM – Long Short-Term Memory

    ในการทำงานด้าน NLP มี Layer อีกประเภทที่เรียกว่า Recurrent Neural Network (RNN) ซึ่งเหมาะสำหรับงานที่มีลำดับเวลา เช่น ประโยคคำพูดเป็นต้น แต่ RNN พื้นฐานมีปัญหากับการ Train ข้อมูลที่มีความยาวมาก ๆ จึงมีการพัฒนา LSTM และ GRU ขึ้นมา (ขอข้ามรายละเอียด) ต่อไป จะลองนำ LSTM มาแทน Flattern และ Dense

    ผลที่ได้คือ

    ดูดีทีเดียว !!!

    ทดสอบการใช้งาน

    สร้างข้อมูลทดสอบ โดยประกอบไปด้วย คำที่โมเดลเคยเจอ และคำที่ไม่อยู่ใน Dictionary ซึ่งจะถูกแทนด้วย 0 ตามนี้

    ผลที่ได้คือ

    สวยงาม พอรับได้

    หวังว่าจะเป็นประโยชน์ครับ

  • python #05 – การ Save/Load ตัวโมเดลจาก Keras แล้วนำไปใช้ใน Production Server

    ต่อจาก python #03 – Train/Validation/Test and Accuracy Assessment with Confusion Matrix

    เมื่อสร้าง Neural Network Model แล้วทำการ Train/Test ปรับค่า Hyper parameters จนได้ผลเป็นที่พอใจแล้ว (Accuracy และ Confusion Matrix ให้ค่าที่รับได้) ก็สามารถเก็บ Model นี้เอาไว้ใช้งานภายหลัง ไม่ต้องเริ่มต้น Train ใหม่ โดยใช้คำสั่ง

    ก็จะได้ไฟล์ (ตามตัวอย่างนี้) ชื่อ example_model.h5 สามารถนำไปใช้บนเครื่อง Production ได้ โดยเรียกใช้งานด้วยคำสั่ง

    จากนั้น ก็จะสามารถใช้ mode.predict() เพื่อใช้งานได้ตามต้องการ

    ต่อ การสร้าง RESTful API สำหรับใช้งานจริง ง่าย ๆ ด้วย Flask และ Waitress ก็สามารถนำ Model นี้ไป Deploy เป็น RESTful API ได้เช่นกัน โดยเพิ่ม

    # load Model
from keras.models import load_model
model = load_model('example_model.h5')

    และ

    y_predict=model.predict(data)		
result=y_predict.argmax(axis=1)[0]

    จากนั้น ก็สั่ง

    python waitress_server.py

    เพื่อส่งค่าผ่าน Postman ไป ที่ Server ก็จะ Error ว่า

    เหตุ เพราะยังไม่ได้มีการสร้าง Tensorflow Graph ขึ้นมา ดังนั้น ต้องเพิ่มคำสั่งต่อไปนี้

    # Tensorflow Graph
import numpy as np
import tensorflow as tf
graph = tf.get_default_graph()

    และ

    with graph.as_default():
     y_predict=model.predict(np_data)

    จากนั้น restart waitress_server แล้วส่งค่าเข้าไปใหม่

    ก็จะได้การ Prediction แล้ว

    หวังว่าจะเป็นประโยชน์ครับ

  • python #04 – Tensorboard

    เมื่อติดตั้ง Tensorflow ก็จะมี Tensorboard ติดตั้งมาให้แล้ว

    วิธีการใช้งาน ก็แสนง่าย คือ ใน Code เพิ่ม
    (ตั้งชื่อ directory ให้ดี เช่นกรณีนี้ ตั้งชื่อว่า example-logs เป็นต้น)

    from time import time
from  keras.callbacks import TensorBoard
tensorboard = TensorBoard(log_dir="example-logs/{}".format(time()))

    และในส่วนของ fit ให้เพิ่ม callbacks เข้าไป

    callbacks=[tensorboard]

    ดังภาพนี้

    จากนั้นก็ Train ตามปรกติ

    เมื่อต้องการดู Tensorboard ก็เพียงเปิดอีก Terminal หนึ่ง (Command Prompt) ไปที่ Directory ที่มี log อยู่ แล้วใช้คำสั่ง

    tensorboard --logdir=example-logs

    ตัว Tensorboard ก็จะทำงาน อ่าน logs จาก –logdir ที่กำหนด แล้วแสดงผลที่ Port 6006



    แต่รายละเอียดใช้ยังไง ขอศึกษาเพิ่มเติมก่อนครับ แหะ ๆ

  • การสร้าง RESTful API สำหรับใช้งานจริง ง่าย ๆ ด้วย Flask และ Waitress

    จาก From LAB to Production – จาก Machine Learning Model สู่ Flask RESTful ซึ่งได้นำ Machine Learning แบบ Statistical Approach อย่าง Logistic Regression ที่สร้างโมเดล และ Train กับข้อมูลเรียบร้อยแล้ว (บนเครื่อง Development) จากนั้น ได้นำโมเดลออกมาใช้งาน โดยใช้ วิธีการ Serialization ด้วย joblib ในภาษา Python ได้เป็นไฟล์ออกมา แล้วจึงนำไปใช้เพื่อใช้ในการทำนาย (predict) ชนิดของดอก Iris บนเครื่อง Production โดยรับ Input จากผู้ใช้ผ่าน HTTP Protocol ทั้ง GET/POST ที่ TCP/5000

    ตัวอย่างดังกล่าว ยังเป็นเพียงการ “ทดสอบ” แต่ในบทความนี้ จะเป็นวิธีการ ซึ่งนำไปสู่การใช้งานจริง ๆ ซึ่ง Flask แนะนำให้ใช้งานกับ “waitress” (น่าจะเลียนแบบจาก Server) ซึ่งเป็น WSGI (Web Server Gateway Interface) อีกตัวหนึ่ง ใช้งานง่าย เพราะไม่ต้องติดตั้ง Apache/Nginx เลย

    ติดตั้ง waitress

    pip install waitress

    predict.py

    from flask import Flask, request, jsonify
from flask_restful import Resource, Api, reqparse
from flask_cors import CORS

app = Flask(__name__)
# Enable CORS
CORS(app)

@app.route("/predict", methods=["POST"])
def predict():
	result = 0
	if request.method == "POST":    		
		input_value = request.form["input_value"]
		# ประมวลผล
		# ...
		# ตัวอย่างเช่น รับค่ามา แล้ว คูณ 2
		result=input_value * 2
		# ###
	return jsonify(
		prediction=result
	),201

    ไฟล์ predict.py เป็นตัวอย่าง python ซึ่งรับค่า input_value จาก HTML form ผ่าน POST method เข้ามา ที่ /predict ซึ่งเขียนด้วย Flask ที่จะไปเรียกใช้ฟังก์ชั่น prediction() แล้วก็ทำการคำนวณที่ต้องการ จากนั้น ตอบค่ากลับไปเป็น JSON ด้วยฟังก์ชั่น jsonify โดยสามารถกำหนด key ชื่อ prediction และ value เป็น result ที่คำนวณได้ และแจ้ง Response Code เป็น 201

    waitress_server.py

    from waitress import serve
import predict
serve(predict.app, host='0.0.0.0', port=8080)

    ไฟล์ waitress_server.py ก็เพียงแค่ import serve จาก waitress ที่ติดตั้งไป และ import predict ซึ่งก็คือไฟล์ predict.py ข้างต้น (อยู่ในไดเรคทอรีเดียวกัน) จากนั้น ก็เรียก predict.app โดยรับได้จากทุก IP (0.0.0.0) ที่ TCP port 8080

    วิธีใช้งาน

    ก็แค่เปิด Command Prompt (ตัวอย่างนี้ทำบน Windows Server) แล้วใช้คำสั่ง

    python waitress_server.py

    จากนั้น ก็พัฒนา web application หรือ จะใช้ postman ทดสอบติดต่อเข้ามาก็ได้ ที่ http://server-ip-address:8080/predict แล้ว POST ข้อมูลเข้ามา ก็จะได้ผลลัพธ์กลับไปเป็น JSON

    หวังว่าจะเป็นประโยชน์ครับ

  • วิธีตรวจสอบรุ่นของ CPU ว่าสามารถใช้งาน Tensorflow ได้หรือไม่

    ปัญหา

    สร้างเครื่องบน VMWare ESXi รุ่นล่าสุดก็แล้ว ลงเป็น Windows Server 2016 DataCenter ก็แล้ว ตาม Spec ของ Tensorflow (Version ล่าสุด 1.12) บอกว่า ใช้ Python 3.6 ก็ลงแล้ว (ยังใช้กับตัวล่าสุด 3.7 ไม่ได้) 

    ติดตั้ง Tensorflow ก็ลงตามปรกติ

    pip install tensorflow

    ก็สำเร็จเรียบร้อยดี แต่พอลอง import

    import tensorflow

    ปรากฏว่าเกิด Error 
    “Failed to load the native TensorFlow runtime.”

    ทั้ง ๆ ที่ลงบน Physical Server ที่ไม่ใช่ VMWare ก็ใช้งานได้ปรกติ ทำไม ???

    ตั้งสมมุติฐาน

    Hardware มีความแตกต่างอะไร ระหว่าง VMWare กับ Physical Server ?

    รวบรวมข้อมูล

    ไปดู Hardware Requirements พบว่า ตั้งแต่ Tensorflow 1.6 เป็นต้นมา ต้องใช้งานบน CPU ที่มี AVX Instruction

    และจาก 

    https://en.wikipedia.org/wiki/Advanced_Vector_Extensions#CPUs_with_AVX

    บอกว่า CPU ที่มี AVX Instruction คือ เก่าสุด ชื่อรุ่น Sandy Bridge

    แล้ว … เครื่อง Windows Server 2016 DataCenter ที่สร้างบน VMWare นั้น ได้ CPU อะไร ??

    ค้นหาข้อมูล พบว่า Microsoft ให้ใช้เครื่องมือฟรี ที่ชื่อว่า coreinfo (ซึ่งบน Linux ใช้ cpuinfo) สามารถ Download ได้ที่ https://docs.microsoft.com/en-us/sysinternals/downloads/coreinfo

    เมื่อลอง Download มาติดตั้ง และ ใช้คำสั่ง coreinfo ได้ผลว่า เป็นรุ่น Intel Xeon รุ่น E7  – 4870

    ลองไปค้นหาดู ว่า รุ่น E7 – 4870 มี Code Name ว่าอะไร  จาก Intel ได้ความว่า ชื่อรุ่น Westmere ซึ่ง ไม่มี AVX !!!!!

    ไปดูลำดับ Codename จาก 

    https://en.wikipedia.org/wiki/List_of_Intel_CPU_microarchitectures

    พบว่า Westmere เป็นรุ่นสุดท้าย ก่อนจะมีการใส่ AVX นั่นเอง (Sandy Bridge, Ivy Bridge, Haswell … เป็นต้นมา มี AVX หมด)

    สรุปผล

    เครื่องบน VMWare ปัจจุบัน นั้นจะได้ Spec ตาม CPU ตัวต่ำสุดใน Cluster ดังนั้น …. เจ้าจึงได้ Westmere ที่ไม่มี AVX ไปใช้ และ ใช้งาน Tensorflow รุ่นตั้งแต่ 1.6 เป็นต้นมาไม่ได้

    จบข่าว

  • 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 แต่ความถูกต้องอาจจะไม่มากนัก เหมาะสำหรับข้อมูลจำนวนมาก ๆ ที่ต้องการทราบว่า มีการกระจายตัวอย่างไรในเบื้องต้น

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

  • 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 ไหน ทำอะไร อันนี้ต้องมาดูรายละเอียดกันต่อครับ