Author: kanakorn.h

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

ในเบื้องต้น ก็ขอให้ทราบถึง วิธีการใช้งานคร่าว ๆ ง่าย ๆ ก่อนครับ
August 15, 2018
วิธีเอา 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
จบจ้า
August 2, 2018
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. จากที่ลองใช้มา ก็สะดวกดี
ลองกันต่อไป
July 27, 2018
วิธีการทำ 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 ไปเป็นสมาชิก และตั้งค่าแบบนี้เช่นกัน

July 26, 2018
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 แบบต่าง ๆ กัน
July 23, 2018
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 ไหน ทำอะไร อันนี้ต้องมาดูรายละเอียดกันต่อครับ
July 19, 2018
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
July 18, 2018
การใช้งาน 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% นั่นเอง
July 16, 2018
สร้าง 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
July 10, 2018