Category: Cloud Computing

  • 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 ได้อย่างสวยงาม

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

  • 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. จากที่ลองใช้มา ก็สะดวกดี

    ลองกันต่อไป

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

  • Introduction to Kaggle – เรียนรู้การงานด้าน Data Science

    Kaggle เป็นแพลตฟอร์มสำหรับ Predictive Modelling และการแข่งขันด้าน Analytics เพื่อหา Model ที่ดีที่สุดสำหรับ Dataset จากบริษัทและบุคคลทั่วไป [อันนี้ คำอธิบายอย่างเป็นทางการ [1] ]

    กล่าวให้ง่ายกว่านั้น Kaggle เป็นสนามทดลองสำหรับคนที่อยากจะทำงานด้าน Data Science โดย ไม่ต้องนับ 0 จากการติดตั้ง OS, Software โน่นนี่นั่น, Library ต่างๆ แล้วต้อง Configuration ให้ทำงานร่วมกันได้ อีกทั้ง เพียงแค่ สมัคร หรือ Authentication ด้วย Facebook, Google, Yahoo แล้ว สร้าง Profile ของตัวเอง เป็นอันเรียบร้อย หลังจากนั้น เราจะได้ “Kernel” ซึ่งจริง ๆ ก็คือ Virtual Machine ที่พร้อมใช้งาน สเปคเครื่องคือ [2]

    1. 4 CPU
    2. 16 GB RAM
    3. 6 Hours Execution Time
    4. 1 GB of disk space เอาไว้เก็บ Output จากการทำงาน
    5. สามารถใช้ GPU ในการคำนวณได้ด้วย
    6. ติดตั้ง Jupyter Notebook – Interactive Web สำหรับเขียน Code ภาษา Python/R เพื่อวิเคราะห์ข้อมูลได้
    7. สามารถเพิ่ม Collaborator เข้ามาร่วมงานกันได้ด้วย ทั้งในส่วนของ Kernel และ Dataset

    ส่วนต่อไปคือ Dataset ก็จะมีผู้คนทั่วโลกได้ Upload ที่เปิด “Public” ให้พวกเราได้ลองวิเคราะห์กัน รวมถึง เราสามารถนำข้อมูลของเราเอง ขึ้นไปวิเคราะห์ก็ได้ โดยกำหนดให้เป็น “Private” ก็ได้เช่นกัน

    ชนิดของ Dataset ประกอบด้วย

    1. CSV
    2. JSON
    3. SQLite
    4. Archives
    5. BigQuery

    นอกจากนั้น ยังมีส่วนของการเรียนรู้ จาก Learn [3] ให้ศึกษาได้ตั้งแต่ การเขียนโปรแกรมภาษา Python, Machine Learning, Pandas, Data Visualization, SQL, R, Deep Learning

    สรุปคือ จากที่ทดลองทำผิดทำถูกมานานเป็นเวลา 2 ปีกว่า เพื่อ “สร้าง” ระบบของตนเอง (โดยพยายามสร้าง Hadoop Cluster + Spark) และ การศึกษาการเรียนภาษา Python บนเครื่อง Notebook ของตนเอง ซึ่งพบว่า เมื่อมีการประมวลผลหนัก ๆ เครื่อง  Core i5 , 8 GB ก็ยังหน่วง ๆ ไม่ไปไหนมาไหนเลย หลังจากได้ลองใช้ Kaggle ในเวลาไม่นาน ก็เข้าใจ Concept ของ Data Science มากขึ้น

     

    ในบทความต่อ ๆ ไป จะมาแสดงตัวอย่างการใช้งานครับ
    ตอนนี้ ดู Youtube ไปพลาง ๆ

    What’s Kaggle?

    Introduction to Kaggle Kernels

    How to Make a Data Science Project with Kaggle

     

    Reference:

    [1] https://en.wikipedia.org/wiki/Kaggle

    [2] https://www.kaggle.com/docs/kernels

    [3] https://www.kaggle.com/learn/overview

  • การใช้งาน Google Datalab Notebook บน Dataproc เพื่อสร้าง Machine Learning Model เบื้องต้น

    ต่อจาก สร้าง Hadoop และ Spark Cluster เพื่องานด้าน Data Science ด้วย Google Cloud Dataproc + Datalab

    1. จาก Google Cloud Datalab คลิก Notebookแล้ว ตั้งชื่อ Demo01

      เลือได้ว่า จะใช้ Python2 หรือ Python3 ในที่นี้จะเลือก Python3
    2. ตรวจสอบรุ่นของ Spark ที่ใช้งานด้วยคำสั่ง
      spark.version

      แล้วกดปุ่ม Shift+Enter เพื่อ Run

    3. สามารถใช้คำสั่งไปย้ง Shell ซึ่งเป็น Linux ได้ โดยใช้เครื่องหมาย ! นำหน้า
      ในที่นี้ จะ Download iris dataset จาก https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data มาไว้ในเครื่อง mycluster-m ด้วย คำสั่ง

      ! wget https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data

      แล้ว เอาไปใส่ใน HDFS ด้วยคำสั่ง

      ! hdfs dfs -put iris.data /

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

    4. จาก Machine Learning #01 – Python with iris dataset ซึ่งเดิมใช้ sklearn จะเปลี่ยนเป็น Spark MLlib เพื่อใช้ความสามารถของ Spark Cluster ได้ เริ่มต้นจาก Import Library ที่จำเป็นดังนี้
      # Import Libaries
      from pyspark.ml import Pipeline
      from pyspark.ml.evaluation import MulticlassClassificationEvaluator
      from pyspark.ml.classification import LogisticRegression
      from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
      from pyspark.ml.feature import VectorAssembler
      from pyspark.sql.types import *
    5. จากนั้น สร้าง Spark Dataframe (Concept จะคล้ายกับ Pandas แต่มีรายละเอียดที่มากกว่า)
      # get into DataFrame
      csvFile = spark.read.csv('/iris.data', inferSchema=True)
      diz = {"Iris-setosa":"1", "Iris-versicolor":"2", "Iris-virginica":"3" }
      df = csvFile.na.replace(diz,1,"_c4")
      df2 = df.withColumn("label",df["_c4"].cast(IntegerType())) \
      .withColumnRenamed("_c0","sepal_length") \
      .withColumnRenamed("_c1","sepal_width") \
      .withColumnRenamed("_c2","petal_length") \
      .withColumnRenamed("_c3","petal_width") 
      train,test = df2.randomSplit([0.75,0.25])

      เริ่มจาก ให้ spark session (spark) อ่านไฟล์ CSV จาก HDFS /iris.data โดยระบุว่า ให้กำหนด Data Type อัตโนมัติ (inforSchema=True) และไฟล์นี้ไม่มี Header

      Dataset นี้ ประกอบด้วย 5 columns เมื่อ Spark อ่านข้อมูลเข้ามา จะตั้งชื่อ column เป็น _c0, _c1, _c2, _c3, _c4 โดย _c4 จะเป็น label ของชนิดของดอก iris ซึ่งกำหนดเป็น String => Iris-setosa, Iris-vesicolor, Iris-virginica ในการใช้งาน Logistic Regression ขั้นตอนต่อไป ไม่สามารถนำเข้าข้อมูลชนิด String เพื่อไปใช้งานได้ จึงต้องทำการเปลี่ยน จาก “Iris-setosa” เป็น “1” แล้วทำการเปลี่ยน “1” ซึ่งเป็น String ให้เป็น Integer ด้วย ฟังก์ชั่น cast และตั้งชื่อว่า column ว่า “label”

      จากนั้น ทำการเปลี่ยนชื่อ column _c0, _c1, _c2, _c3 เป็นชื่อตามต้องการ

      สุดท้าย ใช้ randomSplit([0.75, 0.25]) เพื่อแบ่งข้อมูลสำหรับ train 75% และ test 25%

    6. ลอง แสดง Schema ดู
      df2.printSchema()

      ได้ผลดังนี้


      และใช้คำสั่งนี้ เพื่อดูข้อมูล

      df2.show()

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

    7. ใน Spark 2.x จะมี Concept ของการใช้ Pipeline เพื่อให้สามารถออกแบบการทดลอง ปรับค่า Meta Parameter ต่าง ๆ ของโมเดล และทำงานอย่างเป็นระบบยิ่งขึ้น (ในขั้นตอนนี้ ขอไม่ปรับค่าใด ๆ ก่อน)
      # Model
      assembler = VectorAssembler(
      inputCols=["sepal_length","sepal_width","petal_length","petal_width"],
      outputCol="features")
      lr = LogisticRegression()
      paramGrid = ParamGridBuilder().build()
      
      #Pipeline
      pipeline = Pipeline(stages=[assembler, lr])

      ในการใช้งาน Logistic Regression ต้องกำหนดค่า field คือ features โดยกำหนดให้มาจาก Column sepal_length, sepal_width, petal_length, petal_width ส่วน label ได้กำหนดในขั้นก่อนหน้าแล้ว

      จากนั้นสร้าง lr เป็น instant ของ LogisticRegression

      ในการปรับค่า Parameter จะมาใส่ใน ParamGridBuilder ซึ่งจะไม่กล่าวถึงในขั้นนี้

      สุดท้าย นำ assembler และ lr มาเข้าสู่ stage วิธีการนี้ทำให้การทำซ้ำขั้นตอนต่าง ๆ ใน Pipeline สะดวกยิ่งขึ้น (ต้องเห็นกระบวนการที่ซับซ้อนกว่านี้ จึงจะเห็นประโยชน์)

    8.  ขั้นตอนสำคัญ  pipeline มาแล้ว ก็ต้องนำมาสร้าง model โดยการ Train ด้วยชุดข้อมูล “train”
      model = pipeline.fit(train)
      predictions = model.transform(train)

      แล้ว นำ model ที่ได้ มาทดลอง predictions ด้วย transform() บนข้อมูล train ผลที่ได้ คือ ผลการ Predict จาก Model

    9. ต่อไป คือ การตรวจสอบว่า Model ที่สร้างขึ้น มีความแม่นยำแค่ไหน ในที่นี้ จะใช้ MulticlassClassificationEvaluator เพราะ label มีมากว่า 2 ชนิด
      evaluator=MulticlassClassificationEvaluator(predictionCol="prediction", labelCol="label")

      แล้วนำ เปรียบเทียบว่า สิ่งที่ predict ได้จาก model

      evaluator.evaluate(predictions)

      ถูกต้องมากน้อยขนาดไหน กับข้อมูล test

      evaluator.evaluate(model.transform(test))
    10. ผลที่ได้ ประมาณนี้
      โดยจะเห็นได้ว่า มีความถูกต้อง 0.9521 … หรือ 95.21% นั่นเอง

     

  • สร้าง Hadoop และ Spark Cluster เพื่องานด้าน Data Science ด้วย Google Cloud Dataproc + Datalab

    จาก Ambari #01: ติดตั้ง Ambari Server , Ambari #02 ติดตั้ง Ambari Agent , Ambari #04 การสร้าง Hadoop ด้วย Ambari บน AWS และ GCP #01 วิธีการสร้าง Virtual Machine บน Google Cloud Platform จะเห็นได้ว่า ก็ยังมีความยุ่งยากอยู่ อีกทั้ง หากต้องการใช้ PySpark ก็ต้องตามติดตั้ง Python Packages ต้องปรับค่ามากมาย และหากต้องการขยายระบบ ก็มีงานต้องทำอีกเยอะ

    ในบทความนี้ จะแนะนำอีกวิธีหนึ่ง คือ การใช้งาน Google Cloud Dataproc ซึ่งจะทำให้เราได้ใช้ Hadoop + Spark Cluster ซึ่งได้รับการทดสอบเป็นอย่างดี อีกทั้งยังสามารถเลือกใช้ Spark รุ่นต่างๆได้อย่างง่ายได้ ทำให้สามารถโฟกัสไปยัง Data และ กระบวนทำ Machine Learning ได้เต็มที่

    1. ไปที่ Google Cloud Console เพื่อเลือก Project ที่จะทำงานด้วย และเปิดช้งาน Cloud Dataproc และ Compute Engine APIs และ ในที่นี้ จะมี project-id คือ kx-dataproc-01 (สามารถสร้างในชื่อที่ต้องการเองได้)
      https://console.cloud.google.com/
    2. เปิดใช้งาน Google Cloud Dataproc
      https://console.cloud.google.com/dataproc/
    3. เปิด GCLOUD COMMAND
    4. ในที่นี้ จะสร้าง Cluster ชื่อ mycluster ใน project-id ชื่อ kx-dataproc-01 แล้วให้ copy คำสั่งต่อไปนี้ลงไปใน gcloud command แล้วกดปุ่ม Enter
      gcloud dataproc clusters create mycluster --project kx-dataproc-01 --initialization-actions gs://dataproc-initialization-actions/datalab/datalab.sh
    5. ใช้เวลาประมาณ 5 นาที ก็จะได้ Hadoop + Spark Cluster ที่มี 1 Master และ 2 Workers
      ซึ่ง Master จะชื่อว่า mycluster-m
      และ Workers จะชื่อ mycluster-w-0 และ mycluster-w-1
    6. ต่อไป ทำ SSH Tunnel จาก Master คือ mycluster-m Port 8080 ออกมา โดยพิมพ์คำสั่งต่อไปนี้
      gcloud compute ssh mycluster-m --project kx-dataproc-01 --zone=asia-southeast1-a -- -4 -N -L 8080:mycluster-m:8080

      โดย
      –project ไว้สำหรับระบุชื่อ project-id
      –zone ไว้ระบุ Zone ที่ Cluster อยู่
      — ไว้เป็นตัวคั่น (separator) ว่าหลังจากนี้เป็นคำสั่งของ ssh
      -4 บอกว่า ติดต่อด้วย IPv4
      -N บอกว่า ไม่ต้องเปิด Shell ของเครื่อง Master
      -L บอกว่า จะ Forward Port 8080 ไปยังเครื่อง mycluster-m ที่ port 8080

    7. จากนั้น เปิด Web Preview on port 8080
    8. ก็จะได้ Google Cloud Datalab ซึ่งติดต่อกับ Hadoop+Spark ที่อยู่บน Google Cloud Dataproc ได้แล้ว

    Reference:

    https://cloud.google.com/dataproc/docs/tutorials/dataproc-datalab

  • ขั้นตอนการติดตั้ง Django ด้วย Python3 บน Windows

    ขั้นตอนการติดตั้ง Django ด้วย Python3 บน Windows

    1. ติดตั้ง Python จาก https://www.python.org/downloads/
    2. เปิด cmd โดย Run As Administrator
    3. ใช้คำสั่ง
      python -m pip install django
    4. ทดสอบโดยใช้คำสั่ง
      python -m django --version
    5. สร้าง Project ด้วยคำสั่ง
       django-admin startproject mysite
    6. เข้าไปใน project “mysite” directory ด้วยคำสั่ง
      cd mysite
    7. ทดสอบ runserver
      python manage.py runserver
    8. เปิด website:
      http://127.0.0.1:8000/

    เดี๋ยวมาต่อเรื่อง การสร้าง App, การใช้ Database, การ Authentication และการสร้าง REST API เพื่อใช้งานกับ OAuth2

  • วิธีใช้ Google Sheets เป็นฐานข้อมูล เพื่อการเฝ้าระวังระบบ โดยการใช้งานผ่าน Google API Client Library for Python

    ต่อจาก

    1. วิธีการใช้ Google Sheets เป็นฐานข้อมูล
    2. การใช้งาน Google Drive API ด้วย Google Client Library for Python
    3. วิธีการ Upload ไฟล์ไปบน Google Drive File Stream ด้วย Google Client Library for Python

    คราวนี้ ใครมีข้อมูลที่เกิดขึ้นในเซิร์ฟเวอร์ภายในองค์กร แล้วต้องการส่งไปเขียนเก็บไว้ใน Google Sheets แบบต่อท้าย (Append)

    เช่น ในตัวอย่างนี้ วัดระยะเวลาการโอนย้ายข้อมูล เปรียบเทียบระหว่าง rsync เพื่อสำรองข้อมูลไปไว้ในเครื่องเซิร์ฟเวอร์สำรองที่ต่างวิทยาเขต กับ การนำไปเก็บไว้ใน Google Drive ตามวิธีการที่กล่าวไว้ใน วิธีการ Upload ไฟล์ไปบน Google Drive File Stream ด้วย Google Client Library for Python

    ผมได้เขียนโค๊ดเอาไว้ที่ https://github.com/nagarindkx/google.git
    สามารถโคลนไปใช้งานได้ (ช่วย Reference กันด้วยนะครับ)

    ขั้นตอนการใช้งานมีดังนี้

    1. ใช้คำสั่ง
      git clone https://github.com/nagarindkx/google.git
      cd google
    2. ติดตั้ง python, pip, google-api-python-client ตามที่เขียนไว้ใน การใช้งาน Google Drive API ด้วย Google Client Library for Python และสร้างโปรเจคใน Google Developer Console เปิดใช้งาน Google Sheets API, สร้าง Credentials > OAuth Client ID แล้ว download JSON มาไว้ในชื่อว่า client_secret.json
    3. รูปแบบคำสั่งคือ
      $ python append2gsheet.py --help
      
      usage: append2gsheet.py [-h] [--auth_host_name AUTH_HOST_NAME]
                                   [--noauth_local_webserver]
                                   [--auth_host_port [AUTH_HOST_PORT [AUTH_HOST_PORT ...]]]
                                   [--logging_level {DEBUG,INFO,WARNING,ERROR,CRITICAL}]
                                    --data DATA --sheetid SHEETID [--range RANGE]
                                   [--value-input-option VALUEINPUTOPTION]
      
      optional arguments:
       -h, --help show this help message and exit
       --auth_host_name AUTH_HOST_NAME
         Hostname when running a local web server.
       --noauth_local_webserver
         Do not run a local web server.
       --auth_host_port [AUTH_HOST_PORT [AUTH_HOST_PORT ...]]
         Port web server should listen on.
       --logging_level {DEBUG,INFO,WARNING,ERROR,CRITICAL}
         Set the logging level of detail.
       --data DATA CSV format
       --sheetid SHEETID Google Sheets ID
       --range RANGE Simply Sheet Name like 'Sheet1!A1'
       --value-input-option VALUEINPUTOPTION
         Optional: [RAW,USER_ENTERED]
    4. สิ่งที่ต้องมี คือ Google Sheets ที่สร้างไว้แล้ว ให้สังเกตที่ URL
      ตัวข้อความที่อยู่หลัง https://docs.google.com/spreadsheets/d/ จะเป็น “Sheet ID” ซึ่งจะใช้ในตัวแปร “sheetid” ในขั้นต่อไป
    5. ในแต่ละ Google Sheets จะประกอบด้วย หลาย Sheet ในที่นี้ จะเขียนลง Sheet ที่ชื่อว่า “Data” ซึ่งจะใช้ในตัวแปร “range” ในขั้นต่อไป
    6. ตัวอย่างการใช้งาน เมื่อระบบทำการสำรองข้อมูล จับเวลา ก็จะทำการส่งข้อมูลไปเก็บในลักษณะ CSV อย่างนี้ส่งไป เช่น
      20180129-12,37.0188,27.5338,943.7682,902.7372

      ซึ่งประกอบด้วย 5 ฟิลด์ คือ วันเวลาที่วัด และ ข้อมูล เป็นจำนวนวินาที อีก 4 ฟิลด์
      วิธีการส่งคำสั่งในการใช้งาน ครั้งแรก ต้องใส่  –noauth_local_webserver ด้วย

      python append2gsheet.py --data 20180129-12,37.0188,27.5338,943.7682,902.7372 --sheetid 1YV_W_k8VkJbYn1fG1XXXXXXXXXXXXF8y5YtQwRC0DAY --range 'Data!A1' --noauth_local_webserver
      

      จะได้ผลดังนี้

      ให้เอา URL ไปเปิดบนเว็บ Browser ที่สามารถยืนยันตัวตนกับ Google ได้ ผลดังนี้

      แล้วก็ให้การอนุมัติ

      ก็จะได้ Verification Code อย่างนี้

      เอาไปใส่

      สำเร็จ และ ผลที่ได้

    7. แต่จะเห็นว่า ข้อมูล ตัวเลขที่ใส่เข้ามา จะถูกแปลงเป็นข้อความ ซึ่ง สามารถแก้ไขได้ด้วยการใส่ –value-input-option USER_ENTERED
      python append2gsheet.py --data 20180129-12,37.0188,27.5338,943.7682,902.7372 --sheetid 1YV_W_k8VkJbYn1fG1XXXXXXXXXXXXF8y5YtQwRC0DAY --range 'Data!A1' --noauth_local_webserver --value-input-option USER_ENTERED

      ผลที่ได้คือ คือ บรรทัดล่าง จะได้ชนิดเป็น Numeric มาเลย

    8. เมื่อเก็บผลเรียบร้อยแล้ว สามารถดูเป็น Chart แบบ Realtime ได้

    เผื่อเป็นประโยชนครับ

  • วิธีการใช้ Google Drive เป็น Private Git Repository

    git คือ distributed revision control system

    เรามักใช้ github.com สำหรับเก็บ source code แต่มัน public ซึ่ง บางทีเราก็ต้องการอะไรที่ private

    ต่อไปนี้ คือวิธีการใช้งาน Google Drive เพื่อสร้าง Private Git Repository

    1. ติดตั้ง Google Drive File Stream, git ให้เรียบร้อย
    2. ใน Google Drive สร้าง Directory ชื่อ git ขึ้นมาที่ My Drive
      กรณี Google Drive File Stream ก็จะเห็นที่
      G:\My Drive\git
    3. จากนั้น ก็สร้าง Working Directory  เช่น ที่ Documents
      ในภาพ สร้างไว้ใน Documents\firebase\fmsworkshop
      จากนั้น คลิก Git Bash Here
    4. ใช้คำสั่ง
      git init

      เพื่อสร้าง .git ใน Directory นี้ก่อน
      จากนั้นใช้คำสั่งนี้ ที่มี –bare เพื่อสร้าง Remore Repository บน Google Drive

      git init --bare "G:\My Drive\git\fmsworkshop.git"

    5. บน Google Drive File Stream ก็จะมี fmsworkshop.git ปรากฏขึ้น
      ซึ่งต่อไปก็สามารถ git push ขึ้นไปเก็บไว้ได้แล้ว
    6. ต่อไป ก็พัฒนาโปรแกรมไป
    7. แล้ว ก็ git push ตามปรกติครับ
      git add .
      git commit -m "some text"
      git push "G:\My Drive\git\fmsworkshop.git"

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