Tag: keras

  • 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



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

  • 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

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

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

  • python #02 – ติดตั้ง Tensorflow และ Keras

    ต่อจาก python #01 – ติดตั้ง jupyter notebook บน Windows

    ต่อไปเราจะใช้ Machine Learning Library “Tensorflow” และใช้ “Keras” ซึ่งเป็น High-level Neuron Network API ซึ่งจะไปเรียกใช้ Backend คือ Tensorflow อีกชั้นหนึ่ง

    จาก jupyter notebook ทำตามขั้นตอนต่อไปนี

    1.  คำสั่งต่อไปนี้ เพื่อติดตั้ง Tensorflow

    ! pip install tensorflow

    2.  คำสั่งต่อไปนี้ เพื่อติดตั้ง Keras

    ! pip install keras

    จะได้ผลประมาณนี้

    สร้าง Neural Network ด้วย Keras

    เริ่มจาก import ส่วนต่าง ๆ ได้แก่ Models และ Layers

    import keras
from keras.models import Sequential
from keras.layers import Input, Dense

    สมมุติเราจะสร้าง Model แบบนี้

    model = Sequential([
    Dense(8, activation='relu', input_shape=(10,), name="Hidden_Layer_1"),
    Dense(5, activation='relu', name='Hidden_Layer_2'),
    Dense(3, activation='softmax' , name='Output_Layer')
])

    เสร็จแล้วก็ต้อง compile ตั้งค่า Hyperparameters ต่าง ๆ

    model.compile( loss='categorical_crossentropy',
    optimizer=keras.optimizers.adam(lr=0.001),
    metrics=['accuracy'])

    ดู Summary

    model.summary()

    ได้ผลประมาณนี้