Tag: machine learning

  • python #03 – Train/Validation/Test and Accuracy Assessment with Confusion Matrix

    ต่อจาก python #02 – ติดตั้ง Tensorflow และ Keras ซึ่งกล่าวถึง ขั้นตอนการสร้าง Model และ วาง Layers ต่าง ๆ ของ Keras รวมไปถึง การใช้ model.summary() เพื่อแสดงโครงสร้าง Neural Network ที่สร้างขึ้นมาแล้ว

    ต่อไป เป็นการ นำข้อมูลมาแบ่งเป็นชุด สำหรับ Train/Validate/Evaluate

    การแบ่งข้อมูล

    สมมุติมีข้อมูล ที่อาจจะมาจาก CSV File ซึ่งมี field 0 – 9 คือ ตัวแปรต้น หรือ ที่มักเรียกว่า Features และ มี field 10 เป็น ตัวแปรตาม หรือ ที่เรียกว่า Label

    ทำการแบ่งข้อมูล เป็น X และ y
    (วิธีการ Slice ข้อมูล จะเป็นรูปแบบ data[ row, column])

    ก่อนนำไปใช้ ต้องแปลง y ให้เป็น One-Hot Encode ซึ่ง Keras เองมีเครื่องมือให้อยู่แล้ว

    การแบ่งข้อมูลเป็น Train/Test สามารถทำได้หลายวิธี แต่วิธีหนึ่งที่ง่ายและสะดวก คือ ใช้ train_test_split จาก Scikit Learn ในตัวอย่างนี้ มีข้อมูลตัวอย่างน้อย คือ เพียง 5 samples จึงแบ่งสัดส่วน Test Size = 0.3 หรือ 30%

    การสร้าง Model

    สมมุติ เราออกแบบ Neural Network ตามภาพ กล่าวคือ มี Input Layer จำนวน 10 Nodes และ มี Hidden Layers เป็น Dense 2 ชั้น จำนวน 8 และ 5 Nodes ตามลำดับ โดยมี Activation Function เป็น Relu จากนั้น ส่งไปยัง Output Layer ที่มี 3 Nodes ใช้ Activation Function เป็น Softmax เพราะจะเป็น Categorial Classification

    และ ใช้ Code ตามนี้ แล้ว Compile โดยใช้ Loss Function เป็น Categorical Crossentropy, Optimizer เป็น Adam ที่ Learning Rate 0.001 (เลือกจะตั้งค่าหรือไม่ก็แล้วแต่กรณี) และกำหนด Metrics เป้น Accuracy

    การ Training

    ใช้คำสั่ง fit ในการ train โดยกำหนด X_train คือข้อมูลสำหรับการสอนโมเดล และ y_train เพื่อให้โมเดลเปรียบเทียบว่าต่างจากผลที่คำนวณแค่ไหน (ผ่าน Loss Function) จากนั้นจึงทำการ Adjust Weights กลับมา (ผ่าน Optimizer) ในกระบวนการ Backpropagation
    ในตัวอย่างนี้ ตั้งค่า epochs หรือ จำนวนรอบที่จะ Train และ batch_size เพื่อกำหนดว่า จะให้ใช้ X_train ครั้งละกี่ sample ส่วน verbose ใช้สำหรับกำหนดระดับการแสดงผล 0 คือ แสดงทุกกอย่าง 2 คือแสดงแค่สรุป 2 บรรทัด เป็นต้น

    ในการ Train โมเดล สามารถกำหนด validation_data หรือ ข้อมูลที่ใช้ในการตรวจสอบความแม่นยำของโมเดล ระหว่างการ Train ได้ โดยอาจจะแยกข้อมูลสำหรับ Validation ออกมาต่างหากก็ได้ หรือ จะใช้ X_test, y_test ก็ได้ หรือ จะใช้ข้อมูลใน X_train, y_train แบ่งออกมา โดยการตัังค่า validation_split ก็ได้เช่นกัน

    นอกจากนั้น หากข้อมูลมีความไม่สมดุลย์ของคลาส (Imbanace Classes) ก็สามารถกำหนด class_weight ให้แต่ละ Class ได้ เพื่อให้โมเดลปรับความสมดุลย์เพิ่มเติมได้ และกำหนดการสลับลำดับ (Shuffle) ได้

    ส่วน Callbacks ใช้สำหรับเชื่อมต่อกับ Tensorboard ซึ่งจะกล่าวต่อไปบทความหลังจากนี้

    การ Evaluate ความแม่นยำ

    จะใช้ evaluate() สำหรับทดสอบความแม่นยำของโมเดล

    แสดงผลในรูปของ Graph

    ต้นแบบมาจาก

    https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/

    ดูไอเดียนะครับ ยัง Overfit และการ Learning ยังไม่ไดี (แหะ ๆ ข้อมูลน้อย และ เป็นตุ๊กตาเท่านั้น) ที่ควรจะเป็นคือ Accuracy ควรจะค่อย ๆ เพิ่มขึ้น และ Loss ค่อย ๆ ลดลง

    Confusion Matrix

    ต้นแบบจาก SciKit Learn -> Confusion Matrix

    https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html

    วิธีการใช้งาน

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

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

  • Ambari #08 ปรับแต่ง pyspark ให้สามารถใช้งาน spark.ml ได้ ด้วย conda package management

    เราสามารถใช้งาน Spark ในด้าน Machine Learning ด้วย pyspark แต่ปัญหาอยู่ที่ว่า python ที่ติดตั้งบน Ubuntu 14.04 นั้น ไม่มี package ที่จำเป็นต้องใช้ ได้แก่ numpy, scipy, scikit-learn, matplotlib ซึ่งขั้นตอนการติดตั้ง ก็จะยุ่งยาก เพราะต้อง compile code เองด้วย

    แต่ปัจจุบัน มีเครื่องมือที่เรียกว่า “conda” ทำหน้าที่ติดตั้ง package ที่ต้องการได้สะดวก ในที่นี้ จะเลือกใช้ python 2.7 และ จะติดตั้งลงไปใน /opt/conda

    ขั้นตอนการติดตั้ง conda

    1. ไปเลือก setup script จาก https://conda.io/miniconda.html
    2. ในการนี้ ขอให้ทำในสิทธิ์ของ root
      sudo su
      cd
    3. Download script
      wget https://repo.continuum.io/miniconda/Miniconda2-latest-Linux-x86_64.sh
    4. จากนั้น ใช้คำสั่งต่อไปนี้ เพื่อติดตั้ง conda ลงไปใน /opt/conda และ เลือกใช้ค่า default
      bash Miniconda2-latest-Linux-x86_64.sh -p /opt/conda -b
    5. ติดตั้ง scikit-learn package ซึ่งจะติดตั้ง package อื่นๆที่จำเป็นสำหรับ spark.ml เข้ามาด้วย
      /opt/conda/bin/conda install scikit-learn -y
    6. ทำขั้นตอน 3-6 กับ “ทุกๆ node” ใน Hadoop Cluster

    ต่อไปตั้งค่า Zeppelin ให้สามารถใช้งาน conda แทน python เดิม

    1. เปิด Zeppelin ขึ้นมา
    2. คลิก Interpreter > ค้นหา spark

      แล้วคลิก edit
    3. จากนั้น หาเลื่อนหาค่า pyspark.python แล้วแก้ไขเป็น /opt/conda/bin/python แล้วคลิก save
    4. จากนั้นก็จะสามารถใช้งาน spark.ml ได้แล้ว
  • Machine Learning #01 – Python with iris dataset

    ในบทความนี้ จะแนะนำวิธีการสร้างกระบวนการ Machine Learning ด้วย Python โดยใช้ iris dataset ตั้งแต่การโหลดข้อมูล, สร้าง  Model,  Cross Validation, วัด Accuracy และการนำ Model ไปใช้งาน

    เพื่อความสะดวกในการเรียนรู้ เราจะเลือกใช้ Anaconda ซึ่งเป็น Python Data Science Platform ซึ่งจะรวบรวมเครื่องมือ และ Library ที่จำเป็นต่อการพัฒนา โดยสามารถเลือก Download รุ่นที่เหมาะกับระบบปฏบัติการของท่านได้ที่ https://www.anaconda.com/download/

    สามารถ Clone Repository ตัวอย่างทั้งหมดที่กล่าวถึงในบทความนี้ได้จาก https://github.com/nagarindkx/pythonml

    และ แนะนำให้ใช้งาน jupyter-notebook เพื่อสะดวกในการเรียนรู้

    บทความนี้ใช้ Notebook: 01 – SVM with iris dataset.ipynb

     

    เริ่มจาก import dataset “iris” จาก SciKit

    ซึ่งเป็น dataset ตัวอย่างทีดี ในการสร้างระบบ Predict ชนิดของดอกไม้ จากการป้อนค่า ความกว้างและความยาวของกลีบดอก Iris (รายละเอียดอ่านได้จาก https://en.wikipedia.org/wiki/Iris_flower_data_set) ซึ่งเป็นการวัดความกว้าง และ ความยาวของกลีบดอก ของดอก “iris” (sepal width, sepal length, petal width, petal length) ใน 3 Spicy

    Image Source: https://en.wikipedia.org/wiki/Iris_flower_data_set

    ชุด iris dataset นี้ มักจะใช้ในการเริ่มต้นเรียนรู้ กระบวนการสร้าง Machine Learning เพื่อการ Classification โดยในตัวอย่างนี้จะใช้ Support Vector Machine (SVM) โดยเมื่อสร้างและ Train Model เสร็จแล้ว สามารถนำ Model นี้ไปใช้ในการ จำแนก Species ได้ โดยการระบุ ความกว้างและความยาวดังกล่าว แล้วระบบจะตอบมาได้ว่า เป็น Species ใด

    ในการเริ่มต้นนี้ เราจะใช้ iris dataset ที่มาพร้อมกับ SciKit  (sklearn) ซึ่งเป็น Machine Learning Package ในภาษา Python (ซึ่งติดตั้งมาในชุดของ Anaconda เรียบร้อยแล้ว)

    นำเข้าข้อมูล

    from sklearn import datasets
    iris = datasets.load_iris()

    สำรวจข้อมูล

    print(iris.data)
    print(iris.target)
    print(iris.data.shape)
    print(iris.target.shape)

    ใช้งาน SVM (Support Vector Machine)

    สร้าง SVC (Support Vector Classification) เพื่อทำการ Training ด้วยคำสั่ง fit โดยใส่ค่า data และ target ลงไป

    from sklearn import svm
    clf = svm.SVC()
    clf.fit(iris.data, iris.target)
    

    ผลที่ได้คือ

    SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
      decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
      max_iter=-1, probability=False, random_state=None, shrinking=True,
      tol=0.001, verbose=False)

    ทดลองทำการ Predict

    ด้วยคำสั่ง predict แล้วใส่ Array ข้อมูลลงไป

    print(clf.predict([[ 6.3 , 2.5, 5., 1.9]]))

    ซึ่งระบบจะตอบออกมาเป็น

    [2]

    ต้องการแสดงผลเป็นชื่อของ Target

    ต้องทำในขั้นตอน fit ดังนี้

    clf.fit(iris.data, iris.target_names[ iris.target])
    print(clf.predict([[ 6.3 , 2.5, 5., 1.9]]))

    ผลที่ได้คือ

    ['virginica']

    ทำการ Cross Validation

    โดยแบ่งข้อมูลเป็นสองส่วน คือ ส่วน Train และ Test ทั้ง X และ Y จากนั้น ใช้ Function “fit” ในการ Train

    from sklearn.model_selection import train_test_split
    x_train,x_test,y_train, y_test = train_test_split( iris.data, iris.target, test_size=0.4 , random_state=0)
    
    print(x_train.shape, x_test.shape, y_train.shape, y_test.shape)
    
    clf.fit(x_train, y_train)

    ผลที่ได้คือ

    (90, 4) (60, 4) (90,) (60,)
    SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma='auto', kernel='rbf', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False)

    ทดสอบความแม่นยำ

    ด้วยการ นำข้อมูลส่วน Test ไปทดสอบใน Model ด้วย Function “score”

    print(clf.score(x_test, y_test))

    ผลที่ได้คือ

    0.95

    นำ Model ที่สร้างเสร็จไปใช้ต่อ

    ใช้กระบวนการ pickle หรือ serialization

    import pickle
    pickle.dump(clf, open("myiris.pickle","wb"))

    ซึ่ง ก็จะได้ไฟล์ “myiris.pickle” สามารถนำไปใช้งานต่อได้

    ในบทความต่อไป จะกล่าวถึง การนำ Model นี้ไปใช้งานผ่าน django REST Framework