Month: July 2018

Google Colab – เมื่องานด้าน Data Science ต้องทำงานร่วมกัน

kanakorn.h

July 27, 2018
ก่อนหน้านี้ ได้กล่าวถึง 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

kanakorn.h

July 26, 2018

มีคำถามมาว่า ใช้ 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

kanakorn.h

July 23, 2018
จาก 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

kanakorn.h

July 19, 2018
ข้อมูล 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

kanakorn.h

July 18, 2018
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 เบื้องต้น

kanakorn.h

July 16, 2018
ต่อจาก สร้าง 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
ปัญหาการ Debug บางคำสั่งใน .NET Web Project (VS.NET 2013)

worapot.k

July 12, 2018
ในการพัฒนา web application ด้วย Visual Studio.NET 2013 ผู้พัฒนาบางท่าน อาจจะเคยเจอปัญหาเมื่อ debug ไปถึงบางคำสั่งแล้ว คำสั่งไม่ทำงานตามที่ควรจะเป็น หรือบางครั้งก็ไม่มีการ return ค่าออกมา ทั้ง ๆ ที่ค่าของข้อมูลถูกต้อง ซึ่งหากเจอปัญหานี้แล้ว ให้ลองสังเกตดังต่อไปนี้
1. เครื่องที่ใช้พัฒนาเป็น Windows 32 bit หรือ 64 bit
2. ตรวจสอบแน่ใจแล้วว่าใช้งานคำสั่งได้ถูกต้อง และข้อมูลที่คำสั่งนี้นำไปประมวลผลมีความถูกต้องแล้ว
ถ้าเครื่องที่ใช้เป็น Windows 64 bit ให้ทดลองทำตามดังนี้ คือ
1. ไปที่เมนู TOOLS –> Options
2. จะปรากฏหน้าต่าง Options
3. เมนูด้านซ้ายมือของหน้าต่าง Options เลือกเมนูย่อย Projects and Solutions และภายใต้เมนูนี้ เลือกเมนูย่อย Web Projects จะเห็นตัวเลือกด้านขวามือสองตัวเลือก ให้เลือกเครื่องหมายถูกตัวเลือกแรก คือ Use the 64 version…
4. คลิกปุ่ OK และทดลอง run project และ debug คำสั่งที่พบปัญหาอีกครั้ง
ตัวอย่างคำสั่งที่พบปัญหา

สำหรับตัวอย่างคำสั่งที่เคยพบปัญหาเมื่อทำการ debug คือ คำสั่งที่ใช้ในการอ่านข้อมูลจาก registry

Registry.LocalMachine.OpenSubKey

โดยคำสั่งนี้จะอ่านข้อมูลจาก registry ตาม key ที่ระบุ โดยรายละเอียดปัญหาที่พบคือ มีข้อมูลใน registry ตาม key ที่ระบุจริง แต่ตอน debug กลับ return ค่าว่างกลับมา ซึ่งหากไปใช้ใน projects ที่เป็น Windows และทำการ debug คำสั่งนี้จะ return ข้อมูลออกมาได้ถูกต้อง
July 12, 2018
การเรียกใช้งาน constructor จากอีก constructor ใน C#.NET

worapot.k

July 12, 2018
constructor คืออะไร

constructor ก็คือ ฟังก์ชันที่ถูกเรียกใช้งาน เมื่อ object ถูกสร้างขึ้นมา ซึ่งใน C#.NET ก็คือฟังก์ชันที่ตั้งชื่อเป็นชื่อเดียวกับชื่อ class นั่นเอง

constructor มีประโยชน์อย่างไร

ในการสร้าง object ขึ้นมา บางครั้งต้องมีการระบุค่าเริ่มต้นบางอย่างให้กับ object นั้น ซึ่ง constructor ก็จะเป็นเครื่องมือหนึ่งที่เป็นตัวช่วยบังคับให้ต้องระบุค่าเริ่มต้นนี้ตอนสร้าง object นั่นเอง

ยกตัวอย่าง เช่น

class Student

{

public Student(string studentID)

{

คำสั่งดึงข้อมูลนักศึกษาด้วย Student ID โดยใช้ข้อมูล Student ID จาก argument studentID

}

}

จากตัวอย่างนี้ ต้องการสร้าง object Student โดยใช้ Student ID เพื่อไปดึงข้อมูลเบื้องต้นของนักศึกษามาแสดง

ดังนั้น object ใหม่ที่สร้างจาก class Student ก็จะต้องระบุค่า Student ID ให้กับ argument studentID ก่อน

ตัวอย่างการเรียกใช้งานคือ

Student student = new Student(12345);

student ก็คือ object ที่ถูกสร้าง

123456 คือ ข้อมูล Student ID ทีต้องระบุตอนที่ object นี้ถูกสร้างนั่นเอง

ทำไมต้องเรียกใช้ constructor จากอีก constructor หนึ่ง

ในบางครั้งเมื่อเราใช้งาน class ไประยะเวลาหนึ่ง อาจะเจอกรณีที่ constructor เดิม ยังไม่รองรับความต้องการที่เปลี่ยนไปหรือเพิ่มขึ้น แต่ความต้องการใหม่นั้นยังคงต้องใช้ชุดคำสั่งและขั้นตอนการทำงานเหมือนกับที่มีอยู่เดิมด้วย และมีการเพิ่มเติมชุดคำสั่งใหม่เข้าไปเล็กน้อยเพื่อให้รองรับกับความต้องการใหม่ด้วย ซึ่งทางเลือกที่เป็นไปได้คือ
1. ปรับแก้ constructor เดิมที่มีอยู่ให้รองรับความต้องการใหม่
2. สร้าง constructor ใหม่ โดยทำการสำเนาชุดคำสั่งทั้งหมดใน constructor เดิมมา
3. สร้าง constructor ใหม่ โดยเรียกใช้งาน constructor เดิม
มาพิจารณาแต่ละทางเลือก

ทางเลือกที่ 1 เป็นการปรับแก้ของเดิมที่มีอยู่แล้ว ซึ่งเป็นทางที่ควรเลี่ยงที่สุด เพราะอาจจะไปกระทบกับการทำงานเดิมที่ถูกต้องอยู่แล้ว และอาจจะกระทบเป็นลูกโซ่กับ object อื่นที่มาเรียกใช้

ทางเลือกที่ 2 สำเนาคำสั่งทั้งหมดจาก constructor เดิม มาใส่ใน constructor ใหม่ แล้วเขียนคำสั่งเพิ่มเพื่อให้รองรับความต้องการใหม่ ซึ่งทางเลือกนี้ถือว่าดีกว่าทางเลือกแรก เพราะไม่กระทบกับการทำงานเดิมแน่นอน แต่จะเห็นว่าเกิดความซ้ำซ้อนกันของชุดคำสั่งของ constructor เดิม และใหม่ และจะพบปัญหาในกรณีที่มีความจำเป็นต้องปรับปรุงคำสั่งที่ใช้อยู่ใน constructor ทั้งสอง ผู้พัฒนาก็จะต้องมาแก้ทั้งสองที่ให้เหมือนกันอีก ซึ่งจะเป็นการเสียเวลา

ทางเลือกที่ 3 เรียกใช้งาน constructor เดิม ซึ่งจะเห็นว่าเป็นวิธีการที่สะดวกรวดเร็วที่สุด หากต้องการปรับปรุงคำสั่ง ก็เพียงไปจัดการที่ constructor เดิมเท่านั้น

วิธีการเรียกใช้งาน constructor เดิม จาก constructor ใหม่

syntax ที่ใช้ใน C#.NET คือ หลังจากส่วนประกาศ constructor ให้ใช้ : this() เพิ่มเข้าไป

ยกตัวอย่าง

class Student

{

public Student(string studentID) //constructor เดิม

{

คำสั่งดึงข้อมูลนักศึกษาด้วย Student ID โดยใช้ข้อมูล Student ID จาก argument studentID

}

public Student(string studentID, string citizenID) : this(studentID) //constructor ใหม่

{

คำสั่งใหม่ที่เพิ่มเติม

}

}
July 12, 2018
การยกเลิก SMS ไม่พึงประสงค์/ SMS กวนใจ

worapot.k

July 12, 2018
เชื่อว่าหลายท่านคงเคยประสบกับปัญหากวนใจเรื่อง SMS ไม่พึงประสงค์ ที่ส่งมาโดยที่เราไม่ต้องการ และบางครั้ง SMS เหล่านี้ก็ยังคิดค่าบริการ ทั้ง ๆ ที่เราไม่ได้สมัคร หรือบางครั้งอาจจะสมัครโดยไม่ตั้งใจหรือไม่รู้ตัว ดังนั้นในบทความนี้จะเสนอวิธีการหนึ่ง ที่จะช่วยให้เราสามารถยกเลิก SMS กวนใจเหล่านี้ออกไปบางส่วนได้ ถึงแม้จะไม่ทั้งหมด แต่ก็ช่วยบรรเทาความรำคาญลงไปได้บ้าง โดยช่องทางที่จะแนะนำนี้เป็นการร่วมมือกันระหว่าง กสทช. และผู้ให้บริการเครือข่ายโทรศัพท์เคลื่อนที่ในการให้บริการยกเลิก SMS ดังกล่าว ซึ่งผู้ใช้บริการสามารถทำได้ด้วยตนเอง โดยไม่มีค่าใช้จ่าย ดังนี้
1. กด *137 แล้วโทรออก
2. ทำตามคำแนะนำจากเสียงตอบรับอัตโนมัติของแต่ละผู้ให้บริการเครือข่ายฯ
3. รอรับ SMS แจ้งยกเลิก
ตัวอย่าง SMS ไม่พึงประสงค์ และ SMS ตอบกลับ

จะเห็นว่าหลังจากที่ใช้บริการยกเลิก SMS ผ่าน *137 แล้ว บรรดา SMS ไม่พึงประสงค์ก็ลดน้อยลง เหลือเพียง SMS ข่าวสารจากผู้ให้บริการเครือข่ายฯ เท่านั้น และก็เป็นวิธีการที่ง่ายและรวดเร็ว เพียงไม่กี่ขั้นตอน แค่นี้ก็สามารถยกเลิก SMS กวนใจออกไปได้บางส่วนแล้ว

สิ่งที่ควรรู้

ถึงแม้ว่าเราจะได้ทำการยกเลิก SMS ไม่พึงประสงค์ดังกล่าวไปแล้ว แต่ก็อาจจะมี SMS ไม่พึงประสงค์ใหม่ ๆ เข้ามาได้อีก ทั้งนี้เพราะการใช้วิธีนี้ คือการยกเลิก SMS ปัจจุบันหรือ SMS ที่ถูกสมัครไปแล้ว ไม่ได้เป็นการป้องกัน SMS ใหม่ ๆ ที่จะเกิดขึ้นในอนาคต (เช่น อาจจะเผลอไปสมัครรับ SMS โดยไม่รู้ตัวอีก) อย่างไรก็ตาม ถ้าเกิดปัญหานี้ซ้ำอีก ก็สามารถใช้การโทรไปยัง *137 เพื่อยกเลิก SMS ได้เป็นระยะ ๆ

สำหรับรายละเอียดเพิ่มเติมว่า SMS เหล่านี้มาได้อย่างไร หรือมี SMS ประเภทไหนที่สามารถยกเลิกได้ด้วย *137 บ้าง และเราจะระมัดระวังอย่างไร ไม่ให้เผลอไปสมัครบริการ SMS เหล่านี้โดยไม่ตั้งใจ สามารถศึกษาเพิ่มเติมได้จาก http://tcp.nbtc.go.th/website/home/detail/631/th

ขอขอบคุณที่มาของเนื้อหาจากสำนักรับเรื่องร้องเรียนและคุ้มครองผู้บริโภคในกิจการโทรคมนาคม สำนักงานคณะกรรมการกิจการกระจายเสียง กิจการโทรทัศน์ และกิจการโทรคมนาคมแห่งชาติ

แนะนำการยกเลิก SMS ไม่พึงประสงค์เพิ่มเติม สำหรับผู้ใช้งาน AIS

นอกจากการยกเลิกบริการ SMS ไม่พึงประสงค์ผ่านทาง *137 แล้ว ผู้ให้บริการเครือข่ายฯ AIS ยังมีบริการให้ลูกค้าสามารถยกเลิก SMS เหล่านี้ได้ด้วยตนเองผ่านทางเว็บด้วย โดยทำตามขั้นตอนดังนี้
1. เข้าไปที่ URL https://myais.ais.co.th
2. เมื่อเข้ามาแล้วจะมีหน้าจอให้ login เข้าใช้งานระบบโดยการกรอกเบอร์โทรศัพท์มือถือ และรอรับ OTP เพื่อใช้ในการเข้าใช้งานระบบแต่ละครั้ง หรือจะใช้วิธีการสร้างบัญชีผู้ใช้และรหัสผ่านใหม่สำหรับการเข้าใช้งานครั้งต่อ ๆ ไปก็ได้
3. เมื่อ login เข้าสู่ระบบแล้ว จะปรากฏเมนูด้านขวามือสำหรับการจัดการต่าง ๆ
4. เลือกเมนู บริการ จะเห็นว่าว่ามีเมนู เลือกรับ / ยกเลิก SMS ให้เลือกเมนูนี้เพื่อเข้าไปยกเลิกบริการ SMS ที่เราไม่ต้องการ
5. เราสามารถเลือกว่าจะรับหรือไม่รับ SMS ทั้งที่มาจาก AIS และไม่ได้มาจาก SMS ได้ตามต้องการ
July 12, 2018