title
stringclasses 7
values | text
stringclasses 7
values | src
stringclasses 7
values | license
stringclasses 4
values |
|---|---|---|---|
Machine Learning | # Machine Learning
โดย [ชิตพงษ์ กิตตินราดร](https://guopai.github.io/about.html)
แนะนำ Machine learning และ Deep learning อธิบายหลักการทำงานของ Algorithm วิธีการสร้างและเทรนโมเดลด้วย scikit-learn และ TensorFlow
* บทที่ 1 บทนำ
**Machine Learning**
* บทที่ 2 Linear Regression Algorithm
* บทที่ 3 Linear Regression Programming
* บทที่ 4 Logistic Regression
* บทที่ 5 Categorical Encoding
* บทที่ 6 Feature Scaling
* บทที่ 7 Bias and Variance
* บทที่ 8 Support Vector Machines
* บทที่ 9 Decision Tree
* บทที่ 10 Random Forest
* บทที่ 11 Boosting
* บทที่ 12 Clustering
* บทที่ 13 Anomaly Detection
**Deep Learning**
* บทที่ 14 Neural Network Algorithm
* บทที่ 15 Neural Network Programming
* บทที่ 16 Neural Network Vanishing Gradients
* บทที่ 17 Neural Network Optimisers
* บทที่ 18 Neural Network Regularisation
* บทที่ 19 Convolutional Neural Network
**ภาคผนวก**
* ภาคผนวก 1: ทำไมต้อง Machine Learning
* ภาคผนวก 2: พื้นฐาน Python อย่างสั้นที่สุด
## บทที่ 1 บทนำ
Machine learning (ML) เป็นการประยุกต์คณิตศาสตร์และวิทยาศาสตร์คอมพิวเตอร์เพื่อทำให้คอมพิวเตอร์สามารถเรียนรู้และตัดสินใจได้โดยไม่ต้องกำหนดกฏและเงื่อนไขตายตัว
ML เรียนรู้ด้วยการอ่านข้อมูลที่มนุษย์เตรียมให้ และประมวลผลข้อมูลนั้นเพื่อให้สามารถตัดสินใจตามที่ต้องการ โดยการตัดสินใจที่ ML ทำได้ มีหลายรูปแบบ เช่น
* พยากรณ์ว่าข้อมูลชิ้นใหม่ที่ ML ไม่เคยเห็น มีค่าเท่าใด หรืออยู่ในหมวดหมู่ใด
* จัดข้อมูลเป็นกลุ่มๆ โดยให้ข้อมูลที่มีคุณลักษณะคล้ายกันอยู่ในกลุ่มเดียวกัน
* ตรวจหาข้อมูลชิ้นที่ผิดปกติแปลกไปจากพวก
* จำแนกข้อมูลบางอย่างออกจากข้อมูลทั้งหมด เช่น จำแนกเสียงพูดออกจากเสียงสภาพแวดล้อม
* แนะนำข้อมูลชิ้นใหม่ที่คาดว่ามนุษย์น่าจะสนใจโดยเรียนรู้จากความสนใจเดิม
จะเห็นว่าประโยชน์ของ ML มีหลากหลายมาก สำหรับใครหรือองค์กรที่อยากใช้ ML ในงานของตนเอง สิ่งที่จำเป็นต้องมี (หรือต้องสร้างให้มี) คือ:
1. ข้อมูล: ML ทำงานได้ด้วยการเรียนรู้จากข้อมูล ไม่ใช่ด้วยการป้อนกฏเกณฑ์เข้าไป ดังนั้นผู้ใช้ ML จึงต้องเตรียมข้อมูลที่มีคุณภาพและมีปริมาณเพียงพอ เพื่อให้ ML เรียนรู้ได้ผลดี เรื่องนี้เป็นเรื่องสำคัญและมีรายละเอียด จะอธิบายโดยละเอียดในส่วนต่อๆ ไป
2. ทักษะ Programming: ปัจจุบันนิยมใช้ภาษา Python เป็นภาษาหลักในการทำ ML ดังนั้นควรมีความรู้พื้นฐาน Python เช่น มีความเข้าใจหลักการเขียนโปรแกรม การสร้างและคำนวนตัวแปร ประเภทและโครงสร้างข้อมูลแต่ละประเภท การเขียนเงื่อนไข เช่น if, for, while loop และการเรียกใช้ Library ต่างๆ เช่น numpy (สำหรับการคำนวน Vector และ Matrix), pandas (สำหรับการจัดการและวิเคราะห์ข้อมูลแบบตาราง), matplotlib (สำหรับการพล็อตกราฟเพื่อแสดงผลเป็นภาพ)
3. ทักษะในการใช้ ML Framework: ในอดีตเราต้องเขียนโค้ดเพื่อแปลงสมการคณิตศาสตร์ให้กลายเป็น Algorithm เพื่อคำนวนด้วยตนเอง ซึ่งต้องใช้ความรู้และมีความซับซ้อนค่อนข้างมาก แต่ปัจจุบันมีผู้สร้างซอฟท์แวร์อำนวยความสะดวกในการทำ ML ให้เราใช้ได้ฟรีๆ แบบ Open-source จึงแนะนำให้เรียนรู้วิธีใช้ Framework เหล่านี้ โดย Framework ที่นิยม เช่น scikit-learn สำหรับ Machine learning และ TensorFlow สำหรับ Deep learning
4. ความรู้เกี่ยวกับ ML: ศึกษาหลักการทำงานของ ML Algorithm ประเภทต่างๆ การเตรียมข้อมูล วิธีการทดสอบความแม่นยำของโมเดล การปรับแต่งโมเดลให้ทำงานได้ดีขึ้น การแก้ปัญหาทางเทคนิคต่างๆ ความรู้เหล่านี้สำคัญมาก ถ้าขาดความรู้ความเข้าใจเรื่องเหล่านี้ก็จะไม่สามารถพัฒนา ML ที่ดีได้ ถึงแม้จะใช้เครื่องมือต่างๆ เป็นก็ตาม
### ประเภทของปัญหา Machine learning
ปัญหา Machine learning สามารถจำแนกได้ 2 ประเภทใหญ่ๆ คือ
1. Supervised learning: คือปัญหาที่ในชุดข้อมูลนั้นมีคำตอบอยู่แล้ว ตัวอย่างเช่น:
* Regression: หาคำตอบที่เป็นตัวเลข เช่น ให้ข้อมูลโภชนาการของเด็กคนหนึ่ง พยากรณ์ว่าเด็กคนนี้จะมีความสูงกี่ ซ.ม.
* Classification: หาคำตอบที่เป็นหมวดหมู่ เช่น ให้ภาพ X-ray ทรวงอก พยากรณ์ว่าคนไข้เป็นมะเร็งปอดหรือไม่ (คำตอบมีแต่ ใช่/ไม่ใช่ เรียกว่า Binary classification) หรือให้ข้อมูลเกี่ยวกับครอบครัวของเด็กคนหนึ่ง ทำนายว่าเด็กคนนี้จัดอยู่ในกลุ่มพัฒนาการดี / พัฒนาการปกติ / พัฒนาการช้า (คำตอบมีหลายกลุ่ม เรียกว่า Multiclass classification)
2. Unsupervised learning: คือปัญหาที่ยังไม่มีใครรู้ว่าคำตอบที่ถูกต้องคืออะไร
* Clustering: จัดกลุ่มข้อมูล เช่น มีข้อมูลผู้บริจาค ต้องการจัดกลุ่มผู้บริจาคเป็น 3 กลุ่ม เพื่อออกแบบกลยุทธ์การสื่อสารกับลูกค้าแต่ละกลุ่มที่ต่างกันออกไป
* Non-clustering: ปัญหาอื่นๆ ที่ไม่ใช่การจัดกลุ่ม เช่น ตรวจหาข้อมูลชิ้นที่มีความผิดปกติจากพวก (Anomaly detection) แนะนำข้อมูลที่ผู้ใช้น่าจะสนใจ (Recommendation system) เป็นต้น
นอกจากนี้ยังมี ML ประเภทอื่นๆ สำหรับงานเฉพาะด้าน เช่น Reinforcement learning คือการเรียนรู้ที่มีกลไกการเสริมแรงเพื่อให้คอมพิวเตอร์มีพฤติกรรมที่เราต้องการ เป็นต้น
ตอนนี้เรารู้จักแล้วว่า Machine learning คืออะไร มีกี่ประเภท เอาไปทำอะไรได้บ้าง และถ้าจะทำ ML ต้องมีความรู้และทักษะอะไรบ้าง ในตอนต่อไปจะเริ่มอธิบายกลไกการทำงานของ ML อย่างง่ายที่สุด คือ Linear regression
## บทที่ 2 Linear Regression Algorithm
วิธีที่ดีที่สุดในการทำความเข้าใจ Machine learning คือการอธิบายพร้อมกับตัวอย่าง โดยเราจะเริ่มที่ Algorithm ที่ง่ายที่สุด นั่นคือ Linear regression
เราจะใช้ข้อมูลตัวอย่างจาก [Kaggle](https://www.kaggle.com/venjktry/simple-linear-regression/data) ซึ่งแสดงความสัมพันธ์ระหว่างตัวแปร x บนแกนนอนกับตัวแปร y บนแกนตั้ง ถ้ามองด้วยตาเราจะเห็นว่า x กับ y มีความสัมพันธ์ที่เรียกว่า Positive correlation อย่างชัดเจน นั่นคือยิ่ง x มีค่ามาก y ก็มีค่ามากตามไปด้วย เราจะเห็นความสัมพันธ์ลักษณะในโลกจริงได้มากมาย ตัวอย่างเช่น ยิ่งจำนวนรถมาก เวลาที่ใช้บนถนนต่อการเดินทางหนึ่งเที่ยวก็มีแนวโน้มจะมากขึ้นด้วย
ปัจจุบัน ชุดข้อมูลนี้มีค่า x และ y จำนวน 999 คู่ ตัวอย่างเช่น คู่แรก x = 24, y = 21.54 ส่วนคู่ที่สอง x = 50, y = 47.46 เราเรียกข้อมูลแต่ละคู่เช่นนี้ว่าข้อมูลหนึ่งรายการ
จริงอยู่ที่เรามีข้อมูลถึง 999 รายการ แต่ถ้าเราเก็บข้อมูลมาใหม่เป็นรายการที่ 1000 โดยข้อมูลรายการนี้รู้แค่ค่า x เราจะรู้ได้อย่างไรว่าค่า y เป็นเท่าไร
ตัวอย่างเช่น ถ้าข้อมูลใหม่มี x = 22 เราอาจจะลองลากเส้นแนวดิ่งจากแกน x ที่ 22 แล้วไปบรรจบตั้งฉากกับแกน y ซึ่งดูเหมือนจะได้ประมาณ 20 แต่ช้าก่อน มันอาจจะเป็น 18, 25 หรือแม้กระทั่ง 30 ก็ได้ เพราะข้อมูลตัวอย่างของเรามีรายการที่ x มีค่าประมาณ 22 อยู่หลายรายการ ซึ่งแต่ละรายการก็มีค่า y ไม่เท่ากันเลย
Machine learning จึงมาช่วยเราได้ โดยการใช้ Algorithm ซึ่งก็คือสูตรและกลไกทางคณิตศาสตร์ มาเรียนรู้ข้อมูลที่เรามี เพื่อสร้างโมเดลของข้อมูลขึ้นมา เราจะใช้โมเดลที่สร้างขึ้นนี้ ในการพยากรณ์คำตอบ ซึ่งก็คือค่า y ที่เราต้องการ
ซึ่งในกรณีนี้ โมเดลที่ได้คือ:
```tex
\hat{y} = 1.00065638x - 0.10726546\tag{1}
```
ดังนั้นถ้าเราลองใส่ค่า x = 22 ลงไป จะได้ y = 21.90
คำถามคือ โมเดลนี้ได้มาอย่างไร คำตอบอยู่ในส่วนต่อไป
### Hypothesis function
หัวใจของโมเดลพยากรณ์ คือฟังก์ชันคณิตศาสตร์ที่เป็นตัวแทนความสัมพันธ์ระหว่างตัวแปร x กับคำตอบ y เราเรียกฟังก์ชันนี้ว่า Hypothesis function ซึ่งหมายถึงฟังก์ชันที่เป็น "สมมุติฐาน" ว่าข้อมูลมีความสัมพันธ์กันอย่างไรนั่นเอง โดยในปัญหา Linear regression นั้น Hypothesis function จะอยู่ในรูปแบบ:
```tex
\hat{y} = wx + b\tag{2}
```
* `\hat{y}` คือค่าคำตอบที่พยากรณ์ได้
* `w` คือค่าน้ำหนักของตัวแปร x (มาจากคำว่า Weight) ซึ่งกำหนดความชันของฟังก์ชัน
* `x` คือตัวแปร x ที่เรารู้ค่า
* `b` คือจุดตัดแกน y (มาจากคำว่า Bias)
ฟังก์ชันนี้อยู่ในรูปแบบสมการเส้นตรง นั่นคือค่า x ที่ใส่ลงไป จะมีความสัมพันธ์กับค่า y แบบที่ลากเป็นเส้นตรงได้
หน้าที่ของ Machine learning คือการหาตัวแปร w และ b ซึ่งจะประกอบกันเป็น Hypothesis function ที่มีความคลาดเคลื่อนน้อยที่สุดเมื่อเทียบกับข้อมูลที่เรามี ซึ่งในกรณีตัวอย่างนี้ เราได้ w = 1.00065638 และ b = -0.10726546
เรารู้ได้อย่างไรว่า w และ b ต้องมีค่าเท่าใดจึงจะทำให้โมเดลมีความคลาดเคลื่อนน้อยที่สุด คำตอบมีอยู่ 2 ส่วน ส่วนแรกคือเราต้องมีวิธีการวัดความคลาดเคลื่อน ซึ่งเรียกว่า Cost function ส่วนที่สองคือเราต้องมีวิธีการหาค่า w และ b ที่จะทำให้ค่าความคลาดเคลื่อนใน Cost function นั้นต่ำที่สุด เรียกกระบวนการนี้ว่า Gradient descent
### Cost function
สำหรับ Hypothesis function แต่ละฟังก์ชัน จะมี Cost function คู่อยู่เสมอ ซึ่งทำหน้าที่วัดว่าค่า y ที่พยากรณ์ได้จาก Hypothesis function มีความคลาดเคลื่อนกับค่า y ที่เรามีข้อมูลอยู่จริงเท่าใด โดยสำหรับ Linear regression เราใช้ฟังก์ชันต่อไปนี้เป็น Cost function:
`J(w, b) = \frac{1}{2m} \sum\limits_{i = 1}^m(\hat{y}_i - y_i)^2\tag{3}`
* `J(w, b)` คือผลความต่างระหว่างค่าพยากรณ์กับค่าจริง ที่สอดคล้องกับตัวแปร w และ b
* `m` คือจำนวนรายการข้อมูลทั้งหมดที่มี (เช่นในกรณีตัวอย่างนี้ m = 699 มาจากข้อมูล 999 รายการ แต่กัน 300 รายการเอาไว้ทดสอบความแม่นยำ เรื่องนี้จะอธิบายภายหลัง)
* `\sum\limits_{i = 1}^m` คือผลรวมของรายการถัดไป โดยรวมจากรายการที่ 1 ถึงรายการที่ m
* `(\hat{y}_i - y_i)^2` คือผลต่างระหว่างค่า y ที่พยากรณ์ได้ กับค่า y จริง ของแต่ละรายการ แล้วนำไปยกกำลัง 2 ตัวอย่างเช่น ถ้ารายการแรก พยากรณ์ได้ 20 แต่ในความเป็นจริงต้องเป็น 21.54 จะได้ผลต่างยกกำลัง 2 เท่ากับ `(20-21.54)^2 = 2.37`
อนึ่ง ฟังก์ชันนี้ มีชื่อเรียกเฉพาะตัว ว่า Mean Squared Error หรือ MSE
เป้าหมายของ Algorithm คือการทำให้ `J(w, b)` มีค่าต่ำที่สุดเท่าที่จะเป็นไปได้ เราเรียกจุดนี้ว่า Global minimum ซึ่งหาได้โดยใช้กระบวนการที่เรียกว่า Gradient descent
### Gradient descent
ทบทวนอีกครั้งว่าเรามี Cost function ที่กำหนดความสัมพันธ์ระหว่างตัวแปร w, b กับความคลาดเคลื่อนของโมเดล ในโมเดลที่ข้อมูลมีมิติเดียว (คือมี x เพียงหนึ่งตัวสำหรับข้อมูลแต่ละรายการ แต่ละ x ก็มี w เพียงตัวเดียวเป็นค่าน้ำหนัก) รูปร่างของ Cost function จะมีลักษณะเป็นเหมือนชาม คือมีจุดต่ำที่สุด ซึ่งจุดนั้นเป็นจุดที่เราต้องการเนื่องจากจะทำให้ได้ค่าความคลาดเคลื่อนที่ต่ำที่สุด หน้าที่ของ Gradient descent คือการหาตัวแปร w และ b ที่จะทำให้ได้ J ที่ต่ำที่สุด
ในที่นี้เราจะพิจารณาเฉพาะ Cost function ของ `J(w)` ซึ่งผันแปรตามตัวแปร w เพียงตัวเดียวก่อน
การทำงานของ Gradient descent ใช้ประโยชน์จากข้อเท็จจริงที่ว่า ในแต่ละจุดของเส้นฟังก์ชัน `J(w)` เราจะสามารถลากเส้นไปแตะเพื่อชี้วัด "ความชัน" ของจุดนั้นๆ ได้ จากภาพเราจะเห็นว่าจุดที่ 1 มีความชันมากกว่าจุดที่ 2 และจุดที่ 2 ก็ชันมากกว่าจุดที่ 3 จากคุณสมบัตินี้ หากเรามีกลไกที่จะหาจุดที่มีความชันน้อยลงเรื่อยๆ ไปจนถึงจุดที่แทบไม่มีความชันเลย (จุดที่ 3) เราก็จะได้ Global minimum ที่เราต้องการ
การหาความชันทำได้ด้วยวิชา Calculus โดยการหาอนุพันธ์ (Derivative) ของฟังก์ชัน เมื่อเปรียบเทียบกับ w ซึ่งแทนเป็นสัญลักษณ์ได้ด้วย:
```tex
\frac{\partial J(w)}{\partial w}\tag{4}
```
จากวิชา Calculus เราหาอนุพันธ์ของฟังก์ชันดังกล่าว จะได้ Algorithm ทั่วไปคือ:
ทำซ้ำจนกระทั่งผลลัพธ์ล่าสุดไม่เปลี่ยนแปลงจากผลลัพธ์ครั้งก่อน:
```tex
\theta_j := \theta_j - \alpha \frac{\partial}{\partial\theta_j} J(\theta_0, \theta_1)\tag{5}
```
* `\theta` อ่านว่า Theta คือตัวแปรต่างๆ ของโมเดล เช่น b, w
* `j` คือลำดับที่ของตัวแปร โดยจุดตัดแกน y หรือ b อยู่ลำดับที่ 0 ส่วน w อยู่ลำดับที่ 1
* `\alpha` อ่านว่า Alpha คือค่าคงที่ที่กำหนดอัตราความเร็วของการเคลื่อนที่ไปสู่จุดที่ความชันน้อยลง
จาก Algorithm ทั่วไปนี้ นำมาประยุกต์กับ Linear regression จะได้ว่า:
ทำซ้ำจนกระทั่งผลลัพธ์ล่าสุดไม่เปลี่ยนแปลงจากผลลัพธ์ครั้งก่อน:
```tex
b := b - \alpha \frac{1}{m} \sum\limits_{i = 1}^m(\hat{y_i} - y_i)\tag{6}
w := w - \alpha \frac{1}{m} \sum\limits_{i = 1}^m(\hat{y_i} - y_i)x_i)\tag{7}
```
มาลองทำความเข้าใจ Algorithm นี้ด้วยตัวอย่าง สมมุติว่าเราเริ่มคำนวนด้วยค่าตั้งต้นดังนี้: ; ถ้าเราหาอนุพันธ์ครั้งแรกได้ 1 ครั้งที่สองได้ 0.7 และครั้งที่สามได้ 0.4 เราจะได้:
```tex
2 := 2 - (0.5)1 = 1.5\tag{8}
1.5 := 1.5 - (0.5)0.7 = 1.15\tag{9}
1.15 := 1.15 - (0.5)0.4 = 0.95\tag{10}
```
จะเห็นว่า ผลลัพธ์ค่า b ที่ได้มาค่าน้อยลงเรื่อยๆ คือจาก 1.5 เป็น 1.15 เป็น 0.95 โดยผลลัพธ์ที่ได้แต่ละรอบจะส่งผลให้ความชันของ Cost function ลดลงเรื่องๆ ทำให้อนุพันธ์น้อยลงเรื่อยๆ จาก 1 เป็น 0.7 เป็น 0.4 เป็นต้น
เป้าหมายของกระบวนการ Gradient descent นี้คือการหาค่าตัวแปรของโมเดลที่ทำให้โมเดลมีผลลัพธ์ y ที่คลาดเคลื่อนกับค่า y ที่แท้จริงให้น้อยที่สุด นั่นคือเราจะได้โมเดลที่เป็นตัวแทนของชุดข้อมูลนี้ได้ดีที่สุดนั่นเอง
ถ้าสังเกตดีๆ จะเห็นว่า เราสามารถควบคุมกระบวนการนี้ได้ด้วยการกำหนดตัวแปรสองสิ่ง เราเรียกตัวแปรที่เราเป็นผู้กำหนดเองนี้ว่า Hyperparameter ซึ่งในกรณีนี้ ประกอบด้วย:
* `N_{iteration}` จำนวนครั้งที่เราคำนวนและอับเดตค่าใน Algorithm เช่น 100 ครั้ง หมายความว่าจะมีการคำนวนเพื่อลดความชันลงเรื่อยๆ 100 รอบ โดยถ้าจำนวนครั้งนี้น้อยเกินไป Algorithm ก็จะยังคำนวนไปไม่ถึงจุดที่จะได้ Cost ที่ต่ำที่สุด แต่ถ้าจำนวนครั้งนี้มากเกินไป ก็จะเสียเวลาและพลังงานในการคำนวนมากโดยไม่จำเป็น เพราะรอบหลังๆ ที่ได้ทำให้ Cost function เปลี่ยนแปลง
* `\alpha` เรียกว่า Learning rate หรืออัตราความเร็วในการอับเดตค่าความชัน (อนุพันธ์ของ J เมื่อเทียบกับตัวแปร) ถ้า Learning rate มีค่ามาก จะทำให้ค่าความชันส่งผลไปยังค่าของตัวแปรมากขึ้น ทำให้โมเดลหาจุด Global minimum ได้เร็วขึ้น ในทางกลับกัน ถ้า Learning rate น้อย ตัวแปรก็จะเปลี่ยนแปลงช้าลง
ทีนี้ดูเหมือนกับว่า ถ้าเรากำหนด Learning rate สูงๆ ก็จะทำให้ได้ค่า Global minimum ของ Cost function เร็วขึ้น อย่างไรก็ตามถ้าค่า Learning rate สูงเกินไป อาจจะทำให้โมเดลหา Global minimum ไม่เจอ เพราะในขั้นท้ายๆ ของ Gradient descent ตัวแปรอาจจะกระโดดเลยจุดต่ำสุดของ J ไปอีกด้านหนึ่ง
### Normal equation
นอกจากวิธี Gradient descent แล้ว เรายังมีวิธีการหา Parameter ที่ให้ Cost ที่ต่ำที่สุดอีกวิธี เราเรียกวิธีนี้ว่า Normal equation โดยเพียงใช้สมการ:
```tex
\theta = (X^T X)^{-1} X^T y \tag{11}
```
Normal equation ทำงานได้ดีและเร็วเมื่อจำนวน Feature ไม่มาก ผู้สนใจสามารถหาอ่านวิธีการ Derive ให้ได้มาซึ่ง Normal equation นี้ด้วยตนเอง
ตอนนี้เรามีความรู้และเข้าใจขั้นตอนการสร้างโมเดล Linear regression แล้ว ตอนถัดไปเราจะใช้ตัวอย่างนี้มาสร้างโมเดลจริงกัน
## บทที่ 3 Linear Regression Programming
เมื่อเราเข้าใจแล้วว่า Linear regression algorithm ทำงานอย่างไร ทีนี้ก็มาลองสร้างโมเดลพยากรณ์กัน
โดยทั่วไป การสร้างโมเดลมีขั้นตอนต่อไปนี้:
1. เตรียมข้อมูล
2. Import Library ที่จะใช้งาน และโหลดข้อมูล
3. สำรวจข้อมูล
4. ฝึกโมเดล
5. ทดสอบความแม่นยำของโมเดล
6. นำไปใช้พยากรณ์
โดยจะแนะนำทีละขั้นตอน
### เตรียมข้อมูล
ข้อมูลที่จะนำมาสร้างโมเดล Machine learning มีที่มาหลากหลาย ซึ่งเราสามารถใช้ Python ดึงข้อมูลจากหลากหลายรูปแบบมาใช้ได้ ในขั้นนี้เราจะเน้นการเตรียมข้อมูลให้อยู่ในรูปแบบข้อมูลที่มีโครงสร้าง (Structured data) ที่นำเสนอในรูปแบบตาราง
| | x | y |
| --- | --- | --- |
| 0 | 24 | 21.549452 |
| 1 | 50 | 47.464463 |
| 2 | 15 | 17.218656 |
หลักการเตรียมข้อมูล คือให้สร้างข้อมูลใน Spreadsheet โดยแนวนอนคือตัวอย่างแต่ละรายการ ส่วนแนวตั้งคือข้อมูลของตัวอย่างแต่ละรายการ เราเรียกข้อมูลแนวตั้ง ว่า Feature ซึ่งในกรณี จะเห็นว่ามี 1 Feature คือ x ส่วนคอลัมน์สุดท้าย เราเก็บไว้สำหรับคำตอบ ซึ่งเราต้องการหาเมื่อนำโมเดลมาพยากรณ์จากข้อมูลใหม่ เราเรียกคอลัมน์คำตอบนี้ว่า Label
ตัวอย่างเช่น ข้อมูลชิ้นที่ 1 มี Feature x คือ 50 ซึ่งเชื่อมโยงกับ Label y คือ 47.464463 เราจะฝึกโมเดลให้เรียนรู้ความสัมพันธ์ระหว่าง Feature กับ Label เพื่อให้ได้สมมุติฐานที่ดีที่สุด ว่า Feature กับ Label สัมพันธ์กันอย่างไร เมื่อได้สมมุติฐานนี้ก็จะสามารถพยากรณ์ Label จากข้อมูลชิ้นใหม่ที่รู้แค่ Feature ได้
อนึ่ง เราไม่จำเป็นต้องใส่ลำดับที่ของข้อมูลในคอลัมน์แรกอย่างที่เห็นในตัวอย่าง เพราะเดี๋ยว Library pandas จะสร้างดัชนีเหล่านี้ให้เราเอง
เมื่อเตรียมข้อมูลเสร็จ ให้ Save เป็น .csv ซึ่งเป็นรูปแบบมาตรฐานสำหรับข้อมูลแบบตาราง
### Import Library ที่จะใช้งาน และโหลดข้อมูล
ขั้นต่อไปเราต้องตัดสินใจว่า เราจะสำรวจข้อมูลและสร้างโมเดลด้วยเครื่องมือใด เพื่อที่จะได้โหลด Library ของ Python ที่ต้องใช้เข้ามา ซึ่งสำหรับตัวอย่างนี้เราจะใช้เครื่องมือดังนี้
* numpy เป็น Library มาตรฐานสำหรับการคำนวนและจัดการกับ Vector และ Matrix หลากมิติ ต้องใช้ในการแปลงข้อมูลให้ ML Framework ของเราอ่านได้
* pandas เป็น Library สำหรับโหลดจัดการ และวิเคราะห์ข้อมูล Structured data เช่นตาราง csv ต้องใช้เพื่อโหลดข้อมูลของเราและทำการสำรวจข้อมูลโดยใช้เครื่องมือทางสถิติ
* matplotlib เป็น Library ที่เอาไว้แปลงข้อมูลเป็นกราฟ เพื่อแสดงผลให้เห็นเข้าใจง่าย และเพื่อช่วยในการวิเคราะห์และตัดสินใจ
* scikit-learn เป็น Machine learning framework library มีเครื่องมือและ Algorithm ที่เกี่ยวข้องกับการฝึกโมเดลและตรวจสอบความแม่นยำ
เราเลือกใช้ scikit-learn เพราะเป็น Library ที่ออกแบบมาดี ใช้งานง่าย สามารถเลือก Algorithm ได้หลากหลายโดยมีวิธีการฝึกคล้ายๆ กัน การใช้ Framework อย่าง scikit-learn จะช่วยย่นเวลาและลดโอกาสที่จะเกิดข้อผิดพลาดได้มาก เมื่อเทียบกับการเขียน Algorithm ขึ้นมาเอง
แนะนำให้ไปอ่านคู่มือและคำแนะนำการใช้แต่ละ Library เพื่อทำความคุ้นเคย จะได้ใช้งานได้คล่องและประยุกต์กับสถานการณ์ได้หลากหลาย
เมื่อตัดสินใจได้แล้วเราก็เริ่ม Import Library เหล่านี้ได้:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
```
สำหรับใครที่มาถึงจุดนี้แล้วไม่เข้าใจว่าต้องพิมพ์โค้ดนี้ที่ไหน อย่างไร และแต่ละบรรทัดหมายความว่าอะไร แนะนำให้หยุดก่อน แล้วไปศึกษา Python ขั้นพื้นฐาน ซึ่งปัจจุบันหาอ่านได้ทั่วไปบนเว็บหรือจะเรียนตามคอร์สออนไลน์ต่างๆ ก็ได้
ต่อมาเราจะเริ่มโหลดข้อมูล โดยใช้ pandas:
```python
# Load the data
# Data from https://www.kaggle.com/venjktry/simple-linear-regression/data
data_train = pd.read_csv("data/lr_train.csv")
data_test = pd.read_csv("data/lr_test.csv")
```
ข้อสังเกตที่สำคัญในขั้นนี้ คือจากตัวอย่างเราจะเห็นว่าได้แบ่งข้อมูลเป็นสองไฟล์ คือ `lr_train.csv` และ `lr_test.csv` การแบ่งนี้เกิดขึ้นเพราะในกระบวนการสร้างโมเดล เราจะต้องกันข้อมูลส่วนหนึ่งเอาไว้ไม่ให้โมเดลได้เห็นก่อน เพื่อจะได้เอาโมเดลที่ได้ไปทดลองพยากรณ์กับข้อมูลที่กันเอาไว้ เพื่อทดสอบความแม่นยำ โดยปกติเราจะใช้สัดส่วน Train set: Test set ประมาณ 80:20 แต่ถ้าหากมีข้อมูลหลายรายการมาก เช่นเป็นหลักล้านขึ้นไป ก็สามารถเพิ่มสัดส่วนเป็น 90:10 หรือไปจนถึง 99:1 ก็ได้ เพราะโดยทั่วไปเราต้องการข้อมูลที่เอาไว้ฝึกโมเดลที่มีจำนวนมากที่สุดเท่าที่จะทำได้ ส่วนข้อมูลที่เอาไว้ทดสอบ ถ้าปริมาณข้อมูลรวมมีเยอะมาก ข้อมูลทดสอบก็มีจำนวนมากเพียงพอถึงแม้สัดส่วนจะน้อยก็ตาม
ในกรณีของเรา Train set มี 699 รายการ ส่วน Test set มี 300 รายการ คิดเป็นสัดส่วนประมาณ 70:30
สิ่งสำคัญอีกประการคือการแบ่งข้อมูลออกเป็น Train set และ Test set จะต้องแบ่งแบบสุ่ม ไม่ใช่การตัดเอาส่วนต้นมาเป็น Train set และที่เหลือเป็น Test set เพราะเราต้องการให้ข้อมูลทั้งสองชุดเป็นตัวแทนของรายการข้อมูลที่มี Feature และ Label ที่หลากหลาย กระจายตัวออกตามธรรมชาติ อนึ่ง ในความเป็นจริงเราไม่จำเป็นต้องแบ่งข้อมูลออกเป็นสองไฟล์ ให้ใช้ไฟล์เดียว แล้วใช้ฟังก์ชัน `train_test_split` ของ scikit-learn สุ่มแบ่งให้โดยอัตโนมัติได้
ข้อมูลที่โหลดมา ให้เก็บไว้ใน Object โดยในที่นี้ Train set เก็บไว้ใน `data_train` ส่วน Test set เก็บไว้ใน `data_test`
### สำรวจข้อมูล
เมื่อเราโหลดข้อมูลลงใน Object แล้ว เราก็จะสำรวจข้อมูลที่มี โดยใช้ Method ต่างๆ ของ pandas object ดังนี้:
```python
# Explore the data
print("See the data sample:\n")
print(data_train.head())
print("See the summary of features:\n")
print(data_train.info())
print("Calculate basic stat of each feature:\n")
print(data_train.describe())
```
`data_train.head()` จะแสดงข้อมูล 5 รายการแรกให้เราดู:
| | x | y |
| --- | --- | --- |
| 0 | 24 | 21.549452 |
| 1 | 50 | 47.464463 |
| 2 | 15 | 17.218656 |
| 3 | 38 | 36.586398 |
| 2 | 87 | 87.288984 |
`data_train.info()` จะแสดงจำนวนและประเภทของข้อมูลแต่ละคอลัมน์ และข้อมูลอื่นๆ เช่นจำนวน Memory ที่ใช้:
```
RangeIndex: 699 entries, 0 to 698
Data columns (total 2 columns):
x 699 non-null int64
y 699 non-null float64
dtypes: float64(1), int64(1)
memory usage: 11.0 KB
```
เราจะเห็นว่ามีข้อมูล 699 รายการ โดยจำนวนรายการของ x และ y จะต้องเท่ากัน เพื่อให้ Algorithm สามารถจับคู่คำนวนได้ถูกต้อง นอกจากนี้ ให้สังเกตว่า x เป็นข้อมูลในรูปแบบ int64 คือจำนวนเต็ม ส่วน y เป็นประเภท float64 คือจำนวนที่มีทศนิยม
ต่อมา `data_train.describe()` จะแสดงสถิติพื้นฐานของข้อมูลแต่ละคอลัมน์:
| | x | y |
| --- | --- | --- |
| count | 699.000000 | 699.000000 |
| mean | 50.014306 | 49.939869 |
| std | 28.954560 | 29.109217 |
| min | 0.000000 | -3.839981 |
| 25% | 25.000000 | 24.929968 |
| 50% | 49.000000 | 48.973020 |
| 75% | 75.000000 | 74.929911 |
| max | 100.000000 | 108.871618 |
ใครที่อ่านสถิติขั้นพื้นฐานเป็น จะพบว่าทั้ง x และ y มีลักษณะคล้ายกันมาก เช่น มีค่า Mean และส่วนเบี่ยงเบนมาตรฐานใกล้เคียงกัน มีการกระจายตัวแบบ Normal distribution มีค่าต่ำสุดและสูงสุดใกล้กัน ซึ่งถ้าเราเห็นข้อมูลแบบนี้ก็อาจจะเริ่มนึกออกว่า x และ y น่าจะมีความสัมพันธ์อย่างใกล้ชิดกันมาก (มี Correlation สูง) ซึ่งจะยืนยันได้ด้วยการพล็อตกราฟแบบ Scatter plot โดยใช้ matplotlib:
```python
# Visualise the data
plt.figure(figsize=(12,9))
plt.scatter(data_train["x"], data_train["y"])
plt.xlabel("x")
plt.ylabel("y")
```
ซึ่งยืนยันการวิเคราะห์ของเราจากการอ่านสถิติในขั้นตอนที่แล้ว ว่า x กับ y มีความสัมพันธ์เป็นเส้นตรงซึ่งกันและกัน ซึ่งทำให้เราตัดสินใจเลือกใช้ Linear regression algorithm ในการสร้างโมเดล เพราะเป็นโมเดลที่มีสมมติฐานว่าความสัมพันธ์ระหว่าง Feature กับ Label เป็นเส้นตรง
อนึ่งจะอธิบายไวยากรณ์ของโค้ดด้านบนเพื่อความเข้าใจที่กระจ่าง:
* `plt.figure(figsize=(12,9))` สร้างกราฟว่างๆ ขนาด 12 x 9 เพื่อเป็นพื้นที่ให้เราใส่ข้อมูล
* `plt.scatter(data_train["x"], data_train["y"])` สั่งให้พล็อตกราฟแบบ Scatter plot โดยกำหนด Argument คือ `(ข้อมูลสำหรับแกน x, ข้อมูลสำหรับแกน y)` ซึ่งเราจะดึงข้อมูลจาก pandas object ที่โหลดมาไว้แล้ว โดยข้อมูลแกน x กำหนดให้เป็น `data_train["x"]` ซึ่งแปลว่า "ให้เลือกข้อมูลทั้งหมดจากคอลัมน์ที่ชื่อ "x"" ส่วนข้อมูลสำหรับแกน y ก็ทำลักษณะเดียวกัน
* `plt.xlabel("x")` และ `plt.ylabel("y")` กำหนดชื่อป้ายบนแกน x และ y ว่า "x" และ "y" ตามลำดับ
เมื่อเราเห็นข้อมูลแล้วตัดสินใจเลือก Algorithm แล้ว ก็ถึงเวลาสร้างโมเดลจริงๆ เสียที
### ฝึกโมเดล
เราจะสร้างโมเดลด้วยการเรียกใช้คลาส `LinearRegression` จากโมดูล `linear_model` ของ scikit-learn library
แต่ก่อนอื่นเราต้องเข้าใจก่อนว่า scikit-learn กำหนดว่าข้อมูลที่จะป้อนเข้าสู่ Algorithm จะต้องเป็น Array ที่มีมิติชัดเจนทั้งด้านแถวและด้านคอลัมน์ เช่น ถ้า Feature มี 1 Feature คือ x และแต่ละ x มี 699 รายการ มิติของข้อมูลชุดนี้ต้องเป็น (699,1)
ซึ่งปัญหาจะเกิดขึ้นตรงนี้ ว่า Object ข้อมูลที่เราโหลดเข้ามา อาจไม่ได้มีมิติครบทั้งสองด้าน เช่น pandas object `data_train` ของเรา มีมิติ (699,) คือกำหนดมิติชัดเจนแค่ด้านแถว ส่วนด้านคอลัมน์ไม่ได้กำหนด เราจึงต้องแปลงข้อมูลให้มีมิติครบทั้งสองด้านเสียก่อน
วิธีการแปลงคือ เราจะแปลง pandas object เป็น numpy array โดยในกรณีของเราทำดังนี้:
```python
# Format X_train and y_train into 2D vector
X_train = np.array(data_train["x"]).reshape(-1,1)
y_train = np.array(data_train["y"]).reshape(-1,1)
X_test = np.array(data_test["x"]).reshape(-1,1)
y_test = np.array(data_test["y"]).reshape(-1,1)
print("X_train shape = " + str(X_train.shape))
print("y_train shape = " + str(y_train.shape))
print("X_test shape = " + str(X_test.shape))
print("y_test shape = " + str(y_test.shape))
```
Method `.reshape(-1,1)` เป็นการเติมมิติให้ด้านคอลัมน์ ผลที่ได้คือ:
```python
X_train shape = (699, 1)
y_train shape = (699, 1)
X_test shape = (300, 1)
y_test shape = (300, 1)
```
ซึ่งเป็นรูปแบบข้อมูลที่พร้อมจะนำเข้า Algorithm ให้ฝึกโมเดล
ต่อมาคือขั้นตอนที่สำคัญที่สุด แต่สั้นที่สุด นั่นคือการฝึกโมเดลด้วย Linear regression algorithm:
```python
# Train the data
lr = LinearRegression().fit(X_train, y_train)
print("LR coefficient is", lr.coef_)
print("LR intercept is", lr.intercept_)
```
ผลที่ได้คือ:
* `lr = LinearRegression().fit(X_train, y_train)` เราเรียกฟังก์ชัน `LinearRegression()` แล้วใช้ Method `.fit` ป้อน Vector ของ feature และ Vector ของ label ลงไปในฟังก์ชัน โดยฟังก์ชันจะใช้ข้อมูลเหล่านี้มาคำนวนหา Parameter ที่จะลด Cost function ให้มีค่าต่ำที่สุด โดย Parameter สำหรับ Linear regression ก็คือ Coefficient (= w) และ Intercept (= b) อยู่ใน Hypothesis function ของ Linear regression:
`\hat{y} = wx + b\tag{1}`
* จากนั้นเราพิมพ์ Parameter ทั้งสองตัวมาดู ซึ่งเมื่อเอามาใส่ใน Hypothesis function ก็จะได้สมการเส้นตรงที่เป็นโมเดลของชุดข้อมูลนี้ นั่นก็คือ:
`\hat{y} = 1.00065638x - 0.10726546\tag{2}`
ซึ่งทำให้เราสามารถพยากรณ์ค่า y ได้ด้วยการใส่ค่า x ลงไปตามที่ต้องการ
แต่ก่อนที่เราจะนำโมเดลไปใช้ เราต้องมั่นใจเสียก่อนว่าโมเดลของเราเป็นโมเดลที่ดี นั่นคือมีความแม่นยำสูงพอที่เราจะเชื่อได้ว่าเป็นตัวแทนข้อมูลชุดนี้ได้
### ทดสอบความแม่นยำของโมเดล
หนึ่งในข้อสงสัยที่แทบทุกคนจะถามเมื่อกำลังพิจารณาจะนำ Machine learning มาแก้ปัญหาของตน ก็คือจะรู้ได้อย่างไรว่าโมเดลจะมีความแม่นยำ คำตอบคือมีวิธีการทดสอบและชี้วัดความแม่นยำของโมเดลหลากหลายวิธี ซึ่งแต่ละวิธีก็จะเหมาะสมกับ Algorithm และสถานการณ์ที่แตกต่างกันออกไป
สำหรับ Linear regression เราจะใช้ Method `.score` ของ scikit-learn ในการตรวจสอบความแม่นยำของโมเดล โดยมีวิธีการเรียกใช้ คือ:
```python
# Evaluate model's accuracy on train and test set
print("Train set accuracy = " + str(lr.score(X_train, y_train)))
print("Test set accuracy = " + str(lr.score(X_test, y_test)))
```
Method `.score` นี้จะแตกต่างกันสำหรับแต่ละโมเดล โดย Linear regression จะเรียกใช้วิธีที่เรียกว่า `R^2 Score` ซึ่งมีสูตรคำนวนดังนี้:
```tex
R^2 = 1 - \frac{SS_{res}}{SS_{tot}}\tag{3}
SS_{res} = \sum\limits_{i = 1}^m(y_i - \hat{y}_i)^2\tag{4}
SS_{tot} = \sum\limits_{i = 1}^m(y_i - \bar{y}_i)^2\tag{5}
```
* `SS_{res}` คือ Residual sum of squares ชี้วัดความต่างระหว่างค่าจริงกับค่าที่พยากรณ์ได้
* `SS_{tot}` คือ Total sum of squares ชี้วัดความต่างระหว่างค่าจริงกับค่าเฉลี่ยของค่าจริงทั้งหมด
* ยิ่ง `R^2` มีค่าใกล้ 1 แปลว่าโมเดลมีความแม่นยำมาก
สำหรับตัวอย่างของเรา ได้ผลดังนี้:
```
Train set accuracy = 0.9907015319025518
Test set accuracy = 0.9888014444327563
```
พูดง่ายๆ ก็คือเมื่อเทียบกับ Train set 699 ตัวอย่าง มีความแม่นยำ 99.07% ส่วนเมื่อเทียบกับ Test set 300 ตัวอย่าง มีความแม่นยำ 98.88%
สุดท้าย เรามาลองพล็อตกราฟดูว่าโมเดลของเรามีหน้าตาเป็นอย่างไร เมื่อเทียบกับข้อมูลจริง:
```python
# Make a prediction
y_pred = lr.predict(X_test)
# Visualise the model VS actual data
plt.figure(figsize=(12,9))
plt.scatter(X_test, y_test)
plt.plot(X_test, y_pred, color="red", linewidth=3)
plt.xlabel("x")
plt.ylabel("y")
```
การสร้างกราฟของโมเดล ทำได้โดยการเรียก Method .predict โดยใส่ข้อมูล X_test ลงไป เพื่อให้โมเดลพยากรณ์ค่า y ออกมาเป็นเส้นตรง กำหนดผลที่ได้ลงไปใน Object y_pred จากนั้นเอา y_pred ไปพล็อตในแกน y เป็นเส้นตรงเมื่อเทียบกับ X_test ก็จะได้ฟังก์ชันเส้นตรงของโมเดล
จะเห็นว่าเส้นฟังก์ชันโมเดลสีแดงของเรา ผ่ากลางกลุ่มข้อมูลตัวอย่างแบบพอดีๆ เป็นการยืนยันให้เห็นด้วยตา ว่าโมเดลของเราน่าจะมีความแม่นยำสูงที่สุดเท่าที่จะเป็นไปได้
เป็นอันว่าเราได้สร้างโมเดลพยากรณ์แบบ Linear regression ตัวแปรเดียว ได้สำเร็จเป็นที่เรียบร้อย ตอนต่อไปจะมาเรียนรู้การสร้างโมเดลแบบ Classification เพื่อจำแนกข้อมูลออกเป็นหมวดต่างๆ กัน
## บทที่ 4 Logistic Regression
คราวที่แล้วเราได้เรียนรู้ Linear Regression เพื่อสร้างโมเดลพยากรณ์ผลลัพธ์ที่เป็นตัวเลขต่อเนื่อง (Continuous number) คราวนี้เราจะมาสร้างโมเดลสำหรับพยากรณ์หมวดหมู่ หรือที่เรียกว่า Classification กันบ้าง
โจทย์ของเราคือการจำแนกสายพันธุ์ของพืชตระกูล Iris ออกเป็น 3 กลุ่ม คือ Sentosa, Versicolor, และ Virginica โดยมีข้อมูลอยู่ 4 Feature คือ ความยาวกลีบเลี้ยง (Sepal length), ความกว้างกลีบเลี้ยง (Sepal width), ความยาวกลีบดอก (Petal length), และความกว้างกลีบดอก (Petal width) โดยทั้งหมดมีหน่วยวัดเป็นเซนติเมตร
### Load
เราจะใช้ชุดข้อมูล [Iris plants dataset](https://en.wikipedia.org/wiki/Iris_flower_data_set) ซึ่งเป็นชุดข้อมูลยอดนิยมในการทดสอบโมเดลการจำแนกแบบหลายหมวดหมู่ โดยชุดข้อมูลนี้ถูกฝังอยู่ใน scikit-learn เรียบร้อยแล้ว สามารถเรียกใช้ได้เลยโดยการเรียก `load_iris()` ฟังก์ชัน ในคลาส `datasets`:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
# Load the iris data
iris = datasets.load_iris()
```
### Explore
เมื่อโหลดแล้วลองดูโครงสร้างและคำอธิบายข้อมูล:
```python
print(iris.keys())
print(iris["DESCR"])
print("Feature names are: ", iris["feature_names"])
print("Target names are: ", iris["target_names"])
```
Method `.keys` ของ iris object จะเรียกดู Dictionary key ของชุดข้อมูล ซึ่งประกอบด้วย:
`dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])`
หมายความว่าถ้าเราเรียกดู Keys เหล่านี้ ก็จะเจอข้อมูลใน Key นั้นๆ เช่น ถ้าเราอยากรู้ว่าหมวดหมู่ที่จะพยากรณ์ มีอะไรบ้าง ก็เรียก `iris["target_names"]` ก็จะได้:
`['setosa' 'versicolor' 'virginica']`
แนะนำให้เรียก `iris["DESCR"]` เพื่อดูคำอธิบายชุดข้อมูลด้วย จะได้เข้าใจที่มาที่ไป ลักษณะ และจำนวนตัวอย่างข้อมูล:
```
Iris plants dataset
--------------------
**Data Set Characteristics:**
:Number of Instances: 150 (50 in each of three classes)
:Number of Attributes: 4 numeric, predictive attributes and the class
:Attribute Information:
- sepal length in cm
- sepal width in cm
- petal length in cm
- petal width in cm
- class:
- Iris-Setosa
- Iris-Versicolour
- Iris-Virginica
:Summary Statistics:
============== ==== ==== ======= ===== ====================
Min Max Mean SD Class Correlation
============== ==== ==== ======= ===== ====================
sepal length: 4.3 7.9 5.84 0.83 0.7826
sepal width: 2.0 4.4 3.05 0.43 -0.4194
petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)
petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)
============== ==== ==== ======= ===== ====================
:Missing Attribute Values: None
:Class Distribution: 33.3% for each of 3 classes.
:Creator: R.A. Fisher
:Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)
:Date: July, 1988
The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken
from Fisher's paper. Note that it's the same as in R, but not as in the UCI
Machine Learning Repository, which has two wrong data points.
This is perhaps the best known database to be found in the
pattern recognition literature. Fisher's paper is a classic in the field and
is referenced frequently to this day. (See Duda & Hart, for example.) The
data set contains 3 classes of 50 instances each, where each class refers to a
type of iris plant. One class is linearly separable from the other 2; the
latter are NOT linearly separable from each other.
```
### Prepare
พอเข้าใจข้อมูลแล้ว ก็ต้องเตรียมข้อมูลให้อยู่ในรูปแบบที่จะนำไปให้โมเดลฝึกได้ ซึ่งโดยหลักการคือการกำหนด Matrix ข้อมูลให้อยู่ในตัวแปร X ส่วน Vector เป้าหมายให้อยู่ในตัวแปร y โดยสำหรับชุดข้อมูลที่ฝังอยู่ใน scikit_learn เราสามารถเรียก Method `.data` และ `.target` ได้เลย
```python
X = iris.data
y = iris.target
print("X_shape shape is:", X.shape)
print("y_shape shape is:", y.shape)
```
สองบรรทัดสุดท้าย เป็นการตรวจสอบมิติของข้อมูลทั้ง X และ y ซึ่งจะได้:
X_shape shape is: (150, 4)
y_shape shape is: (150,)
แปลว่า X เป็น Matrix ขนาด (150, 4) คือมี 150 แถวเท่ากับจำนวนตัวอย่าง และ 4 คอลัมน์เท่ากับจำนวน Feature ส่วน y เป็น Column vector ขนาด 150 ซึ่งจะต้องเท่ากับจำนวนแถวของ X matrix
อนึ่ง เราใช้ตัวพิมพ์ใหญ่ เช่น X เวลาแทน Matrix ส่วน Vector ใช้ตัวพิมพ์เล็กเช่น y เพื่อทำให้ชัดเจนว่าข้อมูลอยู่ในประเภทอะไรทางคณิตศาสตร์
จากนั้นเราจะแบ่งข้อมูลออกเป็น Train set กับ Test set โดยการสุ่มด้วยฟังก์ชัน `train_test_split` ในโมดูล `model_selection` โดยฟังก์ชันนี้จะ Return ตัวแปร 4 ตัว ได้แก่ Matrix X เพื่อเทรน, Matrix X เพื่อทดสอบ, Vector Y เพื่อเทรน, และ Vector Y เพื่อทดสอบ ตามลำดับ ดังนั้นให้เรากำหนดตัวแปรทั้ง 4 เมื่อเรียกฟังก์ชันนี้
```python
# Split the data into train and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
print("X_train shape is:", X_train.shape)
print("y_train shape is:", y_train.shape)
print("X_test shape is:", X_test.shape)
print("y_test shape is:", y_test.shape)
```
สังเกตว่า `train_test_split` มี Argument `X`, `y` ซึ่งก็คือชุดข้อมูลที่เราเพิ่งเตรียม และมี `random_state` ซึ่งทำให้เราสามารถกำหนดได้การสุ่มแต่ละครั้งได้ผลออกมาเหมือนกัน ซึ่งเป็นประโยชน์ในการทดสอบโมเดล เพราะถ้าเราเรียกฟังก์ชันแต่ละครั้งแล้วผลออกมาไม่เหมือนกัน คือแต่ละครั้งก็สุ่มใหม่ เราจะไม่สามารถควบคุมตัวแปรในการทดสอบโมเดลได้
วิธีการกำหนด `random_state` คือการใส่ตัวเลขจำนวนเต็มอะไรก็ได้ลงไป ถ้าดูหนังสือหรือโค้ดคนอื่นจะเห็นว่าบางทีจะใส่เลข `42` อันนี้เป็น [Meme](https://www.independent.co.uk/life-style/history/42-the-answer-to-life-the-universe-and-everything-2205734.html) ซึ่งมาจากนิยายวิทยาศาสตร์เรื่อง A Hitchhiker's Guide to the Galaxy ของ Douglas Adams
### Visualise
ก่อนจะสร้างโมเดลก็น่าจะลอง Visualise ข้อมูลให้เห็นภาพสักหน่อย ในที่นี่เราจะสร้าง Scatterplot matrix ซึ่งแสดงความสัมพันธ์ระหว่างข้อมูลแต่ละ Feature และจำแนกจุดที่เป็นตัวแทนของข้อมูลที่อยู่ในหมวดหมู่แต่ละหมวดจาก 3 หมวด โดยการใช้สีที่ไม่เหมือนกัน
```python
# Plot the data
iris_df = pd.DataFrame(X_train, columns=iris.feature_names)
pd.plotting.scatter_matrix(iris_df, c=y_train, figsize=(12,12), marker="o")
```
วิธีอ่าน Scatterplot matrix มีดังนี้:
* Scatterplot matrix แสดงความสัมพันธ์ระหว่างตัวแปรสองตัว ซึ่งอาจจะเป็น Feature ทั้งสองตัว หรืออาจจะเป็น Feature กับ Label ก็ได้ โดยแสดงทุกคู่ความสัมพันธ์ที่เป็นไปได้อยู่ในภาพเดียวกัน เลยมีหน้าตาเป็น Matrix
* จะเห็นว่า Matrix ช่องบนซ้ายแทยงลงมาช่องล่างขวา ไม่ได้แสดงเป็น Scatter plot แต่เป็น Distribution plot เพราะมันคือความสัมพันธ์ของตัวมันเอง โดย Distribution plot ก็มีประโยชน์ ทำเราจะได้เห็นว่ารายการข้อมูลทั้งหมดมีการกระจายตัวใน Feature นั้นอย่างไร เช่น ช่อง Sepal width พบว่ามีการกระจายตัวแบบ Normal distribution คือข้อมูลส่วนมากมีค่าอยู่กลางๆ แถวๆ Mean แล้วกระจายตัวออกทั้งด้านลบและด้านบวก
* ส่วนช่องอื่นๆ เราสามารถกำหนดให้แยกสีตาม Label ได้ ทำให้เห็นว่าในแต่ละคู่ความสัมพันธ์ ข้อมูล Label ไหนอยู่ตรงไหน ตัวอย่างเช่น คู่ Petal length VS. Sepal length (แถว 3 คอลัมน์ 1) จะเห็นว่า Label แรกจะมี Petal และ Sepal length น้อย, Label ที่สองอยู่ตรงกลางๆ, และ Label ที่สามมีค่ามาก แต่เมื่อดู Sepal width VS. Sepal length (แถว 2 คอลัมน์ 1) พบว่า Label 2 และ 3 มีค่าผสมผสานกัน แยกกจากกันไม่เด็ดขาด เป็นต้น
สำหรับเรา ประโยชน์หนึ่งจากการอ่าน Scatterplot matrix คือการสร้างความเข้าใจในภาพรวมว่าชุดข้อมูลนี้น่าจะ "ยาก" หรือ "ง่าย" ในการสร้างโมเดล โดยถ้าข้อมูลแต่ละ Label แยกจากกันค่อนข้างชัด การสร้างโมเดลก็จะค่อนข้างง่ายและแม่นยำ
### Logistic regression algorithm
และแล้วก็เกือบถึงเวลาที่จะฝึกโมเดลให้เข้ากับชุดข้อมูล แต่ก่อนหน้านั้นเรามาทำความเข้าใจว่า Algorithm ที่เราจะใช้นั้นทำงานอย่างไร โดย Algorithm ที่เราเลือกใช้คือ Logistic Regression ชื่ออาจจะฟังดูเหมือน Regression ที่มีเป้าหมายพยากรณ์ค่าต่อเนื่อง แต่ในความเป็นจริงไม่ได้เป็นอย่างนั้น เราลองมาดูกันว่าโมเดลนี้ทำงานอย่างไร
#### Hypothesis function
ใน Classification model เราต้องการให้ y มีคำตอบ คือ 0 หรือ 1 เท่านั้น ซึ่งหมายความว่า "ไม่ใช่" หรือ "ใช่" (ตอนนี้กำหนดให้มีสองคำตอบไปก่อน การใช้หลักการเดียวกันมาใช้กับการจัดหมวดหมู่ที่มีหลายคำตอบ ทำได้โดยการใช้ Softmax function ซึ่งจะกล่าวถึงภายหลัง)
แต่ในความเป็นจริง เราไม่สามารถมั่นใจอะไรได้ร้อยเปอร์เซ็น ว่าคำตอบคือ "ไม่ใช่" หรือ "ใช่" ดังนั้น สิ่งที่เราต้องการ คือเราจะสร้าง Hypothesis function ที่ให้ค่าความเป็นไปได้ ที่คำตอบจะคือ "ไม่ใช่" หรือ "ใช่" โดยกำหนดขอบเขตการตัดสินใจ (Decision boundary) ไว้ที่ 0.5 ซึ่งจะทำให้เราได้ขอบเขตการตัดสินใจดังนี้:
```tex
y = 1 \text{ if } h_\theta(x) \geq 0.5\tag{1.1}
y = 0 \text{ if } h_\theta(x) < 0.5\tag{1.2}
```
โดย `h_\\theta(x)` คือ Hypothesis function ที่มี x เป็น Input ซึ่งอยู่ในรูปของ:
`h_\theta(x) = \sigma(z)\tag{2}`
`\sigma(z)` อ่านว่า Sigma และ อ่านว่า Sigmoid z ซึ่ง `\sigma(z)` นี้เป็นฟังก์ชันที่เรียกว่า Sigmoid function หรือ Logistic function ซึ่งเป็นที่มาของชื่อ Logistic regression นั่นเอง
`\sigma(z) = \frac{1}{1+e^{-z}}\tag{3}`
* แกนนอนคือ Input ซึ่งในที่นี้คือ `z` ส่วนแกนตั้งคือ Output ซึ่งในที่นี้คือ `h_\theta(x) = \sigma(z)`
* สังเกตว่าเมื่อ `z` มีค่ามาก จะมีค่าเข้าใกล้ 1 ส่วนเมื่อ `z` มีค่าน้อย `\sigma(z)` จะมีค่าเข้าใกล้ 0
* สังเกตว่าเมื่อ `z = 0`, `\sigma(z)=0.5` ซึ่งอยู่กึ่งกลางระหว่าง Limit ด้านบน คือ 1 และ Limit ด้านล่าง คือ 0 ดังนั้นเราจึงเลือก 0.5 เป็นขอบเขตการตัดสินใจนั่นเอง
* `e`คือค่าคงที่ของ Euler มีค่าเท่ากับ 2.7182 (และทศนิยมลำดับต่อไปเรื่อยๆ)
* `z` คือ Linear function `z = wx` ซึ่งเราเคยใช้ใน Linear regression โดยไม่มีตัวแปร Intercept `b`
นั่นหมายความว่า:
`\sigma(z) = \frac{1}{1+e^{-(wx)}}\tag{4}`
อนึ่ง สำหรับใครที่สนใจจะเขียน Algorithm เอง จะควรจะแปลง `wx` ให้เป็น Vectorised form เพื่อเร่งความเร็วในการคำนวน ซึ่งมีวิธีคือหาการ Dot product ของ W transpose และ X (ทั้งคู่เป็น Matrix) ดังนั้นเราจะได้ Sigmoid function ดังนี้:
`\sigma(Z) = \frac{1}{1+e^{-(W^T X)}}\tag{5}`
เมื่อได้ Hypotheses function แล้ว หน้าที่ของเรา คือการหาค่า w ที่จะทำให้ค่าความคลาดเคลื่อนระหว่าง `h_\theta(x)` กับ `y` นั้นน้อยที่สุด การที่จะทำให้ค่าความคลาดเคลื่อนน้อยที่สุดดังกล่าว ก็ต้องอาศัย Cost function และการหา Gradient descent ของ Cost function เหมือนที่เราเคยทำ
### Cost function
สำหรับ Logistic regression เราจะใช้ Cost function ดังนี้:
```tex
\text{cost}(h_\theta(x),y) =
\begin{cases}
-\log h_\theta(x) \text{ if } y = 1 \\
-\log(1 - h_\theta(x)) \text{ if } y = 0
\end{cases}\tag{6}
```
ลองทำความเข้าใจเงื่อนไขของ Cost function ด้านบน พิจารณาว่าหน้าที่ของ Cost function คือการหาค่าตัวแปรที่จะส่งผลให้ Cost นั้นต่ำที่สุด ซึ่งแบ่งได้เป็น 2 กรณี คือเมื่อ y เท่ากับ 1 และ y เท่ากับ 0
โดยในกรณีของ y เท่ากับ 1 หากเราได้ Hypothesis function `h_\theta(x) = 1` จะทำให้ Cost function ซึ่งก็คือ `-\log h_\theta(x) = 0` ซึ่งมีค่าน้อยที่สุดที่จะเป็นไปได้ ดังนั้นเราจึงใช้ `-\log h_\theta(x)` เป็นตัวแทนของ Cost function ในกรณี y=1
ส่วนในกรณีของ y เท่ากับ 0 หากเราได้ Hypothesis function `h_\theta(x) = 0` จะทำให้ Cost function ซึ่งก็คือ `-\log(1 - h_\theta(x)) = 0` ซึ่งมีค่าน้อยที่สุดที่จะเป็นไปได้ ดังนั้นเราจึงใช้ `-\log(1 - h_\theta(x))` เป็นตัวแทนของ Cost function ในกรณี `y=0`
เงื่อนไขทั้งสองแบบ สามารถนำมารวมกันเป็นสมการเดียวได้ว่า:
```tex
\text{cost}(h_\theta(x),y) = -y\log(h_\theta(x)) - (1-y)\log(1-h_\theta(x))\tag{7}
```
นำ Cost function นี้มาใส่ในรูปแบบ Cost function ของ Linear regression:
```tex
J(\theta) = \frac{1}{m} \sum\limits_{i = 1}^m \text{cost}(h_\theta(x^{(i)}), y^{(i)})\tag{8}
```
จะได้ Cost function เต็มรูปแบบ คือ:
```tex
J(\theta) = - \frac{1}{m} \sum\limits_{i = 1}^m \left( y^{(i)}\log h_\theta(x^{(i)}) + (1-y^{(i)})\log(1-h_\theta(x^{(i)})) \right) \tag{9}
```
หรือใน Vectorised form ดังนี้:
```tex
J(\theta) = \frac{1}{m} \cdot \left( -y^T \log (h) - (1-y)^T \log (1-h) \right) \tag{10}
```
### Gradient descent
เชื่อหรือไม่ว่าอนุพันธ์ของ J(θ) ของ Logistic regression cost function นั้นเหมือนกับอนุพันธ์ J(θ) ของ Linear regression cost function:
```tex
\theta_j := \theta_j - \alpha \frac{1}{m} \sum\limits_{i = 1}^m(h_\theta (x^{(i)}) - y^{(i)})x_j^{(i)}\tag{11}
```
ส่วน Vectorized version ก็คือ:
```tex
\theta := \theta - \frac{\alpha}{m} X^T(\sigma(X\theta) - y)\tag{12}
```
ดังนั้น วิธีการอับเดตตัวแปรจึงทำเหมือน Linear regression ทุกประการ
#### Softmax function
Algorithm ของเราสามารถให้คำตอบสำหรับปัญหาที่มีคำตอบแค่ 2 ค่า คือ 1 กับ 0 เรียกว่า Binary classification แล้วถ้าคำตอบมีหลายค่า เช่นในโจทย์ของเรา ที่ต้องการจำแนกดอก Iris ออกเป็น 3 สายพันธุ์ล่ะ เราเรียกปัญหาแบบนี้ว่า Multiclass classification
Logistic Regression สามารถให้คำตอบปัญหา Multiclass classification โดยการแก้ไขรายละเอียดของกลไกเล็กน้อย ซึ่งจบลงที่การใช้ Softmax function ตอน Output โดยมีหลักการและขั้นตอนดังนี้:
1) คำนวนหาผลลัพธ์ Linear function `z` ของแต่ละ Class `k`:
```tex
z_k = \theta_k^T x\tag{13}
```
เช่นกรณีของเรา มี `k = 3` เราจะได้ , , และ ของข้อมูลแต่ละรายการ
2) นำ `z_k` ไปประกอบกันใน Softmax function แทน Logistic function เดิม ดังนี้:
```tex
\hat{p}_k = \sigma(z)_k = \frac{e^{z_k}}{\sum\limits_{j = 1}^K e^{z_j}}\tag{14}
```
* `\hat{p}_k` คือความเป็นไปได้ที่รายการนี้จะอยู่ใน Class `k`
* `\sigma(z)_k` เป็นค่าความเป็นไปได้ที่รายการนี้จะอยู่ใน Class `k` โดยเทียบกับคะแนน Linear function ของแต่ละ Class ของรายการนั้น
โดย Softmax จะเลือกพยากรณ์ Class ที่ได้คะแนนความเป็นไปได้สูงที่สุด
ถ้าอ่านแล้วงง ลองโค้ด Softmax function ใน Python ดู:
```python
z = [1, 2, 3]
p = np.exp(z)/np.sum(np.exp(z))
```
เมื่อเรียก p จะได้ผลว่า array([0.09003057, 0.24472847, 0.66524096]) แปลว่าถ้า Linear function z ของ Class แรก ให้ผลเท่ากับ 1 ความเป็นไปได้ของ Class นี้จะเท่ากับ 9% เมื่อเทียบกับ Class ที่สอง (2 --> 24.47%) และ Class ที่สาม (3 --> 66.52%) ดังนั้น Softmax function จะเลือก Class 3 เป็นคำตอบ
3) Algorithm จะนำ `p\hat{p}_k` ไปคำนวนใน Cost function ที่ดัดแปลงจากเดิมเล็กน้อย เรียกว่า Cross entropy cost function เพื่อหา Global minimum ที่จะทำให้ความต่างของค่าที่พยากรณ์กับค่าจริงมีน้อยที่สุด:
```tex
J(\theta) = - \frac{1}{m} \sum\limits_{i = 1}^m \sum\limits_{k = 1}^K y^{(i)}_k \log(\hat{p}^{(i)}_k) \tag{15}
```
* `y^{(i)}_k` คือค่าจริงที่รายการที่ `i` จะอยู่ใน Class `k` ซึ่งจะมีค่า 1 หรือ 0
4) หาอนุพันธ์ในกระบวนการ Gradient descent โดยใช้สูตรเดิม:
```tex
\theta_j := \theta_j - \alpha \frac{1}{m} \sum\limits_{i = 1}^m(\hat{p}^{(i)}_k - y^{(i)}_k)x^{(i)}\tag{16}
```
อนึ่ง ฟังก์ชัน `LogisticRegression` ใน scikit-learn จะเลือกใช้ Softmax function โดยอัตโนมัติอยู่แล้ว โดยดูจากข้อมูล Label `y` ของเรา ซึ่งสะดวกมาก ไม่ต้องทำอะไรเพิ่มแล้ว แค่เรียกฟังก์ชัน
### Modelling
ตอนนี้เราก็พร้อมแล้วในการสร้างโมเดล โดยเรียก Class `LogisticRegression` และพ่วง Method `.fit` เพื่อสร้างเทรนโมเดลไปเลย
```python
# Train the model
logreg = LogisticRegression(max_iter=200, random_state=42).fit(X_train, y_train)
```
จะเห็นว่า Class `LogisticRegression` มี Argument `max-iter` อยู่ด้วย Argument นี้ทำหน้าที่ควบคุม Hyperparameter ของโมเดล โดยเราสามารถกำหนดว่าจะให้ Algorithm (เรียกใน scikit-learn ว่า "Solver") ทำงานกี่รอบ ในลักษณะเดียวกับที่ Gradient descent อับเดต Parameter ซ้ำไปเรื่อยๆ เพื่อให้ Cost function ลดลงทุกๆ รอบ
อันที่จริง แต่ละโมเดลจะมี Argument แบบนี้มากมาย เช่น `LogisticRegression` มี Argument ดังนี้ (ดูจากเอกสารอ้างอิงของ scikit-learn):
```
class sklearn.linear_model.LogisticRegression(penalty='l2', dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)
```
เราจะพูดถึง Hyperparameter เหล่านี้ในหัวข้อถัดไป ในขั้นนี้เพียงแค่ให้รู้ก่อนว่าเราสามารถกำหนดค่าต่างๆ เพื่อปรับแต่งโมเดลของเราได้ในที่นี้
### Evaluate
เมื่อเทรนโมเดลแล้ว เราก็มีประเมินความแม่นยำกัน:
```python
# Evaluate the model's accuracy
print("Train set accuracy = " + str(logreg.score(X_train, y_train)))
print("Test set accuracy = " + str(logreg.score(X_test, y_test)))
```
ได้ผลว่า:
```
Train set accuracy = 0.9642857142857143
Test set accuracy = 1.0
```
นั่นคือเมื่อเทรนกับ Train set ได้ความแม่นยำ 96.42% ส่วนเมื่อนำมาทดสอบกับ Test set ได้ความแม่นยำถึง 100% ทีเดียว
สำหรับวิธีการคำนวนความแม่นยำของ Logistic regression สูตรนั้นง่ายมาก คือคำนวนว่าสัดส่วนระหว่าง `h_\theta(x)` ที่ให้ค่าตรงกับ y ที่แท้จริงนั้น เป็นเท่าไหร่
### Predict
มาลองดูกันว่าเวลาเราต้องการพยากรณ์จริงๆ นั้นทำอย่างไร สมมุติว่าเราไปเจอดอก Iris ที่อยากรู้ว่าเป็นสายพันธุ์ไหน เราจึงไปวัด Feature ทั้ง 4 มา ได้ว่า:
* sepal length 6 cm
* sepal width 2.5 cm
* petal length 4 cm
* petal width 1.5 cm
เราจะต้องใส่ข้อมูลนี้ลงไปในให้โมเดลพยากรณ์ โดยทำข้อมูลให้อยู่ในรูปแบบและมิติเดียวกันกับ X ที่เอาไว้เทรน ซึ่งถ้าจำได้ เราเคยหามิติของ X ไว้ ได้ดังนี้:
```
X_shape shape is: (150, 4)
```
คือเป็น Array ขนาด 150 แถว 4 คอลัมน์ โดยแต่ละแถวคือ 1 รายการ ดังนั้น X ใหม่ของเรา ตั้งชื่อว่า `X_new` จีงจะต้องเป็น Array มิติ (1, 4) ซึ่งเขียนใน Python ได้ว่า `np.array([[6, 2.5, 4, 1.5]])`:
```python
# Make a prediction
X_new = np.array([[6, 2.5, 4, 1.5]])
y_pred = logreg.predict(X_new)
y_pred_prob = logreg.predict_proba(X_new)
print("Prediction:", y_pred, "with the probability array:", y_pred_prob)
print("Predicted target name:", iris["target_names"][y_pred])
```
ได้คำตอบคือ:
```
Prediction: [1] with the probability array: [[0.01372466 0.91809317 0.06818217]]
Predicted target name: ['versicolor']
```
นั่นคือโมเดลได้พยากรณ์ว่าดอก Iris ดอกนี้ เป็นสายพันธุ์ Versicolor โดยมีความมั่นใจ 91.8% อย่างไรก็ตามก็มีความเป็นไปได้ที่จะเป็นสายพันธุ์ Setosa 1.37% และ Virginica 6.81%
ถ้าดูโค้ดแล้วงง ลองพิจารณารายละเอียดดังนี้:
* Method `.predict_proba` หมายว่าว่า ให้พยากรณ์โดย Output ออกเป็น Array ของความเป็นไปได้
* ทำไม `iris["target_names"][y_pred]` จึงให้ผลออกมาเป็นชื่อสายพันธุ์ได้ ถ้าจำได้ตอนต้น เรารู้ว่าชุดข้อมูลนี้ได้เตรียม Dictionary key ที่ชื่อ `target_names` ไว้ให้ โดยมีค่าว่า `['setosa' 'versicolor' 'virginica']` คำสั่งนี้คือการเรียกค่าของ Key `target_names` ลำดับที่ `[y_pred]` ซึ่งในที่นี้คือ `[1]` นั่นเอง
### สรุป
เป็นอันว่าเราสร้างโมเดล Logistic regression เพื่อพยากรณ์ปัญหา Multiclass classification สำเร็จ
ในบทต่อไปจะเจาะลึกรายละเอียดเกี่ยวกับการเตรียมข้อมูล โดยเฉพาะข้อมูลที่เป็นข้อความหรือหมวดหมู่ ซึ่งเราต้องแปลงให้เป็นตัวเลขเสียก่อน
## บทที่ 5 Categorical Encoding
ในบทนี้เราจะเริ่มมาเจาะลึกในรายละเอียด โดยจะอธิบายเรื่องการเตรียมข้อมูลให้มีความพร้อมสำหรับการสร้างโมเดล
เราได้ลองสร้าง Machine learning model มาสองเรื่องแล้ว ถ้าสังเกตว่าพบว่า ข้อมูล Input `x` นั้นจะต้องเป็นตัวเลข แต่ในความเป็นจริง เรามักได้ข้อมูลมาเป็นข้อความ เช่น \[ใช่, ไม่ใช่\] หรือ \[น้อย, กลาง, มาก\] ถ้าเรามีข้อมูลแบบนี้ เราจะต้องแปลงข้อมูลที่เป็นข้อความหรือหมวดหมู่ ให้เป็นตัวเลขเสียก่อน
สมมุติเรามีข้อมูลรายได้ ระดับความสุข ภูมิภาคที่อาศัย และอายุขัย ทั้งหมด 20 ตัวอย่าง เราต้องการพยากรณ์อายุขัยโดยใช้ข้อมูล 3 อย่างแรก:
| Income | Happiness | Area | LifeExpectancy |
| --- | --- | --- | --- |
| 132546 | High | BKK | 80 |
| 190998 | Medium | NE | 75 |
| 49308 | Medium | S | 72 |
| 32062 | Low | NE | 59 |
| 71707 | High | BKK | 65 |
(แสดง 5 ตัวอย่างแรก)
จะเห็นว่า:
* Income หรือรายได้ เป็นตัวเลขอยู่แล้ว
* Happiness หรือระดับความสุข เป็นหมวดหมู่ มี 3 ค่า คือ \[High, Medium, Low\]
* Area หรือภูมิภาคที่อาศัย เป็นหมวดหมู่ มี 4 ค่า คือ \[BKK, NE, S, N\]
* LifeExpectacy เป็นตัวเลขอยู่แล้ว
หน้าที่ของเราคือจะต้องแปลง Happiness และ Area เป็นตัวเลข โดยหลักการมี 2 ขั้น ได้แก่
### Factorisation
คือการแทนค่าในแต่ละหมวดด้วยตัวเลขต่างๆ กัน เช่น High = 0, Medium = 1, Low = 2 เป็นต้น โดยเราสามารถแปลงเองใน Excel หรือจะให้ pandas แปลงให้ก็ได้ ลองเขียนโค้ดตั้งแต่เริ่มต้นดังนี้:
```python
import numpy as np
import pandas as pd
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn import metrics
import matplotlib.pyplot as plt
# Load the dataset
df = pd.read_csv("data/life_expectancy.csv")
# Explore
print(df.head())
print(df.info())
print(df.describe())
```
เราจะเห็นว่า Income และ LifeExpectancy เป็นจำนวนเต็ม (`int64`) ส่วน Happiness และ Area เป็น `object` ซึ่งสองตัวนี้เป็นสิ่งที่เราต้องจัดการ
```
RangeIndex: 20 entries, 0 to 19
Data columns (total 4 columns):
Income 20 non-null int64
Happiness 20 non-null object
Area 20 non-null object
LifeExpectancy 20 non-null int64
dtypes: int64(2), object(2)
```
จากนั้นให้เลือกเฉพาะคอลัมน์ที่เป็น `object` แล้วลองดูข้อมูลที่ถูกเลือก
```python
# Limit to categorical data using df.select_dtypes()
df_categories = df.select_dtypes(include=[object])
print(df_categories.head())
print(df_categories.columns)
print(df_categories.shape)
```
จะได้ Dataframe ใหม่ที่มีคอลัมน์ Happiness และ Area เท่านั้นตามต้องการ และมีมิติ (20, 2)
```
Index(['Happiness', 'Area'], dtype='object')
(20, 2)
```
จากนั้นเรียก Class `LabelEncoder()` ใส่เป็น Argument ของ Method `.apply` ของ Dataframe ใหม่ของเรา แล้วพ่วง Method `.fit_transform` เพื่อแปลง scipy sparse matrix ให้เป็น numpy dense matrix ซึ่งอยู่ในรูปแบบที่เราจะใช้
```python
# Create a LabelEncoder object and fit it to each feature in X
X_label = df_categories.apply(LabelEncoder().fit_transform)
print(X_label.head())
```
ถ้างง บรรทัดนี้คือการสั่งให้ Dataframe ของเราดำเนินการเข้ารหัส Label จากข้อความให้กลายเป็นตัวเลข แล้วแปลงผลลัพธ์ให้อยู่ในรูปแบบที่เอาไปใช้ต่อในการเทรนโมเดลได้
ได้ผลคือ:
```
Happiness Area
0 0 0
1 2 2
2 2 3
3 1 2
4 0 0
```
ถ้าลองเทียบกลับกับข้อมูลจริง เราจะได้คู่รหัสดังนี้:
* {0: "Happiness-Hi", 1: "Happiness-Lo", 2: "Happiness-Mid"}
* {0: "Area-BKK", 1: "Area-N", 2: "Area-S", 3: "Area-NE"}
จากนั้นไปสู่ขั้นตอนต่อไป คือการเข้ารหัส One-hot encoding
### One-hot encoding
ขั้นตอนที่แล้ว เราได้รหัสตัวเลขเดี่ยวๆ แทน Label ของแต่ละคอลัมน์ จริงๆ ดูเหมือนเราน่าจะนำรหัสนี้ไปใช้เป็น Input ของโมเดลได้เลย ซึ่งจริงในบางกรณี อธิบายคือการเข้ารหัสแบบ Factorisation ตัวเลขที่อยู่ใกล้กันจะถูกตีความว่ามี "คุณค่า" ใกล้กัน เช่น 1 กับ 2 ใกล้กันมากกว่า 1 กับ 3 ดังนั้น ถ้าค่าจริงของ 1, 2, 3 มีความสัมพันธ์เชิงคุณค่าที่ต่อเนื่องกัน เราก็สามารถใช้ Factorisation ได้เลย เช่นถ้า 1 แปลว่า "น้อย", 2 แปลว่า "ปานกลาง", และ 3 แปลว่า "มาก" เป็นต้น
แต่ในความเป็นจริง มีหลายกรณีที่ค่าจริงของแต่ละเลขนั้นไม่ได้มีความสัมพันธ์ต่อเนื่องเป็นลำดับขั้นกัน เช่นในกรณีภูมิภาคที่อยู่อาศัย ค่าของแต่ละเลขล้วนมีความหมายของมันเอง และไม่เกี่ยวข้องทางลำดับชั้นกับค่าอื่น
วิธีการแก้ปัญหานี้ คือการใช้ One-hot encoding ซึ่งคือการเข้ารหัสแบบ Binary แทนแต่ละ Label ตัวอย่างเช่น [1, 0, 0, 0] แทน BKK (กทม.), [0, 1, 0, 0] แทน N (ภาคเหนือ) เป็นต้น วิธีการนี้จะทำให้ Label แต่ละอันนั้นเป็นอิสระต่อกัน ทำให้การสร้างโมเดลนั้นแม่นยำมากขึ้น
วิธีการทำ One-hot encoding คือ:
```python
# Create a OneHotEncoder object, and fit it to all of X
X_1hot = OneHotEncoder().fit_transform(X_label).toarray()
print(X_1hot[0:5, :])
print(X_1hot.shape)
```
### Re-creating input X
ทบทวนว่าตอนนี้เรามี Dataframe อยู่ 2 ชุด
* `df` คือ Dataframe ต้นฉบับ มีหัวข้อคือ Income, Happiness, Area, และ LifeExpectancy
* `df_1hot` คือ Dataframe เฉพาะ Happiness และ Area ที่ถูกเข้ารหัส (และขยายขนาด) ด้วย One-hot encoding แล้ว
ทีนี้เรารู้ว่าการจะเทรนโมเดล เราจะต้องเตรียม Dataframe 2 ชุด คือ X ซึ่งเป็น Input ทั้งหมด และ y ซึ่งเป็น Label คำตอบทั้งหมด จะทำอย่างไรดี? อธิบายไปตอนนี้อาจจะงง ลองมาดูโค้ดแล้วอธิบายด้วยโค้ดดีกว่า:
```python
# Recombine numerical and one-hot dataframes to make X
df_1hot = pd.DataFrame(X_1hot)
X = pd.concat([df["Income"], df_1hot], axis=1, sort=False,)
X.columns = ["Income",
"Happiness-Hi", "Happiness-Lo", "Happiness-Mid",
"Area-BKK", "Area-N", "Area-S", "Area-NE"]
y = df["LifeExpectancy"]
print(X.head())
print(X.shape)
print(y.head())
print(y.shape)
```
อธิบายดังนี้:
* เราจะรวม Dataframe เข้าด้วยกัน ดังนั้น ขั้นแรกเราต้องแปลง `X_1hot` ที่เป็น Array ให้เป็น pandas dataframe ก่อน ตั้งชื่อว่า `df_1hot`
* จากนั้นเราประกอบ Dataframe ใหม่ที่จะเป็น X ของเรา ด้วยการ "ต่อ" (Concatenate) คอลัมน์ Income ของ `df` ต้นฉบับ เข้ากับ `df_1hot` ทั้งหมด โดยกำหนด Argument `axis=1` เพื่อให้ต่อออกไปทางแนวนอน
* เพื่อความไม่สับสนและเอาไว้อ้างอิง เราจะตั้งชื่อคอลัมน์ใหม่ให้ Dataframe X ของเรา เช่น รหัสแรกของ Happiness ถ้ามีเลข 1 ตรงนั้น (\[1, 0, 0\]) แปลว่า Happiness-Hi เป็นต้น
* สุดท้ายก็สร้าง Dataframe y โดยเลือกเฉพาะคอลัมน์ที่เป็นคำตอบ จาก Dataframe `df` ต้นฉบับ
อย่าลืมตรวจดูว่าผลที่ได้นั้นเป็นไปตามที่เราคิด ด้วยการ `print` head และ shape ของ X กับ y ออกมาดู
เป็นอันว่าเราได้ Dataframe X และ y ที่พร้อมสำหรับการสร้างโมเดลแล้ว
### Model training
เรามาฝึกโมเดล Linear regression กันเลย โดนอย่าลืมแยกข้อมูลออกเป็น Train set กับ Test set ก่อน:
```python
# Split the data into train and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
print("X_train shape is:", X_train.shape)
print("y_train shape is:", y_train.shape)
print("X_test shape is:", X_test.shape)
print("y_test shape is:", y_test.shape)
# Train the model
lr = LinearRegression().fit(X_train, y_train)
coeff_df = pd.DataFrame(lr.coef_, X.columns, columns=['Coefficient'])
print(coeff_df)
```
พอฝึกแล้ว มาลองดูว่าโมเดลให้คำตอบเป็นค่า Coefficient ของน้ำหนักสำหรับแต่ละ Feature อย่างไร สำหรับ Linear regression หลายตัวแปร หรือที่เรียกว่า Multivariate linear regression นี้ สูตร Linear function คือ:
```tex
\hat{y} = w_1x_1 + w_2x_2 + w_3x_3 + \dots + w_nx_n\ + b \tag{1}
```
โดย `n` คือจำนวน Feature ซึ่งในกรณีของเราคือ 8
เราสามารถสร้างตารางแสดงค่า Coefficient ของแต่ละ Feature ได้ด้วย pandas dataframe โดยกำหนดใน Argument ให้ `lr.coef_` เป็น Input, ให้ชื่อคอลัมน์ `X.columns` เป็น Label แกนนอน และตั้งชื่อคอลัมน์โดยการกำหนด `columns=['Coefficient']` ได้ผลดังนี้:
```
Coefficient
Income 0.000055
Happiness-Hi 8.306516
Happiness-Lo -8.859939
Happiness-Mid 0.553423
Area-BKK -9.442937
Area-N 3.505052
Area-S 4.850387
Area-NE 1.087498
```
จากนั้น เราลองมาดูเลยดีกว่าว่าค่าที่พยากรณ์ได้เทียบกับค่าจริงใน Test set เป็นอย่างไร:
```python
# Make a prediction on test set
y_pred = lr.predict(X_test)
df_pred = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})
print(df_pred)
```
เราพยากรณ์ `y_pred` โดยใช้ `X_test` เป็น Input เพื่อให้ `y_pred` ที่ได้ สามารถนำไปเปรียบเทียบกับ `y_test` ที่เรารู้ค่าอยู่แล้ว เราป้อนทั้งสองตัวเป็น Input ของ pandas dataframe จะได้ผลว่า:
```
Actual Predicted
3 59 63.213900
16 89 74.945451
6 49 60.294754
10 76 82.234579
2 72 69.815254
```
ผลที่ได้ไม่ไกล แต่ก็ไม่ถึงกับใกล้ เราอยากรู้เพิ่ม จึงลองคำนวนค่าเฉลี่ยของ `y_test` และ `y_pred` ดู:
```python
print("Mean of y_test is", np.mean(np.array(y_test)))
print("Mean of y_pred is", np.mean(y_pred))
```
ได้ผลว่า:
```
Mean of y_test is 69.0
Mean of y_pred is 70.10078755113827
```
ซึ่งใกล้กันมาก แสดงว่าการพยากรณ์แต่ละรายการ มีความแปรผันมาก เลยลองพล็อตกราฟเทียบให้เห็นๆ:
```python
# Plot the conparison between actual and predicted y
df_pred.plot(kind="bar", figsize=(9,7))
plt.show()
```
### Evaluation metrics
การดูด้วยตาย่อมไม่เพียงพอ เราเลยต้องลองใช้มาตรวัดต่างๆ สำหรับ Linear regression มาวัดดู:
```python
# Evaluate the model
print("Train set R2-score = " + str(lr.score(X_train, y_train)))
print("Test set R2-score = " + str(lr.score(X_test, y_test)))
print('Test set Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))
print('Test set Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))
print('Test set Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
```
ผลที่ได้มีดังนี้:
```
Train set R2-score = 0.5401999191488698
Test set R2-score = 0.5965533912121594
Test set Mean Absolute Error: 7.596505622473046
Test set Mean Squared Error: 77.30037024375025
Test set Root Mean Squared Error: 8.792062911726136
```
อธิบายดังนี้
1) `R^2` Score วัดค่าสะสมของความต่างระหว่างค่าจริงกับค่าที่พยากรณ์ได้ เมื่อเทียบกับค่าสะสมระหว่างค่าจริงกับค่าเฉลี่ยของค่าจริงทั้งหมด:
```tex
R^2 = 1 - \frac{SS_{res}}{SS_{tot}}\tag{2}
SS_{res} = \sum\limits_{i = 1}^m(y_i - \hat{y}_i)^2\tag{3}
SS_{tot} = \sum\limits_{i = 1}^m(y_i - \bar{y}_i)^2\tag{4}
```
2) Mean Absolute Error (MAE) วัดค่าเฉลี่ยของผลรวมความต่างระหว่างค่าจริงกับค่าที่พยากรณ์ได้:
```tex
MAE = \frac{1}{m} \sum\limits_{i = 1}^m|y_i - \hat{y}_i|\tag{5}
```
วัดค่าเฉลี่ยของความคลาดเคลื่อนของทั้งโมเดล
3) Mean Squared Error (MSE) วัดค่าเฉลี่ยของผลรวมยกกำลังสองของความต่างระหว่างค่าจริงกับค่าที่พยากรณ์ได้:
```tex
MSE = \frac{1}{m} \sum\limits_{i = 1}^m(y_i - \hat{y}_i)^2\tag{6}
```
สำหรับ MSE ตัวอย่างบางตัวที่มีความคลาดเคลื่อนระหว่างค่าจริงกับค่าพยากรณ์สูง จะถูกให้ค่าน้ำหนักมากเป็นทวีคูณ ดังนั้น MSE จึงชี้วัดได้ดีว่าโมเดลของเรามีตัวอย่างที่มีค่าความคลาดเคลื่อนสูงผิดปกติหรือไม่ (Sensitive to outliers)
4) Root Mean Squared Error (RMSE) คือ Square root ของ MSE:
```tex
RMSE = \sqrt{\frac{1}{m} \sum\limits_{i = 1}^m(y_i - \hat{y}_i)^2}\tag{7}
```
RMSE ใช้ Square root แปลง MSE กลับมาให้มีหน่วยใกล้เคียงกับ MAE เพื่อให้ตีความเปรียบเทียบได้ง่ายขึ้น สามารถชี้วัดการกระจายตัวของค่าความคลาดเคลื่อนได้ดี ในกรณีของเราให้ค่าใกล้เคียงกับ MAE คือประมาณ ~ 7-8
จะเห็นว่าโมเดลของเรายังพยากรณ์ได้ไม่ดีนัก ซึ่งมีสาเหตุและทางแก้ดังนี้:
* โมเดลเทรนบนข้อมูลขนาดเล็กมาก คือ Train set 15 รายการเท่านั้น Machine learning ต้องการข้อมูลจำนวนมากกว่านั้นมาก อย่างต่ำๆ ควรจะเป็นหลักหลายๆ ร้อย หรือหลักพัน โดยสำหรับ Linear regression ที่เส้นพยากรณ์เป็นเส้นตรง การที่มีข้อมูลจำนวนมากจะทำให้ค่าความคลาดเคลื่อนโดยเฉลี่ยนั้นลดลง ปัญหานี้เรียกว่าปัญหา Bias ซึ่งตรงข้ามกับปัญหา Variance ที่เป็นโมเดลที่ฟิตกับ Train set มากแต่พยากรณ์ Test set ได้ไม่ดี เราจะพูดถึงปัญหาเหล่านี้ในบทถัดๆ ไป
* ข้อมูลอาจจะมีความแปรผันมากจนสมการเส้นตรง `\hat{y} = w_1x_1 + w_2x_2 + \dots + w_nx_n\ + b` ไม่สามารถฟิตกับข้อมูลได้ดี ถ้าเรามีข้อมูลมากขึ้น เราอาจะลองพล็อต Scatterplot เพื่อดูรูปร่างความสัมพันธ์ข้อมูล แล้วเปลี่ยนสูตร Algorithm ให้ใช้ Hypothesis function ที่เหมาะสมกับรูปร่างข้อมูลขึ้น เช่น หากพบว่าความสัมพันธ์ใน Scatterplot เป็นเส้นโค้ง อาจพิจารณาใช้ Quadratic function ในรูปแบบ `\hat{y} = w_1x^2_1 + w_2x_2 + \dots + w_nx_n\ + b` เรียกว่า Polynomial regression ซึ่งสามารถหา Class ใน scikit-learn ใช้ได้
เป็นอันว่าเราสามารถแปลงข้อมูลที่เป็นข้อความหรือหมวดหมู่ให้เป็นตัวเลขได้แล้ว บทต่อไปเราจะพูดถึงการทำ Feature scaling ซึ่งเป็นอีกขั้นตอนของการเตรียมข้อมูล
## บทที่ 6 Feature Scaling
Machine learning algorithm หลายตัว เช่น SVM และ Neural Networks จะทำงานได้ดีเมื่อข้อมูล Input อยู่ใน Scale มาตรฐาน นั่นคือมีค่าเฉลี่ย Mean เท่ากับ 0 และ Variance เท่ากับ 1 ดังนั้นหากเราใช้ Algorithm เหล่านี้ หรือลองเทรนโมเดลแล้วได้ค่าความแม่นยำต่ำ หรือใช้เวลานานมากในการเทรน ให้ลองเปลี่ยน Scale ของ Feature ดู
Feature scaling มีหลายสูตร แต่สูตรที่ใช้งานได้ดีและเป็นที่นิยม คือสูตร `StandardScaler` ใน `preprocessing` module ของ scikit-learn โดย `StandardScaler` จะมีสูตรดังนี้:
```tex
x_{i (scaled)} = \frac{x_i-\mu}{\sigma}\tag{1}
```
* `x_i` คือ Input `x`
* `\mu` คือค่า Mean ของ Input `x` ทั้งหมด
* `\sigma` คือส่วนเบี่ยงเบนมาตรฐาน หรือ Standard deviation ของ Input `x` ทั้งหมด ซึ่งคิดมาจาก Square root ของ Variance
โดย Variance (`\sigma^2`) มีสูตรคือ:
```tex
\sigma^2 = \frac{1}{m} \sum\limits_{i = 1}^m (x_i-\mu)^2\tag{2}
```
ค่า `x` ที่ Scale แล้ว จะกระจายตัวออกรอบๆ 0 และรวมกันจะมีส่วนเบี่ยงเบนมาตรฐานเท่ากับ 1 ซึ่งเดี๋ยวจะพิสูจน์ให้ดู
เรามาลองทำ `StandardScaler` กัน โดยโหลดข้อมูลมาก่อน:
```python
import numpy as np
import pandas as pd
from sklearn.preprocessing import scale
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
# Load the dataset
df = pd.read_csv("data/life_expectancy.csv")
print(df.head())
```
ซึ่งเป็นชุดข้อมูลเดิมจากบทที่ 5 มีหน้าตาดังนี้:
```
Income Happiness Area LifeExpectancy
0 132546 High BKK 80
1 190998 Medium NE 75
2 49308 Medium S 72
3 32062 Low NE 59
4 71707 High BKK 65
```
เราจะลองทำ Scaling เฉพาะ Feature "Income" และ Label "LifeExpectancy" โดยในความจริงเราไม่จำเป็นต้อง Scale label แต่จะทำให้ดูเพื่อพล็อต Scatterplot แสดงว่าความสัมพันธ์ของข้อมูลยังคงเหมือนเดิมหลังจาก Scale แล้ว
สมมุติว่าจะสร้างโมเดลเฉพาะความสัมพันธ์ระหว่าง `Income` กับ `LifeExpectancy` ลองพล็อต Scatterplot ดูดังนี้:
```python
# Plot Income against LifeExpectancy before scaling
plt.scatter(df["Income"], df["LifeExpectancy"])
```
ก่อนเราจะทำการ Scale มาเตรียมข้อมูลให้เป็น numpy array กันก่อนเพื่อให้ไม่ต้องเรียกคอลัมน์จาก pandas ทุกๆ ครั้ง:
```python
# Prep X and y
x = np.array(df["Income"]).reshape(-1,1)
y = np.array(df["LifeExpectancy"]).reshape(-1,1)
print(x.shape)
print(y.shape)
```
ได้มิติ `x` และ `y` เป็น (20, 1) ทั้งคู่
ต่อมาเราจะ Scale ข้อมูลสองหมวดนี้กันเลย โดยมี 2 วิธีดังนี้:
1) Function `scale`
เป็นวิธีที่ง่ายและสั้น ทำได้โดย:
```python
# Method 1: Apply scaling using scale function
x_scaled = scale(x)
y_scaled = scale(y)
print(x_scaled[:5, :])
print(y_scaled[:5, :])
```
ได้ผลว่า:
```
[[ 0.47792414]
[ 1.38439361]
[-0.81292487]
[-1.08037462]
[-0.46556277]]
[[ 0.77057895]
[ 0.35850465]
[ 0.11126006]
[-0.96013313]
[-0.46564397]]
```
2) Class `StandardScaler`
วิธีนี้จะใช้ Transformer API คำนวน Mean และ Standard deviation ก่อน เพื่อนำค่าทั้งสองไปใช้ประโยชน์ภายหลังได้ เช่นการเอาไป Scale test set ให้มีลักษณะการกระจายตัวเหมือน Train set ซึ่งจะอธิบายความสำคัญของความสามารถในตอนจบบทนี้
วิธีการคือ:
```python
# Method 2.1: Apply scaling using StandardScaler class (fit then transform)
x_scaler = StandardScaler().fit(x)
y_scaler = StandardScaler().fit(y)
print("Mean of x is:", x_scaler.mean_)
print("Variance of x is:", x_scaler.var_)
print("Standard deviation of x is:", x_scaler.scale_)
x_scaled = x_scaler.transform(x)
y_scaled = y_scaler.transform(y)
print(x_scaled[:5, :])
print(y_scaled[:5, :])
```
เราฟิต `StandardScaler` กับข้อมูลก่อน ซึ่งจะเป็นการเก็บ Parameter ที่ได้มาไว้ใน Object ก่อน เราสามารถเรียก Mean, Variance, และ Standard deviation มาดูได้โดยใช้ Method `.mean_`, `.var_`, และ `.scale_` โดยได้คำตอบคือ:
```
Mean of x is: [1.11022302e-17]
Variance of x is: [1.]
Standard deviation of x is: [1.]
```
สังเกตว่า Mean เท่ากับ `1.11022302 \times 10^{(-17)}` ซึ่งมีค่าน้อยมากๆ เข้าใกล้ 0 นั่นเอง
จากนั้นเราค่อยเอา Object ที่ฟิตแล้ว มา Transform เพื่อให้ได้ Array ที่ Scale แล้ว ได้ผลคือ:
```
[[ 0.47792414]
[ 1.38439361]
[-0.81292487]
[-1.08037462]
[-0.46556277]]
[[ 0.77057895]
[ 0.35850465]
[ 0.11126006]
[-0.96013313]
[-0.46564397]]
```
สังเกตว่าเท่ากับวิธีที่ 1
อนึ่ง เราสามารถควบ `.fit` และ `.transform` เอาไว้ในคำสั่งเดียว คือ `.fit_transform` ซึ่งกระชับกว่า ทำได้โดย:
```python
# Method 2.2: Apply scaling using StandardScaler class (fit_transform)
scaler = StandardScaler()
x_scaled = scaler.fit_transform(x)
y_scaled = scaler.fit_transform(y)
print(x_scaled[:5, :])
print(y_scaled[:5, :])
```
จะได้ผลเหมือนเดิม
พบว่าหน้าตาความสัมพันธ์และระยะห่างระหว่างข้อมูลแต่ละรายการนั้นเหมือนเดิมทุกประการ สิ่งเดียวที่ต่างออกไปคือ Scale บนแกน x และ y ที่ตอนนี้ข้อมูลจะกระจายตัวรอบๆ ค่าเฉลี่ย 0 โดยจะลองเช็คอีกทีก็ได้:
```python
# Check that all means is 0 and std is 1.
print("All x has mean of:", x_scaled.mean(axis=0))
print("All x has standard deviation of:", x_scaled.std(axis=0))
```
แน่นอนว่าคำตอบคือ:
```
All x has mean of: [1.11022302e-17]
All x has standard deviation of: [1.]
```
ข้อสำคัญของการทำ Feature scaling คือต้อง Scale ทั้งข้อมูล Train set และ Test set โดยใช้ Mean และ Variance เดียวกัน เพื่อรักษารูปแบบการกระจายตัวของข้อมูลทั้งสองชุดให้เหมือนกัน อย่างไรก็ตาม ไม่ควร Scale ข้อมูลทั้งหมดทีเดียวและค่อยแยก Train set กับ Test set เพราะการทำอย่างนั้นจะทำให้ข้อมูลการกระจายตัวของ Test set "รั่ว" ไปส่งผลต่อการ Scale train set
ดังนั้น วิธีที่ถูกต้องคือ:
1. ใช้ `StandardScaler` เรียก `.fit` เข้ากับ `X_train` แล้วผลที่ได้ไว้เป็น Instance object
2. เรียก `.transform` จาก Instance ในข้อ 1 โดยใส่ Argument เป็น `X_train` เพื่อเปลี่ยนชุด `X_train` ให้ได้ Scale
3. จากนั้นเรียก `.transform` จาก Instance ในข้อ 1 โดยใส่ Argument เป็น `X_test` ซึ่งเป็นการเรียก Parameter (Mean, variance) ที่เคยฟิตจาก `X_train` มาใช้กับ `X_test`
การทำ Feature scaling นั้นยังมีวิธีอื่นๆ อีก เช่น:
* `MinMaxScaler` เป็นการ Scale ให้ข้อมูลมีค่าระหว่างค่าต่ำสุดและสูงสุด เหมาะกับข้อมูลที่มี Standard deviation น้อยมากๆ
* `RobustScaler` เป็นการ Scale โดยใช้ Median และ Quantile แทน Mean กับ Variance เพื่อให้ค่าที่ได้ไม่ได้รับอิทธิพลจากข้อมูลที่มีค่าโดดจากพวก (Outliers)
* `Normalizer` เป็นการ Scale ให้ข้อมูลแต่ละรายการมี Norm เท่ากับ 1 โดยไม่เกี่ยวกับข้อมูลรายการอื่น เหมาะกับงาน Text classification และ Clustering
แนะนำให้ศึกษาเพิ่มจากคู่มือของ scikit-learn และแหล่งข้อมูลอื่นๆ ได้เอง
บทต่อไปจะเข้าสู่รายละเอียดของการเทรนโมเดล โดยจะพูดถึงปัญหา Bias และ Variance และวิธีแก้
## บทที่ 7 Bias and Variance
สมมุติว่าเราเทรนโมเดล Binary classification (มีสองคำตอบ คือ "ใช่" กับ "ไม่ใช่") แล้วได้คะแนนความแม่นยำดังนี้:
* Human-expert's score = 90%
* Train set score = 75%
จะเห็นว่าคะแนนค่อนข้างต่ำ คือถ้าให้มนุษย์จำแนกอาจจะถูกมากกว่า 90% แต่โมเดลจำแนกถูกเพียง 75% เราเรียกว่าโมเดลนี้มีปัญหา Bias
ปัญหานี้เกิดจากการที่โมเดลเราไม่สามารถฟิตกับข้อมูลได้ดีเท่าที่ควร เรียกว่าโมเดลมี Bias หรือโมเดลนั้น Underfit ข้อมูล
สาเหตุของปัญหา Bias มีหลักๆ ดังนี้:
* ข้อมูล Train set มีขนาดเล็กเกินไป โมเดลจึงไม่มี Information เพียงพอที่จะเรียนรู้ว่าควรจะตั้ง Parameter เท่าใดจึงจะเข้าได้กับข้อมูลส่วนมาก
* การตั้ง Hyperparameter ไม่เหมาะสมกับข้อมูล เช่น ตั้ง Learning rate สูงเกินไป หรือการตั้งจำนวนครั้งในการ Iterate น้อยเกินไป (ส่งผลเหมือนกับการบังคับให้โมเดลหยุดการทำงานก่อนกำหนด หรือ Early stopping) ทำให้ Algorithm ไม่สามารถหา Global minimum พบได้
* เราเลือกใช้ Algorithm ที่ไม่เหมาะกับข้อมูล หรือกำหนดโครงสร้าง Algorithm ไม่เหมาะกับข้อมูล โดยมีความซับซ้อนน้อยเกินไป เช่น ข้อมูลที่มีความสัมพันธ์แบบ Polynomial ไม่ใช่เส้นตรง แต่เราไปใช้ Linear regression ซึ่ง "ง่าย" เกินไปเมื่อเทียบกับลักษณะข้อมูล หรือ Neural networks มีจำนวน Layer และจำนวน Neuron ในแต่ละ Layer ไม่เพียงพอกับความซับซ้อนของข้อมูล เป็นต้น
สมมุติว่าเราพยายามแก้ปัจจัยเหล่านี้ เช่น การเพิ่มจำนวน Training set, การลด Learning rate, การเลือก Algorithm ที่เหมาะสมขึ้น แล้วลองเทรนโมเดลใหม่ อาจพบว่าได้คะแนนความแม่นยำดังนี้:
* Human-expert's score = 90%
* Train set score = 87%
* Test set score = 65%
จะเห็นว่า คราวนี้เราได้ความแม่นยำของ Train set สูงขึ้นจนเกือบเท่ามนุษย์แล้ว แต่เมื่อนำไปทดสอบกับ Test set ซึ่งเป็นข้อมูลชุดที่โมเดลไม่เคยเห็น พบว่าได้ความแม่นยำเพียง 65% เท่านั้น
ปัญหานี้เรียกว่า โมเดลมี Variance สูง หรือโมเดลได้ Overfit ข้อมูล ซึ่งมีลักษณะกลับกันกับปัญหา Bias/underfit กล่าวคือ โมเดลพยายาม "รู้ดี" จนเกินไป ด้วยการฟิตตัวเองเข้ากับข้อมูลใน Train set ทุกๆ รายการอย่างถูกต้อง แต่การทำอย่างนี้ไม่ได้แปลว่าขอบเขตการตัดสินใจที่เกิดขึ้นจะฟิตกับข้อมูลอื่นๆ ที่โมเดลไม่เคยเห็น ซึ่งทดสอบได้จากการพยากรณ์ด้วย Test set
สาเหตุของปัญหา Variance มีหลักๆ ดังนี้:
* ข้อมูล Test set มีขนาดเล็กเกินไป ทำให้ไม่เป็นตัวแทนที่ดีในการทดสอบ
* ข้อมูล Train set และ Test set มี่ลักษณะการกระจายตัวที่แตกต่างกันมาก ซึ่งอาจจะเกิดจากการไม่ได้สุ่มคัดแยก Train set / Test set อย่างถูกต้องตั้งแต่แรก หรือการเก็บข้อมูล Train set คนละครั้ง หรือจากคนละแหล่งที่มากับ Test set
* จำนวน Feature มากเกินไป ทำให้โมเดลมีความซับซ้อนจนเกินจำเป็น (อาจแก้ด้วยการตัด Feature ที่คิดว่าไม่ได้ส่งผลจากผลลัพธ์ออก แต่ก็เสี่ยงเพราะเรารู้ได้ยากว่า Feature ไหนสำคัญมากน้อย)
* Algorithm ขาดหรือไม่ได้ใช้กลไกการชดเชยน้ำหนัก ที่เรียกว่า Regularisation ซึ่งจะกล่าวถึงโดยละเอียดในส่วนถัดไป
ดังนั้น ทางแก้คือให้พิจารณาว่า Test set มีขนาดเพียงพอหรือไม่ และมีการกระจายตัวเหมือน Train set หรือไม่ ถ้าสองปัจจัยนี้ผ่าน ก็มาถึงการใช้เทคนิค Regularisation ซึ่งเมื่อทำแล้ว ก็น่าจะได้โมเดลที่มีคะแนนประมาณนี้:
* Human-expert's score = 90%
* Train set score = 85%
* Test set score = 83%
สังเกตว่าคะแนน Train set อาจจะลดลงเล็กน้อย เพราะโมเดลถูกชดเชยน้ำหนัก ทำให้ความแม่นยำบน Train set ลดลง แต่ลดความซับซ้อนลงจนทำให้ฟิตกับข้อมูล Test set ที่โมเดลไม่เคยเห็นได้ดียิ่งขึ้น
เป้าหมายของเรา คือการสร้างโมเดลที่ "กำลังดี" แบบนี้ ซึ่งวิธีที่ได้ผลที่สุดและควรลองเป็นอันดับแรก (เมื่อมั่นใจแล้วว่า Test set ไม่ได้เป็นปัญหา) คือ Regularisation
### Regularisation
Regularisation คือเทคนิคการ "ชดเชยน้ำหนัก" ของ Parameter ต่างๆ ในโมเดล ซึ่งจะทำให้น้ำหนักของ Parameter ต่างๆ ลดลง ส่งผลให้โมเดลลดความซับซ้อนลง จึงเพิ่มโอกาสที่โมเดลจะสามารถฟิตกับข้อมูลที่ไม่เคยมองเห็น เช่น Test set ได้มากขึ้น เราเรียกสถานการณ์แบบนี้ว่าโมเดลสามารถ Generalise ได้ดี
การชดเชยน้ำหนักของ Algorithm แต่ละตัวมีหลักการคล้ายกัน ตัวอย่างเช่น Linear regression ที่ปกติมี Cost function ดังนี้:
```tex
J(\theta_0, \theta_1) = \frac{1}{2m} \sum\limits_{i = 1}^m(h_\theta(x^{(i)}) - y^{(i)})^2 \tag{1}
```
การทำ Regularisation จะเปลี่ยน Cost function ให้เป็นดังนี้:
```tex
J(\theta_0, \theta_1) = \frac{1}{2m} \left(\sum\limits_{i = 1}^m(h_\theta(x^{(i)}) - y^{(i)})^2 + \lambda \sum\limits_{j=1}^n \theta_j^2\right) \tag{2}
```
และปรับ Gradient descent เล็กน้อย ยกเว้น ที่ไม่ต้อง Regularise:
_ทำซ้ำจนกระทั่งผลลัพธ์ล่าสุดไม่เปลี่ยนแปลงจากผลลัพธ์ครั้งก่อน:_
```tex
\theta_0 := \theta_0 - \alpha \frac{1}{m} \sum\limits_{i = 1}^m(h_\theta (x^{(i)}) - y^{(i)})x_0^{(i)} \tag{3}
\theta_j := \theta_j - \alpha\Biggl(\biggl( \frac{1}{m} \sum\limits_{i = 1}^m(h_\theta (x^{(i)}) - y^{(i)})x_j^{(i)}\biggl) + \frac{\lambda}{m} \theta_j\Biggl) \tag{4}
```
สังเกตว่าเราเพิ่ม `\lambda \sum\limits_{j=1}^n \theta_j^2` เข้าไปใน Cost function ซึ่งทั้ง Term นี้มีค่าเป็นบวกเสมอ จึงเป็นการบีบให้ `\sum\limits_{i = 1}^m(h_\theta(x^{(i)}) - y^{(i)})^2` ต้องมีขนาดเล็กลง โดยการที่จะเป็นเช่นนั้นได้ หมายความว่า `h_\theta(x^{(i)})` จะต้องมีขนาดเล็กลง ซึ่งก็หมายความว่าทางเดียวที่จะทำอย่างนั้นได้คือน้ำหนัก `\theta` (หรือ `w` ในบทที่ 2) จะต้องน้อยลงนั่นเอง โดยการลดขนาด `\theta` ลง จะเกิดขึ้นในอัตราคงที่ทุกๆ Iteration ดังนั้นเราอาจเรียก Term นี้ว่า Weight decay term ก็ได้
เรื่อง Regularisation มีรายละเอียดที่ควรรู้ดังนี้:
* `\lambda` อ่านว่า Lambda คือ Hyperparameter ที่ควบคุมระดับของการ Regularise (Regularisation strength) ยิ่งมาก ยิ่งชดเชยมาก แต่ใน scikit-learn บาง Algorithm เช่น Logistic regression จะใช้ Argument `C` แทน ซึ่งเป็น Inverse ของ `\lambda` ดังนั่น เวลากำหนด `C` ยิ่งน้อย ยิ่งชดเชยมาก
* `\sum\limits_{j=1}^n \theta_j^2` มาจาก `l^2` norm ของ Vector ซึ่งเป็นวิธีการวัด "ระยะทาง" ของ Vector เพื่อให้รู้ว่า Vector นี้มีขนาดเท่าไหร่ โดย `l^2` norm มีสูตรคือ:
```tex
|| x ||_2 = \sqrt{\sum_i x_i^2} \tag{5}
```
* ใน scikit-learn ถ้าเป็น Linear regression ให้ใช้ Ridge regression algorithm ในการทำ Linear regression พร้อมกับ `l^2` regularisation เรียกใช้ได้จาก Class `Ridge` ใน `sklearn.linear_model`
* นอกจาก `l^2` regularisation แล้ว ยังมี `l^1` regularisation ซึ่งใช้ `l^1` norm ที่มีสูตรคือ:
```tex
|| x ||_1 = \sum_i |x_i| \tag{6}
```
* ใน scikit-learn ให้ใช้ Lasso regression algorithm ในการทำ Linear regression พร้อมกับ `l^1` regularisation เรียกใช้ได้จาก Class `Lasso` ใน `sklearn.linear_model`
* ข้อแตกต่างสำคัญระหว่าง Ridge regression ที่ใช้ `l^2` regularisation กับ Lasso regression ที่ใช้ `l^1` regularisation ก็คือ Lasso มีแนวโน้มจะตัด Feature ที่มีความสำคัญน้อยมากๆ ออกไปเลย ซึ่งก็คือการลดจำนวน Feature อัตโนมัติแทนเรา ตรงกันข้ามกับ Ridge ที่จะรักษา Feature ทั้งหมดไว้
* ยังมีอีก Algorithm ชื่อว่า Elastic Net ที่รวม Ridge regression กับ Lasso regression เข้าไว้ด้วยกัน โดยเราสามารถเลือกสัดส่วนผสม `r` ว่าจะใช้ Ridge กี่ส่วน Lasso กี่ส่วน โดย `r = 0` จะได้ Ridge ทั้งหมด ส่วน `r = 1` จะได้ Lasso ทั้งหมด สามารถเรียกใช้ได้ด้วย Class `ElasticNet` ใน `sklearn.linear_model`
เป็นอันว่าเราได้รู้จักปัญหา Bias / Variance และรู้วิธีแก้ปัญหาด้วย Regularisation แล้ว ตอนนี้เราก็มีความรู้และเครื่องมือสำหรับการสร้าง Machine learning model ด้วย Algorithm อื่นๆ ซึ่งจะนำเสนอในบทต่อไป
## บทที่ 8 Support Vector Machines
คราวนี้ก็ถึงเวลาที่จะแนะนำ Algorithm ใหม่ ที่ชื่อ Support Vector Machines หรือ SVM ซึ่งทั้งยึดหยุ่นและทำงานได้ดี โดยเฉพาะอย่างยิ่งเมื่อข้อมูลมีความซับซ้อน (หลาย Feature) แต่จำนวนตัวอย่างไม่มาก (ต่ำกว่าแสนรายการ)
ปัญหา Binary classification เราต้องการจำแนกข้อมูลออกเป็นสองพวก คือสีน้ำเงินและสีแดง สิ่งที่ SVM ทำ คือการหาเส้นแบ่งการตัดสินใจที่เป็นเส้นทึบ ซึ่งเส้นนี้จะเกิดขึ้นระหว่างกลางของเส้นประด้านซ้ายและขวา โดยมีเงื่อนไขว่าจะต้องหาคู่ของเส้นประที่กว้างที่สุดเท่าที่จะเป็นไปได้
โดยคู่ของเส้นประที่กว้างที่สุดเท่าที่จะเป็นไปได้นี้ จะมีสองแบบ คือ 1) Hard margin classification คือคู่เส้นประที่ห้ามไม่ให้มีจุดข้อมูลอยู่ในพื้นที่ระหว่างเส้นประ และ 2) Soft margin classification คืออนุญาตให้มีข้อมูลอยู่ในพื้นที่ระหว่างเส้นประได้บ้าง
โดยใน scikit-learn เราสามารถกำหนด Hyperparameter `C` เพื่อเลือกระดับของการอนุญาตให้มีการละเมิดขอบเขตเส้นประ โดยถ้า `C` มาค่าน้อย หมายความว่ายอมให้มีขอบเขตที่กว้างขึ้น นั่นแปลว่ามี Regularisation มากขึ้นนั่นเอง
SVM นั้นถึงแม้จะถูกออกแบบมาสำหรับ Binary classification แต่สามารถนำไปประยุกต์ใช้กับ Multiclass classification และ Linear regression ได้โดยง่าย โดยใช้หลักการเดิมแต่เปลี่ยนรายละเอียดเล็กน้อย ซึ่งจะไม่กล่าวถึงในที่นี้ ขอให้รู้ว่าในระดับการใช้งาน สามารถใส่ข้อมูลแบบ Multiclass ลงไปได้เลย ส่วน SVM สำหรับ Linear regression ให้เรียกใช้ Class `LinearSVR` จากโมดูล `sklearn.svm`
ก่อนที่จะลองทำจริง เรามาทำความเข้าใจกันก่อนว่า SVM ทำงานจริงๆ อย่างไร
### SVM algorithm
SVM ใช้ Hypothesis function แบบเส้นตรง เหมือนกับ Linear regression นั่นคือ:
```tex
\begin{align*}
h_\theta(x) & = w_1x_1 + w_2x_2 + \dots + w_nx_n + b \\
& = w^Tx + b
\end{align*} \tag{1}
```
โดยถ้าผลลัพธ์เป็นบวก จะทำนาย Class ŷ ว่าเป็น 1 ส่วนถ้าเป็นลบ ทำนายว่าเป็น 0 เราสามารถเขียนวิธีการตัดสินใจตามเงื่อนไขดังกล่าวได้ดังนี้:
```tex
\hat{y} =
\begin{cases}
0 \text{ if } w^Tx + b < 0,\\
1 \text{ if } w^Tx + b \geq 0
\end{cases} \tag{2}
```
เมื่อเรานิยามเส้นแบ่งการตัดสินใจแล้ว (เส้นทึบ) เรากำหนดเส้นประทั้งสองด้านของเส้นทึบ โดยเส้นประแต่ละด้านคือตำแหน่งที่ `h_\theta(x)` เท่ากับ -1 และ 1
ต่อมา ลองพิจารณาว่า ความชันของฟังก์ชันการตัดสินใจ เท่ากับ Norm ของ Vector ค่าน้ำหนัก `w`:
```tex
\begin{align*}
\frac{\partial}{\partial x} h_\theta(x) & = \sum\limits_{i = 1}^m |w_i| \\
& = |w_1| + |w_2| + \ldots + |w_i| \\
& = || w ||_1
\end{align*} \tag{3}
```
ดังนั้นถ้าเราหารความชันของฟังก์ชันการตัดสินใจด้วย 2 ก็แปลว่าเราต้องคูณ 2 เข้าไปในความกว้างเส้นประเพื่อให้สมการยังคงเป็นจริง ดังนั้นผลที่ได้คือการขยายความกว้างระหว่างเส้นทึบกับเส้นประออกด้านละ 2 เท่า
จากข้อเท็จจริงนี้ เราก็จะได้เป้าหมายว่าเราต้องการลด `||w||` เพื่อให้ได้ขอบเขตเส้นแบ่งที่กว้างที่สุดเท่าที่จะเป็นไปได้ อย่างไรก็ตาม ในเวลาเดียวกันเราไม่ต้องการให้ขอบเขตเส้นแบ่งนั้นกว้างเกินไปจนกระทั่งครอบคลุมจุดข้อมูล ดังนั้นเราจึงต้องการให้ฟังก์ชันการตัดสินใจนั้นมีค่ามากกว่า 1 ในด้านที่ผลพยากรณ์เป็น 1 ("ใช่") และน้อยกว่า -1 ในด้านที่ผลพยากรณ์เป็น 0 ("ไม่ใช่") โดยถ้าเรากำหนดตัวแปร `t^{(i)} = -1` สำหรับด้าน `\hat{y} = 0` และ `t^{(i)} = 1` สำหรับด้าน `\hat{y} = 1` เราก็จะสามารถเขียนข้อจำกัดนี้ได้ว่า `t^{(i)} (w^T x^{(i)} + b) \geq 1` สำหรับทุก Class คำตอบ
ดังนั้นเราจะได้เป้าหมายการ Optimise ของ SVM algorithm ว่า:
```tex
\begin{align*}
\text{minimise}_{w, b } & \quad \frac{1}{2} w^T w \\
\text{subject to } & \quad t^{(i)} (w^T x^{(i)} + b) \geq 1
\end{align*} \tag{4}
```
สังเกตว่าเรา Minimise `\frac{1}{2} ||w||^2` แทนที่จะเป็น `||w||` เพราะ` \frac{1}{2} ||w||^2` สามารถหาอนุพันธ์ได้ผลเป็น `w` ในขณะที่อนุพันธ์ของ `||w||` เท่ากับ 0 ไม่สามารถนำไป Optimise ได้
เป้าหมายนี้ใช้สำหรับ Hard margin SVM แต่ถ้าเป็น Soft margin ที่เราต้องการอนุญาตให้พื้นที่เส้นขอบเขตการตัดสินใจนั้นกินบริเวณที่มีจุดข้อมูลอยู่ด้วยได้ ก็ต้องเพิ่มตัวแปรที่เรียกว่า Slack variable `\zeta^{(i)} \geq 0` (อ่านว่า Zeta) โดยระดับของ Slack variable จะถูกกำหนดโดย Hyperparameter C
ดังนั้นเป้าหมายการ Optimise สำหรับ Soft margin SVM คือ:
```tex
\begin{align*}
\text{minimise}_{w, b } & \quad \frac{1}{2} w^T w + C\sum\limits_{i = 1}^m\zeta^{(i)}\\
\text{subject to } & \quad t^{(i)} (w^T x^{(i)} + b) \geq 1 - \zeta^{(i)}
\end{align*} \tag{5}
```
### Kernel
SVM algorithm ที่เรานำเสนอไป มีข้อจำกัดคือสามารถสร้างเส้นแบ่งขอบเขตการตัดสินใจแบบเส้นตรงเท่านั้น ซึ่งอาจทำงานได้ไม่ดีถ้าความสัมพันธ์ของข้อมูลนั้นมีความซับซ้อนจนแบ่งด้วยเส้นตรงไม่ได้ วิธีการแก้ปัญหานี้เรียกว่า Kernel
Kernel คือ "ทริค" ทางคณิตศาสตร์ที่ทำให้ Algorithm สามารถ Optimise ค่าตัวแปรแบบ Polynomial ได้ โดยไม่ต้องไปเปลี่ยนรูปแบบและความสัมพันธ์ของ Feature ตั้งต้น แต่ก่อนอื่น เราจะต้องดัดแปลงเป้าหมายการ Optimise ของเราให้อยู่ในรูปแบบที่ Kernel จะทำงานได้ โดยเปลี่ยนจากรูปแบบในสมการที่ (5) ซึ่งเป็นปัญหาแบบ Primal problem ให้กลายเป็นปัญหาแบบ Dual problem (ปัญหาทั้งสองรูปแบบมีรายละเอียดทางคณิตศาสตร์ที่ละเอียดเกินขอบเขตที่จะอธิบายในที่นี้ ในขั้นนี้ขอเพียงให้รู้ว่า SVM algorithm สามารถใช้ทั้งสองวิธีในการ Optimise ได้ผลเหมือนกัน)
รูปแบบของเป้าหมาย Optimise แบบใหม่ที่จะใช้ คือ:
```tex
\begin{align*}
\text{minimise}_{\alpha} & \quad \frac{1}{2} \sum\limits_{i = 1}^m \sum\limits_{j = 1}^m \alpha^{(i)} \alpha^{(j)} t^{(i)} t^{(j)} x^{(i)T} x^{(j)} - \sum\limits_{i = 1}^m\alpha^{(i)}\\
\text{subject to } & \quad \alpha^{(i)} \geq 0
\end{align*} \tag{6}
```
เมื่อหา Vector` \hat{\alpha}` ที่ทำให้สมการนี้มีค่าน้อยที่สุดได้แล้ว (โดยใช้ Quadratic Programming Solver ซึ่งเป็น Algorithm สำเร็จรูปในการหาคำตอบปัญหาประเภทนี้โดยเฉพาะ) เราก็จะสามารถคำนวนหา Vector `\hat{w}` และ Intercept `\hat{b}` ที่ทำให้สมการ Primal problem (4) หรือ (5) นั้นมีค่าน้อยที่สุด โดยทำดังนี้:
```tex
\hat{w} = \sum\limits_{i = 1}^m \alpha^{(i)} t^{(i)} x^{(i)} \tag{7}
\hat{b} = \frac{1}{n_s} \sum\limits_{i = 1}^m (t^{(i)} - \hat{w}^T x^{(i)}) \tag{8}
```
เป็นอันว่าเราได้รูปแบบของเป้าหมาย Optimisation ที่พร้อมสำหรับ Kernel แล้ว ต่อไปคือการอธิบาย Kernel
สมมุติว่าเราต้องการทำเหมือนกับว่า Hypothesis function ที่ประกอบด้วยตัวแปร `x_1` และ `x_2` นั้นมีรูปร่างฟังก์ชันที่ซับซ้อนขึ้น โดยต้องการให้เป็น Second-degree polynomial เราจะสามารถเขียน Mapping function (`\phi` อ่านว่า Phi) ของสมการนี้ได้ดังนี้:
```tex
\phi(x) = \phi
\begin{pmatrix}
x_1 \\
x_2
\end{pmatrix} =
\begin{pmatrix}
x_1^2 \\
\sqrt{2} \; x_1 x_2 \\
x_2^2
\end{pmatrix}
\tag{9}
```
ทีนี้ลองดูว่า ถ้าเราคำนวน Dot product ของ Vector ขนาด 3 มิติ 2 Vector (แบบเดียวกับที่อยู่ในสมการ (6)) โดยสมมุติว่าชื่อ a และ b จะได้ว่า:
```tex
\begin{align*}
\phi(a)^T \phi(b) & =
\begin{pmatrix}
a_1^2 \\
\sqrt{2} \; a_1 a_2 \\
a_2^2
\end{pmatrix}^T
\begin{pmatrix}
b_1^2 \\
\sqrt{2} \; b_1 b_2 \\
b_2^2
\end{pmatrix} \\[2ex]
& = a_1^2 b_1^2 + 2a_1b_1a_2b_2 + a_2^2 b_2^2 \\
& = (a_1b_1 + a_2b_2)^2 \\
& = \left[\begin{pmatrix}
a_1 \\
a_2
\end{pmatrix}^T
\begin{pmatrix}
b_1 \\
b_2
\end{pmatrix}\right]^2 \\
& = (a^Tb)^2
\end{align*}
\tag{10}
```
ก็หมายความว่า เราสามารถหา Dot product ของ Vector ที่อยู่ในรูปแบบ Mapping function (คือยังไม่ได้เปลี่ยนรูปจริงๆ) เพียงด้วยการนำเอา Dot product ของ Vector ต้นฉบับมายกกำลังสอง ซึ่งก็หมายความว่าในทางกลับกัน ถ้าเราคำนวนฟังก์ชันเป้าหมาย Optimisation ด้วยการแทนที่ `(a^Tb)` ด้วย `(a^Tb)^2` เราก็จะได้ผลการคำนวนเสมือนว่าเราได้เปลี่ยนรูป Hypothesis function จาก Linear ให้เป็น Second-degree polynomial โดยไม่ต้องไปเปลี่ยนฟังก์ชันจริง
ดังนั้น เวลาเราใช้ Kernel ก็เพียงเปลี่ยน `x^{(i)T} x^{(j)}` ในสมการที่ (6) ให้เป็น `(x^{(i)T} x^{(j)})^2`
เราเรียกฟังก์ชัน `K(a, b) = (a^Tb)^2` นี้ว่า Second-degree polynomial kernel ซึ่งเป็นหนึ่งใน Kernel หลายแบบที่ทำหน้าที่เดียวกัน ต่างตรงที่แต่ละ Kernel จะเปลี่ยนรูปสมการเป็นรูปแบบที่ไม่เหมือนกัน ทำให้เหมาะกับข้อมูลแต่ละประเภท โดย Kernel เป็นที่นิยม เช่น:
```tex
\text{Linear:} \quad K(a, b) = a^Tb \tag{11}
\text{Polynomial:} \quad K(a, b) = (\gamma a^Tb + r)^d \tag{12}
\text{Gaussian RBF:} \quad K(a, b) = e^{(-\gamma ||a-b||^2)} \tag{13}
\text{Sigmoid:} \quad K(a, b) = \text{tanh} (\gamma a^Tb + r) \tag{14}
```
ทั้งหมดนี้คือหลักการของ SVM และ Kernel อนึ่งคณิตศาสตร์ในส่วนนี้ ส่วนมากอ้างอิงจากหนังสือ Hands-On Machine Learning with Scikit-Learn & TensorFlow โดย Aurélien Géron
ทีนี้ก็ถึงเวลามาลองโปรแกรมกันเลย
### SVM programming
เราจะใช้ชุดข้อมูล Iris เหมือนเดิมในการทดลอง SVM โดยจะใช้ข้อมูล Petal length และ Petal width เท่านั้น เพื่อให้ที่สามารถพล็อตกราฟแสดงขอบเขตการตัดสินใจให้ดูได้
เริ่มด้วยการโหลดและพล็อตดูข้อมูล:
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
from sklearn.svm import SVC
# Load the iris data
iris = datasets.load_iris()
X = iris.data[:, 2:]
y = iris.target
# Split the data into train and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
# Plot the data
plt.figure(figsize=(7,6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='Paired_r')
plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plt.show()
```
ได้ Scatterplot ของความสัมพันธ์ระหว่าง Petal length และ Petal width โดยจำแนกจุดข้อมูลตาม Class ซึ่งได้แก่ `['setosa' 'versicolor' 'virginica']`
จากนั้นทดลองเทรนด้วย Linear SVC ซึ่งเป็นเวอร์ชั่นที่ใช้ Hypothesis function แบบเส้นตรง โดยเรียก Class `LinearSVC` จากโมดูล `sklearn.svm`:
```python
# Model 1: Linear SVC version
# Create a pipeline
clf_linSVC = Pipeline([
("linear_svc", LinearSVC(C=200, loss="hinge", max_iter=100000))
])
# Train the model
clf_linSVC.fit(X_train, y_train)
# Evaluate the model's accuracy
print("Train set accuracy = " + str(clf_linSVC.score(X_train, y_train)))
print("Test set accuracy = " + str(clf_linSVC.score(X_test, y_test)))
```
ทดสอบแล้วได้ค่าความแม่นยำดีทีเดียว:
```
Train set accuracy = 0.9375
Test set accuracy = 0.9736842105263158
```
ทีนี้เราลองพล็อตพื้นที่และเส้นแบ่งการตัดสินใจของโมเดล โดยสร้างฟังก์ชันชื่อ `plot_decision_boundary` ดังนี้:
```python
# Plot the decision boundaries
def plot_decision_boundary(clf, X, y, cmap='Paired_r'):
h = 0.005 # Boundary lines' resolution
x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.figure(figsize=(7,6))
plt.contourf(xx, yy, Z, cmap=cmap, alpha=0.25) # Background
plt.contour(xx, yy, Z, colors='k', linewidths=0.2) # Boundary lines
plt.scatter(X[:,0], X[:,1], c=y, cmap=cmap); # Data points
plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plot_decision_boundary(clf_linSVC, X, y)
```
จะสังเกตว่าการที่ขอบเขตการตัดสินใจเป็นเส้นตรง ทำให้ไม่สามารถฟิตขอบเขตระหว่าง Class สีแดงกับสีฟ้าได้ดี ส่งผลต่อความแม่นยำของโมเดล ดังนั้น เรามาลองใช้ Kernel เพื่อทำให้ขอบเขตการตัดสินใจนั้นมีความโค้งรับกับความสัมพันธ์ของข้อมูล
โดยเราจะใช้ Gaussian RBF kernel เรียกใช้จาก Class `SVC` ในโมดูล `sklearn.svm` โดยกำหนด Argument `kernel="rbf"`:
```python
# Model 2: Gaussian RBF Kernel version
# Create a pipeline
clf_SVC = Pipeline([
("linear_svc", SVC(kernel="rbf", gamma=2, C=10, max_iter=10000))
])
# Train the model
clf_SVC.fit(X_train, y_train)
# Evaluate the model's accuracy
print("Train set accuracy = " + str(clf_SVC.score(X_train, y_train)))
print("Test set accuracy = " + str(clf_SVC.score(X_test, y_test)))
```
สังเกตว่ามี Argument gamma ซึ่งก็คือ Hyperparameter `\gamma` ใน Kernel function `K(a, b) = e^{(-\gamma ||a-b||^2)}` โดย gamma นี้กำหนดความแคบของส่วนโค้งซึ่งมีรูปร่างตามการกระจายแบบ Gaussian
ผลความแม่นยำที่ได้ คือ 100%:
```
Train set accuracy = 0.9553571428571429
Test set accuracy = 1.0
```
ต่อมาลองพล็อตพื้นที่และเส้นแบ่งการตัดสินใจของโมเดลดู:
```python
# Plot the decision boundaries
plot_decision_boundary(clf_SVC, X, y)
```
จะเห็นว่า Kernel นั้นแก้ปัญหาของเราได้จริง เพราะทำให้เส้นการตัดสินใจนั้นโค้งรับกับข้อมูล ส่งผลให้ความผิดพลาดลดลง
เป็นอันว่าเราได้รู้จัก Support Vector Machines รวมทั้ง Kernel ที่ช่วยให้ Algorithm สามารถเรียนรู้การตัดสินใจข้อมูลที่ซับซ้อนได้ ตอนต่อไปจะมาทำความรู้จักกับอีก Algorithm ที่ใช้งานได้ดีในหลายๆ กรณีเช่นกัน คือ Decision tree
## บทที่ 9 Decision Tree
Decision tree เป็น Algorithm ที่เป็นที่นิยม ใช้ง่าย เข้าใจง่าย ได้ผลดี และเป็นฐานของ Random Forest ซึ่งเป็นหนึ่งใน Algorithm ที่ดีที่สุดในปัจจุบัน
หลักการพยากรณ์ด้วย Decision tree นั้นเข้าใจง่ายมาก ให้นึกว่า Decision tree คือต้นไม้กลับหัว โดยบนสุดคือราก และส่วนล่างลงมาที่ไม่สามารถแตกไปไหนได้แล้วก็คือใบ เราจะเริ่มด้วยการพิจารณาเริ่มแรกบนจุดเริ่มต้นที่เรียกว่า Root node ถ้าข้อมูลที่พบเป็นไปตามเงื่อนไขนั้น การตัดสินใจก็จะวิ่งไปทางซ้ายของ Root node ไปที่จุดที่เรียกว่า Child node ซึ่งถ้าข้อมูลที่มาตามเส้นทางนี้ตรงตามเงื่อนไขของ Child node นี้ ก็จะถือว่าสิ้นสุด เราเรียกว่า Node สิ้นสุดว่า Leaf node
ย้อนกลับไปยัง Root node ถ้าข้อมูลที่พิจารณาไม่เป็นไปตามเงื่อนไข การตัดสินใจจะวิ่งไปอีกทาง คือทางขวา ไปพบ Child node อีกอันซึ่งก็จะตั้งเงื่อนไขคำถามต่อไป การตัดสินใจก็จะวิ่งไปทางที่ตรงตามเงื่อนไข ทำอย่างนี้ไปเรื่อยๆ จนได้คำตอบ
สำหรับกลไกการเทรนโมเดลเพื่อสร้าง Decision tree จะอธิบายด้านล่าง เมื่อได้อธิบายเรื่องค่า Gini
ก่อนจะไปไกลกว่านั้น จะชี้ให้เห็นว่า Decision tree นั้นไม่ต้องใช้ข้อมูลที่ทำ Feature scaling เพราะไม่ได้มี Optimisation algorithm แบบทั่วไป จึงใช้งานสะดวกมาก
เพื่อความเข้าใจมากขึ้น ลองมา Program ด้วย scikit-learn กันเลย โดยใช้ชุดข้อมูล Iris เหมือนเดิม เพื่อความเรียบง่ายจะเลือก Feature เฉพาะ Petal length และ Petal width:
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
# Load the iris data
iris = datasets.load_iris()
X = iris.data[:, 2:]
y = iris.target
# Split the data into train and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
```
แล้วก็ลองเทรนโมเดลกันเลย:
```python
# Train and fit the model
tree_clf = DecisionTreeClassifier(max_depth=5).fit(X_train, y_train)
# Evaluate the model's accuracy
print("Train set accuracy = " + str(tree_clf.score(X_train, y_train)))
print("Test set accuracy = " + str(tree_clf.score(X_test, y_test)))
```
สังเกตว่ามี Argument `max-depth` นั่นคือตัวควบคุมว่าจะให้ต้นไม้ของเรามีความลึกกี่ขั้น ถ้าเราพบว่าโมเดลของเรา Overfit ก็ควรลองลดจำนวนชั้นของความลึกลง ดังนั้น `max-depth` จึงเป็น Regularisation hyperparameter ของ Decision trees
สำหรับความคลาดเคลื่อน พบว่าได้ความแม่นยำจาก Method `.score` ดังนี้:
```
Train set accuracy = 0.9821428571428571
Test set accuracy = 1.0
```
คือแม่นยำ 100% ทีเดียว
จากนั้นเรามาลองสร้างกราฟการตัดสินใจ โดยใช้ฟังก์ชัน `export_graphviz` ในโมดูล `sklearn.tree` เพื่อ Export กราฟออกมาด้วย Graphviz ซึ่งเป็น Open-source graph visualisation software:
```python
# Export graph
export_graphviz(tree_clf, out_file="iris_tree.dot",
feature_names=iris.feature_names[2:],
class_names=iris.target_names,
rounded=True, filled=True)
```
ฟังก์ชันนี้จะ Export กราฟออกมาเป็นไฟล์นามสกุล `.dot` ซึ่งเราต้องใช้คำสั่ง `dot` จาก Graphviz package เพื่อแปลงไฟล์เป็น `.png` โดยเรียกคำสั่งจาก Command line:
`$ dot -Tpng iris_tree.dot -o iris_tree.png`
ถ้าอ่านตามแผนภาพก็น่าจะพอเข้าใจคำอธิบายข้างต้นว่า Decision tree พยากรณ์อย่างไร อย่างไรก็ตาม ในแต่ละ Node มีรายละเอียดที่ควรรู้เพื่อเพิ่มความเข้าใจดังนี้:
* `samples` คือจำนวนรายการข้อมูลที่เข้ากันได้กับ Node นั้น ดังนั้น เมื่อการตัดสินใจเคลื่อนลงไปตามความลึกของต้นไม้ จำนวน `samples` ของ Node ในแต่ละชั้นจะมีแนวโน้มที่จะลดลงเรื่อยๆ
* `gini` บ่งชี้ความ "บริสุทธิ์" ของ Node โดย `gini = 0` หมายความว่าข้อมูลทุกรายการใน Node นั้นอยู่ใน Class เดียวกัน ส่วน `gini = 0.5` ก็แปลว่ารายการข้อมูลใน Node นั้นอยู่ใน 2 Class เท่าๆ กัน โดยแสดงผ่าน `value` เช่น `value = [0, 39, 38]` ใน Child node ด้านขวาของ Root node แปลว่า จากข้อมูล 77 รายการที่เข้าเงื่อนไข Node นี้ มี 39 รายการที่อยู่ใน Class `versicolor` และ 38 รายการอยู่ใน Class `virginica` โดยถ้าหยุดพิจารณาที่ขั้นนี้ ก็จะถือว่าข้อมูลที่เข้าเงื่อนไขของ Node นี้อยู่ใน Class `versicolor` เป็นต้น
เพื่อให้เป็นประโยชน์ในการทำความเข้าใจ Algorithm ในส่วนถัดไป เราสามารถบอกได้ว่าค่า `gini` คำนวนตามสูตรนี้:
`G_i = 1 - \sum\limits_{k = 1}^{n} p_{i, k}^2 \tag{1}`
โดย `p_{i, k}` คือสัดส่วนว่าจากจำนวนรายการข้อมูลใน Node ที่ `i` นั้นอยู่ใน Class `k` กี่รายการ
มาถึงจุดนี้เราก็พร้อมที่จะมาทำความเข้าใจว่า Decision tree algorithm นั้นสร้างโมเดลได้อย่างไร โดย scikit-learn จะใช้ Algorithm ที่ชื่อ Classification And Regression Tree (CART) ซึ่งทำงานตามลำดับดังนี้:
1) แบ่ง Train set ออกเป็น 2 ส่วนโดยเลือก Class k และเงื่อนไข `t_k` เช่น petal length <= 2.45 โดยค้นหาคู่ของ `k` และ `t_k` ที่จะได้ Node ที่ "บริสุทธิ์" ที่สุด นั่นคือมีค่า Gini ต่ำที่สุดนั่นเอง เราสามารถแสดง Cost function ที่สอดคล้องกับเงื่อนไขนี้ได้ดังนี้:
`J(k, t_k) = \frac{m_{left}}{m} G_{left} + \frac{m_{right}}{m} G_{right} \tag{2}`
- `G_{left/right}` คือ gini ของข้อมูลชุดซ้ายและขวาที่ถูกแบ่ง
- `m_{left/right}` คือจำนวนรายการข้อมูลในชุดซ้ายและขวา
- `m` คือจำนวนรายการข้อมูลทั้งหมดใน Node นั้น
2) แยกข้อมูลแต่ละชุดย่อยออกเป็นสองชุดและทำซ้ำข้อ 1) เรื่อยๆ จนกระทั่งถึงความลึก max-depth ที่กำหนด หรือจนกระทั่งไม่พบค่า `k` และ `t_k` ที่จะลดความไม่บริสุทธิ์ได้อีกต่อไป
ตอนนี้เราก็เข้าใจแล้วว่า Decision tree สร้างโมเดลอย่างไร สุดท้ายเรามาลองพล็อตเส้นแบ่งการตัดสินใจจากตัวอย่างของเรา:
```python
# Plot the decision boundaries
def plot_decision_boundary(clf, X, y, cmap='Paired_r'):
h = 0.005 # Boundary lines' resolution
x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.figure(figsize=(7,6))
plt.contourf(xx, yy, Z, cmap=cmap, alpha=0.25) # Background
plt.contour(xx, yy, Z, colors='k', linewidths=0.2) # Boundary lines
plt.scatter(X[:,0], X[:,1], c=y, cmap=cmap); # Data points
plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plot_decision_boundary(tree_clf, X, y)
```
จะเห็นว่า Decision tree สร้างเส้นแบ่งการตัดสินใจที่เป็นเส้น Orthogonal คือแนวระนาบและแนวดิ่งที่ตั้งฉากกันเท่านั้น ดังนั้นในบางกรณีจะเป็นไปไม่ได้เลยที่ Decision tree จะทำนาย Test set ได้แม่นยำ 100%
ข้อสังเกตนี้สอดคล้องกับธรรมชาติของ CART algorithm ที่ค้นหา Parameter ที่ดีที่สุดจากบนลงล่างโดยตัดสินใจจากเงื่อนไขที่พบในลำดับชั้นปัจจุบันเท่านั้น โดยไม่ได้เช็คว่าการตัดสินใจในชั้นนั้นจะส่งผลให้ลำดับชั้นล่างๆ ลงมามีค่าความไม่บริสุทธิ์น้อยที่สุดหรือไม่ เราเรียกพฤติกรรมแบบนี้ว่า Greedy algorithm ซึ่งพฤติกรรมแบบนี้ทำให้ต้องใช้เวลานานจนแทบเป็นอนันต์จึงจะหาต้นไม้ที่ดีที่สุดได้ โดยใช้เวลาถึง O(e^m) ในทางคณิตศาสตร์เรียกปัญหานี้ว่า ปัญหา NP-Complete ดังนั้นเมื่อเราใช้ Decision tree เราจึงต้องยอมรับผลลัพธ์ที่อาจจะไม่สมบูรณ์แบบ แต่ส่วนมากก็ดีพอสำหรับงานส่วนมาก
บทต่อไปเราจะเรียนรู้ Random Forest ซึ่งคือการนำต้นไม้หลายๆ ต้นมารวมกันเป็นป่า เพื่อเพิ่มความแม่นยำในการ Generalise โมเดลให้ทำงานได้ดีขึ้นกับข้อมูลที่โมเดลไม่เคยเห็น
## บทที่ 10 Random Forest
Random forest เป็นหนึ่งในกลุ่มของโมเดลที่เรียกว่า Ensemble learning ที่มีหลักการคือการเทรนโมเดลที่เหมือนกันหลายๆ ครั้ง (หลาย Instance) บนข้อมูลชุดเดียวกัน โดยแต่ละครั้งของการเทรนจะเลือกส่วนของข้อมูลที่เทรนไม่เหมือนกัน แล้วเอาการตัดสินใจของโมเดลเหล่านั้นมาโหวตกันว่า Class ไหนถูกเลือกมากที่สุด
ฟังดูเหมือนไม่น่าจะดี แต่ในความเป็นจริงแล้ว กลไกการรวมการตัดสินใจของผู้ตัดสินใจจำนวนมากเข้าด้วยกันมักจะให้ผลการตัดสินใจที่แม่นยำมากกว่าการพึงพาการตัดสินใจจากแหล่งเดียว ปรากฏการณ์นี้เป็นจริงในหลายมิติ เช่นในทางสังคม เราเรียกว่า "ปัญญาของฝูงชน" (Wisdom of the crowd) ซึ่งหากสนใจสามารถค้นคำนี้อ่านได้ทั่วไป
การเรียนรู้แบบ Ensemble นี้จะทำงานได้ดีบนเงื่อนไขที่ว่า โมเดลผู้ทำนายแต่ละตัวจะต้องเรียนรู้อย่างเป็นอิสระต่อกันให้มากที่สุด เหมือนกับเงื่อนไขของปัญญาของฝูงชน ว่าคนแต่ละคนจะต้องตัดสินใจด้วยตนเองให้มากที่สุดโดยไม่ได้รับข้อมูลจากคนอื่นหรือนำเอาข้อมูลจากคนอื่นมาเป็นส่วนในการตัดสินใจ
ใน Machine learning algorithm เรามีวิธีการที่ทำให้การตัดสินใจของแต่ละโมเดลเป็นอิสระต่อกัน โดยการใช้ Algorithm เดียวกัน แต่ให้แต่ละ Instance เรียนรู้จากส่วนของข้อมูลที่ไม่เหมือนกันโดยใช้การสุ่มเลือก กลไกนี้เรียกว่า Bagging และ Pasting โดยสิ่งที่ต่างกันคือ Bagging สามารถสุ่มเลือกข้อมูลรายการเดียวกันได้ แต่ Pasting ไม่อนุญาตให้สุ่มรายการซ้ำกันได้เลย ในทางปฏิบัติ Bagging จะลด Variance ของโมเดลได้ดีกว่า เพราะมีการเลือกรายการข้อมูลซ้ำ ทำให้ได้โมเดลที่เสถียรกว่าและมักจะแม่นยำกว่า Pasting
สำหรับ scikit-learn โมเดลแบบ Bagging จะจะใช้วิธีการสุ่มเลือกรายการข้อมูลแบบ Bootstrap โดยแต่ละ Instance จะเลือก 63% ของข้อมูล เหลือ 37% ที่แต่ละ Instance ไม่เห็น เราเรียก 37% นี้ว่า Out-of-bag (oob) instance การที่มี oob instance ทำให้เราสามารถประเมินความแม่นยำเฉลี่ยของทุกๆ Instance ได้ในระหว่างเทรน โดยการเรียก Argument `oob_score=True` ใน Classifier instance
เมื่อเข้าใจหลักการทำงานแล้ว มาลองสร้างโมเดลกันเลยดีกว่า โดยครั้งนี้เราจะเลือกชุดข้อมูลที่ยากและซับซ้อนขึ้นเล็กน้อย คือชุดข้อมูล Breast cancer wisconsin (diagnostic) dataset ซึ่งวัดค่าต่างๆ จากตัวอย่างก้อนเนื้อที่เจาะออกมา แล้วจำแนกว่าก้อนเนื้อนั้นเป็นเซลมะเร็งเต้านมหรือไม่
ข้อมูลมี 30 Feature ได้แก่ `['mean radius' 'mean texture' 'mean perimeter' 'mean area' 'mean smoothness' 'mean compactness' 'mean concavity' 'mean concave points' 'mean symmetry' 'mean fractal dimension' 'radius error' 'texture error' 'perimeter error' 'area error' 'smoothness error' 'compactness error' 'concavity error' 'concave points error' 'symmetry error' 'fractal dimension error' 'worst radius' 'worst texture' 'worst perimeter' 'worst area' 'worst smoothness' 'worst compactness' 'worst concavity' 'worst concave points' 'worst symmetry' 'worst fractal dimension']` โดยมีจำนวน 569 รายการ จำแนกเป็น Malignant คือเป็นเซลมะเร็ง 212 รายการ และ Benign คือไม่เป็นมะเร็ง 357 รายการ
เราสามารถเรียกข้อมูลชุดนี้จาก `sklearn.datasets` ได้เลย:
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
# Load the breast cancer data
breast_ca = datasets.load_breast_cancer()
# Explore the data
print(breast_ca.keys())
print(breast_ca["DESCR"])
print(breast_ca["feature_names"])
print(breast_ca["target_names"])
# Assign input X and target y
X = breast_ca.data
y = breast_ca.target
```
ไหนๆ เราก็ศึกษามาหลายโมเดลแล้ว เรามาลองเปรียบเทียบความสามารถของแต่ละโมเดลกันทีเดียวไปเลยดีกว่า โดยเปรียบเทียบระหว่าง SVC with Gaussian RBF Kernel / Decision Tree / Random Forest
### SVC with Gaussian RBF Kernel
มาลองโมเดลแรกกัน การสร้างโมเดล Support Vector Machine ต้องทำ Feature scaling ก่อน ถ้าอยากรู้ว่าไม่ทำ Feature scaling แล้วเป็นอย่างไรก็สามารถลองกันเองได้:
```python
# Feature scaling for SVC
X_scaler = StandardScaler().fit(X_train)
X_train_scaled = X_scaler.transform(X_train)
X_test_scaled = X_scaler.transform(X_test)
```
ถ้ายังจำได้ วิธีที่ดีถูกต้องในทางเทคนิคในการทำ Feature scaling คือเรียก `StandardScaler` ให้ฟิตกับข้อมูล `X_train` ก่อนเพื่อสร้าง Instance `X_scaler` ที่จำเอา Parameter ในการ Scale เอาไว้ก่อนโดยไม่นำข้อมูล `X_test` เข้ามาเป็นส่วนหนึ่งของ Parameter จากนั้นใช้ Instance นี้เรียก `.transform` ข้อมูลจริงจากทั้ง `X_train` และ `X_test` เพื่อให้ข้อมูลทั้งสองชุดถูก Scale ด้วย Mean และ Variance แบบเดียวกัน
ต่อมาก็เทรนโมเดล SVC with Gaussian RBF Kernel:
```python
# Train and fit the model: SVC with Gaussian RBF Kernel
svc_clf = SVC(kernel="rbf", gamma="auto", C=1, max_iter=-1).fit(X_train_scaled, y_train)
# Evaluate the model's accuracy
print("For SVC with Gaussian RBF Kernel model:")
print("Train set accuracy = " + str(svc_clf.score(X_train_scaled, y_train)))
print("Test set accuracy = " + str(svc_clf.score(X_test_scaled, y_test)))
```
ได้ความแม่นยำบน Test set ถึง 97.2%
```
For SVC with Gaussian RBF Kernel model:
Train set accuracy = 0.9882629107981221
Test set accuracy = 0.972027972027972
```
### Decision tree
โมเดลที่สอง เริ่มกันเลย:
```python
# Train and fit the model: decision tree
tree_clf = DecisionTreeClassifier(max_depth=None).fit(X_train, y_train)
# Evaluate the model's accuracy
print("For Decision Tree model:")
print("Train set accuracy = " + str(tree_clf.score(X_train, y_train)))
print("Test set accuracy = " + str(tree_clf.score(X_test, y_test)))
# Determine features' importances
print("\nImportance of each feature:\n", tree_clf.feature_importances_)
```
ได้ผลดังนี้:
```
For Decision Tree model:
Train set accuracy = 1.0
Test set accuracy = 0.951048951048951
Importance of each feature:
[0. 0. 0. 0. 0. 0.
0. 0.70264385 0. 0. 0. 0.
0. 0.01277192 0.00155458 0. 0. 0.01702539
0. 0. 0.0877369 0.12550655 0. 0.03452044
0.00985664 0. 0. 0.00838371 0. 0. ]
```
จะเห็นว่าโมเดลที่เทรนด้วย Decision tree มีปัญหา Overfitting ไม่ว่าจะปรับ Hyperparameter อย่างไรก็ไม่สามารถเพิ่มความแม่นยำ Test set ให้เกิน 95.1% ได้ ทั้งๆ ที่โมเดลสามารถฟิตกับ Train set ได้ 100% ปัญหานี้เป็นแรงจูงใจให้เราใช้ Random forest ซึ่งน่าจะให้ผลดีกว่า ซึ่งเดี๋ยวเราจะมาลองกัน
สังเกตว่าเราได้คำนวนสิ่งที่เรียกว่า Feature importances ด้วย ซึ่งเป็นความสามารถพิเศษของโมเดลตระกูล Decision tree โดย Feature importances จำชี้วัด "ความสำคัญ" ของแต่ละ Feature ในลักษณะคล้ายกับการหา Correlation โดยวัดว่า Node ต่างๆ ที่ใช้ Feature นั้นสามารถลดค่าความไม่บริสุทธิ์ (ลด `gini`) ได้เท่าไหร่ โดยจากตัวอย่างจะเห็นว่า Feature ลำดับที่ 7 และ 21 ดูเหมือนจะมีความสำคัญมากที่สุด อย่างไรก็ตามเดี๋ยวเราจะมาลองดูกันอีกทีตอนเทรน Random forest ว่าจะได้ผลเหมือนกันหรือไม่
### Random forest
และแล้วก็มาถึงคิวของ Random forest เราสามารถเรียกโมเดลได้จาก Class `RandomForestClassifier` ในโมดูล `sklearn.ensemble`:
```python
# Train and fit the model: random forest classifier
rforest_clf = RandomForestClassifier().fit(X_train, y_train)
# Evaluate the model's accuracy
print("For Random Forest model:")
print("Train set accuracy = " + str(rforest_clf.score(X_train, y_train)))
print("Test set accuracy = " + str(rforest_clf.score(X_test, y_test)))
# Determine features' importances
print("\nImportance of each feature:\n", rforest_clf.feature_importances_)
```
มาดูผลลัพธ์กันเลย:
```
For Random Forest model:
Train set accuracy = 1.0
Test set accuracy = 0.972027972027972
Importance of each feature:
[0.0203572 0.02322627 0.02598635 0.04133143 0.0066621 0.01541918
0.07545279 0.16202326 0.00550662 0.00652847 0.00736119 0.00434392
0.00986888 0.04103056 0.00350675 0.00480023 0.00873174 0.00562927
0.00371145 0.00552231 0.10679671 0.02272615 0.11522445 0.09619906
0.01558007 0.0118116 0.02579207 0.115044 0.00852107 0.00530486]
```
เราได้โมเดลที่แม่นยำ 97.2% เทียบเท่า SVC with Gaussian RBF Kernel
ทีนี้ลองพิจารณา Feature importances จะพบว่าโมเดลสามารถให้ค่าความสำคัญได้ทุก Feature ไม่มีการตัดออกเหลือ 0 เหมือน Decision tree โดดๆ เพราะ Random forest ใช้ต้นไม้หลายๆ ต้นมาเฉลี่ยกันคิด ทีนี้ลองดูว่า Feature ไหนมีค่าความสำคัญมากที่สุด พบว่าคือ Feature ลำดับที่ 7, 22, 27, และ 20 ตามลำดับ อย่างไรก็ตาม ทุกครั้งที่เทรนโมเดล ค่าเหล่านี้จะเปลี่ยนไป เพราะโมเดลทำการโดยการสุ่มเลือกรายการข้อมูลซึ่งไม่เหมือนกันเลยในแต่ละครั้ง (หากไม่ได้กำหนด `random_state`)
### Decision boundary
ต่อมาเราจะลองพล็อตเส้นแบ่งการตัดสินใจ โดยค่า Feature importances เป็นข้อมูลให้เราสามารถเลือกได้ว่าเราจะใช้ข้อมูลหัวเรื่องไหนไปพล็อตกราฟที่อธิบายการทำงานและการตัดสินใจของโมเดล โดยต้องเลือกเพียง 2 Feature เท่านั้น เพราะกราฟของเรามี 2 มิติ
เริ่มด้วยการสร้าง `X` ใหม่ที่มีแค่ 2 Feature โดยเราจะเลือกลำดับที่ 7 (Mean concave points) และ 20 (Worst radius):
```python
# Choose only X from column 7 and 20
X_selected = breast_ca.data[:, [7,20]]
print(X_selected[:3, :])
```
จากนั้นเทรนโมเดลตามปกติ โดยเปลี่ยน Input ของโมเดล จาก `X_train` เป็น `X_train_select` ซึ่งถูกคัดแยกด้วย `train_test_split` มาจาก Input `X_selected` ตอนแรก:
```python
# Split the selected data into train and test set
X_train_select, X_test_select, y_train, y_test = train_test_split(X_selected, y, random_state=42)
# Train and fit the model: decision tree
rforest_clf = RandomForestClassifier(n_estimators=50).fit(X_train_select, y_train)
# Evaluate the model's accuracy
print("For Random Forest model (with selected X):")
print("Train set accuracy = " + str(rforest_clf.score(X_train_select, y_train)))
print("Test set accuracy = " + str(rforest_clf.score(X_test_select, y_test)))
```
หลายคนอาจจะสนใจว่าถ้าเทรนโมเดลด้วย 2 Feature จาก 30 จะได้ผลอย่างไร คำตอบอยู่ที่นี่:
```
For Random Forest model (with selected X):
Train set accuracy = 1.0
Test set accuracy = 0.916083916083916
```
ก็คือ 91.6% ซึ่งน้อยลงจาก 97.2% พอสมควร แต่ก็ถือว่าดีมาก เพราะเราใช้ข้อมูลเพียง 2 หัวเรื่องมาเทรน
ลองมานำผลที่ได้ไปพล็อตโดยใช้ฟังก์ชัน `plot_decision_boundary` ที่เคยเขียนไว้:
```python
# Plot the decision boundaries
def plot_decision_boundary(clf, X, y, cmap='Paired_r'):
h = 0.003 # Boundary lines' resolution
x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.figure(figsize=(12,9))
plt.contourf(xx, yy, Z, cmap=cmap, alpha=0.25) # Background
plt.contour(xx, yy, Z, colors='k', linewidths=0.2) # Boundary lines
scatter = plt.scatter(X[:,0], X[:,1], c=y, cmap=cmap); # Data points
plt.xlabel(breast_ca.feature_names[7])
plt.ylabel(breast_ca.feature_names[20])
plt.legend(*scatter.legend_elements())
plot_decision_boundary(rforest_clf, X_selected, y)
# Help remind legend names
count = 0
for i in breast_ca["target_names"]:
print(count, "means", i)
count += 1
```
For loop ในส่วนท้ายเป็นเพียงการแสดงว่าหมายเลข Class ไหนหมายถึงอะไร เวลาอ่านพล็อตจะได้ไม่งง:
```
0 means malignant
1 means benign
```
สังเกตว่าบริเวณรอยต่อระหว่าง Class 0 กับ 1 ซึ่งมีข้อมูลทั้งสอง Class ปะปนกัน Random forest พยายามอย่างมากที่จะตัดสินใจโดยโหวตจากการตัดสินใจของต้นไม้แต่ละต้นในป่า
ยังมี Ensemble learning algorithm ที่ฉลาดขึ้นไปอีก โดยใช้หลักการ Boosting ที่ทำงานโดยการให้ Classifier แต่ละ Instance ทำงานแก้ไขข้อผิดพลาดของ Instance ก่อน แทนที่จะทำงานพร้อมกันโดยการสุ่มเลือกรายการข้อมูล เราจะศึกษาและทดลอง Boosting algorithm ในบทต่อไป
## บทที่ 11 Boosting
Boosting เป็นอีกเทคนิคใน Ensemble learning ที่ใช้ Classifier หลายๆ Instance มาช่วยกันสร้างโมเดลและพยากรณ์
การอธิบาย Boosting ให้เข้าใจง่าย น่าจะลองเปรียบเทียบว่ามันต่างกับ Random forest อย่างไร ทั้งคู่เป็น Ensemble learning เหมือนกัน โดย Random forest จะใช้ Classifier หลาย Instance สร้างโมเดลและทำนายพร้อมกัน โดยใช้ "กฎของจำนวนขนาดใหญ่" (Law of large numbers) เป็นคุณสมบัติที่ทำให้การทำนายนั้นแม่นยำกว่าการใช้ Classifier เดี่ยวๆ
ส่วน Boosting นำ Classifier หลายตัวมาทำงานเป็นโซ่ต่อกัน โดยแต่ละตัวจะแก้ไขจุดด้อยของ Classifier ตัวก่อนหน้า พอเทรนเสร็จแล้ว Classifier ทุกตัวจะพยากรณ์ร่วมกัน
ในบทนี้จะแนะนำ Boosting algorithm ที่เป็นที่นิยมสองตัว คือ AdaBoost และ GradientBoosting
#### AdaBoost
AdaBoost เป็น Algorithm พื้นฐานของ Boosting method จึงควรลองทำความเข้าใจเพื่อเป็นฐานสำหรับ Algorithm อื่น
หลักการทำงานของ AdaBoost คือการใช้ Classifier ที่ไม่ซับซ้อน เช่น Decision tree ที่มีชั้นเดียว (เรียกว่า Decision stump) หลายๆ Instance มาเทรนต่อกันเป็นลูกโซ่ โดยในการเทรนแต่ละรอบจะมีการกำหนดค่าน้ำหนักของข้อมูลแต่ละรายการ Classifier instance จะเรียนรู้จากค่าน้ำหนักเหล่านั้น โดยถ้าพยากรณ์ผิด ค่าน้ำหนักของรายการนั้นจะมีค่ามากขึ้น ส่งผลให้ Classifier instance นั้นได้รับ "คะแนน" ต่ำ แต่ในทางกลับกัน ถ้า Instance ไหนพยากรณ์ถูกเป็นสัดส่วนที่มาก ก็จะได้คะแนนมาก
การพยากรณ์ของ AdaBoost คือการถ่วงคะแนนเข้ากับคำตอบของแต่ละ Instance แล้วเลือกคำตอบจาก Class ที่ได้รวมแล้วได้ค่าน้ำหนักมากที่สุด
ขั้นตอนการทำงานอย่างละเอียดของ AdaBoost มีดังนี้:
1) กำหนดน้ำหนัก `w^{(i)}` ตั้งต้นของข้อมูลแต่ละรายการเป็น 1/m โดย m คือจำนวนรายการข้อมูลทั้งหมด:
`w^{(i)} = \frac{1}{m} \tag{1}`
เช่น ถ้ามีข้อมูล 500 รายการ น้ำหนักของ `w^{(1)}`,` w^{(2)}`, `\dots`, `w^{(500)} = 1/500`
2) เทรน Classifier instance แรกและคำนวนอัตราความคลาดเคลื่อน `r_1` โดยเปรียบเทียบระหว่างผลรวมของน้ำหนักของทุกๆ รายการที่ทำนายผิด กับผลรวมของน้ำหนักของทุกๆ รายการ:
`r_j = \frac{\sum\limits_{i = 1}^m w^{(i)}_{[\hat{y}_j^{(i)} \neq \,y^{(i)}]}}{\sum\limits_{i = 1}^m w^{(i)}} \tag{2}`
เราเรียกสมการที่ (2) นี้ว่า Weighted error rate ของ Classifier j
3) นำ Weighted error rate นี้มาคำนวนหาน้ำหนัก `\alpha_j` ของ Classifier j ดังนี้:
`\alpha_j = \eta \log \frac{1-r_j}{r_j} \tag{3}`
* `\eta` อ่านว่า Eta คือ Learning rate hyperparameter ที่ควบคุมอัตราเร็วในการเรียนรู้ ปกติมีค่าเท่ากับ 1
* ยิ่ง Classifier j แม่นยำมากเท่าไหร่ แปลว่า Weighted error rate `r_j` มีค่าน้อย ส่งผลให้น้ำหนัก `\alpha_j `ของ Classifier j นั้นมีค่ามาก
4) นำน้ำหนัก `\alpha_j` ของ Classifier j ไปอับเดตน้ำหนัก `w^{(i)}` ของข้อมูลแต่ละรายการ ตามเงื่อนไขดังนี้:
```tex
\text{for } i = 1, 2, \dots ,m
w^{(i)} =
\begin{cases}
w^{(i)} \quad \text{if } \hat{y}^{(i)} = y^{(i)}\\
w^{(i)} e^{\alpha_j} \quad \text{if } \hat{y}^{(i)} \neq y^{(i)}
\end{cases} \tag{4}
```
แล้ว Normalise น้ำหนัก `w^{(i)}` ของข้อมูลแต่ละรายการ ด้วยการหารด้วยผลรวมของ `w^{(i)}` ทั้งหมด:
`w^{(i)} := \frac{w^{(i)}}{\sum\limits_{i = 1}^m w^{(i)}} \tag{5}`
จากสมการที่ (4) จะเห็นว่ารายการที่ทำนายผิด จะได้รับการ Boost หรือเสริมค่าน้ำหนัก เพื่อให้ Classifier instance j+1 ในรอบถัดไปเทรนซ้ำในสมการที่ (2) โดยเทรนจากค่าน้ำหนัก `w^{(i)}` ใหม่ของข้อมูลแต่ละรายการ
AdaBoosting จะทำกระบวนการที่ (2) ถึง (4) วนซ้ำไปเรื่อยๆ โดยจะหยุดก็ต่อเมื่อ:
* วนซ้ำครบจำนวน Classifier instance ที่กำหนด โดยสามารถกำหนดได้ใน Argument `n_estimators` หรือ
* ไม่พบรายการที่ทำนายผิดพลาดเลยแม้แต่รายการเดียว
5) เมื่อต้องการพยากรณ์ ก็จะคำนวนค่าพยากรณ์ `\hat{y}^{(i)}` ของทุกๆ Classifier instance โดยถ่วงน้ำหนักค่าพยากรณ์แต่ละ Instance ด้วยค่าน้ำหนัก `\alpha_j` ของ Classifier แต่ละ Instance ดังนั้น ค่าพยากรณ์ของ Instance ที่มีความแม่นยำ จะมีค่ามาก ได้รับการพิจารณามาก
คำตอบสุดท้ายที่ AdaBoost พยากรณ์ คือคำตอบที่ได้รับเสียงโหวตที่ถ่วงน้ำหนักแล้วมากที่สุด
สังเกตว่า AdaBoost ให้ค่ากับ Instance ที่ "เก่ง" มากกว่าที่ "ไม่เก่ง" ในขณะที่ Ensemble learning แบบ Random forest ให้ค่าน้ำหนักทุก Instance เท่ากัน
ข้อสังเกตที่สำคัญอีกประการก็คือ AdaBoost ไม่ได้มีเป้าหมายที่ทำให้ Classifier instance ตัวถัดๆ ไปมีความแม่นยำขึ้น แต่ทำงานโดยการเก็บคะแนนความแม่นยำของแต่ละ Instance เอาไว้เพื่อเอามาถ่วงน้ำหนักการตัดสินใจเมื่อต้องการพยากรณ์ในภายหลัง
ใน scikit-learn เราสามารถเรียกใช้ AdaBoost ได้ จาก `AdaBoostClassifier` class ในโมดูล `sklearn.ensemble`
### Gradient boosting
Gradient boosting เลือกวิธีการในการ Optimise อีกวิธี โดยการพยายามให้ Classifier instance ที่มาใหม่แต่ละตัว มีความแม่นยำขึ้นเรื่อยๆ โดยเรียนรู้จากค่าความคลาดเคลื่อนสะสมที่เกิดจากการทำนายของ Instance ก่อนหน้า
การทำงานของ Gradient boosting เข้าใจไม่ยาก สมมุติว่าเราใช้ `DecisionTreeRegressor` เราสามารถจำลอง Algorithm นี้ได้จากโค้ดดังนี้:
```python
from sklearn.tree import DecisionTreeRegressor
tree_reg1 = DecisionTreeRegressor(max-depth=2)
tree_reg1.fit(X, y)
```
จากนั้นเราเทรน `DecisionTreeRegressor` instance ที่ 2 จากความคลาดเคลื่อนสะสม ซึ่งก็คือความต่างระหว่าง `\hat{y}` กับ `y`:
```python
y2 = y - tree_reg1.predict(X)
tree_reg2 = DecisionTreeRegressor(max-depth=2)
tree_reg2.fit(X, y2)
```
และทำแบบนี้อีกครั้ง:
```python
y3 = y2 - tree_reg2.predict(X)
tree_reg3 = DecisionTreeRegressor(max-depth=2)
tree_reg3.fit(X, y3)
```
ส่วนเวลาพยากรณ์ เราจะเอาคำตอบของการพยากรณ์ทุกๆ Instance มาบวกกัน ซึ่งก็คือ:
`h(x) = h_1(x) + h_2(x) + \dots + h_J(x) \tag{6}`
โดย J คือจำนวน Instance ทั้งหมด
แต่ในความเป็นจริงเราไม่ต้องโค้ดเองแบบนี้ สามารถใช้ `GradientBoostingRegressor` หรือ `GradientBoostingClassifier` class ในโมดูล `sklearn.ensemble` ของ scikit-learn ได้เลย
ในแต่ละรอบ Classifier instance จะเทรนจาก Input `X` เดียวกัน แต่เปลี่ยน `y` ให้เป็นความต่างของค่าพยากรณ์กับคำตอบจริง ระหว่าง Instance ก่อนหน้ากับ Instance ปัจจุบัน (Residual error)
ส่วนการ Regularise นั้น Gradient boosting เป็น Algorithm ที่ค่อนข้างไม่ Overfit ง่ายจนเกินไป โดยถ้าหากเราตั้ง `learning_rate` เป็นค่าต่ำๆ จะทำให้ต้นไม้แต่ละต้นมีส่วนในการเรียนรู้น้อยลง นั่นหมายความว่าเราจะต้องใช้ต้นไม้จำนวนมากขึ้นเพื่อฟิต Train set วิธีนี้มักจะช่วยให้ Generalise ไปยังข้อมูลที่โมเดลยังไม่ได้เห็นได้ดีกว่า ดังนั้น สิ่งที่ควรรู้ก็คือ หากเราลดค่า `learning_rate` เราจะต้องเพิ่ม `n_estimators` ด้วย เพื่อลด Bias/underfit
ภาพแรกแสดง `learning_rate=0.1, n_estimators=3` แสดงให้เห็นว่าโมเดลนั้น Underfit เล็กน้อย ควรแก้ด้วยการเพิ่มจำนวนต้นไม้ `n_estimators`
ภาพสองแสดง `learning_rate=0.1, n_estimators=200` แสดงให้เห็นว่าเมื่อเพิ่มจำนวนต้นไม้แล้ว โมเดลสามารถฟิตข้อมูลได้ดียิ่งขึ้น แต่ก็ยังไม่ Overfit จนเกินไป
โดยสรุปแล้ว Algorithm ตระกูล Gradient boosting ซึ่งรวมทั้ง XGBoost เป็นกลุ่ม Algorithm ที่ยืดหยุ่น แม่นยำ และประสิทธิภาพดีที่สุดกลุ่มหนึ่งในปัจจุบัน
มาถึงจุดนี้ เราได้รู้จักกับ Supervised learning algorithm หลักๆ ครบแล้ว (ยกเว้น Neural networks ซึ่งจะเป็นหัวข้อใหญ่อีกกลุ่มหนึ่ง) บทต่อไปเราจะทำความรู้จักกับ Unsupervised learning algorithm เช่น K-Means clustering กัน
## บทที่ 12 Clustering
ที่ผ่านมา 11 บท เราได้ทำความรู้จักกับ Supervised learning ซึ่งมีเป้าหมายในการสร้างโมเดลเพื่อทำนายคำตอบ โดยมีชุดข้อมูลที่รู้คำตอบอยู่แล้วเป็นแหล่งในการเรียนรู้ของ Algorithm ในบทที่ 12 นี้ เราจะมาเรียนรู้ Unsupervised learning ซึ่งเป็นการหาคำตอบจากข้อมูลที่ยังไม่มีใครรู้ว่าคำตอบคืออะไร โดยเราจะมุ่งเน้นที่ Clustering หรือการจัดกลุ่มข้อมูล
สมมุติเรามีข้อมูลที่เป็นความสัมพันธ์ระหว่างสองสิ่ง เช่นในชุดข้อมูล Iris เรามี Petal length และ Petal width ของดอก Iris จำนวน 150 รายการ เราลองโหลดและดูข้อมูล 10 รายการแรกกัน:
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
# Load the iris data
iris = datasets.load_iris()
X = iris.data[:, 2:]
y = iris.target
# Explore the data
print(X[:10, :])
```
ได้ผลออกมาดังนี้:
```
[[1.4 0.2]
[1.4 0.2]
[1.3 0.2]
[1.5 0.2]
[1.4 0.2]
[1.7 0.4]
[1.4 0.3]
[1.5 0.2]
[1.4 0.2]
[1.5 0.1]]
```
สามารถพล็อตข้อมูลเป็น Scatterplot ได้ดังนี้:
```python
# Plot the data
plt.figure(figsize=(7,6))
plt.scatter(X[:, 0], X[:, 1], cmap='Paired_r')
plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plt.show()
```
เราจะมาจัดกลุ่มข้อมูลชุดนี้ออกเป็น 3 กลุ่ม โดยสมมุติว่าเราไม่รู้มาก่อนว่า 3 กลุ่มนี้คืออะไรบ้าง (อันที่จริงเรารู้ เพราะข้อมูลชุดนี้เป็น Classification dataset แต่เราไม่ได้นำคำตอบมาใช้ เพื่อจะได้เปรียบเทียบให้ดูภายหลังว่าการแบ่งกลุ่มของ Algorithm เหมือนหรือต่างกับคำตอบจริงแค่ไหน)
เราจะใช้ K-Means clustering algorithm ซึ่งเรียกใช้ได้จาก Class `KMeans` ในโมดูล `sklearn.cluster`:
```python
# Apply K-Means
kmeans = KMeans(n_clusters=3).fit(X)
```
สังเกตว่าเรากำหนดจำนวน Cluster เป็น 3
เราสามารถแสดงผลการจัดกลุ่มได้ด้วย Method `.label_` ของ `KMeans` instance:
```python
# Output labels
y_clustered = kmeans.labels_
print(y_clustered)
```
ผลออกมาคือ:
```
[2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 1 1 1
1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1
1 1]
```
นี่คือหมายเลข Label ขอบข้อมูลทั้ง 150 รายการที่ K-Means แบ่งให้ เรามาลองพล็อต Scatterplot ที่แบ่งสีตาม Label ใหม่นี้กัน:
```python
# Plot the clustered data with centroids
plt.figure(figsize=(7,6))
scatter = plt.scatter(X[:, 0], X[:, 1], c=y_clustered, cmap='tab10')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=100, c='red')
plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plt.legend(*scatter.legend_elements())
plt.show()
```
จุดสีแดง คือจุดศูนย์กลางของแต่ละ Cluster ซึ่งเราจะอธิบายในส่วน Algorithm ว่าได้มาอย่างไร
อย่างที่บอกตอนแรก คือข้อมูลชุดนี้ในความเป็นจริงเรารู้คำตอบ เพื่อความน่าสนใจจะมาลองดูว่าต้นฉบับนั้นจำแนก Label อย่างไร สิ่งที่ต้องทำก็เพียงแค่เปลี่ยน Argument `c=y_clustered` ใน `plt.scatter` เป็น `c=y` เพื่อให้ Map สีเข้ากับข้อมูล `y` ต้นฉบับ ได้ผลคือ:
ดูคล้ายกันดีมาก ต่างกันเล็กน้อยตรงรอยต่อ
ถ้าพิจารณาดู `y` ของข้อมูลชุดนี้ คือชื่อสายพันธุ์ของดอก Iris ซึ่งมี 3 Class คือ Setosa, Versicolor, Virginica ข้อมูลที่เก็บมาคือความยาวและความกว้างของกลีบดอก ซึ่งเรารู้ว่าโดยธรรมชาติแล้ว Iris ทั้ง 3 สายพันธุ์มีลักษณะความยาวความกว้างกลีบดอกไม่เหมือนกันดังภาพสุดท้าย การที่เราใช้ Machine จำแนกข้อมูลทั้งสองนี้ออกเป็น 3 Class แล้วได้ผลใกล้เคียงการจำแนกของธรรมชาติ ก็ดูเป็นสิ่งที่น่าทึ่งทีเดียว เพราะ Algorithm เป็นกลไกทางคณิตศาสตร์ เมื่อกลไกคณิตศาสตร์นี้ทำงานแล้วได้ผลเหมือนธรรมชาติ นั่นก็อาจจะแปลว่าธรรมชาติสร้างสิ่งต่างๆ ตามหลักคณิตศาสตร์ก็เป็นได้
ทีนี้เรามองลองดูว่า K-Means clustering จำแนกข้อมูลเป็นกลุ่มๆ โดยไม่รู้มาก่อนว่าแต่ละกลุ่มคืออะไรได้อย่างไร
### K-Means clustering algorithm
K-Means clustering มีขั้นตอนการทำงานดังนี้
สมมุติว่าต้องการแบ่ง Cluster เป็น 2 Class:
1) สุ่มเลือกข้อมูลสองจุดใน Dataset เป็นจุดศูนย์กลางเริ่มต้น เรียกว่า Centroid
2) กำหนดให้รายการข้อมูลที่อยู่ใกล้แต่ละ Centroid เป็นสมาชิกของ Centroid นั้น โดยข้อมูลแต่ละรายการจะเป็นสมาชิกได้ Centroid เดียวเท่านั้น:
`c^{(i)} = \text{argmin}_k ||x^{(i)}-\mu_{k}||^2 \tag{1}`
* `c^{(i)}` คือรหัส Class ที่กำหนดให้ข้อมูล `x^{(i)}`
* `\mu_{k}` คือ Centroid k
3) คำนวนค่าเฉลี่ยของสมาชิกทุกรายการในแต่ละ Centroid แล้วย้าย Centroid ไปสู่ค่าเฉลี่ยนั้น ขั้นตอนนี้จะทำให้ Centroid ขยับที่เล็กน้อย
`\mu_{k} = \frac{1}{n} (x^{(k_1)}+x^{(k_2)}+ \dots +x^{(k_n)}) \tag{2}`
4) ทำซ้ำข้อ 2) และ 3) จนกระทั่งได้ Cluster 2 Class โดยมีเงื่อนไขว่าจะจบก็ต่อเมื่อได้รหัสของ Class `c^{(i)}` และ Centroid `\mu_{k}` ที่ทำให้ค่าเฉลี่ยของผลรวมระยะทางระหว่างรายการข้อมูลที่เป็นสมาชิก Centroid กับ Centroid นั้นๆ มีค่าน้อยที่สุด โดยคำนวนจากข้อมูลทุกรายการและ Centroid ทุก Centroid สามารถเขียนเป็น Cost function ได้ดังนี้:
`\text{min}_{c, \mu} J(c, \mu) = \frac{1}{m} \sum\limits_{i=1}^m ||x^{(i)}-\mu_{c^{(i)}}||^2 \tag{3}`
* `\mu_{c^{(i)}}` คือ Centroid ที่ข้อมูล `x^{(i)}` เป็นสมาชิก
จริงๆ ยังมี Clustering algorithm อื่นๆ อีก แต่ K-Means นั้นเป็นที่นิยมมากที่สุด ถ้าสนใจสามารถศึกษาเพิ่มเติมเอกได้จากเอกสารของ scikit-learn
ตอนต่อไปเราจะเริ่มเรียนรู้การตรวจหาข้อมูลที่ผิดปกติ ไม่เข้าพวก ที่เรียกว่า Anomaly detection
## บทที่ 13 Anomaly Detection
หากเรามีชุดข้อมูลที่จะเทรนเพื่อสร้างโมเดล แล้วข้อมูลบางรายการมีค่าผิดปกติไปจากพวก Algorithm จะนำความผิดปกติเหล่านั้นไปคำนวนเป็นส่วนหนึ่งของโมเดล ซึ่งหมายความว่าเราอาจจะได้โมเดลที่ไม่ได้เป็นภาพสะท้อนที่แม่นยำของข้อมูลที่น่าจะนำมาใช้พยากรณ์จริง นั่นคือเกิดปัญหา Overfitting หรือ Variance นั่นเอง
เราเรียกปัญหานี้ว่าปัญหา Outlier หรือข้อมูล Input ที่ผิดแผกไปจวกพวก ซึ่งสามารถตรวจจับได้ด้วย Unsupervised learning algorithm ประเภท Outlier detection โดยเมื่อตรวจเจอแล้ว เราสามารถพิจารณาจัดการกับข้อมูลเหล่านั้น เช่นการลบออกไป เพื่อจะสามารถสร้างโมเดลที่เป็นตัวแทนที่ดีของข้อมูลส่วนมาก
ในอีกด้านหนึ่ง หากเรามีชุดข้อมูลที่เรารู้ว่า "ปกติ" อยู่ เราอาจต้องการตรวจจับข้อมูลใหม่ที่อยู่นอกกรอบของความ "ปกติ" โจทย์แบบนี้มีประโยชน์มากมาย เช่น การตรวจหาความผิดปกติของธุรกรรมการเงินเพื่อเฝ้าระวังการทุจริตคอร์รัปชัน หรือการตรวจการทำงานของเครื่องจักรต่างๆ ในระบบที่มีหลายเครื่อง เพื่อรู้ได้ทันทีเมื่อมีเครื่องที่ผิดปกติ เราเรียกกระบวนการแบบนี้ว่า Novelty detection ซึ่งก็คือการพยากรณ์ว่าข้อมูลใหม่นั้นเป็น Outlier เมื่อเทียบกับข้อมูลที่มีอยู่แล้วหรือไม่นั่นเอง
ในบทนี้เราจะมาเรียนรู้ Unsupervised learning algorithm สำหรับการตรวจจับความผิดปกติ โดยจะนำเสนอ Elliptic envelope, Isolation forest, และ Local Outlier Factor (LOF) สำหรับ Outlier detection ส่วน Novelty detection จะนำเสนอ One Class SVM
### Elliptic envelope
สมมุติว่าเรามีข้อมูลที่มีการกระจายตัวแบบ "มาตรฐาน" เช่นแบบ Gaussian distribution
เราสามารถใช้ Elliptic envelope หาจุดศูนย์กลางของข้อมูล แล้วตรวจหาข้อมูลที่อยู่นอกการกระจายเป็นวงรีแบบ Gaussian โดยจะพิจารณารูปร่างของวงรีตาม Covariance ของการกระจายตัวใน Matrix ข้อมูล
เราสามารถเรียกใช้ Elliptic envelope จาก Class `EllipticEnvelope` ในโมดูล `sklearn.covariance`
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.covariance import EllipticEnvelope
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor
from sklearn.svm import OneClassSVM
# Generate 2-D random data
cov = np.array([[1, .6],
[.6, 1]])
X = np.random.RandomState(0).multivariate_normal(mean=[0, 0],
cov=cov, size=500)
# Call and fit the Elliptic Envelope detector
ee_detector = EllipticEnvelope(contamination=0.1).fit(X)
ee_detect = ee_detector.predict(X)
ee_detect
```
ตอนเราเรียก `EllipticEnvelope` instance (รวมทั้ง Anomaly detection algorithm อื่นๆ) เราสามารถกำหนด Argument `contamination` เพื่อระบุว่าเราจะตรวจหา Anomaly เป็นสัดส่วนเท่าใดเมื่อเทียบกับข้อมูลทั้งหมด เช่น 0.1 คือ 10%
ผลจากการเรียก Method `.predict` จะได้เป็น Array ที่มี Label ของข้อมูลแต่ละรายการ โดย 1 คือปกติ ส่วน -1 คือไม่ปกติ:
```
array([ 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1,
1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1,
1, -1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1,
1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1,
1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1,
1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1,
1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1,
1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1,
-1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1,
1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1,
1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1])
```
เราสามารถพล็อต Scatterplot โดยแยกสีข้อมูลที่ปกติและไม่ปกติ ดังนี้:
```python
# Plot the data
plt.figure(figsize=(9,7))
plt.scatter(X[:, 0], X[:, 1], c=ee_detect, cmap="flag", alpha=0.5)
plt.title("Elliptic Envelope")
plt.show()
```
จะเห็นว่า Elliptic envelope ได้จำแนกข้อมูล 10% ที่อยู่นอกการกระจายตัวแบบวงรีออกจากข้อมูลทั้งหมด
### Isolation forest
Isolation forest ใช้เทคนิคแบบ Random forest โดยสุ่มเลือกจุดบนข้อมูล และสร้าง Tree แยกข้อมูลเป็นสาขา โดยมีสมมุติฐานว่า ข้อมูลปกติจะสามารถแตกกิ่งสาขาเป็นจำนวนพอๆ กัน ดังนั้น หากพบ Node ที่แตกสาขาน้อยกว่าค่าเฉลี่ยอย่างมีนัยสำคัญ ก็จะถือว่าเป็นข้อมูลที่ผิดปกติ
```python
# Call and fit the Isolation Forest detector
if_detector = IsolationForest(n_estimators=10, contamination=0.1).fit(X)
if_detect = if_detector.predict(X)
```
สังเกตว่า Hyperparameter ที่กำหนดได้ คือจำนวนต้นไม้ที่จะมาช่วยกันสุ่ม ซึ่งก็คือ Argument `n_estimators`
เราสามารถเรียกใช้ Isolation forest จาก Class `IsolationForest` ในโมดูล `sklearn.ensemble`
### Local Outlier Factor (LOF)
Local Outlier Factor หรือ LOF เปรียบเทียบความหนาแน่นของข้อมูลจุดต่างๆ แล้วแยกจุดที่มีความหนาแน่นน้อยออกเป็น Anomaly โดยความหนาแน่นจะคำนวนจาก K-Nearest neighbors ซึ่งก็คือระยะห่างระหว่างจุดที่เราสนใจ กับจุด "เพื่อนบ้าน" ที่ใกล้ที่สุดจำนวน K จุดตามที่เรากำหนด
```python
# Call and fit the Local Outlier Factor detector
lof_detector = LocalOutlierFactor(n_neighbors=20, contamination=0.1)
lof_detect = lof_detector.fit_predict(X)
```
อนึ่ง LOF สามารถใช้กับ Novelty detection หรือการตรวจหาข้อมูลใหม่ที่ผิดปกติเมื่อรู้ข้อมูลปัจจุบัน โดยใส่ Argument `novelty=True` แล้วใช้ `.fit(X)` เข้ากับข้อมูลปัจจุบัน ตามด้วย `.predict(X_new)` บนข้อมูลใหม่
เราสามารถเรียกใช้ Local Outlier Factor จาก Class `LocalOutlierFactor` ในโมดูล `sklearn.neighbors`
### One Class SVM
One Class SVM ทำงานโดยการสร้าง Support Vector ด้วย RBF Kernel เพื่อเป็นเส้นขอบเขตการตัดสินใจ ใช้สำหรับ Novelty detection เท่านั้น
```python
# Call and fit the One Class SVM detector
X_new = np.array([[-1, 2],
[-.1, 1]])
svm_detector = OneClassSVM(tol=0.1, nu=0.1, gamma=0.1).fit(X)
svm_detect = svm_detector.predict(X_new)
svm_detect
```
ทบทวนว่า Novelty detection คือการตรวจหาว่าข้อมูลใหม่ผิดปกติหรือไม่ ดังนั้นเราจะป้อนข้อมูลใหม่ลงไปใน `.predict` ซึ่งจากตัวอย่างมี 2 รายการ คือ [-1, 2] และ [-0.1, 1] ซึ่งได้ผลคือ:
```
array([-1, 1])
```
แปลว่าข้อมูลใหม่รายการที่ 1 นั้นผิดปกติ ส่วนรายการที่ 2 นั้นปกติ
เรามาลองพล็อตขอบเขตการตัดสินใจดู สังเกตว่าข้อมูลรายการที่ 1 คือจุดสีแดง ส่วนรายการ 2 คือจุดสีดำ:
```python
# Plot the data with decision boundaries
def plot_decision_boundary(clf, X, y, cmap='Paired_r'):
h = 0.005 # Boundary lines' resolution
x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.figure(figsize=(9,7))
plt.contourf(xx, yy, Z, cmap=cmap, alpha=0.2) # Background
plt.contour(xx, yy, Z, colors='k', linewidths=0.2) # Boundary lines
plt.scatter(X[:, 0], X[:, 1], c="gray", cmap="flag", alpha=0.4)
plt.scatter(X_new[:, 0], X_new[:, 1], s=100, c=svm_detect, cmap="flag", alpha=0.8)
plt.xlabel("x1")
plt.ylabel("x2")
plt.title("One Class SVM with Decision Boundary")
plot_decision_boundary(svm_detector, X, svm_detect)
```
ข้อด้อยอย่างหนึ่งของ SVM คือมี Hyperparameter ที่ต้องปรับแต่งค่อนข้างมาก เช่นจากตัวอย่าง มี `tol=0.1, nu=0.1, gamma=0.1` อย่างไรก็ตาม ข้อด้อยนี้ก็อาจกลายเป็นข้อดีได้ เพราะเราจะสามารถปรับจูนเส้นขอบเขตการตัดสินใจได้ละเอียดตามที่ต้องการ ความหมายของ Hyperparameter แต่ละตัวสามารถดูได้จากคู่มือของ scikit-learn
การเรียกใช้ One Class SVM สามารถเรียกได้จาก Class `OneClassSVM` ในโมดูล `sklearn.svm`
บทต่อไปเราจะเริ่มเรียนรู้ Deep learning กัน โดยเริ่มด้วยการทำความเข้าใจ Neural network ซึ่งเป็นหัวใจของ Deep learning
## บทที่ 14 Neural Network Algorithm
Artificial neural network เป็น Algorithm หลักของการเรียนรู้แบบ Deep learning ซึ่งเป็นแนวทางการเรียนรู้แบบหนึ่งของ Machine learning
หลายคนคงเคยได้ยินมาว่า Deep learning ในปัจจุบันนั้นมีความสามารถมาก เช่นสามารถพยากรณ์มะเร็งจากภาพ X-ray ได้แม่นยำกว่าแพทย์ สามารถแยกแยะหน้าคนว่าใครเป็นใคร สามารถอ่านป้ายจราจรจากภาพถ่าย แยกเสียงพูดออกจากเสียงดนตรี เล่นหมากล้อมชนะแชมป์โลก ไปจนถึงการสร้างภาพดาราที่ไม่มีตัวตนจริง จะเห็นว่าความสามารถเหล่านี้ล้วนมีจุดร่วมกันอยู่หนึ่งอย่าง นั่นคือข้อมูล Input ที่ป้อนเข้า Deep learning algorithm มักจะเป็นข้อมูลแบบที่ไม่มีโครงสร้าง หรือที่เรียกว่า Unstructured data เช่น ภาพ ข้อความ เสียง ในขณะที่ Machine learning algorithm ทั่วไปมักจะเหมาะสมกับข้อมูลแบบ Structured data ที่มีโครงสร้างเป็นตาราง
อะไรคือสิ่งที่ทำให้ Neural network สามารถเรียนรู้จากข้อมูลที่ไม่มีโครงสร้างได้ดีกว่าวิธีอื่นๆ คำตอบอยู่ที่โครงสร้างการเรียนรู้ (Learning architecture) ของ Neural network ต่างจากโครงสร้างการเรียนรู้ของ Machine learning algorithm แบบทั่วไป
เรามาลองทำความเข้าใจโครงสร้างของการเรียนรู้ทั้งสองแบบกันว่าต่างกันอย่างไร
ใน Machine learning algorithm ทั่วไป เช่น Linear regression และ logistic regression โครงสร้างการเรียนรู้เป็นดังนี้:
มี 3 ส่วน คือ Input, Classifier, และ Prediction
1) Input คือข้อมูลที่ป้อนเข้า Algorithm เช่นในกรณีนี้มี 3 Feature ได้แก่ `x_1`, `x_2`, และ `x_3`
2) Classifier คือฟังก์ชันที่นำเอา Input x มาคำนวนร่วมกับค่าน้ำหนัก `w` ของ `x` แต่ละตัว ผลที่ได้เรียกว่า `z` แล้วป้อน `z` เข้าสู่ฟังก์ชันตัดสินใจ `\sigma` เช่น Sigmoid function เพื่อคำนวนความเป็นไปได้ของคำตอบ
3) Prediction คือการตีความคำตอบของ Classifier แล้วนำเสนอผลลัพธ์ให้ผู้ใช้ เช่นคำถาม Binary classification ก็ให้คำตอบว่า "ใช่" หรือ "ไม่ใช่"
ในขณะที่ Neural network มีโครงสร้างการเรียนรู้ดังนี้:
4 ส่วน คือ Input layer, Hidden layer, Output layer, และ Prediction โดยเราจะอธิบายการทำงานทีละส่วน อนึ่ง เราเรียกกระบวนการที่ทั้ง 4 ส่วนนี้ทำงานต่อเนื่องกันจากด้านซ้ายไปด้านขวาของโครงสร้าง Neural network ว่ากระบวนการแผ่กระจายเดินหน้า หรือ Forward propagation ซึ่งทำงานร่วมกับการแผ่กระจายย้อนกลับ หรือ Backward propagation ซึ่งจะอธิบายภายหลัง
แต่ก่อนที่จะรู้จัก Forward propagation หลายคนอาจจะเคยได้ยินหรือเคยตั้งคำถามว่า Artificial neural network นี้มีความเหมือนหรือต่างกับการทำงานของสมองหรือไม่อย่างไร เราลองมาดูภาพ Neuron ในสมอง ซึ่งเป็นหน่วยที่รับ ประมวลผล และส่งข้อมูลไปยังส่วนอื่น ๆ
หากจะเปรียบเทียบ โครงสร้างที่เห็นคือ Neuron ซึ่งรับข้อมูลมาจาก Dendrite แล้วส่งข้อมูลออกไปยัง Neuron ตัวถัดไปผ่าน Axon โดย Neuron แต่ละตัวจะรับและส่งข้อมูลกับ Neuron อื่นๆ หลายตัว ปัจจุบันเรายังไม่มีความเข้าใจดีนักว่าโครงสร้างนี้มีความหมายต่อกระบวนการเรียนรู้ของมนุษย์อย่างไร แต่ถ้าจะให้คาดเดา ก็ดูเหมือนว่าโครงสร้างที่มีการเชื่อมโยงกันเป็นเครือข่ายแบบนี้น่าจะทำให้สมองมีความสามารถในการประมวลผลข้อมูลที่รับมา กลายเป็นการตัดสินใจทั้งระดับร่างกายและจิตใจได้ Artificial neural network ได้รับแรงบันดาลใจมาจากโครงสร้างนี้ ถึงแม้กลไกการทำงานไม่จำเป็นต้องเหมือนกันก็ตาม
### Forward propagation
สมมุติว่า Algorithm มี Parameter w และ b ที่เป็นตัวแทนของข้อมูลเรียบร้อยแล้ว กระบวนการ Forward propagation คือการนำข้อมูล x เข้ามาประมวลผลร่วมกับ Parameter เหล่านั้นเป็นชั้นๆ จนได้คำตอบ
อย่างไรก็ตาม ในตอนเริ่มต้น โมเดลจะยังไม่มี Parameter ที่ถูกต้อง เราจึงต้องสุ่มค่าเริ่มต้นของ Parameter ขึ้นมาก่อน เมื่อ Forward propagation ทำงานจบ 1 เที่ยว ก็จะเปรียบเทียบผลการพยากรณ์กับคำตอบที่รู้อยู่แล้ว จากนั้นโมเดลจะใช้กระบวนการตรงกันข้าม คือ Backward propagation ในการปรับค่า Parameter ให้สะท้อนข้อมูลใน Train set มากขึ้น ทำอย่างนี้หลายๆ รอบจนกระทั่งได้ความแม่นยำของโมเดลตามที่ต้องการ อนึ่งเราเรียกการทำงานไป-กลับแต่ละรอบว่า 1 Epoch (ภาษาไทยอาจแปล Epoch ว่า "กัป" ซึ่งฟังดูยิ่งใหญ่ดี แต่อาจจะไม่เหมาะกับบริบทนี้ จึงขอใช้ Epoch คำเดิม)
Forward propagation มีกระบวนการดังนี้:
1) Input layer คือข้อมูลขาเข้า ถ้าเป็นข้อมูลแบบมีโครงสร้าง x แต่ละตัวจะแทน Feature หรือคอลัมน์ของข้อมูล เช่น อายุ เพศ รายได้ เป็นต้น
แต่ถ้าเป็นข้อมูลแบบไม่มีโครงสร้าง เช่นรูปภาพ x แต่ละตัวจะแทนค่าความสว่างของภาพ 1 Pixel ดังนั้น ถ้าเรามีภาพขาวดำขนาด 64 คูณ 64 Pixel เราจะได้จำนวน Input m = 64 \times 64 = 4096 แต่ถ้าเป็นภาพสี ต้องคูณ 3 เข้าไป เพราะภาพสีแต่ละ Pixel จะมีข้อมูลความสว่าง 3 สี คือ Red, Green, Blue
2) Hidden layer คือชั้นประมวลผลที่ซ่อนอยู่ ซึ่งมีได้หลายชั้น (จากตัวอย่างแสดงชั้นเดียว) ใน Hidden layer แต่ละชั้นจะมีหน่วยประมวลผลที่เรียกว่า Neuron โดยในภาพมี 4 Neuron
หน้าที่ของ Neuron แต่ละตัว คือการรับข้อมูล Input "ทุกตัว" จาก Layer ก่อนหน้า มาประมวลผลโดยใช้ Linear function ร่วมกับค่าน้ำหนัก w ของ Input แต่ละตัว ซึ่งให้ผล z แล้วนำ z ไปคำนวนใน Activation function g ซึ่งอาจจะเป็น Sigmoid, Tanh, หรือ RELU ก็ได้ คำตอบที่ได้เรียกว่า a สังเกตว่ากระบวนการนี้คล้ายกับขั้นตอน Classifier ของ ML algorithm ทั่วไป สิ่งที่ต่างคือชื่อเรียก สัญลักษณ์ที่ใช้แทน และจำนวน Neuron ที่มีมากกว่า 1
เราสามารถเขียนขั้นตอนนี้เป็นสมการได้ดังนี้:
สำหรับ `x^{(i)}` แต่ละรายการ:
```tex
z^{[1](i)} = W^{[1]}x^{(i)} + b^{[1]} \tag{1}
a^{[1](i)} = g(z^{[1](i)}) \tag{2}
```
โดยก่อนจะไปไกลกว่านี้ มาทำความคุ้นเคยกับสัญลักษณ์แทนลำดับที่ของสิ่งต่างๆ ในโมเดลกันก่อน:
* `[1]` ใน Brackets หมายถึงลำดับที่ของ Layer โดยนับ 1 ที่ Hidden layer แรก
* `(i)` ใน Parentheses หมายถึงลำดับรายการข้อมูลที่ i
* 1 ที่ห้อยด้านล่าง a คือลำดับที่ของ Neuron ใน Layer นั้นๆ
* นำสัญลักษณ์ทั้งหมดมารวมกัน ตัวอย่างเช่น `a^{[1](4)}_3` หมายถึง Activation function ตัวที่ 3 ของ Layer ที่ 1 ที่ทำงานกับข้อมูลรายการที่ 4
สิ่งสำคัญที่ต้องรู้ในขั้นนี้ คือ Hidden layer สามารถมีได้หลายชั้น เช่นถ้าหากมีชั้นที่ 2 สมการที่ (1) ก็จะนำ `a^{[1]}` มาแทน x และใช้ `W` และ `b` ของ Layer ที่สอง ดังนั้นเราสามารถเปลี่ยนรูปสมการที่ (1) และ (2) ให้เป็นรูปทั่วไปได้ดังนี้ (Vectorised form):
```tex
Z^{[l]} = W^{[l]}A^{[l-1]} + b^{[l]} \tag{3}
A^{[l]} = g(Z^{[l]}) \tag{4}
```
โดย [l] คือลำดับที่ของ Layer ซึ่งนับ 1 ที่ Hidden layer ที่ 1
คำว่า Deep ใน Deep learning ก็มาจากการที่โมเดลมี Layer หลายชั้นในการประมวลผลนั่นเอง
3) Output layer คือชั้นที่ประมวลผล Activation a ทั้งหมดจากชั้นก่อนหน้า โดยถือว่า `a^{[1]}` คือ Input ร่วมกับค่าน้ำหนัก `W^{[2]}` ของ `a^{[1]}` ในชั้นก่อนหน้า (ไม่ใช่ของ `x` ในชั้นแรก) ได้ผลเป็น `z^{[2]}` แล้วนำ `z^{[2]}` ไปคำนวนใน Activation function เช่น Sigmoid function ได้ผลเป็น `a^{[2]}`
เขียนเป็นสมการได้ดังนี้ (สังเกตว่าสอดคล้องกับสมการที่ (3) และ (4)):
```tex
z^{[2](i)} = W^{[2]}a^{[1](i)} + b^{[2]} \tag{5}
a^{[2](i)} = \sigma(z^{[2](i)}) \tag{6}
```
หรือเขียนเป็นรูปทั่วไป (Vectorised) คือ:
```tex
Z^{[L]} = W^{[L]}A^{[L-1]} + b^{[L]} \tag{7}
A^{[L]} = \sigma(Z^{[L]}) \tag{8}
```
โดย `[L]` คือจำนวน Layer ทั้งหมด ดังนั้นจึงหมายถึง Layer สุดท้าย ส่วน `[L-1]` ก็คือ Layer รองสุดท้าย
เพื่อความเข้าใจที่ดีขึ้น จะนำเสนอให้ดูว่าข้อมูลและตัวแปรแต่ละตัวใน Neural network มีหน้าตาอย่างไรในรูปแบบ Matrix และ Vector
สมมุติว่าเรามีข้อมูลดังนี้: Feature n_0 = 4096 จำนวน m = 10000 รายการ:
```tex
X =
\begin{pmatrix}
x_1^{(1)} & x_1^{(2)} & x_1^{(3)} & \cdots & x_1^{(10000)} \\
x_2^{(1)} & x_2^{(2)} & x_2^{(3)} & \cdots & x_2^{(10000)} \\
x_3^{(1)} & x_3^{(2)} & x_3^{(3)} & \cdots & x_3^{(10000)} \\
\vdots & \vdots & \vdots & \ddots & \vdots \\
x_{4096}^{(1)} & x_{4096}^{(2)} & x_{4096}^{(3)} & \cdots & x_{4096}^{(10000)} \\
\end{pmatrix}
\tag{9}
```
มิติของ Matrix X คือ `(n_0, m) = (4096, 10000)`
เราจะใช้ข้อมูลชุดนี้ใน Neural network ขนาด Layer L = 2 โดยมีจำนวน Neuron ใน Layer แรก `n_1 = 4` Neuron ส่วน Layer ที่สองเป็น Output layer ดังนั้นจึงมี `n_2 = 1`
ค่าน้ำหนัก `W^{[1]}` จะต้องคูณแบบ Dot product กับ X ได้ ดังนั้นจึงมีมิติ `(n_1, n_0) = (4, 4096)`:
```tex
W^{[1]} =
\begin{pmatrix}
w_1^{[1](1)} & w_1^{[1](2)} & w_1^{[1](3)} & \cdots & w_1^{[1](4096)} \\
w_2^{[1](1)} & w_2^{[1](2)} & w_2^{[1](3)} & \cdots & w_2^{[1](4096)} \\
w_3^{[1](1)} & w_3^{[1](2)} & w_3^{[1](3)} & \cdots & w_3^{[1](4096)} \\
w_4^{[1](1)} & w_4^{[1](2)} & w_4^{[1](3)} & \cdots & w_4^{[1](4096)} \\
\end{pmatrix}
\tag{10}
```
เมื่อ `W^{[1]}X` อยู่ในมิติ (n_1, n_0)` \times (n_0, m) = (n_1, m) = (4, 10000)` ดังนั้น `b^{[1]}` จึงจะต้องอยู่ในมิติ (n_1, 1) = (4, 1) จึงจะสามารถบวกเข้าไปสมการได้:
```tex
b^{[1]} =
\begin{pmatrix}
b_1^{[1](1)} \\
b_2^{[1](1)} \\
b_3^{[1](1)} \\
b_4^{[1](1)} \\
\end{pmatrix}
\tag{11}
```
เราต้องการ `Z^{[1]} = W^{[1]}X + b^{[1]}` ดังนั้น `Z^{[1]}` จึงต้องมีมิติ (n_1, m) = (4, 10000):
```tex
Z^{[1]} =
\begin{pmatrix}
z_1^{[1](1)} & z_1^{[1](2)} & z_1^{[1](3)} & \cdots & z_1^{[1](10000)} \\
z_2^{[1](1)} & z_2^{[1](2)} & z_2^{[1](3)} & \cdots & z_2^{[1](10000)} \\
z_3^{[1](1)} & z_3^{[1](2)} & z_3^{[1](3)} & \cdots & z_3^{[1](10000)} \\
z_4^{[1](1)} & z_4^{[1](2)} & z_4^{[1](3)} & \cdots & z_4^{[1](10000)} \\
\end{pmatrix}
\tag{12}
```
ส่วน `A^{[1]}` ก็มีมิติ (n_1, m) เหมือน `Z^{[1]}` เพราะเป็นการนำ `Z^{[1]}` มา Apply activation function ด้วยการ Broadcast ฟังก์ชันเข้าไปใน Matrix:
```tex
A^{[1]} =
\begin{pmatrix}
g(z_1^{[1](1)}) & g(z_1^{[1](2)}) & g(z_1^{[1](3)}) & \cdots & g(z_1^{[1](10000)}) \\
g(z_2^{[1](1)}) & g(z_2^{[1](2)}) & g(z_2^{[1](3)}) & \cdots & g(z_2^{[1](10000)}) \\
g(z_3^{[1](1)}) & g(z_3^{[1](2)}) & g(z_3^{[1](3)}) & \cdots & g(z_3^{[1](10000)}) \\
g(z_4^{[1](1)}) & g(z_4^{[1](2)}) & g(z_4^{[1](3)}) & \cdots & g(z_4^{[1](10000)}) \\
\end{pmatrix}
\tag{13}
```
4) Prediction นำเอาผล Activation `a^{[2]}` ของ Output layer มาตัดสินใจใน Decision function เพื่อพยากรณ์ เขียนเป็นสมการได้ดังนี้:
```tex
\hat{y}^{(i)} = a^{[2](i)} \tag{14}
y^{(i)}_{predict} =
\begin{cases}
1 \quad \text{if } a^{[2](i)} \geq 0.5 \\
0 \quad \text{if } a^{[2](i)} < 0.5
\end{cases} \tag{15}
```
ย้อนกลับมายังคำถามตั้งต้น ว่าทำไม Neural network จึงทำงานได้ดีกับข้อมูลแบบที่ไม่มีโครงสร้าง ลองพิจารณาดังนี้:
* ข้อมูลที่ไม่มีโครงสร้าง เช่นภาพ ข้อความ เสียง จะถูกนำเสนอในโมเดล ในลักษณะที่เป็น Feature จำนวนมาก โดยแต่ละ Feature แทนค่าหน่วยของข้อมูลที่บ่งบอกลักษณะของข้อมูลชิ้นนั้น เช่นความสว่างของ Pixel แต่ละจุด การนำเสนอแบบนี้ทำให้มนุษย์ไม่สามารถบอกหรือเตรียมล่วงหน้าได้ว่า Feature ไหนมีความสำคัญมากน้อย เพราะมีจำนวนมากและมีความซับซ้อนเกินกว่าที่สมองมนุษย์จะประมวลผลได้ ไม่เหมือน Feature ของข้อมูลที่มีโครงสร้างที่อยู่ในรูปของคอลัมน์ในตาราง ที่เราสามารถเตรียมเพิ่ม ลด ปรับแต่ง Feature เพื่อให้มีความหมายต่อโมเดล
* เมื่อเป็นเช่นนี้ หากเราใช้ Algorithm ทั่วไปในการเทรนข้อมูลที่มี Feature จำนวนมหาศาลแบบนี้ ก็มักจะได้ผลที่ไม่ดี เช่นเกิดปัญหา Variance ซึ่งก็คือการที่ Algorithm พยายามฟิตข้อมูลเข้ากับคำตอบที่รู้อยู่แล้ว แต่ Parameter เดียวกันนี้ไม่สามารถนำไปทำนายข้อมูลใหม่ที่มองไม่เห็นได้ดี เพราะจำนวนและความซับซ้อนของ Feature นั้นเกินกำลังที่ Algorithm ทั่วไปที่คำนวนชั้นเดียวจะสามารถทำความเข้าใจได้ดี
* ในขณะที่ Neural network จะแบ่งลำดับขั้นในการเรียนรู้ออกเป็นชั้นๆ โดยชั้นแรกจะเรียนรู้เพื่อแยกแยะ Feature อย่างหยาบๆ เช่น ถ้าเป็นภาพ ก็จะแยกบริเวณที่มีค่าความต่างของสีมาก เช่น ขอบของวัตถุ ออกมาก่อน จากนั้นจึงส่งข้อมูลที่แยกแยะเบื้องต้นแล้ว ไปยัง Layer ชั้นถัดไป ซึ่งจะได้รับข้อมูลที่ประมวลมาแล้ว นำไปแยกแยะค่าน้ำหนักของส่วนที่มีความละเอียดมากขึ้น เช่น ส่วนต่างๆ ของใบหน้า เป็นต้น
* การแยกแยะลักษณะของข้อมูลในแต่ละ Layer อาศัย Neuron หลายๆ ตัวทำงานพร้อมกัน โดยแต่ละตัวจะรับข้อมูลทั้งหมดจากชั้นที่แล้วเหมือนกัน แต่ให้ค่าน้ำหนัก w ไม่เท่ากัน การที่ค่าน้ำหนักของข้อมูล x แต่ละชิ้นไม่เท่ากันเลย ส่งผลเท่ากับการที่ Neuron แต่ละตัวช่วยกันประมวลข้อมูลเดียวกันโดยใช้มุมมองที่ต่างกันไปเล็กน้อย ทำให้เกิดผลเป็นการ Regularise ให้ข้อมูลลดโอกาสที่จะ Overfit train set ไปโดยปริยาย
ทบทวนอีกครั้งว่ากระบวนการทั้งหมดนี้ เรียกว่า Forward propagation ซึ่งจบลงด้วยการได้ค่าพยากรณ์ แต่แน่นอนว่าเมื่อเรายังไม่มี Parameter w และ b ที่ถูกต้อง ค่าที่พยากรณ์ได้ก็จะไม่ตรงกับความจริง ดังนั้นเราจะใช้กระบวนการ Backward propagation ในการปรับแต่ง Parameter ให้เป็นตัวแทนของข้อมูลได้เที่ยงตรงยิ่งขึ้น
### Backward propagation
บางคนอาจจะเคยได้ยินว่า Backward propagation คือส่วนที่ซับซ้อนและยากที่สุดของ Neural network algorithm ซึ่งอาจจะจริงในส่วนของการคำนวน แต่โดยหลักคิดแล้วไม่ได้ยากขนาดนั้น เรามาลองทำความเข้าใจกันดู
ทบทวนว่า กระบวนการ Forward propagation จบลงที่เราได้ค่าพยากรณ์ ดังนั้นสิ่งต่อไปที่เราต้องทำ คือการนำค่าพยากรณ์นั้นมาใส่ใน Cost function เพื่อหาความต่างระหว่างค่าพยากรณ์กับค่าจริง โดยสำหรับ Neural network เราจะใช้ Cost function ลักษณะเดียวกันกับ Logistic regression คือ:
สมมุติว่า L = 2:
```tex
J = -\frac{1}{m} \sum\limits_{i=0}^{m} \left( y^{(i)} \log(a^{[2](i)}) + (1-y^{(i)}) \log(1-a^{[2](i)}) \right) \tag{16}
```
อนึ่ง หากใครสนใจ เราสามารถเขียนโค้ดของ Cost function โดยใช้ numpy ช่วย Vectorise เพื่อให้สามารถคำนวน Cost function ของรายการข้อมูลทั้งหมดได้อย่างรวดเร็วโดยไม่ต้องใช้ For loop โดยเขียนได้ดังนี้:
```python
logprobs = np.multiply(np.log(A2),Y) + np.multiply(np.log(1-A2),1-Y)
cost = (-1/m)*np.sum(logprobs)
```
สิ่งต่อไปที่เราจะทำ คือเราจะหาว่า Parameter ที่ทำให้ Cost function มีค่าต่ำที่สุด โดยใช้กระบวนการ Gradient descent ซึ่งมีหลักการคือ:
1) หาอนุพันธ์ของ Parameter เช่น w เมื่อเปรียบเทียบกับ Cost function J:
```tex
\frac{\partial J(w)}{\partial w}\tag{17}
```
2) นำอนุพันธ์ที่ได้ไปลบออกจาก Parameter นั้น โดยควบคุมความเร็วในการลบด้วย Learning rate `\alpha` แล้วนำ Parameter ใหม่ไปคำนวนใน Forward propagation จะได้ Cost function ที่มีค่าลดลง ทำซ้ำขั้นตอนนี้ไปเรื่อยๆ จน Cost function มีค่าต่ำที่สุดที่จะเป็นไปได้:
ทำซ้ำจนกระทั่งผลลัพธ์ล่าสุดไม่เปลี่ยนแปลงจากผลลัพธ์ครั้งก่อน:
```tex
w := w - \alpha \frac{\partial}{\partial{w}} J(w)\tag{18}
```
ที่อธิบายไป เป็นภาพรวมของกระบวนการ แต่ใน Neural network เรามี Parameter หลายตัวและหลายชั้น ดังนั้นเราจึงต้องใช้หลายสมการในการหาอนุพันธ์ของ Parameter แต่ละตัว
โดย Parameter ที่ต้องหาอนุพันธ์ คือ Parameter ที่ส่งผลต่อค่าพยากรณ์ ได้แก่:
* `z` ของแต่ละ Layer ไม่ได้เป็นตัวแปรที่ต้องการ Optimise แต่จำเป็นต้องหาอนุพันธ์เพื่อจะได้ใช้ Chain rule หาอนุพันธ์ของ `w` และ `b` ได้
* `w` ของแต่ละ Layer เพราะเป็น Coefficient ของ `x`
* `b` ของแต่ละ Layer เพราะเป็น Intercept ของ Linear function `z = wx + b`
จะไม่แสดงวิธีการหาอนุพันธ์ของ Parameter แต่ละตัว เพราะยุ่งยากซับซ้อนค่อนข้างมาก แต่จะแสดงให้เห็นเลยว่าอนุพันธ์ของแต่ละ Parameter คืออะไร:
สมมุติว่า L = 2:
```tex
\color{blue}{dz^{[2]}} = a^{[2]}-y \tag{19}
dW^{[2]} = \color{blue}{dz^{[2]}} a^{[1]T}\tag{20}
db^{[2]} = \color{blue}{dz^{[2]}} \tag{21}
\color{red}{dz^{[1]}} = W^{[2]T} \color{blue}{dz^{[2]}} \tag{22}
dW^{[1]} = \color{red}{dz^{[1]}} x^T \tag{23}
db^{[1]} = \color{red}{dz^{[1]}} \tag{24}
```
ทั้งนี้จะไม่แสดงวิธีคิดแบบ Vectorised เพราะอยากเน้นให้เข้าใจหลักการมากกว่า ส่วนในทางปฏิบัติให้ใช้ Framework อย่าง Tensorflow จะสะดวกกว่ามาก
สังเกตว่าเราหาอนุพันธ์ของ z เช่น `\color{blue}{dz^{[2]}}` และ `\color{red}{dz^{[1]}}` เพื่อเป็นอนุพันธ์ตั้งต้นให้หาอนุพันธ์ของ `w` และ `b` ได้ตามที่เขียนไว้ข้างต้น
เมื่อเราได้อนุพันธ์ทั้ง 6 ตัว (สำหรับโมเดลความลึก 2 ชั้น ถ้า 3 ชั้นก็ต้องเพิ่มอีก 3 ตัว) เราก็จะเอาอนุพันธ์ของ `w` และ `b` ไปอัปเดตค่าตัวแปรทั้งสอง โดยทำดังนี้:
```tex
W^{[1]} := W^{[1]} - \alpha (dW^{[1]}) \tag{25}
b^{[1]} := b^{[1]} - \alpha (db^{[1]}) \tag{26}
W^{[2]} := W^{[2]} - \alpha (dW^{[2]}) \tag{27}
b^{[2]} := b^{[2]} - \alpha (db^{[2]}) \tag{28}
```
แล้วนำตัวแปรที่อัปเดตแล้วไปคำนวน Forward propagation ใน Epoch ใหม่ แล้วคิดอนุพันธ์ นำอนุพันธ์มาอัปเดตตัวแปร ทำอย่างนี้ซ้ำไปเรื่อยๆ จนถึงจุดที่ Cost function มีค่าต่ำที่สุด ก็จะได้โมเดลที่ฟิตกับ Train set ที่ดีที่สุดเท่าที่จะเป็นไปได้
มาถึงจุดนี้ ก็คงพอเข้าใจแล้วว่า Neural network ทำงานอย่างไร และเรียนรู้อย่างไร เรื่อง Neural network นี้มีรายละเอียดและวิธีการประยุกต์ใช้มากมาย ซึ่งจะค่อยๆ อธิบายในบทอื่นๆ
ส่วนในบทต่อไป เราจะเริ่มทดลองสร้างโมเดล Neural network และพยากรณ์ โดยใช้ Framework อย่าง Tensorflow และ Keras
## บทที่ 15 Neural Network Programming
บทนี้เราจะมาลองสร้างโมเดล Neural network อย่างง่ายๆ ด้วยการใช้ Deep learning framework ที่ชื่อ TensorFlow
เป้าหมายของเราคือการสร้างโมเดลพยากรณ์ว่าลายมือเขียนตัวเขียน 0-9 จากฐานข้อมูล MNIST นั้น เขียนว่าตัวเลขอะไร
ปัญหานี้เป็นปัญหาที่เหมาะสมกับ Deep learning เพราะข้อมูล Input เป็นภาพ ซึ่งเป็นข้อมูลที่ไม่มีโครงสร้าง (Unstructured data) และมีจำนวน Feature เยอะมาก โดยในกรณีชุดข้อมูล MNIST นี้ แต่ละภาพมีขนาด 28 x 28 Pixel นั่นคือมี 784 Feature นั่นคือ `x_0` จนถึง `x_{783}`
เราจะเริ่มด้วยการ Import library ที่ต้องใช้ ซึ่งนอกจาก numpy และ matplotlib ตามปกติ เราจะใช้ tensorflow.keras เพื่อโหลดชุดข้อมูลจาก `.datasets`, โครงสร้างโมเดลจาก `.models`, และโครงสร้างของ Layer ต่างๆ จาก `.layers`
Keras คือ High-level interface ของ TensorFlow ซึ่งเป็น Low-level framework เปรียบเทียบเหมือนกับ TensorFlow เป็นวงจรสวิทช์ไฟ เราอาจควบคุมว่าจะเปิดปิดไฟดวงไหนด้วยการเชื่อมสายไฟในสวิทช์ไฟเข้าด้วยกัน แต่จะใช้เวลาและไม่สะดวก Keras เปรียบเสมือนแผงสวิทช์ไฟที่มีสวิทช์และหน้ากากเรียบร้อย ทำให้เราควบคุมการเปิดปิดไฟได้ง่ายและสะดวกกว่ามาก
```python
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
```
Class ต่างๆ ที่เราโหลดมา จะอธิบายภายหลังในส่วนการสร้างโมเดล
จากนั้นเราก็โหลดชุดข้อมูล MNIST โดย TensorFlow ได้ฝัง MNIST ไว้ให้แล้ว เพราะเป็นชุดข้อมูลยอดนิยมที่เอาไว้ฝึกและทดสอบโมเดล การโหลดทำได้โดยเรียก:
```python
# Load the MNIST data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# Check data dimension
print("X_train data shape is", X_train.shape)
print("y_train data shape is", y_train.shape)
print("X_test data shape is", X_test.shape)
print("y_test data shape is", y_test.shape)
# Check data type
print("X_train data type is", X_train.dtype)
print("y_train data type is", y_train.dtype)
print("X_test data type is", X_test.dtype)
print("y_test data type is", y_test.dtype)
```
เราควรเช็กมิติข้อมูลทุกครั้งที่โหลดข้อมูลมา พบว่า Train set มี 60,000 รายการ ขนาด 28 x 28 Pixel ส่วน Test set มี 10,000 รายการ ส่วน Data Type เป็น `uint8`
```
X_train data shape is (60000, 28, 28)
y_train data shape is (60000,)
X_test data shape is (10000, 28, 28)
y_test data shape is (10000,)
X_train data type is uint8
y_train data type is uint8
X_test data type is uint8
y_test data type is uint8
```
จากนั้นมาลองดูตัวอย่างข้อมูลกัน เนื่องจากเรารู้ว่าข้อมูลเป็นภาพ เราสามารถใช้ Method `.imshow` ของ matplotlib แสดงภาพได้ทันที:
```python
# Visualise sample data
img_index = 999
print(y_train[img_index])
plt.imshow(X_train[img_index])
```
ได้ภาพขนาด 28 x 28 สังเกตว่ามีสี เพราะเป็นค่าตั้งต้นของ matplotlib เอง ในความเป็นจริงข้อมูลไม่ได้มีสี
ต่อมา เราจะ Preprocess ข้อมูลให้พร้อมใช้งานขึ้น สิ่งที่จะทำมีดังนี้:
* เปลี่ยนมิติข้อมูลให้เป็น 4 มิติ คือ (จำนวนรายการ, Column, Row, จำนวน Layer สี) โดยข้อมูลของเราเป็นภาพขาวดำขนาด 28 x 28 ดังนั้นมิติคือ (จำนวนรายการ, 28, 28, 1)
* กำหนดตัวแปรมิติข้อมูล เพื่อเตรียมใช้ใน Argument `input_shape` ใน Layer แรกของ Model โดยไม่ต้องระบุจำนวนรายการ ดังนั้น มิติข้อมูลสำหรับ Layer แรก คือ (28, 28, 1) อนึ่งเราต้องกำหนดมิติข้อมูลสำหรับ Layer แรกเท่านั้น ส่วน Layer อื่น TensorFlow จะอนุมานให้เอง
* แปลง Data type ของข้อมูลให้เป็น Float เพื่อให้ Algorithm สามารถคำนวนและแสดงผลเป็นค่าทศนิยมได้
* เลือกข้อมูลแค่บางส่วนมาเทรนและทดสอบ เราจะไม่ใช้ทั้งหมดเพราะจะใช้เวลาเทรนนาน จึงเลือก Train set 2,000 รายการ และ Test set 400 รายการ
* Scale ข้อมูลโดยใช้วิธี Normalise ซึ่งก็คือการหารข้อมูลทุกรายการด้วย Range ของค่าความสว่างของแต่ละ Pixel นั่นก็คือ 255 นั่นเอง
```python
# Reshaping the array to 3-d for Keras
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
# Specify input shape for the mode's 1st layer
input_shape = (28, 28, 1)
# Convert data type to float so we can get decimal points after division
# Also scope down X_train and X_test to 2000:400 samples
X_train = X_train[:2000, :, :, :].astype('float32')
X_test = X_test[:400, :, :, :].astype('float32')
# Also scope down y_train and y_test to 2000:400 samples
y_train = y_train[:2000]
y_test = y_test[:400]
# Normalising all data by dividing by max brightness value.
X_train /= 255
X_test /= 255
print('X_train shape:', X_train.shape)
print('X_test shape:', X_test.shape)
print('y_train shape:', y_train.shape)
print('y_test shape:', y_test.shape)
```
เช็คมิติข้อมูลอีกทีก็จะได้จำนวนรายการและมิติตามที่ต้องการ
```
X_train shape: (2000, 28, 28, 1)
X_test shape: (400, 28, 28, 1)
y_train shape: (2000,)
y_test shape: (400,)
```
ตอนนี้เราก็พร้อมจะสร้างโมเดลแล้ว ในขั้นนี้ เราต้องออกแบบว่าโมเดลของเราจะมีโครงสร้างอย่างไร ดังนั้น สิ่งที่ต้องตัดสินใจก็คือ:
* จำนวน Layer โดยนับ Hidden layer บวก Output layer
* คุณสมบัติของแต่ละ Layer เช่น Hidden layer แรก เป็น Dense layer (ทุก Neuron เชื่อมข้อมูลจากทุก Input จาก Layer ก่อนหน้า), จำนวน 100 Neuron, ใช้ RELU เป็น Activation function เป็นต้น เราจะอธิบายเรื่อง Activation function ในบทต่อๆ ไป
* Layer พิเศษ เช่น Dropout เป็นวิธีการ Regularise วิธีหนึ่ง ซึ่งจะอธิบายในบทต่อๆ ไป
* ตัวเลือกของ Optimisation algorithm ได้แก่ Cost function ที่ใช้ (Argument `loss`), กลไกการ Optimise ที่ใช้ (Argument `optimizer`), และวิธีการชี้วัดความแม่นยำ (Argument `metrics`) โดยตัวเลือกต่างๆ จะอธิบายภายหลังเช่นกัน
เมื่อตัดสินใจได้แล้วว่าโมเดลจะมีโครงสร้างและคุณสมบัติอย่างไร ขั้นตอนในการสร้างโมเดลก็คือ:
* Instantiate โครงสร้างโมเดล โดยเรียก Class `Sequential` ให้อยู่ใน Instance object โดยเราจะใช้ชื่อ Instance นี้ว่า `model`
* เรียก Method `.add` เพื่อสร้าง Layer ทีละชั้น จากซ้ายไปขวา โดยกำหนด Argument ที่สอดคล้องกับโครงสร้าง Layer ที่เราออกแบบไว้
* Compile โมเดลตามโครงสร้างที่เรากำหนดไว้ โดยเรียก Method `.compile`
```python
# Build and compile model
model = Sequential()
model.add(Flatten())
model.add(Dense(100, activation='relu', input_shape=input_shape))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
```
สังเกต Layer สุดท้าย คือ `Dense(10, activation='softmax')` ใช้ Softmax activation function ซึ่งทำให้โมเดลสามารถ Output แบบ Multiclass ได้ โดยเราต้องกำหนดจำนวน Neuron เท่ากับจำนวน Class ที่เป็นไปได้ ซึ่งก็คือ 10 นั่นเอง
จากนั้นก็เริ่มเทรนโดยเรียก Method `.fit` พร้อมกำหนด Argument ต่างๆ ซึ่งหลักๆ ก็มี:
* `epochs` จำนวนรอบของการเทรน โดยแต่ละ Epoch จะทำให้ Loss ลดลง ในขณะที่ Accuracy เพิ่ม
* `batch_size` ขนาดของ Batch ซึ่งก็คือจำนวนรายการข้อมูลที่จะให้ Optimiser คำนวนในหนึ่งครั้ง เช่น ข้อมูลมี 2,000 รายการ ถ้ากำหนด Batch size เป็น 32 แปลว่า Optimiser จะต้องทำงาน 62.5 ครั้ง จึงจะครบทั้ง 2,000 รายการ และถ้ากำหนด Epoch เป็น 20 ก็หมายถึงการทำงาน 62.5 ครั้ง 20 รอบ การกำหนด Batch size จะมีผลโดยตรงกับความเร็วในการคำนวน ยิ่ง Batch ใหญ่ ยิ่งคำนวนเร็ว แต่ Batch ที่ใหญ่เกินไปอาจทำให้ข้อมูลที่คำนวนมีขนาดใหญ่เกินกว่า Memory ของเครื่องเราจะรองรับได้ ทั้งนี้ใน การกำหนด Batch size แบบต่างๆ จะมีชื่อเรียกเฉพาะ เช่น Batch gradient descent แปลว่า Batch size เท่ากับจำนวนรายการข้อมูล ไม่มีการแบ่ง, Mini-batch gradient descent คือการแบ่งข้อมูลออกเป็น Batch, ส่วน Stochastic gradient descent คือ Batch size เท่ากับ 1 เราจะอธิบายเรื่องนี้ละเอียดในภายหลัง
* `validation split` เราสามารถกัน Train set ส่วนหนึ่งไว้เป็น Validation set ซึ่งก็คือข้อมูลชุดที่โมเดลไม่เคยเห็น Keras จะคำนวน Loss และความแม่นยำกับ Validation set ทุกครั้งที่คำนวนจบ 1 Epoch และแสดงผลให้เราเห็น อนึ่งการแบ่ง Validation set จะตัดเอาส่วนสุดท้ายของ Train set มาเลยโดยไม่สุ่ม ดังนั้นเราจึงควรสุ่ม Shuffle ข้อมูลให้เรียบร้อยตั้งแต่แรก รายละเอียดเกี่ยวกับการแบ่งชุดข้อมูลออกเป็น Train / Validation / Test set จะอธิบายละเอียดในบทต่อๆ ไป
```python
# Fit the model to data
model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2, verbose=1)
```
การเทรนโมเดล Neural network อาจใช้เวลานานมาก ขึ้นอยู่กับจำนวนรายการและ Feature ข้อมูล รวมทั้งโครงสร้าง Layer เช่นจำนวน Layer และจำนวน Neuron โดย TensorFlow จะช่วยเราด้วยการแสดงความก้าวหน้าของการเทรนแต่ละ Epoch เป็น Progress bar และเวลาที่ใช้ เพื่อให้เราสามารถประเมินได้ว่าจะต้องรออีกนานเท่าใด
ผลที่ได้ออกมาดังนี้:
```
Train on 1600 samples, validate on 400 samples
Epoch 1/20
[===] - 1s 491us/sample - loss: 1.4701 - accuracy: 0.5881 - val_loss: 0.7175 - val_accuracy: 0.8275
Epoch 2/20
[===] - 0s 158us/sample - loss: 0.6571 - accuracy: 0.8213 - val_loss: 0.4700 - val_accuracy: 0.8600
Epoch 3/20
[===] - 0s 146us/sample - loss: 0.4681 - accuracy: 0.8744 - val_loss: 0.3726 - val_accuracy: 0.8925
. . . . . . .
. . . . . . .
. . . . . . .
Epoch 18/20
[===] - 0s 233us/sample - loss: 0.0807 - accuracy: 0.9844 - val_loss: 0.2492 - val_accuracy: 0.9375
Epoch 19/20
[===] - 0s 174us/sample - loss: 0.0675 - accuracy: 0.9906 - val_loss: 0.2474 - val_accuracy: 0.9275
Epoch 20/20
[===] - 0s 174us/sample - loss: 0.0638 - accuracy: 0.9881 - val_loss: 0.2490 - val_accuracy: 0.9300
```
สังเกตว่าแต่ละ Epoch ที่เทรน Loss และ Validation loss จะลดลงเรื่อยๆ สอดคล้องกับ Accuracy และ Validation accuracy ที่เพิ่มขึ้นเรื่อยๆ ซึ่งในกรณีของเราไปหยุดที่ Validation accuracy 93% เราสามารถใช้ผลนี้เป็นตัวบ่งชี้ว่าควรจะปรับ Hyperparameter ต่างๆ ของโมเดลหรือไม่อย่างไร เพื่อทำให้โมเดลมีความแม่นยำมากขึ้น รวมทั้งสามารถวิเคราะห์ปัญหา Bias/variance ด้วยการเปรียบเทียบข้อมูลจากการเทรนกับข้อมูลจาก Validation set
เราสามารถ Visualise ความก้าวหน้าของการฝึกโมเดลได้ โดยการใช้ matplotlib พล็อตค่าจาก `model.history.history` ซึ่งเก็บตัวเลขการเทรนไว้ใน Dictionary key:
```python
# Review model's progress
plt.figure(figsize=(9,6))
plt.plot(model.history.history['accuracy'], label='Train accuracy')
plt.plot(model.history.history['val_accuracy'], label='Validation accuracy')
plt.ylabel('Value')
plt.xlabel('No. epoch')
plt.legend()
plt.show()
```
จะเห็นว่าโมเดลของเราสามารถเพิ่ม Train accuracy ได้อย่างต่อเนื่อง อย่างไรก็ตาม ดูเหมือน Validation accuracy จะไม่ยอมเพิ่มจากจุดสูงสุด คือประมาณ 0.93 ตั้งแต่ Epoch ที่ 8 จากข้อมูลนี้เราสามารถวิเคราะห์ได้ว่าโมเดลมีปัญหา Variance ซึ่งก็คือการที่ไม่สามารถ Generalise ให้พยากรณ์ข้อมูลที่ไม่เคยเห็นได้ดีเท่าที่ควร ดังนั้นข้อมูลนี้จึงบอกเราว่าเราควรลองมาตรการต่างๆ ที่จะช่วยลดปัญหา Variance เช่น การเพิ่มขนาด Validation set การเพิ่มหรือปรับเทคนิคการ Regularisation เป็นต้น
ต่อมา เราก็นำทดสอบความแม่นยำของโมเดล กับ Test set ซึ่งแยกไว้ตั้งแต่แรกอีกที โดยการใช้ Method `.evaluate`:
```python
# Evaluate model's accuracy
score = model.evaluate(X_test, y_test, verbose=0)
print("Loss is", score[0])
print("Accuracy score is", score[1])
```
ได้ผลใกล้เคียงกับ Validation accuracy คือ 92.25%
```
Loss is 0.3142095559835434
Accuracy score is 0.9225
```
ตรงจุดนี้อาจมีคำถาม ว่าทำไมเราต้องทดสอบกับ Test set อีก ทั้งๆ ที่ได้ทดสอบกับ Validation set แล้ว คำตอบคือ Validation set มีหน้าที่เป็นชุดทดสอบให้เราปรับแต่งค่าต่างๆ ของโมเดล ซึ่งทำให้เกิดความเสี่ยงที่เราจะปรับค่าเพื่อ "เอาใจ" Validation set ส่งผลให้เรา Overfit validation set ทำให้เราไม่รู้ว่าโมเดลของเราจะมีความสามารถในการพยากรณ์ข้อมูลจริงที่ไม่เคยมองเห็นเพียงใด ดังนั้นเราจึงต้องทดสอบโมเดลที่ปรับแต่งเสร็จแล้ว กับ Test set อีกที เพื่อให้ได้ผลที่เที่ยงธรรม ไม่หลอกตัวเอง
สุดท้าย เรามาลองพยากรณ์กันเลย โดยป้อนภาพที่มี Index ที่ต้องการจาก `X_test` ลงไปใน Method `.predict` โดยอย่าลืมแปลงมิติข้อมูลให้สอดคล้องกับตอนแรก นั่นก็คือ (จำนวนรายการ, 28, 28, 1) ซึ่งก็คือ (1, 28, 28, 1) นั่นเอง
Method `.predict` จะ Output ออกมาเป็น Array ของความเป็นไปได้ การตีความก็คือเราจะเลือก Index ที่มีความเป็นไปได้สูงสุดเป็นคำตอบ เราสามารถใช้ Method `.argmax` ในการ Output index ที่มีค่าสูงสุดได้:
```python
# Make a prediction
image_index = 12
plt.imshow(X_test[image_index].reshape(28, 28),cmap='Greys')
pred = model.predict(X_test[image_index].reshape(1, 28, 28, 1))
print("Prediction probability array is:")
count = 0
for i in pred.squeeze():
print(count, ":", i)
count += 1
print("From which the max choice is:", pred.argmax())
```
```
Prediction probability array is:
0 : 6.983635e-06
1 : 1.8324994e-07
2 : 7.03581e-05
3 : 3.01667e-05
4 : 0.005716639
5 : 0.00045127788
6 : 9.964272e-07
7 : 0.0036463942
8 : 3.6717152e-05
9 : 0.99004024
From which the max choice is: 9
```
จะเห็นว่าภาพที่ 12 ที่เราเลือก เป็นภาพของเลข 9 โมเดลได้พยากรณ์ว่า 9 โดยให้ความเป็นไปได้ 99%
การเปรียบเทียบภาพจริงกับค่าที่พยากรณ์ได้ จะช่วยเป็นข้อมูลให้เราวิเคราะห์ข้อผิดพลาดของโมเดลได้ว่าเป็นอย่างไรและน่าจะเกิดจากอะไร โดยจะอธิบายเรื่อง Error analysis เพิ่มเติมในบทต่อๆ ไป
บทต่อไป เราจะมาเจาะลึกเกี่ยวกับโครงสร้างของโมเดลและตัวเลือกของ Optimisation algorithm
### บทที่ 16 Neural Network Vanishing Gradients
หลังจากที่เราสามารถสร้างโมเดล Deep learning แบบพื้นฐานแล้ว เราจะมาสำรวจปัญหาต่างๆ ในการเทรน Neural network และแนวทางแก้ไข โดยในบทนี้จะพูดถึงปัญหา Vanishing gradients
ในการเทรน Deep neural network เราอาจพบว่าโมเดลเทรนจบจนได้ Loss ที่ต่ำที่สุด แต่ก็ไม่ต่ำเท่าที่ควร นั่นคือเกิดปัญหา Bias ทั้งๆ ที่เราได้วางโครงสร้าง Layers, จำนวน Neuron, และจำนวนรายการเนื้อหาเหมาะสมเพียงพอแล้ว
บ่อยครั้งที่ Bias นี้ เกิดจากปัญหาที่เรียกว่า Vanishing gradients นั่นคือการที่เมื่อเราเทรนโมเดลโดยการอัปเดต Parameter ซ้ำๆ ในกระบวนการ Gradient descent อนุพันธ์ `\delta w` บางตัวจะมีค่าน้อยลงจนเหลือน้อยมากๆ โดยเฉพาะในตัวที่อยู่ใน Layer ชั้นแรกๆ ที่ใกล้กับ Input layer ส่งผลให้การอัปเดต Parameter ครั้งถัดไป Loss จะเปลี่ยนแปลงน้อยลงมากจนไม่เกิดผลในการ Optimise หรือต้องใช้เวลา (จำนวนรอบ) สูงมากๆ ในการเทรน อนึ่ง ในทางกลับกัน หากอนุพันธ์เพิ่มขึ้นสูงเกินไป ก็จะเกิดปัญหาที่เรียกว่า Exploding gradients ซึ่งก็ส่งผลให้ Optimise ไม่สามารถ Converge หาคำตอบที่ดีได้เช่นกัน
ปัญหา Vanishing gradients นี้มีแนวทางในการแก้ 3 แนวทางด้วยกัน ได้แก่:
* การเปลี่ยนวิธีการตั้งค่าตั้งต้นของ Parameter
* การเปลี่ยน Activation function
* การใช้เทคนิค Batch normalisation
ซึ่งเราจะอธิบายทีละแนวทาง
### Xavier and He initialisation
ถ้าเราตั้งค่าตั้งต้นให้กับน้ำหนัก w เป็น 0 เราจะแทบไม่สามารถเทรนอะไรได้เลย เพราะทุก Neuron ใน Layer แรกจะส่งค่า Activation เดียวกันออกไปยัง Layer ถัดไป ดังนั้นเราจึงต้องตั้งค่าตั้งต้นน้ำหนัก w ให้ไม่ใช่ 0 และไม่ใช่ตัวเลขที่เท่ากัน
แต่ถ้าเราตั้งค่าตั้งต้นของ w เป็นตัวเลขสุ่มทั่วไป จะพบว่าบางตัวเลขอาจทำให้เกิดปัญหา Vanishing gradients ดังนั้น เราจึงต้องมีวิธีที่ดีในการสุ่มค่าตั้งต้นของ w
วิธีดังกล่าว เรียกว่า Xavier initialisation มีหลักการคือจะต้องสุ่มค่าที่ทำให้ Variance ของ Output เท่ากับ Variance ของ Input ใน Layer เดียวกัน และต้องทำให้อนุพันธ์ `\delta w` ในแต่ละ Layer มี Variance เท่ากันทั้งขาเข้าและขาออกเมื่อทำ Backward propagation ด้วย อย่างไรก็ตามข้อกำหนดนี้เป็นไปไม่ได้ที่จะทำจริง เพราะจะทำได้ก็ต่อเมื่อแต่ละ Layer มีจำนวนการเชื่อมต่อขาเข้าเท่ากับขาออก ดังนั้นวิธีที่ดีที่สุดในการจำลองผลลัพธ์นี้ให้เกิดขึ้นได้ คือการใช้สมการต่อไปนี้:
```tex
r = \sqrt{\frac{6}{n_i + n_{i+1}}} \tag{1}
```
โดย n_i คือจำนวนการเชื่อมต่อขาเข้าของ Layer นั้น ส่วน `n_{i+1}` คือจำนวนการเชื่อมต่อที่ออกจาก Layer นั้น
วิธี Initialisation นี้เรียกว่า Xavier initialisation ตามชื่อของผู้คิดค้น ถูกออกแบบให้ใช้กับ Tanh activation function ซึ่งจะอธิบายในส่วนถัดไป
อย่างไรก็ตาม ในปัจจุบันเรามักใช้ Activation function ตระกูล ReLU แทน Sigmoid และ Tanh ดังนั้นเราจึงต้องเปลี่ยนแปลงวิธี Initialise ของ Xavier ให้อยู่ในรูปนี้:
```tex
r = \sqrt{\frac{6}{n_i}} \tag{2}
```
วิธีนี้เรียกว่า He initialisation ตามชื่อผู้คิดค้น ความแตกต่างกับ Xavier คือวิธีของ He พิจารณาเฉพาะจำนวนการเชื่อมต่อขาเข้าเท่านั้น
ทั้งสองวิธีเป็นวิธีสุ่มจาก Uniform distribution คือกระจายตัวออกเท่าๆ กันตลอด Range ของข้อมูล เราสามารถจะเลือกสุ่มแบบ Normal distribution คือกระจายการสุ่มให้กระจุกตัวเยอะตรงกลางๆ ของ Range ก็ได้ โดยการเปลี่ยนแปลงสมการเล็กน้อย ทั้งนี้ใน TensorFlow เราสามารถกำหนดวิธีการ Initialise ค่าน้ำหนักได้โดยใช้ Argument kernel_initializer ใน Layer เช่น:
```python
model.add(Dense(64,
kernel_initializer='he_uniform',
bias_initializer='zeros'))
```
อนึ่ง ค่าน้ำหนักของ b สามารถเริ่มด้วย 0 ได้ ไม่มีปัญหาอะไร
**ปัจจุบัน แนะนำให้ใช้ He initialiser** เพราะออกแบบมาให้ใช้กับ Activation function ตระกูล ReLU และ ELU ซึ่งแนะนำให้ใช้แทน Sigmoid หรือ Tanh โดยจะพูดถึงเรื่องนี้ในส่วนถัดไป
### Activation functions
ทบทวนอีกครั้ง ว่าการคำนวนของแต่ละ Neuron ประกอบด้วยการรับ Input `a^{[l-1]}` มาถ่วงน้ำหนักกับ `W^l` และ `b^l` จะได้ Linear function `z^l` จากนั้นจะนำ `z^l` ไปเป็น Input ของ Activation function `g` ซึ่งได้ผลเป็น `a^l` เขียนรวมได้ทั้งหมดดังนี้:
```tex
z^{[l](i)} = W^{[l]}a^{[l-1](i)} + b^{[l]} \tag{3}
a^{[l](i)} = g(z^{[l](i)}) \tag{4}
```
หน้าที่ของ Activation function g คือการควบคุม Output ของ Neuron ให้อยู่ใน Range ที่ Neuron ชั้นถัดไปจะคำนวนได้ง่าย และถ้าหาก Activation นั้นอยู่ใน Hidden layer ชั้นสุดท้าย ก็จะมีหน้าที่ควบคุม Range ของ Output ให้สามารถตีความเป็นคำตอบได้ง่าย
ยกตัวอย่างเช่นเมื่อใช้ Sigmoid function แทน g ตามสมการด้านล่าง ค่า Activation ที่ได้จะอยู่ในช่วง 0 ถึง 1 เท่านั้น ซึ่งสะดวกในการตีความแบบ Classification (มากกว่า 0.5 คือ "ใช่" น้อยกว่าคือ "ไม่ใช่"):
```tex
\sigma(z) = \frac{1}{1+e^{(-z)}} \tag{5}
```
Sigmoid function หาก z สูงมากๆ Activation ก็จะได้ผลเข้าใกล้ 1 ในทางกลับกัน หาก z น้อยมากๆ Activation ก็จะได้ผลเข้าใกล้ 0
นอกจาก Sigmoid ยังมี Activation function ที่คล้ายกัน คือ Tanh ย่อมาจาก Hyperbolic Tangent ซึ่งอยู่ในรูปนี้:
```tex
\text{tanh}(z) = \frac{1-e^{-2z}}{1+e^{-2z}} \tag{6}
```
Tanh ต่างจาก Sigmoid ตรงที่ Output จะอยู่ใน Range -1 และ 1 ซึ่งส่งผลให้การตีความแตกต่างออกไป โดยมีจุดตัดการตัดสินใจที่ 0 ไม่ใช่ 0.5
สังเกตว่า Output range ของ Tanh คือ 2 สูงกว่า Range ของ Sigmoid ที่เท่ากับ 1 อยู่ 2 เท่า
ทั้ง Sigmoid และ Tanh ต่างมีปัญหาหลักอยู่ 2 อย่าง ดังนี้:
* ใช้ Exponential ในการคำนวน ทำให้เปลืองพลังการประมวลผล
* เป็นหนึ่งในปัจจัยที่ทำให้เกิดปัญหา Vanishing gradients เพราะถ้าหาก Activation ของ Sigmoid / Tanh ออกมาเป็นค่าน้อยๆ หรือมากๆ อนุพันธ์ (ความชัน) ของ Sigmoid function ก็จะมีค่าน้อยมากเข้าใกล้ 0 เราต้องใช้อนุพันธ์ของ Sigmoid function ในการคำนวนอนุพันธ์ของ `z^{[1]}` ซึ่งจะถูกนำไปคำนวนอนุพันธ์ของ `w^{[1]}` และ `b^{[1]}` อีกต่อหนึ่ง นั่นหมายความว่า Neuron ที่ให้ค่า Activation สูงหรือต่ำเกินไป จะส่งผลให้การอัปเดต Parameter รอบถัดไปมีการเปลี่ยนแปลงน้อยลงกว่าที่ควรจะเป็น ซึ่งส่งผลให้กระบวนการ Optimisation ไม่สามารถหา Loss ที่ต่ำที่สุดได้
ปัญหาทั้งสองนี้แก้ได้โดยการเปลี่ยน Activation function เป็น ReLU
ReLU ย่อมาจาก Rectified Linear Unit เป็นฟังก์ชันที่เรียบง่ายมาก เรียกว่า Ramp function คือถ้า Input มีค่าตั้งแต่ 0 ขึ้นไป Output ก็จะมีค่าเท่ากัน ส่วน Input ที่น้อยกว่า 0 จะกำหนด Output เป็น 0 ตลอด
สามารถเขียน ReLU เป็นสมการได้ดังนี้:
```tex
\text{relu}(z) =
\begin{cases}
z \quad \text{if } z \geq 0 \\
0 \quad \text{if } z < 0
\end{cases}\tag{7}
```
หรือเขียนได้อีกอย่างว่า:
```tex
\text{relu}(z) = \text{max}(0, x)\tag{8}
```
ดูเผินๆ เหมือนว่า ReLU ไม่น่าจะช่วยให้โมเดลทำงานได้ดี เพราะ Output เป็น Linear function ที่แทบไม่ได้ดัดแปลงแก้ไขอะไร แต่ในความเป็นจริงพบว่า การใช้ ReLU ใน Hidden layer นอกจากจะทำให้การเทรนทำได้รวดเร็วกว่า Sigmoid หลายเท่าแล้ว ยังช่วยแก้ปัญหา Vanishing gradients ได้เป็นอย่างมาก เพราะความชันของฟังก์ชันจะเป็นค่าคงตัว คือ 1 เสมอ
จะเห็นว่าการทำงานของ ReLU คือการ "ส่งต่อ" Linear function ออกไป โดยเลือกปิด Neuron บางตัวออกไปเลยหาก Neuron นั้นมีค่าน้อย ซึ่งพฤติกรรมนี้อาจส่งผลให้ Optimiser ไม่สามารถ Converge หา Loss ที่ต่ำเท่าที่ควร แต่ในความเป็นจริง ปัญหานี้ไม่ได้เกิดขึ้นตลอดเวลา เพราะ Activation function ใน Neuron หนึ่งๆ คือผลรวมของ Input ทุก Feature ดังนี้:
```tex
a_1^{[1](1)} = g(w_1^{[1](1)} x_1^{[1](1)} + w_2^{[1](1)} x_2^{[1](1)} + \dots + w_n^{[1](1)} x_n^{[1](1)} + b_1^{[1](1)}) \tag{9}
```
นั่นแปลว่าต่อให้มี `wx` บางคู่ที่ให้ผลลบ แต่โดยรวมแล้ว `wx` ทุกคู่บวกรวมกัน ก็มีโอกาสที่จะเป็นบวกสูงกว่าเป็นลบมาก ดังนั้นจึงมีโอกาสน้อยที่ ReLU จะให้ผลออกมาเป็น 0
แต่ก็ไม่ใช่ว่าจะไม่มีโอกาสที่ ReLU จะให้ผลลบเลย ในบางโมเดล Neuron หลายสิบเปอร์เซ็นถูกปิดเพราะ ReLU ทางแก้คือใช้ Activation function ที่ดัดแปลงส่วนแบนของ ReLU ให้มีความลาดเอียงเล็กน้อย เรียกว่า Leaky ReLU:
```tex
\text{relu}(z) = \text{max}(0.01, x)\tag{10}
```
หน้าตาของกราฟจะคล้าย ReLU แต่ส่วนบนจะลาดลงเล็กน้อย เช่นถ้า Input เท่ากับ -1 จะส่งผลให้ Output เท่ากับ -0.01 เป็นต้น
ล่าสุด ในปี 2015 มีคณะนักวิจัยเสนอ Activation function ใหม่ที่ชื่อ ELU หรือ Exponential Linear Unit ที่ทดสอบแล้วได้ผลเหนือกว่า ReLU และ Leaky ReLU ทุกด้าน เช่น เวลาที่ใช้เทรนโดยรวมสั้นกว่า และได้ความแม่นยำสูงกว่า ELU มีสมการดังนี้:
```tex
\text{ELU}_{\alpha}(z) =
\begin{cases}
\alpha(e^z-1) \quad \text{if } z < 0 \\
z \quad \text{if } z \geq 0
\end{cases}\tag{11}
```
ELU มีคุณสมบัติที่อุดช่องว่างของ Activation function อื่นๆ ที่ผ่านมา ช่วยลดปัญหา Vanishing gradients เพราะอนุพันธ์ของฟังก์ชันยังมีค่าบวกอยู่ถึงแม้ Input จะมีค่าน้อยกว่า 0 ไปจนถึง -2 โดยเราสามารถปรับค่า Hyperparameter `\alpha` เพื่อกำหนดว่า Output จะมีค่าเท่าใดเมื่อ Input มีค่าติดลบมากๆ โดยปกติตั้งไว้ที่ 1
ข้อเสียของ ELU คือต้องใช้พลังประมวลผลมาก แต่ก็แลกกับการที่ทำให้ Optimiser นั้น Converge เร็วขึ้น อย่างไรก็ตามในเวลาทดสอบกับ Test set หรือเวลาใช้โมเดลพยากรณ์จริง (Forward propagation ขาเดียว) ELU จะใช้เวลานานกว่า ReLU ดังนั้นใน Application ที่ความเร็วในการได้ผลลัพธ์เป็นสิ่งสำคัญ ก็ควรพิจารณาให้ดีว่ายอมรับความช้าลงได้หรือไม่
**ปัจจุบันแนะนำให้ใช้ ELU เป็นอันดับแรก** ตามด้วย Leaky ReLU, ReLU, Tanh, และ Sigmoid
ใน TensorFlow เราสามารถเลือกใช้ Activation function ใดก็ได้ เพียงแค่เปลี่ยนค่าของ Argument activation ใน Model layer
ต่อมาเป็นเทคนิคสุดท้ายเพื่อลดปัญหา Vanishing gradients นั่นคือ Batch normalisation
### Batch normalisation
เวลาเทรนโมเดลหลายๆ ครั้ง ค่าเฉลี่ยและการกระจายตัวของ Input สำหรับแต่ละ Neuron ในแต่ละ Layer จะมีแนวโน้มที่จะเปลี่ยนไปเรื่อยๆ ซึ่งทำให้ Gradient descent ทำงานได้ไม่เต็มประสิทธิภาพ เช่น ใช้เวลานานในการคำนวน และต้องใช้จำนวนรอบมากกว่าจะ Converge ได้ เรียกปัญหานี้ว่า Internal covariate shift ดังนั้นเมื่อพิจารณาว่าข้อมูล Input เริ่มแรกต้องถูก Scale ให้เรียบร้อยเสียก่อน ทำไมเราจึงไม่ Scale และ Normalise ข้อมูล Input ของแต่ละ Layer ระหว่างการเทรนไปด้วยเสียเลย
Batch normalisation คือการปรับ Mean และ Variance ของ Input สำหรับแต่ละ Layer ให้เป็นมาตรฐาน แล้วปรับ Scale และตำแหน่งของ Input ทั้งชุดให้ เทคนิคนี้เพิ่งถูกเสนอเมื่อปี 2015 นี้เอง การทำ Batch normalisation นอกจากจะทำช่วยลดปัญหา Vanishing gradient ลงเกือบทั้งหมดแล้ว ยังทำให้เราสามารถตั้ง Learning rate ได้เร็วขึ้น หรือลดจำนวน Epoch ที่ต้องเทรน (เพราะ Input ไม่ใหญ่เกินไป) ส่งผลให้เทรนโมเดลได้เร็วขึ้น นอกจากนี้ยังให้ผลในการ Regularise ด้วยระดับหนึ่ง
ขั้นตอนในการทำ Batch normalisation มีดังนี้:
1) หา Mean `\mu_B` และ Variance `\sigma_B^2` ของ Mini-batch B:
```tex
\mu_B = \frac{1}{m_B} \sum\limits_{i=1}^{m_B} x^{(i)} \tag{12}
\sigma_B^2 = \frac{1}{m_B} \sum\limits_{i=1}^{m_B} (x^{(i)} - \mu_B)^2 \tag{13}
```
2) Normalise z ด้วยการนำ Input z ไปลบกับ Mean ของ Mini-batch และหารส่วนเบี่ยงเบนมาตรฐานของ Mini-batch:
```tex
z_{norm}^{(i)} = \frac{z^{(i)}-\mu_B}{\sqrt{\sigma_B^2 + \epsilon}} \tag{14}
```
โดย `\epsilon` อ่านว่า Epsilon คือจำนวนขนาดเล็กมากๆ ที่บวกเข้าไปเพื่อป้องกันไม่ให้ตัวหารของสมาการเป็น 0 โดยปกติตั้งเป็น `10^{-5}`
3) Scale และปรับตำแหน่งชุดข้อมูลโดยการนำ `z_{norm}^{(i)}` ไปคำนวนร่วมกับ Scaling parameter `\gamma` และ Shifting parameter `\beta`:
```tex
\tilde{z}^{(i)} = \gamma z_{norm}^{(i)} + \beta \tag{15}
```
โดย Scaling parameter \gamma และ Shifting parameter \beta จะถูกใส่เข้าไปใน Backward propagation เพื่อให้ Algorithm ปรับค่าทั้งสองนี้ระหว่างเทรน
มีข้อสังเกตว่าถ้าเราทำ Batch normalisation บน Hidden layer แรก ก็ไม่มีความจำเป็นต้อง Normalise input ตั้งแต่แรก
อย่างไรก็ตาม Batch norm ทำให้การคำนวน Forward propagation ช้าลง ดังนั้นจึงควรพิจารณาว่าการใช้ He initialisation บวกกับ ELU activation function นั้นให้ผลดีเพียงพอแล้วหรือไม่
ใน TensorFlow เราสามารถทำ Batch normalisation โดยการสร้าง Layer ชื่อ BatchNormalization ได้เลย
เป็นอันว่าเราเรียนรู้เทคนิคที่จะลดปัญหา Vanishing gradients ได้ถึง 3 แนวทาง บทต่อไปเราจะมาทำความรู้จักกับ Optimiser ต่างๆ ที่จะช่วยเพิ่มความเร็วในการเทรนโมเดล
## บทที่ 17 Neural Network Optimisers
มาจนถึงตอนนี้ เรารู้ว่ากลไกที่นำเอาอนุพันธ์ของตัวแปรต่างๆ มาอัปเดตเพื่อลด Loss ใน Cost function นั้นเรียกว่า Gradient descent ซึ่งทำงานโดยการนำเอาอนุพันธ์ไปถ่วงน้ำหนักด้วย Learning rate `\alpha` แล้วลบออกจาก Parameter ดังนี้:
```tex
W^{[l]} := W^{[l]} - \alpha (dW^{[l]}) \tag{1}
b^{[l]} := b^{[l]} - \alpha (db^{[l]}) \tag{2}
```
โดย [l] คือลำดับที่ของ Layer
กลไกการ Optimise แบบนี้ มักเกิดปัญหาว่าถ้าหากอนุพันธ์นั้นมีค่าน้อย (คือมีความชันน้อย) ก็จะทำให้ Parameter ถูกอัปเดตแต่ละรอบช้ามาก ส่งผลให้ใช้เวลานานกว่าโมเดลจะเทรนจนถึงจุดที่ Loss ค่ำที่สุดเท่าที่จะเป็นไปได้
ปัจจุบัน มี Algorithm ชั้นสูงเพื่อเพิ่มประสิทธิภาพการ Optimise ให้เลือกใช้ โดย Optimiser เหล่านี้ล้วนมีหลักการคล้ายกัน คือนำค่าอนุพันธ์ล่าสุดไปเพิ่มน้ำหนักให้แก่การ Optimise ในรอบถัดไป เพื่อเร่งความเร็วของการอัปเดตให้มากขึ้น ในบทนี้เราจึงจะมาเรียนรู้ Optimiser ชั้นสูง 3 ตัว ได้แก่ Momentum, RMSProp, และ Adam โดยเราสามารถเรียกใช้ Optimiser เหล่านี้ได้โดยการกำหนด Argument ใน Method .compile เช่น:
```python
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
```
### Momentum
Momentum optimiser ใช้อนุพันธ์ล่าสุดมาทำให้การเคลื่อนที่ของ Cost function นั้นพุ่งไปข้างหน้าอย่างนุ่มนวล หัวใจหลักของความสามารถนี้คือการใช้ **Exponentially weighted moving average (EMA) ของอนุพันธ์** มาอัปเดต Parameter
วิธีการคำนวน Momentum มีดังนี้:
1) คำนวน Vector ของ "น้ำหนักเร่ง" v โดยใช้ EMA:
```tex
v_{dW^{[l]}} = \beta v_{dW^{[l]}} + (1-\beta)dW^{[l]} \tag{3}
v_{db^{[l]}} = \beta v_{db^{[l]}} + (1-\beta)db^{[l]} \tag{4}
```
`v_{dW^{[l]}}` และ `v_{db^{[l]}}` คือ Vector ของน้ำหนักเร่งของ dW และ db ตัวที่แล้ว โดยเริ่ม Initialise ด้วย 0
`\beta` คือค่าน้ำหนักของ EMA ปกติตั้งที่ 0.9 ซึ่งแปลว่า "ค่าน้ำหนักเร่งใหม่ มาจากค่าน้ำหนักเร่งเก่า 9 ส่วน และ dW 1 ส่วน"
2) นำค่าน้ำหนักเร่ง `v_{dW^{[l]}}` และ `v_{db^{[l]}}` ที่ได้ ไปถ่วง Learning rate `\alpha` และลบออกจาก `W^{[l]}` และ `b^{[l]}`:
```tex
W^{[l]} := W^{[l]} - \alpha (v_{dW^{[l]}}) \tag{5}
b^{[l]} := b^{[l]} - \alpha (v_{db^{[l]}}) \tag{6}
```
สังเกตว่าสมการที่ (5) และ (6) นั้นก็คือการอัปเดต Parameter ตามปกติ เพียงเปลี่ยนตัวแปรที่เอาไปถ่วงน้ำหนักและลบออก จากเดิมใช้ `dW^{[l]` และ `db^{[l]}` เป็นค่าน้ำหนักเร่ง `v_{dW^{[l]}}` และ `v_{db^{[l]}}`
### RMSProp
RMSProp ย่อมาจาก Root Mean Square Propagation มีคุณสมบัติคล้ายกับ Momentum แต่แทนที่จะใช้ EMA ของอนุพันธ์ตัวที่ผ่านๆ มาในการอัปเดต Parameter เปลี่ยนไปใช้ EMA ของยกกำลังสองของอนุพันธ์แทน โดยมีวิธีการคำนวนดังนี้:
1) คำนวน Vector ของ "น้ำหนักเร่ง" s โดยใช้ EMA ของยกกำลังสองของอนุพันธ์:
```tex
s_{dW^{[l]}} = \beta s_{dW^{[l]}} + (1-\beta)dW^{[l]2} \tag{7}
s_{db^{[l]}} = \beta s_{db^{[l]}} + (1-\beta)db^{[l]2} \tag{8}
```
2) นำค่าน้ำหนักเร่ง `s_{dW^{[l]}}` และ `s_{db^{[l]}}` ที่ได้ ไปประกอบกับ `dW^{[l]}` และ `db^{[l]}` และถ่วงกับ Learning rate `\alpha` ตามสมการด้านล่าง แล้วลบออกจาก `W^{[l]}` และ `b^{[l]}`:
```tex
W^{[l]} := W^{[l]} - \alpha \left(\frac{dW^{[l]}}{\sqrt{s_{dW^{[l]}}} + \epsilon}\right) \tag{9}
b^{[l]} := b^{[l]} - \alpha \left(\frac{db^{[l]}}{\sqrt{s_{db^{[l]}}} + \epsilon}\right) \tag{10}
```
โดย `\epsilon` คือค่าคงที่ขนาดเล็กๆ ที่ป้องกันไม่ให้ตัวหารเป็น 0
สังเกตว่า Term ที่เอาไปถ่วงกับ Learning rate นั้นไม่เหมือน Momentum กล่าวคือเป็นการนำ Square root ของค่าน้ำหนักเร่งไปหารออกจากอนุพันธ์ วิธีการนี้จะช่วยจำกัดความแปรผันในทิศที่ตั้งฉากกับทิศทางที่ไปสู่จุดต่ำสุดของ Cost function ในขณะที่ Momentum สนใจในการสร้างแรงที่มุ่งไปสู่ทิศต่ำสุดของ Cost function อย่างเดียว
### Adam
Adam ย่อมาจาก Adaptive Moment Estimation เป็นการรวม Momentum และ RMSProp เข้าด้วยกัน ถือว่าเป็น Optimiser ที่ดีที่สุดในปัจจุบัน มีวิธีการคำนวนดังนี้ (แสดงเฉพาะสำหรับ w):
1) คำนวน Vector ของ "น้ำหนักเร่ง" v โดยใช้ EMA ตามแบบ Momentum และ Vector ของ "น้ำหนักเร่ง" s โดยใช้ EMA ตามแบบ RMSProp แล้วแก้ Bias ที่เกิดจากการที่ v และ s ถูก Initialise ด้วย 0 (ถ้าไม่แก้จะทำให้ v และ s รอบแรกๆ มีค่าต่ำกว่าที่ควรจะเป็น):
```tex
v_{dW^{[l]}} = \beta_1 v_{dW^{[l]}} + (1-\beta_1)dW^{[l]} \tag{11}
v_{dW^{[l]}}^{corrected} = \frac{v_{dW^{[l]}}}{1-\beta_1^t} \tag{12}
s_{dW^{[l]}} = \beta_2 s_{dW^{[l]}} + (1-\beta_2)dW^{[l]2} \tag{13}
s_{dW^{[l]}}^{corrected} = \frac{s_{dW^{[l]}}}{1-\beta_2^t} \tag{14}
```
2) นำค่าน้ำหนักเร่ง `v_{dW^{[l]}}^{corrected}` และ `s_{dW^{[l]}}^{corrected}` ไปประกอบกันในลักษณะเดียวกับ RMSProp คือ `v_{dW^{[l]}}^{corrected}` เป็นตัวตั้ง หารด้วย Square root ของ `s_{dW^{[l]}}^{corrected}` เพื่อจำกัดความแปรผันในทิศที่ตั้งฉากกับทิศทางที่ไปสู่จุดต่ำสุดของ Cost function แล้วถ่วงกับ Learning rate `\alpha` แล้วลบออกจาก `W^{[l]}` และ `b^{[l]}`:
```tex
W^{[l]} := W^{[l]} - \alpha \left(\frac{v_{dW^{[l]}}^{corrected}}{\sqrt{s_{dW^{[l]}}^{corrected}} + \epsilon}\right) \tag{15}
```
ในทางปฏิบัติ แนะนำให้ใช้ Adam ไปเลย เว้นแต่จะมีปัญหาก็สามารถลองใช้ Momentum ได้
ในบทต่อไปจะพูดถึงเทคนิคการ Regularise deep neural network ซึ่งรวมทั้ง Dropout layer
## บทที่ 18 Neural Network
Regularisation คือเทคนิคในการลดปัญหา Variance ของโมเดล นั่นก็คือการที่โมเดลถูกเทรนแล้วฟิตกับข้อมูลชุด Train set ได้ดี แต่พยากรณ์ไม่แม่นยำเมื่อนำไปใช้กับ Test set หรือข้อมูลจริงที่โมเดลไม่เคยเห็น บางทีเราเรียกปัญหานี้ว่า Generalisation error
ปัญหา Generalisation error เกิดขึ้นจากการที่โมเดลฟิต Parameter เข้ากับ Train set อย่างรัดกุมเกินไป จนกระทั่งไม่สามารถพยากรณ์ข้อมูลที่มองไม่เห็นได้อย่างเที่ยงตรงเท่าที่ควร
ซึ่งถ้าหากเราดำเนินการเพื่อลด Generalisation error ก็จะได้โมเดลที่มีความซับซ้อนน้อยลง ทำให้สามารถ Generalise ไปยังข้อมูลชุดใหม่ๆ ได้ดียิ่งขึ้น
เทคนิคการลด Generalisation error ที่จะนำเสนอ คือ l^2 regularisation, Dropout regularisation, และ Early stopping
### L2 regularisation
แนวทางพื้นฐานในการแก้ปัญหา Generalisation error คือการเพิ่ม Regularisation term เข้าไปใน Cost function และในการอัปเดต Parameter เพื่อกดค่า w ให้น้อยลง
ค่าของ Regularisation term นี้ จะแปรผันตามความซับซ้อนของโมเดล ด้วยการใช้ `l^2` norm ของ W เป็นพื้นฐาน
Cost function ที่รวม Regularisation term แล้ว มีสมการรูปทั่วไปดังนี้:
```tex
J = \frac{1}{m} \sum\limits_{i=1}^m L(\hat{y}^{(i)}, y^{(i)}) + \frac{\lambda}{2m} \sum\limits_{l=1}^L \Vert{W^{[l]}}\Vert_F^2 \tag{1}
```
โดย `\Vert{W^{[l]}}\Vert_F^2` คือ Frobenius norm ของ Matrix W คำนวนจากผลรวมของ w ยกกำลังสองทุกตัวของทุก Layer ตั้งแต่ Hidden layer ไปจนถึง Output layer สามารถแทนเป็นสมการดังนี้:
```tex
\Vert{W^{[l]}}\Vert_F^2 = \sum\limits_{i=1}^{n^{l-1}} \sum\limits_{l=1}^{n^l} (W_{i,j}^{[l]})^2 \tag{2}
```
โดย W เป็น Matrix ขนาด `n^{l-1}` คูณ `n^{l}`
สิ่งที่ Regularisation term นี้ทำ ก็คือการกดดันให้ค่าน้ำหนัก w มีค่าน้อยลง โดยการทำงานคู่กับการที่เราบวก `\frac{\lambda}{m} W^{[l]}` เข้าไปในอนุพันธ์ของ w ทำให้ `dW^{[l]}` มีค่ามากขึ้น ส่งผลให้ `W^{[l]}` มีค่าน้อยลง ดังนี้:
```tex
dW^{[l]} = \text{from backprop} + \frac{\lambda}{m} W^{[l]} \tag{3}
W^{[l]} := W^{[l]} - \alpha(dW^{[l]}) \tag{4}
```
โดยการลดลงของ `w` นี้ จะแปรผันตามขนาดที่แท้จริงของ W เราเรียกพฤติกรรมนี้ว่าการถดถอยน้ำหนัก หรือ Weight decay
สังเกตว่าการทำ `l^2` regularisation นี้ เราต้องกำหนด Hyperparameter \lambda ที่ควบคุมว่า Regularisation term จะมีผลต่อการถดถอยของน้ำหนักเพียงใด
ใน TensorFlow เราสามารถทำ `l^2` regularisation โดยการกำหนด Argument ใน Layer ดังนี้:
```python
from keras import regularizers
model.add(Dense(64, input_dim=64,
kernel_regularizer=regularizers.l2(0.01)))
```
การ Regularise ด้วยวิธีนี้ เป็นวิธีทั่วไปที่ใช้ในสถิติและ Machine learning algorithm อื่นๆ อย่างไรก็ตาม เมื่อใช้กับ Deep neural network `l^2` regularisation มีปัญหาอันหนึ่ง คือปรากฏการณ์ Co-adaptation กล่าวคือมันทำให้ค่าน้ำหนักที่มีค่ามาก ยิ่งขยายขนาด ส่วนค่าน้ำหนักที่มีค่าน้อย ยิ่งลดขนาด นั่นก็คือการขยายความต่างนั่นเอง ปรากฏการณ์นี้ทำให้เราไม่สามารถใช้ประโยชน์จากโมเดลที่มีความซับซ้อนมากขึ้นได้เต็มที่ เพราะเมื่อเราทำให้โมเดลซับซ้อนขึ้น ผลที่ได้กลับเป็นโมเดลที่เน้นสิ่งที่มีค่ามาก และกดสิ่งที่มีค่าน้อยลงอย่างเป็นระบบ ดังนั้นเราจึงมีวิธีการ Regularise พิเศษสำหรับ Neural network ที่เรียกว่า Dropout
### Dropout regularisation
หลักคิดของ Dropout นั้นเรียบง่ายมาก เราจะ "ปิด" Neuron บางตัวในระบบ ไม่ให้รับข้อมูลใดๆ ดังนั้น Neuron ที่ถูกปิดก็จะไม่ส่งข้อมูลออกไปยัง Neuron ตัวอื่นเช่นเดียวกัน
ในระบบนี้ แสดงการกำหนด Dropout เท่าเท่ากับ 0.25 บน Layer ที่ 2 และ 3 นั่นคือ ให้ปิด Neuron 25% ของ Layer ดังกล่าว
การ "ปิด" Neuron บางตัวในเครือข่ายแต่ละชั้น เป็นการเลือกปิดแบบสุ่ม ซึ่งฟังเผินๆ อาจจะดูเหมือนเป็นความคิดที่ไม่ดี แต่ในความจริงเทคนิคนี้ใช้งานได้ดี เพราะเราไม่ได้ไปปิด Input x แต่ไปปิดหน่วยประมวลผลบางตัว การเลือกปิดแบบสุ่มนี้จะป้องกันการเกิด Co-adaptation และได้ผลในการลด Overfitting เพราะทำให้โมเดลนั้น "ง่าย" ลง แต่ไม่ได้จงใจกดข้อมูลลักษณะใดลักษณะหนึ่งลง เป็นการสุ่มกดเพื่อลดความซับซ้อนของทั้งระบบ
ในทางเทคนิค วิธีการทำ Dropout คือการสร้าง Boolean matrix มิติเท่ากับ Matrix ของ Activation ที่ต้องการใช้ Dropout โดยสุ่มค่า Yes/No ตามสัดส่วนที่เรากำหนด เช่น ถ้ากำหนดให้ปิด 25% ก็คือให้ทั้ง Matrix มีค่า True 75% ค่า False 25% จากนั้นนำ Dropout matrix นี้ไปคูณแบบ Element-wise เข้ากับ Activation matrix ก็จะได้ Activation matrix ใหม่ที่บาง Element มีค่าเท่ากับศูนย์ในตำแหน่งเดียวกับที่ใน Dropout matrix มีค่าเป็น False จากนั้นนำสัดส่วนการปิดไปหารแบบ Element-wise ออกจาก Activation matrix ใหม่ เพื่อทำการ Normalise
แสดงวิธีการทำ Dropout ใน iPython ได้ดังนี้:
```python
In [1]: keep_prob = 0.75
In [2]: import numpy as np
In [3]: d = np.random.rand(3,4) < keep_prob
In [4]: d
Out[4]:
array([[False, True, True, True],
[ True, True, True, True],
[ True, False, True, True]])
In [5]: a = np.random.randn(3,4)
In [6]: a
Out[6]:
array([[-0.37998077, -0.96594641, 0.54147094, -0.35392546],
[-0.34891998, -0.53428796, -1.03811021, -2.36410892],
[-0.26496699, 0.21605195, -1.11321207, 0.53065364]])
In [7]: a_dropped = np.multiply(a,d)
In [8]: a_dropped
Out[8]:
array([[-0. , -0.96594641, 0.54147094, -0.35392546],
[-0.34891998, -0.53428796, -1.03811021, -2.36410892],
[-0.26496699, 0. , -1.11321207, 0.53065364]])
In [9]: a_dropped /= keep_prob
In [10]: a_dropped
Out[10]:
array([[-0. , -1.28792855, 0.72196126, -0.47190062],
[-0.46522664, -0.71238394, -1.38414694, -3.15214523],
[-0.35328932, 0. , -1.48428276, 0.70753819]])
```
ใน TensorFlow เราสามารถทำ Dropout ได้อย่างง่ายดาย โดยการเพิ่ม Dropout layer ลงไปก่อนหน้า Layer ที่เราต้องการทำ Dropout ดังนี้:
```python
model.add(Dropout(0.25)) # Dropout 25%
```
ในปัจจุบัน แนะนำให้ใช้ Dropout ก่อน สำหรับ Deep neural network
### Early stopping
Early stopping คือการหยุดการเทรนก่อนที่ Optimiser จะ Converge หา Loss ที่ต่ำที่สุด โดยมีสมมุติฐานว่ายิ่งเทรนไป โมเดลจะยิ่งซับซ้อนขึ้น จนอาจจะเกินจากที่จะสามารถ Generalise ได้ดี
จะเห็นว่า ตามปกติ Optimiser จะเทรนเพื่อให้ได้ Train error ต่ำที่สุด แต่บางครั้ง Test error จะเริ่มวกกลับไปมีค่าสูงขึ้นก่อนที่จะพบจุดต่ำสุดของ Cost function ดังนั้น เราควรจะหยุดการเทรนที่จุดที่ Test error ต่ำที่สุด ไม่ใช่ Train error ต่ำที่สุด
วิธีการในทางปฏิบัติ คือเมื่อเราเทรนโมเดลด้วยการเรียก Method `.fit` ให้เราแยกข้อมูลเทรนส่วนหนึ่งออกมาเป็น Validation set เพื่อให้ Optimiser ทดสอบความแม่นยำทุกๆ Epoch ดังนี้:
```python
# Fit the model to data
model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2, verbose=1)
```
ระหว่างเทรน จะได้ผลออกมาดังนี้:
```
Train on 1600 samples, validate on 400 samples
Epoch 1/20
[===] - 1s 491us/sample - loss: 1.4701 - accuracy: 0.5881 - val_loss: 0.7175 - val_accuracy: 0.8275
Epoch 2/20
[===] - 0s 158us/sample - loss: 0.6571 - accuracy: 0.8213 - val_loss: 0.4700 - val_accuracy: 0.8600
Epoch 3/20
[===] - 0s 146us/sample - loss: 0.4681 - accuracy: 0.8744 - val_loss: 0.3726 - val_accuracy: 0.8925
. . . . . . .
. . . . . . .
. . . . . . .
Epoch 18/20
[===] - 0s 233us/sample - loss: 0.0807 - accuracy: 0.9844 - val_loss: 0.2492 - val_accuracy: 0.9375
Epoch 19/20
[===] - 0s 174us/sample - loss: 0.0675 - accuracy: 0.9906 - val_loss: 0.2474 - val_accuracy: 0.9275
Epoch 20/20
[===] - 0s 174us/sample - loss: 0.0638 - accuracy: 0.9881 - val_loss: 0.2490 - val_accuracy: 0.9300
```
ให้สังเกต Validation accuracy ซึ่งจะเพิ่มขึ้นเรื่อยๆ แต่ถึงจุดหนึ่ง จะวกกลับเป็นมีค่าลดลง เช่น Epoch 18 ได้ 93.75% ส่วน Epoch 19 กลับแม่นยำลดลงเป็น 92.75% ดังนั้น เราอาจเลือกหยุดการเทรนที่ Epoch 18 แทนที่จะเป็น Epoch 20 เป็นต้น
เราสามารถเลือกใช้เทคนิคการ Regularise แบบต่างๆ นี้ได้ตามสถานการณ์ อย่างไรก็ตาม ก่อนที่จะใช้เทคนิคการ Regularisation เพื่อลด Generalisation error ขอให้พิจารณาดูก่อนว่า Validation set หรือ Test set ที่เราเอามาทดสอบ มีขนาดเล็กเกินไป หรือมาจาก Distribution ที่ต่างจาก Train set หรือไม่ ซึ่งเป็นสิ่งที่ควรจะแก้ไขก่อน
ตอนนี้เรารู้จักหลักการและเทคนิคพื้นฐานของ Deep learning แล้ว ในบทต่อไปจะพูดถึงโครงสร้าง Deep learning model สำหรับงานเฉพาะด้าน เช่นการจำแนกภาพ โดยใช้ Convolutional Neural Network หรือ CNN
## บทที่ 19 Convolutional Neural Network
Neural network ทั่วไปอาจทำงานได้ดีกับข้อมูลที่ไม่ซับซ้อนและถูกเตรียมมาให้มีมาตรฐานเดียวกัน เช่นภาพขาวดำขนาดเล็กที่วัตถุอยู่กลางภาพ แต่พอข้อมูลมีความซับซ้อน ขนาด และความหลากหลายมากขึ้น จะทำงานได้ไม่ดีนัก โดยมักจะเกิดปัญหา Variance ซึ่งก็คือการที่โมเดลไม่สามารถทำนายข้อมูลที่ไม่เคยเห็นได้ดีเท่าที่ควร
ในบทนี้เราจะมาทำความรู้จัก Convolutional Neural Network หรือ CNN ซึ่งเป็นโครงสร้าง Neural network แบบพิเศษ ที่มีความสามารถในการจำแนกข้อมูลประเภทรูปภาพได้ดีกว่า Neural network ทั่วไปมาก
ไอเดียหลักของ CNN คือการที่ใช้ Layer ชนิดพิเศษ ที่เรียกว่า Convolution layer ซึ่งทำหน้าที่สกัดเอาส่วนต่างๆ ของภาพออกมา เช่น เส้นขอบของวัตถุต่างๆ เพื่อให้โมเดลสามารถเรียนรู้ลักษณะของภาพได้อย่างมีประสิทธิภาพและแม่นยำ
ใน CNN จะใช้ Convolution layer มาประกอบกับ Layer ชนิดอื่น เช่น Pooling layer แล้วนำกลุ่ม Layer ดังกล่าวมาซ้อนต่อๆ กัน โดยอาจเปลี่ยน Hyperparameter บางอย่าง เช่นขนาดของ Filter layer (ซึ่งเป็นส่วนหนึ่งของ Convolution layer) และจำนวน Channel ของ layer วิธีการนำเอาส่วนต่างๆ มาประกอบกันนี้ เรียกว่าเป็นโครงสร้าง (Architecture) ของ CNN ซึ่งมีหลายแบบ เช่น LeNet, AlexNet, VGG, ResNet, Inception Network เป็นต้น ซึ่งเราจะพูดถึงโครงสร้างแบบต่างๆ นี้ในบทถัดไป แต่ตอนนี้เรามีทำความเข้าใจส่วนประกอบต่างๆ ของ CNN ซึ่งเป็นพื้นฐานที่จะนำมาประกอบกันเสียก่อน โดยเริ่มที่ Convolution layer
### Convolution layer
เพื่อความเข้าใจ ให้ลองทำความเข้าใจก่อนว่า Convolution คืออะไร
สมมุติเรามี Matrix ซ้ายมือ ขนาด 6x6 และมี Matrix ตรงกลาง ซึ่งเรียกว่า Filter หรือ Kernel ขนาด 3x3 เราจะนำเฉพาะ 3x3 ช่องแรกของ Matrix แรก มาคูณแบบ Element-wise กับ Filter matrix แล้วนำผลที่ได้แต่ละค่า (ซึ่งมีทั้งสิ้น 9 ค่า) มาบวกกัน แล้วนำไปสู่ในแถวแรกคอลัมน์แรกของ Matrix ที่สามซึ่งเป็นผลลัพธ์ ผลลัพธ์ที่ว่า เท่ากับ -1
ถัดมา เราจะเลื่อนกรอบขนาด 3x3 ใน Matrix แรกไปทางขวา 1 ช่อง แล้วทำแบบเดิม ผลลัพธ์ที่ได้ นำไปใส่ในแถว 1 ช่อง 2 ของ Matrix ผลลัพธ์ ทำไปเรื่อยๆ จนสุดทาง แล้วเลื่อนกรอบ 3x3 ลงมาด้านล่าง 1 ช่อง (ชิดขอบด้านซ้ายมือ) แล้วทำแบบเดิม จนกระทั่งเติมค่าใน Matrix ผลลัพธ์จนเต็ม
กระบวนการนี้ เรียกว่า Convolution ซึ่งแสดงสัญลักษณ์ด้วย * ส่วน Neural network ที่มี Layer ที่ใช้กระบวนการ Convolution นี้อย่างน้อย 1 Layer เราก็เรียกว่า Convolutional neural network
ถ้าหากข้อมูล Input เป็นภาพสี RGB แปลว่าจะมีค่าสีที่เป็น Matrix ขนาด 6x6 จำนวน 3 ชั้น ดังนั้น Filter ของเราก็จะมี 3 ชั้นตามไปด้วย ส่วนการคำนวน Convolve ก็ให้ทำทีละชั้น นั่นคือ Input ชั้นที่ 1 คูณ Element-wise กับ Filter ชั้นที่ 1 ส่วน Input ชั้นที่ 2 คูณ Element-wise กับ Filter ชั้นที่ 2 เป็นต้น เสร็จแล้วนำผลที่ได้ของทั้ง 3 ชั้นมาบวกกันทั้งหมด กลายเป็นตัวเลข Scalar ตัวเดียว แล้วนำไปใส่ในช่องแรกของ Matrix ผลลัพธ์
ในกระบวนการนี้ Matrix แรกด้านซ้ายมือที่เป็น Input ก็คือ `a^{[l-1]}` ส่วน Filter matrix คือ Matrix ของค่าน้ำหนัก `W^{[l]}` ซึ่งมีค่าที่ต้องเรียนรู้จากกระบวนการ Backward propagation ผลที่ได้จากการ Convolve 2 Matrix นี้เข้าด้วยกัน คือ Matrix ผลลัพธ์ นั่นคือ `W^{[l]}a^{[l-1]}` นั่นเอง จากนั้นเราก็บวก Intercept `b^{[l]}` เข้าไป ประกอบกันกลายเป็นผลลัพธ์สมการเส้นตรง `Z^{[l]} = W^{[l]}a^{[l-1]} + b^{[l]}` แล้วก็นำ `Z^{[l]}` นี้ไปป้อนเข้า Activation function `g(Z^{[l]})` ก็จะได้ผลเป็น Activation output ของ Layer นั้น นั่นก็คือ `A^{[l]}`
สังเกตว่า Convolution layer นี้ มีคุณสมบัติพิเศษอยู่ 2 ประการ คือ:
1) ทั้ง Layer ใช้ค่าน้ำหนัก W ร่วมกัน: กระบวนการ Convolution ใช้ Filter ค่าน้ำหนักตัวเดียวกัน มาคำนวนหา Wa โดยการ Convolve กับ Input ในตำแหน่ง Grid ต่างๆ หลายๆ ครั้งจนครบ ดังนั้น จำนวนของค่าน้ำหนัก w ใน Matrix ค่าน้ำหนัก W จะมีจำนวนน้อยกว่า Neural network แบบทั่วไปมาก ซึ่งนอกจากจะส่งผลให้การคำนวนทำได้เร็วขึ้นมากแล้ว การใช้ค่าน้ำหนักชุดเดิมซ้ำๆ ในหลายๆ ส่วนของภาพจะเป็นการตรวจจับคุณลักษณะบางประการในหลายๆ ส่วนของภาพ
ตัวอย่างเช่น หาก Filter matrix มีแถวซ้ายเป็นค่าบวก แถวขวาเป็นค่าลบ ดังนี้:
```tex
f =
\begin{pmatrix}
1 & 0 & -1 \\
1 & 0 & -1 \\
1 & 0 & -1
\end{pmatrix} \tag{1}
```
ถ้าเรานำ Filter นี้ไป Convolve กับ Input matrix ที่ด้านซ้ายกับขวาสว่างไม่เท่ากัน เช่น:
```tex
A =
\begin{pmatrix}
10 & 10 & 10 & 0 & 0 & 0\\
10 & 10 & 10 & 0 & 0 & 0\\
10 & 10 & 10 & 0 & 0 & 0\\
10 & 10 & 10 & 0 & 0 & 0\\
10 & 10 & 10 & 0 & 0 & 0\\
10 & 10 & 10 & 0 & 0 & 0
\end{pmatrix} \tag{2}
```
จะส่งผลให้ Linear function ผลลัพธ์ มีค่ามากตรงแถวกลางๆ ดังนี้:
```tex
A * f =
\begin{pmatrix}
0 & 30 & 30 & 0\\
0 & 30 & 30 & 0\\
0 & 30 & 30 & 0\\
0 & 30 & 30 & 0
\end{pmatrix} \tag{3}
```
ค่ามากหมายถึงมีความสว่างมาก นั่นแปลว่า Filter นี้ใช้ Detect ส่วนของภาพที่เป็นเส้นขอบแนวดิ่งนั่นเอง
2) การเชื่อมต่อข้าม Layer แบบ Sparse: ค่าของ Output ในแต่ละ Layer เป็นผลมาจากการคำนวนค่า Input เพียงบางส่วน ซึ่งต่างกับ Neural network ทั่วไปที่มีการเชื่อมต่อแบบ Dense หมายถึงค่าของ Output แต่ละ Neuron มาจากการคำนวน Input ทุก Neuron การเชื่อมต่อแบบ Sparse ส่งผลให้การคำนวนนั้นเร็วขึ้นมาก
### Padding
กระบวนการ Convolution มักจะทำให้ Matrix ผลลัพธ์มีมิติเล็กลง ซึ่งถ้าหากเราทำ Convolution หลายๆ ชั้น ภาพสุดท้ายที่ออกมาก็จะเล็กลงมาก นอกจากนั้น Convolution ยังมีแนวโน้มที่จะทำให้ข้อมูลที่อยู่ตามขอบของภาพนั้นไม่ถูกนำไปคำนวนอย่างเต็มที่เหมือนข้อมูลที่อยู่ส่วนกลางของภาพ เพราะ Filter มีโอกาสจับข้อมูลตามขอบภาพน้อยกว่าตรงกลางภาพ
ทางออกต่อปัญหา 2 ข้อนี้ คือการทำ Padding ซึ่งก็คือการขยายขอบของข้อมูล Input ออกทุกด้านเท่าๆ กัน เช่น ถ้า Input มีขนาด 6x6 การทำ Padding p = 1 จะทำให้ Input มีขนาดเป็น 8x8
เราสามารถคำนวนได้ว่าเมื่อทำ Padding แล้ว มิติของ Output จะเป็นเท่าใด แต่ก่อนอื่น ลองเปรียบเทียบกับแบบธรรมดา
1) "Valid" convolution คือไม่มี Padding
มิติของ Output คือ:
```tex
(n-f + 1), (n-f + 1) \tag{4}
```
โดย n คือมิติของ Input ส่วน f คือมิติของ Filter
2) "Same" convolution คือการ Pad เพื่อให้มิติของ Output เท่ากับมิติของ Input
มิติของ Output คือ:
```tex
(n + 2p -f + 1), (n + 2p -f + 1) \tag{5}
p = \frac{f-1}{2} \tag{6}
```
โดย p คือขนาด Pixel ของ Padding ในแต่ละด้าน.
ตัวอย่างเช่น ถ้า Filter มีขนาด 5x5 เราจะต้อง Pad เป็นจำนวนดังนี้:
```tex
p = \frac{5-1}{2} = 2 \text{ pixel} \tag{7}
```
อนึ่ง f ควรจะเป็นเลขคี่ เพื่อให้เกิดความสมมาตรและมีจุดกึ่งกลาง
### Stride
Stride แปลว่า "ย่างก้าว" หมายถึงจำนวนช่องที่จะเลื่อนไปในกระบวนการ Convolution แต่ละครั้ง เช่นถ้าเลื่อนทีละช่อง Stride s = 1 แต่ถ้าเลื่อนทีละ 2 ช่อง ก็คือ s = 2
สูตรในการคำนวนขนาด Output เมื่อใช้ Stride คือ:
```tex
\lfloor\frac{n + 2p -f}{s} + 1\rfloor, \lfloor\frac{n + 2p -f}{s} + 1\rfloor \tag{8}
```
สังเกตว่าเราจะปัดเศษลง ไม่ใช่ปัดขึ้น
### Pooling layer
หลังจากที่ข้อมูลผ่าน Convolution layer แล้ว บ่อยครั้งที่จะถูกส่งเข้า Layer อีกแบบหนึ่งที่เรียกว่า Pooling layer
หน้าที่ของ Pooling layer คือการสกัดเอาส่วนที่สำคัญที่สุดของข้อมูล และเพิ่มประสิทธิภาพการประมวลผลให้รวดเร็วยิ่งขึ้น กลไกของ Pooling layer นั้นเรียบง่ายมาก คือการสกัดเอาเฉพาะค่าสูงสุดของ Grid เก็บไว้ใน Output เช่น Pooling layer ขนาด 2x2 โดยมีค่า Stride s = 2
Pooling layer ที่สกัดเอาเฉพาะค่าสูงสุดของ Grid เก็บไว้ เรียกว่า Max pooling ซึ่งเป็นรูปแบบที่ใช้บ่อยที่สุด นอกจากนั้นยังมี Average pooling ซึ่งหาค่าเฉลี่ยของ Grid เก็บไว้ แต่ใช้น้อยกว่า Max pooling มาก
### ตัวอย่าง Convolutional Network
ตอนนี้เรารู้จักองค์ประกอบของ Convolutional neural network แล้ว เราจะจบบทนี้ด้วยการแสดงตัวอย่างว่าองค์ประกอบเหล่านี้ จะถูกนำมาต่อกันเป็น CNN อย่างไร
#### Input Layer
สมมุติว่าเรามีภาพตั้งต้นขนาด 32x32 pixel โดยเป็นภาพสี RGB นั่นหมายความว่าภาพนี้มี 3 Layer คือแทนสี Red, Green, และ Blue โดยเราต้องการจำแนกภาพนี้ออกเป็น 10 ประเภท:
```
Input layer a[0]: (32, 32, 3)
```
**1st Layer**
ใน Layer แรก เราจะใช้ Convolution layer ขนาด 5x5 โดยมี Stride เท่ากับ 1 และไม่มี Padding โดยจะใช้ Convolution layer บบนี้ทั้งสิ้น 6 Layer นั่นก็คือ `f^{[1]} = 5, s^{[1]} = 1, p^{[1]} = 0, n_C^{[1]} = 6` เราจะได้มิติของ `a^{[1]}` จากการคำนวนตามสมการที่ (4) (n-f + 1) ดังนี้
```
Convolution layer a[1]: (28, 28, 6)
```
จากนั้นเราจะใช้ Max pooling ขนาด `f^{[1]} = 2, s^{[1]} = 2` ก็จะได้มิติของ Activation function ของ Layer ที่ 1 จากการคำนวนตามสมการที่ (8) `\lfloor\frac{n + 2p -f}{s} + 1\rfloor` ดังนี้:
```
Max-pooling layer a[1]: (14, 14, 6)
```
**2nd Layer**
ต่อมาใน Layer ที่สอง เราจะใช้ Convolution layer ขนาด 5x5 โดยมี Stride เท่ากับ 1 และไม่มี Padding โดยจะใช้ Convolution layer บบนี้ทั้งสิ้น 16 Layer นั่นก็คือ `f^{[2]} = 5, s^{[2]} = 1, p^{[2]} = 0, n_C^{[2]} = 16` จะได้มิติดังนี้:
```
Convolution layer a[2]: (10, 10, 16)
```
จากนั้นเราจะใช้ Max pooling ขนาด `f^{[2]} = 2, s^{[2]} = 2` ก็จะได้มิติของ Output ของ Layer ที่ 2 ดังนี้:
```
Max-pooling layer a[2]: (5, 5, 16)
```
เสร็จแล้วเราจะปิดท้าย Layer ที่สอง ด้วยการรวมเอา Output ทั้งหมดมา Activate ใน Dense layer นั่นก็คือ Layer ที่เชื่อมต่อทุก Neuron แบบปกติ ซึ่งจะมีขนาดเท่ากับ Output นั่นก็คือ 5x5x16 = 400 เราเรียก Layer ชนิดนี้ว่า Dense หรือ Flatten layer:
```
Flatten (dense) layer a[2]: (400)
```
**3rd Layer**
จากนั้นเราจะนำ Dense layer ไปเชื่อมเข้ากับ Dense layer อีกชั้น แต่คราวนี้ลดขนาดลงเป็น 120:
```
Flatten (dense) layer a[3]: (120)
```
**4th Layer**
แล้วก็นำ Dense layer ไปเชื่อมเข้ากับ Dense layer อีกชั้นหนึ่งซึ่งเล็กลงไปอีก คราวนี้มีขนาด 86:
```
Flatten (dense) layer a[4]: (86)
```
**5th Layer**
สุดท้ายก็ Output ออกไปยัง Softmax layer ขนาด 10 neuron เพื่อจำแนก Classification ออกเป็น 10 กลุ่ม:
```
Softmax layer a[5]: (10)
```
คงพอจะเห็นภาพว่าเราสามารถนำส่วนประกอบต่างๆ มาประกอบกันเป็น Convolutional neural network ได้ตามตัวอย่าง ซึ่งอันที่จริงเป็นโครงสร้างที่เรียกว่า LeNet-5 ซึ่งถูกตีพิมพ์แผนแพร่เมื่อปี 1998 และถูกนำมาใช้ในการอ่านตัวเลขบนเช็คโดยธนาคารหลายแห่ง ถือเป็นหนึ่งในโครงสร้าง CNN แบบคลาสสิค
## ภาคผนวก 1: ทำไมต้อง Machine Learning
ย้อนไปในช่วงสามปีที่เรียนม.ปลาย ผู้เขียนใช้เวลาไปกับการอ่านนิยายวิทยาศาสตร์ชุดสถาบันสถาปนา (Foundation Series) ของ Isaac Asimov นิยายชุดนี้เป็นส่วนสำคัญที่ทำให้ผู้เขียนเลือกเรียนเศรษฐศาสตร์ และทำงานด้านนวัตกรรมทางสังคมมาจนถึงทุกวันนี้
แกนหลักของพล็อตเรื่องในสถาบันสถาปนา คือการที่มีนักคณิตศาสตร์ผู้หนึ่งได้พัฒนาศาสตร์การพยากรณ์ ที่เรียกว่า Psychohistory และใช้ข้อมูลที่ได้จากการพยากรณ์ด้วยศาสตร์นี้ มาลดระยะเวลาและผลกระทบของวิกฤติที่มนุษยชาติกำลังเผชิญ (ในบริบทว่าในอนาคต มนุษย์ได้แผ่ขยายตั้งรกรากไปในดาวต่างๆ ทั่วทั้งกาแล็กซี่มาแล้วเป็นเวลานับหมื่นปี จนลืมไปแล้วว่ามนุษย์ถือกำเนิดบนดาวเคราะห์โลกดวงนี้)
จุดมุ่งหมายของการพยากรณ์นั้นไม่ใช่เป็นไปเพื่อการรู้เหตุการณ์ล่วงหน้าโดยตัวมันของเอง แต่คือการรู้สิ่งที่รู้ได้ แต่ปกติมนุษย์รู้ได้ยากเพราะข้อจำกัดของการรับรู้ การประมวลผล และญาณทัศนะของมนุษย์ ข้อจำกัดเหล่านี้เป็นปัจจัยสำคัญที่เป็นอุปสรรคขวางกั้นไม่ให้มนุษย์สามารถแก้ปัญหาอย่างชาญฉลาด หรือพัฒนาตนเองและสังคมให้ก้าวหน้าขึ้นไปได้ ตั้งแต่อดีตเมื่อมนุษย์เริ่มพัฒนามาจนถึงปัจจุบัน เราอยู่กับข้อจำกัดนี้ โดยปรับตัวให้เข้ากับข้อจำกัดและสร้างอารยธรรมที่อยู่บนพื้นฐานของข้อจำกัดนี้ ดังที่เราเห็นว่าสังคมส่วนมากล้วนให้ค่ากับประสบการณ์และความรู้ฝังลึกที่สะสมในตัวบุคคลและวัฒนธรรม
ดังนั้น การพัฒนาปัญญาประดิษฐ์ โดยเฉพาะ Machine learning นี้ ผู้เขียนเห็นว่ากำลังจะเป็นปัจจัยสำคัญที่จะผลักดันให้มนุษย์ก้าวเข้าสู่ยุคที่สอง คือยุคที่การเข้าใจและการตัดสินใจนั้นอยู่บนพื้นฐานของความจริง ไม่ใช่ความเห็นหรือการคาดเดา การที่เราสามารถรู้ได้ว่าอะไรจริงและตัดสินใจบนพื้นฐานของความจริง จะปลดปล่อยเราให้เป็นอิสระจากความไม่รู้ ความไม่แน่ใจ ความหลงผิด และในขณะเดียวกัน ก็สามารถใช้ความรู้นี้มาเสริมสร้างคุณลักษณะและกิจกรรมอันเป็นเอกลักษณ์ของมนุษย์ นั่นก็คืออุดมคติ ความคิดสร้างสรรค์ ศิลปะ และการพัฒนาด้านจิตวิญญาณ อันเป็นขอบเขตที่เครื่องจักรยังไม่อาจแทนที่ได้
### ความจริงที่ไม่ต้องคาดเดา
หากจะพูดกันเฉพาะในประเทศไทย เรามีปัญหาและความท้าทายต่างๆ มากมายที่ดูเหมือนจะใช้เวลามานานก็ยังไม่สามารถแก้ไขหรือป้องกันได้ ยังไม่นับปัญหาใหม่ๆ ที่เกิดขึ้นอย่างรวดเร็ว รุนแรง และกำลังกลายเป็นความเสี่ยงต่อคน สังคม และสิ่งแวดล้อมเป็นอย่างมาก เป้าหมายในการทำงานของผู้เขียนคือการหาทางแก้ไขปัญหาเหล่านี้ด้วยวิธีการใหม่ๆ ดังนั้นจึงพอจะเห็นว่าแนวทางการใช้ Machine ช่วยทำความเข้าใจและตัดสินใจนั้นมีศักยภาพสูงที่จะช่วยแก้ไขปัญหาเหล่านี้ได้
ยกตัวอย่างเช่น ในเรื่องฝุ่นขนาดเล็ก PM2.5 ที่คนไทยกำลังเผชิญอย่างหนัก ที่ผ่านมาภาครัฐล้มเหลวอย่างสิ้นเชิงที่จะแก้ปัญหา ซึ่งสาเหตุหนึ่งของความล้มเหลวคือการขาดความรู้และข้อเท็จจริงว่า ฝุ่นละอองขนาดเล็กที่เกิดขึ้น มาจากปัจจัยใดมากน้อย อย่างไรก็ตาม วิทยาศาสตร์ข้อมูลและ Machine learning ได้ให้คำตอบต่อเรื่องนี้อย่างชัดแจ้ง ว่า[การเผาในที่โล่งนั้นเป็นปัจจัยที่มีส่วนเกี่ยวข้องมากที่สุดต่อปัญหาฝุ่นละอองขนาดเล็ก](https://towardsdatascience.com/identifying-the-sources-of-winter-air-pollution-in-bangkok-part-ii-72539f9b767a#--responses) สิ่งที่เหลือที่ต้องทำ คือการนำเอาข้อเท็จจริงนี้มาปฏิบัติให้เป็นนโยบายโดยผู้มีส่วนเกี่ยวข้อง (ซึ่งทำได้หรือไม่นั้นเป็นอีกปัญหาหนึ่ง)
หรือในเรื่องการดูแลและส่งเสริมพัฒนาการเด็กปฐมวัย ปัจจุบันเริ่มมีความตื่นตัวในการเสริมสร้างพัฒนาการเด็กตั้งแต่ยังเล็ก โดยมีหลักฐานและการวิจัยมากมายที่บ่งชี้ว่าการแทรงแซง (Intervention) ที่เหมาะสมจะทำให้เด็กเติบโตมามีความสามารถในการเรียนรู้และมีความสุขในระยะยาวมากกว่าการไม่ทำอะไรเลย ปัญหาอยู่ที่ว่า หน่วยงานที่มีหน้าที่ส่งเสริมพัฒนาการเด็ก เช่นศูนย์พัฒนาเด็กเล็กที่กระจายอยู่ตามองค์การบริหารส่วนตำบลทั่วประเทศ ไม่สามารถรู้ได้อย่างทันท่วงทีว่าเด็กคนไหนจำเป็นต้องเสริมพัฒนาในด้านใด หรือกว่าจะรู้ก็ต้องใช้เวลาหลายเดือนหรือเป็นปี เป็นการสูญเสียนาทีทองของพัฒนาการไปอย่างน่าเสียดาย ในเรื่องนี้ Machine learning สามารถเข้ามาช่วยพยากรณ์ได้ว่าเด็กคนไหนมีพัฒนาการด้อยด้านใด และจำเป็นแค่ไหนที่จะต้องเสริมในด้านต่างๆ โดยสามารถรู้ได้ตั้งแต่วันแรกที่รับเด็กเข้ามาในศูนย์ฯ จากการเก็บข้อมูลและหาความสัมพันธ์ระหว่างปัจจัยต่างๆ ในเด็กแต่ละคน เช่นสุขภาพ การเลี้ยงดู สภาพครอบครัว ฯลฯ
ส่วนในเรื่องสุขภาพจิต ปัจจุบันมีผู้มีปัญหาด้านจิตใจที่ต้องการคำปรึกษาเป็นจำนวนมาก และหลายคนก็มีปัญหาหนักที่เป็นความเสี่ยงในการฆ่าตัวตาย จำนวนผู้ต้องการคำปรึกษาที่มากมาย ทำให้บริการให้คำปรึกษาต่างๆ นั้นไม่สามารถให้บริการได้ทัน ทำให้ผู้ที่มีปัญหาจำนวนมากไม่ได้รับการปรึกษา หรือได้รับช้าเกินไป ในเรื่องนี้ เราสามารถใช้เทคโนโลยีอย่างแชทบอท ผนวกกับ Machine learning ในการตรวจหาได้ว่าผู้ขอรับคำปรึกษาคนไหนมีความเสี่ยงในการฆ่าตัวตาย เพื่อที่จะส่งเคสดังกล่าวให้ผู้ให้คำปรึกษาและช่วยเหลือที่เป็นมนุษย์มาดูแลได้ทันที เป็นเครื่องมือในการคัดกรองความเสี่ยงตามหลักการแพทย์
และด้วยเทคนิคเดียวกัน เราสามารถตรวจหาสิ่งผิดปกติจากฐานข้อมูล Open data เพื่อตรวจหาการทุจริตคอร์รัปชันประเภทต่างๆ เช่นการจัดซื้อจัดจ้างภาครัฐ โดยการออกแบบกลไกการตีความข้อมูลที่เป็นข้อมูลสาธารณะอยู่แล้ว
### Machine learning สำหรับทุกคน
เช่นเดียวกับที่คนส่วนมากในยุคปัจจุบันสามารถใช้คอมพิวเตอร์และอุปกรณ์ต่างๆ เพื่อทำงานสำนักงาน ค้นหาข้อมูล และสื่อสารกันได้ ผู้เขียนมีความเห็นว่าคนในอนาคตควรจะมีความเข้าใจและความสามารถเบื้องต้นในการทำให้ Machine นั้นเรียนรู้และให้คำตอบที่เป็นข้อเท็จจริงแก่เรา ทฤษฎี แนวคิด และการปฏิบัติเรื่องวิทยาศาสตร์ข้อมูลและ Machine learning อาจดูเข้าถึงได้ยาก เข้าใจยาก และทำได้ยากสำหรับคนทั่วไปในปัจจุบัน แต่ก็เหมือนกับที่ยุคหนึ่ง คนทั่วไปรู้สึกว่าอินเทอร์เน็ตเป็นพื้นที่ลึกลับ เข้าถึงได้ยาก หรือย้อนไปอีกในยุคที่การศึกษาในระบบยังไม่แพร่หลาย คนส่วนมากก็รู้สึกว่าการคำนวนทศนิยม เศษส่วน อัตราเร็ว เป็นเรื่องยากเกินเข้าใจ สิ่งที่ยากในยุคหนึ่ง หากได้รับการพิสูจน์ว่ามีประโยชน์อย่างกว้างขวาง ก็จะพัฒนากลายเป็นสิ่งที่เข้าใจและปฏิบัติกันทั่วไปในยุคต่อมา
การสร้างความเข้าใจเรื่องปัญญาประดิษฐ์ วิทยาศาสตร์ข้อมูล และ Machine learning สำหรับคนทั่วไป มีการดำเนินการแล้วในประเทศฟินแลนด์ โดยเปิด[คอร์สออนไลน์ฟรีสำหรับทุกคน](https://www.elementsofai.com/) ซึ่งผู้จัดทำมีเป้าหมายให้ประชาชนฟินแลนด์ 1% ได้เรียนคอร์สนี้
หนึ่งในปัจจัยสำคัญที่ทำให้คนทั่วไปเรียนรู้ Machine learning ได้ง่ายขึ้น คือความแพร่หลายของภาษาโปรแกรมระดับ High-level ที่เข้าใจง่าย ใช้ง่าย อย่าง Python และ Library ต่างๆ ที่เป็น Framework สำหรับการสร้าง Machine learning system เช่น scikit-learn และ TensorFlow ที่ได้จัดการเรื่องการวางสูตรคำนวนที่ซับซ้อนและละเอียดอ่อนให้เราแทบทั้งหมด ผู้เขียนเองถึงแม้จะมีความรู้พื้นฐานและประสบการณ์ด้านคอมพิวเตอร์มาบ้าง แต่ไม่เคยได้ศึกษาการเขียนโค้ดจริงๆ จังๆ ก็สามารถใช้เวลาเพียงแค่ไม่ถึง 6 เดือนในการเรียนรู้ภาษา Python และ Machine learning จนมีความรู้และความมั่นใจในการนำมาประยุกต์ใช้
แต่เมื่อเครื่องมือนั้นพร้อมและใช้งานง่ายขึ้น ก็เป็นหน้าที่ของเราที่จะต้องมีความเข้าใจในหลักการและเทคนิคต่างๆ เพื่อให้สามารถเลือกใช้เครื่องมือต่างๆ นั้นได้เหมาะสมกับโจทย์และเป้าหมายที่ต้องการ นี่เป็นที่มาและแรงบันดาลใจให้ผู้เขียนได้พยายามถ่ายทอดหลักการของ Machine learning อย่างค่อนข้างลึกซึ้ง ประกอบกับการแนะนำวิธีการในการปฏิบัติจริง เพื่อช่วยให้ผู้อ่านสามารถเริ่มต้นเส้นทางในการเรียนรู้เรื่องนี้ได้ และในขณะเดียวกัน ก็เป็นการฝึกทบทวนความเข้าใจของผู้เขียนเอง จากสิ่งที่ได้ศึกษาและปฏิบัติมา ให้แม่นยำชัดเจนขึ้นด้วย
## ภาคผนวก 2: พื้นฐาน Python อย่างสั้นที่สุด
บทนี้จะแนะนำ Python สำหรับผู้ที่ไม่มีพื้นฐานการเขียนโค้ดเลย โดยจะอธิบายเฉพาะเรื่องพื้นฐานที่สำคัญจริงๆ อย่างสั้นและกระชับที่สุด เพื่อให้สามารถเริ่มต้นได้และสามารถใช้ Machine learning framework เช่น scikit-learn และ TensorFlow
ขอย้ำอีกรอบ ว่าสิ่งที่แนะนำนี้ไม่ได้ครบถ้วนสมบูรณ์ตามหลักวิชาการ แต่เน้นกระชับ สั้น ง่าย ให้เริ่มต้นเรียนรู้ได้เท่านั้น
Python เป็นภาษาคอมพิวเตอร์แบบ High-level นั่นหมายความว่าเราสามารถสั่งให้ Python ทำสิ่งต่างๆ ได้ในลักษณะที่คล้ายกับภาษาคน โดยไม่ต้องไปสนใจเรื่อง "หลังบ้าน" ของคอมพิวเตอร์มากนัก เช่นการจัดการหน่วยความจำ การระบุประเภทตัวแปร เป็นต้น ทำให้เขียนง่าย อ่านง่าย เข้าใจง่าย
นอกจากนั้น Python ยังเป็นภาษาแบบ Interpret หมายความว่าเวลาเราเรียก Script หรือโปรแกรมที่เขียนด้วย Python เครื่องก็จะตีความ คำนวน และแสดงผลทันที โดยไม่ต้องสั่งแปลงเป็นภาษาเครื่องก่อนจะรันโปรแกรม (เรียกว่าการ Compile) ทำให้สะดวกรวดเร็วในการพัฒนาโปรแกรม แต่แลกมากับการที่ความเร็วและประสิทธิภาพในการคำนวนจะด้อยกว่าภาษาที่ต้อง Compile เช่น C++ เป็นต้น
ปัจจุบัน Python เป็นภาษา "มาตรฐาน" สำหรับงานวิทยาศาสตร์ข้อมูล, AI, Machine learning นอกจากนั้นยังใช้ในอีกหลายวงการ เช่นการสร้างเว็บไซต์ ผ่าน Framework เช่น Django และ Flask เป็นต้น
### การติดตั้งและใช้งาน Python
ขั้นแรกให้โหลด Python มาติดตั้งก่อน โดยเข้าไปที่[เว็บไซต์ของ Python](https://www.python.org/) ไปที่หน้า Downloads และทำตามคำแนะนำได้เลย
อย่างไรก็ตาม ถ้าจะใช้ Python ในงานวิทยาศาสตร์ข้อมูล, AI, Machine learning แนะนำวิธีติดตั้งอีกแบบ คือการติดตั้ง Python และ Library มาตรฐานที่มักจะได้ใช้แบบรวดเดียวจบ ผ่าน [Anaconda](https://www.anaconda.com/distribution/) ก็จะได้ Library พื้นฐาน เช่น numpy, pandas, matplotlib มาเลย ส่วน scikit-learn และ TensorFlow ก็สามารถติดตั้งได้ง่ายๆ โดยใช้คำสั่ง `conda` ใน Commandline เช่น `conda install scikit-learn` และ `conda install tensorflow` เป็นต้น รายละเอียดเรื่องการติดตั้งและจัดการ Package จะไม่อธิบายมาก สามารถอ่านและศึกษาได้โดยตรง
การเขียนโค้ดและเรียกโปรแกรมที่เขียนด้วย Python มีหลายวิธี ดังนี้
* iPython: เรียก `ipython` จาก Commandline จะสามารถเขียนโค้ดและรันทีละบรรทัดๆ เหมาะสำหรับการทำลองไอเดียสั้นๆ เร็วๆ หรือใช้ Python เป็นเครื่องคิดเลข
* IDE: ใช้ Python ผ่านโปรแกรมที่เป็นสภาพแวดล้อมสำหรับการเขียนโค้ดโดยเฉพาะ เช่น PyCharm หรือ Spyder โดยสามารถติดตั้งและเรียกใช้ IDE เหล่านี้ได้เอง
* Jupyter Lab: ใช้ Python ผ่าน Jupyter Notebook (ปัจจุบันพัฒนาเป็นรุ่นใหม่ เรียกว่า Jupyter Lab) โดยการเรียก `jupyter lab` จาก Commandline จะเปิดเว็บขึ้นมาในลักษณะ Web-based IDE นั่นเอง สำหรับงาน Data science/ML แนะนำวิธีนี้ เพราะสามารถแยกโค้ดเป็น Cell ย่อยๆ และสามารถใส่ Cell ที่เป็นข้อความธรรมดาเพื่ออธิบายโค้ดของเราควบคู่ไปได้
### การคำนวน
เมื่อเรียกใช้ Python ผ่านช่องทางที่ถนัดแล้ว ก็มาเริ่มกันเลย
การคำนวนและการแสดงผล ทำได้ง่ายมาก เช่น:
```
2*0.5/3
```
จะได้คำตอบเป็น `0.3333333333333333` สังเกตว่าถ้าเราคำนวนหลายๆ อย่างใน Term เดียว เราอาจจะไม่แน่ใจว่า Python จะคำนวนสัญลักษณ์ไหนก่อน ซึ่งจริงๆ มีลำดับที่ชัดเจน แต่ถ้าไม่อยากจำ แนะนำว่าให้ใส่วงเล็บให้ชัดเจนไปเลย เช่น:
```
(2*0.5)/3
```
นอกจากบวก `+` ลบ `-` คูณ `*` หาร `/` ยังมี Operator ที่น่ารู้ เช่น ยกกำลัง `**` Floor division `//` (หารไม่เอาเศษ) และ Modulus `%` (หารแล้วเอาแค่เศษ) สามารถดูเพิ่มเติมได้จากเว็บต่างๆ เช่น[ที่นี่](https://www.w3schools.com/python/python_operators.asp)
### Variables: การกำหนดตัวแปร
เวลาเราเขียนโค้ด เรามักจะต้องการเก็บข้อมูลบางอย่างเอาไว้ก่อนเพื่อเรียกใช้ภายหลัง เราเรียกที่เก็บข้อมูลนี้ว่าตัวแปร หรีอ Variable
ตัวอย่างเช่น:
```python
age = 50
name = "John"
print(age)
print(name)
```
จะได้คำตอบคือ:
```
50
John
```
สังเกตว่า ค่าของตัวแปรที่เป็นตัวเลข สามารถใส่ได้เลย ส่วนถ้าเป็นตัวหนังสือ ต้องใช้ Quotation ครอบไว้ จะใช้ `"` หรือ `'` ก็ได้
เราใช้ฟังก์ชัน `print()` เพื่อแสดงผลสิ่งที่อยู่ในวงเล็บ เราเรียกสิ่งที่อยู่ในวงเล็บว่า Argument โดยในที่นี้เราจะใส่ตัวแปรของเราเป็น Argument ทำให้ Python print ค่าของตัวแปรของเราออกมา อนึ่ง Argument อาจมีได้หลายอัน ขึ้นอยู่กับว่า Function นั้นรองรับ Argument อะไรบ้าง โดยเราใช้ Comma `,` คั่นระหว่างแต่ละ Argument ซึ่งเดี๋ยวเราจะเห็นตัวอย่างเมื่ออธิบาย Function อื่นๆ ต่อไป
ทีนี้เราจะลองใช้ประโยชน์จากตัวแปร โดยเราต้องการที่จะบอกว่า John อายุ 50 ปี:
```python
print(name + ' is ' + str(age) + ' years old.')
```
ได้คำตอบว่า:
```
John is 50 years old.
```
ลองมาดูกันว่าเกิดอะไรขึ้นบ้าง:
* เครื่องหมาย `+` ในที่นี้ คือการเอาข้อความ (เรียกว่า String) มาต่อกัน (เรียกการกระทำแบบนี้ว่า Concatenate)
* การ Concatenate จะต้องทำระหว่างข้อมูลประเภทเดียวกันเท่านั้น เช่น String กับ String ดังนั้น เราจึงต้องแปลงตัวแปร `age` จากตัวเลขจำนวนเต็ม (Integer หรือ int) ให้เป็นข้อความ (String หรือ str) ด้วยการเรียกฟังก์ชัน `str()`
* สังเกตว่าเราเว้นวรรคบางจุด เช่น ก่อนและหลัง `is` และก่อน `years old` เพื่อให้ข้อความที่ออกมามีการเว้นวรรคที่ถูกต้อง เพราะการ Concatenate ไม่ได้เว้นวรรคให้เรา
ทีนี้ถ้าเรากำหนดตัวแปรใหม่ เช่น `age = 35` แล้วเรียก `print` เหมือนเดิมอีกรอบ Output ที่ได้ก็จะเปลี่ยนตามตัวแปรใหม่ นั่นก็คือ `John is 35 years old.`
### Data types: ประเภทของข้อมูล
ตัวแปรสามารถเก็บข้อมูลได้หลายประเภท เราจะทำความรู้จักประเภทข้อมูลพื้นฐานที่สำคัญและใช้บ่อยดังนี้:
* Text `str`
* Numerical `int`, `float`
* Sequence `list`, `tuple`
* Mapping `dict`
* Boolean `bool`
#### String
เรารู้จัก String กันแล้วก่อนหน้านี้ String มีคุณสมบัติที่น่าสนใจบางอย่าง เช่น:
1) String เป็น Array หมายความว่าตัวอักษรแต่ละตัวจะถูกมองว่าเป็นข้อมูล 1 ชิ้น ดังนั้นเราจึงสามารถจัดการตัวอักษรใน String ได้หลากหลาย เช่น:
**หาความยาว** โดยใช้ฟังก์ชัน len()
```python
a = "Hello, World!"
print(len(a))
```
ได้คำตอบคือ `13`
**ตัดเอา Space ว่างท้าย String ออก** โดยใช้ Method `.strip()` (Method คือฟังก์ชันที่ใช้ได้กับตัวแปร โดยการนำไปต่อท้ายตัวแปรได้ทันที เพื่อกระทำการบางอย่างกับข้อมูลในตัวแปรนั้น ลองดูตัวอย่างข้างล่าง)
```python
a = " Hello, World! "
print(a.strip())
```
ได้คำตอบว่า `Hello, World!` โดยไม่มี Space หลัง `!`
**แยกคำออกจากกัน** โดยใช้ Method `.split()`
```python
a = "My name is John."
print(a.split())
```
จะเป็นการแยกประโยคออกเป็นคำๆ โดยแยกที่ Space ได้ผลคือ `['My', 'name', 'is', 'John.']` ทั้งนี้สามารถกำหนดได้ว่าให้แยกที่พบอักษรอะไร เช่น `a.split(",")` คือให้แยกเมื่อพบ Comma เป็นต้น
สังเกตว่า `['My', 'name', 'is', 'John.']` เป็นข้อมูลประเภท List ซึ่งจะอธิบายภายหลังว่าคืออะไร ตอนนี้เพียงให้รู้ว่า List นี้มีข้อมูล 4 รายการ คือคำแต่ละคำนั่นเอง คั่นด้วย Comma
**เลือกเฉพาะบางตัวอักษรตามลำดับที่** เป็นความสามารถที่เรียกว่า Slicing ซึ่งใช้ได้กับทุกอย่างที่มีลักษณะเป็น Array หลักการคือ Python จะกำหนดให้ข้อมูลชิ้นแรกมีรหัส Index 0 และเพิ่มขึ้นทีละ 1 ต่อไปเรื่อยๆ ดังนั้น:
```python
a = "Hello, World!"
print(a[1])
```
จะได้ `e`
เราสามารถเลือก Slicing เป็น Range ได้ โดยใช้ Colon `:` คั่น โดยจะนับ Index เริ่มต้นเป็นชิ้นแรก (Inclusive) แต่ Index ตัวขบขะไม่นับตัวมันเอง (Exclusive) ตัวอย่างเช่น:
```python
a = "Hello, World!"
print(a[2:5])
```
จะได้ `llo`
สุดท้าย ถ้าใน String มีเครื่องหมายที่ปกติจะถูกตีความว่ามีความหมายพิเศษ เช่น `"` เราจะไม่สามารถใส่เครื่องหมายนั้นลงไปได้ตรงๆ ถ้าอยากใส่ ต้องใช้ Backslash `\` ไว้ก่อน เราเรียก `\` ว่า **Escape character** ตัวอย่างเช่น:
```python
print("My name is \"John\".")
```
จะได้ `My name is "John".`
แถม Escape character ที่มีประโยชน์มาก คือ `\n` คือการขึ้นบรรทัดใหม่ ส่วน `\t` คือ Tab
อ่านเพิ่มเติมเกี่ยวกับ String ได้[ที่นี่](https://www.w3schools.com/Python/python_strings.asp)
#### Int และ Float
Int (Integer) คือจำนวนเต็ม เช่น -1, 0, 5, 100 ส่วน Float คือจำนวนที่มีทศนิยม เช่น -0.12, 5.816497 เป็นต้น เราสามารถดูได้ว่าตัวเลขของเราคือประเภทอะไร โดยใช้ฟังก์ชัน `type()` เช่น:
```python
x = 1
y = 2.5
print(type(x))
print(type(y))
```
จะได้:
```
<class 'int'>
<class 'float'>
```
เราสามารถแปลงระหว่าง `int` กับ `float` ได้ โดยใช้ฟังก์ชัน `int()` และ `float()`
#### List
List เป็นข้อมูลแบบ Array ที่มีสมาชิกหลายตัว สามารถผสมสมาชิกประเภทต่างๆ กันได้ และสามารถสลับตำแหน่ง เปลี่ยนแปลงข้อมูลได้ จึงใช้งานได้หลายวัตถุประสงค์ยืดหยุ่นมาก เราสามารถสร้าง List โดยการใช้ Bracket [] เช่น:
```python
emptylist = []
print(emptylist)
```
ก็จะได้ List ว่างๆ คือ [] ส่วน List ที่มีสมาชิก ก็ใส่สมาชิกนั้นลงไปเลย คั่นแต่ละตัวด้วย Comma เช่น:
```python
fruitlist = ["apple", "banana", "cherry"]
print(fruitlist)
```
ก็จะได้ `['apple', 'banana', 'cherry']`
สมมุติเราอยากเลือกแค่ banana กับ cherry ก็ใช้ Slicing ได้ เช่น:
```python
fruitlist = ["apple", "banana", "cherry"]
print(fruitlist[1:])
```
ก็จะได้ `['banana', 'cherry']` สังเกตว่าตอน Slice ถ้าเราไม่ใส่ Index ตัวจบ ก็แปลว่าให้เลือกไปจนถึงสมาชิกตัวสุดท้าย โดยรวมตัวสุดท้ายด้วย ในทางกลับกัน ถ้าไม่ใส่ Index ตัวเริ่ม ก็คือให้เริ่มที่สมาชิกตัวแรกเลย
เราสามารถเปลี่ยนสมาชิกใน List ง่ายๆ เช่น:
```python
fruitlist = ["apple", "banana", "cherry"]
fruitlist[1] = "pineapple"
print(fruitlist)
```
จะได้ `['apple', 'pineapple', 'cherry']` ทันที
ส่วนถ้าจะเพิ่มสมาชิก ก็ทำได้โดยใช้ Method .append() เช่น:
```python
fruitlist = ["apple", "banana", "cherry"]
fruitlist.append("orange")
print(fruitlist)
```
จะได้ `['apple', 'banana', 'cherry', 'orange']`
นอกจากนี้ยังมีการแทรกสมาชิก ใช้ `.insert(index, object)` โดยใส่ Index ที่ต้องการแทรกลงไปเป็น Argument ก่อนจะใส่ Object ที่ต้องการแทรก ส่วนการลบสมาชิก ก็สามารถใช้ `.remove(object)` ซึ่งใส่ชื่อ Object เป็น Argument หรือไม่ก็ `.pop(index)` ซึ่งใช้หมายเลข Index เป็น Argument (ถ้าไม่ใส่จะหมายถึงให้เอารายการสุดท้ายออก)
ถ้าต้องการลบสมาชิกทั้งหมดใน List ให้เหลือ List ว่างๆ ก็ใช้ `.clear()`
สุดท้าย เราสามารถเอา List มาต่อกันได้ โดยการใช้เครื่องหมาย + เช่น:
```python
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]
list3 = list1 + list2
print(list3)
```
จะได้ `['a', 'b', 'c', 1, 2, 3]`
สุดท้าย เราสามารถนับจำนวนสมาชิกใน List ได้ โดยใช้ฟังก์ชัน len() เช่นเดียวกับการนับจำนวนตัวอักษรใน String
List จะมีประโยชน์มากเมื่อใช้คู่กับ For loop ซึ่งจะอธิบายในส่วนถัดๆ ไป
สามารถอ่านเรื่อง List เพิ่มเติมได้[ที่นี่](https://www.w3schools.com/Python/python_lists.asp)
#### Tuple
Tuple เป็นข้อมูลแบบ Array ที่มีสมาชิกหลายตัวคล้ายกับ List ต่างกันที่ Tuple นั้นไม่สามารถเปลี่ยนแปลงข้อมูลข้างในได้ เราสามารถสร้าง Tuple โดยใช้วงเล็บ () เช่น:
```python
emptytuple = ()
print(emptytuple)
```
ก็จะได้ List ว่างๆ คือ () ส่วนคุณสมบัติอื่นๆ ก็เหมือนกับ List ต่างตรงที่ไม่สามารถเพิ่ม ลบ สิ่งที่อยู่ใน Tuple ได้
อ่านเพิ่มเกี่ยวกับ Tuple ได้[ที่นี่](https://www.w3schools.com/Python/python_tuples.asp)
#### Dictionary
Dictionary เป็นประเภทข้อมูลที่เก็บข้อมูลแต่ละตัวเป็นคู่ ซึ่งประกอบด้วยรหัส (Key) กับค่า (Value) เรียกว่า Key-value pair เราสามารถสร้าง Dictionary ด้วยการใช้วงเล็บปีกนก `{}` ตัวอย่างเช่น:
```python
profiledict = {
"name": "John",
"age": 50,
"sex": "male"
}
print(profiledict)
```
จะได้ `{'name': 'John', 'age': 50, 'sex': 'male'}` สังเกตว่าข้อมูลแต่ละคู่จะใช้ Comma แบ่ง
เราสามารถ**เรียก Value** ของ Key-value pair โดยการเรียก Key ที่ต้องการ โดยเรียกใน Bracket เช่น:
```python
print(profiledict["name"])
```
ก็จะได้ Value ของ Key `"name"` นั่นก็คือ `"John"`
อีกวิธีในการเรียก Value คือการใช้ Method `get(key)` ก็ได้ผลเหมือนกัน
เราสามารถ**เปลี่ยน Value** ได้ โดยการเรียก Key แล้วกำหนด Value ใหม่โดยใช้เครื่องหมาย `=` เช่น:
```python
profiledict = {
"name": "John",
"age": 50,
"sex": "male"
}
profiledict["age"] = 35
print(profiledict)
```
ก็จะได้ `{'name': 'John', 'age': 35, 'sex': 'male'}` ตามที่ต้องการ
การ**เพิ่ม Key-value pair** ใหม่ใน Dict ให้ทำเหมือนกับการเปลี่ยน Value โดยกำหนด Key และ Value ตามที่ต้องการได้เลย เช่น:
```python
profiledict = {
"name": "John",
"age": 50,
"sex": "male"
}
profiledict["address"] = "Bangkok"
print(profiledict)
```
จะได้ `{'name': 'John', 'age': 50, 'sex': 'male', 'address': 'Bangkok'}`
ส่วนการ**ลบ Key-value pair** ก็ใช้ Method `.pop(key)`
การ Loop สมาชิกใน Dictionary โดยปกติจะได้ Key ออกมา แต่ถ้าอยากได้ Value ก็สามารถทำได้ โดยจะอธิบายในส่วน For loop
อ่านเพิ่มเกี่ยวกับ Dictionary ได้[ที่นี่](https://www.w3schools.com/Python/python_dictionaries.asp)
#### Boolean
Boolean คือข้อมูลที่มีสองค่าเท่านั้น คือ True หรือ False โดย Python จะพิจารณาจาก Expression ที่ใส่ เช่น:
```python
print(10 > 9)
print(10 == 9)
print(10 < 9)
```
คำตอบคือ:
```
True
False
False
```
สังเกตว่า เวลาเปรียบเทียบความเท่ากัน ใช้ == ไม่ใช่ = เพราะ = เป็นเครื่องหมายสำหรับการกำหนดค่าให้กับตัวแปร (Assignment) ไม่ใช่การเปรียบเทียบว่าจริงหรือไม่ (Validation)
สำหรับรายละเอียดอื่นๆ อ่านเพิ่มได้[ที่นี่](https://www.w3schools.com/Python/python_booleans.asp)
### Conditions: การกำหนดเงื่อนไข
บ่อยครั้งที่เราต้องการให้โค้ดของเรามีความฉลาด เช่นสามารถทำสิ่งหนึ่งภายใต้เงื่อนไขบางอย่าง หรือให้ทำสิ่งเดิมวนซ้ำๆ จนกระทั่งบรรลุถึงเงื่อนไขที่ต้องการ ความสามารถแบบนี้เรียกว่า Conditions หรือบางทีก็เรียกว่า Flow control เป็นหัวใจของการเขียนโค้ด ควรจะเรียนรู้ไว้ให้คล่อง
เราจะทำความรู้จัก Conditions 3 รูปแบบ คือ:
```
If...Else
For loop
While loop
```
**If...Else**
เราสามารถกำหนดให้โปรแกรม เรียกโค้ดบรรทัดหนึ่งๆ ก็ต่อเมื่อเงื่อนไขบางอย่างเป็นจริง
If: การกำหนดเงื่อนไข ทำได้โดยการเขียน if เว้นวรรค ตามด้วย Statement ที่เป็นเงื่อนไข ตามด้วย Colon : เช่น:
```python
a = 10
b = 25
if b > a:
print("b is greater than a")
```
เนื่องจากในกรณีนี้ b มากกว่า a ตามเงื่อนไขใน if (statement): Python ก็จะเรียกโค้ดที่อยู่บรรทัดถัดไป โดยจะเรียกเฉพาะบรรทัดที่ถูก Indent เท่านั้น การ Indent ทำได้โดยการกด Tab หรือเคาะ Space 2 หรือ 4 ที
Elif: ถ้าเราต้องการสร้างเงื่อนไขต่อไป ในกรณีที่เงื่อนไขแรกไม่เป็นจริง ก็ใช้ elif ซึ่งย่อมาจาก Else if เช่น:
```python
a = 25
b = 25
if b > a:
print("b is greater than a")
elif b == a:
print("b equals a")
```
Else: แต่ถ้าเราต้องการเพียงแค่จะดักเงื่อนไขที่ไม่เป็นจริงจาก If ด้านบน ก็เพียงใช้ else ดังนี้:
```python
a = 50
b = 25
if b > a:
print("b is greater than a")
else:
print("b is not greater than a")
```
And/Or: ใน Statement เราสามารถใช้ Operator and หรือ or เชื่อม 2 Statement เข้าด้วยกัน เพื่อสร้างเงื่อนไขที่เจาะจงขึ้นได้ โดย and แปลว่าจะต้องเป็นจริงทั้ง 2 Statement ส่วน or เป็นจริง Statement เดียวก็ถือว่าจริง
**For loop**
For loop ใช้สำหรับการวนโค้ดซ้ำๆ ตามสมาชิกของข้อมูลแบบ Text, Sequence, และ Mapping นั่นก็คือ str, list, tuple, และ dict สำหรับผู้เริ่มต้นอาจจะงง จึงให้ลองดูตัวอย่างดังนี้:
```python
for i in "banana":
print(i)
```
จะได้ Output ว่า:
```
b
a
n
a
n
a
```
หลักการทำงานของ For loop คือการกำหนดตัวแปรขึ้นมาตัวหนึ่ง เช่น i (นิยมใช้ เพราะย่อมาจาก Iteration แปลว่าการทำซ้ำเป็นรอบ) แล้วกำหนดค่า i ให้เป็นสมาชิกแต่ละตัวตั้งแต่ตัวแรกไปจนถึงตัวสุดท้าย โดยให้กระทำกับ i ตามโค้ดที่ถูก Indent ไว้ เช่นในที่นี้ ก็เพียงให้พิมพ์ค่า i ออกมา โดยการวนแต่ละรอบ จะ Output ออกหนึ่งบรรทัด พอวนรอบถัดไป ก็ Output ออกบรรทัดใหม่ ทำอย่างนี้ไปเรื่อยๆ จนถึงสมาชิกตัวสุดท้าย
ลองมาดู For loop สำหรับ List กัน:
```python
fruitlist = ["apple", "banana", "cherry"]
for i in fruitlist:
print(i)
```
จะได้:
```
apple
banana
cherry
```
หลายคนอาจสงสัยว่า จะทำอย่างนี้ไปทำไม คำตอบคือมันจะมีประโยชน์เมื่อไปผสมกับอย่างอื่นที่ทำให้ Output นั้นมีความหมาย ตัวอย่างเช่น:
```python
fruitlist = ["apple", "banana", "cherry"]
count = 1
for i in fruitlist:
print("Fruit number " + str(count) + " is " + i + ".")
count = count + 1
print("There are " + str(count-1) + " fruit types.")
```
Output ที่ได้คือ:
```
Fruit number 1 is apple.
Fruit number 2 is banana.
Fruit number 3 is cherry.
There are 3 fruit types.
```
อธิบายดังนี้:
* เรามีข้อมูลตั้งต้นเป็น List ของประเภทผลไม้ เราต้องการให้โปรแกรมระบุลำดับที่ของประเภทผลไม้ พร้อมกับบอกว่าเป็นประเภทอะไร นอกจากนั้น เรายังอยากให้โปรแกรมสรุปว่าสุดท้ายผลไม้ใน List มีทั้งหมดกี่ประเภท
* เมื่อได้โจทย์แล้ว ก็ต้องวางแผน จะเห็นว่าเราต้องการนับลำดับที่ของผลไม้ โดยให้ตัวเลขเพิ่มขึ้นเรื่อยๆ ดังนั้น เราจะกำหนดตัวแปรสำหรับลำดับที่ที่จะแสดงผล โดยกำหนดไว้เป็น 1 ก่อน ด้วยการกำหนด `count = 1`
* จากนั้นก็เริ่มวน For loop โดยใน Loop ให้พิมพ์ `count` และ `i` ซึ่งก็คือชื่อผลไม้ใน List นั่นเอง
* ตอนเราจะจบ Loop แต่ละรอบ เราจะต้องเปลี่ยนตัวแปร `count` ให้เพิ่มขึ้นรอบละ 1 ซึ่งทำได้โดยการกำหนด `count = count + 1` หรือจะย่อว่า `count += 1` ก็ได้
* ดังนั้น พอผ่านรอบแรกมาถึงจุดนี้ `count` จะเท่ากับ 2 เมื่อ For loop วนรอบสอง ก็จะแสดงค่า `count` ของรอบนี้ เป็น 2 ตามที่ต้องการ ซึ่งจับคู่กับ `banana` ทำอย่างนี้ไปเรื่อยๆ จนจบ List
* สุดท้าย เราจะสรุปจำนวนประเภทผลไม้ ซึ่งก็คือ `count` แต่ต้องลบ 1 เพราะรอบสุดท้าย คือรอบที่ 3 ได้จบรอบด้วยการบวก `count` ไปอีก 1 ทำให้ `count` ตอนจบเท่ากับ 4 ตอนพิมพ์จำนวนสรุปตอนจบนี้ ต้องทำ "นอก Loop" นั่นคือให้กลับไปสร้าง Statement ที่ไม่ได้อยู่ใน Indent นั่นเอง เพราะถ้ายังอยู่ใน Indent โปรแกรมก็จะเรียกโค้ดบรรทัดนี้ทุกครั้งที่วน Loop ซึ่งไม่ใช่สิ่งที่เราต้องการ
* อนึ่ง วิธีการสรุปจำนวนรายการใน List ที่ง่ายกว่านั้น คือการใช้ฟังก์ชัน `len(object)` เช่น `print("There are " + str(len(fruitlist)) + " fruit types.")` สังเกตว่าเราใช้ `str()` คลุมรอบ `len()` อีกที เพราะ `len()` ให้ผลเป็นตัวเลข ซึ่งเอามา Concatenate กับ Text ไม่ได้ ต้องเปลี่ยนตัวเลขให้เป็น `str` เสียก่อน
เราสามารถ**หยุด For loop** ได้ด้วยการใช้ `break` และ `continue`
1) `break` จะหยุด For loop ก่อนที่จะวนครบทุกรายการ โดยจะรันรายการล่าสุดเป็นรายการสุดท้าย:
```python
fruits = ["apple", "banana", "cherry"]
for i in fruits:
print(i)
if i == "banana":
break
```
จะได้:
```
apple
banana
```
2) continue จะข้ามรายการล่าสุด แล้วไปต่อที่รายการถัดไป:
```python
fruits = ["apple", "banana", "cherry"]
for i in fruits:
if i == "banana":
continue
print(i)
```
จะได้:
```
apple
cherry
```
**While loop** เป็นการวนซ้ำตราบใดที่เงื่อนไขยังคงเป็นจริง เช่น:
```python
i = 1
while i < 6:
print(i)
i += 1
```
จะได้:
```
1
2
3
4
5
```
การใช้ While loop ให้ระวังอย่าลืมบวก i เพิ่ม เพื่อให้มีจุดที่ Loop จะวนจนไปชนเงื่อนไขที่ไม่เป็นจริง มิฉะนั้น หากเงื่อนไขเป็นจริงเสมอ While loop ก็จะวนตลอดกาล
การหยุด While loop สามารถใช้ break และ continue ได้เช่นเดียวกับ For loop
### Function: ฟังก์ชัน
Function คือกลุ่มโค้ดที่จะรันต่อเมื่อถูกเรียกใช้เท่านั้น การสร้างฟังก์ชัน ให้ใช้ def เว้นวรรค ตามด้วยชื่อฟังก์ชันที่ต้องการ ตามด้วย Colon : ตัวอย่างเช่น:
```python
def greeting():
print("Hello!")
```
พอจะเรียกฟังก์ชัน ก็เพียงเรียก greeting() ก็จะได้:
```
Hello!
```
สังเกตว่าที่ผ่านมา เรารู้จักกับฟังก์ชันที่มาพร้อมกับ Python หลายตัวแล้ว เช่น `str()` หรือ `len()` ฟังก์ชันเหล่านี้ก็เหมือนกับฟังก์ชันที่เราสร้างขึ้นเอง ต่างกันที่ Python เตรียมมาให้เราแล้วเท่านั้นเอง
Argument
เราสามารถใส่ข้อมูลเข้าไปในฟังก์ชัน เพื่อให้ฟังก์ชันทำอะไรบางอย่างกับข้อมูล แล้วให้ผลลัพธ์ออกมาได้ โดยผลลัพธ์ก็สามารถออกมาเป็นข้อมูลได้เช่นกัน ข้อมูลที่เราใส่ในฟังก์ชัน เรียกว่า Argument (บางทีก็เรียกว่า Parameter เวลาพูดถึงตัวแปรที่อยู่ในวงเล็บตอนสร้างฟังก์ชัน) โดยใส่ในวงเล็บที่ต่อท้ายชื่อฟังก์ชันตอนเราสร้างฟังก์ชัน ตัวอย่างเช่น:
```python
def greeting(name):
print("Hello, " + name + "!")
```
เวลาเรียกฟังก์ชัน ก็ใส่ Argument ที่เราต้องการลงไป เช่น:
```python
greeting("John")
```
ก็จะได้:
```
Hello, John!
```
ถ้าเรากำหนด Argument กี่ตัวตอนสร้าง Function ตอนเรียกเราก็ต้องใส่ Argument จำนวนเท่ากัน เข่น:
```python
def greeting(fname, lname):
print("Hello, " + fname + " " + lname + "!")
```
เวลาเรียกฟังก์ชัน ก็ใส่ Argument ทั้งสองลงไปตามลำดับ เช่น:
```python
greeting("John", "Doe")
```
ก็จะได้:
```
Hello, John Doe!
```
หากเราไม่รู้ว่าตอนเรียกฟังก์ชัน จะมี Argument ที่ป้อนเข้าไปกี่ตัว เราสามารถทำดังนี้ตอนสร้างฟังก์ชัน:
1) ใช้ Arbitary argument หรือ `*args` โดยการใส่ `*` ก่อนชื่อ Parameter ตอนสร้างฟังก์ชัน วิธีนี้จะเป็นการส่ง Tuple เข้าไปในในฟังก์ชัน โดยไม่ต้องระบุจำนวน Argument ที่แน่นอน ตัวอย่างเช่น:
```python
def fruitlist(*fruit):
print("The last fruit is " + fruit[-1] + ".")
fruitlist("apple", "banana", "cherry")
```
ก็จะได้ The last fruit is cherry. สังเกตว่าในฟังก์ชัน เราเลือกผลไม้รายการสุดท้ายโดยการ Slice ด้วย [-1] ซึ่งหมายถึงรายการสุดท้าย
2) ใช้ Keyword argument หรือ kwargs โดยการใส่ Key-value เข้าไปในฟังก์ชัน โดยตอนเรียกให้เรียก Key ก็จะได้ Value วิธีนี้ต้องระบุจำนวน Argument ที่แน่นอน เช่น:
```python
def fruitlist(fruit1, fruit2, fruit3):
print("The last fruit is " + fruit3 + ".")
fruitlist(fruit1 = "apple", fruit2 = "banana", fruit3 = "cherry")
```
ก็จะได้ The last fruit is cherry. เช่นเดิม
3) ใช้ Arbitary keyword argument หรือ `**kwargs` โดยการใส่ `**` ก่อนชื่อ Parameter ตอนสร้างฟังก์ชัน วิธีนี้จะเป็นการส่ง Dictionary ของ Argument เข้าไปในฟังก์ชัน โดยตอนเรียกก็เรียก Key จะได้ Value ออกมา วิธีนี้ไม่ต้องระบุจำนวน Argument ที่แน่นอน เช่น:
```python
def fruitlist(**fruits):
print("The last fruit is " + fruits["fruit3"] + ".")
fruitlist(fruit1 = "apple", fruit2 = "banana", fruit3 = "cherry")
```
ก็จะได้ The last fruit is cherry. เช่นเดียวกัน
ใช้ List และ Dictionary เป็น Argument
เราสามารถใส่ List หรือ Dictionary ที่กำหนดไว้แล้ว ลงไปเป็น Argument ได้ เช่น:
```python
fruits = ["apple", "banana", "cherry"]
def fruitlist(fruits):
print("The last fruit is " + fruits[-1] + ".")
fruitlist(fruits)
```
หรือ:
```python
fruitdict = {
"fruit1": "apple",
"fruit2": "banana",
"fruit3": "cherry"
}
def fruitlist(fruitdict):
print("The last fruit is " + fruitdict["fruit3"] + ".")
fruitlist(fruitdict)
```
ก็จะได้ `The last fruit is cherry.` เช่นเดียวกันทั้งหมด
Return value
เราสามารถให้ฟังก์ชัน Output ค่าออกมาได้ เช่น:
```python
def bmi(weight, height):
return weight/(height**2)
bmi(70, 1.72)
```
### Library import: การเรียกใช้ Library
Python มี Library ที่ขยายความสามารถเฉพาะทางให้เลือกใช้จำนวนมาก เช่น numpy เป็น Library สำหรับการประมวลผลแบบ Array หลายมิติที่มีประสิทธิภาพสูง หรือ pandas เอาไว้จัดการข้อมูลแบบตาราง เป็นต้น
ก่อนจะใช้ Library เหล่านี้ เราต้องติดตั้งเสียก่อน โดยถ้าใช้ Python ปกติ ก็ใช้ pip เป็นตัวติดตั้งและจัดการ Package เช่น `pip install numpy` ส่วนถ้าใช้ Anaconda ที่แนะนำในตอนแรก ก็ใช้คำสั่ง conda จัดการ เช่น `conda install numpy` เป็นต้น
การเรียกใช้ Library มีสองวิธีใหญ่ๆ ได้แก่:
1) เรียกโดยตรง โดยใช้ import เช่น:
```python
import numpy
```
เวลาจะใช้งาน ก็ต้องเรียก numpy ก่อน เช่น:
```python
a = numpy.array([[1, 2], [3, 4]])
```
2) เรียกโดยการเปลี่ยนชื่อ หรือที่เรียกว่า Alias เพื่อย่นชื่อให้สั้นลงโดยใช้ as จะได้เรียกใช้สะดวก เช่น:
```python
import numpy as np
```
เวลาจะใช้งาน ก็สามารถเรียก np ได้เลย เช่น:
```python
a = np.array([[1, 2], [3, 4]])
```
3) เรียกเฉพาะบางฟังก์ชันหรือ Class ที่จะใช้ โดยใช้ `from...import` เช่น:
```python
from numpy import array
```
เวลาเรียก ก็เรียกชื่อฟังก์ชัน array เลย เช่น:
```python
a = array([[1, 2], [3, 4]])
```
ทั้งหมดนี้น่าจะพอให้สามารถเริ่มต้นเขียนโค้ดด้วย Python เรียกใช้ Library ต่างๆ และประยุกต์นำไปแก้ปัญหาต่างๆ ได้ | https://guopai.github.io | CC-BY 4.0 |
Python ภาษาไทย | # Python ภาษาไทย
Python ภาษาไทย เขียนโดย วรรณพงษ์ ภัททิยไพบูลย์ เอกสารชิ้นนี้เป็นการรวบรวมและสรุปสิ่งที่สำคัญจากเว็บ [https://python3.wannaphong.com/](https://python3.wannaphong.com/)
ผลงานนี้ ใช้[สัญญาอนุญาตของครีเอทีฟคอมมอนส์แบบ แสดงที่มา 4.0 International](http://creativecommons.org/licenses/by/4.0/)
## บทนำ
Python เป็นภาษาเขียนโปรแกรมคอมพิวเตอร์ระดับสูง เป็นหนึ่งในภาษาที่ได้ความนิยมอย่างมากในปัจจุบัน ตั้งแต่วงการไอโอที ปัญญาประดิษฐ์ เว็บ และอื่น ๆ เนื่องจากความยืดหยุ่นของตัวภาษา เขียนได้อย่างรวดเร็ว เชื่อมต่อกับภาษาอื่น ๆ ได้ดี ดังนั้น ผู้เริ่มต้นเขียนโปรแกรม หรือ เขียนโปรแกรมเป็นอยู่แล้ว ควรเรียนรู้และสามารถใช้งานภาษานี้ได้
## บทที่ 1 เริ่มต้นกับ python
Python เป็นภาษาอย่างหนึ่งของคอมพิวเตอร์ มีจุดเด่นคล่อง ๆ ดังนี้
- เป็นภาษาที่มี syntax ที่เรียบง่ายและสะอาด สามารถเรียนรู้ได้ง่าย เข้าใจได้ง่าย
- สนับสนุนการเขียนโปรแกรมแบบ OOP
- ทำงานแบบ interpreter
- dynamic code (ภาษาที่ไม่ต้องกำหนด type ในการประกาศตัวแปร)
Python เวชั่นแรกถูกพัฒนาโดย Guido van Rossum พัฒนาขึ้นมาในปี ค.ศ.1991
ปัจจุบัน Python ได้ถูกพัฒนาโดย Python Software Foundation
ได้เดินทางมาถึง Python 3
## เริ่มต้นกับภาษา Python
เให้ผู้อ่านติดตั้ง Python ดังนี้
- Windows เข้าไปที่ [https://www.python.org/download/](https://www.python.org/download/) ให้เลือกดาวน์โหลด รุ่นในสาย Python 3 แล้วเลือกให้ตรงกับสเปคเครื่อง ตัวอย่างเช่น เครื่องผมใช้ Windows 64 Bit ผมต้องเลือก Python 3.4.1
Windows X86-64 MSI Installer เมื่อรันหน้าต่างติดตั้งขึ้นมา
อย่าลืมเลือก set path ด้วย จะได้ไม่ต้องมาเสียเวลาตั้งค่าภายหลัง
โดยทำอย่างนี้ เริ่มต้นด้วยการรันไฟล์ติดตั้งที่โหลดมา
เสร็จแล้วกด Next ไปเรื่อย ๆ
- Linux สำหรับบน Ubuntu หรือ Linux ในสาย Debian
- Mac OS X เข้าไปที่ [https://www.python.org/download/](https://www.python.org/download/)
เมื่อติดตั้งแล้ว ผู้อ่านสามารถเขียนโปรแกรมภาษา Python ได้เลย
### เครื่องมือที่ใช้ในการเขียนภาษา Python
มีหลายโปรแกรม ผู้อ่านสามารถใช้ IDLE (Python GUI)
ในการเขียนโปรแกรมได้หรือจะใช้โปรแกรมอย่าง Notepad++ หรือ text editor
ต่าง ๆ และ IDLE ในการเขียนได โดยบันทึกไฟล์เป็นนามสกุล .py
นอกจากนี้ เราขอแนะนำ PyCharm เป็น IDLE ที่น่าใช้งาน โหลดฟรีได้ที่ [http://www.jetbrains.com/pycharm/](http://www.jetbrains.com/pycharm/) เลือกรุ่นที่เป็น Community Edition
**โปรแกรมแรก Hello world.py**
**โค้ด**
```python
print ("Hello world")
# ผลลัพธ์: Hello world
```
## บทที่ 2 ชนิดข้อมูลพื้นฐาน
ข้อมูล คือ ข้อเท็จจริง นี้คงเป็นกฎที่หลาย ๆ ท่านคงเคยศึกษามา
บทนี้จะกล่าวถึงเรื่อง ชนิดของข้อมูลพื้นฐาน
ซึ่งเป็นสิ่งสำคัญที่ทุกท่านต้องรู้ก่อนเขียนโปรแกรมในภาษา Python
ใน Python มีชนิดข้อมูลหลายประเภท มีชนิดข้อมูลธรรมดาเพียง 3 ชนิด ได้แก่
1. จำนวนเต็ม (Integer)
2. จำนวนจริง (Float)
3. สายอักขระ หรือ สตริง (String)
ข้อมูลแบบซับซ้อนอีก 2 ชนิดดังนี้
1. รายการ หรือ ลิสต์ (List)
2. พจนานุกรม หรือ ดิกชันนารี (Dictionary)
ข้อมูลซับซ้อนนี้หมายถึง ข้อมูลนี้ประกอบไปด้วยข้อมูลอื่นที่อยู่ภายในแล้วแต่การใช้งาน ถ้าแบ่งเป็นประเภทใหญ่ ๆ จะได้ดังนี้
1. ตรรกกะ
2. ตัวเลข
3. ลำดับ มีให้เลือกนำไปใช้งาน 3 ชนิด ดังนี้
1. สายอักขระ หรือ สตริง (String)
2. ทูเปิ้ล (Tuple)
3. รายการ หรือ ลิสต์ (List)
4. จับคู่ (Mapping)
### List ใน Python
ในภาษา Python ไม่มีข้อมูลชนิดอาร์เรย์ (array) เหมือนกับภาษาอื่น
แต่สามารถใช้ข้อมูลชนิดลิสต์แทนอาร์เรย์ได้ โดยชื่อชนิดลิสต์ คือ list
ข้อมูลชนิดนี้จะเรียงต่อกันในลิสต์ของตัวแปรและคั่นข้อมูลด้วยเครื่องหมาย , ครอบด้วยเครื่องหมาย square brackets [" และ "]
มีลักษณะดังนี้
```python
[1,2,3,4,5,6]
```
สามารถดึงข้อมูลจากลิสต์มาใช้งานได้ดังนี้
```python
a = [1,2,3,4,5,6]
print(a[2]) # output: 3
```
และ
```python
b = [[1, 2], [3, 4]]
print(b[0][0]) # output: 1
```
**การดำเนินการลิสต์**
- len() เป็นคำสั่งนับจำนวนสมาชิกในลิสต์
- list+list เป็นคำสั่งรวมสมาชิกของลิสต์ตัวอย่างเช่น`[1, 2] + [3, 4]`ผลลัพธ์`[1, 2, 3, 4]`
- เช็คสมาชิกในลิสต์ เช่น`3 in [1, 2, 3]`ผลลัพธ์`True`
- เพิ่มข้อมูลเข้าไปยังข้อมูลชนิด List
ใช้คำสั่ง
```python
list.append(วัตถุ)
```
- Iteration เป็นการแยกข้อมูลออกมาจากลิสต์ เช่น`for x in [1, 2, 3]: print (x),`ผลลัพธ์`1 2 3`
- คำสั่ง insert(x,y)
เป็นคำสั่งสำหรับเพิ่มข้อมูลเข้าไปแซงข้อมูลในตำแหน่งนั้น โดย x เป็น
ตำแหน่ง index และ y เป็นข้อมูลที่ต้องการแทนที่
**ตัวอย่าง**
```python
a= [1,2,3,4,5]a.insert(1,"hi")
print(a)
```
ผลลัพธ์
```python
[1, 'hi', 2, 3, 4, 5]
```
### อาร์เรย์ (array) เบื้องต้นใน Python
อาร์เรย์ (array) เป็นข้อมูลชนิดหนึ่ง เป็นโครงสร้างข้อมูล แต่ว่า Python ไม่สนับสนุนอาร์เรย์ชนิดนี้โดยตรง จึงต้องใช้ชนิดข้อมูลที่เรียกว่ารายการ ซึ่งเกือบเหมือนกับอาร์เรย์ แต่สามารถเข้าถึงได้เพียงหนึ่งดัชนี
**อาร์เรย์ 1 มิติ**
ใน Python จะมีรูปแบบดังนี้ [1,2,3,4,5,6]
```python
a = [1,2,3,4,5,6]
print(a[2])
```
จะได้ผลลัพธ์ คือ 3 จะเห็นได้ว่าใน python จะนับอาร์เรย์ตัวที่ 1 เป็น 0 ไล่ไปเรื่อย ๆ
หากต้องการจำนวน 3 ถึง 5 ใช้คำสั่ง
```python
print(a[2:5])
```
ผลลัพธ์จะได้ [3, 4, 5]
ถ้าต้องการค่าข้อมูลบนอาร์เรย์ ตามตำแหน่งคอลัมน์
```python
print(a[5:])
```
จะได้ผลลัพธ์ [6]
ต่อมาเราจะเปลี่ยนค่าข้อมูลในอาร์เรย์กัน
เช่น a[5] จากเดิมเป็น [6] หากใช้คำสั่ง
```python
>>a[5] = 11
>>print(a[5:])
[11]
```
จะเห็นได้ว่าข้อมูลใหม่จะทับข้อมูลเก่า ข้อมูลเก่าจะหายไปเป็นไปตามหลักการเก็บข้อมูลของคอมพิวเตอร์
หากใช้คำสั่ง print(a[:]) คือแสดงอาร์เรย์ทั้งหมดออกมา
```python
>>> print(a[:])
[1, 2, 3, 4, 5, 11]
```
**อาร์เรย์ 2 มิติ**
อาร์เรย์ 2 มิติมีการจัดเรียงข้อมูลในแถว / คอลัมน์ สามารถเปรียบเทียบได้กับเมทริกซ์ในคณิตศาสตร์
ใน Python อาร์เรย์ 2 มิติ จะมีรูปแบบเป็น [[1, 2], [3, 4]]
```python
b = [[1, 2], [3, 4]]
```
ถ้าเป็นรูปแบบเมทริกซ์ในคณิตศาสตร์จะเป็น
b = [1, 2]
[3, 4]
หากต้องการดึงข้อมูลมาใช้จากอาร์เรย์ 2 มิติ ใช้คำสั่งดังนี้ เช่น
```python
>>> b = [[1, 2], [3, 4]]
>>> print(b[0][0])
1
```
แถวที่ 1 หลักที่ 1 คือ 1
```python
>>> print(b[0][1])
2
```
แถวที่ 1 หลักที่ 2 คือ 2
```python
>>> print(b[1][0])
3
```
แถวที่ 2 หลักที่ 1 คือ 3
```python
>>> print(b[1][1])
4
```
แถวที่ 2 หลักที่ 2 คือ 4
หากต้องการแสดงทั้งแถวและคอลัมน์ใช้คำสั่ง
```python
>>> print(b[0:][0:])
[[1, 2], [3, 4]]
```
หากต้องการเฉพาะแถวที่ 1 ใช้คำสั่ง
```python
>>> print(b[0][0:])
[1, 2]
```
**อาร์เรย์ 3 มิติ**
มีลักษณะการใช้งานเหมือนกับที่ผ่านมา แต่มีอาร์เรย์เพิ่มอีกมิติ ตัวอย่างเช่น
[[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
[[19, 20, 21], [22, 23, 24], [25, 26, 27]]]
การนำไปใช้งาน
```python
>>> d = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
[[19, 20, 21], [22, 23, 24], [25, 26, 27]]]
>>> d[0][1]
[4, 5, 6]
>>> d[0][1][2]
6
```
หากต้องการคำนวณมากกว่านั้น แนะนำให้ใช้โมดูล [numpy](http://www.numpy.org/) แทนดีกว่า
### การดำเนินการแบบตรรกะ (Boolean Operations) ใน Python 3
การดำเนินการแบบตรรกะ (Boolean Operations) ใน Python 3 โดยใช้ตรรกะศาสตร์เข้ามา โดยการใช้หลักเหตุและผล ผลลัพธ์ที่ได้จะได้ จริง
(True) และ เท็จ (False)
หากผู้อ่านเคยเรียนวิชาตรรกะศาสตร์มาจะเข้าใจบทความนี้ยิ่งขึ้น
**การเปรียบเทียบประพจน์**
จริง และ จริง ได้ จริง ที่เหลือเท็จ
เท็จ หรือ เท็จ ได้ เท็จ ที่เหลือจริง
ถ้า จริง แล้ว เท็จ ได้ เท็จ ที่หลือจริง
จริง ก็ต่อเมื่อ จริง , เท็จ ก็ต่อเมื่อ เท็จ ได้ จริง ที่เหลือเท็จ
**การดำเนินการแบบตรรกะใน Python 3**
| การดำเนินการ | ความหมาย | ผลลัพธ์ |
| --- | --- | --- |
| x or y | x หรือ y | ถ้า x = True , y = True ดังนั้น x หรือ y ได้จริง (True) |
| x and y | x และ y | ถ้า x = False , y = True ดังนั้น x และ y ได้เท็จ (False) |
| not x == y | ถ้า x แล้ว y | ถ้า x = True , y = False ดังนั้น ถ้า x แล้ว y ได้จริง (True) |
### ทูเพิล (Tuple) ใน Python
ทูเพิล (Tuple) คือ โครงสร้างข้อมูลแบบเรียงลำดับ (List) ที่ไม่สามารถแก้ไขข้อมูลที่อยู่ใน
tuple ได้ ตัวอย่างทูเพิล(Tuple)
```python
Tuple1 = (5,4,3)
print (Tuple1)
```
**ผลลัพธ์**
`(5,4,3)`
**เมื่อเปรียบเทียบความแตกต่างระหว่างทูเพิล(Tuple) กับแบบเรียงลำดับ (List)ตัวอย่าง** เช่น
กรณี List
```python
List1 = [5,4,3]
List1.append(2)
print (List1)
```
**ผลลัพธ์**
`>>[5, 4, 3, 2]`
กรณี **Tuple**
```python
Tuple1 = (5,4,3)
print (Tuple1)
```
**ผลลัพธ์**
`>>(5,4,3)`
หากต้องการเพิ่มข้อมูลเข้าไปใน Tuple
```python
Tuple2 = (5,4,3)
Tuple2.append(2)
print (Tuple2)
```
**ผลลัพธ์**
```python
>>> Tuple2 = (5,4,3)
>>> Tuple2.append(2)
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
Tuple2.append(2)
AttributeError: 'tuple' object has no attribute 'append'
```
จะพบว่าเราไม่สามารถใช้ append เพิ่ม 2 เข้าไปใน Tuple ได้
นี่คือข้อแตกต่างระหว่างข้อมูลแบบเรียงลำดับ (List) กับทูเพิล (Tuple)
### ตัวแปรข้อมูล Dictionary ใน Python
Dictionary เป็นอาเรย์ที่สามารถใช้สตริงเป็นคีย์ (key) ในการเข้าถึงข้อมูลได้ โดยปกติอาเรย์จะมีคีย์เป็นจำนวนเต็มนับตั้งแต่ 0 ถึง n-1
โดยชนิดข้อมูลประเภทจับคู่ ใน Python จะครอบเริ่มด้วย { และลงท้ายด้วย } ตามนี้
> {'ก':1,'ข':2,'ค':3}
>
หมายความว่าในดิกชั่นนารีนี้ มีค่า 3 ค่า คือ 1,2 และ 3 และมีคีย์ 3 คีย์คือ 'ก','ข' และ 'ค'
ในการเรียกใช้งานข้อมูลในดิกชั่นนารี สามารถทำได้โดยการอ้างอิงคีย์ใน [คีย์] เช่น
```python
>>> {'ก':1,'ข':2,'ค':3}['ข']
2
```
สรุปตัวแปร Dictionary ใน Python คืออะไร?
> Dictionary คือตัวแปรข้อมูลประเภท key, value
>
มีรูปแบบดังนี้
> {key:value}
>
ตัวอย่างเช่น
```python
>>> money = {'Art':'250', 'Mark':'549'}
>>> money
{'Mark': '549', 'Art': '250'}
>>> money['Mark']
'549'
>>> money['Art']
'250'
```
โดยสร้างตัวแปร money เก็บจำนวนเงินของ Art และ Mark โดยใน {'Art':'250', 'Mark':'549'} ข้างหน้า : คือ Key ข้างหลัง : คือ value
บรรทัดที่ 4 ต่อมา เราได้สั่ง money['Mark'] คือ ให้แสดงค่าของคีย์ Mark ที่เก็บอยู่ในตัวแปร money
นอกจากนั้นเรายังสามารถสร้างตัวแปรข้อมูล Dictionary ด้วยคำสั่ง dict() ได้ดังนี้
```python
>>> name = dict(name='Mark', age=18)
>>> name
{'name': 'Mark', 'age': 18}
```
และนอกจากกำหนดค่าแล้วเราสามารถเพิ่มค่าเข้าไปยัง Dictionary ได้ดังนี้
```python
>>> buy = {} #ข้างในนี้ Dictionary ว่างเปล่า
>>> buy['Mark'] = '70' #เพิ่มคีย์ Mark และค่า 70 เข้าไปยัง buy
>>> buy['Art'] = '36' #เพิ่มคีย์ Art และค่า 36 เข้าไปยัง buy
>>> buy
{'Mark': '70', 'Art': '36'}
```
ต่อไปเราจะมาลองทำ Dictionary ซ้อนในค่าของคีย์ใน Dictionary
```python
>>> money = {'Art':'250', 'Mark':'549'}
>>> money['Pop'] = {'buy':123} #สร้างคีย์ Pop ขึ้นมาแล้วเก็บค่า {'buy':123} เข้าไป
>>> money
{'Pop': {'buy': 123}, 'Mark': '549', 'Art': '250'}
>>> money['Pop'] #แสดงค่าข้อมูลในคีย์ Pop
{'buy': 123}
>>> money['Pop']['buy'] #แสดงค่าข้อมูลคีย์ buy ในคีย์ Pop
123
```
**คำสั่งกับตัวแปรข้อมูล Dictionary ใน Python**
**คำสั่ง dict.keys(), dict.values(), dict.items()**
- คำสั่ง **dict.keys()** เป็นคำสั่งสำหรับดึงคีย์ทั้งหมดใน Dictionary ออกมา
- คำสั่ง **dict.values()** เป็นคำสั่งสำหรับดึงค่าในคีย์ทั้งหมดใน Dictionary ออกมา
- คำสั่ง **dict.items()** เป็นคำสั่งสำหรับดึงทั้งค่าและคีย์ทั้งหมดใน Dictionary ออกมา
```python
>>> money = {'Art':'250', 'Mark':'549'}
>>> list(money.keys())
['Mark', 'Art']
>>> list(money.values())
['549', '250']
>>> list(money.items())
[('Mark', '549'), ('Art', '250')]
```
**คำสั่ง dict.get()**
เป็นคำสั่งสำหรับรับค่าในคีย์ของ Dictionary ที่ต้องการ ตัวอย่างเช่น
```python
>>> money = {'Art':'250', 'Mark':'549'}
>>> print(money.get('Art'))
250
>>> print(money.get('Mark'))
549
```
**คำสั่ง dict.update()**
เป็นคำสั่งสำหรับใช้เปลี่ยนแปลงค่าข้อมูลในคีย์ของ Dictionary ที่ต้องการ ตัวอย่างเช่น
```python
>>> money = {'Art':'250', 'Mark':'549'}
>>> money2 = {'Ploy':300} #สร้าง Dictionary
>>> money.update(money2) #เพิ่ม Dictionary ของ money2 เข้าไปยัง Dictionary ของ money
>>> money
{'Mark': '549', 'Art': '250', 'Ploy': 300}
>>> money.update({'Art':115}) #ปรับเปลี่ยนค่าข้อมูลของคีย์ Art ใน Dictionary ของ money
>>> money
{'Mark': '549', 'Art': 115, 'Ploy': 300}
```
**คำสั่ง dict.pop()**
เป็นคำสั่งสำหรับดึงค่าข้อมูลในคีย์ที่ต้องการออกแล้ว ให้ลบคีย์นั้นทิ้งใน Dictionary นั้น ตัวอย่างเช่น
```python
>>> money = {'Mark': '549', 'Art': '115', 'Ploy': 300}
>>> money.pop('Art')
115
>>> money
{'Mark': '549', 'Ploy': 300}
```
**คำสั่ง dict.fromkeys()**
ถ้าต้องการให้ค่าสำหรับแต่ละคีย์เหมือนกัน เราสามารถใช้ fromkeys() เพื่อ Dictionary ด้วยคีย์เดียวกันได้ ตัวอย่างเช่น
```python
>>> a = {}
>>> a.fromkeys(['1','2','3','4'],'Cat')
{'1': 'Cat', '4': 'Cat', '2': 'Cat', '3': 'Cat'}
```
**คำสั่ง dict.clear()**
เป็นคำสั่งสำหรับล้างข้อมูลทั้งหมดใน Dictionary ตัวอย่างเช่น
```python
>>> money = {'Mark': '549', 'Art': '115', 'Ploy': 300}
>>> money.clear()
>>> money
{}
```
### Byte Array ในภาษาไพทอน Python 3
ในภาษาไพทอนจะมีข้อมูลชนิดหนึ่ง คือ ข้อมูลไบต์ (Byte) เป็น bytes-like
object (วัตถุที่เหมือนกับไบต์)
โดยในภาษาไพทอนจะมีสัญลักษณ์บ่งบอกขนิดข้อมูลนี้ b''
**ตัวอย่างเช่น**
```python
a = b'Hello'
print(a)
print(type(a)
```
ผลลัพธ์
```
b'Hello'
<class 'bytes'>
```
มาเริ่มคำสั่ง Byte Array ในภาษาไพทอน 3 กัน
**คำสั่ง**
```python
bytearray([source[, encoding[, errors]]])
```
เป็นคลาสลำดับเปลี่ยนแปลงได้ของจำนวนเต็มในช่วง 0 < = x < 256
สามารถสร้าง bytearray ได้จากข้อมูลชนิด list หรือไบต์ได้ดังนี้
```python
>>> # ข้อมูลไบต์
>>> b = bytearray(b"Hello World")
>>> b.split()
[bytearray(b'Hello'), bytearray(b'World')]
>>> b[:5]
b"It"
>>> b
bytearray(b'It World')
>>> # ข้อมูล list
>>> key1 = [1,2,3]
>>> key2 = bytearray(key1)
>>> key2
bytearray(b'\x01\x02\x03')
```
รับค่าขนาดไบต์ได้โดยอ้าอิงข้อมูลในข้อมูลชนิดไบต์ :
```python
>>> b = bytearray(b"Hello World")
>>> b[:1]
bytearray(b'H')
>>> b[1]
101
>>> b[:0]
bytearray(b'')
>>> b[0]
72
>>> #ลูปจำนวนไบต์ทั้งหมดออกมา
>>> for c in b: print(c)
...
72
101
108
108
111
32
87
111
114
108
100
>>>
>>> for c in key2: print(c)
...
1
2
3
```
อ่านเอกสารเพิ่มเติมได้ที่ [https://docs.python.org/3/library/functions.html#bytearray](https://docs.python.org/3/library/functions.html#bytearray)
## บทที่ 3 การแสดงผลข้อมูลใน Python 3
การแสดงผลข้อมูลถือเป็นสิ่งสำคัญเพื่อให้รู้ผลลัพธ์จากการประมวลผลของคอมพิวเตอร์
ถ้าไม่มีการแสดงผลการทำงานของโปรแกรม
การที่เขียนโปรแกรมนั้นจะไม่มีประโยชน์อะไรเลย
เพราะไม่สามารถนำข้อมูลไปใช้งานได้
### รูปแบบการแสดงผลข้อมูลใน Python 3
> print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
>
- objects คือ วัตถุ
- sep คือ การแยก
- end คือ การขึ้นบรรทัดใหม่
### ตัวแทนชนิดของข้อมูล
%s - สตริง เช่น ข้อความ
%d - จำนวนเต็ม
%f - เลขทศนิยม
%.<number of digits>f - เลขทศนิยมมีจำนวนคงตัวเลขทางด้านขวาของจุดทศนิยม
%x/%X - จำนวนเต็มใน hex แทน (พิมพ์เล็ก/ใหญ่)
### **ตัวอย่างการแสดงผลข้อมูลใน Python 3**
**ตัวอย่างที่ 1**
```python
print("Hello World")
```
**ผลลัพธ์**
> Hello World
>
อธิบาย
ตัวอย่างนี้แสดงข้อความที่กำหนดออกมาทางจอภาพเท่านั้น ไม่มีการแสดงข้อมูลอื่นเพิ่มเติม
**ตัวอย่างที่ 2**
```python
print ("1+1 = %d" % (2))
```
**ผลลัพธ์**
> 1+1 = 2
>
อธิบาย
ในตัวอย่างนี้มีการใช้ String Formatting
ในแบบข้อความผสมกับตัวแทนชนิดข้อมูล มีการรับค่าคงที่เข้า คือ 2
เข้ามาแทนที่ตัวแทนชนิดข้อมูลในประโยค
**ตัวอย่างที่ 3**
```python
num = 100
print ("%d/2" % (num))
```
**ผลลัพธ์**
> 100/2
>
อธิบาย
ในตัวอย่างนี้มีการใช้ String Formatting ในแบบข้อความผสมกับตัวแทนชนิดข้อมูล โดยมีการเรียกใช้ตัวแปรเข้ามาแทนที่ตัวแทนชนิดข้อมูล
**ตัวอย่างที่ 4**
```python
print ("Are you ok?","\n")
```
**ผลลัพธ์**
> Are you ok?
>
อธิบาย
ในตัวอย่างนี้แสดงข้อความที่กำหนดออกมาทางจอภาพเท่านั้น และขึ้นบรรทัดใหม่โดยใช้ \n
### หากเราต้องการแสดงข้อมูลซ้ำ
print (ข้อความหรือตัวแปร*จำนวนที่ต้องการแสดงซ้ำ)
**ตัวอย่างเช่น**
```python
print ("Hello, World!"*5)
```
**ผลลัพธ์**
>>> print ("Hello, World!"*5)
Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!
## บทที่ 4 Decimal Python
เรามาเรียนรู้การใช้ Decimal หรือเลขทศนิยมใน Python กัน
สิ่งหนึ่งที่โปรแกรมเมอร์รู้กันนั้นก็คือคอมพิวเตอร์ใช้เลขฐานสองเป็นภาษาเครื่อง
คือ 0 และ 1 ไม่ได้ใช้เลขฐานสิบดังที่มนุษย์ ทำให้การใช้ Decimal
หรือเลขทศนิยมในเลขฐานสอง จะไม่ตรงกับเลขทศนิยมในเลขฐานสิบได้
หากเราเขียนโปรแกรมเปรีบเทียบเช่น
```python
>>> print (0.05 + 0.05 == 0.1)
True
```
จะเห็นได้ว่าได้ผลลัพธ์ที่ต้องการในระดับหนึ่ง แต่ถ้าเราเขียนโปรแกรมที่มีการทำงานวนซ้ำกันจำนวนหลาย ๆ ครั้งมาก ๆ กับเลขทศนิยม เช่น
```python
>>> aa = 0.0
>>> for i in range(1000):
aa += 0.0001
print(repr(aa))
0.0001
0.0002
0.00030000000000000003
...
0.09980000000000183
0.09990000000000183
0.10000000000000184
>>> print (aa == 1.0)
False
```
จะเห็นได้ว่าโปรแกรมทำงานไม่ได้ผลลัพธ์ตามที่เราต้องการและออกแบบไว้
หากเราต้องการให้ทำงานเพื่อให้ได้ผลลัพธ์ที่ต้องการ เราต้องทำตามเอกสาร
[PEP-327](https://www.python.org/dev/peps/pep-0327/)
เป็นสเปคของเลขทศนิยมฐานสิบใน Python ทำให้ได้ผลลัพธ์ที่ถูกต้องกว่า อย่าลืม from decimal import Decimal กัน เช่น
```python
>>> from decimal import Decimal
>>> b = Decimal("0.0")
>>> for i in range(1000):
b += Decimal("0.001")
print(repr(b))
Decimal('0.001')
...
Decimal('1.000')
>>> print(b == Decimal("1.0"))
True
```
อ่านรายละเอียดเพิ่มเติมได้ที่
[https://docs.python.org/3/library/decimal.html](https://docs.python.org/3/library/decimal.html)
## บทที่ 5 การใช้งาน range ใน Python
range เป็นคำสั่งสำหรับมีไว้ในการลำดับจำนวนตัวเลข เช่น แสดงตัวเลข 0 - 3
หรือแบบก้าวกระโดด 3,6,9 มีทั้งไปทาง + และ - ตามระบบเส้นจำนวนจริง
มีหลักในการใช้งานหลักน
```python
range(เริ่ม,จบ, การเพิ่มขึ้น)
```
**ตัวอย่างการใช้งาน range ใน Python**
```python
>>> list(range(3))
[0, 1, 2]
```
```python
>>> list(range(0,10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```
```python
>>> list(range(-3,9))
[-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]
```
```python
>>> list(range(0, 20, 2))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
```
**การนำไปใช้กับการลูป**
สมมุติว่า มีโจทย์โปรแกรมให้เขียนโปรแกรมโดยใช้ for การลูปใน Python โดยไล่ตามนี้
1
22
333
4444
55555
โค้ดตัวอย่าง
```python
>>> for i in range(1, 6): #กำหนดให้ตัวแปร i แทน range(1, 6) หมายถึงช่วงของตัวเลข 1 - 6
print(str(i) * i + "\n")
1
22
333
4444
55555
```
## บทที่ 6 แยกข้อความด้วย split ใน Python 3
การเขียนโปรแกรม เมื่อเรารับค่าข้อมูลมา โดยที่เราได้ทำกำหนดเครื่องหมายแยกข้อความ เช่น , - เป็นต้น
เมื่อต้องการแสดง หากต้องการแแสดงตัวแปรที่รับข้อมูลมาโดยมีการแยกข้อความมาแล้ว ใน Python เราต้องใช้ split
มีหลักการใช้งานดังนี้
```python
ตัวแปร.split("เครื่องหมายแยกข้อความที่กำหนด")
```
**ตัวอย่าง**
```python
a = u'สวัสดีปีใหม่ ขอให้มีแต่ความสุขกันนะครับ'
a.split(" ")
```
ผลลัพธ์
```python
a = u'สวัสดีปีใหม่ ขอให้มีแต่ความสุขกันนะครับ'
>>> a.split(" ")
['สวัสดีปีใหม่', 'ขอให้มีแต่ความสุขกันนะครับ']
```
**ตัวอย่าง**
```python
b = "แมว,คน,นก"
b.split(",")
```
ผลลัพธ์
```python
>>> b = "แมว,คน,นก"
>>> b.split(",")
['แมว', 'คน', 'นก']
```
## บทที่ 7 Input การรับค่าข้อมูลจากคีย์บอร์ดใน Python
การรับค่าข้อมูล (Input) จากคีย์บอร์ดใน Python เป็นเรื่องพื้นฐานที่นักพัฒนาโปรแกรมไม่ว่าภาษาไหนก็ต้องเรียนรู้ด้วย
เมื่อตอน Python 2 มีคำสั่งรับค่าข้อมูลจากคีย์บอร์ดด้วยคำสั่ง
**raw_input()**
แต่ใน Python 3 ปัจจุบันนี้ได้มีการเปลี่ยนแปลงคำสั่งนิดหน่อยจาก
***raw_input()***
เป็น
***input()***
หากผู้อ่านเคยใช้ Python 2 เปลี่ยนมาใช้ Python 3 สามารถนำมาใช้งานง่าย ๆ แค่แก้ไขโค้ดนิดหน่อยสำหรับคำสั่งดังกล่าว
**การรับค่า String ข้อความ ใน Python 3**
ใช้ input() โดยมีรูปแบบการใช้งานดังน
```python
text = input("Enter some text ")
```
**การรับค่าตัวเลขจำนวนเต็มใน Python 3**
ต้องใช้
**int**
มาใช้งานกับ
**input()**
เพื่อกำหนดให้รับค่าข้อมูลได้เฉพาะที่เป็นจำนวนเต็ม (-1 , 0 , 1) โดยใช้คำสั่ง
**int(input())**
โดยมีรูปแบบการใช้งานดังนี้
```python
number = int(input("Enter a integer: "))
```
**การรับค่าเลขทศนิยมใน Python 3**
ต้องใช้
**float**
มาใช้งานกับ
**input()**
เพื่อกำหนดให้รับค่าข้อมูลที่เป็นเลขทศนิยมได้ (-1.84 , 0.96 , 1.78) โดยใช้คำสั่ง
**float(input())**
โดยมีรูปแบบการใช้งานดังนี้
```python
floating = float(input("Enter a floating point number: "))
```
กรณีที่เขียนโปรแกรมโดยใช้คำสั่ง input() ไปแล้วต้องการแปลงค่าข้อมูลที่รับมาเป็นตัวเลขเพื่อนำไปคำนวณ เช่น
```python
number = input("Enter some text ") #กำหนดตัวแปร number ให้รับค่าข้อมูล
anumber = float(number) #เปลี่ยนข้อมูลที่รับมาในตัวแปร number ให้สามารถแปลงเป็น เลขทศนิยม
#เพื่อนำไปคำนวณได้ หากต้องการกำหนดให้เป็นจำนวณเต็มแค่เปลี่ยน float เป็น int
```
## บทที่ 8 การรับค่าตัวแปรและแสดงค่าตัวแปรใน Python 3
ทำไมต้องมีตัวแปร บทนิยมของตัวแปร คือ ลักษณะของข้อมูลที่เปลี่ยนแปลงได้ แสดงโดยใช้สัญลักษณ์ เช่น ตัวแปร X , Y ในเรื่องกราฟแกน X , Y ทางคณิตศาสตร์ เป็นต้น
ตัวแปรทำให้มีความง่ายต่อการเรียกใช้งานข้อมูล ถ้าจะเปรียบเทียบ ขอเปรียบเทียบแบบง่าย ๆ ตัวแปรก็เหมือนกับช่องว่างในกรอกข้อมูลในเอกสารต่าง ๆ
**กฎการตั้งชื่อตัวแปรใน Python 3**
- ห้ามตั้งชื่อตัวแปรให้ตรงกับคีย์เวิร์ดของ Python 3 โดยมีคีย์เวิร์ด ดังนี้ False class finally is return None continue for lambda try True def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise แต่สามารถใช้ตัวพิมพ์ใหญ่ได้
- ห้ามใช้ตัวพิมพ์เล็ก
- ห้ามใช้อักษระสัญลักษณ์ เช่น / * - + # ! - % $ เป็นต้น
- ห้ามใช้ตัวเลข
- ไม่เว้นว่าง
**รูปแบบการรับค่าตัวแปรใน Python 3**
จะเป็นตัวเลขหรือข้อความก็ได้
> ตัวแปร = input()
>
ตัวอย่างในรูปแแบบข้อความ เช่น
> name = input("What is your name? ")
แล้วรันจะได้ผลลัพท์ มีให้กรอกข้อความ
What is your name?
>
สมมุติให้ผมกรอกว่า tonatn
What is your name? tontan
ตัวอย่างในรูปแบบตัวเลข
> a = int(input("input1: "))
>
**การแสดงค่าหรือดึงค่าจากตัวแปรมาใช้งานใน Python 3**
> ตัวแปร
>
ตัวอย่างเช่น
> name
>
ก็จะแสดงผลลัพท์ค่าตัวแปร
'tontan'
หรือ print name
ก็แสดงค่าตัวแปรเช่นกัน
**ตัวอย่างการเขียนโปรแกรมใน Python 3 โดยใช้ตัวแปรรวมด้วยโปรแกรมบวกเลข**
```python
a = int(input("input1: "))
input1: 1
b = int(input("input1: "))
input1: 3
print ("=" , a + b)
= 4
```
## บทที่ 9 คำสั่งเงื่อนไข if else ใน Python 3
บทความนี้จะพูดถึงเรื่อง คำสั่งเงื่อนไข if else ใน Python 3 กัน
**คำสั่งเงื่อนไข if**
นี้ใช้ในการเปรียบเทียบเงื่อนไขว่าตรงตามที่ต้องการหรือไม่
**คำสั่ง elif**
ถ้าไม่ให้ทำการเปรียบเทียบต่อไป
**คำสั่ง else**
จนหมดเงื่อนไขที่จะเปรียบเทียบแล้วให้ทำตามคำสั่ง else
รูปแบบการใช้คำสั่งเงื่อนไข if else ใน Python 3
```python
if เงื่อนไข:
คำสั่ง
elif เงื่อนไข:
คำสั่ง
else:
คำสั่ง
```
**อธิบายรูปแบบการใช้คำสั่งเงื่อนไข if else ใน Python 3**
เมื่อกำหนดเงื่อนไข if แล้ว ถ้าโปรแกรมที่สร้างนั้น
ต้องใช้เงื่อนไขหลายเงื่อนไขในการเปรียบเทียบ elif
โดยเปรียบเทียบเงื่อนไขไปเรื่อย ๆ จนกว่าเงื่อนไขไหนจะเป็นจริงจนสุดท้าย
ถ้าเงื่อนไขทั้งหมดเป็นเท็จ ให้ทำตามคำสั่งในเงื่อนไข else
**ตัวอย่างการนำคำสั่งเงื่อนไข if else ไปใช้ในการเขียนโปรแกรมบน Python 3**
**ตัวอย่าง**
โปรแกรมตรวจสอบตัวเลขว่าน้อยกว่ามากกว่าหรือเท่ากับ 0
**หลักการโปรแกรม**
รับค่าตัวเลขเข้ามาแล้วเอามาแทนตัวแปร x ให้ตัวแปร y = 0 เช็คว่า น้อยกว่ามากกว่าหรือเท่ากับ 0
**โค้ด:**
```python
y = 0
x = int(input("input: "))
if x == y:
print ("=" , y)
elif x < y:
print ("<" , y)
elif x > y:
print (">" , y)
else:
print ("No, It isn't num.")
```
## บทที่ 10 ฟักชั่นทางคณิตศาสตร์เบี้องต้นใน Python 3
ฟักชั่นคณิตศาสตร์ถือเป็นสิ่งที่ขาดไม่ได้ในภาษาคอมพิวเตอร์ ฟักชั่นทางคณิตศาสตร์พื้นฐานก็จะมี + - * / เพื่อไม่เป็นการเสียมาเริ่มเนื้อหากันเลย
**ฟักชั่นพื้นฐาน + - * / ** (บวก ลบ คูณ หาร ยกกำลัง) ใน Python 3**
รูปแบบการใช้ ฟักชั่นพื้นฐาน + - * / ง่าย ๆ ดังนี้
บวก
> 2 + 2
4
ลบ
50 - 5
45
คูณ
2 * 3
6
หาร
8 / 5
1.6
>
แบบเงื่อนไข
> (2 + 2) * 5
20
>
การยกกำลังใน Python 3
> 2 ** 4
16
>
ตัวอย่างการใช้ฟักชั่นทางคณิตศาสตร์โดยอ้างอิงตัวแปรใน Python 3
> a = 4
b = 3
(a + b) / a
1.75
>
อีกตัวอย่างหนึ่ง ใช้ฟักชั่นทางคณิตศาสตร์เบี้องต้นในรูปแบบสมการ
> x = 3 + 4a
y = 2 - 3a
z = x + y
print(z)
(5+1a)
>
## บทที่ 11 คำสั่งการวงรอบ Loop หรือคำสั่งทำซ้ำ
การเขียนโปรแกรมในบางกรณีโปรแกรมที่เขียนต้องทำงานอย่างหนึ่ง ๆ ซ้ำกันหลาย ๆ ครั้ง เราต้องใช้การวงรอบ Loop ในการโปรแกรม
บทนี้จะนำเสนอการใช้คำสั่งการวงรอบ Loop ขอเรียกว่า คำสั่งทำซ้ำ
คำสั่งการวงรอบ Loop มีดังนี้
- for
- while
คำสั่งทำซ้ำ for ใน Python 3
**รูปแบบ**
```python
for ตัวแปร in ลำดับขอบเขต :
คำสั่ง
```
**ตัวอย่างที่ 1**
```python
for c in 'word':
print( c )
```
**ผลลัพธ์**
```python
w
o
r
d
```
**อธิบาย**
กำหนดให้ตัวแปร c มีลำดับอยู่ใน word
(ถ้าเอาตามหลักคณิตศาสตร์ คือ เซต C มีสมาชิกเป็น w , o , r ,
d)แล้วแสดงสมาชิกที่อยู่ในขอบเขตนั้นออกมา
**ตัวอย่างที่ 2**
```python
for count in range(1, 11):
print(count)
```
**ผลลัพธ์**
```python
1
2
3
4
5
6
7
8
9
10
```
**อธิบาย**
กำหนดให้ตัวแปร count มีลำดับในเงื่อนไข(1, 11) คือ ไล่ตัวเลขจาก 1 ถึง 10 ไม่เอา 11
**ตัวอย่างที่ 3**
```python
for x in range(3):
print (x)
else:
print ('Final x = %d' % (x))
```
**ผลลัพธ์**
```python
0
1
2
Final x = 2
```
**อธิบาย**
กำหนดให้ x มีลำดับใน range(3) แล้วแสดงลำดับออกมา ต่อมาใช้ else แสดงลำดับสุดท้ายออกมา นั้นคือ 2
**ตัวอย่างที่ 4**
```python
list_of_lists = [["1, 2, 3"], ["4, 5, 6"], ["7, 8, 9"]]
for i in list_of_lists: # loop รายการละ 1 รายการ
for x in i: # loop รายการที่อยู่ในภายใน i ทีละ 1
print (x) # แสดงผลรายการแต่ละอันที่อยู่ในรายการย่อยของรายการ i
```
**ผลลัพธ์**
```python
1, 2, 3
4, 5, 6
7, 8, 9
```
**อธิบาย**
list อยู่ในลำดับของ list_of_lists แล้ว x อยู่ในลำดับของ list ให้แสดงลำดับนั้นออกมา
**คำสั่งทำซ้ำ While ใน Python 3**
คำสั่งทำซ้ำ While ใน Python
มีลักษณะการใช้เหมือนกันแต่จนกว่าเงื่อนไขที่กำหนดจะพบกัน เพราะการวนรอบใน
Python เพื่อให้มีประสิทธิภาพ While จึงนำมาใช้จำนวนน้อยครั้ง
ยกเว้นในกรณีที่มีการนำเข้าข้อมูลของผู้ใช้ที่จำเป็น
**รูปแบบ**
```python
while นิพจน์:
ข้อความสั่ง(s)
```
**ตัวอย่างที่ 5**
```python
count = 0
while (count <= 8):
print ('Is:', count)
count = (count + 1)
```
**ผลลัพธ์**
```python
Is: 0
Is: 1
Is: 2
Is: 3
Is: 4
Is: 5
Is: 6
Is: 7
Is: 8
```
**อธิบาย**
กำหนดให้ตัวแปร x มีค่าเท่ากับ 0
แล้วต่อมาใช้คำสั่งทำซ้ำ While โดยในขณะที่ count น้อยกว่าหรือเท่ากับ 8
แล้วให้แสดงค่านั้นตามหลัง Is: แล้วให้ count + 1
แล้ววนรอบต่อไปจนกว่าจะเท่ากับ 8
**ตัวอย่างที่ 6**
```python
while True:
n = input("Please enter 'hello':")
if n.strip() == 'hello':
break
```
**ผลลัพธ์**
```python
Please enter 'hello':
```
**อธิบาย**
กำหนดให้มีค่าความจริงเป็นจริง ให้ตัวแปร x
รับค่าจากผู้ใช้มาใช้ในเงื่อนไข if โดยค่าที่ได้จะเป็นจริงก็ต่อเมื่อค่า n
มีค่าเป็น hello เท่านั้นแล้วจึงจะออกจากการวนรอบโดยใช้ break
## บทที่ 12 Python OOP อ๊อบเจ็กและคลาส
หลาย ๆ ท่านคงเคยได้ยินคำว่า OOP การเขียนโปรแกรมเชิงวัตถุกันมาบ้างแล้ว โดย OOP ย่อมาจาก Object-Oriented Programming เป็นหลักการที่เหมาะสมกับการพัฒนาโปรแกรมทั้งขนาดเล็ก ขนาดกลาง และขนาดใหญ่
คลาสจะแบ่งปัญหาใหญ่ให้เล็กลงเพื่อแก้ไขในขอบเขตที่จำกัด บทนี้จะพาทุกท่านไปเขียน OOP ในภาษา Python กัน
มาเริ่มกันด้วยคลาสง่าย ๆ บน Python กัน
```python
class FC:
pass
```
ต่อมาสร้างอ๊อบเจ็ก
```python
a = FC()
```
เราสามารถนำ a ไปใช้งานได้เลย เหมือนกล่องเปล่า
```python
a.one = 1
a.ten = 10
print (a.ten - a.one)
```
**ผลลัพธ์**
> 9
>
ตัวอย่างข้างบนมีข้อเสียตรงที่อ๊อบเจ็กอื่นของคลาส FC จะไม่มี one และ ten สามารถแก้ไขได้โดยการกำหนดค่าเริ่มต้น
```python
class FC:
one = 1
ten = 10
```
เวลาเอาไปใช้
```python
a = FC.one
b = FC.ten
print (b - a)
```
**ผลลัพธ์**
> 9
>
ตัวอย่างข้างบน เป็นที่แน่นอนว่า คลาส FC มี one และ ten แน่นอน แต่ยังไม่สามารถกำหนดค่าเริ่มต้นแบบเป็นระเบียบได้
```python
class FC:
def __init__(self,one,ten):
self.one = one
self.ten = ten
```
วิธีกำหนดค่าเริ่มต้นจะต้องใช้ constructor เข้ามาช่วย นั้นคือเมธอดชื่อ
__init__ ทุกเมธอดในคลาสจะใช้พารามิเตอร์ตัวแรกแทนตัวเอง
ชึ่งปกติจะใช้ชื่อ self สำหรับในภาษาซีหรือจาวา self คือ this
```python
a = FC(1,10)
```
ต่อมาใส่เมธอดเพิ่มเติมเข้าไปในคลาส
```python
class FC:
def __init__(self,one,ten):
self.one = one
self.ten = ten
def show(self):
print (self.ten,"-",self.one,"=",self.ten - self.one)
```
นำมาใช้
```python
a = FC(one=1,ten=10)
a.show()
```
**ผลลัพธ์**
> 10 - 1 = 9
>
## บทที่ 13 Python Regular Expressions
Regular Expressions (RegEx) คือ วิธีการตรวจสอบข้อมูล โดยกำหนดรูปแบบของสตริงที่ต้องการตรวจสอบที่เรียกว่า แพตเทิร์น(Pattern) มีต้นกำเนิดมาจากภาษา Perl
**รูปแบบแพตเทิร์น(Pattern) ใน Python**
**Anchors**
```
^
```
เริ่มต้นของสตริงหรือเริ่มต้นของบรรทัดในรูปแบบหลายบรรทัด
```
\A
```
จุดเริ่มต้นของสตริง
```
$
```
สิ้นสุดของสตริงหรือจุดสิ้นสุดของเส้นในรูปแบบหลายบรรทัด
```
\Z
```
สิ้นสุดของสตริง
```
\b
```
ขอบเขตคำ
```
+
```
ตรงกับอย่างน้อยหนึ่งอักขระก่อนหน้านี้
```
*
```
มีหรือไม่ก็ได้
```
|
```
คือ "หรือ" , "OR"
**haracter Classes**
```
.
```
(จุด) แทนตัวอักษรใด ๆ 1 ตัว ยกเว้นตัวอักษรขึ้นบรรทัดใหม่
```
\s
```
เว้นบรรทัด
```
\S
```
ไม่ได้เว้นบรรทัด
```
\B
```
ไม่ขอบเขตคำ
```
<
```
จุดเริ่มต้นของคำ
```
>
```
สุดท้ายของคำ
```
\b
```
ตรงกับขอบเขต string
```
\d
```
แทนตัวเลข 0 ถึง 9
```
\D
```
ตัวอักษรที่ไม่ใช่ตัวเลข
```
\w
```
คำ
```
\W
```
ไม่ใช่คำ
```
{จำนวนที่ซ้ำ}
```
ระบุว่าต้องการการซ้ำซ้อนทั้งหมดกี่ตัว
**อักขระพิเศษ**
```
\n
```
บรรทัดใหม่
```
\t
```
Tab
**กลุ่ม**
```
(? ... )
```
Passive (ไม่จับ) กลุ่ม
```
[abc]
```
ช่วง (A หรือ B หรือ C)
```
[^abc]
```
ไม่ใช่ a หรือ b หรือ c
```
[a-z]
```
ใช้แทน a - z ตัวพิมพ์เล็ก
```
[a-z0-9]
```
ใช้แทน a-z ตัวพิมพ์เล็กและแทนเลข 0 - 9
```
[A-Z]
```
ใช้แทน A - Z ตัวพิมพ์ใหญ่
```
[A-Z0-9]
```
ใช้แทน A - Z ตัวพิมพ์ใหญ่และแทนเลข 0 - 9
```
[0-9]
```
ใช้แทนช่วง 0 - 9 ที่ยกมาด้านบนเป็นรูปแบบแพตเทิร์น(Pattern) ใน Python ที่ใช้กันบ่อย ๆ สำหรับเรื่อง รูปแบบแพตเทิร์น(Pattern) ไปศึกษารายละเอียดย่อย ๆ ได้ที่ [http://www.cheatography.com/davechild/cheat-sheets/regular-expressions/](http://www.cheatography.com/davechild/cheat-sheets/regular-expressions/)
ในการใช้ Regular Expressions ใน Python เราต้องใช้โมดูลที่มากับตัว Python ที่มีชื่อว่า re
### findall
```
findall()
```
เป็นฟังก์ชั่นที่มีประสิทธิภาพที่สุดในโมดูล re เราจะใช้
```
findall()
```
ในการค้นหารูปแบบในตัวอย่างนี้
**ผลลัพธ์**
> ['Barack Obama', 'Bill Gates']
>
### match
```
re.match()
```
ตรวจสอบว่า Regular Expressions
ตรงที่จุดเริ่มต้นของสตริง เมื่อพบจะคืนค่า match object ออกมา
ถ้าไม่พบจะคืนค่า None ออกมา ดังตัวอย่างต่อไปนี้
```python
>>> import re
>>> m = p.match('tempo')
>>> m
<_sre.SRE_Match object; span=(0, 5), match='tempo'>
```
ถ้าไม่พบข้อความ
```python
>>> import re
>>> p.match("")
>>> print(p.match(""))
None
```
### search
re.search() ใช้ค้นหารูปแบบภายในสตริงที่กำหนด ดังตัวอย่างต่อไปนี้
```python
import re
print(re.search(r'\d\d\d', 'Your number is <b>123</b>').group(0))
```
**ผลลัพธ์**
123
---
**การใช้ `re.search()` กับการเช็คเงื่อนไข if else**
หากต้องการเช็คเงื่อนไข if else ว่าถ้าในสตริงมีรูปแบบที่ตรงกับรูปแบบ re
ที่กำหนดไว้ ให้ทำเงื่อนไขใน if หากไม่ใช่ ให้ทำเงื่อนไขใน else
สามารถทำได้โดยใช้โค้ดต่อไปนี้
**ตัวอย่างเช่น**
หากกำหนดรูปแบบให้ค้นหา 0 - 9 หากพบให้แสดงเป็น 1 หากไม่พบ ให้แสดงเป็น 0
เขียนรูปแบบ re ได้เป็น [0-9] ได้โค้ดออกมาตามตัวอย่างนี้
```python
import re
a = '5'
if (re.search(r'[0-9]',a)):
print("1")
else:
print("0")
```
**ผลลัพธ์**
```python
1
```
---
### sub
re.sub() เป็นคำสั่งที่ใช้แทนที่ตัวอักษรในสตริง ไม่ว่าจะเป็นคำหรือประโยค ดังตัวอย่างต่อไปนี้
```python
import re
a = "คน เดิน ด้วย เครื่องบิน"
b = re.sub("เดิน", "บิน", a)
print(b)
```
**ผลลัพธ์**
> คน บิน ด้วย เครื่องบิน
>
### compile
```
re.compile()
```
เป็นคำสั่งที่ใช้รวบรวมรูปแบบ (Pattern) เป็นวัตถุเก็บรูปแบบที่ต้องการ ดังตัวอย่างต่อไปนี้
> import re
>
**ผลลัพธ์**
> ['hello', 'world']
>
### split
```
re.split
```
เป็นคำสั่งที่ใช้แยกสตริงตามที่กำหนด เราสามารถนำมาใช้ได้กับ Regular Expressions ดังตัวอย่างต่อไปนี้
```python
>>> import re
>>> re.split('\W+','This... is a test.')
['This', 'is', 'a', 'test', '']
```
สำหรับท่าใดที่อยากลองเขียน Regular Expressions ดู สามารถเข้าไปลองเขียนเล่นได้ที่ [http://re-try.appspot.com/](https://re-try.appspot.com/)
## บทที่ 14 อ๊อบเจ็กและคลาสพื้นฐานในภาษา Python
ในภาษา Python การสร้างอ๊อบเจ็กและคลาส มีรูปแบบดังนี้
ลองเขียนอ๊อบเจ็กและคลาสกันดู
แล้วนำเรียกใช้ข้อมูลที่อยู่ในคลาส test
```python
>>> a = test() #กำหนดให้ a แทนคำสั่งในคลาส test
>>> a.run() #เรียกใช้ฟังก์ชัน run ในคลาส test
It's ok
>>> a.opentest() #เรียกใช้ฟังก์ชัน opentest ในคลาส test
Open A Test
```
จะเห็นได้ว่า เราสามารถเรียกใช้ฟังก์ชั่นที่อยู่ในคลาสได้
ด้วยการอ้างอิงตำแหน่งที่อยู่ของฟังก์ชั่นในคลาสนั้น
ต่อไปเราจะกำหนดให้ฟังก์ชั่นในคลาสสามารถกำหนดพารามิเตอร์ของฟังก์ชั่นได้ด้วยการใช้ self
แล้วลองนำมาใช้งานดู
```python
>>> b = test2() #กำหนดให้ b แทนคำสั่งในคลาส test2
>>> b.minus(10,5) #เรียกใช้ฟังก์ชัน minus ในคลาส test2 โดยกำหนดพารามิเตอร์ num1,num2
5
```
หากเราต้องการกำหนดค่าเริ่มต้นจะต้องใช้ constructor เข้ามาช่วย นั้นคือเมธอดชื่อ __init__ โดยทุกเมธอดในคลาสจะใช้พารามิเตอร์ตัวแรกแทนตัวมันเอง พูดง่าย ๆ ฟังก์ชั่นที่มีเมธอดชื่อ __init__ จะเป็นฟังก์ชั่นหลักของคลาสนั้น
เมื่อเรียกใช้คลาส test3
```python
>>> c = test3(1,2)
3
```
นอกจากนั้นเรายังสามารถเพิ่มฟังก์ชั่นลงในคลาสที่มีการใช้เมธอดชื่อ __init__ ได้ด้วย
เรียกใช้งานในคลาส test4
```python
>>> aa = test4(2,3)
5
>>> aa.test()
It's ok
```
เราสามารถกำหนดค่าว่างให้กับคลาสได้ด้วยคำสั่ง pass ตัวอย่างเช่น
```python
class D():
pass
```
เราสามารถใช้คลาส D โดยใช้เก็บค่าต่าง ๆ ได้เลย เหมือนเป็นกล่องเปล่า ตัวอย่างเช่น
```python
>>> a = D()
>>> a.one = 1
>>> a.ten = 10
>>> print (a.ten - a.one)
9
```
### คืนค่าข้อมูลด้วย return
คำสั่ง return เป็นคำสั่งสำหรับคืนคาข้อมูลที่อยู่ในคลาสและฟังก์ชัน
**ตัวอย่างเช่น**
```python
def ok():
return "ok"
print(ok)
print(ok())
```
ผลลัพธ์
```
ok
```
## บทที่ 15 สร้าง Modules ใน Python 3
ในบางกรณีเมื่อเราพัฒนาโปรแกรมโดยมีความซับซ้อนและมีขนาดใหญ่ ทำให้เราต้องเสียเวลาไปกับเขียนโค้ดเดิม ๆ ที่เรียกใช้และมีลักษณะการทำงานเหมือนกัน
หากเราเปลี่ยนมาใช้งานแบบ Modules ใน Python 3 จะช่วยเพิ่มความสะดวกสบายในเขียนโค้ดและเรียกใช้งานขึ้น
ใน Python เราแค่เขียนไฟล์ Modules ขึ้นมา แล้วบันทึก เวลาต้องการเรียกใช้งานแค่ import ชื่อไฟล์ Modules ที่สร้าง โดยไฟล์ Modules ที่สร้างต้องอยู่ในโฟลเดอร์เดียวกันกับไฟล์งานที่เรียกใช้
**ตัวอย่างเช่น**
ไฟล์ mod1.py
```python
def cal1(a,b):
c = a + b
return c
```
เป็นการสร้างฟังก์ชัน cal1 ขึ้นมา ทำเป็น Module เมื่อเรียกไปใช้งาน
ไฟล์ testmod1.py
```python
import firstmod
print (firstmod.cal1(5,6))
```
เรียกใช้งานฟังก์ชัน cal1 ใน Module ชื่อ firstmod จะได้ผลลัพธ์เป็น
> 11
>
**ตัวอย่างต่อมา**
ไฟล์ mod2.py
```python
def body():
print ("I'm Python. :)")
```
เรียกมาใช้งาน
ไฟล์ testmod2.py
```python
import mod2
mod2.body()
```
ได้ผลลัพธ์เป็น
> I'm Python. :)
>
## บทที่ 16 ฟังก์ชัน math ใน Python
ฟังก์ชัน math เป็นฟังก์ชันที่ใช้คำนวณทางคณิตศาสตร์ เพื่อหาค่าทางคณิตศาสตร์ โดยฟังก์ชัน math ใน Python นี้จะใช้ฟังก์ชันทางคณิตศาสตร์ที่กำหนดโดยมาตรฐาน C
> เวลาเรียกใช้งานฟังก์ชัน math ใน Python ต้อง import math เข้ามาด้วย
>
**ทฤษฎีตัวเลข**
- การปัดเลขทศนิยมmath.ceil(x)เมื่อแทน x เป็นจำนวนจริงเลขทศนิยมโค้ดตัวอย่าง math.ceil(0.54) แสดงผล 1
- math.copysign(x, y)คืนค่าจำนวนจริงมีจำนวน (ค่าสัมบูรณ์) ของ x แต่เป็นเครื่องหมายของ y `math.copysign(1.0,-0.0)` ผลลัพธ์ `1.0`
- ค่าสัมบูรณ์math.fabs(x)คืนค่าสัมบูรณ์ของ xโค้ดตัวอย่าง`math.fabs(0.9)` ผลลัพธ์ `0.9`
- แฟกทอเรียล math.factorial(x) คืนค่า x แฟกทอเรียล เพิ่มค่าข้อผิดพลาดถ้า x ไม่เป็นจำนวนเต็มหรือเป็นจำนวนลบ
```python
>>> math.factorial(5)
120
```
- ปัดเศษทศนิยมทิ้งmath.floor(x)คืนค่า x โดยปัดเศษทศนิยบนค่า X ทิ้ง
```python
>>> math.floor(9.2)
9
```
- math.fmod(x,y)คืนค่าส่วนเหลือของ x หาร ด้วย y
```python
>>> math.fmod(33,55)
33.0 #หลังจากที่ 33/55 จะพบว่า เราไม่สามารถหารได้ถ้าไม่มีส่วนที่เหลือ คือ 33.0
>>> math.fmod(10,20)
10.0
```
- math.frexp(x)คืนค่าแมนทิสซา(mantissa)และเลขชี้กำลังของ x เป็นคู่ (m, e)
```python
>>> math.frexp(16)
(0.5, 5)
>>> math.frexp(8)
(0.5, 4)
```
- math.fsum(iterable)คืนค่าผลรวมของ iterable เช่น set, list, หรือ tuple
```python
>>> import math
>>> i=[5,6,1]
>>> math.fsum(i)
12.0
```
- math.isfinite()คืนค่า true หรือ false ถ้าค่าของ x จะมีขอบเขต (เพิ่งมีใน Python 3.2)
```python
>>> math.isfinite(12**12)
True
>>>math.isfinite(333**55555553333445)
false
```
- math.isinf(x)คืนค่า True ถ้า x เป็นจำนวนเต็มบวกหรือเต็มลบที่เป็นจำนวนอนันต์ ถ้าไม่เป็นจำนวนอนันต์คืนค่า False
- math.isnan(x)คืนค่า True ถ้า x ไม่ใช่จำนวนตัวเลข และคืนค่า False หากไม่ตรงกับเงื่อนไขนี้
- math.ldexp(x, i)คืนค่า x * (2**i) คำสั่งนี้เป็นหลัก ผกผันของ ฟังก์ชัน frexp()
- math.modf(x)คืนค่าส่วนที่เป็นจำนวนเต็มและเศษส่วนของ x ทั้งผลลัพธ์ดำเนินการเครื่องหมายของ x และเป็นจำนวนจริง
- math.trunc(x)คืนค่าจริงของ x ถูกตัดเหลือเพียง Integral (มักจะเป็นจำนวนเต็ม ) ตัวแทน X__trunc__()
**Power และฟังก์ชั่นลอการิทึม**
- math.exp(x)คืนค่า e**x
- math.expm1(x)เพิ่งมีใน Python 3.2 เป็นต้นมาคืนค่า e**x - 1 ของจำนวนจริงขนาดเล็ก ในบวกการลบ exp(x) - 1 จะส่งผลต่อการสูญเสียความแม่นยำที่สำคัญไปฟังก์ชัน expm1() จะช่วยให้สามารถคำนวณปริมาณความแม่นยำเต็มรูปแบบนี้:
```python
>>> from math import exp, expm1
>>> exp(1e-5) - 1 #ช่วยให้ผลลัพธ์ที่ถูกต้องถึง 11ตำแหน่ง
1.0000050000069649e-05
>>> expm1(1e-5) # ให้ผลลัพธ์ที่ถูกต้องแม่นยำกว่า exp()
1.0000050000166668e-05
```
- math.log(x[, เลขฐาน])คืนค่าผลลัพธ์ที่ได้จากค่า log ตามคณิตศาสตร์ หากไม่ได้กำหนดเลขฐาน เลขฐานจะเป็นค่า e
```python
>>> import math
>>> math.log(10)
2.302585092994046
>>> math.log(10,10)
1.0
>>> math.log(2)
0.6931471805599453
>>> math.log(1)
0.0
>>> math.log(2,2)
1.0
```
- math.log1p(x)คืนค่าลอการิทึมธรรมชาติของ 1 + x (ฐาน e) ผลลัพธ์การคำนวณที่ถูกต้องสำหรับ x อยู่ใกล้ศูนย์
- math.log2(x)เพิ่งมีใน Python 3.3 เป็นต้นมาคืนค่าผลลัพธ์ที่ได้จากค่า log เลขฐาน 2 เหมือนใช้คำสั่ง log(x, 2)
- math.log10(x)คืนค่าผลลัพธ์ที่ได้จากค่า log เลขฐาน 10 เหมือนใช้คำสั่ง log(x, 10)
- math.pow(x, y)คืนค่าผลลัพธ์ที่ได้จากการที่ x ยกกำลัง y
- math.sqrt(x)คืนค่ารากที่สองของ x
**ฟังก์ชันตรีโกณมิติ**
- math.acos(x)คืนค่าอาร์กโคไซน์ (arccos หรือ cos-1) ของ x ในเรเดียน
- math.asin(x)คืนค่า arc sine ของ x ในเรเดียน
- math.atan(x)คืนค่า arc tan ของ x ในเรเดียน
- math.atan2(y, x)คืนค่า atan(y / x) ของ x ในเรเดียน
- math.cos(x)คืนค่า cosine ของ x ในเรเดียน
- math.hypot(x, y)คืนค่าการคำนวณบรรทัดฐานแบบยุคลิด sqrt (x * x + y * y) นี้เป็นความยาวของเวกเตอร์จากแหล่งกำเนิดไปยังจุด (x, y)
- math.sin(x)คืนค่า sin ของ x ในเรเดียน
- math.tan(x)คืนค่า sin ของ x ในเรเดียน
**Angular conversion**
- math.degrees(x)แปลงมุม x จากเรเดียนให้เป็นองศา
- math.radians(x)แปลงมุม x จากองศาให้เป็นเรเดียน
```python
>>> import math
>>> math.radians(180)
3.141592653589793
>>> math.degrees(3.141592653589793)
180.0
```
**Hyperbolic functions**
- math.acosh(x) คืนค่าส่วนกลับ hyperbolic cosine ของ x
- math.asinh(x) คืนค่าส่วนกลับ hyperbolic sine ของ x
- math.atanh(x) คืนค่าส่วนกลับ hyperbolic tangent ของ x
- math.cosh(x) คืนค่า hyperbolic cosine ของ x
- math.sinh(x) คืนค่า hyperbolic sine ของ x
- math.tanh(x) คืนค่า hyperbolic tangent ของ x
**ค่าคงตัว**
- math.pi ค่าคงที่ทางคณิตศาสตร์ของ π = 3.141592...
- math.e ค่าคงที่ทางคณิตศาสตร์ของ e = 2.718281...
## บทที่ 17 Type hints ใน Python
หลังจากที่ Python 3.5 ได้เปิดตัวออกมา ได้มีไวยากรณ์หนึ่งที่เพิ่มเข้ามาตั้งแต่ Python 3.5 นั่นคือ Type hints
Type hints คือ การบอกว่าฟังก์ชันหรือ method ต้องการตัวแปรชนิดใด และคืนค่าออกมาเป็นชนิดข้อมูลชนิดใด ช่วยให้เราสามารถเขียนโค้ดมีคุณภาพมากยิ่งขึ้น
ในภาษา Python ได้มีการเพิ่มการรองรับ type hints มาตั้งแต่ Python 3.5 เป็นต้นมา
สำหรับ Python ที่ต่ำกว่า 3.5 สามารถใช้งาน type hints โดย backport ด้วยคำสั่ง
```
pip install typing
```
**การใช้งาน `type hints`**
สมมติว่าต้องการสร้างฟังก์ชันบวกเลขด้วยข้อมูลชนิด int โดยที่ไม่ใช้ type hints
```python
def plus(a,b): return a+b
```
ผลลัพธ์
```python
plus("9", "1")
"91"
```
จะเห็นได้ว่า หากเป็น str บวกกันจะรวมข้อความกัน ทั้งที่เราอยากให้เฉพาะข้อมูล int เท่านั้นที่บวกกันได้ เพราะเราไม่ได้กำหนด method ว่าต้องการตัวแปรชนิดใด
เมื่อลองมาใช้ Type hints
การใช้ Type hints ทำได้ง่าย ๆ เพียงแค่เติม : หลังพารามิเตอร์แต่ละตัวแล้วใส่ชนิดข้อมูลที่ต้องการลงไป และใส่ -> ตามด้วยชนิดข้อมูลที่จะคืนค่าหลัง ) ดังนี้
```python
def plus(a: int,b: int)->int: return a+b
```
หากลองรันจะรันได้ปกติ
```python
plus("9", "1")
"91"
```
แต่หากนำไปใช้ใน IDE อย่าง PyCharm จะมีการแจ้งเตือนหากใช้ข้อมูลผิดชนิดข้อมูลที่กำหนดไว้
## บทที่ 18 Recursive Function กับ Python
รีเคอร์ซีฟฟังก์ชัน (recursive functions) คือ ฟังก์ชันที่เรียกตัวเอง โดยแต่ละครั้งที่ฟังก์ชันถูกเรียก จะเกิดตัวแปรอัตโนมัติชุดใหม่ที่ไม่เกี่ยวข้องกับชุดเดิม จึงเรียกอีกชื่อหนึ่งว่า "ฟังก์ชันแบบเวียนเกิด"
หลักการรีเคอร์ซีฟฟังก์ชัน คือ เขียนโปรแกรมวนซ้ำเพื่อลดปัญหาของโปรแกรมที่ซับซ้อน
ขั้นตอนการเขียนรีเคอร์ซีฟฟังก์ชัน
- ทำความเข้าใจโจทย์
- หาจุดวนกลับ โดยจะหาเมื่อการวนกลับยุติลงแล้วส่งค่ากลับไปคืนจุดที่เรียก
- หาขั้นตอนที่ต้องเรียกซ้ำ
รูปแบบทั่วไปของรีเคอร์ซีฟฟังก์ชันมีรูปแบบดังนี้
```python
def ฟังกชัน(พารามิเตอร์):
if < เงื่อนไขที่ผลให้ยุติการเรียกซ้ำ (จุดวกกลับ หรือ base case) >:
ส่งคำตอบคืน
else:
แยกปัญหาเป็นประเด็นย่อย ด้วยการเรียกซ้ำ (Recursive)
```
> ข้อควรระวัง : ในการเขียนโปรแกรมด้วยรีเคอร์ซีฟฟังก์ชันต้องรอบคอบ และรีเคอร์ซีฟฟังก์ชันจำเป็นจะต้องมี if statement เพื่อตัดสินใจว่าควรเรียกตัวเองต่อไปหรือไม่
>
ตัวอย่างเช่น โปรแกรม Python หาแฟกทอเรียลได้
โดยนิยามของแฟกทอเรียฟังก์ชัน คือ
```
n! = n*(n-1)! if n < 0
```
เอานำมาหา 5!
```
5! = 5*4*3*2*1 = 5*4!
4! = 4*3*2*1 = 4*3!
3! = 3*2*1 = 3*2!
2! = 2*1 = 2*1!
1! = 1 = 1
0! = 1 นี่คือ จุดวกกลับ หรือ base case
```
สามารถเขียนโปรแกรม Python หาแฟกทอเรียลในรีเคอร์ซีฟฟังก์ชันได้ดังนี้
```python
def factorial(num):
if num==0:
return 1
else:
return num * factorial(num-1)
print(factorial(3))
print(factorial(5))
```
ผลลัพธ์
```
6
120
```
ในทางกลับกัน เราสามารถนำรีเคอร์ซีฟฟังก์ชันมาเขียนเป็นฟังก์ชันลูปได้เช่นกัน
```python
def factorial(num):
i=num
while num!=0:
if num!=1:
i=i*(num-1)
num-=1
return i
print(factorial(3))
print(factorial(5))
```
ผลลัพธ์
```
6
120
```
เมื่อเปรียบเทียบระหว่างแบบรีเคอร์ซีฟฟังก์ชันกับแบบฟังก์ชันลูป
จะเห็นได้ว่า รีเคอร์ซีฟฟังก์ชันลดความซับซ้อนของโปรแกรมและเข้าใจง่ายขึ้น
**ข้อควรระวังการใช้งานรีเคอร์ซีฟฟังก์ชัน**
คือ ปัญหา Stack Overflow และในสถานการณ์ทั่วไป รีเคอร์ซีฟฟังก์ชันทำงานช้ากว่าลูป เพราะต้องเสียเวลาสร้าง Call Stack ในทุกครั้งที่เรียก
เมื่อนำรีเคอร์ซีฟฟังก์ชันไปสร้างเป็นไฟล์
```
factorial1.py
```
แล้วนำฟังก์ชันลูปไปสร้างเป็นไฟล์
```
factorial2.py
```
ทำการทดสอบด้วยโค้ด
```
python -m profile ไฟล์.py
```
ผลลัพธ์
ไฟล์ factorial1.py
```
6
120
16 function calls (8 primitive calls) in 0.007 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.000 0.000 :0(exec)
2 0.000 0.000 0.000 0.000 :0(print)
1 0.007 0.007 0.007 0.007 :0(setprofile)
1 0.000 0.000 0.000 0.000 factorial1.py:1(<module>)
10/2 0.000 0.000 0.000 0.000 factorial1.py:1(factorial)
1 0.000 0.000 0.007 0.007 profile:0(<code object <module> at 0x7f1448cc08a0, file "factorial1.py", line 1>)
0 0.000 0.000 profile:0(profiler)
```
ไฟล์ factorial2.py
```
6
120
8 function calls in 0.005 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.000 0.000 :0(exec)
2 0.000 0.000 0.000 0.000 :0(print)
1 0.005 0.005 0.005 0.005 :0(setprofile)
1 0.000 0.000 0.000 0.000 factorial2.py:1(<module>)
2 0.000 0.000 0.000 0.000 factorial2.py:1(factorial)
1 0.000 0.000 0.005 0.005 profile:0(<code object <module> at 0x7f55e91108a0, file "factorial2.py", line 1>)
0 0.000 0.000 profile:0(profiler)
```
จะเห็นได้ว่า ในภาษา Python รีเคอร์ซีฟฟังก์ชันทำงานช้ากว่าฟังก์ชันลูป และมีการเรียกใช้ function calls มากกว่า
## บทที่ 19 ติดตั้งโมดูล python ด้วย pip
pip เป็นคำสั่งสำหรับใช้ติดตั้งโมดูล Python ที่อยู่บน [pypi.org](http://pypi.org)
PyPI ย่อมาจาก Python Package Index เป็นแหล่งรวมชุดคำสั่งของภาษา Python โดยทำงานร่วมกับคำสั่ง pip สำหรับติดตั้งชุดคำสั่งใน Python
ผู้ใช้งานสามารถค้นหาไลบรารีหรือโปรแกรมภาษา Python ได้ง่าย ๆ จากช่องค้นหา และมีรายละเอียดการคำสั่งติดตั้ง กับประวัติรุ่นไลบรารีที่ต้องการ
ส่วนสำหรับนักพัฒนาจะนำชุดคำสั่งภาษา Python ที่เขียน
ไม่ว่าจะเป็นไลบรารีหรือโปรแกรมต่าง ๆ ที่ใช้ร่วมกับภาษา Python
ขึ้นไปฝากไว้กับ PyPI โดย PyPI มีอยู่ 2 ส่วนด้วยกัน
1. Test PyPI
Test PyPI ตั้งอยู่ที่ [https://test.pypi.org/](https://test.pypi.org/) ให้นักพัฒนาสามารถอัพโหลดไลบรารีหรือโปรแกรมภาษา Python ของตัวเองขึ้นทดสอบก่อนนำไปอัพโหลดขึ้น PyPI โดยการติดตั้งไลบรารีจาก Test PyPI จะใช้คำสั่งที่ยาวขึ้นมาหน่อยดังนี้
> pip install -i https://test.pypi.org/simple/ ชื่อไลบรารี
>
2. PyPI
PyPI ตั้งอยู่ที่ [https://pypi.org/](https://pypi.org/) ผู้ใช้งานสามารถติดตั้งไลบรารีหรือโปรแกรมโปรแกรมภาษา Python ได้ หากว่านักพัฒนาอัพโหลดไลบรารีหรือโปรแกรมของตัวเองขึ้น PyPI แล้ว
เพียงแค่ใช้คำสั่ง
> pip install ไลบรารี
>
**คำสั่งที่ควรรู้**
- pip install package - เป็นคำสั่งติดตั้งโมดูล
- pip uninstall package - เป็นคำสั่งถอนการติดตั้งโมดูล (ต้องยืนยันก่อนถอนด้วย)
## บทที่ 19 เขียนไฟล์-อ่านไฟล์ด้วยภาษา Python
บทนี้เราจะมาเรียนรู้กับการอ่าน เขียน ไฟล์บนภาษา Python
### เขียนและอ่านข้อมูลจากเท็กซ์ไฟล์บน Python 3
เท็กซ์ไฟล์ (Text Files) เป็นอีกหนึ่งรูปแบบในการบันทึกข้อมูล
**มาเริ่มต้นที่การเปิดไฟล์กัน**
รูปแบบการเปิดไฟล์
> ตัวแปร = open(ชื่อไฟล์, โหมดการเปิดไฟล์)
>
**โหมดการเปิดไฟล์ที่ใช้กับเท็กซ์ไฟล์**
r คือ อ่านเพียงอย่างเดียว
w คือ เขียนเพียงอย่างเดียว ถ้ายังไม่มีไฟล์ จะสร้างไฟล์ใหม่
w+ คือ เขียน สร้างไฟล์ใหม่ หรือแทนที่ข้อมูลเดิม
a คือ เปิดไฟล์แล้วเขียนข้อมูลต่อท้ายข้อมูลเดิม
r+ คือ เปิดไฟล์เพื่ออ่านหรือเขียนข้อมูลทับไฟล์
**ตัวอย่าง**
```python
a = open('work1.txt', 'w')
```
**เขียนข้อมูลลงเท็กซ์ไฟล์**
สำหรับโหมดเขียนข้อมูลลงไฟล์นี้ ห้ามใช้ r เพราะโหมดนี้ไม่สามารถเขียนข้อมูลลงไฟล์ได้
มีรูปแบบดังนี้
> ตัวแปรที่เปิดไฟล์.write(ข้อความหรือตัวแปร)
>
**ตัวอย่าง**
```python
a = open('work1.txt', 'w')
a.write('This is a testn')
```
**ผลลัพธ์**
work1.txt
> This is a testn
>
เขียน**ข้อมูลรายการ (List) ลงเท็กซ์ไฟล์ทีละบรรทัด**
มีรูปแบบดังนี้
> ตัวแปรที่เปิดไฟล์.writelines(List ข้อมูล)
>
**อ่านข้อมูลจากเท็กซ์ไฟล์**
มีรูปแบบดังนี้
> ตัวแปรที่เปิดไฟล์.read()
>
**ตัวอย่าง**
```python
a = open('work1.txt', 'r')
a.read()
```
**ผลลัพธ์**
> This is a testn
>
**หรือจะใช้ with**
```python
with open('work1.txt', 'r') as f:
read_data = f.read()
print(read_data)
```
**ผลลัพธ์**
> This is a testn
>
**อ่านข้อมูลจากเท็กซ์ไฟล์ทีละบรรทัด**
ในการอ่านข้อมูลทีละบรรทัดนี้ Python ได้แบ่งบรรทัดโดยอ้างอิง `\n`
เวลาเขียนข้อมูลลงไฟล์ หากต้องการขึ้นบรรทัดใหม่ให้ใส่ `\n` ตามหลังเข้าไปด้วย
มีรูปแบบดังนี้
> ตัวแปรที่เปิดไฟล์.readline()
>
**ตัวอย่าง**
```python
a = open('work2.txt', 'r')
a.readline()
```
**ปิดไฟล์หลังเรียกใช้งาน**
เมื่อเรียกใช้งานไฟล์เสร็จ ควรที่จะปิดไฟล์เพื่อคืนทรัพยากรให้กับระบบ
มีรูปแบบการใช้งานดังนี้
> ตัวแปรที่เปิดไฟล์.close
>
**ตัวอย่าง**
> a.close()
>
**ฟังก์ชันเพิ่มเติม**
- ตัวแปรที่เปิดไฟล์.name - จะคืนค่าชื่อไฟล์ที่เปิดอยู่
- ตัวแปรที่เปิดไฟล์.mode - จะคืนค่าโหมดการเปิดไฟล์ เช่น w , r เป็นต้น
### อ่าน-เขียนข้อมูลไบนารีไฟล์ในภาษาไพทอน
ไบนารีไฟล์ (binary files) เป็นไฟล์ข้อมูลในรูปแบบเฉพาะของคอมพิวเตอร์ โดยข้อมูลที่เก็บอาจเป็นเลขจำนวนเต็ม ตัวอักษร และอื่น ๆ เป็นต้น
ในภาษาไพทอน มีหลักไวยากรณ์ในการอ่านและเขียนข้อมูลไบนารีไฟล์ในภาษาไพทอนดังนี้
**การเปิดไฟล์ไบนารีในภาษาไพทอน**
> open(ชื่อไฟล์,โหมดการเปิดไฟล์)
>
โหมดการเปิดไฟล์มีดังนี้
- wb เขียนไบนารีไฟล์หรือสร้างไบนารีไฟล์ใหม่ในกรณีที่ไม่มีไฟล์ที่เรียก
- rb อ่านไบนารีไฟล์
- ab เขียนข้อมูลต่อท้ายข้อมูลที่มีอยู่ในไฟล์
- wb+ เขียนไบนารีไฟล์หรือสร้างไบนารีไฟล์ใหม่ในกรณีที่ไม่มีไฟล์ที่เรียก
- rb+ อ่านไบนารีไฟล์ ถ้าไม่มีไฟล์ให้สร้างไฟล์ใหม่
- ab+ เขียนข้อมูลต่อท้ายข้อมูลที่มีอยู่ในไฟล์ ถ้าไม่มีไฟล์ให้สร้างไฟล์ใหม่
**การปิดไฟล์**
หลังอ่าน เขียน ไฟล์แล้ว เพื่อคืนความจำให้กับระบบ ต้องทำการปิดไฟล์ โดยใช้คำสั่ง
> file.close()
>
**เขียนข้อมูลลงไฟล์**
```
ทบทวนความรู้พื้นฐานเรื่องจำนวนไบต์และบิต MB GB
8 Bit (บิต) = 1 Byte (ไบต์)
1 Byte (ไบต์) = 1 ตัวอักษร
1 KB (กิโลไบต์) = 1024 Byte
1 MB (เมกกะไบต์) = 1024 KB
1 GB (กิกะไบต์) = 1024 MB
```
การเขียนข้อมูลลงไบนารีไฟล์ในภาษาไพทอน ใช้คำสั่งต่อไปนี้
```python
file.write(ข้อมูลไบต์)
```
**ตัวอย่างการเขียนข้อมูลลงไฟล์**
```python
ofile = open("a", 'wb') # wb เขียนไฟล์
ofile.write(b"ok")
ofile.close()
```
**เขียนข้อมูลต่อจากไฟล์เดิม**
ใช้โหมดเปิดไฟล์ ab
ตัวอย่าง
```python
ofile = open("a", 'ab') # ab เขียนข้อมูลต่อจากไฟล์เดิม
ofile.write(b"Hi")
ofile.close()
```
**อ่านไฟล์**
ใช้คำสั่ง
```python
file.read(ขนาดข้อมูลไบต์ที่อ่าน)
```
**ตัวอย่างการอ่านไฟล์**
```python
ofile = open("a", 'rb') # rb อ่านไฟล์
print(ofile.read(2)) # อ่านข้อมูล 2 ไบต์
print(ofile.read(2)) # อ่านข้อมูลอีก 2 ไบต์
ofile.close() # ปิดไฟล์
```
ผลลัพธ์
```python
b'ok'
b'Hi'
```
## บทที่ 20 สร้างโมดูลพร้อมใช้ให้คอมเครื่องอื่น
หลักการเรียกใช้โมดูลในโฟลเลอร์เดียวกัน
ในการ import เรียกใช้โมดูลในโฟลเลอร์เดียวกัน สามารถทำได้โดยตามตัวอย่างนี้
hello.py
```python
print("Hello")
```
เราสร้างตัวโมดูลสำหรับเรียกใช้กันในโฟลเลอร์เดียวกันแล้ว สามารถเรียกใช้ได้เลยโดยใช้การ
```python
import ชื่อไฟล์โมดูล
```
โดยชื่อไฟล์โมดูลไม่ต้องมี .py ตัวอย่างเช่น
[show.py](http://show.py/)
```python
import hello
```
ผลลัพธ์
```
Hello
```
หากเราต้องการให้มีการเรียกใช้คำสั่งที่อยู่ในโมดูล เราต้องสร้างฟังก์ชันขึ้นมารองรับด้วย เมื่อเรียกใช้งาน โดยอ้างอิงจากฟังก์ชันที่อยู่ใน cal.py
test.py
```python
from cal import plue,plueto #เรียกใช้ฟังก์ชันหรือ class จากโมดูล cal
print(plue(5))
print(plueto(5,10))
```
ผลลัพธ์
```
10
15
```
หากเราต้องการทราบคำสั่งที่อยู่ในโมดูล cal ที่เราเขียนขึ้นมา สามารถใช้คำสั่ง **dict**.keys() ได้ดังนี้
list.py
```python
import cal
print(cal.__dict__.keys())
```
ผลลัพธ์
```
dict_keys(['__builtins__', 'plueto', '__name__', '__doc__', 'plue', '__spec__', '__file__', '__loader__', '__cached__', '__package__'])
```
ในกรณีที่มีคำสั่งในโมดูลที่เราเขียน หากเราต้องการสร้าง main ขึ้นมา (เหมือนภาษา C) โดยจะเรียกใช้งานได้เฉพาะโค้ดนี้เท่านั้น เราสามารถใช้ **name** == '**main**' ได้ตามน
caltwo.py
```python
if __name__ == '__main__':
print("5")
```
เมื่อเรา import โมดูลเข้ามา
show2.py
```python
import caltwo
```
ผลลัพธ์
จะพบว่า ไม่มีอะไรขึ้นมาเพราะ show2.py ไม่ใช่โปรแกรมหลัก
### ทำไฟล์ติดตั้งโมดูลใน Python
หลังจากที่ได้พาผู้อ่านไปเรียกใช้โมดูลในโฟลเลอร์เดียวกันมาแล้ว ต่อไปเราจะทำให้สามารถเรียกใช้งานโมดูลได้โดยที่ไม่ต้องเป็นต้องอยู่โฟลเลอร์เดียวกันกับไฟล์โมดูล เหมือนเราเรียกใช้โมดูล lxml , pyside โดยมีตัวอย่างต่อไปนี้
```python
from distutils.core import setup #ระบบติดตั้งโมดูล
setup(name='Distutils', #ชื่อโมดูล
version='1.0', #เวชั่นของโมดูล
description='Python Distribution Utilities', #รายละเอียดโมดูล
author='Greg Ward', #ชื่อผู้สร้างโมดูล
author_email='gward@python.net', #อีเมลล์ติดต่อผู้สร้างโมดูล
url='https://www.python.org/sigs/distutils-sig/', #หน้าเว็บโมดูล
packages=['distutils'], #packages ที่ถูกรวมด้วย โดย packages คือโฟลเลอร์ที่ใช้เก็บไฟล์โมดูลของเรา
)
```
ต่อไปลงมือทำโมดูลกัน โดยนำไฟล์ cal.py มาทำเป็นโมดูล โดยมีโค้ดดังต่อไป
**cal.py**
```python
def plue(arg):
return arg+arg
def plueto(a,b):
return a+b
```
สร้างโฟลเลอร์ใหม่ แล้วเก็บไฟล์ cal.py ไว้ในโฟลเลอร์ packages ที่เราสร้างขึ้นมาเพิ่มชื่อว่า cal
**รายละเอียดระบบไฟล์ของโมดูล**
```
โฟลเลอร์หลัก\
cal\
__init__.py
cal.py
setup.py
```
และผมสร้างไฟล์ __init__.py เป็นไฟล์สำหรับกำหนดค่าการเรียกใช้คำสั่งในโมดูล
**__init__.py**
```python
from cal import * # หมายถึงเรียกใช้โมดูลจากไฟล์ cal.py ที่อยู่ในโฟลเลอร์เดียวกัน โดยดึงคำสั่งทุกคำสั่งมา
```
เสร็จแล้วทำไฟล์ setup.py ซึ่งเป็นไฟล์ระบบล์ติดตั้งโมดูล โดยไว้ในโฟลเลอร์หลัก
โดยโค้ดไฟล์ setup.py มีดังนี้
**setup.py**
```python
from distutils.core import setup
setup(
name='cal',
version='0.0.1',
author='Wannaphong',
packages=['cal'],
url='https://python3.wannaphong.com',
license='MIT', #license
description='Test',
include_package_data=True,
)
```
แล้วเปิดคอมมานด์ไลน์ทำการติดตั้งโมดูลที่ผมทำขึ้นมาเอง
> python setup.py install
>
เสร็จแล้วลองรันใช้งานใน Python IDE ดู
> >>> from cal import cal
>
อ่านรายละเอียดของการทำไฟล์ติดตั้งโมดูลใน Python ได้ที่
[https://docs.python.org/3/distutils/setupscript.html](https://docs.python.org/3/distutils/setupscript.html)
### ส่งโมดูล Python ขึ้นไปยัง PyPI
**PyPI คืออะไร**
PyPI ย่อมาจาก Python Package Index เป็นคลังโปรแกรมและไลบรารีเสริมของ Python โดย Python เวชั่นใหม่ ๆ สามารถสั่งติดตั้งโมดูลจาก PyPI
ได้ด้วยคำสั่ง pip หรือคำสั่ง easy_install ได้
อย่างแรกให้ผู้อ่านสมัคร PyPI account สำหรับส่งโมดูลขึ้นไปยัง PyPI ได้ที่
[https://pypi.python.org/pypi?%3Aaction=register_form](https://pypi.python.org/pypi?%3Aaction=register_form)
โดยต้องใช้ PGP Key ID ด้วย อ่านวิธีการทำ PGP Key ID ได้ที่ [https://www.thaicert.or.th/papers/general/2013/pa2013ge002.html](https://www.thaicert.or.th/papers/general/2013/pa2013ge002.html)
หลังจากที่ยืนยันอีเมลเสร็จแล้ว ให้ผู้อ่านเตรียมความพร้อมของไฟล์เหล่านี้
1. ไฟล์ setup.py
ต้องมีรายละเอียดดังนี้
```python
from distutils.core import setup
def read(*paths):
"""สำหรับใช้ดึงข้อมูลจากไฟล์มาแสดง"""
with open(os.path.join(*paths), 'r') as f:
return f.read()
setup(
name = 'mypackage', # ชื่อโมดูล
packages = ['mypackage'], # โฟลเลอร์ไลบรารี
version = '0.1', #เวอร์ชั่นโมดูล
description = 'รายละเอียด',
long_description=(read('README.txt')), #รายละเอียดการใช้งานโมดูล
author = '', # ชื่อนักพัฒนา
author_email = '', # อีเมลนักพัฒนา
url = '', # ลิงค์หน้าหลักโมดูล
#download_url = '', # ลิงค์ดาวน์โหลด
keywords = ['testing', 'logging', 'example'], # คำค้น
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 3',
'Topic :: Scientific/Engineering',] # รายละเอียดเบื้องต้นของโมดูล
],
)
```
2. ไฟล์โมดูล
3. ไฟล์ README.txt
ไฟล์ README.txt นี้เป็นรายละเอียดการใช้งานโมดูลของเรา เหมือนที่เราเห็นทั่วไปตามหน้าเพจของ PyPI
สามารถสร้างไฟล์โดยอาคัยเครื่องมือจากเว็บ [http://rst.ninjs.org](http://rst.ninjs.org/)
4. ไฟล์ LICENSE.txt เป็นไฟล์ที่ระบุลิขสิทธิ์การใช้งานโมดูลของเรา เช่น ผมเลือก MIT สามารถเข้าไปที่ [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT)
เพื่อก็อบ LICENSE มาวางไว้ที่ LICENSE.txt ได้เลย
> แนะนำให้ใช้ภาษาอังกฤษทั้งหมด
>
เปิดคอมมานด์ไลน์เข้าไปยังโฟลเลอร์ที่เก็บไฟล์ setup.py ของโมดูล แล้วใช้คำสั่ง
> python setup.py register
>
```
>python setup.py register
running register
running check
We need to know who you are, so please choose either:
1. use your existing login,
2. register as a new user,
3. have the server generate a new password for you (and email it to you), or
4. quit
Your selection [default 1]:
1
Username:
Password:
Registering pytemperature to https://pypi.python.org/pypi
Server response (200): OK
I can store your PyPI login so future submissions will be faster.
(the login will be stored in C:\Users\วรรณพงษ์\.pypirc)
Save your login (y/N)?y
```
แล้วใช้คำสั่ง
> python setup.py sdist
>
จะได้โฟลเลอร์ dist โดยข้างในจะเก็บไฟล์บีบอัดโมดูลไว้
เสร็จแล้วทำการติดตั้งโมดูล twine เป็นโมดูลที่ช่วยอัพโหลดไฟล์ขึ้น PyPI
> pip install twine
>
จากนั้นทำการอัพโหลดไฟล์โมดูลขึ้น pypi
> twine upload dist/*
>
หลังจากนี้สามารถติดตั้งโมดูลของคุณได้จากคำสั่ง
> pip install ชื่อโมดูลของคุณ
>
## บทที่ 21 เริ่มต้นกับ NumPy
โมดูล NumPy เป็นโมดูลส่วนเสริมของภาษา Python สำหรับใช้คำนวณทางคณิตศาสตร์และวิทยาศาสตร์ โดยมีคำสั่งพร้อมใช้งานจำนวนมากมาย และโมดูลนี้สามารถสร้างข้อมูลชนิดอาร์เรย์ (ที่ภาษา Python ไม่มี) และคำนวณอาร์เรย์ของตัวเลข สตริงและวัตถุได้
โมดูล NumPy รองรับทั้ง Python 2 , Python 3 และใช้ License: BSD
**การติดตั้งโมดูล NumPy**
สามารถติดตั้งได้โดยใช้คำสั่ง pip: (ตรวจสอบการตั้งค่า c compiler กับ Python ให้เรียบร้อยก่อนติดตั้งครับ)
```bash
$ pip install numpy
```
สำหรับผู้ใช้ Windows สามารถโหลดไฟล์ .whl มาติดตั้งได้จาก [http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy](http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy)
### การใช้งาน NumPy
ในการใช้งานต้อง import NumPy เข้ามา
```python
import numpy as np
```
**ข้อมูลชนิดอาร์เรย์กับ NumPy**
อย่างที่เรารู้กัน ภาษา Python ไม่มีข้อมูลชนิดอาร์เรย์ สามารถใช้ list แทนได้ แต่หากใช้โมดูล NumPy เราจะสามารถใช้ข้อมูลชนิดอาร์เรย์ได้ดังนี้
```python
>>> x = np.array([1,2,3])
>>> x
array([1, 2, 3])
```
ต่อไปเราจะมาสร้าง array เก็บข้อมูลระหว่าง 0 - 10 กัน
```python
>>> x = np.arange(10)
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
```
เมื่อเรานำ x ที่เก็บข้อมูลอาร์เรย์ของตัวเลขไว้ มาบวกกับ 10 และนำมาบวกกับตัวมันเอง
```python
>>> x = np.arange(10)
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> y = x + 10 # มาบวกกับ 10
>>> y
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
>>> z = x + x # บวกกับตัวมันเอง
>>> z
array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
```
การเรียกใช้ข้อมูลจากอาร์เรย์ และแทนที่ข้อมูลในอาร์เรย์ได้ดังนี้
```python
>>> x = np.arange(10)
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> x[1]
1
>>> x[8]
8
>>> x[9]
9
>>> x[0] = 99
>>> x
array([99, 1, 2, 3, 4, 5, 6, 7, 8, 9])
```
หาค่าสูงสุด ต่ำสุด
```python
x = np.arange(5) + 1
x.mean() # ค่าเฉลี่ยเลขคณิต คือ 3.0
x.max() # ค่ามากสุดือ 5
x.min() # ค่าน้อยสุดคือ 1
x.std() # คำนวณส่วนเบี่ยงเบนมาตรฐาน คือ 1.414
```
ต่อไปเราจะย้ายข้อมูลอาร์เรย์จากแถวเดียว (อาร์เรย์ 1 มิติ) ไปเป็น 2 แถว (อาร์เรย์ 2 มิติ) ได้ โดยแถวและหลักต้องสมดุลกัน เป็นเมทริกซ์ สามารถใช้คำสั่ง reshape() ได้ดังนี้
```python
>>> x = np.arange(10)
>>> y = x.reshape(2,5) # สร้างเมทริกซ์ 2 * 5
>>> y
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
```
หากเรากำหนดค่าเมทริกซ์ไม่สมดุลกัน จะเกิดข้อผิดพลาดขึ้น เนื่องจากค่าเมทริกซ์ไม่สมดุล
```python
>>> x = np.arange(10)
>>> y = x.reshape(2,2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
```
**เมทริกซ์**
```python
>>> A = np.matrix('1.0 2.0; 3.0 4.0')
>>> A
[[ 1. 2.]
[ 3. 4.]]
>>> type(A) # ตรวจสอบชนิดของข้อมูลตัวแปร A
<class 'numpy.matrixlib.defmatrix.matrix'>
>>> A.T # เมทริกซ์สลับเปลี่ยน (transpose)
[[ 1. 3.]
[ 2. 4.]]
>>> X = np.matrix('5.0 7.0')
>>> Y = X.T
>>> Y
[[5.]
[7.]]
>>> print(A*Y) # การคูณเมทริกซ์
[[19.]
[43.]]
>>> print(A.I) # อินเวอร์สของเมทริกซ์
[[-2. 1. ]
[ 1.5 -0.5]]
```
อ่านเอกสารการใช้งาน NumPy เพิ่มเติมได้ที่ [http://wiki.scipy.org/Tentative_NumPy_Tutorial](http://wiki.scipy.org/Tentative_NumPy_Tutorial)
## บทที่ 22 เชื่อมต่อฐานข้อมูล MySQL ด้วยภาษาไพทอน
ในการเชื่อมต่อฐานข้อมูล MySQL ด้วยภาษาไพทอนสามารถใช้โมดูล mysql-connector ในการเชื่อมต่อฐานข้อมูล MySQLได้
โมดูล mysql-connector-python เป็น MySQL driver ที่เขียนในภาษาไพทอนทั้งหมด
(ไม่มีปัญหาเรื่องความเข้ากันได้) พร้อมรองรับ DB API v2.0 specification
(PEP-249) พัฒนาโดย Oracle
ใช้ License: GNU GPLv2
รองรับทั้ง Python 2 และ Python 3
สามารถติดตั้งได้โดยใช้คำสั่ง pip :
```
pip install mysql-connector-python
```
### เอกสารการใช้งาน
ในการเรียกใช้งานโมดูลนี้ต้อง
```python
import mysql.connector
```
เข้ามาทุกครั้ง
**การเชื่อมต่อกับฐานข้อมูล**
```python
import mysql.connector
# user: scott
# password: tiger
# host: 127.0.0.1
# database: employees
cnx = mysql.connector.connect(user='scott', password='tiger',host='127.0.0.1',database='employees')
cnx.close()
```
หากต้องการจัดการข้อผิดพลาดสามารถใช้ try except เข้ามาช่วยได้ดังนี้
แต่หากไม่ต้องการกรอกข้อมูลลงใน argument สามารถใช้ข้อมูลชนิด dictionary ช่วยในการเชื่อมต่อกับ
ฐานข้อมูลได้ดังนี้
```python
import mysql.connector
config = {
'user': 'scott',
'password': 'tiger',
'host': '127.0.0.1',
'database': 'employees',
'raise_on_warnings': True,
}
cnx = mysql.connector.connect(**config)
cnx.close()
```
### การใช้คำสั่ง SQL กับฐานข้อมูล MySQL ในภาษาไพทอน
เราสามารถใช้คำสั่ง SQL เพื่อสร้างฐานข้อมูล สร้างตาราง เพิ่มข้อมูลลงตาราง ปรับเปลี่ยนข้อมูล และลบข้อมูลได้ โดยใช้คำสั่ง
> cursor.execute(โค้ด SQl)
>
เมื่อใช้งานคำสั่งเสร็จ ต้องใช้คำสั่ง
> commit()
>
เพื่อบันทึกข้อมูลเสมอ
**ตัวอย่างเช่น**
ใช้คำสั่งสร้างตาราง
```python
import mysql.connector
from mysql.connector import errorcode
con = mysql.connector.connect(user='scott', password='tiger',host='127.0.0.1',database='employees')cursor = con.cursor()
sql = '''CREATE TABLE foo (
bar VARCHAR(50) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
'''
cursor.execute(sql)
con.commit()
con.close()
```
**การเพิ่มข้อมูล**
```python
import mysql.connector
con = mysql.connector.connect(user='scott', password='tiger',host='127.0.0.1', database='employees')
add_db = "insert into foo(bar) values('Tontan')"
cursor = con.cursor()
ccursor.execute(add_db)
con.commit()
con.close()
```
### การดึงข้อมูลมาใช้งาน
สามารถใช้คำสั่ง
> cursor.fetchall()
>
หลังคำสั่ง
> cursor.execute(โค้ด SQl)
>
โดยโค้ด SQl ต้องเป็นคำสั่ง query ข้อมูลตามหลักภาษา SQL
**ตัวอย่าง**
```python
import mysql.connector
con = mysql.connector.connect(user='scott', password='tiger',host='127.0.0.1',database='employees')
cursor = con.cursor()
sql = ("select bar from foo")
cursor.execute(sql)
data = cursor.fetchall() # ได้ผลลัพธ์ออกมาในรูป list
print(data[0])
```
ผลลัพธ์
```
Tontan
```
เอกสารการใช้งาน [http://dev.mysql.com/doc/connector-python/en/](http://dev.mysql.com/doc/connector-python/en/)
## บทที่ 23 เชื่อมต่อกับฐานข้อมูล SQLite ใน Python 3
การเรียกใช้ฐานข้อมูล SQLite ใน Python 3 เราต้องเรียกใช้โมดูลมาตรฐาน sqlite3 ด้วยการ import เข้ามา
> import sqlite3
>
ในการเชื่อมต่อฐานข้อมูลเราจะใช้คำสั่ง
> sqlite3.connect(database [,timeout ,other optional arguments])
>
หากต้องการ cursor ฐานข้อมูลใช้คำสั่ง
> connection.cursor([cursorClass])
>
รันคำสั่ง SQL กับฐานข้อมูล SQLite ใช้คำสั่ง
> cursor.execute(คำสั่ง sql [, optional parameters])
>
fetchall ใช้คำสั่ง
> cursor.fetchall()
>
หลังเพิ่มลบแก้ไข ให้
> connection.commit()
>
ปิดการเชื่อมต่อกับฐานข้อมูล SQLite
> connection.close()
>
เรามาเริ่มลองเขียนโปรแกรมกันครับ
### เปิดฐานข้อมูล SQLite ใน Python 3
```python
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('1.db') # สร้างไฟล์ 1.db เป็นไฟล์ฐานข้อมูล
print("เปิดฐานข้อมูลสำเร็จ")
```
**ผลลัพธ์**
> เปิดฐานข้อมูลสำเร็จ
>
และจะได้ไฟล์ฐานข้อมูล 1.db
### สร้างตารางฐานข้อมูล SQLite ใน Python 3
```python
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('1.db')
print("เปิดฐานข้อมูลสำเร็จ")
conn.execute('''CREATE TABLE SAVEONE
(ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
MESSENGE CHAR(150));''')
print("สร้างตารางสำเร็จ :D ")
conn.close()
```
**ผลลัพธ์**
> เปิดฐานข้อมูลสำเร็จ
>
### เพิ่มข้อมูล INSERT ลงไปฐานข้อมูล SQLite ใน Python 3
```python
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('1.db')
print("เปิดฐานข้อมูลสำเร็จ")
conn.execute("INSERT INTO SAVEONE (ID,NAME,MESSENGE ) \
VALUES (1, 'ต้นตาล','ทดสอบระบบ :D ')")
conn.execute("INSERT INTO SAVEONE (ID,NAME,MESSENGE ) \
VALUES (2, 'วรรณพงษ์','ทดสอบระบบ ครับ :D ')")
conn.commit()
print("เพิ่มระเบียงข้อมูลสำเร็จ")
conn.close()
```
**ผลลัพธ์**
> เปิดฐานข้อมูลสำเร็จ
>
### อ่านข้อมูลด้วยการเลือกตาราง (SELECT) กับฐานข้อมูล SQLite ใน Python 3
```python
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('1.db')
print("เปิดฐานข้อมูลสำเร็จ")
cursor = conn.execute("SELECT ID,NAME,MESSENGE from SAVEONE")
for row in cursor:
print("ID = ", row[0])
print("NAME = ", row[1])
print("MESSENGE = ", row[2])
print("ดำเนินการเสร็จสิ้น")
conn.close()
```
**ผลลัพธ์**
> เปิดฐานข้อมูลสำเร็จ
>
### fetchall ฐานข้อมูล
```python
import sqlite3
import sys
conn = sqlite3.connect('1.db')
with conn:
cur = conn.cursor()
cur.execute("SELECT * FROM SAVEONE")
rows = cur.fetchall()
for row in rows:
print(row)
input()
```
**ผลลัพธ์**
> (1, 'ต้นตาล','ทดสอบระบบ :D ')
>
### **อัปเดรตข้อมูลใหม่โดยใช้คำสั่ง UPDATE กับฐานข้อมูล SQLite ใน Python 3**
```python
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('1.db')
print("เปิดฐานข้อมูลสำเร็จ")
conn.execute("UPDATE SAVEONE set NAME = 'HI' where ID=1")
conn.commit()
print("แถวที่อัปเดรตข้อมูลใหม่ :", conn.total_changes)
cursor = conn.execute("SELECT ID,NAME,MESSENGE from SAVEONE")
for row in cursor:
print("ID = ", row[0])
print("NAME = ", row[1])
print("MESSENGE = ", row[2])
print("ดำเนินการเสร็จสิ้น")
conn.close()
input()
```
**ผลลัพธ์**
> เปิดฐานข้อมูลสำเร็จ
>
### ลบข้อมูล (DELETE) กับฐานข้อมูล SQLite ใน Python 3
```python
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('1.db')
print("เปิดฐานข้อมูลสำเร็จ")
conn.execute("DELETE from SAVEONE where ID=2;")
conn.commit()
print("แถวที่ถูกลบ :", conn.total_changes)
cursor = conn.execute("SELECT ID,NAME,MESSENGE from SAVEONE")
for row in cursor:
print("ID = ", row[0])
print("NAME = ", row[1])
print("MESSENGE = ", row[2])
print("ดำเนินการเสร็จสิ้น")
conn.close()
input()
```
**ผลลัพธ์**
> เปิดฐานข้อมูลสำเร็จ
>
อ่านรายละเอียดเพิ่มเติมได้ที่ [https://docs.python.org/3/library/sqlite3.html](https://docs.python.org/3/library/sqlite3.html)
## บทที่ 23 เขียนโปรแกรมเครือข่าย Socket ใน Python
Socket ในความหมายภาษาไทยแบบง่าย ๆ หมายถึง
เต้ารับที่สามาเอาอุปกรณ์มาเชื่อมต่อกันได้ เหมือนเต้ารับของปลั๊กไฟ
ในการเขียนโปรแกรม Socket คือ การสื่อสารระหว่างโปรแกรมบนเครือข่าย
ในการเขียนโปรแกรมเชื่อมต่อการสื่อสารนั้นเราต้องใช้ Socket API
โดยต้องระบุถึงโปรแกรมผ่าน Port Number
และที่อยู่ของเครื่องอีกเครื่องหนึ่งบนเครือข่ายด้วย IP Address
**สรุป**
> Socket Address = IP Address + Port Number
>
ในการเขียนโปรแกรมในปัจจุบัน ภาษาคอมพิวเตอร์ต่าง ๆ ได้รองรับ Socket
กันไปนานแล้ว เช่น Java , Python , C/C++ เป็นต้น การใช้งาน Socket
จึงไม่ได้จำกัดแค่ภาษาใดภาษาหนึ่ง
ในการเขียนโปรแกรมภาษา Python ได้รวม Socket API เข้ามาตั้งแต่ต้นแล้ว เวลาเรียกใช้งานต้อง
> import socket
>
เข้ามาในโค้ดโปรแกรม
**รายละเอียดเบื้องต้นของโมดูล Socket ใน Python :**
- socket.listen() – listen สำหรับการเชื่อมต่อขาเข้า
- socket.accept() – ยอมรับการเชื่อมต่อขาเข้า
- socket.recv() – ส่งกลับข้อมูลที่เข้ามาเป็น string
- socket.send() – ส่งข้อมูลไปยังไคลเอนต์ socket
- socket.close() – ปิดซ็อกเก็ต
มาลองเขียนโปรแกรมเครือข่าย Socket ส่งข้อมูลข้ามเครือข่ายกัน
ในการรับส่งข้อมูล ต้องมีผู้ส่งสาร สื่อ และผู้รับสาร โดยส่ง และรับข้อมูล โดย TCP ใน Python
**โค้ด client.py**
```python
import socket
TCP_IP = "127.0.0.1" # ที่อยู่ ip
TCP_PORT = 8081 # port
BUFFER_SIZE = 1024
MESSAGE = "Hello, World!" # ข้อความที่จะส่ง
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TCP_IP,TCP_PORT)) #เชื่อมต่อ
s.send(MESSAGE.encode('utf-8')) #ส่งข้อมูลโดยก่อนส่งได้เข้ารหัสตัวอักษรเป็น utf-8
data = s.recv(BUFFER_SIZE) #ดึงผลลัพธ์การส่งข้อมูล
s.close() #จบการเชื่อมต่อ
print("received data:", data) #แสดงผลลัพธ์การส่งข้อมูล
```
**โค้ด server.py**
```python
import socket
TCP_IP = "127.0.0.1"
TCP_PORT = 8081
BUFFER_SIZE = 1024
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TCP_IP,TCP_PORT)) #เชื่อมต่อ
s.listen(1)
conn, addr = s.accept() #รอรับข้อมูลที่ส่งมาจาก client.py
print('Connection address:', addr) #แสดงลายละเอียดของ client ที่เชื่อมต่อมา
while 1:
data = conn.recv(BUFFER_SIZE)
if not data: break
print("received data:", data) #แสดงข้อมูลที่ส่งมา
conn.send(data) # echo
conn.close() #จบการเชื่อมต่อ
```
ในการรัน ต้องรันไฟล์ server.py ก่อนครับ เพราะ server.py เป็นไฟล์เซิร์ฟเวอร์สำหรับรับและส่งข้อมูล แล้วจึงค่อยรัน client.py
**ผลลัพธ์**
ไฟล์ server.py
```
Connection address: ('127.0.0.1', 60447)
received data: b'Hello, World!'
```
ไฟล์ client.py
> received data: b'Hello, World!'
>
จากโปรแกรมข้างบนจะพบว่า เราได้กำหนดค่า IP Address เป็น 127.0.0.1
นั้นคือส่งข้อมูลภายในเครื่อง เพื่อทดสอบโปรแกรมและกำหนดค่า Port Number
เป็น 8081 โดย Port Number ต้องห้ามซ้ำกับ Port Number ที่มีอยู่ในระบบ
หากเอาไปใช้งานผ่านเครือข่ายให้แก้ IP Address และ Port Number
ตามที่ต้องการ
## Python Cheat Sheet เบื้องต้น
เป็น Cheat Sheet สำหรับไวยากรณ์ภาษา Python เบื้องต้น
### **การดำเนินการทางตรรกะพื้นฐาน**
if :
```python
if test:
หาก test เป็นจริงจะทำงานตามคำสั่งในนี้
elif test2:
หาก test2 เป็นจริงจะทำงานตามคำสั่งในนี้
else:
หากเงื่อนไขทั้งหมดเป็นเท็จ จะทำงานตามนี้
```
### **Python loop**
for :
```python
for x in aSequence:
#ดำเนินการสมาชิกแต่ละตัวใน aSequence
#ตัวอย่างเช่น สมาชิกที่อยู่ใน list
#ตัวอักษรที่อยู่ใน string เป็นต้น
for x in range(10):
#ดำเนินการ 10 ครั้ง (0 ถึง 9)
for x in range(5,10):
#ดำเนินการ 5 ครั้ง (5 ถึง 9)
```
while :
```python
while test:
#ทำจนกว่าจะสิ้นสุด
#จนกว่า test จะเป็น false
```
### **Python Strings**
Strings เป็นลำดับของอักษระที่เรียงต่อกัน มักเป็นข้อความที่เก็บไว้
การสร้าง :
```
the_string = "Hello World!"
the_string = 'Hello World!'
```
การเข้าถึงตัวอักษรตามลำดับ `the_string[1]` คืนค่า `e`
การแยก String `the_string.split(" ")` คืนค่า `['Hello', 'World!']`
ในการแปลง List เป็นสตริง เราสามารถทำได้ด้วยคำสั่ง join()
```
words = ["this", "is", "a", "list", "of", "strings"]
```
`' '.join(words)` คืนค่า `"This is a list of strings"`
`'ZOOL'.join(words)` คืนค่า `"ThisZOOLisZOOLaZOOLlistZOOLofZOOLstrings"`
`"".join(words)` คืนค่า `"Thisisalistofstrings"`
String Formatting : เหมือนกับ printf() ของภาษา C โดยใช้ % หลังสตริงตามด้วย tuple โดยมีสตริงอยู่ภายใน เช่น
```
the_string = "Hello World!"
print("text : %s" % the_string)
```
ผลลัพธ์ text : Hello World!
แปลงสตริงจากตัวพิมพ์ใหญ่เป็นตัวพิมพ์เล็ก "PYTHON".lower() คืนค่า "python"
แปลงสตริงจากตัวพิมพ์เล็กเป็นตัวพิมพ์ใหญ่ "python".upper() คืนค่า PYTHON
นับจำนวนสตริงที่กำหนด "pythonpy".count("py") คืนค่า 2
ค้นหาตำแหน่งสตริงที่ต้องการ "python".find("n") คืนค่า 5 และสามารถค้นหาแบบกำหนดช่วงได้ "pythonpython".find("n",4,6) คืนค่า 5
แทนที่สตริง "pythonpython".replace("py","go") คืนค่า "gothongothon"
### Python Dictionaries
การสร้าง :
```
emptyDict = {}
thisdict = {"a":1, "b":23, "c":"eggs"}
```
การดึงข้อมูล : thisdict["a"] คืนค่า 1
### Python List
การสร้าง List :
```
thelist = ['5', '3', 'p', '9', 'e']
thelist = list('53p9e') # ['5', '3', 'p', '9', 'e']
```
การเข้าถึงข้อมูล : thelist[0] คืนค่า '5'
**ดึง List เฉพาะส่วนที่ต้องการ :**
thelist[1:3] คืนค่า ['3', 'p']
thelist[2:] คืนค่า ['p', '9', 'e']
thelist[:2] คืนค่า ['5', '3']
thelist[2:-1] คืนค่า ['p', '9']
วัดความยาว len(thelist) คืนค่า 5
เรียงลำดับ list ใหม่ thelist.sort() ตอนนี้ list กลายเป็น [3,5,9,'e','p']
เพิ่ม thelist.append(7) ตอนนี้ list กลายเป็น [3,5,9,'e','p',7]
คืนค่า และ ลบค่าออก thelist.pop() คืนค่า 7 ตอนนี้ list กลายเป็น [3,5,9,'e','p']
แทรก List thelist.insert(1, 't') ตอนนี้ list กลายเป็น ['5', 't', '3', 'p', '9', 'e']
ลบค่า thelist.remove("t") ตอนนี้ list กลายเป็น ['5', '3', 'p', '9', 'e']
del thelist[0] ตอนนี้ list กลายเป็น ['3', 'p', '9', 'e']
บวก list thelist + [0] คืนค่า ['3', 'p', '9', 'e', 0]
ค้นหาค่าใน List '3' in thelist คืนค่า True
### Python Tuples
การสร้าง Tuples :
```
emptyTuple = ()
singleItemTuple = ("spam",) # note the comma!
thistuple = 12, 89, 'a'
thistuple = (12, 89, 'a')
```
การดึงข้อมูล : thistuple[0] คืนค่า 12
### Python File
**การเปิดไฟล์:**
```
thisfile = open("datadirectory/file.txt",โหมดเปิดไฟล์)
```
โหมดการเปิดไฟล์
- w เขียนไฟล์
- r อ่านไฟล์
- a เขียนไฟล์ต่อจากข้อมูลเดิม
หากไม่กำหนดโหมดการเปิดไฟล์ ค่าพื้นฐานเป็น r อ่านได้เท่านั้น
**คำสั่งเพิ่มเติม**
- `thisfile.read()` อ่านสตริงตัวแรกจากไฟล์
- `thisfile.readline()` อ่านข้อมูล 1 บรรทัดจากไฟล์
- `thisfile.readlines()` อ่านข้อมูลจากบรรทัดทั้งหมดในไฟล์
- `for eachline in thisfile:` อ่านบรรทัดต่อบรรทัดในไฟล์
- `thisfile.write()` เขียนไฟล์
- `thisfile.close()` ปิดไฟล์
หากทำงานกับภาษาไทย แนะนำให้ใช้ codecs โดยใช้ utf-8
```python
import codecs
thisfile = codecs.open("datadirectory/file.txt",โหมดเปิดไฟล์, encoding="utf-8")
```
### Python Functions
```python
def myFunc(param1, param2):
# param1 และ param2 ใช้รับข้อมูลเมื่อใช้งาน myFunc(ข้อมูล1,ข้อมูล2)
# หากไม่มีการรับข้อมูล ไม่ต้องใส่ param ก็ได้
return param1+param2
```
### Python Class
```python
class FC:
def __init__(self,one,ten):
self.one = one
self.ten = ten
def show(self):
print (self.ten,"-",self.one,"=",self.ten - self.one)
a = FC(one=1,ten=10)
a.show()
``` | https://python3.wannaphong.com | CC-BY 4.0 |
มหาวิหารกับตลาดสด (The Cathedral and the Bazaar) | มหาวิหารกับตลาดสด
Eric
Steven
Raymond
Thyrsus Enterprises
esr@thyrsus.com
$Date: 2009-01-06 14:39:20 $
นี่คือรุ่น 3.0
2543
Eric S. Raymond
สงวนลิขสิทธิ์
อนุญาตให้ทำสำเนา แจกจ่าย และ/หรือ แก้ไขเอกสารนี้ได้ ภายใต้เงื่อนไขของ Open Publication License รุ่น 2.0
ผมวิเคราะห์แยกแยะโครงการโอเพนซอร์สที่ประสบความสำเร็จโครงการหนึ่ง คือ fetchmail ซึ่งดำเนินการโดยเจตนาจะทดสอบทฤษฎีที่น่าประหลาดใจเกี่ยวกับวิศวกรรมซอฟต์แวร์ ที่ได้มาจากการพิจารณาความเป็นมาของลินุกซ์ ผมกล่าวถึงทฤษฎีเหล่านี้ในมุมมองของรูปแบบการพัฒนาสองแนวทางที่แตกต่างกันโดยสิ้นเชิง คือรูปแบบ ``มหาวิหาร'' ที่ใช้กันในโลกพาณิชย์เกือบทั้งหมด กับรูปแบบ ``ตลาดสด'' ของโลกลินุกซ์ ผมแสดงให้เห็นว่า รูปแบบเหล่านี้เกิดจากข้อสมมุติที่ขัดแย้งกัน เกี่ยวกับธรรมชาติของงานแก้บั๊กซอฟต์แวร์ จากนั้น ผมได้ให้ทัศนะพร้อมเหตุผลรองรับที่ได้จากประสบการณ์ของลินุกซ์สำหรับข้อเสนอที่ว่า ``ขอให้มีสายตาเฝ้ามองมากพอ บั๊กทั้งหมดก็เป็นเรื่องง่าย'' ผมเปรียบข้อเสนอดังกล่าวกับระบบซึ่งมีการแก้ไขตัวเองของตัวกระทำที่เห็นแก่ตัว และสรุปด้วยการสำรวจนัยของแนวคิดนี้สำหรับอนาคตของวงการซอฟต์แวร์
ลินุกซ์คือผู้ล้มยักษ์ เมื่อ 5 ปีที่แล้ว (ปี 1991) ใครจะไปคิดว่าระบบปฏิบัติการระดับโลก จะก่อตัวขึ้นราวกับมีเวทมนตร์จากการแฮ็กเล่นๆ ในเวลาว่างของนักพัฒนานับพันจากทั่วโลกที่เชื่อมต่อกันด้วยเส้นใยบางๆ อย่างอินเทอร์เน็ตเท่านั้น
ผมคนหนึ่งล่ะ ที่ไม่เชื่อ ตอนที่ลินุกซ์เข้ามาอยู่ในความสนใจของผมเมื่อต้นปี 1993 นั้น ผมได้เข้ามาเกี่ยวข้องกับยูนิกซ์ และการพัฒนาแบบโอเพนซอร์สมาสิบปีแล้ว ผมยังเป็นหนึ่งในผู้สมทบงานให้ GNU เป็นคนแรกๆ ในช่วงกลางทศวรรษ 1980 ผมได้ปล่อยซอฟต์แวร์โอเพนซอร์สออกสู่อินเทอร์เน็ตแล้วหลายตัว โดยได้สร้างและร่วมสร้างโปรแกรมหลายโปรแกรม (nethack, โหมด VC และ GUD ของ Emacs, xlife และอื่นๆ) ซึ่งยังคงใช้กันอยู่แพร่หลายในทุกวันนี้ ผมคิดว่าตัวเองรู้ดีเรื่องการพัฒนาซอฟต์แวร์
แต่ลินุกซ์ได้ลบล้างสิ่งที่ผมเคยคิดว่ารู้ไปมาก ผมเคยพร่ำสอนเกี่ยวกับบัญญัติยูนิกซ์ เรื่องการเขียนโปรแกรมขนาดเล็ก การสร้างต้นแบบอย่างเร็ว และการเขียนโปรแกรมแบบวิวัฒนาการมาหลายปี แต่ผมยังเชื่ออีกด้วย ว่ามีความซับซ้อนวิกฤติระดับหนึ่ง ที่ถ้าเลยขั้นนี้ไป ก็ต้องใช้วิธีพัฒนาที่รวมศูนย์ มีทฤษฎีมากกว่านั้น ผมเชื่อว่าซอฟต์แวร์ที่สำคัญๆ (เช่น ระบบปฏิบัติการ และโปรแกรมขนาดใหญ่อย่าง Emacs) ควรจะถูกสร้างเหมือนสร้างมหาวิหาร (cathedral) โดยพ่อมดซอฟต์แวร์สักคน หรือผู้วิเศษกลุ่มเล็กๆ เป็นผู้ประดิษฐ์ขึ้นอย่างบรรจง ในดินแดนโดดเดี่ยวอันศักดิ์สิทธิ์ ไม่มีตัวทดสอบ (beta) ออกมาให้ลองก่อนเวอร์ชันจริง
วิธีการพัฒนาของไลนัส ทอร์วัลด์ เป็นเรื่องแปลกประหลาด วิธีของเขาคือ `ออกเนิ่นๆ ออกถี่ๆ มอบงานทุกส่วนให้คนอื่นเท่าที่จะทำได้ และเปิดกว้างถึงขั้นสำส่อน' นี่ไม่ใช่การสร้างมหาวิหารอย่างเงียบเชียบด้วยความเทิดทูนบูชา ชุมชนของลินุกซ์นั้น เหมือนกับตลาดสด (bazaar) ที่เอะอะอื้ออึงฟังไม่ได้ศัพท์ ซึ่งแต่ละคนมีวาระและวิธีการที่แตกต่างหลากหลาย (เห็นได้จากไซต์ FTP ของลินุกซ์ ที่ใครก็สามารถส่งผลงานของตัวเองเข้ามาได้) การจะเกิดระบบปฏิบัติการที่เสถียรและเป็นเอกภาพขึ้นได้จากสภาพดังกล่าว จึงดูเหมือนต้องเป็นผลจากปาฏิหาริย์เท่านั้น
ความจริงที่ว่าการพัฒนาแบบตลาดสดนี้ใช้งานได้ และได้ผลดีด้วยนั้น เป็นเรื่องน่าตกใจมาก ขณะที่ผมเรียนรู้ไปเรื่อยๆ นั้น ผมไม่เพียงทุ่มเทให้กับโครงการทั้งหลาย แต่ผมยังพยายามหาสาเหตุ ว่าทำไมโลกของลินุกซ์จึงไม่เพียงไม่แตกเป็นเสี่ยงๆ ด้วยความโกลาหล แต่ยังกลับแข็งแกร่งและมั่นคงขึ้นเรื่อยๆ ด้วยอัตราเร็วที่นักสร้างมหาวิหารแทบไม่สามารถจินตนาการถึงได้
กลางปี 1996 ผมคิดว่าผมเริ่มเข้าใจแล้ว ผมมีโอกาสอันยอดเยี่ยมที่จะทดสอบทฤษฎีของตัวเอง ในรูปแบบของโครงการโอเพนซอร์ส ซึ่งผมสามารถเจาะจงให้พัฒนาในแบบตลาดสดได้ ผมจึงลองทำดู และมันก็ประสบความสำเร็จดีทีเดียว
เรื่องราวต่อไปนี้เป็นเรื่องของโครงการดังกล่าว ผมจะใช้ตัวอย่างนี้เสนอคติสำหรับการพัฒนาแบบโอเพนซอร์สที่ได้ผล หลายอย่างไม่ใช่สิ่งที่ผมเพิ่งเรียนรู้เป็นครั้งแรกจากโลกของลินุกซ์ แต่เราจะเห็นว่าโลกของลินุกซ์ทำให้มันสำคัญขึ้นมาอย่างไร ถ้าผมคิดไม่ผิด คติเหล่านี้จะช่วยให้คุณเข้าใจมากขึ้น ว่าอะไรคือสิ่งที่ทำให้สังคมลินุกซ์กลายเป็นบ่อเกิดของซอฟต์แวร์ดีๆ และอาจช่วยทำให้คุณพัฒนาผลิตภาพของคุณเองให้มากขึ้นได้ด้วย
ต้องส่งเมลให้ได้
ตั้งแต่ปี 1993 ผมเป็นผู้บริหารงานด้านเทคนิคของผู้ให้บริการอินเทอร์เน็ตฟรีเล็กๆ ที่ชื่อว่า Chester Country InterLink (CCIL) ซึ่งอยู่ใน West Chester รัฐเพนซิลเวเนีย ผมเป็นผู้ร่วมก่อตั้ง CCIL และได้เขียนซอฟต์แวร์กระดานข่าวที่ไม่เหมือนใครและรองรับหลายผู้ใช้ของเราขึ้น ซึ่งคุณสามารถลองได้โดยเทลเน็ตไปยัง <ulink url="telnet://locke.ccil.org">locke.ccil.org</ulink> ปัจจุบันระบบนี้รองรับผู้ใช้สามพันคนด้วยสามสิบคู่สาย งานนี้ทำให้ผมสามารถเข้าสู่อินเทอร์เน็ตได้ตลอด 24 ชั่วโมง ผ่านเครือข่ายความเร็ว 56K ของ CCIL ความจริงความสามารถนี้เป็นเรื่องจำเป็นในงานแบบนี้อยู่แล้ว
ผมเคยตัวกับการรับส่งอีเมลได้อย่างทันใจ จนรู้สึกว่าการต้องเทลเน็ตไปยัง locke เป็นระยะๆ เพื่อเช็กอีเมลนั้น เป็นเรื่องน่ารำคาญ ผมต้องการให้อีเมลของผมถูกส่งไปยัง snark (ชื่อเครื่องที่บ้านผม) เพื่อที่ผมจะได้รับการแจ้งเตือนเมื่ออีเมลมาถึง และสามารถจัดการอีเมลด้วยโปรแกรมบนเครื่องของผมเอง
โพรโทคอลหลักสำหรับส่งเมลบนอินเทอร์เน็ต คือ SMTP (Simple Mail Tranfer Protocol) นั้น ไม่ตรงกับความต้องการ เพราะมันจะทำงานได้ดีต่อเมื่อเครื่องของเราต่ออินเทอร์เน็ตอยู่ตลอดเวลา แต่เครื่องของผมไม่ได้ต่ออยู่ตลอด และไม่มีหมายเลขไอพีที่แน่นอนด้วย สิ่งที่ผมต้องการคือโปรแกรมที่ติดต่อออกผ่านการเชื่อมต่อชนิดไม่ต่อเนื่อง และดึงจดหมายมาส่งบนเครื่อง ผมรู้ว่ามีโปรแกรมประเภทนี้อยู่ และส่วนมากมักจะใช้โพรโทคอลแบบง่ายๆ ที่ชื่อ POP (Post Office Protocol) ซึ่งโปรแกรมอีเมลทุกวันนี้ส่วนมากรู้จักและสนับสนุน แต่ว่าตอนนั้น มันไม่มีอยู่ในโปรแกรมเมลที่ผมใช้อยู่
ผมต้องการโปรแกรมอ่าน POP3 ดังนั้นผมจึงค้นหาในอินเทอร์เน็ต และพบโปรแกรมหนึ่ง ความจริงผมพบโปรแกรมอย่างนี้ถึง 3-4 ตัว ผมลองใช้โปรแกรมหนึ่งไปสักพัก แต่มันขาดความสามารถที่ควรจะมีอย่างยิ่ง คือการเข้าไปแก้ที่อยู่ของเมลที่ดึงมา เพื่อที่จะตอบจดหมายกลับได้ถูกต้อง
ปัญหามีดังนี้ สมมุติว่าใครบางคนชื่อ joe ที่อยู่ที่ locke ส่งเมลมาหาผม ถ้าผมดึงเมลมายัง snark และตอบเมลฉบับนี้ โปรแกรมเมลของผมจะพยายามส่งไปยังผู้ใช้ที่ชื่อ joe บน snark ซึ่งไม่มีอยู่ และการแก้ที่อยู่เองให้เป็น <email>@ccil.org</email> นั้น ก็ไม่ใช่เรื่องที่น่าสนุกนัก
สิ่งนี้เป็นสิ่งที่คอมพิวเตอร์ควรจะทำให้ผม แต่ว่าไม่มีโปรแกรมอ่าน POP ตัวไหนเลยที่มีอยู่ในขณะนั้นที่ทำได้ และนี่ก็พาเรามารู้จักกับบทเรียนข้อแรก:
1. ซอฟต์แวร์ดีๆ เริ่มมาจากการสนองความต้องการส่วนตัวของผู้พัฒนา
เรื่องนี้คงชัดเจนอยู่แล้ว (มีสุภาษิตมานานแล้วว่า ``ความจำเป็น คือบ่อเกิดของการคิดค้น'') แต่ก็มีนักพัฒนาจำนวนมากที่ใช้เวลาแต่ละวันไปกับการปั่นงานแลกเงิน เพื่อสร้างโปรแกรมที่เขาไม่ได้ต้องการ หรือไม่ได้รักที่จะทำ แต่ไม่เป็นเช่นนั้นในโลกของลินุกซ์ ซึ่งอาจเป็นคำอธิบายว่าทำไมคุณภาพเฉลี่ยของซอฟต์แวร์ที่สร้างโดยชุมชนลินุกซ์จึงสูงกว่าปกติ
แล้วผมก็เลยกระโจนเข้าสู่การสร้างโปรแกรม POP3 ตัวใหม่อย่างบ้าคลั่ง เพื่อเอาไปแข่งกับตัวเดิมๆ ทันทีอย่างนั้นหรือ? ไม่มีวันหรอก! ผมได้สำรวจเครื่องมือจัดการ POP ที่มีอยู่ในมือ และถามตัวเองว่า ``โปรแกรมไหนที่ใกล้เคียงกับสิ่งที่ผมต้องการมากที่สุด?'' เพราะว่า:
2. โปรแกรมเมอร์ที่ดีย่อมรู้ว่าจะเขียนอะไร แต่โปรแกรมเมอร์ที่ยอดเยี่ยมจะรู้ว่าอะไรต้องเขียนใหม่ และอะไรใช้ของเก่าได้
ผมไม่ได้บอกว่าตัวเองเป็นโปรแกรมเมอร์ที่ยอดเยี่ยม ผมแค่พยายามเลียนแบบดู คุณสมบัติที่สำคัญของโปรแกรมเมอร์ที่ยอดเยี่ยมก็คือ ความขี้เกียจอย่างสร้างสรรค์ พวกเขารู้ว่าคุณได้เกรด A ไม่ใช่เพราะความพยายาม แต่เพราะผลของงานต่างหาก และมันก็มักจะง่ายกว่าที่จะเริ่มต้นจากบางส่วนที่มีอยู่แล้ว แทนที่จะเริ่มใหม่ทั้งหมด
ตัวอย่างเช่น <ulink url="http://catb.org/~esr/faqs/linus">ไลนัส ทอร์วัลด์</ulink> ไม่ได้สร้างลินุกซ์ขึ้นมาจากศูนย์ เขาเริ่มด้วยโค้ดและความคิดบางส่วนจากมินิกซ์ ซึ่งเป็นยูนิกซ์ขนาดเล็กสำหรับเครื่องพีซี ต่อมาโค้ดของมินิกซ์ก็หายไปหมด ถ้าไม่ถูกถอดออกก็ถูกแทนที่ด้วยโค้ดใหม่ๆ แต่ตอนที่ยังอยู่ มันได้ทำหน้าที่เสมือนโครงนั่งร้านสำหรับสร้างสรรค์ทารกที่จะกลายมาเป็นลินุกซ์ในที่สุด
ด้วยแนวคิดเดียวกัน ผมจึงค้นหาโปรแกรม POP ที่มีอยู่แล้ว โดยเลือกตัวที่เขียนไว้อย่างดีพอสมควร เพื่อใช้เป็นจุดเริ่มต้นในการพัฒนา
ธรรมเนียมการแบ่งปันซอร์สโค้ดในโลกของยูนิกซ์ ทำให้การนำโค้ดไปใช้ใหม่เป็นเรื่องง่ายมาแต่ไหนแต่ไร (นี่เป็นเหตุผลว่าทำไม GNU ถึงได้เลือกยูนิกซ์เป็นระบบปฏิบัติการหลัก แม้จะสงวนท่าทีชัดเจนว่าไม่ใช่ยูนิกซ์ก็ตาม) โลกของลินุกซ์ได้นำเอาธรรมเนียมนี้มาใช้อย่างเต็มพิกัดทางเทคโนโลยี ทำให้เรามีโปรแกรมโอเพนซอร์สจำนวนมหาศาล ดังนั้นการใช้เวลาเสาะหาโปรแกรมที่เกือบจะดีอยู่แล้วของใครสักคน จะทำให้คุณได้ผลลัพธ์ดีๆ ในโลกของลินุกซ์มากกว่าที่อื่น
แล้วมันก็ได้ผลสำหรับผม เมื่อรวมกับโปรแกรมที่ผมพบครั้งก่อน การค้นหาครั้งที่สองเพิ่มรายชื่อโปรแกรมที่เข้าท่าขึ้นเป็นเก้าตัว คือ fetchpop, PopTart, get-mail, gwpop, pimp, pop-perl, popc, popmail และ upop ตัวแรกที่ผมเลือกคือ fetchpop ซึ่งสร้างโดย Seung-Hong Oh ผมได้เขียนความสามารถในการเปลี่ยนหัวจดหมายเข้าไป และปรับปรุงการทำงานอื่นๆ ซึ่งผู้สร้างได้รับเข้าไปใช้ในเวอร์ชัน 1.9
ไม่กี่สัปดาห์ต่อมา ผมบังเอิญได้อ่านโค้ดของ popclient ซึ่งสร้างโดย คาร์ล แฮร์ริส เลยพบปัญหาว่า ถึงแม้ fetchpop จะมีแนวคิดดีๆ ที่ไม่เหมือนใคร (อย่างเช่นการทำงานในโหมดดีมอนเบื้องหลัง) แต่มันทำงานได้กับ POP3 เท่านั้น และโค้ดของมันก็ค่อนข้างเป็นงานของมือสมัครเล่น (ตอนนั้น Seung-Hong เป็นโปรแกรมเมอร์ที่เก่ง แต่ขาดประสบการณ์ ซึ่งลักษณะทั้งสองแสดงให้เห็นในตัวโค้ด) ผมพบว่าโค้ดของคาร์ลดีกว่า ดูเป็นมืออาชีพและแน่นหนา แต่โปรแกรมของเขายังขาดความสามารถที่สำคัญและค่อนข้างทำยาก ที่มีใน fetchpop (ซึ่งบางอย่างเป็นฝีมือของผม)
จะเปลี่ยนไหม? ถ้าผมเลือกจะเปลี่ยน ผมต้องทิ้งสิ่งที่ผมสร้างขึ้นมา เพื่อแลกกับโปรแกรมใหม่อันเป็นฐานการพัฒนาที่ดีกว่า
แรงจูงใจในทางปฏิบัติที่จะเปลี่ยน คือการได้ความสามารถในการสนับสนุนหลายโพรโทคอล โพรโทคอล POP3 เป็นโพรโทคอลที่ใช้กันมากในเครื่องแม่ข่ายตู้ไปรษณีย์เมล แต่ก็ไม่ใช่โพรโทคอลเดียว fetchpop และโปรแกรมคู่แข่งตัวอื่นไม่สนับสนุน POP2, RPOP หรือ APOP และผมยังมีเค้าความคิดที่จะเพิ่ม <ulink url="http://www.imap.org">IMAP</ulink> (Internet Message Access Protocol) ซึ่งเป็นโพรโทคอลที่ออกแบบมาใหม่ล่าสุด และมีประสิทธิภาพมากที่สุดเข้าไปอีกด้วย เพื่อความมัน
แต่ผมมีเหตุผลทางทฤษฎีที่คิดว่าการเปลี่ยนอาจจะดีก็ได้ ซึ่งเป็นสิ่งที่ผมเรียนรู้มานานก่อนจะพบกับลินุกซ์
3. ``เตรียมพร้อมที่จะทิ้งสิ่งเดิมไป คุณได้ทิ้งแน่ ไม่ว่าจะอย่างไร'' (จาก เฟรด บรูกส์ ใน <citetitle>The Mythical Man-Month</citetitle>, บทที่ 11)
หรืออีกนัยหนึ่ง คุณมักจะไม่ได้เข้าใจปัญหาอย่างแท้จริง จนกว่าคุณจะเริ่มลงมือทำครั้งแรก พอลงมือครั้งที่สอง คุณอาจรู้มากพอจะทำสิ่งที่ถูกแล้ว ดังนั้นถ้าคุณต้องการทำให้ถูกต้องจริงๆ ก็ควรเตรียมพร้อมที่จะเริ่มต้นใหม่ <link linkend="JB">[JB]</link>
ผมบอกตัวเองว่าสิ่งที่ผมเพิ่มเข้าไปใน fetchpop เป็นความพยายามครั้งแรกของผม ดังนั้นผมจึงเปลี่ยน
หลังจากผมส่งแพตช์ชุดแรกไปให้ คาร์ล แฮร์ริส เมื่อวันที่ 25 มิถุนายน 1996 ผมพบว่าเขาเลิกสนใจ popclient ไปก่อนหน้านั้นแล้ว ตัวโค้ดดูสกปรก และมีบั๊กเล็กๆ น้อยๆ ประปราย ผมมีเรื่องที่อยากแก้หลายจุด และเราก็ตกลงกันได้อย่างรวดเร็ว ว่าสิ่งที่สมเหตุสมผลที่สุดคือผมควรจะรับโปรแกรมนี้ไปดูแลต่อ
เผลอไม่ทันไร โครงการของผมก็โตพรวดพราด ผมไม่ได้คิดถึงแค่แพตช์เล็กแพตช์น้อยสำหรับโปรแกรม POP ที่มีอยู่แล้วอีกต่อไป ผมกำลังดูแลโปรแกรมทั้งตัว และผมก็เกิดความคิดในสมองมากมาย ซึ่งผมรู้ดีว่าจะนำไปสู่ความเปลี่ยนแปลงขนานใหญ่
ในวัฒนธรรมซอฟต์แวร์ที่เน้นการแบ่งปันโค้ด นี่เป็นวิถีทางตามธรรมชาติที่โครงการต่างๆ จะก้าวหน้าต่อไป ผมกำลังทำตามหลักการนี้:
4. ถ้าคุณมีทัศนคติที่เหมาะสม ปัญหาที่น่าสนใจจะมาหาคุณเอง
แต่ทัศนคติของ คาร์ล แฮร์ริส นั้นสำคัญยิ่งกว่า เขาเข้าใจดีว่า
5. เมื่อคุณหมดความสนใจในโปรแกรมใดแล้ว หน้าที่สุดท้ายของคุณคือ ส่งมันต่อให้กับผู้สืบทอดที่มีความสามารถ
ผมและคาร์ลรู้โดยไม่ต้องคุยกันในเรื่องนี้เลย เรามีเป้าหมายร่วมกันที่จะหาคำตอบที่ดีที่สุดที่มีอยู่ คำถามเดียวที่เกิดขึ้นกับแต่ละฝ่ายก็คือ ผมจะพิสูจน์ได้ไหม ว่าผมคือผู้ดูแลที่ควรวางใจ เมื่อผมทำได้ เขาก็จากไปอย่างนุ่มนวล ผมหวังว่าผมจะทำเช่นนั้นเหมือนกัน เมื่อถึงตาที่ผมต้องส่งต่อให้คนอื่น
ความสำคัญของการมีผู้ใช้
และแล้วผมก็รับช่วง popclient ต่อมา และที่สำคัญไม่แพ้กันคือ ผมรับช่วงฐานผู้ใช้ของ popclient มาด้วย การมีผู้ใช้เป็นสิ่งที่ยอดมาก ไม่ใช่แค่เพราะพวกเขาแสดงให้เห็น ว่าคุณกำลังสนองความต้องการที่มีอยู่จริง ว่าคุณกำลังทำสิ่งที่ควร แต่ถ้าบ่มเพาะดีๆ เขาก็อาจมาเป็นผู้ร่วมพัฒนากับคุณได้
จุดแข็งอีกอย่างหนึ่งในขนบของยูนิกซ์ ซึ่งลินุกซ์ผลักดันไปถึงจุดสุดยอด คือผู้ใช้หลายคนเป็นแฮ็กเกอร์ด้วย และเพราะมีซอร์สโค้ดให้ดู พวกเขาจึงเป็นแฮ็กเกอร์ที่ <emphasis>ทรงประสิทธิภาพ</emphasis> ซึ่งมีประโยชน์อย่างมหาศาลในการย่นเวลาจัดการบั๊ก เพียงแค่คุณกระตุ้นพวกเขาสักเล็กน้อย เหล่าผู้ใช้จะช่วยกันหาสาเหตุของปัญหา และแนะนำวิธีแก้ไข แถมช่วยพัฒนาโค้ดได้เร็วกว่าที่คุณทำเองคนเดียวเสียอีก
6. การปฏิบัติต่อผู้ใช้เยี่ยงผู้ร่วมงาน เป็นหนทางที่สะดวกที่สุด ที่จะนำไปสู่การพัฒนาโค้ดอย่างรวดเร็ว และการแก้บั๊กอย่างได้ผล
เรามักประเมินผลของวิธีการแบบนี้ต่ำไป ความจริงแล้ว พวกเราส่วนใหญ่ในโลกโอเพนซอร์สประเมินพลาดไปอย่างแรง ว่ามันสามารถรองรับจำนวนผู้ใช้ที่เพิ่มขึ้น และเอาชนะความซับซ้อนของระบบได้ดีเพียงใด จนกระทั่ง ไลนัส ทอร์วัลด์ ได้แสดงให้เราเห็น ว่ามันไม่ได้เป็นอย่างที่เราคิด
ความจริงแล้ว ผมคิดว่าผลงานที่ชาญฉลาดที่สุด และส่งผลต่อเนื่องมากที่สุดของไลนัส ไม่ใช่การสร้างเคอร์เนลลินุกซ์ แต่เป็นการสร้างตัวแบบการพัฒนาลินุกซ์ต่างหาก ครั้งหนึ่ง ผมเคยแสดงความเห็นนี้ต่อหน้าเขา เขาก็ยิ้ม และกล่าวสิ่งที่เขาพูดอยู่เสมอด้วยเสียงเบาๆ ว่า ``ผมเป็นแค่คนขี้เกียจสุดๆ คนหนึ่ง ที่อยากได้ชื่อจากผลงานของคนอื่น'' ขี้เกียจอย่างหมาจิ้งจอก หรืออย่างที่ โรเบิร์ต ไฮน์ไลน์ นักเขียนชื่อดังได้บรรยายตัวละครของเขาตัวหนึ่งไว้ว่า ``ขี้เกียจเกินกว่าจะล้มเหลว''
ถ้าเรามองย้อนกลับไป วิธีการและความสำเร็จของลินุกซ์ เคยเกิดขึ้นมาก่อนแล้ว ในการพัฒนาไลบรารี Lisp พร้อมทั้งคลังโค้ด Lisp ของโครงการ GNU Emacs ซึ่งตรงข้ามกับการพัฒนาแบบมหาวิหารอย่างส่วนหลักที่เขียนด้วยภาษาซีของ Emacs และโปรแกรมส่วนมากของ GNU วิวัฒนาการของโค้ดส่วน Lisp นั้นเป็นไปอย่างลื่นไหล และถูกผลักดันโดยผู้ใช้อย่างมาก แนวคิดและตัวต้นแบบมักจะถูกแก้ไขและเขียนใหม่ 3-4 ครั้ง ก่อนจะได้รูปแบบสุดท้ายที่เสถียรพอ และการร่วมมือกันอย่างหลวมๆ ที่ทำผ่านอินเทอร์เน็ต ก็เกิดขึ้นอยู่เสมอ เช่นเดียวกับลินุกซ์
อันที่จริง ก่อนผมจะทำ fetchmail ผลงานที่ผมคิดว่าประสบความสำเร็จที่สุดของผมนั้น คงเป็นโหมด VC (Version Control) ของ Emacs โดยเป็นการทำงานแบบลินุกซ์ คือร่วมมือกันผ่านเมลกับคนอื่นอีก 3 คน ซึ่งจนถึงทุกวันนี้ มีเพียงคนเดียวในกลุ่มนั้น (คือ ริชาร์ด สตอลล์แมน ผู้สร้าง Emacs และผู้ก่อตั้ง <ulink url="http://www.fsf.org">มูลนิธิซอฟต์แวร์เสรี</ulink>) ที่ผมเคยพบหน้า โหมด VC เป็นส่วนติดต่อ (front end) กับ SCCS, RCS และต่อมาถึง CVS ของ Emacs ที่ช่วยให้การดำเนินการกับระบบควบคุมเวอร์ชันเป็นไปได้ใน ``สัมผัสเดียว'' เป็นการพัฒนามาจากโหมด sccs.el เล็กๆ ง่ายๆ ที่ใครบางคนเขียนไว้ การพัฒนา VC ประสบความสำเร็จเพราะ Emacs Lisp ได้ผ่านขั้นตอนต่างๆ ของวัฏจักรซอฟต์แวร์ (ออก/ทดสอบ/พัฒนา) อย่างรวดเร็ว ไม่เหมือนตัว Emacs เอง
เรื่องทำนองนี้ไม่ได้เกิดกับ Emacs เท่านั้น ยังมีซอฟต์แวร์อื่นที่มีโครงสร้างสองชั้น พร้อมชุมชนผู้ใช้สองระดับ ซึ่งประกอบด้วยแกนที่พัฒนาแบบมหาวิหาร และชุดเครื่องมือที่พัฒนาแบบตลาดสด ตัวอย่างหนึ่งคือ MATLAB เครื่องมือเชิงพาณิชย์สำหรับวิเคราะห์และพล็อตภาพข้อมูล ผู้ใช้ MATLAB และผลิตภัณฑ์อื่นทำนองนี้ต่างรายงานเหมือนๆ กัน ว่าความเคลื่อนไหว ความตื่นตัว และนวัตกรรม มักเกิดในส่วนที่เปิด ซึ่งชุมชนที่ใหญ่โตและหลากหลายสามารถเข้าไปเปลี่ยนแปลงอะไรเองได้
ออกเนิ่นๆ ออกถี่ๆ
การออกโปรแกรมแต่เนิ่นๆ และบ่อยๆ เป็นส่วนสำคัญยิ่งของรูปแบบการพัฒนาลินุกซ์ นักพัฒนาส่วนมาก (รวมทั้งผมด้วย) เคยเชื่อว่า วิธีนี้เป็นนโยบายที่ไม่เข้าท่าเลยสำหรับโครงการขนาดใหญ่ เพราะรุ่นที่ออกเร็ว มักหมายถึงรุ่นที่อุดมไปด้วยบั๊ก และคุณไม่ต้องการให้ผู้ใช้ละความอดทนกับโปรแกรมไปเร็วนัก
ความเชื่อนี้ถือเป็นการหนุนเสริมความเคยชินที่จะใช้การพัฒนาแบบสร้างมหาวิหาร ถ้าจุดประสงค์หลักคือการให้ผู้ใช้พบบั๊กให้น้อยที่สุดแล้วล่ะก็ ทำไมคุณถึงคิดจะเว้นช่วงการออกรุ่นถึงหกเดือน (หรือนานกว่านั้น) โดยทำงานเป็นบ้าเป็นหลังเพื่อตรวจสอบและแก้ไขบั๊กในระหว่างนั้น แกนของ Emacs ที่เขียนด้วยภาษาซี ก็พัฒนาด้วยวิธีนี้เอง แต่ในทางตรงข้าม ไลบรารี Lisp กลับใช้วิธีอื่น เพราะมีคลังของ Lisp อยู่นอกการควบคุมของ FSF (มูลนิธิซอฟต์แวร์เสรี) และเราสามารถจะไปเอา Lisp รุ่นใหม่ๆ และรุ่นที่กำลังพัฒนาอยู่มาใช้ได้ โดยไม่ต้องสนใจว่า Emacs จะมีรุ่นใหม่ออกมาเมื่อไร <link linkend="QR">[QR]</link>
ในบรรดาคลังเหล่านี้ แหล่งที่สำคัญที่สุด ก็คือคลัง Lisp ของมหาวิทยาลัยโอไฮโอสเตต ซึ่งประมาณว่าคงมีหลักการและความสามารถหลายอย่างเหมือนกับคลังซอฟต์แวร์ลินุกซ์ใหญ่ๆ ในปัจจุบัน แต่มีพวกเราน้อยคนที่จะคิดลงไปลึกซึ้งเกี่ยวกับสิ่งที่เราได้ทำลงไป หรือเกี่ยวกับการมีอยู่ของคลังดังกล่าว ว่าเป็นเครื่องบ่งชี้ถึงปัญหาของรูปแบบการพัฒนาแบบมหาวิหารของ FSF ในปี 1992 ผมเคยพยายามผนวกโค้ดจากโอไฮโอหลายชิ้นเข้าไปในไลบรารี Lisp ที่เป็นทางการของ Emacs แต่ติดปัญหาการเมืองใน FSF และล้มเหลวในที่สุด
แต่หนึ่งปีหลังจากนั้น เมื่อลินุกซ์เริ่มเป็นที่รู้จักในวงกว้าง ก็เป็นที่ชัดเจนว่ารูปแบบการพัฒนาที่แตกต่างและมีประสิทธิภาพกว่าได้เกิดขึ้นที่นั่น นโยบายการพัฒนาอย่างเปิดกว้างของไลนัสตรงข้ามกับแบบมหาวิหารอย่างสิ้นเชิง คลังซอฟต์แวร์ของลินุกซ์ในอินเทอร์เน็ตผุดขึ้นอย่างรวดเร็ว ผู้จัดจำหน่ายต่างๆ ก็เริ่มเกิดขึ้นมา สิ่งเหล่านี้เกิดขึ้นได้เพราะความถี่ของการออกของระบบแกน ซึ่งบ่อยมากชนิดที่เราไม่เคยได้ยินมาก่อน
ไลนัส ปฏิบัติกับผู้ใช้ของเขาเหมือนกับผู้ร่วมงาน ด้วยวิธีที่ได้ผลที่สุด:
7. ออกเนิ่นๆ ออกถี่ๆ และฟังเสียงผู้ใช้
นวัตกรรมของไลนัสไม่ได้อยู่ที่ความไวในการออกรุ่นใหม่ ซึ่งรวบรวมสิ่งที่ผู้ใช้ตอบกลับมาเป็นจำนวนมาก (เรื่องแบบนี้เป็นขนบในโลกยูนิกซ์ตั้งนานมาแล้ว) แต่อยู่ที่การขยายขอบเขตความสามารถนี้ขึ้นไปถึงระดับความเข้มข้นที่พอเหมาะกับความซับซ้อนของสิ่งที่เขาพัฒนา ในช่วงแรกนั้น (ราวปี 1991) ไม่ใช่เรื่องแปลกเลยที่เขาจะออกเคอร์เนลใหม่มากกว่าหนึ่งครั้ง<emphasis>ต่อวัน!</emphasis> นวัตกรรมนี้เป็นไปได้เพราะเขาได้สร้างฐานผู้ร่วมพัฒนาขนาดใหญ่ และใช้อินเทอร์เน็ตเพื่อการร่วมมือทำงานมากกว่าใครๆ
แต่ว่ามันเป็นไปได้<emphasis>อย่างไร?</emphasis> มันเป็นสิ่งที่ผมจะทำตามได้ไหม? หรือว่านี่เป็นอัจฉริยภาพเฉพาะตัวของ ไลนัส ทอร์วัลด์ เท่านั้น?
ผมไม่คิดอย่างนั้น ผมยอมรับว่าไลนัสเป็นแฮ็กเกอร์ที่เก่งมาก มีพวกเราสักกี่คนที่จะสามารถสร้างเคอร์เนลของระบบปฏิบัติการระดับคุณภาพโดยเริ่มจากศูนย์ได้อย่างนี้? แต่ลินุกซ์ไม่ได้เป็นตัวอย่างของการก้าวกระโดดทางความคิดที่ยิ่งใหญ่อะไรเลย ไลนัสเองก็ไม่ได้เป็น (หรืออย่างน้อยก็ยังไม่ได้เป็น) อัจฉริยะในการออกแบบผู้สร้างนวัตกรรมในแบบที่ ริชาร์ด สตอลล์แมน หรือ เจมส์ กอสลิง (ผู้สร้าง NeWS และจาวา) เป็นเลย แต่ไลนัสเป็นอัจฉริยะในการควบคุมการพัฒนา เขามีสัมผัสพิเศษในการหลีกเลี่ยงบั๊กและทางตันของการพัฒนา และฉลาดในการหาเส้นทางที่เปลืองแรงน้อยที่สุดจากจุดหนึ่งไปอีกจุดหนึ่ง อันที่จริง เค้าโครงทั้งหมดของลินุกซ์ก็แสดงออกถึงคุณสมบัติข้อนี้ และสะท้อนถึงแนวทางการออกแบบชนิดอนุรักษ์นิยมและเรียบง่ายของไลนัสเอง
ดังนั้น ถ้าการออกบ่อยๆ และการใช้อินเทอร์เน็ตให้เป็นประโยชน์อย่างเต็มที่ไม่ใช่เรื่องบังเอิญ แต่เป็นอัจฉริยภาพเชิงวิศวกรรมของไลนัสที่มองทะลุถึงวิธีที่ง่ายและสั้นที่สุดในการพัฒนาล่ะก็ เขากำลังมุ่งเพิ่มปัจจัยอะไร? อะไรคือสิ่งที่เขาต้องการสร้างขึ้นจากวิธีการทำงานแบบนี้?
คำถามนี้มีคำตอบในตัวมันเองอยู่แล้ว ไลนัสได้พยายามกระตุ้นและให้รางวัลแก่กลุ่มแฮ็กเกอร์หรือผู้ใช้ของเขาอย่างสม่ำเสมอ กระตุ้นโดยการสร้างโอกาสที่จะได้เป็นส่วนหนึ่งของงานสร้างสรรค์อันน่าภาคภูมิใจ ให้รางวัลด้วยความคืบหน้าในงานของพวกเขาที่เห็นได้อย่างไม่ขาดสาย (ถึงขนาดออกเป็น <emphasis>รายวัน</emphasis>)
สิ่งที่ไลนัสมุ่งผลักดันให้เพิ่มขึ้นสูงสุดคือปริมาณคน-ชั่วโมงที่ทุ่มเทลงไปในการตรวจสอบบั๊กและการพัฒนา แม้จะเสี่ยงต่อการเกิดปัญหาด้านเสถียรภาพของโค้ด และจำนวนผู้ใช้ซึ่งอาจลดลงเมื่อเกิดบั๊กร้ายแรงที่แก้ลำบาก ไลนัสได้แสดงตัวราวกับว่า เขาเองเชื่อในสิ่งต่อไปนี้:
8. ถ้ามีผู้ทดสอบและผู้พัฒนามากพอ ปัญหาแทบทุกอย่างจะได้รับการรายงานโดยเร็ว และใครสักคนจะมองเห็นวิธีแก้ปัญหาได้อย่างปรุโปร่ง
หรือพูดง่ายๆ คือ ``ขอให้มีสายตาเฝ้ามองมากพอ บั๊กทั้งหมดก็เป็นเรื่องง่าย'' (Given enough eyeballs, all bugs are shallow) ผมขอตั้งคำพูดนี้เป็น ``กฎของไลนัส''
เดิมทีนั้น ผมเขียนกฎนี้ไว้ว่า ปัญหาทุกปัญหา ``จะมีใครบางคนมองออก'' ไลนัสได้ค้านว่า ผู้ที่เข้าใจและสามารถแก้ไขปัญหาได้ ไม่จำเป็นต้องเป็นและมักไม่ใช่คนที่รายงานปัญหาเป็นคนแรก ``มีใครคนหนึ่งเจอปัญหา'' เขากล่าว ``เดี๋ยวก็มี <emphasis>ใครอีกคน</emphasis> ที่เข้าใจตัวปัญหา และผมจะบอกไว้เลยว่า การค้นพบปัญหานั้นท้าทายมากกว่า'' การแก้ข้อความตรงนี้ถือว่าสำคัญ ซึ่งเราจะเห็นว่ามันสำคัญอย่างไรในหัวข้อถัดไป เมื่อเราพิจารณาวิธีการแก้บั๊กอย่างละเอียดยิ่งขึ้น แต่สิ่งที่สำคัญคือ ทั้งสองขั้นตอนของกระบวนการ (การค้นพบและแก้ไขปัญหา) มีแนวโน้มที่จะเกิดขึ้นอย่างรวดเร็ว
ผมคิดว่า ความแตกต่างโดยพื้นฐานของการพัฒนาแบบมหาวิหารและแบบตลาดสด ก็อยู่ที่กฎของไลนัสนี่แหละ ในมุมมองของนักพัฒนาแบบสร้างมหาวิหาร บั๊กและปัญหาในการพัฒนานั้นยาก มีเงื่อนงำ ลึกลับซับซ้อน ต้องใช้เวลานานนับเดือนในการตรวจสอบโดยการทุ่มเทแรงงานของคนไม่กี่คน เพื่อจะสร้างความมั่นใจว่าได้กำจัดบั๊กไปหมดแล้ว ผลคือ ระยะเวลาการออกรุ่นที่ยาวนาน และความผิดหวังที่เลี่ยงไม่ได้ เมื่อโปรแกรมรุ่นใหม่ที่รอคอยมาแสนนานทำงานไม่สมบูรณ์
ในทางกลับกัน ในมุมมองแบบตลาดสด คุณจะถือว่าบั๊กเป็นเรื่องง่ายๆ หรืออย่างน้อยก็จะกลายเป็นเรื่องง่ายๆ อย่างรวดเร็ว เมื่อเจอกับสายตาของนักพัฒนาผู้กระตือรือร้นนับพันที่ช่วยกันลงไม้ลงมือกับโปรแกรมแต่ละรุ่นที่ออกมา ดังนั้นคุณจึงออกโปรแกรมให้ถี่เข้าไว้ เพื่อที่บั๊กจะถูกกำจัดมากขึ้น และผลข้างเคียงที่ดีก็คือ คุณจะลดโอกาสเสียหายถ้ามีปัญหาหลุดออกไปจริงๆ
เท่านั้นแหละ เพียงพอแล้ว ถ้า ``กฎของไลนัส'' ผิดล่ะก็ ระบบใดก็ตามที่มีความซับซ้อนมากขนาดเคอร์เนลลินุกซ์ และถูกแฮ็กโดยคนจำนวนมากพอๆ กัน ก็ควรจะล้ม ณ จุดใดจุดหนึ่งเพราะการประสานงานที่ไม่ดี และเพราะบั๊ก ``ลึกลับ'' ที่ตรวจไม่พบ ในทางกลับกัน ถ้ากฎของไลนัสถูกต้อง นี่ก็เพียงพอที่จะอธิบายได้ ว่าทำไมลินุกซ์จึงมีบั๊กน้อย และไม่ล่มเมื่อเปิดทิ้งไว้เป็นเดือนๆ หรือแม้แต่เป็นปีๆ
บางทีเรื่องนี้อาจไม่น่าตื่นเต้นเท่าไรนัก นักสังคมวิทยาค้นพบหลายปีมาแล้วว่า ค่าเฉลี่ยของความเห็นจากกลุ่มคนจำนวนมากที่เชี่ยวชาญพอๆ กัน (หรือไม่รู้เรื่องพอๆ กัน) จะมีความน่าเชื่อถือในการทำนายมากกว่าความเห็นของใครสักคนที่ถูกสุ่มมา พวกเขาเรียกสิ่งนี้ว่า <firstterm>ปรากฏการณ์เดลไฟ (Delphi Effect)</firstterm> ซึ่งปรากฏว่า สิ่งซึ่งไลนัสได้แสดงให้เห็นก็คือ ปรากฏการณ์นี้ใช้ได้กับการแก้บั๊กในระบบปฏิบัติการด้วย กล่าวคือ ปรากฏการณ์เดลไฟสามารถจัดการกับความซับซ้อนของการพัฒนา แม้กับความซับซ้อนขนาดเคอร์เนลของระบบปฏิบัติการ <link linkend="CV">[CV]</link>
ความพิเศษอย่างหนึ่งในกรณีของลินุกซ์ ซึ่งช่วยเสริมปรากฏการณ์เดลไฟเข้าไปอีก คือการที่ผู้ร่วมสมทบงานในแต่ละโครงการได้ผ่านการกลั่นกรองตัวเองมาแล้ว ผู้เข้าร่วมตั้งแต่แรกคนหนึ่งชี้ว่า งานที่สมทบเข้ามานั้น ไม่ใช่ว่ามาจากใครก็ได้ แต่มาจากผู้คนที่สนใจมากพอที่จะใช้ซอฟต์แวร์ เรียนรู้วิธีการทำงาน พยายามหาทางแก้ปัญหาที่พบ และลงมือสร้างแพตช์ที่ใช้การได้ ใครก็ตามที่ผ่านการกลั่นกรองเหล่านี้ ย่อมมีแนวโน้มที่จะมีสิ่งดีๆ มาร่วมสมทบ
กฎของไลนัสสามารถกล่าวได้อีกแบบว่า ``การแก้บั๊กสามารถทำขนานกันได้'' (Debugging is parallelizable) ถึงแม้การสื่อสารระหว่างผู้แก้บั๊กกับนักพัฒนาที่ทำหน้าที่ประสานงานจะเป็นเรื่องจำเป็น แต่ในระหว่างผู้แก้บั๊กด้วยกันเองนั้น แทบไม่ต้องประสานงานกันเลย ดังนั้น การแก้บั๊กจึงไม่เพิ่มความซับซ้อนและค่าโสหุ้ยในการจัดการเป็นอัตรากำลังสองเหมือนการเพิ่มนักพัฒนา
ในทางปฏิบัติ การสูญเสียประสิทธิภาพตามทฤษฎีจากการทำงานซ้ำซ้อนของผู้แก้บั๊กนั้น แทบไม่เกิดกับโลกของลินุกซ์เลย ผลอย่างหนึ่งของนโยบาย ``ออกเนิ่นๆ ถี่ๆ'' ก็คือทำให้ความซ้ำซ้อนดังกล่าวลดลงเหลือน้อยที่สุด เนื่องจากมีการเผยแพร่การแก้ไขต่างๆ ที่ได้รับกลับมาออกไปสู่ชุมชนอย่างรวดเร็ว <link linkend="JH">[JH]</link>
บรูกส์ (ผู้แต่ง <citetitle>The Mythical Man-Month</citetitle>) เคยตั้งข้อสังเกตแบบผ่านๆ เกี่ยวกับเรื่องนี้ไว้ว่า ``ต้นทุนของการดูแลรักษาโปรแกรมที่มีผู้ใช้แพร่หลาย มักมีค่าประมาณร้อยละ 40 ของต้นทุนที่ใช้ในการพัฒนา น่าแปลกใจตรงที่จำนวนผู้ใช้มีผลกระทบอย่างมากต่อต้นทุนนี้ <emphasis>ยิ่งมีผู้ใช้มากก็เจอบั๊กมาก</emphasis>'' [เน้นข้อความเพิ่ม]
มีผู้ใช้มากก็เจอบั๊กมาก เพราะเมื่อผู้ใช้เพิ่มขึ้น โอกาสที่จะทรมานโปรแกรมในรูปแบบต่างๆ กันก็เพิ่มขึ้น และจะยิ่งเพิ่มขึ้นอีกเมื่อผู้ใช้เป็นผู้ร่วมพัฒนาด้วย เพราะแต่ละคนจะมีวิธีตรวจบั๊กด้วยมโนทัศน์และเครื่องมือวิเคราะห์ที่ต่างกันไปคนละเล็กละน้อย จากแง่มุมที่ต่างกัน ดูเหมือนว่า ``ปรากฏการณ์เดลไฟ'' เกิดขึ้นได้ก็เพราะความหลากหลายของผู้ใช้นี่เอง และโดยเฉพาะในบริบทของการแก้บั๊ก ความหลากหลายยังมีแนวโน้มที่จะลดงานที่ซ้ำซ้อนอีกด้วย
ดังนั้น การเพิ่มจำนวนผู้ทดสอบอาจจะไม่ช่วยลดความซับซ้อนของบั๊กยากๆ ในมุมมองของ<emphasis>นักพัฒนา</emphasis> แต่มันจะช่วยเพิ่มโอกาสที่เครื่องมือของใครสักคนจะเหมาะกับตัวปัญหา จนทำให้บั๊กดูง่าย<emphasis>สำหรับคนคนนั้น</emphasis>
ไลนัสยังมีแผนสำรองอยู่อีก ในกรณีที่เกิดบั๊กร้ายแรง เลขรุ่นของเคอร์เนลลินุกซ์จะถูกกำหนดในลักษณะที่ผู้ใช้สามารถเลือกได้ ว่าจะใช้รุ่น ``เสถียร'' ล่าสุด หรือจะใช้รุ่นใหม่กว่าที่เสี่ยงต่อบั๊ก เพื่อจะได้ใช้ความสามารถใหม่ๆ แฮ็กเกอร์ลินุกซ์ส่วนมากยังไม่ได้นำยุทธวิธีนี้ไปใช้อย่างเป็นระบบ แต่ก็ควรจะทำ การมีทางเลือกทำให้ทั้งสองทางดูน่าสนใจขึ้น <link linkend="HBS">[HBS]</link>
สายตากี่คู่ที่จะจัดการความซับซ้อนได้
การสังเกตในภาพรวม ว่ารูปแบบตลาดสดช่วยเร่งอัตราการแก้บั๊กและการวิวัฒนาการของโค้ด ก็เป็นส่วนหนึ่ง แต่ในอีกส่วนหนึ่ง เราก็ต้องเข้าใจด้วย ว่ามันทำงานอย่างไรและด้วยเหตุผลใดในระดับย่อยของพฤติกรรมประจำวันของนักพัฒนาและนักทดสอบ ในหัวข้อนี้ (ซึ่งเขียนขึ้นหลังจากบทความฉบับแรกสามปี โดยใช้ข้อมูลเชิงลึกจากนักพัฒนาที่ได้อ่านบทความและสำรวจพฤติกรรมของตน) เราจะพิจารณาโดยละเอียดเกี่ยวกับกลไกที่เกิดขึ้นจริง ผู้อ่านที่ไม่มีพื้นฐานทางเทคนิคอาจข้ามหัวข้อนี้ไปได้
ประเด็นสำคัญที่จะเข้าใจเรื่องนี้ คือการตระหนัก ว่าทำไมรายงานบั๊กจากผู้ใช้ที่ไม่สนใจซอร์สมักจะไม่ค่อยมีประโยชน์นัก ผู้ใช้ที่ไม่สนใจซอร์สมักจะรายงานแค่อาการผิวเผิน โดยถือว่าสภาพแวดล้อมของเขาปกติ ดังนั้นเขาจึง (ก) ละเลยข้อมูลประกอบที่สำคัญ (ข) ไม่ค่อยจะบอกวิธีการที่แน่นอนในการทำให้เกิดบั๊กซ้ำ
ปัญหาของเรื่องนี้ ก็คือความไม่เข้ากันของมโนภาพเกี่ยวกับโปรแกรมของผู้ทดสอบและของผู้พัฒนา ผู้ทดสอบมองจากข้างนอกเข้ามาข้างใน แต่ผู้พัฒนามองจากข้างในออกข้างนอก ในการพัฒนาแบบซอร์สปิด ทั้งสองฝ่ายจะติดแหง็กอยู่กับบทบาททั้งสองนี้ และดูจะคุยกันไม่เข้าใจ รู้สึกว่าอีกฝ่ายน่ารำคาญ
การพัฒนาแบบโอเพนซอร์สทำลายพันธะดังกล่าวเสีย ทำให้ง่ายต่อผู้ทดสอบและผู้พัฒนาที่จะมองภาพร่วมกัน บนพื้นฐานของซอร์สโค้ดจริง และสื่อสารเข้าใจกัน ในทางปฏิบัติแล้ว มีความแตกต่างอย่างมากสำหรับนักพัฒนา ระหว่างรายงานบั๊กที่รายงานแค่อาการภายนอก กับที่พุ่งตรงไปยังเค้าโครงที่มีพื้นฐานจากซอร์สโค้ดของโปรแกรมเอง
แทบทุกครั้ง บั๊กจะแก้ง่ายถ้าบรรยายอาการของเงื่อนไขข้อผิดพลาดได้ในระดับซอร์สโค้ด แม้จะไม่สมบูรณ์ก็ตาม เมื่อผู้ทดสอบบางคนของคุณสามารถชี้ได้ว่า "มีปัญหาเรื่องค่าล้นที่บรรทัด nnn" หรือแม้เพียงแค่ "ภายใต้เงื่อนไข X, Y และ Z ตัวแปรนี้จะตีกลับ" แค่มองที่โค้ดที่มีปัญหาอย่างคร่าวๆ ก็มักเพียงพอที่จะบ่งชี้ชนิดของข้อผิดพลาด และแก้ไขได้ทันที
ดังนั้น การใช้ซอร์สโค้ดทั้งสองฝ่ายจึงช่วยเพิ่มทั้งการสื่อสาร และการเสริมแรงกันระหว่างสิ่งที่ผู้ทดสอบรายงานกับสิ่งที่ผู้พัฒนาหลักรู้ ผลก็คือ มีแนวโน้มจะช่วยประหยัดเวลานักพัฒนาหลักได้ดี แม้จะต้องประสานงานหลายฝ่าย
คุณลักษณ์อีกประการหนึ่งของวิธีการโอเพนซอร์สที่ช่วยประหยัดเวลานักพัฒนา ก็คือโครงสร้างของการสื่อสารของโครงการโอเพนซอร์สทั่วไป ในย่อหน้าก่อน ผมใช้คำว่า "นักพัฒนาหลัก" ซึ่งสะท้อนถึงความแตกต่างระหว่างแกนของโครงการ (ซึ่งมักจะเป็นกลุ่มเล็กๆ การมีนักพัฒนาหลักแค่คนเดียวถือเป็นเรื่องปกติ และหนึ่งถึงสามคนถือว่าธรรมดา) กับนักทดสอบและผู้ร่วมสมทบที่รายล้อม (ซึ่งมักมีจำนวนหลักร้อย)
ปัญหาพื้นฐานที่องค์กรพัฒนาซอฟต์แวร์แบบดั้งเดิมพยายามแก้ ก็คือกฎของบรูกส์: ``การเพิ่มโปรแกรมเมอร์ในโครงการที่ล่าช้า จะทำให้มันยิ่งช้าขึ้นไปอีก'' หรือกล่าวในรูปทั่วไป กฎของบรูกส์ทำนายว่า ความซับซ้อนและต้นทุนการสื่อสารของโครงการ จะเพิ่มในอัตรากำลังสองของจำนวนนักพัฒนา ในขณะที่งานที่ได้จะเพิ่มในแบบเชิงเส้น
กฎของบรูกส์สร้างขึ้นบนพื้นฐานของประสบการณ์ที่ว่า บั๊กต่างๆ มีแนวโน้มที่จะหนีไม่พ้นเรื่องการเชื่อมต่อระหว่างโค้ดที่เขียนโดยคนกลุ่มต่างๆ และค่าโสหุ้ยในการสื่อสาร/ประสานงานกันในโครงการ ก็มีแนวโน้มจะเพิ่มตามจำนวนการเชื่อมโยงระหว่างมนุษย์ ดังนั้น ขนาดของปัญหาจึงโตตามจำนวนช่องทางสื่อสารระหว่างนักพัฒนา ซึ่งแปรผันตรงกับกำลังสองของจำนวนนักพัฒนา (หรือพูดให้ละเอียดกว่านั้น คือเป็นไปตามสูตร N*(N - 1)/2 เมื่อ N คือจำนวนนักพัฒนา)
การวิเคราะห์ตามกฎของบรูกส์ (และความกลัวจำนวนนักพัฒนามากๆ ในทีมพัฒนาที่เป็นผลตามมา) ตั้งอยู่บนข้อสมมุติที่ซ่อนอยู่ คือโครงสร้างการสื่อสารของโครงการ จะต้องเป็นกราฟสมบูรณ์ (complete graph) เสมอไป กล่าวคือ ทุกคนจะพูดกับคนอื่นๆ ทุกคน แต่ในโครงการโอเพนซอร์ส นักพัฒนารอบนอกต่างทำงานกับสิ่งที่กลายเป็นงานย่อยที่แบ่งทำขนานกันได้ และมีปฏิสัมพันธ์กันเองน้อยมาก การแก้ไขโค้ดและรายงานบั๊กต่างส่งเข้าสู่ทีมพัฒนาหลัก และค่าโสหุ้ยตามกฎของบรูกส์ ก็จะเกิดกับเฉพาะ <emphasis>ภายใน</emphasis> กลุ่มนักพัฒนาหลักกลุ่มเล็กๆ นี้เท่านั้น <link linkend="SU">[SU]</link>
ยังมีเหตุผลเพิ่มเติม ที่ทำให้การรายงานบั๊กในระดับซอร์สโค้ดมีแนวโน้มจะมีประสิทธิภาพมาก เนื่องจากบ่อยครั้งที่ข้อผิดพลาดเดียวสามารถแสดงอาการได้หลายแบบ โดยขึ้นอยู่กับรายละเอียดของรูปแบบและสภาพแวดล้อมการใช้งานของผู้ใช้ ข้อผิดพลาดดังกล่าวมีแนวโน้มที่จะเป็นบั๊กชนิดที่ซับซ้อนและละเอียดอ่อน (เช่น ข้อผิดพลาดในการจัดการหน่วยความจำแบบพลวัต หรือมีช่วงว่างระหว่างการขัดจังหวะที่ไม่แน่นอน) ที่ทำให้เกิดซ้ำตามต้องการหรือชี้ชัดด้วยการวิเคราะห์แบบตายตัวได้ยากที่สุด และเป็นบั๊กที่สร้างปัญหาให้กับซอฟต์แวร์ในระยะยาวได้มากที่สุด
นักทดสอบที่ส่งรายงานสิ่งที่อาจเป็นบั๊กที่แสดงอาการหลายแบบดังกล่าว โดยรายงานในระดับซอร์สโค้ด (เช่น "ผมคิดว่ามันมีช่วงว่างระหว่างการจัดการสัญญาณแถวๆ บรรทัดที่ 1250" หรือ "คุณเติมค่าศูนย์ในบัฟเฟอร์นั้นตรงไหนหรือ?") อาจกำลังให้ข้อมูลที่สำคัญยิ่งยวดสำหรับแก้อาการหลายอาการต่อผู้พัฒนาซึ่งอาจอยู่ใกล้โค้ดเกินกว่าจะเห็นได้ ซึ่งในกรณีเช่นนั้น อาจจะยากหรือเป็นไปไม่ได้เลย ที่จะรู้ว่าอาการผิดปกติอันไหนเกิดจากบั๊กไหน แต่ด้วยการออกบ่อยๆ ก็แทบไม่จำเป็นต้องรู้เลย คนอื่นๆ อาจจะพบอย่างรวดเร็ว ว่าบั๊กของเขาได้รับการแก้ไขหรือยัง ในหลายๆ กรณี รายงานบั๊กในระดับซอร์สโค้ดจะทำให้อาการผิดปกติหลายอย่างหายไป โดยไม่ได้ชี้ชัดถึงวิธีที่แก้ไขเลย
ข้อผิดพลาดที่ซับซ้อนและแสดงหลายอาการ ยังมีแนวโน้มจะมีหลายทางที่จะไล่ไปสู่บั๊กที่แท้จริง ทางไหนที่ผู้พัฒนาหรือผู้ทดสอบคนหนึ่งๆ จะสามารถไล่ไปได้ ก็ขึ้นอยู่กับรายละเอียดปลีกย่อยของสภาพแวดล้อมของบุคคลนั้น และอาจกลายเป็นทางที่แน่นอนชัดเจนได้ในภายหลัง ผลก็คือ นักพัฒนาและผู้ทดสอบแต่ละคนจะช่วยสุ่มตัวอย่างสถานะของโปรแกรมแบบต่างๆ ขณะหาสมุฏฐานของอาการ ยิ่งบั๊กละเอียดอ่อนและซับซ้อนเท่าใด ความชำนาญโดยลำพังก็ช่วยเชื่อมโยงได้น้อยเท่านั้น
สำหรับบั๊กที่ง่ายและทำซ้ำได้ การสุ่มตัวอย่างก็ไม่จำเป็นนัก ความชำนาญในการตรวจบั๊กและความคุ้นเคยกับโค้ดและโครงสร้างโปรแกรมจะช่วยได้มาก แต่สำหรับบั๊กที่ซับซ้อนแล้ว ก็ต้องอาศัยการสุ่มตัวอย่างช่วย ในสภาวะดังกล่าว การมีผู้แกะรอยจากหลายเส้นทางจะได้ผลกว่าการใช้ไม่กี่คนแกะรอยทีละทาง แม้ว่าไม่กี่คนที่ว่านั้นจะมีความชำนาญโดยเฉลี่ยสูงกว่าก็ตาม
ผลของเรื่องนี้จะใหญ่โตมาก ถ้าความยากของการแกะรอยแบบต่างๆ จากอาการเพื่อหาบั๊กนั้น แตกต่างกันมากจนไม่สามารถทำนายได้จากอาการ นักพัฒนาเพียงคนเดียวที่ทดลองแกะรอยทีละแบบจะมีโอกาสที่จะเลือกแบบที่ยากก่อนพอๆ กับที่จะเลือกแบบที่ง่ายก่อน ในทางกลับกัน สมมุติว่ามีหลายคนลองแกะรอยพร้อมๆ กันขณะที่จะออกรุ่นอย่างกระชั้นชิด ก็มีโอกาสที่จะมีบางคนพบทางที่ง่ายที่สุดทันที และแก้บั๊กได้ในเวลาอันสั้น ผู้ดูแลโครงการจะเห็น แล้วก็ออกรุ่นใหม่ และคนอื่นๆ ที่กำลังแกะรอยบั๊กเดียวกันก็สามารถจะหยุดได้ ก่อนที่จะใช้เวลากับการแกะรอยแบบที่ยากนั้นนานเกินไป <link linkend="RJ">[RJ]</link>
เมื่อใดที่กุหลาบจะไม่เป็นกุหลาบ?
เมื่อได้ศึกษาวิธีการของไลนัส และสร้างทฤษฎีว่ามันสำเร็จได้อย่างไรแล้ว ผมได้ตัดสินใจที่จะทดสอบทฤษฎีนี้กับโครงการของผมเอง (ที่ต้องยอมรับว่าซับซ้อนน้อยกว่าและทะเยอทะยานน้อยกว่ามาก)
แต่สิ่งแรกที่ผมทำ คือการปรับ popclient ให้ลดความซับซ้อนลง งานของคาร์ล แฮรริส นั้นดูดี แต่ก็ได้สร้างความซับซ้อนที่ไม่จำเป็น ตามแบบที่โปรแกรมเมอร์ภาษาซีหลายคนชอบทำ เขามองตัวโค้ดเป็นศูนย์กลาง และโครงสร้างข้อมูลเป็นส่วนสนับสนุนของโค้ด ผลก็คือ โค้ดนั้นสวยงามดี แต่โครงสร้างข้อมูลออกแบบตามอำเภอใจและค่อนข้างแย่ (อย่างน้อยก็แย่ตามมาตรฐานที่สูงอยู่แล้วของแฮ็กเกอร์ Lisp มือฉมังคนนี้)
อย่างไรก็ดี ผมมีอีกจุดประสงค์หนึ่งในการเขียนใหม่ นอกจากการปรับปรุงโค้ดและโครงสร้างข้อมูล นั่นคือการปรับโปรแกรมให้กลายเป็นสิ่งที่ผมเข้าใจได้ทั้งหมด มันไม่สนุกเลยในการรับผิดชอบแก้บั๊กของโปรแกรมที่คุณไม่เข้าใจ
ในราวเดือนแรก ผมทำตามแนวทางที่คาร์ลออกแบบไว้ ความเปลี่ยนแปลงที่สำคัญอย่างแรกที่ผมทำ คือเพิ่มการสนับสนุน IMAP ผมทำโดยการจัดระบบโพรโทคอลใหม่ให้เป็นไดรเวอร์ทั่วไปหนึ่งตัว และตารางวิธีการสามอัน (สำหรับ POP2, POP3 และ IMAP) การเปลี่ยนแปลงทั้งครั้งนี้และครั้งก่อน แสดงให้เห็นหลักการทั่วไปที่โปรแกรมเมอร์ควรจำให้ขึ้นใจ โดยเฉพาะสำหรับภาษาอย่างซี ซึ่งไม่ได้สนับสนุนชนิดข้อมูลแบบพลวัต นั่นคือ:
9. โครงสร้างข้อมูลที่ฉลาดกับโค้ดที่โง่ ทำงานได้ดีกว่าในทางกลับกัน
บรูกส์, บทที่ 9 : ``ให้ผมดูโฟลว์ชาร์ตของคุณ แล้วปิดตารางของคุณไว้ ผมก็ยังจะงงต่อไป แต่ถ้าให้ผมดูตารางของคุณ ผมแทบไม่ต้อดูโฟลว์ชาร์ตของคุณเลย ทุกอย่างชัดเจน'' เมื่อพิจารณาเวลาสามสิบปีของการเปลี่ยนแปลงของคำศัพท์และยุคสมัยแล้ว ประเด็นก็ยังเหมือนเดิม
ณ จุดนี้ (ต้นเดือนกันยา 1996 ทำมาแล้วประมาณ 6 อาทิตย์) ผมเริ่มคิดจะเปลี่ยนชื่อโครงการแล้ว เพราะมันไม่ใช่แค่โปรแกรมสำหรับ POP อีกต่อไป แต่ผมยังไม่แน่ใจ เพราะมันยังไม่มีอะไรใหม่จริงๆ ในด้านการออกแบบ popclient รุ่นของผมยังไม่ได้พัฒนาเอกลักษณ์เป็นของตัวเองเลย
แต่เงื่อนไขนั้นก็ได้เปลี่ยนไปอย่างมาก เมื่อ popclient เริ่มจะส่งเมลต่อไปยังพอร์ต SMTP ได้ ผมจะกลับมาพูดถึงเรื่องนี้อีกที แต่ก่อนอื่น ผมพูดไว้ก่อนหน้านี้ว่า ผมตั้งใจจะใช้โครงการนี้พิสูจน์ทฤษฎีของผมเกี่ยวกับสิ่งที่ ไลนัส ทอร์วัลด์ ทำ คุณอาจจะถามว่า ผมทำอย่างไรบ้าง? ผมทำอย่างนี้:
ผมออกเนิ่นๆ และถี่ๆ (แทบจะไม่เคยทิ้งช่วงเกินสิบวัน และถ้าเป็นช่วงที่มีการพัฒนาแบบเข้มข้น ผมออกทุกวัน)
ผมเพิ่มรายชื่อผู้ทดสอบโดยใส่ชื่อทุกคนที่คุยกับผมเรื่อง fetchmail
ผมประกาศแบบเป็นกันเองไปยังผู้ทดสอบทุกคนเมื่อออก กระตุ้นให้ผู้คนมีส่วนร่วม
และผมฟังผู้ทดสอบเบต้า ขอความเห็นเกี่ยวกับการออกแบบ และขอบคุณเมื่อเขาส่งแพตช์ และความคิดเห็นมาให้
ผลลัพธ์จากมาตรการง่ายๆ เหล่านี้เห็นได้รวดเร็ว ตั้งแต่เริ่มโครงการ ผมได้รับการรายงานบั๊กที่มีคุณภาพระดับที่นักพัฒนาอยากได้ใจจะขาด และบ่อยครั้งที่มีวิธีแก้มาให้ด้วย ผมได้รับคำวิจารณ์ที่ให้แนวคิดที่ดี ได้รับเมลจากแฟนๆ ได้รับคำแนะนำคุณสมบัติใหม่ๆ ซึ่งนำไปสู่:
10. ถ้าคุณปฏิบัติกับผู้ทดสอบรุ่นเบต้า เหมือนกับเป็นแหล่งทรัพยากรชั้นเยี่ยมแล้ว เขาจะตอบแทนด้วยการเป็นทรัพยากรชั้นเยี่ยมให้
ดัชนีชี้วัดความสำเร็จของ fetchmail ที่น่าสนใจอย่างหนึ่ง คือขนาดของเมลลิงลิสต์ fetchmail-friends ของผู้ทดสอบเบต้าของโครงการ ขณะที่แก้ไขปรับปรุงบทความนี้รุ่นล่าสุด (พฤศจิกายน 2000) มีสมาชิกถึง 287 คน และเพิ่มขึ้น 2-3 คนทุกสัปดาห์
ความจริงแล้ว ตั้งแต่ผมเริ่มแก้ไขปรับปรุงบทความในปลายเดือนพฤษภาคม 1997 ผมพบว่าคนในรายชื่อเริ่มจะลดจำนวนลงจากเกือบ 300 คนในตอนแรก ด้วยเหตุผลที่น่าสนใจ คือ หลายๆ คนได้ขอให้ผมเอาชื่อเขาออก เพราะ fetchmail ทำงานได้ดีแล้ว จนพวกเขาไม่ต้องการมีส่วนร่วมในการสนทนาอีก บางที นี่อาจจะเป็นส่วนหนึ่งในวงจรชีวิตของโครงการแบบตลาดสดที่โตเต็มที่แล้วก็ได้
จาก Popclient สู่ Fetchmail
จุดเปลี่ยนที่แท้จริงของโครงการ เกิดขึ้นเมื่อ Harry Hochheiser ส่งร่างโค้ดของเขาสำหรับการส่งเมลต่อไปยังพอร์ต SMTP ของเครื่องลูกข่ายมาให้ผม ผมรู้ทันทีว่าความสามารถนี้ถ้าทำงานได้จริงอย่างเชื่อถือได้แล้ว จะทำให้วิธีกระจายเมลแบบอื่นๆ เตรียมม้วนเสื่อไปได้เลย
เป็นเวลาหลายสัปดาห์ ที่ผมได้ปรับปรุงต่อเติม fetchmail โดยรู้สึกว่าส่วนติดต่อนั้นทำงานได้ดี แต่ดูรกรุงรัง ไม่สวยและมีตัวเลือกหยุมหยิมเต็มไปหมด ผมรำคาญตัวเลือกที่ให้โยนเมลที่ดึงมาไปลงแฟ้ม mailbox หรือเอาต์พุตมาตรฐาน แต่ก็ไม่รู้เหมือนกันว่าทำไม
(ถ้าคุณไม่สนเรื่องทางเทคนิคของการส่งเมลในอินเทอร์เน็ต ก็อ่านข้ามสองย่อหน้าถัดไปนี้ได้เลย)
สิ่งที่ผมเห็นเมื่อคิดถึงการส่งเมลต่อไปยัง SMTP ก็คือ popclient นั้นพยายามทำงานหลายอย่างเกินไป มันถูกออกแบบให้เป็นทั้งโปรแกรมจัดส่งเมลภายนอก (mail transport agent – MTA) และโปรแกรมกระจายเมลภายในเครื่อง (local delivery agent – MDA) เมื่อมีความสามารถในการส่งเมลต่อไปยัง SMTP แล้ว มันก็ควรจะเลิกทำตัวเป็น MDA และเป็นเพียง MTA เพียงอย่างเดียว แล้วโอนหน้าที่ในการกระจายเมลในเครื่องไปให้โปรแกรมอื่น เหมือนกับที่ sendmail ทำอยู่
ทำไมต้องไปยุ่งกับรายละเอียดในการตั้งค่าการกระจายเมล หรือการล็อคกล่องเมลก่อนเขียนต่อท้าย ในเมื่อแทบจะแน่ใจได้ว่ามีพอร์ต 25 ให้ใช้ในทุกแพล็ตฟอร์มที่สนับสนุน TCP/IP อยู่แล้ว? โดยเฉพาะอย่างยิ่ง เมื่อการใช้พอร์ตดังกล่าวยังรับประกันได้ว่าจะทำให้เมลที่ดึงมานั้น ดูเหมือนเมล SMTP ปกติที่รับมาจากผู้ส่งโดยตรง ซึ่งเป็นสิ่งที่เราต้องการจริงๆ อยู่แล้ว
(กลับสู่เรื่องเดิม...)
ถึงแม้คุณจะไม่ได้ติดตามศัพท์แสงทางเทคนิคในย่อหน้าก่อน แต่ก็ยังมีบทเรียนที่สำคัญหลายบทสำหรับเรื่องนี้ สิ่งแรกก็คือ การส่งเมลต่อไปยัง SMTP เป็นผลลัพธ์ที่ดีที่สุดที่ผมได้รับจากการเลียนแบบวิธีพัฒนาของไลนัสอย่างจงใจ ผู้ใช้คนหนึ่งได้ให้แนวคิดสุดยอดอันนี้ สิ่งที่ผมต้องทำคือเข้าใจความหมายและสิ่งที่จะตามมา
11. สิ่งที่ดีที่สุดรองจากการมีแนวคิดดีๆ ก็คือการตระหนักถึงแนวคิดที่ดีจากผู้ใช้ของคุณ บางครั้ง การตระหนักดังกล่าวก็ถือว่าสำคัญกว่า
สิ่งที่น่าสนใจตามมาคือ คุณจะค้นพบอย่างรวดเร็ว ว่าถ้าคุณซื่อสัตย์กับการบอกว่าได้แนวคิดมาจากผู้ใช้มากเท่าไร โลกภายนอกยิ่งจะมองว่าคุณเป็นคนสร้างสิ่งนั้นขึ้นมาเองทุกกระเบียดนิ้ว และมองคุณว่าเป็นอัจฉริยะที่ถ่อมตัว ดูอย่างไลนัสสิ!
(ตอนที่ผมพูดบนเวทีในงาน Perl Conference เดือนสิงหาคมปี 1997 ลาร์รี วอลล์ แฮ็กเกอร์ผู้ยิ่งยงนั่งอยู่แถวหน้า เมื่อผมพูดถึงเรื่องในย่อหน้าที่ผ่านมา เขาตะโกนขึ้นราวกับเสียงปลุกเร้าของนักบุญ ว่า "บอกเขาไป บอกเขาไปให้หมด เพื่อน!" ผู้ฟังทั้งหมดหัวเราะครืน เพราะรู้ว่าเรื่องนี้เกิดกับเขาซึ่งเป็นผู้สร้างภาษา Perl ด้วย)
สองสามสัปดาห์จากการทำงานโครงการนี้ด้วยแนวคิดเดียวกัน ผมเริ่มได้รับการยกย่องคล้ายๆ กันนี้ ไม่ใช่แค่จากผู้ใช้ของผม แต่ยังมาจากคนอื่นๆ ที่ได้ยินเรื่องของโครงการด้วย ผมซุกเมลเหล่านั้นบางฉบับออกไป ผมอาจจะหยิบกลับมาอ่านในบางครั้ง ถ้าเกิดสงสัยขึ้นมาว่าชีวิตผมมีค่าหรือเปล่า :-)
แต่ยังมีบทเรียนพื้นฐานที่ไม่เกี่ยวกับการเมืองอีกสองข้อ ที่เกี่ยวกับการออกแบบทุกชนิดโดยทั่วไป
12. บ่อยครั้งที่วิธีการที่เฉียบแหลมและแปลกใหม่ จะมาจากการตระหนักว่า คุณมองปัญหานั้นผิดมาตลอด
ผมเคยพยายามแก้ปัญหาผิดประเด็น โดยการพัฒนา popclient ให้เป็นทั้ง MTA/MDA ในตัวเดียวกันต่อไป พร้อมกับโหมดการกระจายเมลแบบต่างๆ ภายในเครื่อง แต่การออกแบบ fetchmail ต้องเริ่มคิดใหม่แต่ต้นให้เป็น MTA ล้วนๆ โดยเป็นส่วนหนึ่งของเส้นทางเมลในอินเทอร์เน็ตผ่านโพรโทคอล SMTP
เมื่อคุณเจอทางตันในการพัฒนา เมื่อคุณพบว่าตัวเองต้องคิดหนักกับแพตช์ถัดไป ก็มักจะเป็นเวลาที่จะเลิกถามตัวเองว่า ``ได้คำตอบที่ถูกต้องหรือยัง'' แต่ควรจะถามใหม่ว่า ``ตั้งคำถามถูกหรือเปล่า'' บางทีก็อาจต้องนิยามปัญหาใหม่
เอาล่ะ ผมได้มองปัญหาของผมใหม่ ชัดเจนว่าสิ่งที่ควรทำคือ (1) เพิ่มการส่งเมลต่อไปยัง SMTP เข้าไปในไดรเวอร์ทั่วไป (2) ทำให้มันเป็นโหมดปริยาย และ (3) เอาโหมดอื่นๆ ออกไปในที่สุด โดยเฉพาะ โหมดกระจายไปยังแฟ้ม (deliver-to-file) และโหมดกระจายไปยังเอาต์พุตมาตรฐาน (deliver-to-standard-output)
ผมลังเลที่จะทำขั้นที่ 3 อยู่ระยะหนึ่ง เพราะกลัวว่าจะทำให้ผู้ที่ใช้ popclient มานานที่อาจจะใช้วิธีกระจายเมลแบบอื่นอยู่ไม่พอใจ ตามทฤษฎีแล้ว เขาสามารถเปลี่ยนไปแก้แฟ้ม <filename>.forward</filename> (หรือแฟ้มอื่นๆ ที่เทียบเท่าถ้าไม่ใช้ sendmail) ได้ทันที โดยได้ผลเหมือนเดิม แต่ในทางปฏิบัติ การเปลี่ยนดังกล่าวอาจจะยุ่งยาก
แต่เมื่อผมได้ทำจริงๆ ผลที่ได้นั้นดีมาก ส่วนที่ยุ่งที่สุดของไดรเวอร์ถูกตัดออกไป การปรับแต่งค่าทำได้ง่ายขึ้นอย่างเห็นได้ชัด ไม่จำเป็นต้องไปยุ่งกับทั้ง MDA และกล่องเมลของผู้ใช้อีกต่อไป ไม่ต้องกังวลว่า OS ที่ใช้อยู่สนับสนุนการล็อคแฟ้มหรือเปล่า
นอกจากนั้น โอกาสเดียวที่จะทำเมลหายก็หมดไปอีกด้วย เดิมที ถ้าคุณระบุให้กระจายไปยังแฟ้ม (delivery-to-file) และเนื้อที่ดิสก์เกิดเต็มขึ้นมา เมลนั้นจะหายไป แต่สิ่งนี้จะไม่เกิดขึ้นกับการส่งต่อไปยัง SMTP เพราะว่าโปรแกรมรับเมลแบบ SMTP จะไม่ยอมตกลงจนกว่าเมลจะถูกกระจายไปเรียบร้อย หรืออย่างน้อยก็ส่งเข้าที่พักไว้ รอการกระจายต่อในภายหลัง
เรื่องประสิทธิภาพก็ยังสูงขึ้นอีกด้วย (แม้จะไม่รู้สึกในการทำงานครั้งเดียว) ผลดีอีกอย่างที่ไม่สำคัญเท่าไร คือคู่มือวิธีใช้ (man page) ดูง่ายลงมาก
ต่อมาภายหลัง ผมต้องนำส่วนกระจายเมลผ่าน MDA ที่ผู้ใช้กำหนดกลับมาอีก เพื่อจัดการกับบางสถานการณ์ที่เกี่ยวกับ SLIP แต่ผมพบวิธีที่ง่ายกว่าเดิมมากในการเพิ่มมันเข้าไป
คติของเรื่องนี้น่ะหรือ? อย่าลังเลที่จะทิ้งความสามารถที่หมดอายุแล้ว เมื่อคุณพบว่าคุณสามารถทำได้โดยผลลัพธ์ยังเท่าเดิม อังตวน เดอ แซง-เตกซูเปรี (ผู้เป็นนักบินและนักออกแบบเครื่องบิน ในช่วงที่ไม่ได้เขียนหนังสืออมตะสำหรับเด็ก) กล่าวไว้ว่า:
13. ``ความสมบูรณ์แบบ (ในการออกแบบ) จะได้มาไม่ใช่เมื่อไม่มีอะไรจะเพิ่ม แต่จะได้มาเมื่อไม่มีอะไรจะเอาออกต่างหาก''
เมื่อโค้ดขของคุณดีขึ้นและเรียบง่ายขึ้น เมื่อนั้นแหละที่คุณจะรู้สึกว่ามัน <emphasis>ใช่</emphasis> และในกระบวนการนี้ การออกแบบของ fetchmail ได้สร้างเอกลักษณ์ของตัวเอง ซึ่งแตกต่างไปจาก popclient เดิม
มันถึงเวลาที่จะเปลี่ยนชื่อซะที การออกแบบแบบใหม่ดูเหมือนกับเป็นคู่ของ sendmail มากกว่าที่ popclient เดิมเคยเป็น โปรแกรมทั้งคู่เป็น MTA แต่ในขณะที่ sendmail จะผลักออกไปแล้วกระจาย แต่ popclient ตัวใหม่จะดึงเข้ามาแล้วกระจาย สองเดือนถัดมา ผมเปลี่ยนชื่อมันเป็น fetchmail
มีบทเรียนทั่วๆ ไปอีกข้อจากเรื่องเกี่ยวกับวิธีที่การกระจายเมลแบบ SMTP กลายมาเป็น fetchmail นี้ คือบทเรียนที่ว่า ไม่ใช่แค่การตรวจบั๊กเท่านั้น ที่ทำขนานกันได้ แต่การพัฒนาและการสำรวจความเป็นไปได้ของการออกแบบก็ทำขนานได้ (ในระดับที่น่าประหลาดใจ) เช่นกัน เมื่อการพัฒนาของคุณมีรูปแบบวนรอบอย่างรวดเร็ว การพัฒนาและเพิ่มความสามารถจะกลายเป็นการแก้บั๊กกรณีพิเศษ นั่นคือ `บั๊กเนื่องจากสิ่งที่ขาดไป' ในคุณสมบัติหรือแนวคิดเริ่มแรกของตัวซอฟต์แวร์
แม้กับการออกแบบระดับบน การมีผู้ร่วมพัฒนาจำนวนมากเดินผ่านการออกแบบของคุณในทิศทางต่างๆ ก็ยังมีประโยชน์มากๆ ลองคิดถึงการที่ก้อนน้ำหาทางไหลจนลงท่อ หรือมดที่หาอาหาร ต่างเป็นการสำรวจโดยใช้การแพร่กระจาย ตามด้วยการช่วงใช้ที่จัดการผ่านกลไกการสื่อสาร วิธีนี้ใช้การได้ดีมาก เหมือนกับที่ผมและ Harry Hochheiser ทำ ใครบางคนจากภายนอก อาจพบสิ่งสุดยอดที่อยู่ใกล้ๆ ตัวคุณ ที่คุณอยู่ใกล้เกินกว่าจะมองเห็นก็ได้
Fetchmail เติบโต
แล้วผมก็อยู่กับการออกแบบที่เนี้ยบและมีนวัตกรรม อยู่กับโค้ดที่ผมรู้ว่าทำงานได้ดี เพราะผมใช้อยู่ทุกวัน และอยู่กับผู้ทดสอบเบต้าที่เพิ่มขยายขึ้นเรื่อยๆ ผมเริ่มรู้สึกทีละนิด ว่าผมไม่ได้ผูกพันกับการแฮ็กเล็กๆ น้อยๆ ของตัวเองที่อาจจะบังเอิญมีประโยชน์กับคนอื่นบางคนอีกต่อไป แต่ผมกำลังเขียนโปรแกรมที่แฮ็กเกอร์ที่ใช้ยูนิกซ์และอ่านเมลผ่าน SLIP/PPP ทุกคนต้องมี
ด้วยความสามารถส่งเมลต่อไปยัง SMTP ทำให้ fetchmail นำหน้าคู่แข่งไปไกลจนถึงขั้นสามารถเป็น ``killer'' หรือโปรแกรมอมตะที่เติมช่องว่างได้อย่างเฉียบขาด จนทำให้ตัวเลือกอื่นไม่ใช่แค่ถูกทิ้งไป แต่แทบจะถูกลืมไปเลย
ผมคิดว่าคุณไม่อาจจะตั้งเป้าหรือวางแผนเพื่อให้โปรแกรมมาถึงจุดนี้ได้เลย คุณต้องเป็นไปเอง ด้วยแนวคิดการออกแบบที่ทรงพลังพอที่ผลลัพธ์ที่ออกมาจะกลายเป็นสิ่งที่เลี่ยงไม่ได้ เป็นธรรมชาติ หรือแม้แต่เหมือนถูกลิขิตไว้ วิธีเดียวที่จะได้สุดยอดแนวคิดอย่างนั้นมา คือต้องมีความคิดจำนวนมาก หรือไม่ก็มีวิจารณญาณทางวิศวกรรมที่นำความคิดของผู้อื่นมาใช้ โดยที่เจ้าของไม่นึกว่าจะนำมาใช้ได้ขนาดนี้
แอนดี้ ทาเนนบอม มีความคิดเริ่มแรกคือสร้างยูนิกซ์ง่ายๆ สำหรับ IBM PC โดยเฉพาะ เพื่อใช้เป็นตัวอย่างในการสอนหนังสือ (เขาเรียกมันว่ามินิกซ์) ไลนัส ทอร์วัลด์ ผลักดันแนวคิดของมินิกซ์ต่อไปจนไกลเกินกว่าที่แอนดี้จะเคยนึกถึง และมันก็กลายเป็นสิ่งมหัศจรรย์ ในทำนองเดียวกัน (แต่ขนาดเล็กกว่า) ผมนำแนวคิดบางอย่างของ คาร์ล แฮร์ริส และ Harry Hochheiser มาใช้ แล้วผลักดันต่ออย่างจริงจัง ในบรรดาพวกเรา ไม่มีใครสักคนที่เป็น `ผู้คิดค้น' ในแบบที่ผู้คนนึกฝันว่าเป็นอัจฉริยะเลย แต่จริงๆ แล้วผลงานทางวิทยาศาสตร์ วิศวกรรม และการพัฒนาซอฟต์แวร์นั้น ส่วนมากไม่ได้เกิดจากอัจฉริยะที่เป็นผู้คิดค้นเลย เรื่องพวกนั้นเป็นตำนานปรัมปราของแฮ็กเกอร์เสียมากกว่า
ผลลัพธ์ที่ออกมาร้อนแรงพอๆ กัน จะว่าไปแล้ว ก็เป็นความสำเร็จชนิดที่แฮ็กเกอร์ทุกคนฝันถึงเลย และนั่นหมายความว่า ผมต้องตั้งมาตรฐานของตัวเองให้สูงขึ้น และในการทำให้ fetchmail ดีได้อย่างที่ผมมองเห็นความเป็นไปได้นี้ นอกจากผมจะต้องเขียนเพื่อสนองความต้องการของตัวเองแล้ว ยังต้องเพิ่มความสามารถที่คนอื่นที่อยู่นอกแวดวงของผมต้องการอีกด้วย ในขณะเดียวกัน ก็ต้องรักษาตัวโปรแกรมให้เรียบง่ายและแน่นหนาดังเดิมด้วย
ความสามารถสำคัญอันแรกที่ผมเพิ่มเข้ามาหลังจากตระหนักถึงความจริงข้างต้น คือการสนับสนุน multidrop หรือความสามารถที่จะดึงเมลจากกล่องเมลรวมที่รวมเมลของผู้ใช้กลุ่มหนึ่ง ไปกระจายให้กับผู้ใช้แต่ละคนตามที่จ่าหน้าในเมล
ผมตัดสินใจที่จะเพิ่มการสนับสนุน multidrop ส่วนหนึ่งเพราะมีผู้ใช้จำนวนหนึ่งเรียกร้อง แต่สาเหตุสำคัญคือ ผมคาดว่ามันจะช่วยแก้บั๊กต่างๆ ในโค้ดส่วน single drop ออกไปด้วย เพราะจะเป็นการบังคับให้ผมมาสนใจกับการจัดการเรื่องที่อยู่เมลในรูปทั่วไปจริงๆ เสียที และมันก็เป็นอย่างที่ผมคิด การแจงที่อยู่เมลแบบ <ulink url="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc822.txt">RFC 822</ulink> ให้ถูกต้อง กินเวลาของผมไปมาก ไม่ใช่เพราะว่าโค้ดของมันยาก แต่มันมีรายละเอียดที่เกี่ยวพันกันค่อนข้างเยอะ
แต่การเพิ่มการจัดการที่อยู่เมลแบบ multidrop เข้ามานั้น กลายเป็นการตัดสินใจที่ยอดเยี่ยมเกี่ยวกับการออกแบบ ตอนนี้ผมรู้ว่า:
14. เครื่องมือทั่วไปจะใช้ประโยชน์ได้ตามที่ตั้งใจไว้ แต่เครื่องมือที่ยอดเยี่ยมจริงๆ จะสามารถใช้ไปในทางที่ไม่ได้ตั้งใจไว้ได้ด้วย
การใช้ fetchmail แบบ multidrop ที่คาดไม่ถึง คือใช้ทำเมลลิ่งลิสต์ โดยเก็บรายชื่อสมาชิกและกระจายเมลในฝั่ง <emphasis>เครื่องลูกข่าย</emphasis> ของการเชื่อมต่ออินเทอร์เน็ต ซึ่งหมายความว่า ใครก็ตามที่มีเครื่องต่อกับอินเทอร์เน็ตผ่านบัญชีของ ISP ก็สามารถจัดการกับเมลลิ่งลิสต์ได้ โดยไม่ต้องอาศัยแฟ้ม alias ในฝั่งของ ISP เลย
การเปลี่ยนแปลงที่สำคัญอีกอย่างที่นักทดสอบของผมเรียกร้องคือ สนับสนุน MIME (Multipurpose Internet Mail Extensions) แบบ 8 บิต ซึ่งอันนี้ทำค่อนข้างง่าย เพราะผมได้ระวังให้โค้ดทำงานแบบ 8 บิตได้มาตั้งแต่ต้น (กล่าวคือ โดยไม่พยายามใช้งานบิตที่ 8 ที่ไม่ได้ใช้ในรหัส ASCII มาเก็บข้อมูลในโปรแกรม) ที่ผมทำเช่นนี้ไม่ใช่เป็นเพราะคาดไว้ก่อนว่าจะต้องเพิ่มความสามารถนี้ แต่เป็นเพราะผมทำตามกฎอีกข้อหนึ่ง:
15. เมื่อจะเขียนโปรแกรมที่เกี่ยวกับทางผ่านของข้อมูล (gateway) ใดๆ พึงหลีกเลี่ยงการเปลี่ยนแปลงกระแสข้อมูลให้มากที่สุด และ <emphasis>ห้าม</emphasis> ทิ้งข้อมูลทุกชนิด ยกเว้นผู้รับจะบังคับให้ทำเช่นนั้น!
ถ้าผมไม่ปฏิบัติตามกฎนี้ การสนับสนุน MIME แบบ 8 บิตจะยากและเต็มไปด้วยบั๊ก แต่สิ่งที่ผมต้องทำจริงๆ ก็แค่อ่านมาตรฐานของ MIME (<ulink url="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc1652.txt">RFC 1652</ulink>) และเพิ่มส่วนแก้ไขข้อมูลส่วนหัวนิดเดียว
ผู้ใช้บางคนจากยุโรปเรียกร้องให้ผมเพิ่มตัวเลือกในการจำกัดจำนวนเมลที่จะดึงในแต่ละครั้ง (เพื่อที่พวกเขาจะได้สามารถควบคุมค่าโทรศัพท์ได้) ผมปฏิเสธเรื่องนี้เป็นเวลานาน และผมก็ยังไม่ชอบความสามารถนี้เท่าไรนัก แต่ถ้าคุณเขียนโปรแกรมให้โลกใช้ คุณต้องฟังเสียงของผู้ใช้ เงื่อนไขนี้ไม่ได้เปลี่ยนแปลงเพียงเพราะเขาไม่ได้ได้จ่ายคุณเป็นตัวเงิน
บทเรียนเพิ่มเติมจาก Fetchmail
ก่อนที่เราจะกลับไปสู่ประเด็นเกี่ยวกับวิศวกรรมซอฟต์แวร์ทั่วไป ยังมีบทเรียนให้ตรึกตรองอีกนิดหน่อยจากประสบการณ์ของ fetchmail โดยเฉพาะ ผู้อ่านที่ไม่มีพื้นฐานทางเทคนิคสามารถข้ามหัวข้อนี้ไปได้
ไวยากรณ์ของแฟ้ม rc (แฟ้มควบคุม) มีคำแทรกที่จะใส่หรือไม่ก็ได้ ซึ่งตัวแจงจะไม่สนใจ ไวยากรณ์ที่คล้ายภาษาอังกฤษที่เกิดจากคำแทรกดังกล่าว ทำให้อ่านง่ายกว่าการใช้คู่ คำหลัก-ค่า ที่สั้นห้วนตามแบบฉบับที่คุณจะได้เมื่อตัดคำแทรกเหล่านั้นออกไป
แนวคิดดังกล่าว เริ่มจากการทดลองอะไรเล่นๆ ตอนดึก หลังจากที่ผมสังเกตว่ารูปแบบการประกาศในแฟ้ม rc ชักจะเริ่มคล้ายประโยคคำสั่งย่อยๆ (นี่เป็นเหตุผลที่ผมเปลี่ยนคำหลัก ``server'' ของ popclient ไปเป็น ``poll'')
ผมรู้สึกว่าการพยายามทำประโยคคำสั่งย่อยๆ ให้คล้ายภาษามนุษย์อาจทำให้มันใช้ง่ายขึ้น ทุกวันนี้ แม้ผมจะอยู่ฝ่ายสนับสนุนค่ายการออกแบบที่ ``ทำให้มันเป็นภาษา'' อย่างที่มี Emacs และ HTML และโปรแกรมจัดการฐานข้อมูลหลายตัวเป็นตัวอย่าง แต่โดยปกติ ผมก็ไม่ได้นิยมไวยากรณ์ที่ ``คล้ายภาษามนุษย์'' มากมายนัก
โดยธรรมเนียมแล้ว โปรแกรมเมอร์มีแนวโน้มที่จะชอบไวยากรณ์ควบคุมที่เที่ยงตรงและกระชับ และไม่มีส่วนเกินอยู่เลย นี่เป็นมรดกทางวัฒนธรรมจากยุคที่ทรัพยากรการคำนวณมีราคาแพง ซึ่งทำให้ขั้นตอนการแจงต้องประหยัดและง่ายที่สุดเท่าที่จะทำได้ ภาษามนุษย์ซึ่งมีส่วนเกินราว 50% จึงไม่ใช่รูปแบบที่เหมาะสมในขณะนั้น
นี่ไม่ใช่เหตุผลที่โดยปกติผมพยายามหลีกเลี่ยงไวยากรณ์ที่คล้ายภาษามนุษย์ ผมยกเหตุผลดังกล่าวขึ้นมาในที่นี้เพียงเพื่อจะหักล้างเท่านั้น ด้วยพลังคำนวณและหน่วยความจำที่ถูกลง ความสั้นห้วนก็ไม่ควรจะเป็นคำตอบสุดท้ายอีกต่อไป ทุกวันนี้ สิ่งที่สำคัญกว่าสำหรับภาษา ก็คือความสะดวกต่อมนุษย์ ไม่ใช่ความง่ายสำหรับคอมพิวเตอร์
อย่างไรก็ดี ยังมีเหตุผลที่ดีที่พึงระวัง ข้อแรกคือความซับซ้อนของขั้นตอนการแจง คุณคงไม่ต้องการจะให้ความสำคัญกับมันจนกลายมาเป็นแหล่งบั๊กแหล่งใหญ่ หรือทำให้ผู้ใช้สับสน อีกข้อหนึ่งคือการพยายามทำไวยากรณ์ของภาษาให้คล้ายภาษามนุษย์ มักจะติดข้อจำกัดว่า ``ภาษามนุษย์'' ที่ว่านั้น จะถูกดัดจนผิดรูปอย่างร้ายแรง จนถึงขั้นที่ความคล้ายคลึงกับภาษาธรรมชาติอย่างผิวเผินจะน่าปวดหัวพอๆ กับไวยากรณ์แบบเก่า (คุณจะพบผลร้ายดังกล่าวได้ในสิ่งที่เรียกว่า ภาษา ``รุ่นที่สี่'' และภาษาสืบค้นฐานข้อมูลเชิงพาณิชย์ต่างๆ)
ไวยากรณ์ควบคุมของ fetchmail ดูจะหลีกเลี่ยงปัญหาดังกล่าว เพราะกรอบของภาษาจะจำกัดอย่างมาก มันไม่มีอะไรคล้ายกับภาษาอเนกประสงค์เลย สิ่งที่บรรยายเป็นเพียงสิ่งที่ไม่ซับซ้อน ดังนั้น จึงมีแนวโน้มของความสับสนน้อยมากในการสลับไปมาระหว่างภาษามนุษย์ง่ายๆ กับภาษาที่ใช้ควบคุมจริง ผมคิดว่า เราน่าจะได้บทเรียนที่กว้างขึ้นสำหรับเรื่องนี้:
16. ตราบใดที่ภาษาของคุณไม่ได้ซับซ้อนระดับภาษาทูริงสมบูรณ์ การเสริมแต่งไวยากรณ์ก็อาจช่วยคุณได้
อีกบทเรียนหนึ่ง เป็นเรื่องเกี่ยวกับความนิรภัยโดยอาศัยความลึกลับ (security by obscurity) ผู้ใช้ fetchmail บางคนขอให้ผมแก้โปรแกรมให้เก็บรหัสผ่านในรูปที่เข้ารหัสลับในแฟ้ม rc เพื่อไม่ให้ผู้บุกรุกอ่านรหัสผ่านได้ง่ายนัก
ผมไม่ทำตามคำขอนั้น เพราะมันไม่ได้เพิ่มการปกป้องใดๆ เลย ใครก็ตามที่ได้รับสิทธิ์อ่านแฟ้ม rc ของคุณ จะสามารถเรียกใช้ fetchmail ในฐานะตัวคุณได้อยู่แล้ว และถ้าเขากำลังล่าหารหัสผ่านของคุณ เขาก็สามารถถอดส่วนถอดรหัสออกจากโค้ดของ fetchmail เพื่ออ่านเอาก็ได้
สิ่งที่จะได้จากการเข้ารหัสลับรหัสผ่านในแฟ้ม <filename>.fetchmailrc</filename> ก็คือการให้มายาภาพของความนิรภัยต่อผู้ที่ไม่ได้คิดอย่างถี่ถ้วน กฎทั่วไปของเรื่องนี้ก็คือ:
17. ระบบนิรภัยจะมีความนิรภัยเท่ากับความลับที่มันเก็บเท่านั้น พึงระวังความนิรภัยหลอกๆ
เงื่อนไขตั้งต้นที่จำเป็นสำหรับแนวทางตลาดสด
ผู้ตรวจทานและผู้ทดลองอ่านบทความนี้คนแรกๆ ต่างตั้งคำถามเหมือนๆ กัน เกี่ยวกับเงื่อนไขตั้งต้นที่จำเป็นสำหรับการพัฒนาแบบตลาดสด รวมทั้งคุณสมบัติของผู้นำโครงการ และสถานะของโค้ดขณะที่ออกสู่สาธารณะเพื่อเริ่มสร้างชุมชนผู้ร่วมพัฒนา
ค่อนข้างชัดเจนอยู่แล้ว ว่าไม่มีใครสามารถเขียนโค้ดตั้งแต่ต้นในแบบตลาดสดได้ <link linkend="IN">[IN]</link> การทดสอบ ตรวจบั๊ก และปรับปรุงในแบบตลาดสดนั้น เป็นไปได้ แต่การ <emphasis>เริ่มต้น</emphasis> โครงการในแบบตลาดสดเป็นเรื่องที่ยากมาก ไลนัสเองก็ไม่ได้ลองทำ ผมก็ไม่ได้ลองเหมือนกัน ชุมชนนักพัฒนาที่จะบังเกิดขึ้น จะต้องการอะไรที่ทำงานได้และทดสอบได้ไว้เล่นด้วย
เมื่อคุณเริ่มสร้างชุมชน สิ่งที่คุณต้องสามารถนำเสนอให้ได้ก็คือ <emphasis>ความเป็นไปได้</emphasis> โปรแกรมของคุณไม่จำเป็นต้องทำงานได้ดี มันอาจจะหยาบๆ มีบั๊ก ไม่สมบูรณ์ และขาดเอกสารอธิบายได้ แต่สิ่งที่จะพลาดไม่ได้ก็คือ (ก) ต้องเรียกใช้งานได้ (ข) ทำให้ผู้ที่จะร่วมพัฒนาเชื่อได้ ว่ามันจะวิวัฒน์ไปเป็นสิ่งที่เนี้ยบได้ในอนาคตอันใกล้
ทั้งลินุกซ์และ fetchmail ต่างออกสู่สาธารณะพร้อมการออกแบบที่แข็งแรงและดึงดูด หลายคนที่คิดเกี่ยวกับรูปแบบตลาดสดตามที่ผมได้นำเสนอ ต่างถือว่าสิ่งนี้สำคัญยิ่งยวด แล้วก็กระโดดจากจุดนั้นไปยังข้อสรุปทันที ว่าความหยั่งรู้ในการออกแบบและความฉลาดของผู้นำโครงการ เป็นสิ่งที่ขาดเสียไม่ได้
แต่ไลนัสได้การออกแบบของเขามาจากยูนิกซ์ ผมเองก็ได้การออกแบบของผมมาจาก popclient ที่มีมาก่อน (แม้จะเปลี่ยนไปอย่างมากในภายหลัง มากกว่าที่เกิดกับลินุกซ์หลายเท่า) ดังนั้น ผู้นำหรือผู้ประสานงานของงานในแบบตลาดสด ยังต้องมีพรสวรรค์ในการออกแบบอย่างเอกอุ หรือเขาสามารถสร้างขึ้นได้จากการใช้พรสวรรค์การออกแบบของผู้อื่น?
ผมคิดว่าไม่ใช่เรื่องคอขาดบาดตายเลย ที่ผู้ประสานงานจะต้องสามารถออกแบบซอฟต์แวร์ได้อย่างบรรเจิด แต่เป็นเรื่องสำคัญมาก ที่ผู้ประสานงานต้องสามารถ <emphasis>ตระหนักรู้แนวคิดการออกแบบที่ดีจากผู้อื่น</emphasis>
ทั้งโครงการลินุกซ์และ fetchmail ต่างแสดงตัวอย่างของเรื่องนี้ ในขณะที่ไลนัสไม่ใช่นักออกแบบคิดค้นที่ดีเลิศ (ดังที่ได้กล่าวไปแล้ว) แต่เขาได้แสดงความสามารถพิเศษในการตระหนักรู้การออกแบบที่ดี และผนวกรวมเข้าในเคอร์เนลลินุกซ์ และผมก็ได้บรรยายไปแล้ว ถึงการที่แนวคิดการออกแบบดีที่สุดเพียงชิ้นเดียวใน fetchmail (การส่งเมลต่อไปยัง SMTP) มาจากคนอื่น
ผู้อ่านบทความนี้คนแรกๆ ได้ยกยอผม โดยบอกว่าผมหมิ่นเหม่ที่จะประเมินคุณค่าของความเป็นผู้คิดค้นในโครงการตลาดสดต่ำเกินไป เพราะผมมีความเป็นผู้คิดค้นอยู่ในตัว และก็เลยไม่พูดถึงมัน ก็อาจจะมีส่วนจริง การออกแบบเป็นความเชี่ยวชาญที่แข็งที่สุดของผม (ถ้าเทียบกับการเขียนโค้ดหรือการตรวจบั๊ก)
แต่ปัญหาของความฉลาดและความเป็นผู้คิดค้นในการออกแบบซอฟต์แวร์ ก็คือมันจะกลายเป็นนิสัย กล่าวคือ คุณจะเริ่มทำอะไรเจ๋งๆ และซับซ้อนแบบเป็นไปโดยอัตโนมัติในจุดที่คุณควรทำให้มันเรียบง่ายและแน่นหนา ผมเคยทำโครงการพังเพราะทำผิดแบบนี้มาแล้ว แต่ผมพยายามหลีกเลี่ยงปัญหาดังกล่าวเมื่อทำ fetchmail
ดังนั้น ผมจึงเชื่อว่าโครงการ fetchmail ประสบความสำเร็จเพราะผมงดนิสัยของผมที่จะพยายามฉลาด เรื่องนี้ อย่างน้อยก็สามารถค้านเรื่องที่ว่า ความเป็นผู้คิดค้นออกแบบเป็นสิ่งจำเป็นสำหรับความสำเร็จของโครงการตลาดสด และลองพิจารณาลินุกซ์ดูสิ สมมุติว่า ไลนัส ทอร์วัลด์ ได้พยายามดึงเอานวัตกรรมพื้นฐานของการออกแบบระบบปฏิบัติการออกไปในระหว่างการพัฒนา มันจะเป็นไปได้ไหมที่เคอร์เนลที่ได้จะเสถียรและประสบความสำเร็จอย่างที่เรามี?
แน่นอนว่าความเชี่ยวชาญในขั้นพื้นฐานของการออกแบบและเขียนโค้ดเป็นสิ่งจำเป็น แต่ผมก็คาดหวังว่าใครที่คิดจะตั้งโครงการแบบตลาดสดจริงจัง ก็คงมีความสามารถเหนือระดับที่ต้องการอยู่แล้ว ตลาดของชื่อเสียงภายในชุมชนโอเพนซอร์สได้ให้แรงกดดันอย่างละเอียดอ่อนต่อผู้คน ที่จะไม่ตั้งโครงการพัฒนาที่ตัวเองไม่มีความสามารถจะดูแล เท่าที่ผ่านมา แรงกดดันดังกล่าวก็ทำงานได้ดี
ยังมีความเชี่ยวชาญอีกชนิดหนึ่งที่ไม่ได้เกี่ยวข้องกับการพัฒนาซอฟต์แวร์ ที่ผมคิดว่าสำคัญต่อโครงการแบบตลาดสดพอๆ กับความฉลาดในการออกแบบ และอาจจะสำคัญกว่าเสียด้วยซ้ำ กล่าวคือ ผู้ประสานงานหรือผู้นำโครงการแบบตลาดสด จะต้องมีความเชี่ยวชาญในการติดต่อสื่อสารกับผู้คน
เรื่องนี้ควรจะชัดเจนอยู่แล้ว ในการสร้างชุมชนพัฒนา คุณต้องดึงดูดผู้คน ทำให้เขาสนใจในสิ่งที่คุณทำ และทำให้เขายินดีกับปริมาณงานที่เขาทำ งานทางเทคนิคจะมีอยู่ตลอดเพื่อทำงานนี้ แต่เป็นเพียงส่วนน้อยของเรื่องราวทั้งหมด บุคลิกที่คุณแสดงออกก็มีความสำคัญเช่นกัน
ไม่ใช่เรื่องบังเอิญที่ไลนัสเป็นคนนิสัยดีที่ทำให้คนที่คล้ายกับเขาต้องการช่วยเขา ไม่ใช่เรื่องบังเอิญที่ผมเป็นคนเปิดเผยที่มีชีวิตชีวาซึ่งชอบทำงานกับฝูงชน และมีสัญชาตญาณของอารมณ์ขัน ถ้าจะให้รูปแบบตลาดสดทำงานได้ การมีความเชี่ยวชาญในการดึงดูดผู้คนจะช่วยได้มากทีเดียว
สภาพแวดล้อมทางสังคมของซอฟต์แวร์โอเพนซอร์ส
มีข้อเขียนเกี่ยวกับเรื่องนี้จริงๆ ว่าการแฮ็กที่ดีที่สุด เริ่มจากวิธีส่วนตัวในการแก้ปัญหาที่ตัวผู้เขียนพบในชีวิตประจำวัน และแพร่หลายออกไป เพราะปรากฏว่าเป็นปัญหาปกติที่ผู้ใช้จำนวนมากก็พบเช่นกัน เรื่องนี้นำเรากลับไปสู่กฏข้อที่ 1 ซึ่งกล่าวใหม่ในแบบที่มีประโยชน์ขึ้นได้ว่า:
18. การแก้ปัญหาที่น่าสนใจ เริ่มจากการค้นหาปัญหาที่คุณสนใจ
ซึ่งเหมือนที่เกิดกับ คาร์ล แฮร์ริส กับ popclient รุ่นแรกๆ และกับผมกับ fetchmail อย่างไรก็ดี เรื่องนี้เป็นที่เข้าใจกันมานานแล้ว แต่จุดที่น่าสนใจจริงๆ โดยเฉพาะในประวัติของลินุกซ์และ fetchmail ที่เราต้องศึกษา ก็คือขั้นต่อไปต่างหาก กล่าวคือ วิวัฒนาการของซอฟต์แวร์ในชุมชนผู้ใช้และผู้ร่วมพัฒนาที่มีขนาดใหญ่และตื่นตัวสูง
ในหนังสือ <citetitle>The Mythical Man-Month</citetitle> เฟรด บรูกส์ ตั้งข้อสังเกตว่า เวลาในการทำงานของโปรแกรมเมอร์นั้นทดแทนกันไม่ได้ การเพิ่มนักพัฒนาให้กับโครงการซอฟต์แวร์ที่ล่าช้าอยู่ จะทำให้มันยิ่งล่าช้ายิ่งขึ้น ดังที่เราได้กล่าวไปแล้ว เขาอ้างว่าความซับซ้อนและค่าโสหุ้ยในการสื่อสารของโครงการ จะเพิ่มขึ้นในอัตรากำลังสองของจำนวนนักพัฒนา ในขณะที่งานที่ได้ จะเพิ่มขึ้นเป็นลักษณะเส้นตรงเท่านั้น กฎของบรูกส์ได้รับการยอมรับโดยทั่วไปว่าเป็นความจริง แต่เราได้วิเคราะห์มาแล้วในบทความนี้ ถึงวิธีต่างๆ ที่กระบวนการพัฒนาแบบโอเพนซอร์สได้ทะลายข้อสมมุติต่างๆ ของกฎนี้ และถ้าว่ากันที่ผลในทางปฏิบัติ หากกฎของบรูกส์ครอบคลุมทั้งหมดแล้ว ลินุกซ์ก็คือสิ่งที่เป็นไปไม่ได้
หนังสืออมตะของ เจอรัลด์ เวนเบิร์ก ชื่อ <citetitle>จิตวิทยาของการเขียนโปรแกรมคอมพิวเตอร์ (The Psychology of Computer Programming)</citetitle> เสนอสิ่งที่เราเข้าใจเบื้องหลังได้ว่าเป็นการแก้ไขกฎของบรูกส์ครั้งสำคัญ ในการอภิปรายเกี่ยวกับ ``การเขียนโปรแกรมแบบไร้อัตตา'' เวนเบิร์กตั้งข้อสังเกตว่า ในหน่วยงานที่นักพัฒนาไม่มีการหวงห้ามโค้ด และยังเชิญชวนให้คนอื่นๆ ให้มาช่วยกันหาข้อผิดพลาด และจุดที่อาจจะพัฒนาต่อได้ จะมีการพัฒนาได้เร็วกว่าหน่วยงานอื่นๆ อย่างเห็นได้ชัด (เร็วๆ นี้ เทคนิค `extreme programming' ของ เคนต์ เบ็ก ที่ให้นักพัฒนาจับคู่กันดูโค้ดกันและกัน อาจเป็นความพยายามหนึ่งที่จะบังคับให้เกิดผลดังกล่าว)
บางที การเลือกใช้คำของเวนเบิร์ก อาจทำให้การวิเคราะห์ของเขาไม่ได้รับการยอมรับเท่าที่ควรจะเป็น บางคนอาจจะอมยิ้มเมื่อนึกถึงการบรรยายถึงแฮ็กเกอร์ในอินเทอร์เน็ตด้วยคำว่า ``ไร้อัตตา'' แต่ผมคิดว่าเหตุผลของเขานั้นดีเหลือเกิน โดยเฉพาะอย่างยิ่งในปัจจุบัน
ด้วยการใช้ประโยชน์จากผลของ ``การเขียนโปรแกรมแบบไร้อัตตา'' อย่างเต็มพิกัด วิธีการแบบตลาดสดได้บรรเทาผลของกฎของบรูกส์ลงอย่างมาก มันไม่ถึงกับทำลายหลักการเบื้องหลังของกฎของบรูกส์ลง แต่ด้วยจำนวนนักพัฒนาที่มากพอ และด้วยการสื่อสารที่สะดวก ผลของมันสามารถถูกกลบได้ด้วยปัจจัยตรงข้ามที่ไม่ได้มีลักษณะเป็นเชิงเส้น ซึ่งจะมองไม่เห็นจนกว่าจะเกิดเงื่อนไขดังกล่าวขึ้น เรื่องนี้ ก็คล้ายกับความสัมพันธ์ระหว่างฟิสิกส์แบบนิวตันและแบบไอน์สไตน์ กล่าวคือ ระบบเก่าก็ยังใช้การได้ที่ระดับพลังงานต่ำ แต่ถ้าคุณเพิ่มมวลและความเร็วมากพอ คุณก็จะพบเรื่องแปลกประหลาดอย่างการระเบิดแบบนิวเคลียร์ หรือลินุกซ์
ประวัติของยูนิกซ์ควรจะช่วยปูพื้นให้กับสิ่งที่เราเรียนรู้จากลินุกซ์ได้ (รวมทั้งสิ่งที่ผมได้ลงมือตรวจสอบผ่านการทดลองในขนาดที่เล็กลง ด้วยการเลียนแบบวิธีของไลนัสอย่างเจตนา <link linkend="EGCS">[EGCS]</link>) นั่นคือ ในขณะที่โดยเนื้อแท้แล้วการเขียนโค้ดยังคงเป็นกิจกรรมที่ต้องทำคนเดียวอยู่ แต่การแฮ็กที่สุดยอดจริงๆ กลับเกิดจากการควบคุมทิศทางความสนใจและพลังสมองของชุมชนทั้งหมด นักพัฒนาที่ใช้แค่สมองของตนเองในโครงการปิด กำลังจะถูกแซงโดยนักพัฒนาที่รู้วิธีสร้างสภาพแวดล้อมแบบเปิดเพื่อการวิวัฒน์ ที่ซึ่งผลตอบรับที่ช่วยสำรวจวิธีออกแบบที่เป็นไปได้ การสมทบโค้ด การชี้ข้อผิดพลาด และการปรับปรุงอื่นๆ จะมาจากคนเป็นร้อยๆ (หรืออาจเป็นพันๆ)
แต่โลกของยูนิกซ์สมัยก่อน กลับไม่สามารถใช้วิธีนี้ไปถึงจุดสูงสุดได้ ด้วยปัจจัยหลายประการ ปัจจัยหนึ่งก็คือข้อจำกัดทางกฎหมายของสัญญาอนุญาตแบบต่างๆ ความลับทางการค้า และความสนใจทางธุรกิจ นอกจากนี้ อีกปัจจัยหนึ่งที่เข้าใจได้ คืออินเทอร์เน็ตยังใช้การได้ไม่ดีพอในตอนนั้น
ก่อนที่อินเทอร์เน็ตจะมีราคาถูกอย่างทุกวันนี้ ได้มีชุมชนเล็กๆ ที่รวมตัวกันด้วยพื้นที่ทางภูมิศาสตร์บางกลุ่ม ซึ่งมีวัฒนธรรมที่สนับสนุนให้เกิดการเขียนโปรแกรมแบบ ``ไร้อัตตา'' ของเวนเบิร์ก และนักพัฒนาสามารถดึงดูดผู้อยากรู้อยากเห็นและผู้ร่วมพัฒนาที่มีทักษะจำนวนมากได้อย่างง่ายดาย ชุมชนอย่าง เบลล์แล็บ, แล็บ AI และ LCS ของ MIT, UC Berkeley เหล่านี้ได้กลายเป็นบ่อเกิดของนวัตกรรมระดับตำนานมากมาย และทุกวันนี้ชุมชนเหล่านี้ก็ยังคงแสดงศักยภาพอยู่
ลินุกซ์เป็นโครงการแรกที่สามารถใช้ <emphasis>โลกทั้งใบ</emphasis> เป็นแหล่งของพรสวรรค์ได้อย่างจงใจและประสบความสำเร็จ ผมไม่คิดว่ามันเป็นเรื่องบังเอิญ ที่ช่วงเวลาบ่มเพาะตัวของลินุกซ์ พอดีกันกับการเกิดของเครือข่ายใยแมงมุม (World Wide Web) และที่ลินุกซ์เริ่มเติบโตในระหว่างปี 1993–1994 ซึ่งตรงกับช่วงที่เกิดอุตสาหกรรมการให้บริการอินเทอร์เน็ต และเกิดการบูมของอินเทอร์เน็ตในความสนใจกระแสหลักของผู้คน ไลนัสเป็นคนแรกที่รู้วิธีเล่นกับกฎเกณฑ์ใหม่ๆ ที่อินเทอร์เน็ตได้สร้างขึ้น
แม้อินเทอร์เน็ตราคาถูก จะเป็นเงื่อนไขที่จำเป็นในการพัฒนาในแบบลินุกซ์ แต่ผมคิดว่าแค่สิ่งนี้อย่างเดียวยังไม่เพียงพอ ปัจจัยที่สำคัญอีกอย่างหนึ่งก็คือ การพัฒนาของรูปแบบความเป็นผู้นำ และประเพณีแห่งความร่วมมือต่างๆ ซึ่งทำให้ผู้พัฒนาสามารถดึงดูดผู้ร่วมพัฒนา และใช้ประโยชน์สูงสุดจากสื่ออย่างอินเทอร์เน็ต
แต่เป็นรูปแบบความเป็นผู้นำแบบไหน? และอะไรคือประเพณีต่างๆ ที่ว่า? สิ่งเหล่านี้ไม่สามารถได้มาจากการใช้อำนาจ หรือถึงแม้ว่ามันจะใช้ได้ แต่การเป็นผู้นำที่ใช้การบังคับ ก็ไม่สามารถสร้างผลลัพธ์อย่างที่เราเห็นอยู่ทุกวันนี้ได้ เวนเบิร์กยกคำกล่าวจากอัตชีวประวัติของ ปโยต์ อเล็กเซวิช โครพอตกิน (Pyotr Alexeyvich Kropotkin) อนาธิปัตย์ชาวรัสเซียในคริสต์ศตวรรษที่ 19 ในหนังสือ <citetitle>ความทรงจำของนักปฏิวัติ (Memoirs of a Revolutionist)</citetitle> ซึ่งเกี่ยวข้องกับเรื่องนี้อย่างมาก:
ด้วยความที่เติบโตมาในครอบครัวที่มีทาส ผมได้เข้าสู่ชีวิตที่กระฉับกระเฉงเหมือนๆ กับชายหนุ่มอื่นๆ ในยุคของผม ซึ่งมีความมั่นใจในความจำเป็นของการบังคับบัญชา การออกคำสั่ง การตำหนิ การลงโทษ และอะไรทำนองนี้ แต่เมื่อผมได้เริ่มบริหารบรรษัทอย่างจริงจัง และต้องติดต่อจัดการกับผู้คนซึ่งไม่ใช่ทาส ทั้งความผิดพลาดแต่ละครั้ง อาจจะนำไปสู่ความเสียหายอันใหญ่หลวง ผมก็ได้เริ่มตระหนักถึงความแตกต่างระหว่าง หลักแห่งการบังคับบัญชาและระเบียบวินัย กับ หลักแห่งการทำความเข้าใจขั้นพื้นฐานร่วมกัน หลักอันแรกใช้การได้ดีกับการเดินสวนสนามของทหาร แต่ไม่มีประโยชน์อะไรเลยในชีวิตจริง จุดหมายที่ตั้งไว้จะบรรลุได้ ก็ด้วยความทุ่มเทอย่างแข็งขัน จากเจตน์จำนงอันหลากหลายที่มีเป้าหมายร่วมกันเท่านั้น
``ความทุ่มเทอย่างแข็งขัน จากเจตน์จำนงอันหลากหลายที่มีเป้าหมายร่วมกัน'' คือสิ่งที่โครงการอย่างลินุกซ์ต้องการอย่างไม่ต้องสงสัย และไม่มีทางที่ ``หลักแห่งการบังคับบัญชา'' จะใช้ได้ผลกับเหล่าอาสาสมัครในสวรรค์ของอนาธิปัตย์ที่เราเรียกว่าอินเทอร์เน็ต การที่จะดำเนินงานและแข่งขันอย่างได้ผล เหล่าแฮ็กเกอร์ที่ต้องการจะเป็นผู้นำโครงการที่ต้องการความร่วมมือใดๆ จะต้องเรียนรู้วิธีที่จะสรรหาและกระตุ้นชุมชนที่สนใจจริง ในแบบที่กล่าวไว้อย่างหลวมๆ ใน ``หลักแห่งความเข้าใจกัน'' ของโครพอตกิน พวกเขาต้องเรียนรู้ที่จะใช้กฏของไลนัส <link linkend="SP">[SP]</link>
ก่อนหน้านี้ ผมได้กล่าวถึง ``ปรากฏการณ์เดลไฟ'' ในฐานะคำอธิบายที่พอจะใช้ได้สำหรับกฎของไลนัส แต่ระบบที่ปรับตัวได้ในทางชีววิทยาและเศรษฐศาสตร์ ก็น่าจะเป็นตัวเปรียบเทียบที่ดีเช่นกัน โลกของลินุกซ์มีลักษณะหลายๆ อย่างคล้ายคลึงกับตลาดเสรีหรือระบบนิเวศน์ ซึ่งประกอบด้วยกลุ่มของตัวกระทำที่เห็นแก่ตัว ที่พยายามหาทางที่จะได้ประโยชน์สูงสุด โดยในกระบวนการนั้น จะเกิดการจัดระเบียบที่มีการแก้ไขตัวเองแบบเป็นไปเอง ซึ่งจะมีผลแทรกซึมและมีประสิทธิภาพเกินกว่าที่การวางแผนจากส่วนกลางใดๆ จะทำได้ และที่นี่เองที่เราจะมองหา ``หลักแห่งความเข้าใจกัน''
``ฟังก์ชันอรรถประโยชน์'' ที่แฮ็กเกอร์ลินุกซ์พยายามจะทำให้ได้มากที่สุด ไม่ได้เกี่ยวกับเรื่องเศรษฐกิจ แต่เกี่ยวกับความพึงพอใจส่วนตัวและชื่อเสียงในหมู่แฮ็กเกอร์ด้วยกัน (บางคนอาจเรียกแรงจูงใจของพวกเขาเหล่านั้นว่า ``ความเห็นแก่ประโยชน์ส่วนรวม'' โดยมองข้ามความจริงที่ว่า ``ความเห็นแก่ประโยชน์ส่วนรวม'' ก็คืออีกรูปแบบหนึ่งของความพึงพอใจส่วนตัวของ ``ผู้ที่เห็นแก่ประโยชน์ส่วนรวม'') จะว่าไปแล้ว วัฒนธรรมอาสาสมัครในลักษณะนี้ ก็ไม่ใช่เรื่องพิเศษอะไร มีอีกกลุ่มหนึ่งที่ผมได้เข้าร่วมมานานแล้ว คือกลุ่มผู้รักนิยายวิทยาศาสตร์ กลุ่มนี้ต่างจากกลุ่มแฮกเกอร์ตรงที่พวกเขาตระหนักใน ``อีโก้บู'' (egoboo มาจาก ego-boosting หรือการเพิ่มชื่อเสียงของบุคคลในหมู่คนคลั่งไคล้สิ่งเดียวกัน) อย่างชัดแจ้งมาเป็นเวลานานแล้ว ในฐานะสิ่งจูงใจพื้นฐานในการเข้าร่วมกิจกรรมอาสาสมัคร
ไลนัส ซึ่งประสบความสำเร็จในการวางตัวเองเป็นผู้ดูแลโครงการ โดยที่การพัฒนาส่วนใหญ่ทำโดยคนอื่นๆ และเฝ้าหล่อเลี้ยงความสนใจในตัวโครงการจนกระทั่งมันอยู่ได้ด้วยตัวเอง ได้แสดงให้เห็นถึงความเข้าใจอันเฉียบแหลมใน ``หลักแห่งความเข้าใจร่วมกัน'' ของโครพอตกิน มุมมองต่อโลกของลินุกซ์ในลักษณะกึ่งเศรษฐศาสตร์แบบนี้ เปิดโอกาสให้เราได้เห็นว่า ความเข้าใจนั้นถูกนำไปใช้อย่างไร
เราอาจจะมองวิธีของไลนัสเป็นเหมือนการสร้างตลาด ``อีโก้บู'' ที่มีประสิทธิภาพ โดยร้อยรัดความเห็นแก่ตัวของแฮ็กเกอร์แต่ละคนอย่างแน่นหนาที่สุดเท่าที่จะทำได้ เข้ากับปลายทางอันยากลำบาก ซึ่งจะไปถึงได้ก็ด้วยความร่วมมืออย่างไม่ลดละเท่านั้น อย่างในโครงการ fetchmail ผมก็ได้แสดงให้ดู (แม้จะในขนาดที่เล็กกว่า) ว่าวิธีของเขาสามารถทำซ้ำได้ โดยให้ผลที่ดี บางที ผมอาจจะทำแบบจงใจและมีแบบแผนกว่าเขานิดหน่อยด้วยซ้ำ
หลายคน (โดยเฉพาะผู้ที่มีความเคลือบแคลงทางการเมืองกับตลาดเสรี) อาจคาดไว้ว่า วัฒนธรรมของเหล่าคนอัตตาสูงที่เป็นตัวของตัวเอง คงจะแตกกระจาย แบ่งแยก สิ้นเปลือง ลึกลับ และไม่เป็นมิตร แต่สิ่งที่คาดไว้นั้นกลับถูกหักล้างอย่างชัดเจนโดยความหลากหลาย คุณภาพ และความลึกของเนื้อหาของเอกสารลินุกซ์ (หากจะยกมาเพียงตัวอย่างเดียว) เป็นคำสาปที่รู้กันดี ว่าโปรแกรมเมอร์นั้น <emphasis>เกลียด</emphasis> การเขียนเอกสาร แล้วแฮ็กเกอร์ลินุกซ์สร้างเอกสารออกมาได้มากมายอย่างนี้ได้อย่างไร? อย่างที่เราได้เห็น ตลาดเสรีสำหรับอีโก้บูของลินุกซ์สามารถสร้างพฤติกรรมที่มีคุณค่า และสนองความต้องการของผู้อื่น ได้ดีกว่าหน่วยผลิตเอกสารของผู้ผลิตซอฟต์แวร์เชิงพาณิชย์ ที่มีทุนสนับสนุนอย่างมหาศาลเสียอีก
ทั้งโครงการ fetchmail และเคอร์เนลลินุกซ์ ได้แสดงให้เห็นว่า ด้วยการตอบแทนอัตตาของแฮกเกอร์หลายๆ คน อย่างเหมาะสม ผู้พัฒนาและผู้ประสานงานที่มีความสามารถ สามารถใช้อินเทอร์เน็ตดึงเอาข้อดีของการมีผู้ร่วมพัฒนาเยอะๆ ออกมาได้ โดยไม่ทำให้เกิดความสับสนอลหม่าน ดังนั้นเพื่อแย้งกับกฎของบรูกส์ ผมขอเสนอกฎข้อต่อไปนี้:
19. หากผู้ประสานงานมีสื่อที่ดีอย่างน้อยเท่ากับอินเทอร์เน็ต และรู้ว่าจะนำการพัฒนาโดยไม่ต้องบังคับได้อย่างไร หลายหัวย่อมดีกว่าหัวเดียวแน่นอน
ผมคิดว่า อนาคตของซอฟต์แวร์โอเพนซอร์ส จะเป็นของผู้ที่รู้วิธีเล่นเกมของไลนัสมากขึ้นเรื่อยๆ คนซึ่งหันหลังให้กับมหาวิหาร และอ้าแขนรับตลาดสด นี่ไม่ได้หมายความว่า วิสัยทัศน์และความหลักแหลมส่วนบุคคลจะไม่มีความหมายอีกต่อไป ถ้าจะพูดให้ถูก ผมคิดว่า ความรุดหน้าของซอฟต์แวร์โอเพนซอร์ส จะเป็นของผู้ที่เริ่มจากวิสัยทัศน์และความหลักแหลมเฉพาะบุคคล และขยายมันออกไปด้วยการสร้างชุมชนอาสาสมัครที่สนใจเรื่องนั้นอย่างเกิดผล
บางที นี่อาจจะไม่ได้เป็นแค่อนาคตของซอฟต์แวร์ <emphasis>โอเพนซอร์ส</emphasis> เท่านั้น ไม่มีผู้พัฒนาแบบซอร์สปิดรายไหน ที่จะเทียบเคียงได้กับศูนย์รวมของผู้มีพรสวรรค์ซึ่งชุมชนลินุกซ์สามารถใช้รับมือกับปัญหา และมีน้อยรายมาก ที่จะสามารถจ้างคนได้มากกว่า 200 คน (600 ในปี 1999, 800 ในปี 2000) อย่างกลุ่มคนที่ช่วยพัฒนา fetchmail!
บางที ที่สุดแล้ว วัฒนธรรมโอเพนซอร์สจะประสบชัยชนะ ไม่ใช่เพราะความร่วมมือเป็นสิ่งที่ชอบด้วยศีลธรรม หรือ การ ``ปิดบัง'' ซอฟต์แวร์เป็นเรื่องผิดศีลธรรม (ในกรณีที่คุณเชื่อในอย่างหลัง ซึ่งทั้งไลนัสและผมไม่เชื่อ) แต่เพียงเพราะว่า โลกของการปิดซอร์สไม่สามารถเอาชนะการแข่งขันทางวิวัฒนาการกับชุมชนโอเพนซอร์ส ซึ่งสามารถระดมเวลาอันเปี่ยมไปด้วยทักษะจำนวนมาก มาให้กับปัญหาหนึ่งๆ ได้
เกี่ยวกับการบริหารจัดการและปัญหาที่ไม่เป็นปัญหา
บทความ <citetitle>มหาวิหารและตลาดสด</citetitle> ฉบับดั้งเดิมของปี 1997 จบลงด้วยภาพข้างต้น คือภาพที่หมู่โปรแกรมเมอร์อนาธิปัตย์ที่ทำงานกันเป็นเครือข่ายอย่างมีความสุข เอาชนะและท่วมทับโลกแห่งลำดับชั้นการบริหารของซอฟต์แวร์ปิดแบบเก่า
อย่างไรก็ดี ยังมีผู้กังขาอยู่มากพอควรที่ยังไม่เชื่อ และคำถามที่พวกเขาถาม ก็สมควรแก่การพิจารณา ความเห็นแย้งต่อเหตุผลของตลาดสดส่วนใหญ่ มาลงเอยที่การอ้าง ว่าฝ่ายสนับสนุนรูปแบบตลาดสดประเมินผลของการเพิ่มพูนผลิตภาพของระบบบริหารแบบเดิมต่ำเกินไป
ผู้จัดการโครงการพัฒนาซอฟต์แวร์แบบดั้งเดิมมักเห็นค้านว่า ความไม่จริงจังของกลุ่มผู้ร่วมโครงการที่มารวมตัว เปลี่ยนแปลง และสลายไปในโลกโอเพนซอร์สนั้น จะหักล้างกับส่วนสำคัญของข้อดีที่เห็นได้ชัดในเรื่องจำนวน ที่ชุมชนโอเพนซอร์สมีเหนือนักพัฒนาซอร์สปิดใดๆ พวกเขาจะตั้งข้อสังเกตว่า ในการพัฒนาซอฟต์แวร์นั้น สิ่งที่สำคัญคือความพยายามที่ยั่งยืนจริงๆ ในระยะยาว และการที่ลูกค้าสามารถคาดหวังการลงทุนที่ต่อเนื่องในผลิตภัณฑ์ได้ ไม่ใช่แค่ว่ามีคนจำนวนมากแค่ไหนที่โยนกระดูกลงหม้อแล้วรอให้แกงอุ่น
มีประเด็นสำคัญอยู่ในข้อโต้แย้งนี้แน่นอน และอันที่จริง ผมได้สร้างแนวคิดที่คาดหวังว่า คุณค่าของการบริการในอนาคต จะเป็นกุญแจสำคัญของเศรษฐศาสตร์การผลิตซอฟต์แวร์ อยู่ในบทความ <ulink url="http://catb.org/~esr/writings/cathedral-bazaar/magic-cauldron/"><citetitle>The Magic Cauldron</citetitle></ulink>
แต่ข้อโต้แย้งนี้ก็มีปัญหาใหญ่ซ่อนอยู่เช่นกัน คือการเข้าใจเอาว่า การพัฒนาแบบโอเพนซอร์สจะไม่สามารถให้ความพยายามที่ยั่งยืนแบบนั้นได้ อันที่จริงแล้ว ก็มีโครงการโอเพนซอร์สหลายโครงการที่ได้รักษาทิศทางที่สอดคล้อง และชุมชนผู้ดูแลที่มีประสิทธิภาพมาเป็นเวลานานพอสมควร โดยไม่ต้องอาศัยโครงสร้างของแรงจูงใจ หรือสายงานการบังคับบัญชาชนิดที่การบริหารแบบเดิมเห็นว่าจำเป็นเลย การพัฒนาบรรณาธิกรณ์ GNU Emacs เป็นตัวอย่างที่สุดขั้วและให้แง่คิดได้มาก โครงการนี้ ได้ซึมซับเอาความพยายามของผู้ร่วมสมทบงานเป็นร้อยๆ คน ตลอดเวลา 15 ปี เข้ามารวมในวิสัยทัศน์ทางสถาปัตยกรรมที่เป็นอันหนึ่งอันเดียวกัน แม้จะมีกิจกรรมเกิดขึ้นมากมาย และมีเพียงคนเดียว (คือตัวผู้เขียน Emacs เอง) ที่ได้ทำงานอย่างตื่นตัวตลอดช่วงระยะเวลาดังกล่าว ไม่มีโปรแกรมบรรณาธิกรณ์ซอร์สปิดตัวไหน ที่จะมีสถิติยาวนานเทียบเท่าได้
ตัวอย่างนี้ อาจเป็นเหตุผลให้เราตั้งคำถามกลับ เกี่ยวกับข้อดีของการพัฒนาซอฟต์แวร์ที่บริหารในแบบเดิม โดยไม่ได้เกี่ยวข้องกับส่วนที่เหลือของข้อโต้แย้งระหว่างรูปแบบมหาวิหารกับตลาดสดเลย ถ้ามันเป็นไปได้สำหรับ GNU Emacs ที่จะแสดงวิสัยทัศน์ทางสถาปัตยกรรมที่คงเส้นคงวาตลอดเวลา 15 ปี หรือสำหรับระบบปฏิบัติการอย่างลินุกซ์ ที่จะทำอย่างเดียวกันได้ตลอดเวลา 8 ปี ท่ามกลางการเปลี่ยนแปลงอย่างรวดเร็วของเทคโนโลยีฮาร์ดแวร์และแพล็ตฟอร์ม และถ้ามีโครงการโอเพนซอร์สที่มีการออกแบบสถาปัตยกรรมเป็นอย่างดีจำนวนมาก ที่มีช่วงเวลาการทำงานเกิน 5 ปี (ซึ่งก็มีจริงๆ) แล้วล่ะก็ เราก็ต้องตั้งข้อสงสัยแล้วล่ะ ว่าค่าโสหุ้ยหนักๆ ของการพัฒนาด้วยการบริหารแบบเก่า จะให้อะไรแก่เราเป็นการตอบแทน (ถ้ามี)
ไม่ว่ามันจะเป็นอะไร แต่ไม่ใช่การดำเนินการที่รับประกันได้ในเรื่องกำหนดการ การใช้งบประมาณ หรือการทำได้ครบตามข้อกำหนดแน่ๆ หายากมากที่จะมีโครงการที่ `มีการจัดการ' ที่สามารถบรรลุเป้าหมายใดเป้าหมายหนึ่งได้ โดยไม่ต้องพูดถึงการบรรลุครบทั้งสามเป้าหมายเลย และดูจะไม่ใช่ความสามารถในการปรับตัวตามการเปลี่ยนแปลงของเทคโนโลยี และบริบททางเศรษฐกิจในช่วงชีวิตของโครงการเช่นกัน ชุมชนโอเพนซอร์สได้พิสูจน์ให้เห็นถึงประสิทธิผลที่มากกว่า <emphasis>มาก</emphasis> ในแง่ดังกล่าว (เช่น ดังที่ใครก็สามารถตรวจสอบได้ โดยเปรียบเทียบประวัติศาสตร์ 30 ปีของอินเทอร์เน็ต กับครึ่งชีวิตที่สั้นๆ ของเทคโนโลยีเครือข่ายที่สงวนสิทธิ์ หรือเปรียบเทียบค่าโสหุ้ยของการย้ายจาก 16 บิต ไป 32 บิต ในไมโครซอฟท์วินโดวส์ กับการเปลี่ยนรุ่นของลินุกซ์ที่แทบไม่ต้องใช้ความพยายามเลยในช่วงเดียวกัน ไม่ใช่แค่ตามสายการพัฒนาของอินเทลเท่านั้น แต่รวมถึงการย้ายไปยังฮาร์ดแวร์ชนิดอื่นกว่า 12 ชนิด รวมถึงชิปแอลฟา 64 บิตด้วย)
สิ่งหนึ่งที่หลายคนคิดว่าการพัฒนาแบบเก่าจะให้ตอบแทนได้ คือใครบางคนที่จะให้สัญญาทางกฎหมาย และค่าชดเชยสำหรับการฟื้นตัวในกรณีที่โครงการมีปัญหา แต่เรื่องดังกล่าวเป็นเพียงมายาภาพ สัญญาอนุญาตซอฟต์แวร์เกือบทั้งหมด ได้เขียนถึงการสงวนการรับผิดชอบแม้กระทั่งการรับประกันคุณค่าเชิงการค้า ไม่ต้องพูดถึงเรื่องการทำงานเลย และกรณีของการฟื้นตัวหลังซอฟต์แวร์ไม่ทำงานได้สำเร็จก็หายากเต็มที หรือแม้จะมีเป็นเรื่องปกติ การรู้สึกสบายใจที่มีใครให้ฟ้องร้องได้ ก็เป็นการผิดประเด็น คุณไม่อยากขึ้นโรงขึ้นศาลหรอก คุณต้องการซอฟต์แวร์ที่ทำงานได้ต่างหาก
ฉะนั้นแล้ว อะไรคือสิ่งที่จะได้จากการจ่ายค่าโสหุ้ยของการบริหารดังกล่าว?
เพื่อที่จะเข้าใจเรื่องดังกล่าว เราต้องเข้าใจเสียก่อน ว่าผู้บริหารโครงการพัฒนาซอฟต์แวร์คิดว่าเขากำลังทำอะไรอยู่ หญิงสาวคนหนึ่งที่ผมรู้จัก ซึ่งดูจะถนัดเรื่องนี้ บอกว่า การบริหารโครงการซอฟต์แวร์ประกอบด้วยหน้าที่ห้าอย่าง:
<emphasis>กำหนดเป้าหมาย</emphasis> และทำให้ทุกคนเดินหน้าไปในทิศทางเดียวกัน
<emphasis>ตรวจสอบ</emphasis> และทำให้แน่ใจว่าไม่มีการข้ามรายละเอียดที่สำคัญ
<emphasis>กระตุ้น</emphasis> ผู้คนให้ทำงานส่วนที่น่าเบื่อ แต่จำเป็น
<emphasis>แบ่งงาน</emphasis> ให้กับบุคคลต่างๆ เพื่อผลการทำงานที่ดี
<emphasis>จัดสรรทรัพยากร</emphasis> ที่จำเป็นสำหรับการดำเนินโครงการ
เป็นเป้าหมายที่คุ้มค่า ทุกข้อเลย แต่ในรูปแบบโอเพนซอร์ส และในสภาพแวดล้อมทางสังคมที่เกี่ยวข้อง เรื่องต่างๆ ดังกล่าวกลับเริ่มจะไม่มีผลอย่างน่าประหลาด เราจะพิจารณาแต่ละข้อในลำดับย้อนกลับ
เพื่อนของผมรายงานว่า <emphasis>การจัดสรรทรัพยากร</emphasis> โดยทั่วไปเป็นการปกป้อง เมื่อคุณมีคน มีเครื่อง และมีพื้นที่สำนักงานแล้ว คุณต้องปกป้องสิ่งเหล่านั้นจากผู้จัดการโครงการอื่นๆ ที่จะแข่งขันยื้อแย่งทรัพยากรเดียวกัน และจากผู้บริหารระดับบนที่พยายามจะจัดสรรทรัพยากรที่มีจำกัด เพื่อใช้ให้เกิดประโยชน์สูงสุด
แต่นักพัฒนาโอเพนซอร์สล้วนแต่เป็นอาสาสมัคร และได้คัดเลือกตัวเอง ทั้งในเรื่องความสนใจและความสามารถในการร่วมงานกับโครงการที่ตนทำงานอยู่แล้ว (และโดยทั่วไป เรื่องนี้ก็ยังเป็นจริง แม้ในกรณีที่ถูกจ้างด้วยเงินเดือนให้แฮ็กโอเพนซอร์ส) แนวความคิดของตัวอาสาสมัครเองมีแนวโน้มจะดูแลด้าน `รุกล้ำ' ของการจัดสรรทรัพยากรโดยอัตโนมัติอยู่แล้ว ผู้คนจะนำทรัพยากรของตนมาใช้ในงานเอง และผู้จัดการโครงการก็มีความจำเป็นน้อยมาก หรือไม่มีความจำเป็นเลย ที่จะต้อง `เล่นบทปกป้อง' ในความหมายปกติ
อย่างไรก็ดี ในโลกของพีซีราคาถูก และอินเทอร์เน็ตความเร็วสูง เราพบอยู่เนืองๆ ว่าทรัพยากรที่มีจำกัดเพียงอย่างเดียว ก็คือความสนใจของคนที่เชี่ยวชาญ โครงการโอเพนซอร์สเมื่อจะล่มนั้น ไม่ได้ล่มเพราะขาดเครื่องหรือเครือข่ายหรือพื้นที่สำนักงานเลย แต่จะตายเมื่อนักพัฒนาเองขาดความสนใจในโครงการอีกต่อไปเท่านั้น
เมื่อเป็นดังนั้น เรื่องที่สำคัญเป็นสองเท่า ก็คือแฮ็กเกอร์โอเพนซอร์สนั้น <emphasis>แบ่งงานตัวเอง</emphasis> เพื่อผลิตภาพสูงสุดด้วยการพิจารณาตัวเอง อีกทั้งสภาพแวดล้อมทางสังคมก็จะเลือกคนตามความสามารถอย่างไร้ความปรานี เพื่อนผมซึ่งคุ้นเคยกับทั้งโลกโอเพนซอร์สและโครงการปิดขนาดใหญ่ เชื่อว่าที่โอเพนซอร์สประสบความสำเร็จ ส่วนหนึ่งเป็นเพราะวัฒนธรรมของมันยอมรับเฉพาะผู้มีพรสวรรค์ 5% แรกของประชากรโปรแกรมเมอร์เท่านั้น และเธอใช้เวลาเกือบทั้งหมดของเธอ ในการบริหารการใช้งานประชากรอีก 95% ที่เหลือ และเธอจึงได้มีโอกาสสังเกตโดยตรง ถึงความแตกต่างของผลิตภาพถึงร้อยเท่า ระหว่างโปรแกรมเมอร์ที่เก่งสุดๆ กับโปรแกรมเมอร์ที่แค่มีความสามารถธรรมดา
ขนาดของความแตกต่างดังกล่าว ได้ทำให้เกิดคำถามเสมอๆ ว่า โครงการแต่ละโครงการ รวมทั้งภาพรวมของวงการทั้งหมด จะดีขึ้นไหม ถ้าไม่มีคนกว่า 50% ที่ด้อยความสามารถเหล่านั้น? ผู้บริหารโครงการที่ชอบใคร่ครวญ จะเข้าใจมาเป็นเวลานานแล้ว ว่าถ้าหน้าที่เดียวของการบริหารโครงการซอฟต์แวร์แบบเดิม คือการเปลี่ยนคนที่เก่งน้อยที่สุด จากการขาดทุนสุทธิ ให้ไปเป็นกำไรแล้วล่ะก็ จะเป็นเรื่องที่ไม่คุ้มค่าเอาเสียเลย
ความสำเร็จของชุมชนโอเพนซอร์สได้เพิ่มความแหลมคมของคำถามนี้ขึ้นไปอีก โดยให้หลักฐานที่ชัดเจน ว่าการใช้อาสาสมัครจากอินเทอร์เน็ตที่ได้กลั่นกรองตัวเองมาก่อนแล้ว จะเสียค่าใช้จ่ายน้อยกว่า และมีประสิทธิภาพกว่าการบริหารตึกที่เต็มไปด้วยคนที่อาจจะอยากทำอย่างอื่นมากกว่า
ซึ่งนำเรามาสู่คำถามเรื่อง <emphasis>การกระตุ้น</emphasis> อย่างเหมาะเจาะ วิธีที่เทียบเคียงและได้ยินบ่อยๆ ในการบรรยายประเด็นของเพื่อนผม คือว่าการบริหารงานพัฒนาแบบเดิมนั้น เป็นการชดเชยที่จำเป็นสำหรับโปรแกรมเมอร์ที่ขาดแรงจูงใจ ซึ่งจะไม่ทำงานให้ดีถ้าไม่มีการกระตุ้น
คำตอบนี้ มักจะมาพร้อมกับการกล่าวอ้าง ว่าชุมชนโอเพนซอร์สจะพึ่งพาได้ ก็แต่สำหรับงานที่ `เจ๋ง' หรือเย้ายวนทางเทคนิคเท่านั้น ส่วนที่เหลือจะถูกทิ้งร้าง (หรือทำอย่างลวกๆ) ถ้าไม่ถูกปั่นโดยผู้ใช้แรงงานในคอกที่มีเงินกระตุ้น มีผู้บริหารโครงการโบยแส้ให้ทำงาน ผมได้ให้เหตุผลทางจิตวิทยาและสังคมสำหรับการตั้งข้อสงสัยในข้ออ้างนี้ใน <ulink url="http://catb.org/~esr/writings/cathedral-bazaar/homesteading/"><citetitle>Homesteading the Noosphere</citetitle></ulink> แต่อย่างไรก็ดี เพื่อจุดประสงค์ในขณะนี้ ผมคิดว่าการชี้ถึงนัยของการยอมรับว่าเรื่องนี้เป็นเรื่องจริง จะน่าสนใจกว่า
ถ้ารูปแบบการพัฒนาซอฟต์แวร์ในแบบเดิมซึ่งปิดซอร์สและมีการจัดการอย่างเข้มข้น จะมีเหตุผลสนับสนุนเพียงเพราะเรื่องปัญหาที่นำไปสู่ความเบื่อหน่ายแล้วล่ะก็ มันก็จะมีผลอยู่ในแต่ละส่วนของโปรแกรมในระหว่างที่ไม่มีใครเห็นว่าปัญหานั้นน่าสนใจ และไม่มีใครอีกที่จะกล้ำกรายเข้าไปใกล้เท่านั้น เพราะเมื่อมีการแข่งขันของโอเพนซอร์สเกี่ยวกับซอฟต์แวร์ส่วนที่ `น่าเบื่อ' ผู้ใช้ก็จะรู้เอง ว่าปัญหาจะถูกแก้ในที่สุดโดยใครบางคนที่เลือกปัญหานั้นเพราะความน่าสนใจของปัญหาเอง ซึ่งสำหรับซอฟต์แวร์ในฐานะงานสร้างสรรค์แล้ว เป็นสิ่งกระตุ้นที่ได้ผลกว่าเงินเพียงอย่างเดียว
ดังนั้น การมีโครงสร้างการบริหารแบบเดิมเพียงอย่างเดียวเพื่อสร้างแรงกระตุ้น จึงอาจเป็นเทคนิคที่ดี แต่เป็นกลยุทธ์ที่แย่ เพราะอาจจะได้ประโยชน์ในระยะสั้นก็จริง แต่ในระยะยาวแล้ว จะสูญเสียอย่างแน่นอน
เท่าที่ผ่านมา การบริหารงานพัฒนาแบบเดิม ดูจะไม่ใช่ทางเลือกที่ดีเมื่อเทียบกับโอเพนซอร์สในสองประเด็น (การจัดสรรทรัพยากร และการแบ่งงาน) และดูเหมือนจะใช้ได้แค่ชั่วคราวในประเด็นที่สาม (การกระตุ้น) และผู้บริหารโครงการแบบเก่าผู้ถูกคุกคามอย่างน่าสงสาร ก็จะไม่ได้คะแนนช่วยจากประเด็น <emphasis>การตรวจสอบ</emphasis> เลย ข้อโต้แย้งที่แข็งที่สุดที่ชุมชนโอเพนซอร์สมี ก็คือว่าการตรวจทานโดยนักพัฒนาอื่นแบบกระจายกำลัง จะชนะวิธีเดิมๆ ทั้งหมดในการตรวจสอบให้แน่ใจว่าไม่มีรายละเอียดต่างๆ หลุดรอดไป
เราสามารถเก็บประเด็น <emphasis>การกำหนดเป้าหมาย</emphasis> ไว้เป็นเหตุผลสำหรับการยอมเสียค่าโสหุ้ยให้กับการบริหารโครงการซอฟต์แวร์แบบเดิมได้ไหม? ก็อาจจะได้ แต่การจะยอมรับ เราก็ต้องการเหตุผลที่ดีที่จะเชื่อ ว่าคณะกรรมการบริหารและแผนงานของบริษัท จะประสบความสำเร็จในการกำหนดเป้าหมายที่คุ้มค่าและเห็นร่วมกันอย่างกว้างขวาง มากกว่าผู้นำโครงการและสมาชิกอาวุโสซึ่งทำหน้าที่คล้ายกันนี้ในโลกโอเพนซอร์ส
เรื่องนี้ค่อนข้างจะเชื่อได้ยาก ไม่ใช่เพราะข้อมูลสนับสนุนของฝ่ายโอเพนซอร์ส (ความยืนยาวของ Emacs หรือความสามารถของ ไลนัส ทอร์วัลด์ ในการขับเคลื่อนหมู่นักพัฒนาด้วยการพูดเกี่ยวกับ ``การครองโลก'') ที่ทำให้เชื่อได้ยาก แต่เป็นเพราะความน่ากลัวที่ได้แสดงให้เห็นของกลไกแบบเดิม ในการกำหนดเป้าหมายของโครงการซอฟต์แวร์มากกว่า
ทฤษฎีชาวบ้านที่รู้จักกันดีที่สุดทฤษฎีหนึ่งของวิศวกรรมซอฟต์แวร์ ก็คือร้อยละ 60 ถึง 70 ของโครงการซอฟต์แวร์แบบเดิม จะไม่เคยเสร็จ หรือไม่ก็ถูกผู้ใช้กลุ่มเป้าหมายปฏิเสธ ถ้าอัตราส่วนดังกล่าวใกล้เคียงกับความเป็นจริง (ซึ่งผมก็ไม่เคยเห็นผู้บริหารที่มีประสบการณ์คนไหนกล้าเถียง) ก็หมายความว่า มีโครงการส่วนใหญ่ที่กำลังมุ่งสู่เป้าหมายที่ (ก) ไม่สามารถบรรลุได้ในความเป็นจริง หรือ (ข) ผิดพลาด
เรื่องนี้เป็นเหตุผลมากกว่าเรื่องอื่นๆ ที่ทำให้ในโลกวิศวกรรมซอฟต์แวร์ทุกวันนี้ วลี ``คณะบริหาร'' มักจะทำให้ผู้ที่ได้ยินต้องเสียวสันหลังวาบ แม้ว่า (หรือบางที โดยเฉพาะถ้า) ผู้ที่ได้ยินนั้นเป็นผู้บริหารเช่นกัน วันที่เรื่องนี้เป็นที่รู้กันเฉพาะในหมู่โปรแกรมเมอร์ ได้ผ่านไปนานแล้ว การ์ตูนดิลเบิร์ตทุกวันนี้ ไปไม่ค่อยพ้นโต๊ะของ <emphasis>ผู้บริหาร</emphasis> หรอก
ดังนั้น คำตอบของเราสำหรับนักบริหารโครงการพัฒนาซอฟต์แวร์แบบเดิม จึงง่ายดาย กล่าวคือ ถ้าชุมชนโอเพนซอร์สประเมินค่าของการบริหารแบบเดิมต่ำเกินไปแล้วล่ะก็ <emphasis>ทำไมพวกคุณจำนวนมากถึงได้ดูแคลนกระบวนการของคุณเองเล่า?</emphasis>
อีกครั้งที่ตัวอย่างของชุมชนโอเพนซอร์สได้เพิ่มความแหลมคมให้กับคำถามนี้อย่างชัดเจน เพราะเรา <emphasis>สนุก</emphasis> กับสิ่งที่เราทำนั่นเอง งานสร้างสรรค์ของเราประสบผลสำเร็จทั้งทางเทคนิค ส่วนแบ่งตลาด และความยอมรับ ในอัตราที่น่าอัศจรรย์ เราได้พิสูจน์แล้ว ไม่เพียงแค่ว่าเราสามารถพัฒนาซอฟต์แวร์ที่ดีกว่าได้ แต่ยังพิสูจน์ด้วยว่า <emphasis>ความรื่นเริงคือทรัพย์สิน</emphasis>
สองปีครึ่งหลังจากเขียนบทความนี้รุ่นแรก แนวคิดระดับรากฐานที่สุดที่ผมสามารถให้ได้เพื่อสรุปเรื่องทั้งหมด ไม่ใช่วิสัยทัศน์ของโลกซอฟต์แวร์ที่โอเพนซอร์สเป็นใหญ่ ซึ่งดูเป็นไปได้สำหรับคนปกติทั่วไปในทุกวันนี้
แต่ผมต้องการชี้แนะในสิ่งที่อาจเป็นบทเรียนที่กว้างขึ้นเกี่ยวกับซอฟต์แวร์ (และอาจจะเกี่ยวกับงานสร้างสรรค์และงานวิชาชีพทุกชนิด) มนุษย์มักจะมีความยินดีกับงานเมื่อมันมีความท้าทายที่เหมาะสม ไม่ง่ายจนน่าเบื่อ และไม่ยากจนไม่สามารถบรรลุได้ โปรแกรมเมอร์ที่มีความสุข ก็คือคนที่ไม่ถูกใช้งานต่ำเกินไป หรือต้องแบกรับเป้าหมายที่กำหนดไว้ชุ่ยๆ โดยมีแรงเสียดทานต่อการทำงานอย่างเคร่งเครียด <emphasis>ความรื่นเริงจะให้ประสิทธิภาพ</emphasis>
ถ้าคุณรู้สึกถึงความเกลียดและความกลัวเมื่อนึกถึงกระบวนการทำงานของคุณ (แม้จะในแบบประชดประชันตามแบบการ์ตูนดิลเบิร์ตก็ตาม) ก็ควรถือว่านั่นเป็นเครื่องหมายบ่งชี้ว่ากระบวนการได้ล้มเหลวเสียแล้ว ความรื่นเริง อารมณ์ขัน และความขี้เล่น เป็นทรัพย์สินอย่างแท้จริง มันไม่ใช่การทำให้ดูเพราะพริ้งเมื่อผมเขียนถึง "หมู่โปรแกรมเมอร์ผู้มีความสุข" และก็ไม่ใช่เรื่องขบขันเลยที่สัตว์นำโชคของลินุกซ์เป็นนกเพนกวินแรกรุ่นอ้วนจ้ำม่ำ
กลายเป็นว่า ผลที่สำคัญที่สุดอย่างหนึ่งของความสำเร็จของโอเพนซอร์ส ก็คือการสอนเรา ว่าการเล่นเป็นวิธีที่มีประสิทธิภาพทางเศรษฐกิจที่สุดสำหรับงานสร้างสรรค์
ส่งท้าย: เน็ตสเคปอ้าแขนรับตลาดสด
เป็นความรู้สึกที่แปลกที่ได้รู้ว่า คุณกำลังร่วมสร้างประวัติศาสตร์...
วันที่ 22 มกราคม 1998 ประมาณเจ็ดเดือนหลังจากที่ผมเผยแพร่บทความ <citetitle>มหาวิหารกับตลาดสด</citetitle> บริษัท เน็ตสเคป คอมมิวนิเคชัน ได้ประกาศแผนที่จะ <ulink url="http://www.netscape.com/newsref/pr/newsrelease558.html">แจกซอร์สของ Netscape Communicator</ulink> ผมไม่เคยคาดคิดมาก่อนเลย ว่าสิ่งนี้จะเกิดขึ้น จนถึงวันประกาศ
Eric Hahn รองประธานบริหารและหัวหน้าฝ่ายเทคโนโลยีของเน็ตสเคป ได้ส่งอีเมลสั้นๆ ถึงผมในภายหลัง บอกว่า: ``ในนามของทุกๆ คนที่เน็ตสเคป ผมอยากจะขอบคุณที่คุณได้ช่วยเราตั้งแต่ต้นให้มาถึงจุดนี้ ความคิดและข้อเขียนของคุณคือแรงบันดาลใจโดยพื้นฐานของการตัดสินใจของเรา''
ในสัปดาห์ต่อมา ผมบินไปที่ซิลิคอนแวลลีย์ตามคำเชิญของเน็ตสเคป เพื่อเข้าร่วมงานประชุมระยะเวลาหนึ่งวัน (ในวันที่ 4 ก.พ. 1998) กับผู้บริหารระดับสูงและผู้เชี่ยวชาญทางเทคนิคของบริษัท เราร่วมกันวางกลยุทธ์การปล่อยซอร์ส และสัญญาอนุญาตของเน็ตสเคป
สองสามวันถัดมา ผมเขียนว่า:
เน็ตสเคปกำลังจะจัดเตรียมการทดสอบจริงขนาดใหญ่ สำหรับรูปแบบตลาดสดในโลกธุรกิจ ขณะนี้ โลกโอเพนซอร์สกำลังเผชิญกับอันตราย ถ้าการดำเนินการของเน็ตสเคปไม่เป็นผล แนวคิดโอเพนซอร์สอาจจะถูกลดความน่าเชื่อถือลง ถึงขนาดที่จะไม่ได้รับความสนใจจากโลกธุรกิจอีกเลยเป็นสิบปี
ในทางกลับกัน นี่ก็ถือเป็นโอกาสอันงดงามเช่นกัน ปฏิกิริยาเบื้องต้นต่อความเคลื่อนไหวครั้งนี้ในวอลล์สตรีทและที่อื่นๆ กำลังเป็นบวกอย่างระมัดระวัง เรากำลังได้รับโอกาสพิสูจน์ตัวเองด้วย ถ้าเน็ตสเคปสามารถรุกส่วนแบ่งตลาดกลับมาได้จากความเคลื่อนไหวครั้งนี้ ก็อาจเป็นการเริ่มต้นปฏิวัติวงการอุตสาหกรรมซอฟต์แวร์ ซึ่งควรจะเกิดมาตั้งนานแล้ว
ปีหน้านี้ น่าจะเป็นช่วงเวลาที่น่าศึกษาและน่าสนใจอย่างยิ่ง
และมันก็เป็นเช่นนั้นจริงๆ ขณะที่ผมเขียนเรื่องนี้ในกลางปี 2000 การพัฒนาของสิ่งที่ได้รับการขนานนามต่อมาว่า โมซิลล่า ได้กลายเป็นความสำเร็จระดับคุณภาพ โดยสามารถบรรลุเป้าหมายเริ่มแรกของเน็ตสเคป คือการปฏิเสธการผูกขาดถาวรของไมโครซอฟท์ในตลาดเบราว์เซอร์ และยังประสบความสำเร็จอย่างถล่มทลายอีกด้วย (โดยเฉพาะการออกเครื่องจักรซอฟต์แวร์สำหรับวาดหน้าเว็บรุ่นใหม่ที่ชื่อ เก็คโค)
อย่างไรก็ดี มันก็ยังไม่ได้รับแรงพัฒนาอย่างใหญ่หลวงจากภายนอกเน็ตสเคป อย่างที่ผู้ก่อตั้งโมซิลล่าคาดหวังไว้แต่ต้น ปัญหาของที่นี่ ดูจะเป็นเพราะการแจกจ่ายโมซิลล่าได้แหกกฎพื้นฐานของรูปแบบตลาดสดเป็นเวลานาน กล่าวคือ ไม่ได้ให้สิ่งที่ผู้ที่อาจร่วมสมทบสามารถเรียกใช้เพื่อดูการทำงานได้ (ตลอดเวลากว่าหนึ่งปีตั้งแต่ออก การคอมไพล์โมซิลล่าจากซอร์สจำเป็นต้องอาศัยสิทธิ์อนุญาตใช้งานสำหรับไลบรารีโมทีฟ ซึ่งเป็นซอฟต์แวร์สงวนสิทธิ์)
ที่เป็นลบมากที่สุด (จากมุมมองของโลกภายนอก) คือกลุ่มโมซิลล่าไม่ได้ให้เบราว์เซอร์ระดับคุณภาพเป็นเวลาถึงสองปีครึ่งหลังจากตั้งโครงการ และในปี 1999 แกนนำคนสำคัญของโครงการก็ได้สร้างความรู้สึกที่ไม่ดี ด้วยการลาออก และบ่นถึงการบริหารที่แย่ และการเสียโอกาสต่างๆ ``โอเพนซอร์ส'' เขาตั้งข้อสังเกตอย่างถูกต้อง ``ไม่ใช่เวทมนตร์วิเศษ''
และมันก็ไม่ใช่จริงๆ อาการต่างๆ ในระยะยาวของโมซิลล่าดูจะดีขึ้นอย่างมากในขณะนี้ (ในเดือนพฤศจิกายน 2000) เทียบกับขณะที่ เจมี่ ซาวินสกี้ เขียนจดหมายลาออก ในช่วงอาทิตย์หลังๆ รุ่นปล่อยประจำวันได้ผ่านระดับคุณภาพที่สำคัญไปสู่การใช้งานจริงเป็นที่เรียบร้อย แต่เจมี่ก็กล่าวได้ถูกต้อง ที่ชี้ให้เห็นว่า การเปิดซอร์สไม่จำเป็นต้องช่วยชีวิตโครงการเดิมที่กำหนดเป้าหมายไว้แย่ๆ หรือมีโค้ดที่ยุ่งเหยิง หรือมีอาการป่วยเรื้อรังอื่นๆ ทางวิศวกรรมซอฟต์แวร์ได้เสมอไป โมซิลล่าได้แสดงตัวอย่าง ทั้งการประสบความสำเร็จและการล้มเหลวของโอเพนซอร์สในเวลาเดียวกัน
อย่างไรก็ดี ในช่วงเวลาเดียวกันนี้ แนวคิดโอเพนซอร์สก็ได้ประสบความสำเร็จ และมีผู้สนับสนุนในที่อื่นๆ ตั้งแต่การออกซอฟต์แวร์ของเน็ตสเคป เราก็ได้เห็นการบูมอย่างมโหฬารของความสนใจในรูปแบบการพัฒนาแบบโอเพนซอร์ส ซึ่งเป็นแนวโน้มที่ทั้งรับและให้แรงขับเคลื่อนต่อความสำเร็จของระบบปฏิบัติการลินุกซ์ในเวลาเดียวกัน แนวโน้มที่โมซิลล่าได้จุดประกายขึ้น ได้ดำเนินต่อไปในอัตราที่สูงขึ้นเรื่อยๆ
เชิงอรรถ
<citetitle><anchor id="JB"/>[JB]</citetitle> ในหนังสือ <citetitle>Programing Pearls (อัญมณีแห่งการเขียนโปรแกรม)</citetitle> จอน เบนทลีย์ นักตั้งคติพจน์ทางวิทยาการคอมพิวเตอร์ ได้ให้ความเห็นต่อข้อสังเกตของบรูกส์ไว้ว่า ``ถ้าคุณเตรียมพร้อมที่จะทิ้งสิ่งหนึ่ง คุณจะได้ทิ้งไปสองสิ่ง'' เขากล่าวได้ถูกต้องค่อนข้างแน่นอนทีเดียว ประเด็นของข้อสังเกตของบรูกส์และเบนทลีย์ ไม่ใช่เพียงแค่ว่าคุณควรคาดได้ว่าความพยายามครั้งแรกจะผิดเท่านั้น แต่ยังย้ำว่า การตั้งต้นใหม่ด้วยแนวคิดที่ถูกต้อง มักจะเกิดผลมากกว่าการพยายามกู้ซากที่เละเทะ
<emphasis><anchor id="QR"/>[QR]</emphasis> มีตัวอย่างของการพัฒนาแบบโอเพนซอร์สในตลาดสด ที่ประสบความสำเร็จในยุคก่อนอินเทอร์เน็ตบูม และไม่เกี่ยวกับธรรมเนียมของยูนิกซ์และอินเทอร์เน็ตด้วย การพัฒนาของโปรแกรมบีบอัดซึ่งมุ่งใช้สำหรับดอส ชื่อ <ulink url="http://www.cdrom.com/www/infozip/">info-Zip</ulink> ระหว่างปี 1990–1992 คือตัวอย่างหนึ่งดังกล่าว อีกตัวอย่างหนึ่งคือระบบกระดานข่าว RBBS (สำหรับดอสอีกเหมือนกัน) ซึ่งเริ่มต้นในปี 1983 และได้สร้างชุมชนที่แข็งแกร่งพอที่จะมีการออกรุ่นสม่ำเสมอมาจนถึงปัจจุบัน (กลางปี 1999) ถึงแม้เมลและการใช้แฟ้มร่วมกันในอินเทอร์เน็ตจะมีข้อได้เปรียบทางเทคนิคอย่างมากเหนือ BBS แล้วก็ตาม ในขณะที่ชุมชนของ info-Zip อาศัยเมลในอินเทอร์เน็ตในระดับหนึ่ง แต่วัฒนธรรมของนักพัฒนา RBBS สามารถจะใช้ชุมชนออนไลน์ผ่าน RBBS ซึ่งไม่ขึ้นกับโครงสร้างพื้นฐาน TCP/IP เลยได้
<emphasis><anchor id="CV"/>[CV]</emphasis> แนวคิดที่ว่า ความโปร่งใสและการตรวจทานโดยนักพัฒนาอื่น มีประโยชน์ต่อการจัดการความซับซ้อนของการพัฒนาระบบปฏิบัติการ ปรากฏว่าไม่ใช่เรื่องใหม่แต่อย่างใด ในปี 1965 ซึ่งเป็นช่วงแรกๆ ของประวัติศาสตร์ของระบบปฏิบัติการแบบแบ่งเวลาทำงาน (time-sharing) นั้น Corbató และ Vyssotsky ซึ่งเป็นผู้ร่วมออกแบบระบบปฏิบัติการมัลทิกซ์ (Multics) ได้ <ulink url="http://www.multicians.org/fjcc1.html">เขียน</ulink> ไว้ว่า
เราคาดหวังว่าจะเปิดเผยระบบมัลทิกซ์ เมื่อมันทำงานได้อย่างมีเสถียรภาพ.. การเปิดเผยดังกล่าวเป็นสิ่งที่ดี ด้วยเหตุผลสองประการ: ข้อแรก ระบบจะถูกสังเกตและวิจารณ์ในสาธารณะ จากการอาสาสมัครของผู้อ่านที่สนใจ ข้อสอง ในยุคที่ความซับซ้อนเพิ่มมากขึ้น ก็เป็นความจำเป็นสำหรับนักออกแบบระบบในปัจจุบันและในอนาคต ที่จะทำให้ระบบปฏิบัติการภายในชัดเจนที่สุดเท่าที่จะเป็นไปได้ เพื่อจะได้เห็นประเด็นต่างๆ ของระบบพื้นฐาน
<emphasis><anchor id="JH"/>[JH]</emphasis> จอห์น แฮสเลอร์ ได้เสนอแนะคำอธิบายที่น่าสนใจสำหรับข้อเท็จจริงที่ว่า การซ้ำซ้อนของแรงงานดูจะไม่กลายเป็นการหน่วงงานพัฒนาโอเพนซอร์ส เขาได้เสนอสิ่งที่ผมจะตั้งชื่อให้ว่า ``กฎของแฮสเลอร์'' ซึ่งกล่าวว่า ค่าโสหุ้ยของงานที่ซ้ำซ้อน มีแนวโน้มจะโตตามขนาดของทีมงานในอัตราที่ต่ำกว่ากำลังสอง กล่าวคือ ช้ากว่าค่าโสหุ้ยในการวางแผนและบริหารที่จำเป็นสำหรับการกำจัดความซ้ำซ้อนดังกล่าว
คำอ้างนี้ไม่ได้ขัดกับกฎของบรูกส์ อาจจะจริงที่ว่า ค่าโสหุ้ยของความซับซ้อนทั้งหมด และความเสี่ยงต่อบั๊ก จะโตในอัตรากำลังสองตามขนาดของทีม แต่ค่าโสหุ้ยจาก <emphasis>งานที่ซ้ำซ้อน</emphasis> จะเป็นกรณีพิเศษที่โตช้ากว่านั้น ไม่ยากเลยที่จะให้เหตุผลกับเรื่องนี้ เริ่มจากข้อเท็จจริงที่ไร้ข้อกังขาที่ว่า เป็นการง่ายกว่าที่จะเห็นพ้องในขอบเขตหน้าที่ระหว่างโค้ดของนักพัฒนาต่างๆ ซึ่งจะช่วยป้องกันการซ้ำซ้อนของงาน ถ้าเทียบกับการป้องกันผลที่เกี่ยวเนื่องถึงกันอย่างไม่ตั้งใจในส่วนต่างๆ ของระบบ ซึ่งทำให้เกิดบั๊กต่างๆ
เมื่อใช้กฎของไลนัสและกฎของแฮสเลอร์ร่วมกัน ก็จะได้ว่า มีขนาดวิกฤติสามขนาดในโครงการซอฟต์แวร์ต่างๆ กล่าวคือ ในโครงการเล็กๆ (ที่มีนักพัฒนาหนึ่งถึงสามคน) ก็ไม่จำเป็นต้องมีโครงสร้างการบริหารอะไรมากไปกว่าการเลือกนักพัฒนาหลัก และมีช่วงของโครงการขนาดกลางที่โตกว่านั้น ซึ่งค่าโสหุ้ยในการบริหารตามปกติจะต่ำ ทำให้ข้อดีของการเลี่ยงความซ้ำซ้อนของแรงงาน การติดตามบั๊ก และการตรวจสอบการหลุดรอดของรายละเอียด สามารถเอาชนะค่าโสหุ้ยได้
แต่ในขนาดที่ใหญ่กว่านั้น การใช้กฎของไลนัสและกฎของแฮสเลอร์ร่วมกัน จะให้ผลว่า มีช่วงของโครงการขนาดใหญ่ ที่ค่าโสหุ้ยและปัญหาของการบริหารแบบเดิม จะโตเร็วกว่าค่าโสหุ้ยประมาณการของงานที่ซ้ำซ้อน โดยที่ค่าโสหุ้ยเหล่านี้ ยังไม่รวมความไร้ประสิทธิภาพในการใช้ผลของสายตาที่เฝ้ามองจำนวนมาก ซึ่งอย่างที่เราเห็น ว่าสามารถทำงานได้ดีกว่าการบริหารแบบเดิมมากในการตรวจสอบบั๊กและรายละเอียดต่างๆ ดังนั้น ในกรณีของโครงการขนาดใหญ่ ผลของกฎเหล่านี้เมื่อประกอบกัน จึงทำให้ลดข้อดีของการบริหารแบบเดิมลงจนเหลือศูนย์
<emphasis><anchor id="HBS"/>[HBS]</emphasis> การแยกรุ่นของลินุกซ์ ระหว่างรุ่นทดสอบและรุ่นเสถียร ยังทำหน้าที่อีกอย่างที่เกี่ยวข้องกับการกีดกันความเสี่ยง (แต่ไม่ใช่) การแยกรุ่นจะจัดการกับปัญหาอีกข้อหนึ่ง คือการไม่มีเส้นตายของเส้นตาย เมื่อโปรแกรมเมอร์ต้องอยู่กับทั้งรายการคุณสมบัติโปรแกรมที่ไม่เปลี่ยนแปลง และกำหนดการที่ตายตัว คุณภาพก็จะตก และอาจเกิดความยุ่งเหยิงอย่างใหญ่หลวงได้ ถ้าจะทำให้ได้ทั้งสองอย่าง ผมเป็นหนี้ต่อ มาร์โค เอียนซิติ และ อลัน แม็คคอร์แม็ค จากโรงเรียนธุรกิจฮาร์วาร์ด ที่ได้แสดงหลักฐานให้ผมเห็นว่า การผ่อนผันข้อกำหนดอย่างใดอย่างหนึ่ง จะทำให้กำหนดการสามารถบรรลุได้
ทางหนึ่งที่ทำได้ คือกำหนดเส้นตายตายตัว แต่ให้รายการคุณสมบัติโปรแกรมยืดหยุ่นได้ โดยยอมทิ้งคุณสมบัติบางอย่างได้ ถ้ายังทำไม่เสร็จตามกำหนด นี่คือนโยบายหลักของแขนงเคอร์เนลที่ "เสถียร" อลัน ค็อกซ์ (ผู้ดูแลเคอร์เนลรุ่นเสถียร) ออกรุ่นเคอร์เนลเป็นระยะค่อนข้างสม่ำเสมอ แต่ไม่รับประกันว่าบั๊กไหนจะแก้เมื่อไร หรือความสามารถไหนจะถูกถ่ายกลับมาจากแขนงทดสอบ
หรืออีกทางหนึ่ง ก็คือกำหนดรายการคุณสมบัติที่ต้องการ แล้วออกเมื่อทำเสร็จเท่านั้น นี่คือนโยบายหลักของแขนง "ทดสอบ" ของเคอร์เนล เดอ มาร์โค และ ลิสเตอร์ ได้อ้างถึงงานวิจัยที่แสดงให้เห็นว่า นโยบายกำหนดการแบบนี้ ("ทำเสร็จแล้วปลุกด้วย") จะไม่ใช่แค่ให้คุณภาพสูงสุด แต่โดยเฉลี่ยแล้ว ยังทำให้ออกได้เร็วกว่ากำหนดการที่ "ตามความเป็นจริง" หรือ "เคร่งครัด" เสียอีก
ผมได้กลับมาสงสัย (ในช่วงต้นปี 2000) ว่าในบทความนี้รุ่นก่อนๆ ผมได้ประเมินความสำคัญของนโยบายต่อต้านเส้นตายที่ว่า "ทำเสร็จแล้วปลุกด้วย" ต่อผลิตภาพและคุณภาพของชุมชนโอเพนซอร์สต่ำเกินไปอย่างร้ายแรง ประสบการณ์ทั่วๆ ไปของการออก GNOME 1.0 อย่างรีบเร่งในปี 1999 ทำให้เราเห็นว่า ความกดดันในการออกรุ่นก่อนที่จะพร้อม สามารถสลายข้อดีด้านคุณภาพหลายข้อที่โอเพนซอร์สเคยให้ตามปกติได้
อาจจะกลายเป็นว่า ความโปร่งใสของกระบวนการ เป็นหนึ่งในแรงขับดันสามเรื่องที่สำคัญพอๆ กันต่อคุณภาพของโอเพนซอร์ส อีกสองเรื่องก็คือกำหนดการแบบ "ทำเสร็จแล้วปลุกด้วย" และการกลั่นกรองตัวเองของนักพัฒนา
<emphasis><anchor id="SU"/>[SU]</emphasis> ไม่แปลก และก็ไม่ผิดไปเสียทั้งหมด ถ้าจะมองลักษณะการจัดโครงสร้างที่ประกอบด้วยนักพัฒนาแกนและที่รายล้อม ว่าเป็นการใช้ข้อแนะนำของบรูกส์สำหรับแก้ปัญหาอัตราการเติบโตที่เป็นกำลังสอง ที่เรียกว่าโครงสร้าง "ทีมผ่าตัด" ในรูปแบบที่ผ่านอินเทอร์เน็ต แต่ก็มีความแตกต่างอย่างมาก กลุ่มของบทบาทผู้เชี่ยวชาญ เช่น "บรรณารักษ์โค้ด" ที่บรูกส์วาดภาพไว้รอบๆ หัวหน้าทีม ไม่ได้มีอยู่จริง แต่บทบาทเหล่านั้น กลับถูกดำเนินการโดยผู้ทำงานทั่วไป ที่มีเครื่องมือช่วยที่ค่อนข้างมีประสิทธิภาพกว่าในยุคของบรูกส์ นอกจากนี้ วัฒนธรรมโอเพนซอร์สยังอาศัยธรรมเนียมยูนิกซ์ที่เข้มแข็งเกี่ยวกับความเป็นสัดส่วน, API และการซ่อนรายละเอียด ซึ่งไม่มีข้อไหนอยู่ในองค์ประกอบที่บรูกส์กำหนดเลย
<emphasis><anchor id="RJ"/>[RJ]</emphasis> ผู้แสดงความเห็นที่ได้ชี้ให้ผมเห็นเกี่ยวกับผลของความยาวที่ต่างกันมากๆ ของเส้นทางการแกะรอย ที่มีต่อความยากในการบ่งชี้บั๊ก ได้สันนิษฐานว่า ความยากของเส้นทางการแกะรอยอาการอันหลากหลายของบั๊กเดียวกัน จะแปรปรวนในแบบเอ็กซ์โพเนนเชียล (ซึ่งผมเดาว่าหมายถึงการกระจายแบบเกาส์หรือปัวซอง และเห็นด้วยว่าดูน่าจะเป็นไปได้) ถ้าเป็นไปได้ที่จะทดลองเพื่อหารูปร่างของการกระจายดังกล่าว ก็จะเป็นข้อมูลที่มีความหมายอย่างยิ่ง การที่ความยากในการแกะรอยมีการกระจายที่หนีห่างมากๆ จากแบบแบนราบซึ่งความน่าจะเป็นเท่าๆ กัน ก็จะหมายความว่า แม้นักพัฒนาที่ลุยเดี่ยว ก็ควรจำลองกลยุทธ์แบบตลาดสด โดยจำกัดเวลาที่ใช้ในการแกะรอยอาการหนึ่งๆ ก่อนที่จะเปลี่ยนไปดูอาการอื่น ความมุ่งมั่นอาจไม่ได้เป็นผลดีเสมอไป...
<emphasis><anchor id="IN"/>[IN]</emphasis> ประเด็นที่เกี่ยวข้องกับเรื่องที่นักพัฒนาจะสามารถตั้งต้นโครงการจากศูนย์ในแบบตลาดสดได้หรือไม่ ก็คือประเด็นว่า รูปแบบตลาดสดสามารถสนับสนุนงานที่เป็นนวัตกรรมอย่างแท้จริงได้หรือไม่ บางคนอ้างว่า หากปราศจากความเป็นผู้นำที่เข้มแข็งแล้ว ตลาดสดก็สามารถทำได้เพียงจัดการการลอกเลียนและปรับปรุงแนวคิดเดิมที่มีอยู่ที่อยู่ในขั้นประดิษฐ์คิดค้นเท่านั้น คำโต้แย้งที่เป็นที่รู้จักกันมากที่สุด คงเป็น <ulink url="http://www.opensource.org/halloween/">เอกสารวันฮัลโลวีน</ulink> ซึ่งเป็นบันทึกข้อความสองชิ้นที่น่ากระอักกระอ่วนของไมโครซอฟท์ ที่เขียนเกี่ยวกับปรากฏการณ์โอเพนซอร์ส ผู้เขียนเอกสารได้เปรียบเทียบการพัฒนาระบบปฏิบัติการที่คล้ายยูนิกซ์ของลินุกซ์กับการ ``ไล่กวดไฟท้าย'' และแสดงความเห็นว่า ``(เมื่อโครงการได้ประสบความสำเร็จ "เทียบเคียง" กับแนวคิดใหม่ล่าสุดแล้ว) ระดับของการบริหารที่ต้องใช้ในการผลักดันไปสู่แนวรุกใหม่จะมากมายมหาศาล''
มีข้อผิดพลาดร้ายแรงหลายอย่างเกี่ยวกับข้อเท็จจริงที่ข้อโต้แย้งนี้พยายามจะบอก ข้อแรกถูกเปิดเผยเมื่อผู้เขียนเอกสารฮัลโลวีนเองได้ตั้งข้อสังเกตในภายหลังว่า ``บ่อยครั้ง [...] ที่แนวคิดงานวิจัยใหม่ๆ ถูกทำให้เป็นจริง และมีให้ใช้ในลินุกซ์ก่อนที่จะมีหรือถูกรวมเข้าในแพล็ตฟอร์มอื่น''
ถ้าเราแทน ``ลินุกซ์'' ด้วย ``โอเพนซอร์ส'' เราจะเห็นว่าเรื่องนี้ไม่ใช่เรื่องใหม่อะไรเลย ตามประวัติแล้ว ชุมชนโอเพนซอร์สไม่ได้ประดิษฐ์ Emacs หรือ World Wide Web หรือตัวอินเทอร์เน็ตเองด้วยการไล่กวดไฟท้าย หรือต้องมีการบริหารอย่างมากมายมหาศาลเลย และในปัจจุบัน ก็มีงานนวัตกรรมมากมายที่ยังดำเนินต่อไปในโลกโอเพนซอร์ส จนถึงกับทำให้ผู้ใช้เคยตัวกับการมีทางเลือก โครงการ GNOME (เพื่อเป็นตัวอย่างของอีกหลายโครงการ) ก็ยังคงผลักดัน GUI ใหม่ล่าสุดและเทคโนโลยีออบเจ็กต์อย่างหนัก มากพอที่จะดึงดูดความสนใจจากสื่อมวลชนสาขาคอมพิวเตอร์ที่อยู่นอกชุมชนลินุกซ์ และยังมีตัวอย่างอื่นอีกเป็นกองทัพ ซึ่งการเข้าไปดู <ulink url="http://freshmeat.net/">Freshmeat</ulink> สักวันหนึ่ง ก็สามารถพิสูจน์ได้อย่างรวดเร็ว
แต่มีข้อผิดพลาดที่พื้นฐานกว่านั้นอีกเรื่องหนึ่ง คือการทึกทักกลายๆ ว่า <emphasis>รูปแบบมหาวิหาร</emphasis> (หรือรูปแบบตลาดสด หรือรูปแบบการบริหารชนิดอื่นใด) สามารถสร้างนวัตกรรมได้อย่างแน่นอน นี่เป็นเรื่องไร้สาระ กลุ่มคนใดๆ ไม่สามารถมีแนวคิดที่พลิกโฉมได้ แม้กลุ่มอาสาสมัครอนาธิปัตย์ในตลาดสด ก็มักไม่สามารถคิดค้นอะไรใหม่ได้อย่างแท้จริง ไม่ต้องพูดถึงกลุ่มคณะกรรมการในบริษัท ที่มีความเสี่ยงต่อการอยู่รอดโดยมีสถานะของบริษัทเป็นเดิมพันเลย แต่ <emphasis>แนวคิดมาจากปัจเจกบุคคล</emphasis> ต่างหาก สิ่งที่ดีที่สุดที่กลไกทางสังคมที่แวดล้อมเขาสามารถคาดหวังว่าจะทำได้ ก็คือการ <emphasis>ตอบสนอง</emphasis> ต่อแนวคิดที่พลิกโฉมต่างๆ โดยหล่อเลี้ยงและตอบแทนและทดสอบแนวคิดอย่างจริงจัง แทนที่จะขยี้ทิ้งเสีย
บางคนอาจจะมองว่านี่เป็นมุมมองเพ้อฝัน ที่ย้อนกลับไปสู่เรื่องของบุคคลตัวอย่างที่เป็นผู้ประดิษฐ์โดยลำพังในแบบเก่า ไม่ใช่อย่างนั้น ผมไม่ได้อ้างว่ากลุ่มคนจะไม่สามารถ <emphasis>พัฒนา</emphasis> แนวคิดพลิกโฉมได้หลังจากที่ได้เกิดแนวคิดขึ้นแล้ว อันที่จริง เราได้เรียนรู้จากกระบวนการตรวจทานโดยนักพัฒนาอื่นมาแล้ว ว่ากลุ่มพัฒนาลักษณะนั้นมีความสำคัญต่อการสร้างผลลัพธ์คุณภาพสูง แต่ผมกำลังชี้ให้เห็นว่า การพัฒนาในแต่ละกลุ่มดังกล่าว จะเริ่มจาก (และต้องถูกจุดประกายโดย) แนวคิดที่ดีในหัวของคนคนหนึ่ง มหาวิหารและตลาดสดและโครงสร้างทางสังคมแบบอื่นสามารถจับประกายนั้น แล้วปรับปรุงต่อได้ แต่จะไม่สามารถสร้างขึ้นเองได้ตามต้องการ
ดังนั้น ต้นตอของปัญหาของนวัตกรรม (ในซอฟต์แวร์ หรือในสาขาอื่นๆ) โดยเนื้อแท้ จึงอยู่ที่การทำอย่างไรไม่ให้นวัตกรรมต้องถูกทิ้งไป แต่ที่อาจจะพื้นฐานกว่านั้น คือ <emphasis>ทำอย่างไรจึงจะสร้างกลุ่มคนที่สามารถมีแนวคิดดีๆ ได้ตั้งแต่ต้น</emphasis>
การทึกทักว่าการพัฒนาในแบบมหาวิหารจะสามารถจัดการเคล็ดลับนี้ได้ แต่แนวกั้นต่อการเข้าร่วมที่ต่ำ และความคล่องตัวของกระบวนการของตลาดสดจะทำไม่ได้ จึงเป็นเรื่องน่าขัน ถ้าสิ่งที่ต้องการมีแค่คนคนเดียวที่มีความคิดที่ดีแล้วล่ะก็ สภาพแวดล้อมทางสังคมที่คนคนหนึ่งสามารถดึงดูดความร่วมมือของคนอื่นเป็นร้อยเป็นพันที่มีแนวคิดที่ดี ก็เลี่ยงไม่ได้ที่จะสร้างนวัตกรรมแซงหน้ารูปแบบใดๆ ที่บุคคลต้องพยายามเสนอขายทางการเมืองให้กับผู้บริหารในทำเนียบ ก่อนที่จะสามารถทำตามแนวคิดได้ โดยไม่เสี่ยงต่อการถูกไล่ออกจากงาน
และอันที่จริงแล้ว ถ้าเราดูประวัติของนวัตกรรมซอฟต์แวร์ที่เกิดจากองค์กรที่ใช้รูปแบบมหาวิหารแล้ว เราจะเห็นได้อย่างรวดเร็วว่าเกิดขึ้นน้อยมาก บริษัทใหญ่ๆ จะอาศัยแนวคิดใหม่ๆ จากงานวิจัยของมหาวิทยาลัย (ทำให้ผู้เขียนเอกสารวันฮัลโลวีนไม่สบายใจนัก เกี่ยวกับเครื่องไม้เครื่องมือของลินุกซ์ ที่เลือกหยิบใช้งานวิจัยเหล่านั้นได้รวดเร็วกว่า) หรือมิฉะนั้น ก็ซื้อกิจการบริษัทเล็กๆ ที่สร้างขึ้นจากมันสมองของผู้สร้างนวัตกรรมบางคน ไม่มีกรณีใดที่นวัตกรรมจะเกิดจากวัฒนธรรมมหาวิหารโดยแท้จริงเลย อันที่จริง นวัตกรรมหลายชิ้นที่นำเข้ามาด้วยวิธีดังกล่าว กลับต้องขาดใจตายอย่างเงียบเชียบ ภายใต้ "ระดับการบริหารที่มากมายมหาศาล" ที่ผู้เขียนเอกสารวันฮัลโลวีนสรรเสริญยิ่งนัก
อย่างไรก็ดี นั่นเป็นประเด็นเชิงลบ ผู้อ่านควรได้รับประเด็นเชิงบวกบ้าง ผมขอแนะนำให้ทดลองดังนี้:
เลือกเกณฑ์สำหรับวัดจำนวนการคิดค้นที่คุณเชื่อว่าสามารถใช้ได้อย่างสม่ำเสมอ ถ้านิยามของคุณคือ ``ฉันรู้เมื่อได้เห็นก็แล้วกัน'' นั่นก็ไม่ใช่ปัญหาสำหรับการทดลองนี้
เลือกระบบปฏิบัติการซอร์สปิดตัวไหนก็ได้ที่แข่งกับลินุกซ์ พร้อมทั้งแหล่งสำหรับตรวจสอบงานพัฒนาปัจจุบัน
เฝ้าดูแหล่งดังกล่าวและ Freshmeat ทุกวันเป็นเวลาหนึ่งเดือน นับจำนวนการประกาศออกรุ่นที่ Freshmeat ที่คุณถือว่าเป็นงาน `คิดค้น' และใช้เกณฑ์เดียวกันของงาน `คิดค้น' นี้กับการประกาศของระบบปฏิบัติการอีกตัวนั้น แล้วนับดู
สามสิบวันให้หลัง รวมคะแนนทั้งสองฝ่าย
ในวันที่ผมเขียนตรงนี้ Freshmeat มีประกาศออกรุ่นยี่สิบสองรายการ ซึ่งมีสามรายการที่อาจเป็นสิ่งใหม่ล่าสุดในระดับหนึ่ง นี่ยังถือเป็นวันที่เชื่องช้าสำหรับ Freshmeat แต่ผมจะตกใจมากถ้ามีผู้อ่านท่านใดรายงานว่า มีสิ่งที่อาจเป็นนวัตกรรมถึงสามรายการ <emphasis>ต่อเดือน</emphasis> ในแหล่งซอร์สปิดแหล่งไหน
<emphasis><anchor id="EGCS"/>[EGCS]</emphasis> ขณะนี้ เรามีประวัติศาสตร์ของโครงการที่อาจเป็นการทดสอบที่ชี้วัดศักยภาพของรูปแบบตลาดสดได้ดีกว่า fetchmail ในหลายๆ ทาง คือ <ulink url="http://egcs.cygnus.com/">EGCS</ulink> (Experimental GNU Compiler System)
โครงการนี้ประกาศตัวเมื่อกลางเดือนสิงหาคม 1997 โดยเป็นความพยายามอย่างจงใจ ที่จะใช้แนวคิดจากบทความ <citetitle>มหาวิหารกับตลาดสด</citetitle> ที่เผยแพร่รุ่นแรก ผู้ก่อตั้งโครงการรู้สึกว่า การพัฒนาของ GCC หรือ GNU C Compiler กำลังติดขัด เป็นเวลายี่สิบเดือนตั้งแต่นั้น ที่ GCC และ EGCS กลายเป็นผลิตภัณฑ์ที่คู่ขนานกัน โดยดึงแรงงานจากนักพัฒนาในอินเทอร์เน็ตกลุ่มเดียวกัน เริ่มต้นจากซอร์สของ GCC เดียวกัน ใช้ชุดเครื่องมือและสภาพแวดล้อมการพัฒนาของยูนิกซ์เหมือนกัน แต่ต่างกันตรงที่ EGCS พยายามใช้เทคนิคของตลาดสดที่ผมได้บรรยายไปแล้ว ในขณะที่ GCC ยังคงใช้โครงสร้างการทำงานที่คล้ายมหาวิหารมากกว่า และทำโดยกลุ่มนักพัฒนาที่ปิด และออกรุ่นไม่บ่อย
นี่ถือว่าใกล้เคียงกับการทดลองที่ควบคุมตัวแปรมากที่สุดเท่าที่จะทำได้ และผลลัพธ์ก็เห็นได้อย่างรวดเร็ว ภายในไม่กี่เดือน EGCS ได้พัฒนาความสามารถไปไกลกว่าอย่างเห็นได้ชัด ทั้งออปติไมซ์ได้ดีกว่า และสนับสนุนภาษาฟอร์แทรนและซีพลัสพลัสได้ดีกว่า หลายคนพบว่า EGCS รุ่นระหว่างพัฒนายังเชื่อถือได้กว่ารุ่นเสถียรล่าสุดของ GCC เสียอีก และดิสทริบิวชันลินุกซ์ต่างๆ ก็เริ่มจะเปลี่ยนมาใช้ EGCS แทน
ในเดือนเมษายน 1999 มูลนิธิซอฟต์แวร์เสรี (ผู้สนับสนุนอย่างเป็นทางการของ GCC) ได้ยุบกลุ่มพัฒนา GCC เดิมเสีย แล้วโอนการควบคุมของโครงการไปให้ทีมหลักของ EGCS แทน
<emphasis><anchor id="SP"/>[SP]</emphasis> แน่นอน คำวิจารณ์ของโครพอตกินและกฎของไลนัส ได้สร้างประเด็นกว้างๆ เกี่ยวกับกลไกไซเบอร์สำหรับจัดโครงสร้างสังคม ทฤษฎีชาวบ้านอีกทฤษฎีหนึ่งของวิศวกรรมซอฟต์แวร์ ก็ได้ชี้ให้เห็นอีกประเด็นหนึ่ง คือกฎของคอนเวย์ ซึ่งกล่าวกันโดยทั่วไปว่า ``ถ้าคุณมีทีมงานสี่ทีมร่วมกันทำคอมไพเลอร์ คุณก็จะได้คอมไพเลอร์ที่ทำงานสี่ขั้น'' ข้อความดั้งเดิมอยู่ในรูปทั่วไปกว่านั้น: ``องค์กรต่างๆ ที่ออกแบบระบบ จะถูกบังคับให้สร้างระบบที่สะท้อนโครงสร้างการสื่อสารขององค์กรเหล่านั้น'' เราอาจกล่าวอย่างย่นย่อกว่านั้นได้ว่า ``วิธีการจะกำหนดผลลัพธ์'' หรือแม้แต่ว่า ``กระบวนการจะกลายเป็นผลิตภัณฑ์''
น่าสังเกตพอๆ กัน ว่าในชุมชนโอเพนซอร์สนั้น รูปแบบโครงสร้างชุมชนก็ตรงกับหน้าที่ที่ทำในหลายระดับ เครือข่ายนี้ครอบคลุมทุกอย่างและทุกที่ ไม่ใช่แค่อินเทอร์เน็ต แต่ผู้คนที่ทำงานยังได้สร้างเครือข่ายแบบกระจาย ขึ้นต่อกันอย่างหลวมๆ ในระดับเดียวกัน ที่มีส่วนที่ทดแทนกันได้เกิดขึ้นกลายส่วน และไม่ล้มครืนลงแบบทันทีทันใด ในเครือข่ายทั้งสอง แต่ละกลุ่มจะมีความสำคัญแค่ในระดับที่กลุ่มอื่นต้องการจะร่วมมือด้วยเท่านั้น
ตรงส่วน ``ในระดับเดียวกัน'' นี้ สำคัญมากสำหรับผลิตภาพอันน่าทึ่งของชุมชน ประเด็นที่โครพอตกินพยายามจะชี้เกี่ยวกับความสัมพันธ์เชิงอำนาจ ได้ถูกพัฒนาต่อไปโดย `หลัก SNAFU' ที่ว่า ``การสื่อสารที่แท้จริง จะเกิดได้ระหว่างคนที่เท่าเทียมกันเท่านั้น เพราะผู้ที่ด้อยกว่าจะได้รับการตอบแทนอย่างสม่ำเสมอกว่า ถ้าพูดโกหกให้ผู้ที่เหนือกว่าพอใจ เทียบกับการพูดความจริง'' ทีมงานที่สร้างสรรค์จะขึ้นอยู่กับการสื่อสารอย่างแท้จริง และจะถูกขัดขวางอย่างมากจากการมีความสัมพันธ์เชิงอำนาจ ชุมชนโอเพนซอร์ส ซึ่งปราศจากความสัมพันธ์เชิงอำนาจดังกล่าว จึงได้สอนเราในทางตรงกันข้าม ให้รู้ถึงข้อเสียของความสัมพันธ์ดังกล่าวในรูปของบั๊ก ผลิตภาพที่ถดถอย และโอกาสที่สูญเสียไป
นอกจากนี้ หลัก SNAFU ยังได้ทำนายว่า ในองค์กรที่มีอำนาจหน้าที่นั้น จะเกิดการตัดขาดระหว่างผู้มีอำนาจตัดสินใจ กับความเป็นจริง เพราะข้อมูลที่ผู้มีอำนาจตัดสินใจจะได้รับ มักมีแนวโน้มจะเป็นการโกหกให้พอใจ การเกิดเหตุการณ์เช่นนี้ในการพัฒนาซอฟต์แวร์แบบเดิม ก็เข้าใจได้ง่าย เนื่องจากมีแรงจูงใจอย่างแรงกล้าสำหรับผู้ที่ด้อยกว่า ที่จะซ่อน เพิกเฉย และลดปัญหาลง เมื่อกระบวนการนี้กลายมาเป็นผลิตภัณฑ์ ซอฟต์แวร์ก็กลายเป็นหายนะ
บรรณานุกรม
ผมยกคำพูดหลายแห่งมาจากหนังสืออมตะของ เฟรดเดอริก พี. บรูกส์ ชื่อ <citetitle>The Mythical Man-Month</citetitle> เพราะแนวคิดของเขายังต้องการการพิสูจน์ต่อไปในหลายๆ เรื่อง ผมขอแนะนำอย่างยิ่ง ให้อ่านฉบับครบรอบ 25 ปีจาก Addison-Wesley (ISBN 0-201-83595-9) ซึ่งเพิ่มบทความ ``No Silver Bullet'' (ไม่มียาครอบจักรวาล) ปี 1986 ของเขา
ฉบับปรับปรุงแก้ไขใหม่นี้ ยังปิดท้ายด้วยการหวนรำลึกเมื่อผ่านไป 20 ปี อันเป็นบทที่ประเมินค่าไม่ได้ ในบทดังกล่าว บรูกส์ยอมรับอย่างจริงใจเกี่ยวกับการตัดสินเล็กน้อยในเนื้อหาดั้งเดิมซึ่งไม่ผ่านการทดสอบของห้วงเวลา ผมอ่านบทหวนรำลึกนี้ครั้งแรกหลังจากที่รุ่นแรกของบทความนี้เสร็จไปเยอะแล้ว และต้องประหลาดใจที่ได้พบว่า บรูกส์ได้ถือว่ากระบวนการที่คล้ายตลาดสดเป็นผลมาจากไมโครซอฟท์! (อย่างไรก็ตาม ความจริงแล้ว การผูกโยงดังกล่าวกลายเป็นความผิดพลาด ในปี 1998 เราได้รู้จาก <ulink url="http://www.opensource.org/halloween/">เอกสารวันฮัลโลวีน</ulink> ว่าชุมชนนักพัฒนาภายในของไมโครซอฟท์นั้น แบ่งเป็นก๊กเป็นเหล่ามากมาย ซึ่งการเข้าถึงซอร์สโดยทั่วไปที่จำเป็นสำหรับการทำงานแบบตลาดสดนั้น ยังเป็นไปไม่ได้เลย)
หนังสือของ เจอรัลด์ เอ็ม. เวนเบิร์ก ชื่อ <citetitle>The Psychology Of Computer Programming (จิตวิทยาของการเขียนโปรแกรมคอมพิวเตอร์)</citetitle> (New York, Van Nostrand Reinhold 1971) ได้เสนอแนวคิดที่ออกจะโชคร้ายที่ได้ชื่อว่า ``การเขียนโปรแกรมแบบไร้อัตตา'' ถึงแม้เขาจะไม่มีวี่แววว่าจะเป็นคนแรกที่ตระหนักถึงความสูญเปล่าของ ``หลักแห่งการบังคับบัญชา'' แต่เขาก็อาจเป็นคนแรกที่มองเห็นและโต้ประเด็นนี้ โดยเชื่อมโยงกับการพัฒนาซอฟต์แวร์โดยเฉพาะ
ริชาร์ด พี. เกเบรียล ซึ่งได้ตรึกตรองเกี่ยวกับวัฒนธรรมยูนิกซ์ก่อนยุคลินุกซ์ ได้โต้แย้งอย่างลังเล ถึงข้อได้เปรียบของรูปแบบคล้ายตลาดสดในบทความปี 1989 ชื่อ ``LISP: Good News, Bad News, and How To Win Big'' (LISP: ข่าวดี, ข่าวร้าย, และวิธีชนะอย่างยิ่งใหญ่'') ของเขา แม้จะเก่าแล้วในบางเรื่อง แต่บทความนี้ก็ยังเป็นที่ยกย่องในหมู่แฟนๆ ภาษา LISP (รวมถึงผมด้วย) ผู้ร่วมแสดงความเห็นท่านหนึ่งเตือนผมว่า ตอนที่ชื่อ ``Worse Is Better'' (แย่กว่าดีกว่า) แทบจะเป็นการเก็งการเกิดของลินุกซ์ทีเดียว บทความดังกล่าวสามารถอ่านในเว็บได้ที่ <ulink url="http://www.naggum.no/worse-is-better.html">http://www.naggum.no/worse-is-better.html</ulink>
หนังสือของ เดอ มาร์โค และ ลิสเตอร์ ชื่อ <citetitle>Peopleware: Productive Projects and Teams (พีเพิลแวร์: โครงการและทีมงานอุดมผลงาน)</citetitle> (New York; Dorset House, 1987; ISBN 0-932633-05-6) เป็นอัญมณีมีค่าที่ได้รับความชื่นชมน้อยกว่าที่ควร ซึ่งผมยินดีที่ได้เห็น เฟรด บรูกส์ อ้างถึงในบทหวนรำลึกของเขา แม้สิ่งที่ผู้เขียนกล่าวถึงจะเกี่ยวข้องโดยตรงกับชุมชนลินุกซ์หรือโอเพนซอร์สน้อยมาก แต่แนวคิดของผู้เขียนเกี่ยวกับเงื่อนไขที่จำเป็นสำหรับงานสร้างสรรค์ ก็เป็นสิ่งที่เฉียบแหลม และคุ้มค่าสำหรับใครก็ตามที่พยายามจะนำข้อดีของรูปแบบตลาดสดไปใช้ในบริบทเชิงพาณิชย์
ท้ายที่สุด ผมต้องยอมรับว่า ผมเกือบจะเรียกบทความนี้ว่า ``The Cathedral and the Agora'' จริงๆ โดยคำว่า agora นี้ เป็นภาษากรีก ใช้เรียกตลาดเปิดโล่ง หรือที่ประชุมสาธารณะ บทความสัมมนาชื่อ ``agoric systems'' ของ มาร์ค มิลเลอร์ และ เอริก เดร็กซ์เลอร์ ซึ่งได้บรรยายคุณสมบัติที่อุบัติขึ้นของระบบนิเวศน์คอมพิวเตอร์ที่คล้ายตลาด ได้ช่วยให้ผมเตรียมพร้อมสำหรับการคิดอย่างชัดเจน เกี่ยวกับปรากฏการณ์เทียบเคียงในวัฒนธรรมโอเพนซอร์ส เมื่อลินุกซ์มากระตุ้นเตือนผมในห้าปีต่อมา บทความนี้อ่านได้บนเว็บที่ <ulink url="http://www.agorics.com/agorpapers.html">http://www.agorics.com/agorpapers.html</ulink>
กิติกรรมประกาศ
บทความนี้ได้รับการปรับปรุงด้วยการสนทนากับผู้คนจำนวนมากที่ช่วยตรวจทาน ขอขอบคุณ Jeff Dutky <email>dutky@wam.umd.edu</email> ซึ่งได้แนะนำคำสรุปที่ว่า ``การแก้บั๊กสามารถทำขนานกันได้'' และได้ช่วยวิเคราะห์ตามคำสรุปดังกล่าวด้วย ขอบคุณ Nancy Lebovitz <email>nancyl@universe.digex.net</email> สำหรับคำแนะนำว่า ผมได้เลียนแบบเวนเบิร์กด้วยการอ้างคำพูดของโครพอตกิน มีคำวิจารณ์ที่ลึกซึ้งจาก Joan Eslinger <email>wombat@kilimanjaro.engr.sgi.com</email> และ Marty Franz <email>marty@net-link.net</email> จากเมลลิ่งลิสต์ General Technics นอกจากนี้ Glen Vandenburg <email>glv@vanderburg.org</email> ยังได้ชี้ให้เห็นถึงความสำคัญของการกลั่นกรองตัวเองของประชากรผู้สมทบ และแนะนำแนวคิดที่ช่วยให้เกิดผลอย่างมาก ว่างานพัฒนาปริมาณมากถือว่าเป็นการแก้ `บั๊กเนื่องจากสิ่งที่ขาดไป' Daniel Upper <email>upper@peak.org</email> ได้แนะนำการเปรียบเทียบกับธรรมชาติของสิ่งนี้ ผมรู้สึกขอบคุณต่อสมาชิกของ PLUG หรือ Philadelphia Linux User's Group ที่ได้หาผู้ทดลองอ่านชุดแรกสำหรับบทความรุ่นแรก Paula Matuszek <email>matusp00@mh.us.sbphrd.com</email> ได้ให้ความกระจ่างแก่ผมเกี่ยวกับวิธีการบริหารงานซอฟต์แวร์ Phil Hudson <email>phil.hudson@iname.com</email> เตือนผมว่า การจัดโครงสร้างของวัฒนธรรมแฮ็กเกอร์ จะสะท้อนโครงสร้างของซอฟต์แวร์ และในทางกลับกันก็เป็นจริงด้วย John Buck <email>johnbuck@sea.ece.umassd.edu</email> ชี้ว่า MATLAB ก็ให้ตัวอย่างที่เหมือนกับ Emacs และ Russell Johnston <email>russjj@mail.com</email> ทำให้ผมได้สติเกี่ยวกับกลไกบางอย่างที่อภิปรายในหัวข้อ ``สายตากี่คู่ที่จะจัดการกับความซับซ้อนได้'' และท้ายที่สุด ความเห็นของ ไลนัส ทอร์วัลด์ เป็นประโยชน์มาก และการให้ความเห็นชอบของเขาตั้งแต่เนิ่นๆ นั้น ช่วยเป็นกำลังใจได้มาก
Isriya Paireepairit <markpeak@gmail.com>, 2545
Arthit Suriyawongkul <arthit@gmail.com>, 2545
Theppitak Karoonboonyanan <thep@linux.thai.net>, 2549
Visanu Euarchukiati <viseua@inet.co.th>, 2549 | https://linux.thai.net/~thep/catb/cathedral-bazaar/ | Open Publication License v2 |
ลงหลักปัญญาภูมิ (Homesteading the Noosphere) | ลงหลักปัญญาภูมิ
Eric
Steven
Raymond
Thyrsus Enterprises
esr@thyrsus.com
$Date: 2008-10-03 10:13:35 $
นี่คือรุ่นที่ 3.0
2543
Eric S. Raymond
สงวนลิขสิทธิ์
อนุญาตให้ทำสำเนา แจกจ่าย และ/หรือ แก้ไขเอกสารนี้ได้ ภายใต้เงื่อนไขของ Open Publication License รุ่น 2.0
1.22
24 สิงหาคม 2543
esr
ทฤษฎีการต่อแต้ม, นกยูง และกวาง. ความคล้ายคลึงกับความเป็นอัศวิน.
แปลงเป็น DocBook 4.1.
1.21
31 สิงหาคม 2542
แก้ไขครั้งใหญ่เพื่อตีพิมพ์ในหนังสือของ O'Reilly. เพิ่มแนวคิดเกี่ยวกับต้นทุนของการฟอร์กและแพตช์เถื่อนจาก Michael Chastain. Thomas Gagne (tgagne@ix.netcom.com) ตั้งข้อสังเกตเรื่องความคล้ายระหว่าง "ผู้มีอาวุโสชนะ" กับเคล็ดของระบบฐานข้อมูล. การอุปมาอุปมัยกับการเมืองของ Henry Spencer. Ryan Waldron and El Howard (elhoward@hotmail.com) สมทบความคิดเกี่ยวกับคุณค่าของนวัตกรรม. Thomas Bryan (tbryan@arlut.utexas.edu) อธิบายความเอือมระอาของแฮ็กเกอร์ต่อนโยบาย ``เขมือบแล้วขยาย''. Darcy Horrocks ให้แรงบันดาลใจต่อหัวข้อใหม่ ``ของขวัญนั้นดีแค่ไหน?'' เนื้อหาใหม่เรื่องความเชื่อมโยงกับลำดับชั้นของคุณค่าของมาสโลว์ และข้อห้ามเรื่องการโจมตีความสามารถ.
1.14
21 พฤศจิกายน 2541
แก้ไขเล็กน้อย และแก้ลิงก์ที่เสีย.
1.10
11 กรกฎาคม 2541
ลบการอ้างถึงคำว่า `fame' ของ Fare Rideau ตามที่เขาแนะนำ.
1.9
26 พฤษภาคม 2541
เพิ่มการแยกความแตกต่างระหว่าง noosphere/ergosphere ของ Faré Rideau. เพิ่มการแก้ต่างของ RMS ว่าเขาไม่ได้ต่อต้านการค้า. หัวข้อใหม่เรื่องการถ่ายทอดวัฒนธรรมและภาคการศึกษา (ขอบคุณ Ross J. Reedstrom, Eran Tromer, Allan McInnes, Mike Whitaker และคนอื่นๆ). เพิ่มเติมเกี่ยวกับความอ่อนน้อมถ่อมตน (`พฤติกรรมที่ไร้อัตตา') จาก Jerry Fass และ Marsh Ray.
1.8
27 เมษายน 2541
เพิ่ม Goldhaber ในบรรณานุกรม. ฉบับนี้เป็นฉบับที่จะตีพิมพ์ใน proceedings ของงาน Linux Expo.
1.7
16 เมษายน 2541
หัวข้อใหม่เรื่อง `นัยในภาพรวม' ถกเรื่องแนวโน้มการตั้งถิ่นฐานใน noosphere ที่ผ่านมา และตรวจสอบเรื่องปรากฏการณ์ `ผู้พิชิต'. เพิ่มคำถามเพื่อการค้นคว้าเพิ่มเติมอีกข้อ.
1.3
12 เมษายน 2541
แก้ไขคำสะกดผิด และตอบคำวิจารณ์จากสาธารณชนรอบแรก. บรรณานุกรมสี่รายการแรก. ข้อสังเกตจากผู้ไม่ประสงค์จะเอ่ยนาม เกี่ยวกับการทำงานของแรงกระตุ้นจากชื่อเสียง แม้ตัวช่างฝีมือจะไม่รู้ตัว. เพิ่มการเปรียบเทียบกับ warez d00dz ที่น่าศึกษา, เนื้อหาเรื่องเงื่อนไข `ซอฟต์แวร์ควรบอกเอง', และข้อสังเกตเกี่ยวกับการเลี่ยงความนิยมตัวบุคคล. ผลของการเปลี่ยนแปลงทั้งหมดนี้ ทำให้หัวข้อ `ปัญหาของอัตตา' ยาวขึ้น และถูกแบ่งเป็นหัวข้อย่อย.
1.2
10 เมษายน 2541
เผยแพร่บนเว็บเป็นครั้งแรก.
หลังจากที่ได้สังเกตเห็นความขัดแย้งกันเอง ระหว่างอุดมการณ์อย่างเป็นทางการที่กำหนดโดยสัญญาอนุญาตโอเพนซอร์สต่างๆ กับพฤติกรรมที่ปรากฏจริงของแฮ็กเกอร์ทั้งหลาย ผู้เขียนจึงได้ตรวจสอบจารีตประเพณีในทางปฏิบัติ ที่คอยกำหนดกฎเกณฑ์กรรมสิทธิ์และอำนาจควบคุมของซอฟต์แวร์โอเพนซอร์สทั้งหลาย ผู้เขียนจะแสดงให้เห็นว่า จารีตประเพณีเหล่านั้นบ่งบอกถึงทฤษฎีแห่งทรัพย์สินที่อยู่เบื้องหลัง ซึ่งละม้ายกับทฤษฎีสิทธิถือครองที่ดินของล็อค จากนั้น ผู้เขียนจะเชื่อมโยงเรื่องดังกล่าวเข้ากับการวิเคราะห์วัฒนธรรมแฮ็กเกอร์ ซึ่งเป็น `วัฒนธรรมแห่งการให้' (gift culture) ซึ่งสมาชิกจะแข่งขันเพื่อเกียรติยศ โดยอุทิศเวลา แรงกายแรงใจ และความคิดสร้างสรรค์ให้กับชุมชน และท้ายที่สุด ผู้เขียนจะตรวจสอบผลพวงของการวิเคราะห์นี้ ต่อการยุติข้อขัดแย้งในชุมชน และพัฒนาเป็นจารีตโดยนัย
ความขัดแย้งในตัวเองในเบื้องต้น
ใครก็ตาม ที่เฝ้ามองโลกที่ไม่หยุดนิ่งและอุดมผลของซอฟต์แวร์โอเพนซอร์สในอินเทอร์เน็ตสักระยะหนึ่ง จะสังเกตได้ถึงความขัดแย้งในตัวเองที่น่าสนใจข้อหนึ่ง ระหว่างสิ่งที่แฮ็กเกอร์โอเพนซอร์สบอกว่าเชื่อ กับวิธีปฏิบัติที่เป็นจริง หรืออีกนัยหนึ่งคือ ระหว่างอุดมการณ์อย่างเป็นทางการของวัฒนธรรมโอเพนซอร์ส กับการปฏิบัติในความเป็นจริง
วัฒนธรรมเป็นกลไกที่ปรับตัวได้ วัฒนธรรมโอเพนซอร์สเอง ก็เป็นการสนองตอบต่อแรงขับเคลื่อนและแรงกดดันที่บ่งบอกได้จำนวนหนึ่ง ซึ่งการปรับตัวของมันไปตามสภาวการณ์ต่างๆ ก็มีทั้งจากอุดมการณ์ในจิตสำนึก และจากการเรียนรู้ที่สั่งสมกันมาแบบไม่รู้ตัว หรือไม่มีการเอ่ยถึง และก็ไม่แปลกอะไร ที่การปรับตัวแบบเป็นไปเอง จะขัดกับอุดมการณ์ในจิตสำนึกไปบ้าง
ในบทความนี้ ผู้เขียนจะเจาะหาต้นตอของความขัดแย้งในตัวเองดังกล่าว เพื่อใช้ค้นหาแรงขับเคลื่อนและแรงกดดันเหล่านั้น ผู้เขียนจะอนุมานต่อถึงประเด็นที่น่าสนใจจำนวนหนึ่งเกี่ยวกับวัฒนธรรมแฮ็กเกอร์และจารีตประเพณีของมัน จากนั้นจะสรุปด้วยการแนะนำหนทางที่จะทำให้การเรียนรู้ที่แฝงอยู่ในวัฒนธรรมนี้ที่ว่านั้น มีประสิทธิผลยิ่งขึ้น
อุดมการณ์ต่างๆ ของแฮ็กเกอร์
อุดมการณ์ของวัฒนธรรมโอเพนซอร์สบนอินเทอร์เน็ต (สิ่งที่แฮ็กเกอร์บอกว่าเชื่อ) เป็นเรื่องที่ค่อนข้างซับซ้อนในตัวเอง สมาชิกทุกคนเห็นพ้องต้องกันว่า โอเพนซอร์ส (กล่าวคือ ซอฟต์แวร์ที่แจกจ่ายได้อย่างเสรี และสามารถพัฒนาหรือปรับเปลี่ยนตามความต้องการที่เปลี่ยนไปได้) เป็นสิ่งที่ดี และควรค่าแก่การร่วมกันลงแรงอย่างแข็งขัน ความเห็นพ้องนี้นี่เอง ที่เป็นตัวบ่งชี้ความเป็นส่วนหนึ่งในวัฒนธรรมนี้ของแต่ละบุคคล อย่างไรก็ดี เหตุผลของแต่ละคนหรือแต่ละวัฒนธรรมย่อยที่สนับสนุนความเชื่อดังกล่าว กลับแตกต่างกันอย่างเห็นได้ชัด
ความแตกต่างหนึ่งคือระดับความจริงจังที่จะยึดถือ ว่าการพัฒนาแบบโอเพนซอร์สเป็นเพียงหนทางที่สะดวกที่จะไปสู่เป้าหมาย (คือเป็นเครื่องมือที่ดี เป็นของเล่นที่สนุก และเป็นเกมที่น่าเล่น) หรือคือเป้าหมายในตัวของมันเอง
คนที่จริงจังมากอาจจะบอกว่า ``ซอฟต์แวร์เสรีคือชีวิตของฉัน! ฉันเกิดมาเพื่อสร้างโปรแกรมและทรัพยากรข้อมูลที่สวยงามใช้ประโยชน์ได้ และให้เปล่า'' คนที่จริงจังปานกลางอาจจะพูดว่า ``โอเพนซอร์สเป็นสิ่งที่ดีที่ฉันเต็มใจสละเวลาช่วยให้มันเกิด'' ส่วนคนที่จริงจังน้อยอาจจะบอก ``อืมม์ โอเพนซอร์สบางทีก็ดีเหมือนกันนะ ฉันก็เล่นกับมันและเคารพผู้คนที่สร้างมันขึ้นมา''
ความแตกต่างอีกมุมหนึ่งคือระดับความเป็นปฏิปักษ์กับซอฟต์แวร์เชิงพาณิชย์ และ/หรือ บริษัทที่เห็นได้ชัดว่าครอบครองตลาดซอฟต์แวร์เชิงพาณิชย์อยู่
คนที่ต่อต้านการค้ามากๆ อาจจะบอกว่า ``ซอฟต์แวร์พาณิชย์คือการปล้นและหมกเม็ด ฉันเขียนซอฟต์แวร์เสรีก็เพื่อจบความชั่วร้ายนี้'' คนที่ต่อต้านการค้าปานกลาง อาจจะพูดว่า ``ซอฟต์แวร์พาณิชย์โดยทั่วไปก็โอเค เพราะโปรแกรมเมอร์สมควรได้รับค่าตอบแทน แต่บริษัทที่แถซอฟต์แวร์ห่วยๆ ไปมา โดยทิ้งน้ำหนักตัวเองใส่ชาวบ้าน คือพวกชั่วร้าย'' ส่วนคนที่ไม่ต่อต้านการค้าเลย อาจจะบอก ``ซอฟต์แวร์พาณิชย์ก็โอเค แต่ฉันเขียนซอฟต์แวร์โอเพนซอร์สเพราะฉันชอบกว่า'' (ทุกวันนี้ ท่ามกลางการเติบโตของอุตสาหกรรมภาคโอเพนซอร์สหลังจากปล่อยรุ่นแรกของบทความนี้สู่สาธารณะ ใครบางคนอาจจะเคยได้ยินด้วยว่า ``ซอฟต์แวร์พาณิชย์ก็ดีนะ ตราบใดที่ฉันยังได้ซอร์ส หรือมันยังทำงานตามที่ฉันต้องการ'')
ในวัฒนธรรมโอเพนซอร์ส มีทัศนคติครบทั้งเก้าแบบที่เกิดจากการจับคู่ความเห็นในเรื่องทั้งสอง การชี้ความแตกต่างตรงนี้มีความหมาย เพราะมันหมายถึงวาระ พฤติกรรมการปรับตัวและการให้ความร่วมมือที่แตกต่างกันของแต่ละคน
ตามนัยประวัติแล้ว ภาคที่เห็นได้ชัดและมีระเบียบแบบแผนมากที่สุดของวัฒนธรรมแฮ็กเกอร์ก็คือ กลุ่มที่จริงจังมากและต่อต้านการค้า มูลนิธิซอฟต์แวร์เสรี (Free Software Foundation—FSF) ที่ก่อตั้งโดย ริชาร์ด เอ็ม. สตอลแมน (Richard M. Stallman—RMS) ได้ให้แรงสนับสนุนอย่างมากต่อการพัฒนาแบบโอเพนซอร์สตั้งแต่ต้นทศวรรษ 1980 เป็นต้นมา ซึ่งรวมถึงเครื่องมืออย่าง Emacs และ GCC ที่ยังคงเป็นพื้นฐานของโลกโอเพนซอร์สบนอินเทอร์เน็ต และมีทีท่าจะคงอยู่ต่อไปในอนาคต
เป็นเวลาหลายปีที่ FSF ได้เป็นศูนย์รวมที่สำคัญที่สุดเพียงแห่งเดียวของการทำงานโอเพนซอร์ส ซึ่งได้ผลิตเครื่องมือจำนวนมากที่ยังคงเป็นส่วนที่สำคัญที่สุดของตัววัฒนธรรม นอกจากนี้ FSF ยังเป็นผู้สนับสนุนโอเพนซอร์สในรูปแบบสถาบันที่มองเห็นได้จากภายนอกวัฒนธรรมแฮ็กเกอร์เพียงแห่งเดียวเป็นเวลายาวนาน FSF ได้บัญญัติคำว่า `ซอฟต์แวร์เสรี' (free software) อย่างได้ผล โดยมีเจตนาลึกๆ ที่จะให้เกิดแรงปะทะ (ซึ่งฉลากใหม่ `<ulink url="http://www.opensource.org">โอเพนซอร์ส'</ulink> (open source) มีเจตนาลึกเท่ากันที่จะหลีกเลี่ยง)
ดังนั้น ภาพที่ปรากฏของวัฒนธรรมแฮ็กเกอร์ทั้งจากภายในและภายนอก FSF จึงมีแนวโน้มที่จะแสดงเอกลักษณ์ของตัวเองด้วยทัศนคติที่จริงจังและความมุ่งหวังที่จะต่อต้านการค้าของ FSF แม้ตัว RMS เองจะปฏิเสธว่าไม่ได้ต่อต้านการค้า แต่คนทั่วไปก็อ่านความเคลื่อนไหวต่างๆ ของเขาออกมาเช่นนั้น รวมทั้งสาวกที่เสียงดังที่สุดของเขาหลายคน การขับเคลื่อนที่ทรงพลังและชัดแจ้งของ FSF ที่จะ ``กระทืบการเก็บกักซอฟต์แวร์ให้จมดิน!'' กลายเป็นตัวแทนที่ชัดที่สุดของอุดมการณ์แฮ็กเกอร์ และ RMS ก็กลายเป็นตัวแทนที่ชัดที่สุดของผู้นำของวัฒนธรรมแฮ็กเกอร์
ข้อกำหนดในสัญญาอนุญาตของ FSF คือ ``General Public License'' (GPL) นั้น แสดงทัศนคติดังกล่าวของ FSF อย่างชัดแจ้ง และก็เป็นสัญญาอนุญาตที่ใช้กันกว้างขวางที่สุดในโลกโอเพนซอร์สด้วย <ulink url="http://metalab.unc.edu/pub/Linux/welcome.html">Metalab</ulink> (หรือ Sunsite ในอดีต) ของมหาวิทยาลัยนอร์ธแคโรไลนา เป็นแหล่งเก็บซอฟต์แวร์ที่ใหญ่ที่สุดและเป็นที่รู้จักกันมากที่สุดในโลกของลินุกซ์ ในเดือนกรกฎาคม 1997 ประมาณครึ่งหนึ่งของแพกเกจซอฟต์แวร์ใน Sunsite ที่ระบุสัญญาอนุญาต เป็นซอฟต์แวร์ที่ใช้ GPL
แต่ FSF ไม่ใช่ทั้งหมดของโอเพนซอร์ส ยังมีผู้ที่ส่งเสียงน้อยกว่า เผชิญหน้าน้อยกว่า และเป็นมิตรกับตลาดมากกว่าอยู่เสมอในแวดวงแฮ็กเกอร์ นักปฏิบัติทั้งหลายไม่ได้เคร่งครัดกับอุดมการณ์เท่ากับธรรมเนียมทางวิศวกรรมที่พบในความพยายามแรกๆ ของโอเพนซอร์สซึ่งเกิดก่อน FSF เสียอีก ธรรมเนียมเหล่านี้ที่สำคัญที่สุดก็คือ วัฒนธรรมทางเทคนิคที่เกี่ยวพันกันของยูนิกซ์กับอินเทอร์เน็ตก่อนยุคพาณิชย์
ทัศนคติโดยปกติของนักปฏิบัติจะต่อต้านการค้าแค่ปานกลาง และความสลดใจต่อโลกธุรกิจก็ไม่ใช่ที่การ `หมกเม็ด' โดยตรง แต่เป็นการที่โลกดันทุรังปฏิเสธวิถีทางที่ดีกว่าที่ประกอบด้วยยูนิกซ์ มาตรฐานเปิด และซอฟต์แวร์โอเพนซอร์ส ถ้าจะมีสิ่งที่นักปฏิบัติเกลียดชัง ก็ไม่น่าจะใช่ `พวกหมกเม็ด' โดยทั่วไป แต่น่าจะเป็นราชาแห่งวงการซอฟต์แวร์อย่างไอบีเอ็มในอดีต และไมโครซอฟท์ในปัจจุบันมากกว่า
สำหรับนักปฏิบัติแล้ว GPL มีความสำคัญในฐานะเครื่องมือ ไม่ใช่ในฐานะตัวของมันเอง และคุณค่าของมันก็ไม่ใช่ในฐานะอาวุธต่อต้าน `การหมกเม็ด' แต่เป็นเครื่องมือสำหรับกระตุ้นให้เกิดการแบ่งปันซอฟต์แวร์และการเติบโตของ <ulink url="http://www.tuxedo.org/~esr/writings/cathedral-bazaar"> การพัฒนาแบบตลาดสด</ulink> นักปฏิบัติจะให้คุณค่ากับเครื่องไม้เครื่องมือที่ดี มากกว่าเกลียดชังการพาณิชย์ และอาจใช้ซอฟต์แวร์พาณิชย์คุณภาพสูงโดยไม่รู้สึกขัดกับอุดมการณ์ ในขณะเดียวกัน ประสบการณ์โอเพนซอร์สก็ได้สอนให้เขาได้รู้ถึงมาตรฐานของคุณภาพทางเทคนิคที่ซอฟต์แวร์ปิดน้อยตัวจะบรรลุได้
เป็นเวลาหลายปีที่มุมมองของนักปฏิบัติถูกแสดงออกมาในวัฒนธรรมแฮ็กเกอร์ ด้วยกระแสต่อต้านการใช้ GPL หรือกิจกรรมต่างๆ ของ FSF โดยทั่วไป โดยในช่วงตลอดทศวรรษ 1980 และต้นทศวรรษ 1990 นั้น ทัศนคตินี้ดูจะประสานกันกับแฟนๆ Berkeley Unix และผู้ที่ใช้สัญญาอนุญาตแบบ BSD รวมไปถึงความพยายามยุคแรกที่จะสร้างยูนิกซ์โอเพนซอร์สจากซอร์สของ BSD แต่ในที่สุด ความพยายามเหล่านี้ก็ไม่สามารถสร้างชุมชนแบบตลาดสดที่ใหญ่พอ แล้วก็แตกเป็นเสี่ยงๆ และไร้ประสิทธิผล
จนกระทั่งเกิดการบูมของลินุกซ์ในช่วงต้น 1993–1994 แนวคิดนักปฏิบัติจึงได้กลับมาเรืองอำนาจ แม้ ลินุส ทอร์วาลด์ จะไม่เคยแสดงความต่อต้าน RMS แต่เขาก็ได้ทำตัวให้เป็นตัวอย่าง ด้วยการมองการเติบโตของลินุกซ์เชิงพาณิชย์อย่างเป็นมิตร ด้วยการสนับสนุนการใช้ซอฟต์แวร์พาณิชย์คุณภาพสูงอย่างชัดแจ้งในงานเฉพาะ และด้วยการหยอกเอินพวกเคร่งและคลั่งลัทธิในแวดวงอย่างสุภาพ
ผลข้างเคียงของการเติบโตอย่างรวดเร็วของลินุกซ์ก็คือ การดึงดูดแฮ็กเกอร์หน้าใหม่จำนวนมากเข้ามาร่วม โดยที่ลินุกซ์คือสิ่งที่พวกเขาให้ความภักดี และวาระต่างๆ ของ FSF กลายเป็นเรื่องของอดีต และถึงแม้คลื่นลูกใหม่ของเหล่าแฮ็กเกอร์ลินุกซ์จะเรียกระบบของตัวเองว่า ``คำตอบของยุค GNU'' (the choice of a GNU generation) แต่ส่วนมากมีแนวโน้มจะเลียนแบบทอร์วาลด์มากกว่าสตอลแมน
ในที่สุด กลุ่มผู้เคร่งอุดมการณ์ที่ต่อต้านการค้าค่อยๆ พบว่าตัวเองกลายเป็นชนกลุ่มน้อยขึ้นเรื่อยๆ ความเปลี่ยนแปลงนี้เห็นได้ชัดเมื่อเน็ตสเคปประกาศในเดือนกุมภาพันธ์ 1998 ว่าจะแจกจ่าย Navigator 5.0 ในรูปซอร์สโค้ด เรื่องนี้ได้กระตุ้นความสนใจ `ซอฟต์แวร์เสรี' ในภาคธุรกิจ การเรียกร้องที่ตามมา ให้วัฒนธรรมแฮ็กเกอร์ถือโอกาสสำคัญนี้เปลี่ยนฉลากผลิตภัณฑ์จาก `ซอฟต์แวร์เสรี' (free software) เป็น `โอเพนซอร์ส' (open source) ได้รับการตอบสนองอย่างรวดเร็ว จนต้องทำให้ทุกคนต้องประหลาดใจ
ในการพัฒนาอีกด้านหนึ่งที่เสริมกัน กลุ่มนักปฏิบัติได้เกิดศูนย์รวมขึ้นหลายศูนย์ในช่วงกลางทศวรรษ 1990 ชุมชนใหม่หลายแห่งที่มีแนวคิดและผู้นำเป็นของตนเองก็เริ่มแตกหน่อออกจากรากของยูนิกซ์/อินเทอร์เน็ต ในจำนวนนี้ แหล่งที่สำคัญที่สุดหลังจากลินุกซ์ได้แก่วัฒนธรรมชุมชน Perl ของ ลาร์รี วอลล์ (Larry Wall) อีกกลุ่มหนึ่งที่ถึงจะเล็กกว่าแต่ก็สำคัญ คือธรรมเนียมปฏิบัติที่เกิดรอบๆ ภาษา Tcl ของ John Osterhout และภาษา Python ของ Guido van Rossum ชุมชนทั้งสามได้แสดงอิสรภาพของอุดมการณ์ด้วยการสร้างสัญญาอนุญาตของตัวเอง โดยไม่ใช้ GPL
ทฤษฎีสำส่อน ปฏิบัติเคร่งครัด
แม้กระนั้น ท่ามกลางความเปลี่ยนแปลงเหล่านี้ ก็ยังคงมีทฤษฎีสาธารณะแบบกว้างๆ ที่อธิบายความหมายของ `ซอฟต์แวร์เสรี' หรือ `โอเพนซอร์ส' การแสดงออกที่ชัดเจนที่สุดของทฤษฏีสามัญนี้ สามารถพบได้ในสัญญาอนุญาตโอเพนซอร์สทั้งหลาย ซึ่งต่างก็มีองค์ประกอบที่สำคัญๆ ร่วมกัน
ในปี 1997 องค์ประกอบร่วมเหล่านี้ ได้ถูกกลั่นกรองออกมาเป็น `แนวทางซอฟต์แวร์เสรีเดเบียน' (Debian Free Software Guidelines) ซึ่งต่อมาได้กลายเป็น <ulink url="http://www.opensource.org">นิยามโอเพนซอร์ส</ulink> (Open Source Definition—OSD) ด้วยแนวทางที่กำหนดโดย OSD นี้ สัญญาอนุญาตโอเพนซอร์สใดๆ จะต้องปกป้องสิทธิ์อย่างไร้เงื่อนไขของฝ่ายใดก็ตามที่จะแก้ไขและแจกจ่ายซอฟต์แวร์โอเพนซอร์ส
ด้วยเหตุนี้ ทฤษฎีที่แฝงอยู่ใน OSD (และสัญญาอนุญาตที่สอดคล้องกับ OSD ทั้งหลาย เช่น GPL, สัญญาอนุญาต BSD, และสัญญาอนุญาต Artistic ของ Perl) ก็คือ ใครจะแฮ็กอะไรก็ได้ ไม่มีการห้ามกลุ่มบุคคลต่างๆ มิให้นำเอาผลิตภัณฑ์โอเพนซอร์ส (ตัวอย่างเช่น คอมไพเลอร์ภาษาซี gcc ของมูลนิธิซอฟต์แวร์เสรี) มาทำซ้ำแล้วพัฒนาต่อไปอีกทางโดยที่ยังใช้ชื่อผลิตภัณฑ์เดิม
การแยกเส้นทางแบบนี้เรียกว่า <emphasis>การฟอร์ก</emphasis> (fork) ลักษณะสำคัญของการฟอร์กก็คือ เกิดโครงการเดิมเพิ่มอีกชุดมาแข่งกัน โดยที่ไม่สามารถแลกเปลี่ยนโค้ดกันได้อีก อันทำให้ชุมชนนักพัฒนาที่มีศักยภาพต้องแตกแยก (มีปรากฏการณ์บางอย่างที่ดูเผินๆ อาจจะคล้ายการฟอร์ก แต่ไม่ใช่ เช่น การเกิดอย่างมโหฬารของดิสทริบิวชันลินุกซ์ที่แตกต่างกัน การฟอร์กเทียมๆ เหล่านี้ อาจทำให้เกิดโครงการแยกกันก็จริง แต่ทั้งหมดก็ยังคงใช้โค้ดเกือบทั้งหมดร่วมกัน และยังคงได้รับประโยชน์จากการพัฒนาของกลุ่มอื่นอย่างเต็มที่ จนไม่นับว่าเป็นความสูญเปล่า ไม่ว่าจะเป็นทางเทคนิคหรือทางสังคม จึงไม่ถือเป็นการฟอร์ก)
สัญญาอนุญาตโอเพนซอร์สไม่ได้ทำอะไรเพื่อห้ามปรามการฟอร์กเลย ยิ่งเรื่องการฟอร์กเทียมๆ ยิ่งไม่ต้องพูดถึง และอันที่จริง ใครบางคนอาจแย้งว่า มันเชื้อเชิญให้ทำทั้งสองอย่างด้วยซ้ำ อย่างไรก็ตาม ในทางปฏิบัติแล้ว การฟอร์กเทียมเป็นเรื่องปกติ แต่การฟอร์กจริงแทบจะไม่เกิดขึ้นเลย การแตกกลุ่มในโครงการใหญ่ๆ ไม่ค่อยจะมีให้เห็น แต่ถ้ามี ก็จะมีการเปลี่ยนชื่อ และต้องผ่านการกลั่นกรองจากสาธารณะด้วย เห็นได้ชัดว่า กรณีอย่างการแยก GNU Emacs/XEmacs หรือการแยก gcc/egcs หรือการแตกเป็นเสี่ยงๆ ของกลุ่ม BSD นั้น กลุ่มผู้แยกตัวต่างรู้สึกว่าต้องต่อสู้กับจารีตอันแข็งแกร่งของประชาคมอยู่ไม่น้อย <link linkend="BSD">[BSD]</link>
ในความเป็นจริง (ซึ่งขัดแย้งในตัวเองกับทฤษฎีสาธารณะที่ใครแฮ็กอะไรก็ได้) วัฒนธรรมโอเพนซอร์สมีจารีตประเพณีที่ละเอียดยิบย่อยแต่กลับไม่ค่อยยอมรับกันว่ามี ว่าด้วยเรื่องของกรรมสิทธิ์อยู่ จารีตประเพณีนี้ คอยกำหนดกฎเกณฑ์ว่าใครสามารถแก้ไขซอฟต์แวร์ได้บ้าง มีเงื่อนไขใดบ้างที่จะสามารถแก้ไขซอฟต์แวร์ได้ และโดยเฉพาะอย่างยิ่ง ใครที่มีสิทธิ์ที่จะแจกจ่ายซอฟต์แวร์ที่แก้ไขแล้วกลับไปให้กับชุมชน
ข้อห้ามของวัฒนธรรมช่วยเน้นจารีตให้ปรากฏเด่นชัดยิ่งขึ้น ดังนั้น น่าจะเป็นการดีถ้าเรามาสรุปข้อห้ามที่สำคัญไว้ ณ ที่นี้:
มีแรงกดดันอย่างรุนแรงจากสังคมที่คอยต้านการฟอร์กโครงการทั้งหลาย จะไม่มีการฟอร์กนอกจากจะมีการวิงวอนด้วยความจำเป็นอันสาหัส ทั้งยังต้องผ่านการกลั่นกรองจากสาธารณะ และมักจะต้องเปลี่ยนชื่อด้วย
การแจกจ่ายการแก้ไขในโครงการโดยปราศจากความร่วมมือจากผู้ดูแลมักไม่ได้รับการยอมรับ ยกเว้นในกรณีพิเศษจริงๆ เช่นการแก้ปัญหาเรื่องการข้ามแพล็ตฟอร์มเล็กๆ น้อยๆ
จะไม่มีการลบชื่อบุคคลออกจากประวัติโครงการ จากกิติกรรมประกาศ หรือจากรายชื่อผู้ดูแล <emphasis>อย่างเด็ดขาด</emphasis> ยกเว้นด้วยความยินยอมของบุคคลนั้น
ในส่วนที่เหลือของบทความนี้ เราจะมาตรวจสอบข้อห้ามเหล่านี้ และจารีตประเพณีเรื่องกรรมสิทธิ์กันในรายละเอียด เราจะไม่เพียงศึกษาว่ามันทำงานอย่างไร แต่จะศึกษาด้วยว่ามันได้เปิดเผยอะไรบ้างเกี่ยวกับพลวัตทางสังคมเบื้องหลัง และโครงสร้างของแรงจูงใจต่างๆ ในชุมชนโอเพนซอร์ส
กรรมสิทธิ์กับโอเพนซอร์ส
ความหมายของ `กรรมสิทธิ์' คืออะไร ในเมื่อทรัพย์สินสามารถทำซ้ำได้ไม่จำกัด แปรเปลี่ยนรูปได้สารพัด แถมวัฒนธรรมแวดล้อมก็ไม่มีความเกี่ยวข้องกับพลังอำนาจ หรือเศรษฐศาสตร์ที่ขาดแคลนด้านวัตถุใดๆ เลย?
อันที่จริง ในกรณีของวัฒนธรรมโอเพนซอร์ส คำถามนี้ตอบง่ายมาก เจ้าของโครงการซอฟต์แวร์ก็คือบุคคลที่มีเอกสิทธิ์โดยการยอมรับของชุมชนในวงกว้าง ที่จะ <emphasis>แจกจ่ายซอฟต์แวร์ที่แก้ไขแล้ว</emphasis>
(ในการอภิปรายเรื่อง `กรรมสิทธิ์' ในหัวข้อนี้ ผู้เขียนจะใช้คำเอกพจน์ เหมือนกับว่าทุกโครงการมีเจ้าของเพียงคนเดียว แต่ขอให้เข้าใจด้วยว่าโครงการอาจมีเจ้าของเป็นกลุ่มก็ได้ เราจะมาตรวจสอบพลวัตภายในของกลุ่มดังกล่าวในภายหลัง)
ตามสัญญาอนุญาตโอเพนซอร์สมาตรฐานแล้ว ทุกฝ่ายเท่าเทียมกันในเกมแห่งวิวัฒนาการ แต่ในทางปฏิบัติ จะมีความแตกต่างที่ยอมรับกันเป็นอย่างดี ระหว่างแพตช์ที่ `เป็นทางการ' ที่ตรวจสอบและรวมเข้าแล้วในซอฟต์แวร์ที่วิวัฒน์ไปข้างหน้า โดยผู้ดูแลที่สาธารณชนยอมรับ กับแพตช์ `เถื่อน' ของบุคคลที่สาม แพตช์เถื่อนเป็นของแปลกปลอม และมักไม่ค่อยได้รับความเชื่อถือ <link linkend="rp">[RP]</link>
เรื่องของการแจกจ่ายการแก้ไข <emphasis>สู่สาธารณะ</emphasis> เป็นเรื่องพื้นฐานที่สร้างได้ง่าย จารีตประเพณีเชื้อเชิญผู้คนให้แก้ไขซอฟต์แวร์เพื่อใช้ส่วนตัวเมื่อจำเป็น จารีตประเพณีไม่ว่าอะไรใครที่แจกจ่ายซอฟต์แวร์ที่แก้ไขแล้วในกลุ่มผู้ใช้หรือนักพัฒนากลุ่มเล็กๆ แต่เมื่อใดก็ตาม ที่การแก้ไขนั้นถูกประกาศสู่ชุมชนโอเพนซอร์สโดยทั่วไป โดยชนกับต้นฉบับ นั่นแหละที่เรื่องกรรมสิทธิ์จะเป็นเรื่องขึ้นมา
โดยทั่วไปแล้ว มีสามทางที่จะได้กรรมสิทธิ์ในโครงการโอเพนซอร์ส ทางที่หนึ่ง ซึ่งชัดเจนที่สุด คือตั้งโครงการเอง เมื่อโครงการใดมีผู้ดูแลเพียงคนเดียวตั้งแต่แรกเริ่ม และผู้ดูแลนั้นก็ยังคงทำงานอยู่ จารีตประเพณีก็จะไม่แม้แต่จะยอมให้มี <emphasis>คำถาม</emphasis> ว่าใครเป็นเจ้าของโครงการ
ทางที่สองคือ ให้มีการถ่ายโอนกรรมสิทธิ์นั้นให้กับคุณจากเจ้าของคนเดิม (การถ่ายโอนนี้ บางทีก็รู้จักกันในนาม `การส่งไม้' (passing the baton)) ประชาคมจะเข้าใจดีว่า เป็นหน้าที่จองเจ้าของโครงการที่จะส่งต่อโครงการให้กับผู้สืบทอดที่มีความสามารถ เมื่อเขาไม่ต้องการหรือไม่สามารถอุทิศเวลาให้กับงานพัฒนาหรือดูแลโครงการได้อีก
เป็นเรื่องสำคัญในกรณีของโครงการใหญ่ๆ ที่ต้องมีการประกาศการถ่ายโอนการควบคุมดังกล่าวอย่างเป็นทางการ และถึงแม้จะไม่เคยปรากฏว่ามีชุมชนโอเพนซอร์สไหนไปก้าวก่ายการตัดสินใจของเจ้าของโครงการ แต่ตามธรรมเนียมปฏิบัติแล้ว ก็จะถือเอาความเหมาะสมตามความเห็นของสาธารณชนเป็นสำคัญ
สำหรับโครงการเล็กๆ การบันทึกการเปลี่ยนกรรมสิทธิ์ลงในประวัติการเปลี่ยนแปลงของโครงการที่แนบไปพร้อมกับการแจกจ่ายก็ถือว่าเพียงพอ โดยถือว่า ถ้าเจ้าของคนก่อนไม่ได้เต็มใจถ่ายโอนการควบคุมให้ เขาก็สามารถร้องขออำนาจคืนด้วยการสนับสนุนของชุมชน โดยประท้วงในที่สาธารณะภายในเวลาอันควรได้
ทางที่สามที่จะได้มาซึ่งกรรมสิทธิ์ในโครงการ คือการสังเกตพบว่าโครงการมีสิ่งที่ควรทำต่อ แต่เจ้าของได้หายตัวไป หรือเลิกสนใจ ถ้าคุณต้องการทำงานชิ้นนั้น ก็เป็นความรับผิดชอบของคุณที่จะพยายามหาตัวเจ้าของให้พบ ถ้าคุณหาไม่พบ ก็อาจจะประกาศในที่ที่เกี่ยวข้อง (เช่น ในกลุ่มข่าว Usenet ที่ตั้งขึ้นเพื่อโปรแกรมประเภทนั้น) ว่าโครงการนั้นไร้ผู้ดูแล และคุณกำลังพิจารณารับภาระดูแลต่อ
ตามธรรมเนียมแล้ว คุณควรเว้นช่วงเวลาสักพัก ก่อนที่จะตอบการประกาศของคุณ ว่าคุณจะประกาศตัวเป็นเจ้าของคนใหม่ โดยในช่วงนี้ ถ้ามีใครบางคนประกาศว่าเขากำลังทำงานกับโครงการนี้อยู่ ก็ถือว่าเขาได้ไป ถ้ายังไม่มีใครตอบ การประกาศต่อสาธารณะมากกว่าหนึ่งครั้งก็ถือว่าเป็นมารยาทที่ดี คุณจะยิ่งได้คะแนนมารยาทมากขึ้นถ้าคุณประกาศในฟอรัมที่เกี่ยวข้องหลายแห่ง (เช่น กลุ่มข่าวที่เกี่ยวข้องและเมลลิงลิสต์) และจะได้มากขึ้นอีกถ้าคุณแสดงความอดทนที่จะรอคำตอบ โดยทั่วไปแล้ว ยิ่งคุณแสดงความพยายามให้เห็นมากเท่าไร ในการให้โอกาสเจ้าของคนเดิมหรือผู้อื่นที่อาจอ้างสิทธิ์ที่จะให้คำตอบ การอ้างกรรมสิทธิ์ของคุณเมื่อไร้คำตอบ ก็จะดูดีมากขึ้นเท่านั้น
ถ้าคุณได้ผ่านขั้นตอนทั้งหมดนี้ท่ามกลางสายตาของชุมชนผู้ใช้ของโครงการมาแล้ว ก็จะไม่มีการคัดค้านอะไรอีก คุณก็สามารถอ้างกรรมสิทธิ์ในโครงการไร้ผู้ดูแลนี้ และสามารถบันทึกการถ่ายโอนลงในประวัติโครงการได้ อย่างไรก็ตาม วิธีนี้ก็ยังปลอดภัยน้อยกว่าการรับไม้โดยตรง และคุณก็ยังไม่อาจคาดหวังว่าจะมีความชอบธรรมเต็มที่ จนกว่าคุณจะได้ลงมือปรับปรุงจนเห็นได้ชัดในสายตาของชุมชนผู้ใช้
ผู้เขียนได้สังเกตเห็นจารีตประเพณีเหล่านี้ในสถานการณ์จริงมากว่า 20 ปี ย้อนไปจนถึงประวัติศาสตร์ของซอฟต์แวร์โอเพนซอร์สในยุคเก่าก่อน FSF เป็นจารีตประเพณีที่มีลักษณะที่น่าสนใจมากๆ หลายประการ ประการหนึ่งคือ แฮ็กเกอร์ส่วนใหญ่ประพฤติตามนี้โดยไม่รู้ตัว และความจริงแล้ว นี่อาจเป็นการสรุปอย่างสมบูรณ์และอย่างรู้ตัวเป็นครั้งแรกที่เคยจดบันทึก
ลักษณะอีกอย่างหนึ่งสำหรับจารีตประเพณีแฝงนี้ก็คือ ทุกคนเชื่อฟังมันอย่างสม่ำเสมอในระดับที่น่าสังเกต (หรือกระทั่งน่าพิศวง) ผู้เขียนได้สังเกตวิวัฒนาการของโครงการโอเพนซอร์สมาหลายร้อยโครงการ และสามารถนับจำนวนครั้งของการฝ่าฝืนอย่างร้ายแรงที่สังเกตเห็นหรือเคยได้ยินได้ด้วยนิ้วมือของผู้เขียน
ยังมีลักษณะที่น่าสนใจประการที่สาม คือจารีตประเพณีเหล่านี้ มีการพัฒนาตามกาลเวลา และพัฒนาในทิศทางที่แน่นอน ทิศทางที่ว่านี้ เป็นไปเพื่อเอื้อให้เกิดความโปร่งใสในสาธารณะมากยิ่งขึ้น เกิดความสังวรณ์ในสาธารณะมากขึ้น และเกิดความเอาใจใส่มากขึ้นในการระวังรักษาการนับผลงานและประวัติโครงการในทางที่ (นอกเหนือจากสิ่งอื่น) สถาปนาความชอบธรรมแก่เจ้าของปัจจุบันของโครงการ
ลักษณะเหล่านี้บ่งบอกว่า จารีตประเพณีเหล่านี้มิได้เกิดขึ้นโดยบังเอิญ แต่เป็นผลของแผนการณ์แฝง หรือแบบแผนที่เกิดซ้ำแล้วซ้ำเล่าในวัฒนธรรมโอเพนซอร์ส โดยเป็นสิ่งพื้นฐานที่สุดต่อแนวทางการทำงาน
มีผู้ให้ความเห็นคนแรกๆ ต่อบทความนี้ ชี้ว่าการเปรียบเทียบกับด้านตรงข้าม ระหว่างวัฒนธรรมแฮ็กเกอร์ในอินเทอร์เน็ตกับวัฒนธรรมนักเจาะ/ขโมย (cracker/pirate) (พวก ``warez d00dz'' ที่มุ่งเจาะเกมและขโมยข้อมูลจากระบบ bulletin board) จะช่วยทำให้เห็นภาพของแบบแผนที่เกิดซ้ำแล้วซ้ำเล่าในวัฒนธรรมทั้งสองได้เป็นอย่างดี เราจะกลับมาพูดถึงพวก d00dz เพื่อเปรียบเทียบในภายหลังในบทความนี้
ล็อคกับกรรมสิทธิ์ที่ดิน
เพื่อที่จะเข้าใจแบบแผนที่กล่าวมา การสังเกตอุปมาอุปไมยในประวัติของจารีตประเพณีนี้ กับสิ่งที่อยู่นอกเหนือขอบเขตของสิ่งที่แฮ็กเกอร์สนใจ อาจจะช่วยได้ นักศึกษาประวัติศาสตร์กฎหมายและปรัชญาการเมืองคงจะนึกออก ว่าทฤษฎีทรัพย์สินที่แฝงอยู่ในแบบแผนดังกล่าวนั้น เหมือนกันทุกประการกับทฤษฎีกฎหมายจารีตประเพณีของแองโกล-อเมริกัน ว่าด้วยสิทธิถือครองที่ดิน!
ตามทฤษฏีดังกล่าว มีสามทางที่จะได้มาซึ่งกรรมสิทธิ์ในที่ดิน:
ตามพื้นที่บริเวณชายขอบ ซึ่งมีที่ดินอยู่แต่ไม่เคยมีเจ้าของ ใครก็ตามสามารถเข้าครอบครองได้ด้วยการ <emphasis>ปักหลัก</emphasis> โดยออกแรงหักร้างถางพง กั้นรั้ว แล้วก็ร้องขอโฉนดของตน
วิธีปกติในการถ่ายโอนที่ดินที่จับจองแล้ว ก็คือการ <emphasis>ถ่ายโอนกรรมสิทธิ์</emphasis> กล่าวคือ รับโฉนดต่อจากเจ้าของเดิม ตามทฤษฎีนี้ แนวคิดเรื่อง `ลำดับการถ่ายโอนกรรมสิทธิ์' จึงสำคัญ สิ่งที่จะพิสูจน์สิทธิครอบครองที่ดินอย่างแท้จริง ก็คือลำดับของโฉนดและการถ่ายโอนย้อนหลังกลับไปจนถึงตอนที่ที่ดินถูกปักหลักเป็นครั้งแรก
และท้ายที่สุด ทฤษฎีกฎหมายจารีตประเพณียอมรับว่า โฉนดที่ดินอาจสูญหายหรือถูกทิ้งร้าง (ตัวอย่างเช่น เมื่อเจ้าของตายลงโดยไร้ทายาท หรือหลักฐานที่ใช้พิสูจน์ลำดับการถ่ายโอนกรรมสิทธิ์ย้อนไปจนถึงที่ดินว่างเปล่าสูญหายไป) ผืนดินที่ถูกทอดทิ้งในลักษณะนี้ อาจมีการอ้างการถือครองโดย <emphasis>การครอบครองปรปักษ์ (adverse possession)</emphasis> กล่าวคือ ใครก็สามารถย้ายเข้าครอบครอง ปรับปรุงที่ดิน และร้องขอโฉนดได้ เหมือนกับการเริ่มปักหลักใหม่
เช่นเดียวกับจารีตประเพณีของแฮ็กเกอร์ ทฤษฎีนี้ก็มีวิวัฒนาการตามธรรมชาติในบริบทที่การควบคุมจากส่วนกลางมีน้อยมากหรือไม่มีเลย มันมีการพัฒนามาตลอดช่วงพันปีจากกฎชนเผ่านอร์สและเยอรมัน แต่เนื่องจากทฤษฎีนี้ได้รับการจัดระบบและให้เหตุผลโดยนักปรัชญาการเมือง จอห์น ล็อค (John Locke) บางครั้งจึงเรียกทฤษฎีนี้ว่า ทฤษฎีทรัพย์สินของล็อค (Lockean theory of property)
ทฤษฎีที่มีตรรกะคล้ายๆ กันนี้ มีแนวโน้มที่จะพัฒนาขึ้นในทุกที่ที่ทรัพย์สินมีคุณค่าทางเศรษฐกิจหรือต่อความอยู่รอด โดยที่ไม่มีอำนาจใดที่แข็งแกร่งพอจะบังคับการจัดสรรทรัพย์สินที่ขาดแคลนแบบรวมศูนย์ได้ เรื่องนี้เกิดแม้แต่กับวัฒนธรรมนักล่าสัตว์หาอาหาร ที่บางครั้งเชื่อกันแบบอุดมคติว่าไม่มีแนวคิดของ `ทรัพย์สมบัติ' ด้วย ตัวอย่างเช่น ตามประเพณีของคนป่าเผ่า !Kung San แห่งทะเลทราย Kgalagadi (เดิมคือ `Karahari') แล้ว จะไม่มีกรรมสิทธิ์ในบริเวณพื้นที่ล่าสัตว์ แต่ <emphasis>มี</emphasis> การถือครองบ่อน้ำและน้ำพุ ภายใต้หลักการที่เทียบเคียงได้กับทฤษฎีของล็อค
ตัวอย่างของเผ่า !Kung San นับว่าให้บทเรียนบางอย่าง เพราะมันแสดงให้เห็นว่า จารีตประเพณีทรัพย์สินของล็อคจะเกิดขึ้นก็ต่อเมื่อ ผลตอบแทนที่คาดหวังจากทรัพยากรมีค่ามากกว่าต้นทุนที่ใช้ในการปกป้อง บริเวณพื้นที่ล่าสัตว์ไม่ได้กลายเป็นทรัพย์สินก็เพราะผลตอบแทนจากการล่านั้นคาดเดาได้ยากมาก และความแปรปรวนก็สูง และ (ถึงแม้จะให้ผลตอบแทนสูง) ก็ไม่ได้จำเป็นต่อการอยู่รอดแบบวันต่อวัน ในขณะที่บ่อน้ำมีความจำเป็นอย่างยิ่งต่อการอยู่รอด และเล็กพอที่จะปกป้องกรรมสิทธิ์ได้
คำว่า `noosphere' ในชื่อบทความนี้ หมายถึงอาณาเขตของความคิด เป็นพื้นที่ของความนึกคิดที่เป็นไปได้ทั้งหมด <link linkend="N">[N]</link> สิ่งที่เราเห็นได้ว่าแฝงอยู่ในจารีตประเพณีกรรมสิทธิ์ของแฮ็กเกอร์ ก็คือทฤษฎีทรัพย์สินของล็อคในชนิดย่อยชนิดหนึ่งของ noosphere กล่าวคือพื้นที่ที่เป็นของโปรแกรมทั้งหลายนั่นเอง ดังนั้น จึงเป็นที่มาของ `homesteading the noosphere' ซึ่งทุกๆ คนที่ตั้งโครงการโอเพนซอร์สต่างกระทำ
Faré Rideau <email>fare@tunes.org</email> ชี้ให้เห็นอย่างถูกต้อง ว่าแฮ็กเกอร์ทั้งหลายไม่ได้ทำงานในอาณาเขตของความคิดล้วนๆ เขายืนยันว่า สิ่งที่แฮ็กเกอร์เป็นเจ้าของคือ <emphasis>โครงการพัฒนาโปรแกรม</emphasis> ซึ่งเป็นศูนย์รวมของแรงงานทางวัตถุ (การพัฒนา, การบริการ ฯลฯ) โดยมีสิ่งอื่นเชื่อมโยงด้วยอย่างชื่อเสียง ความน่าเชื่อถือ ฯลฯ เขาจึงยืนยันว่า พื้นที่ที่ครอบครองโดยโครงการของแฮ็กเกอร์นั้น <emphasis>ไม่ใช่</emphasis> noosphere แต่เป็นคู่ของทั้งสองอย่าง คือเป็นโครงการพัฒนาโปรแกรมที่ทำการสำรวจ noosphere ต่างหาก (ต้องขออภัยต่อนักดาราฟิสิกส์ทั้งหลายที่จะกล่าวว่า คำที่น่าจะถูกต้องตามรากศัพท์ที่ใช้เรียกพื้นที่ควบคู่นี้ น่าจะเป็นคำว่า `ergosphere' หรือ `sphere of work')
ในทางปฏิบัติแล้ว ความแตกต่างระหว่าง noosphere กับ ergosphere ไม่ได้มีความสำคัญต่อจุดมุ่งหมายของสิ่งที่เรากำลังอภิปราย และน่าสงสัยว่า `noosphere' ในความหมายบริสุทธิ์ที่ Faré ยืนยันนั้น พูดได้เต็มปากหรือไม่ว่ามีอยู่จริงในทางที่มีความหมาย คนที่จะเชื่ออาจจะต้องเป็นนักปรัชญาในแนวของพลาโตกระมัง และความแตกต่างระหว่าง noosphere กับ ergosphere จะมีความสำคัญ <emphasis>ในทางปฏิบัติ</emphasis> ก็ต่อเมื่อคุณต้องการจะยืนยันว่าความคิดทั้งหลาย (ที่เป็นองค์ประกอบของ noosphere) ไม่สามารถครอบครองได้ แต่การทำให้เป็นรูปธรรมในรูปโครงการนั้น สามารถครอบครองได้ คำถามนี้นำไปสู่ประเด็นเรื่องทฤษฎีของทรัพย์สินทางปัญญา ซึ่งอยู่นอกเหนือขอบเขตของบทความนี้ (แต่กรุณาอ่าน <link linkend="DF">[DF]</link>)
อย่างไรก็ตาม เพื่อไม่ให้เกิดความสับสน จำเป็นต้องตั้งข้อสังเกตว่า ไม่ว่า noosphere หรือ ergosphere ก็ไม่ใช่สิ่งเดียวกับองค์รวมของสถานที่เสมือนในสื่ออิเล็กทรอนิกส์ที่บางครั้ง (ท่ามกลางความไม่ชอบของแฮ็กเกอร์ส่วนใหญ่) เรียกกันว่า `ไซเบอร์สเปซ' (cyberspace) ทรัพย์สินในโลกที่ว่านั้นอยู่ภายใต้กฎเกณฑ์อีกอย่างหนึ่ง ที่ใกล้เคียงกับโลกของวัตถุมากกว่า กล่าวคือ ใครที่เป็นเจ้าของสื่อหรือเครื่องที่ส่วนของ `ไซเบอร์สเปซ' หนึ่งๆ พักอาศัยอยู่ ก็เป็นเจ้าของไซเบอร์สเปซชิ้นนั้นทันที
ตรรกะของล็อคเกี่ยวกับจารีตประเพณีชี้ให้เห็นอย่างชัดเจนว่า แฮ็กเกอร์โอเพนซอร์สได้สังเกตจารีตประเพณีที่ตนปฏิบัติ เพื่อที่จะปกป้องผลตอบแทนบางอย่างจากความพยายามของตน ผลตอบแทนที่ว่านั้น ต้องมีความหมายมากกว่าความพยายามที่ใช้ในการปักหลักโครงการ มากกว่าต้นทุนของการดูแลประวัติของรุ่นต่างๆ ที่บันทึก `ลำดับการถ่ายโอนกรรมสิทธิ์' และมากกว่าต้นทุนของการแจ้งแก่สาธารณชนและรอคอยก่อนจะถือครองโครงการที่ไร้ผู้ดูแล
นอกจากนี้ `ผลที่ได้' จากโอเพนซอร์สจะต้องเป็นอะไรที่มากกว่าแค่ประโยชน์ใช้สอยของซอฟต์แวร์ แต่เป็นสิ่งอื่นที่จะถูกทำลายหรือเจือจางลงด้วยการฟอร์ก ถ้าประโยชน์ใช้สอยเป็นประเด็นสำคัญเพียงอย่างเดียวแล้วล่ะก็ จะไม่มีจารีตที่ห้ามการฟอร์ก และกรรมสิทธิ์ในโอเพนซอร์สก็จะไม่คล้ายกับสิทธิถือครองที่ดินแต่อย่างใดเลย ในความเป็นจริงแล้ว โลกอีกใบที่ว่านี้ (ที่ซึ่งประโยชน์ใช้สอยเป็นสิ่งที่ได้เพียงอย่างเดียว และการฟอร์กก็ไม่เป็นปัญหาแต่อย่างใด) เป็นโลกที่สัญญาอนุญาตโอเพนซอร์สทั้งหลายที่มีอยู่ต่างบุ้ยใบ้ให้มีด้วยซ้ำ
เราสามารถตัดตัวเลือกบางตัวของชนิดของผลตอบแทนออกไปก่อน เนื่องจากคุณไม่สามารถรวมตัวกันได้อย่างแท้จริงผ่านการติดต่อในระบบเครือข่าย การแสวงหาอำนาจย่อมไม่ใช่คำตอบแน่นอน ในทำนองเดียวกัน วัฒนธรรมโอเพนซอร์สก็ไม่มีอะไรที่คล้ายกับเงินตรา หรือมีระบบเศรษฐศาสตร์ที่ขาดแคลนอะไร ดังนั้น แฮ็กเกอร์ก็ไม่สามารถทำเพื่อสิ่งที่ใกล้เคียงกับความมั่งคั่งทางวัตถุใดๆ (เช่น การสะสมแต้มความจน) ได้เช่นกัน
แม้กระนั้น ก็ยังมีหนทางหนึ่งที่กิจกรรมโอเพนซอร์สสามารถช่วยทำให้บุคคลมั่งคั่งขึ้นได้ ซึ่งเป็นหนทางที่ให้แนวคิดที่มีคุณค่าเกี่ยวกับแรงบันดาลใจเบื้องหลัง ในบางโอกาส ชื่อเสียงที่บุคคลได้รับจากวัฒนธรรมแฮ็กเกอร์สามารถกระจายออกไปในโลกแห่งความเป็นจริงในทางที่มีผลทางเศรษฐกิจได้ มันสามารถทำให้คุณได้งานดีๆ หรือได้รับการทำสัญญาเป็นที่ปรึกษา หรือได้เขียนตำราก็ได้
อย่างไรก็ดี ผลข้างเคียงชนิดนี้มีน้อยมาก และแทบจะไม่มีเลยสำหรับแฮ็กเกอร์ส่วนใหญ่ จนไม่อาจจะเชื่อได้ว่าเป็นคำอธิบายทั้งหมด ถึงแม้เราจะไม่สนใจคำประท้วงหลายต่อหลายครั้งของแฮ็กเกอร์ ว่าพวกเขาไม่ได้ทำเพื่อเงิน แต่มาจากอุดมคติหรือความรักก็ตาม
แม้กระนั้น หนทางที่ผลข้างเคียงทางเศรษฐกิจที่ว่าจะมีผลก็น่าตรวจสอบ ต่อจากนี้ เราจะพบว่า ความเข้าใจในพลวัตของชื่อเสียงภายในวัฒนธรรมโอเพนซอร์ส <emphasis>โดยตัวของมันเอง</emphasis> ก็สามารถอธิบายอะไรๆ ได้ดีทีเดียว
แวดวงแฮ็กเกอร์ในฐานะวัฒนธรรมการให้
เพื่อที่จะเข้าใจบทบาทของชื่อเสียงในวัฒนธรรมโอเพนซอร์ส การย้ายจากเรื่องประวัติศาสตร์ออกไปสู่มานุษยวิทยาและเศรษฐศาสตร์ แล้วตรวจสอบความแตกต่างระหว่าง <emphasis>วัฒนธรรมการแลกเปลี่ยน (exchange culture)</emphasis> กับ <emphasis>วัฒนธรรมการให้ (gift culture)</emphasis> อาจจะช่วยได้ดี
มนุษย์มีแรงขับโดยกำเนิดที่จะช่วงชิงสถานภาพทางสังคม แรงขับนี้เกาะเกี่ยวแนบแน่นกับประวัติศาสตร์วิวัฒนาการของเรา 90% ของประวัติศาสตร์เผ่าพันธุ์มนุษย์ก่อนยุคเกษตรกรรมนั้น บรรพบุรุษของเราอาศัยอยู่เป็นกลุ่มนักล่าสัตว์หาอาหารเร่ร่อน ผู้ที่อยู่ในสถานภาพสูงๆ (คือคนที่มีความสามารถในการสร้างพันธมิตร และโน้มน้าวผู้อื่นให้ร่วมมือ) จะได้คู่ที่แข็งแรงที่สุด และได้ครอบครองอาหารที่ดีที่สุด แรงขับเพื่อสถานภาพนี้ แสดงตัวออกมาในหลายรูปแบบ ขึ้นอยู่กับระดับความขาดแคลนของสิ่งยังชีพเป็นสำคัญ
วิธีที่มนุษย์รวมกลุ่มกันเกือบทั้งหมด เป็นการปรับตัวตามความขาดแคลนและตามความต้องการ แต่ละวิธีก็จะมีวิธีการได้มาซึ่งสถานภาพทางสังคมที่ต่างกัน
วิธีที่ง่ายที่สุดคือ <emphasis>ระบบยศศักดิ์</emphasis> ในระบบยศศักดิ์นี้ สิ่งที่ขาดแคลนจะถูกจัดสรรโดยอำนาจศูนย์กลาง โดยมีการสนับสนุนด้วยกำลัง ระบบยศศักดิ์ เป็นวิธีที่ปรับตัวตามขนาดได้แย่มากๆ <link linkend="Mal">[Mal]</link> จะเกิดความป่าเถื่อนและไร้ประสิทธิภาพเมื่อขนาดของกลุ่มโตขึ้น ด้วยเหตุนี้ ระบบยศศักดิ์ในกลุ่มที่ใหญ่กว่าครอบครัวใหญ่มักจะกลายเป็นภาระของเศรษฐกิจในระดับที่ใหญ่กว่าที่ต่างชนิดกันเสมอ ในระบบยศศักดิ์ สถานภาพทางสังคมจะกำหนดโดยการเข้าถึงอำนาจเป็นปฐม
สังคมของเราเป็น <emphasis>เศรษฐกิจแลกเปลี่ยน (exchange economy)</emphasis> เป็นส่วนใหญ่ ระบบนี้เป็นการปรับตัวอย่างซับซ้อนต่อภาวะขาดแคลน ซึ่งปรับตัวตามขนาดได้ดี ต่างจากแบบยศศักดิ์ การจัดสรรสิ่งขาดแคลนจะกระทำในลักษณะกระจายอำนาจ ผ่านการค้าขายแลกเปลี่ยน และความร่วมมือโดยสมัครใจ (และอันที่จริง ผลโดยรวมของความต้องการแข่งขัน จะออกมาในรูปพฤติกรรมการสร้างความร่วมมือนั่นเอง) ในเศรษฐกิจแลกเปลี่ยน สถานภาพทางสังคมจะกำหนดโดยการมีอำนาจควบคุมสิ่งต่างๆ (ซึ่งไม่จำเป็นต้องเป็นวัตถุ) เพื่อใช้สอยหรือแลกเปลี่ยนเป็นปฐม
ผู้คนส่วนใหญ่มีมโนภาพของทั้งสองแบบที่กล่าวข้างต้นแฝงอยู่ รวมทั้งปฏิกิริยาที่มีต่อกัน ตัวอย่างเช่น รัฐ กองทหาร และอาชญากรรมที่มีการจัดตั้ง ก็คือระบบยศศักดิ์ที่เกาะกินเศรษฐกิจแลกเปลี่ยนในวงกว้างที่เรียกกันว่า `ตลาดเสรี' อย่างไรก็ดี ยังมีรูปแบบที่สาม ที่แตกต่างโดยสิ้นเชิงจากทั้งสองแบบ และมักไม่ได้มีการยอมรับกันนอกจากนักมานุษยวิทยา คือ <emphasis>วัฒนธรรมการให้ (gift culture)</emphasis>
วัฒนธรรมการให้ไม่ใช่การปรับตัวตามความขาดแคลน แต่ตามความเหลือเฟือ วัฒนธรรมนี้จะเกิดกับประชากรที่ไม่ได้มีปัญหาความขาดแคลนทางวัตถุเกี่ยวกับสิ่งยังชีพมากมายอะไร เราสามารถสังเกตเห็นวัฒนธรรมการให้จริงได้ในวัฒนธรรมอะบอริจินที่อาศัยในเขตที่สภาพอากาศเบาสบายและมีอาหารบริบูรณ์ และเรายังสามารถสังเกตเห็นวัฒนธรรมนี้ได้ในบางชนชั้นของสังคมเรา โดยเฉพาะในธุรกิจการแสดงและในหมู่คนร่ำรวย
ความเหลือเฟือทำให้ความสัมพันธ์แบบยศศักดิ์ดำรงอยู่ได้ยาก และการแลกเปลี่ยนกลายเป็นเกมที่แทบจะไร้ความหมาย ในวัฒนธรรมการให้นี้ สถานภาพทางสังคมไม่ได้กำหนดโดยสิ่งที่คุณควบคุม แต่โดย <emphasis>สิ่งที่คุณให้ไป</emphasis>
ดังนั้น จึงเป็นที่มาของงานฉลอง potlatch ของหัวหน้าเผ่าชาว Kwakiutl เป็นที่มาของการแสดงออกอย่างถี่ถ้วนและมักปรากฏต่อสาธารณชนของเหล่าเศรษฐี ถึงความรักที่มีต่อมวลมนุษย์ และเป็นที่มาของความพยายามอันยาวนานของแฮ็กเกอร์ที่จะสร้างโค้ดโอเพนซอร์สคุณภาพสูง
ด้วยการตรวจสอบดังนี้ จึงเห็นได้ชัดว่า สังคมของแฮ็กเกอร์โอเพนซอร์สแท้ที่จริงก็คือวัฒนธรรมการให้นั่นเอง ภายในสังคมนี้ ไม่มีความขาดแคลน `สิ่งจำเป็นสำหรับยังชีพ' กล่าวคือ เนื้อที่ดิสก์ ความเร็วของเครือข่าย และพลังของหน่วยประมวลผล อย่างรุนแรงอะไร มีการแบ่งปันซอฟต์แวร์อย่างเสรี ความเหลือเฟือนี้ ทำให้เกิดสภาวการณ์ที่มาตรวัดความสำเร็จในการแข่งขันมีอยู่เพียงอย่างเดียว คือชื่อเสียงในหมู่ชน
อย่างไรก็ดี ลำพังการสังเกตนี้เพียงอย่างเดียว ยังไม่เพียงพอที่จะอธิบายลักษณะของวัฒนธรรมแฮ็กเกอร์ นักเจาะระบบและ warez d00dz ก็มีวัฒนธรรมการให้ที่งอกงามในสื่อ (อิเล็กทรอนิกส์) เดียวกันกับของแฮ็กเกอร์ แต่พฤติกรรมของกลุ่มนี้จะแตกต่างอย่างมาก บุคลิกกลุ่มในวัฒนธรรมนั้นจะรุนแรงและปิดตัวกว่าในกลุ่มแฮ็กเกอร์มาก พวกเขาจะเก็บความลับไว้กับตัวมากกว่าจะแบ่งปัน เราจะพบกลุ่มนักเจาะระบบที่แจกจ่ายโปรแกรมไร้ซอร์สที่เจาะซอฟต์แวร์อื่น มากกว่าที่จะบอกเคล็ดลับว่าทำได้อย่างไร (หากสนใจรายละเอียดเบื้องลึกของพฤติกรรมนี้ อ่าน <link linkend="lw">[LW]</link>)
ในกรณีที่คุณยังไม่ประจักษ์ การเปรียบเทียบนี้แสดงให้เห็นว่า มีมากกว่าหนึ่งวิธีที่จะดำเนินวัฒนธรรมการให้ ประวัติศาสตร์และคุณค่าเป็นสิ่งสำคัญ ผู้เขียนได้สรุปประวัติของวัฒนธรรมแฮ็กเกอร์ไว้ใน <citetitle>A Brief History of Hackerdom</citetitle><link linkend="HH">[HH]</link> วิธีที่วัฒนธรรมนี้ก่อร่างขึ้นมาได้ไม่ใช่สิ่งลึกลับอะไร เหล่าแฮ็กเกอร์ได้กำหนดวัฒนธรรมของตนเองด้วยทางเลือกจำนวนหนึ่งเกี่ยวกับ <emphasis>รูปแบบ</emphasis> ที่พวกเขาจะแข่งขันกัน และรูปแบบที่ว่านี้แหละ ที่เราจะตรวจสอบกันต่อไปในส่วนที่เหลือของบทความนี้
ความหรรษาแห่งการแฮ็ก
อนึ่ง ในการวิเคราะห์ `เกมแห่งชื่อเสียง' (reputation game) นี้ ผู้เขียนมิได้มีเจตนาที่จะละเลยความพึงใจทางศิลปะของการออกแบบซอฟต์แวร์ที่สวยงามและสร้างให้มันใช้งานได้ แฮ็กเกอร์ทุกคนต่างได้ผ่านประสบการณ์ความพึงใจนี้ และเติบโตมากับมัน ใครที่ไม่เคยเห็นมันเป็นแรงจูงใจที่สลักสำคัญ ก็ไม่มีทางมาเป็นแฮ็กเกอร์แต่แรกแล้ว ไม่ต่างอะไรกับการที่คนที่ไม่ได้รักดนตรีไม่มีทางเป็นนักประพันธ์เพลง
ดังนั้น บางทีเราควรจะพิจารณาการอธิบายพฤติกรรมแฮ็กเกอร์ในแบบที่ใช้ความหรรษาล้วนๆ ของการเป็นช่างฝีมือเป็นแรงจูงใจหลักดูบ้าง การอธิบายด้วย `ความเป็นช่างฝีมือ' นี้ จะต้องอธิบายจารีตประเพณีแฮ็กเกอร์ว่าเป็นหนทางที่ทั้งให้โอกาสสูงสุดในการเป็นช่างฝีมือ และให้คุณภาพของผลลัพธ์สูงสุดด้วย คำอธิบายนี้จะขัดแย้ง หรือให้ผลลัพธ์ที่ต่างจากการอธิบายโดยใช้เกมแห่งชื่อเสียงหรือไม่?
ก็ไม่เชิง ในการตรวจสอบคำอธิบายโดยใช้ความเป็นช่างฝีมือ เราก็กลับมาที่ปัญหาเดิม ที่บังคับความเป็นแฮ็กเกอร์ให้ดำเนินในแบบวัฒนธรรมการให้อยู่เช่นเดิม คนคนหนึ่งจะทำงานให้มีคุณภาพสูงสุดได้อย่างไร ถ้าไม่มีมาตรวัดคุณภาพ? และถ้าระบบเศรษฐศาสตร์ไร้ซึ่งความขาดแคลนแล้ว จะมีมาตรวัดใดอีก นอกจากการประเมินผลของคนอื่น? ปรากฏว่า ท้ายที่สุดแล้ว วัฒนธรรมช่างฝีมือก็ต้องจัดโครงสร้างตัวเองโดยอาศัยเกมแห่งชื่อเสียงอยู่ดี และอันที่จริง เราสามารถสังเกตความเปลี่ยนแปลงนี้ได้ในวัฒนธรรมช่างฝีมือในอดีตทั้งหลาย ตั้งแต่สมาคมวิชาชีพในยุคกลางเป็นต้นมา
ในด้านหนึ่งที่สำคัญ คำอธิบายโดยใช้ความเป็นช่างฝีมือนั้น อ่อนกว่าแบบ `วัฒนธรรมการให้' อยู่ เพราะลำพังตัวมันเอง ก็ไม่ได้ช่วยอธิบายความขัดแย้งในตัวเองที่ตั้งต้นบทความนี้เลย
และท้ายที่สุด แรงจูงใจจากความเป็นช่างฝีมือเอง ก็อาจไม่ได้ห่างไกลในทางจิตวิทยาจากเกมแห่งชื่อเสียงอย่างที่เราคิด ลองนึกภาพโปรแกรมอันสวยงามของคุณถูกล็อกเก็บไว้ในลิ้นชัก และไม่เคยถูกใช้อีกเลย แล้วลองนึกภาพที่มันถูกใช้งานจริงด้วยความพอใจของผู้คน แบบไหนที่คุณพึงใจ?
แม้กระนั้น เราจะยังคงให้ความสนใจกับคำอธิบายที่ใช้ความช่างฝีมือต่อไป เพราะมันเข้ากับสามัญสำนึกของแฮ็กเกอร์หลายคน และยังอธิบายบางแง่มุมของพฤติกรรมของแต่ละบุคคลได้ดี <link linkend="HT">[HT]</link>
หลังจากที่ผู้เขียนได้เผยแพร่รุ่นแรกของบทความนี้บนอินเทอร์เน็ต มีผู้ขอสงวนนามท่านหนึ่งตอบกลับมา ให้ความเห็นว่า: ``คุณไม่อาจทำงานเพื่อให้ได้ชื่อเสียง แต่ชื่อเสียงจะเป็นสิ่งตอบแทน พร้อมกับสิ่งอื่นๆ ถ้าคุณทำงานดีจริง'' นับเป็นประเด็นละเอียดอ่อนและสำคัญ แรงจูงใจจากชื่อเสียงจะยังคงทำงานต่อไป ไม่ว่าช่างฝีมือจะรู้ตัวหรือไม่ ด้วยเหตุนี้ ท้ายที่สุดแล้ว ไม่ว่าแฮ็กเกอร์จะเข้าใจพฤติกรรมของตัวเองว่าเป็นส่วนหนึ่งของเกมแห่งชื่อเสียงหรือไม่ แต่พฤติกรรมของเขาก็จะถูกเกมควบคุมอยู่ดี
ผู้แสดงความเห็นท่านอื่นๆ ได้เชื่อมโยงรางวัล คือความเคารพจากบุคคลอื่น และความหรรษาแห่งการแฮ็ก เข้ากับความต้องการเหนือระดับการเลี้ยงชีวิตรอด ตามทฤษฎี `ลำดับชั้นของคุณค่า' แห่งแรงจูงใจของมนุษย์อันมีชื่อเสียงของ อับราฮัม มาสโลว์ (Abraham Maslow) <link linkend="MH">[MH]</link> ตามทัศนะนี้ ความหรรษาแห่งการแฮ็กได้สนองความต้องการตระหนักในศักยภาพตน (self-actualization) หรือความบรรลุขั้นสูง (transcendence) ซึ่งจะไม่มีทางแสดงออกอย่างมั่นคง จนกว่าความต้องการในระดับต่ำลงไป (รวมถึงความปลอดภัยทางกายภาพ และ `ความเป็นส่วนหนึ่งของสังคม' (belongingness) หรือความเคารพจากคนรอบข้าง) จะได้รับการตอบสนองขั้นต่ำเป็นอย่างน้อย ดังนั้น เกมแห่งชื่อเสียงจึงอาจสำคัญอย่างยิ่งยวด ในการให้บริบททางสังคมที่ทำให้ความหรรษาแห่งการแฮ็กสามารถ <emphasis>เปลี่ยน</emphasis> เป็นแรงกระตุ้นหลักของแต่ละบุคคล
ด้านต่างๆ อันหลากหลายของชื่อเสียง
มีเหตุผลหลายข้อที่ปรากฏในทุกๆ วัฒนธรรมการให้ ที่ทำให้ชื่อเสียง (เกียรติยศ) มีค่าควรแก่การได้มา:
ข้อแรก ซึ่งชัดเจนที่สุด คือชื่อเสียงที่ดีในกลุ่มเป็นรางวัลที่สำคัญที่สุด เราถูกกำหนดอย่างแยกไม่ออกให้ต้องประสบกับมันในแบบนี้ ตามเหตุแห่งวิวัฒนาการที่เราได้กล่าวมาแล้ว (หลายคนเรียนรู้ที่จะหันเหแรงขับสู่เกียรติยศไปสู่สิ่งต่างๆ ที่สังคมยอมรับ ซึ่งไม่มีส่วนเกี่ยวข้องกับกลุ่มที่มองเห็นได้ เช่น ``เกียรติ'', ``ความมั่นคงในคุณธรรม'', ``ความเคร่งในศีลธรรม'' ฯลฯ แต่นี่ไม่ได้เปลี่ยนกลไกเบื้องหลังแต่อย่างใด)
ข้อสอง เกียรติยศเป็นทางที่ดี (และเป็น <emphasis>ทางเดียว</emphasis> ในเศรษฐศาสตร์การให้) ที่จะดึงดูดความสนใจและความร่วมมือจากคนอื่น ถ้าคุณเป็นที่รู้จักในความเอื้ออารี ความฉลาด ความไม่เอารัดเอาเปรียบ ความเป็นผู้นำ หรือในลักษณะที่ดีอย่างอื่น ก็เป็นการง่ายที่จะโน้มน้าวผู้อื่นให้เชื่อ ว่าเขาจะได้ประโยชน์ถ้าร่วมมือกับคุณ
ข้อสาม ถ้าเศรษฐศาสตร์การให้ของคุณมีการติดต่อ หรือเกี่ยวพันกับเศรษฐศาสตร์แลกเปลี่ยน หรือระบบยศศักดิ์ ชื่อเสียงของคุณก็อาจกระจายออกไปและพาคุณไปสู่สถานภาพที่สูงขึ้นในระบบเหล่านั้น
นอกเหนือจากเหตุผลทั่วไปเหล่านี้ เงื่อนไขที่แปลกประหลาดของวัฒนธรรมแฮ็กเกอร์ยังทำให้เกียรติยศมีคุณค่ามากกว่าในวัฒนธรรมการให้ `ในโลกแห่งความเป็นจริง' ยิ่งขึ้นไปอีก
`เงื่อนไขแปลกประหลาด' หลักๆ ก็คือ สิ่งที่คนคนหนึ่งให้ออกไป (หรือตีความอีกอย่าง คือสิ่งบ่งชี้ที่มองเห็นได้ ถึงแรงกายแรงใจและเวลาที่คนคนหนึ่งให้ไป) มีความซับซ้อนมากๆ คุณค่าของมันไม่ได้มีอะไรชัดเจนใกล้เคียงกับคุณค่าในการให้วัตถุสิ่งของ หรือเงินตราในเศรษฐศาสตร์แลกเปลี่ยนเลย เป็นความยากลำบากกว่ามากที่จะแยกความแตกต่างระหว่างของขวัญที่ดีกับของขวัญที่แย่โดยไร้อคติ ด้วยเหตุนี้ ความสำเร็จของข้อเสนอขอเลื่อนสภานภาพของผู้ให้ จึงขึ้นอยู่กับวิจารณญาณของผู้อื่นอย่างละเอียดอ่อน
ความแปลกประหลาดอีกประการหนึ่ง คือความบริสุทธิ์กว่าของวัฒนธรรมโอเพนซอร์ส วัฒนธรรมการให้ส่วนใหญ่สามารถประนีประนอมได้ ไม่ว่าจะด้วยความสัมพันธ์แบบเศรษฐศาสตร์แลกเปลี่ยนอย่างการแลกด้วยสินค้าหรูหรา หรือจะด้วยความสัมพันธ์แบบเศรษฐศาสตร์ยศศักดิ์อย่างเรื่องครอบครัวหรือหมู่ญาติ ไม่ปรากฏว่ามีสิ่งที่คล้ายกันนี้อย่างเห็นได้ชัดในวัฒนธรรมโอเพนซอร์สเลย ดังนั้น หนทางที่จะได้สถานภาพนอกจากชื่อเสียงในหมู่ชนแล้ว ก็ไม่มีอีกเลย
สิทธิถือครองและแรงกระตุ้นจากชื่อเสียง
เรากำลังมาถึงจุดที่จะนำเอาการวิเคราะห์ที่ผ่านมา มารวมกันเป็นลักษณะที่สอดคล้องต้องกันของจารีตประเพณีการถือครองของแฮ็กเกอร์ เราได้เข้าใจผลที่ได้จากการปักหลัก noosphere มาแล้ว มันคือชื่อเสียงในหมู่ชนในวัฒนธรรมการให้ของแฮ็กเกอร์ พร้อมทั้งกำไรทางอ้อมและผลข้างเคียงที่ตามมา
จากความเข้าใจตรงนี้ เราสามารถวิเคราะห์จารีตประเพณีทรัพย์สินของวัฒนธรรมแฮ็กเกอร์ตามทฤษฎีของล็อค ว่าเป็นหนทางหนึ่งของ <emphasis>การเพิ่มแรงกระตุ้นจากชื่อเสียงให้ถึงขีดสุด</emphasis> เป็นหนทางแห่งการประกันการให้เครดิตต่อบุคคล ว่าได้ให้แก่ผู้ที่ควรให้ และไม่ให้แก่ผู้ที่ไม่ควรให้
ข้อห้ามสามข้อที่เราสังเกตมาข้างต้น เข้ากันได้ดีมากกับการวิเคราะห์นี้ ชื่อเสียงของบุคคลจะกระทบกระเทือนอย่างไม่เป็นธรรม ถ้ามีผู้อื่นมาขโมยหรือปู้ยี่ปู้ยำงาน ข้อห้ามเหล่านี้ (และจารีตประเพณีที่เกี่ยวข้อง) พยายามที่จะป้องกันไม่ให้เกิดเหตุดังกล่าว (หรือถ้าจะพูดให้ตรงแนวปฏิบัติกว่านั้นก็คือ แฮ็กเกอร์จะหลีกเลี่ยงการฟอร์ก หรือการทำแพตช์เถื่อนกับโครงการของผู้อื่น เพื่อที่จะสามารถปฏิเสธความชอบธรรมของพฤติกรรมเดียวกันที่เกิดกับตัวเองนั่นเอง)
การฟอร์กโครงการเป็นสิ่งที่เลว เพราะถือเป็นการทำให้ผู้ที่มาร่วมก่อนการฟอร์กต้องเสี่ยงกับเรื่องชื่อเสียง โดยที่สามารถทำได้เพียงแค่การเข้าร่วมทั้งสองโครงการย่อยพร้อมๆ กันหลังการฟอร์ก (แต่การกระทำเช่นนี้ ออกจะชวนสับสน หรือยากเกินกว่าจะทำได้จริง)
การแจกจ่ายแพตช์เถื่อน (หรือที่แย่กว่านั้น คือไบนารีเถื่อน) ทำให้เจ้าของต้องเผชิญความเสี่ยงเรื่องชื่อเสียงอย่างไม่เป็นธรรม เพราะถึงแม้โค้ดที่เป็นทางการจะถูกต้องสมบูรณ์ทุกประการ แต่เจ้าของก็ต้องมาตอบโต้คำวิพากษ์วิจารณ์กับบั๊กที่เกิดจากแพตช์เถื่อน (แต่อ่าน <link linkend="rp">[RP]</link>)
การลักลอบคัดชื่อบางคนออกจากโครงการ ถือเป็นอาชญากรรมร้ายแรงในบริบทของวัฒนธรรม การกระทำดังกล่าวเป็นการขโมยของขวัญของเหยื่อ แล้วมานำเสนอว่าเป็นของขวัญของโจรเอง
แน่นอนว่าการฟอร์กโครงการหรือแจกจ่ายแพตช์เถื่อน ยังเป็นการจู่โจมชื่อเสียงของกลุ่มนักพัฒนาแรกเริ่มอีกด้วย ถ้าผู้เขียนฟอร์กหรือทำแพตช์เถื่อนกับโครงการของคุณ ก็เหมือนกับผู้เขียนพูดว่า: ``คุณตัดสินใจผิดพลาด โดยไม่สามารถนำพาโครงการไปยังจุดที่ฉันพาไปได้'' และใครก็ตามที่ใช้โปรแกรมชุดที่ผู้เขียนฟอร์ก ก็เท่ากับรับรองการท้าทายของผู้เขียนไปด้วย แต่การท้าทายเช่นนี้ โดยตัวของมันเองก็อาจเป็นการท้าทายที่เป็นธรรม ถึงแม้จะรุนแรงไปหน่อย มันคือความแหลมคมขั้นสุดยอดของการตรวจสอบโดยหมู่ชน ดังนั้น มันจึงไม่เพียงพอในตัวเองที่จะนับเป็นข้อห้าม ถึงแม้มันจะช่วยสนับสนุนข้อห้ามอย่างไม่ต้องสงสัย
พฤติกรรมในข้อห้ามทั้งสามก่อความเสียหายโดยรวมต่อชุมชนโอเพนซอร์สไม่แพ้ความเสียหายโดยส่วนตัวต่อเหยื่อ มันทำลายชุมชนทั้งหมด ด้วยการลดโอกาสความเป็นไปได้ในสายตาของผู้ที่จะเข้าร่วม ที่การให้หรือทำงานใดๆ จะได้รับผลตอบแทนที่ดี
มีคำอธิบายแบบอื่นที่น่าตั้งข้อสังเกตไว้ ณ ที่นี้ เกี่ยวกับข้อห้ามสองในสามข้อดังกล่าว
ข้อแรก แฮ็กเกอร์มักจะอธิบายความชิงชังการฟอร์กโครงการ ด้วยการคร่ำครวญถึงการทำงานซ้ำซ้อนอันสิ้นเปลืองที่จะเกิดขึ้น เมื่อโครงการลูกทั้งสองพัฒนาอย่างขนานกันไปในอนาคต และยังตั้งข้อสังเกตด้วยว่า การฟอร์กมักจะแบ่งแยกชุมชนนักพัฒนาออกจากกัน ทำให้โครงการลูกทั้งสองเหลือกำลังสมองน้อยลงกว่าโครงการเดิม
ผู้แสดงความเห็นท่านหนึ่งชี้ว่า เป็นไปได้ยากมากที่โครงการลูกที่แยกตัวมากกว่าหนึ่งจะอยู่รอดได้ด้วย `ส่วนแบ่งตลาด' ที่มากพอในระยะยาว เหตุผลนี้ ได้ช่วยเสริมแรงจูงใจของทุกฝ่ายที่จะร่วมมือกัน และหลีกเลี่ยงการฟอร์ก เพราะยากที่จะคาดเดาล่วงหน้า ว่าใครจะเป็นฝ่ายพ่ายแพ้ และมองดูงานของตนเองหายไปต่อหน้าต่อตา หรือจ่อมจมอยู่ในซอกหลืบอันลี้ลับ
มีผู้ชี้ด้วยว่า เพียงข้อเท็จจริงง่ายๆ ที่ว่า การฟอร์กมีแนวโน้มจะก่อความตึงเครียดและการทะเลาะวิวาท ก็เพียงพอแล้วที่จะกระตุ้นแรงกดดันทางสังคมที่จะต้านมัน ความตึงเครียดและการทะเลาะวิวาททำลายการทำงานเป็นทีม อันเป็นสิ่งสำคัญสำหรับผู้เข้าร่วมแต่ละคนที่จะไปให้ถึงเป้าหมาย
ความไม่ชอบแพตช์เถื่อน ก็มักจะได้รับคำอธิบายด้วยการคัดค้าน ว่ามันจะก่อให้เกิดปัญหาความเข้ากันได้ระหว่างรุ่นถัดๆ มา ทำให้การติดตามบั๊กยุ่งยากอย่างสาหัส และเป็นการโยนภาระให้กับผู้ดูแล ซึ่งมีงานมากพออยู่แล้วกับการไล่แก้ความผิดพลาด <emphasis>ที่เกิดจากตัวเอง</emphasis>
คำอธิบายเหล่านี้มีส่วนจริงอยู่ไม่น้อย และยังช่วยเสริมหลักการของล็อคเรื่องการถือครองอีกด้วย แต่ถึงแม้จะดูหลักแหลม มันก็ยังไม่สามารถอธิบายได้ ว่าทำไมจึงมีการแสดงอารมณ์และการแบ่งฝ่ายอย่างมากมาย เมื่อข้อห้ามถูกบิดเบือนหรือละเมิดในบางโอกาส ไม่เฉพาะจากฝ่ายที่เสียหาย แต่ทั้งจากฝ่ายสนับสนุนและผู้สังเกตการณ์ที่มักแสดงปฏิกิริยาอย่างแข็งกร้าว ความโหดเหี้ยมต่อการทำงานซ้ำซ้อนและต่อความน่ารำคาญของการดูแลโค้ด ไม่น่าจะเพียงพอที่จะอธิบายพฤติกรรมที่เห็นได้
จากนั้น เรายังมีข้อห้ามที่สามอีกด้วย เป็นเรื่องยากที่จะเข้าใจ ว่าจะมีอะไรนอกเหนือจากเกมแห่งชื่อเสียงอีก ที่จะอธิบายข้อนี้ เราจะได้เห็นกันต่อไป ถึงการที่ข้อห้ามข้อนี้ไม่ได้ถูกวิเคราะห์เจาะลึกมากไปกว่าคำว่า ``ก็มันไม่ยุติธรรม'' ดังจะกล่าวถึงในหัวข้อถัดไป
ปัญหาของอัตตา
ในตอนต้นของบทความนี้ ผู้เขียนได้กล่าวถึงการเรียนรู้ที่ปรับเปลี่ยนได้ของวัฒนธรรม ว่ามักจะสวนทางกับอุดมการณ์ในจิตสำนึก เราได้เห็นตัวอย่างหลักๆ ของเรื่องนี้มาแล้วจากเรื่องของจารีตประเพณีการถือครองตามทฤษฎีของล็อค ที่มีการดำเนินตามอย่างกว้างขวาง ถึงแม้จะเป็นการฝ่าฝืนเจตนารมณ์ที่ระบุไว้ในสัญญาอนุญาตมาตรฐานทั้งหลายก็ตาม
ผู้เขียนยังได้สังเกตอีกตัวอย่างหนึ่งที่น่าสนใจของปรากฏการณ์นี้ เมื่อได้สนทนาถึงการวิเคราะห์เกมแห่งชื่อเสียงกับเหล่าแฮ็กเกอร์ คือการที่แฮ็กเกอร์หลายคนต่อต้านการวิเคราะห์นี้ และแสดงความลังเลอย่างเห็นได้ชัด ที่จะยอมรับว่าพฤติกรรมของพวกเขาถูกกระตุ้นด้วยความกระหายชื่อเสียงในหมู่ชน หรือที่ผู้เขียนขอเรียกอย่างไม่ได้พิจารณาถี่ถ้วนนักว่า `การสนองอัตตา' (ego satisfaction) ไปก่อน
ตัวอย่างนี้แสดงให้เห็นถึงประเด็นหนึ่งที่สำคัญในวัฒนธรรมแฮ็กเกอร์ วัฒนธรรมนี้ไม่เชื่อถือและเหยียดหยามการใช้อัตตาและแรงกระตุ้นจากอัตตา การโฆษณาตัวเองมีแนวโน้มที่จะถูกวิพากษ์วิจารณ์อย่างไร้ความปรานี แม้จะเป็นกรณีที่ชุมชนอาจมีทีท่าที่จะได้ผลประโยชน์บางอย่างก็ตาม และอันที่จริง ความเหยียดหยามนี้รุนแรงจนกระทั่ง `คนตำแหน่งใหญ่' และผู้อาวุโสของวัฒนธรรมนี้ จำเป็นต้องพูดจานุ่มนวลและถ่อมตัวอย่างมีอารมณ์ขันแทบทุกครั้ง เพื่อรักษาสถานภาพของตัวเองไว้ การที่ทัศนคติแบบนี้สอดรับกันกับโครงสร้างของแรงจูงใจที่ดำเนินบนพื้นฐานของอัตตาเกือบทั้งหมดอย่างเห็นได้ชัดได้ จึงเป็นเรื่องที่ต้องการคำอธิบายเป็นอย่างมาก
แน่นอนว่าส่วนใหญ่ของเรื่องนี้มีที่มาจากทัศนคติแง่ลบของชาวยุโรปและอเมริกันที่มีต่อ `อัตตา' ส่วนผสมของวัฒนธรรมของแฮ็กเกอร์ส่วนใหญ่สอนพวกเขาว่า การปรารถนาการสนองอัตตาเป็นแรงกระตุ้นที่ผิด (หรืออย่างน้อยก็ไม่มีวุฒิภาวะ) อัตตาเช่นนั้น อย่างดีที่สุดก็พอทนได้แบบอิหลักอิเหลื่อในหมู่พวกเอาแต่ใจตัวด้วยกันเท่านั้น และมักจะแสดงถึงความป่วยทางจิต เฉพาะการแสดงออกอย่างเหมาะสมและการเปลี่ยนรูปแบบ เช่น ``ชื่อเสียงในหมู่ชน'', ``ความเคารพตนเอง'', ``ความเป็นมืออาชีพ'' หรือ ``ความภาคภูมิในความสำเร็จ'' เท่านั้น ที่จะเป็นที่ยอมรับ
ผู้เขียนสามารถเขียนบทความได้อีกเรื่องหนึ่งทีเดียว เกี่ยวกับรากอันง่อนแง่นของมรดกทางวัฒนธรรมส่วนนี้ และภัยมากมายของการหลอกตัวเองของเรา โดยเชื่อ (อย่างตรงข้ามกับหลักฐานทางจิตวิทยาและพฤติกรรมทั้งหมด) ว่าพวกเรามีแรงกระตุ้นที่ `ไร้อัตตา' อย่างแท้จริงจริงๆ บางทีผู้เขียนอาจจะเขียนไปแล้ว ถ้า Friedrich Wilhelm Nietzsche และ Ayn Rand ไม่ได้เขียนงานอันยอดเยี่ยม (ไม่ว่าพวกเขาจะล้มเหลวในงานอื่นเช่นไรก็ตาม) ในการทำลายภาพของ `ความรักผู้อื่น' ลงเหลือเพียงความสนใจส่วนตัวชนิดที่ไม่รู้ตัวเท่านั้น
แต่ผู้เขียนไม่ได้มุ่งเขียนเกี่ยวกับปรัชญาหรือจิตวิทยาเกี่ยวกับจริยธรรมในที่นี้ ดังนั้น ผู้เขียนจะเพียงสังเกตชนิดเล็กๆ ของภัยของความเชื่อที่ว่าอัตตาเป็นสิ่งเลว ซึ่งก็คือว่า: มันได้สร้างความยากลำบากทางอารมณ์ต่อแฮ็กเกอร์ทั้งหลาย ที่จะทำความเข้าใจพลวัตทางสังคมของวัฒนธรรมของตนเองอย่างรู้ตัว!
แต่เรายังตรวจสอบเส้นทางนี้ไม่เรียบร้อยดีนัก ข้อห้ามของวัฒนธรรมรอบข้างต่อพฤติกรรมที่ขับเคลื่อนด้วยอัตตา ถูกเน้นในวัฒนธรรม (ย่อย) ของแฮ็กเกอร์มากเสียจนน่าสงสัยว่ามีกลไกแบบแปรเปลี่ยนพิเศษบางอย่างสำหรับแฮ็กเกอร์ แน่นอนว่าข้อห้ามที่ว่านี้จะอ่อนกว่า (หรือไม่มีอยู่เลย) ในวัฒนธรรมการให้อื่น เช่น วัฒนธรรมในหมู่นักแสดง หรือในหมู่มหาเศรษฐี
คุณค่าของความถ่อมตน
เมื่อได้ฟันธงลงไปแล้วว่าเกียรติยศคือศูนย์กลางของกลไกต่างๆ ในการให้รางวัลในวัฒนธรรมแฮ็กเกอร์ เราก็จำเป็นต้องมาทำความเข้าใจกันต่อ ว่าทำไมจึงดูสำคัญนักที่เรื่องนี้ยังมีความเห็นแตกต่าง และไม่เป็นที่ยอมรับกันอย่างมาก
ความต่างจากวัฒนธรรมการลักขโมยสามารถบอกอะไรเราได้ ในวัฒนธรรมนั้น พฤติกรรมการแสวงหาชื่อเสียงจะโจ่งแจ้งหรือกระทั่งโอ้อวด นักเจาะระบบเหล่านี้พยายามจะแสวงหาคำสรรเสริญที่สามารถปล่อย ``โปรแกรมปลดล็อกศูนย์วัน'' (zero-day warez) (ซอฟต์แวร์ที่เจาะแล้ว และแจกจ่ายภายในวันเดียวกับวันประกาศตัวของซอฟต์แวร์ดั้งเดิมที่ยังไม่ถูกเจาะ) แต่จะปิดปากสนิทเรื่องวิธีการที่ทำ นักมายากลเหล่านี้ไม่ชอบที่จะบอกเคล็ดแก่ผู้อื่น ซึ่งผลก็คือ องค์ความรู้ของวัฒนธรรมนักเจาะโดยรวมมีการเพิ่มพูนในอัตราที่ต่ำมาก
ในทางตรงกันข้าม ในชุมชนแฮ็กเกอร์นั้น สิ่งที่ทำคือสิ่งที่พูด มีสังคมที่เชื่อมั่นในความสำเร็จด้วยตนเอง (meritocracy) (ช่างฝีมือที่เก่งที่สุดเป็นผู้ชนะ) มีจิตวิญญาณที่เข้มแข็งที่เชื่อว่า เรื่องของคุณภาพนั้นควร (อันที่จริงคือ <emphasis>ต้อง</emphasis>) ปล่อยให้เนื้องานบอกเอง การอวดอ้างที่ดีที่สุดที่จะทำได้ คือการบอกว่าโค้ดนั้น ``แค่ทำงานได้'' (just works) และบอกว่า โปรแกรมเมอร์ที่มีฝีมือจะเห็นว่ามันดี ด้วยเหตุนี้ องค์ความรู้ของวัฒนธรรมแฮ็กเกอร์จึงเพิ่มพูนอย่างรวดเร็ว
ข้อห้ามต่อการเก๊กท่าโดยมีแรงขับจากอัตตาจึงช่วยเพิ่มผลิตผล แต่นั่นก็เป็นเพียงผลทางอ้อม สิ่งที่ได้รับการปกป้องโดยตรงในที่นี้ คือคุณภาพของข้อมูลในระบบการประเมินผลโดยหมู่ชนในชุมชน กล่าวคือ การโอ้อวดหรือสำคัญตนจะถูกเมิน เพราะถือเป็นพฤติกรรมที่เหมือนคลื่นรบกวน อันจะทำลายสัญญาณที่มีคุณภาพที่มาจากการทดลองภายใต้พฤติกรรมแบบสร้างสรรค์และร่วมมือ
ด้วยเหตุผลที่คล้ายกัน การโจมตีผู้เขียนแทนที่จะเป็นโค้ดก็จะไม่เกิดเช่นกัน ตรงนี้มีความละเอียดอ่อนที่น่าสนใจข้อหนึ่งที่ช่วยเสริมประเด็น คือแฮ็กเกอร์รู้สึกอิสระที่จะโจมตีกันด้วยเรื่องอุดมการณ์และความแตกต่างระหว่างบุคคล แต่จะไม่เคยได้ยินแฮ็กเกอร์คนไหนโจมตีความสามารถทางเทคนิคของคนอื่นในที่สาธารณะ (แม้แต่การวิจารณ์เป็นการส่วนตัวก็ถือเป็นเรื่องไม่ปกติ และมักจะใช้น้ำเสียงที่เบา) การล่าบั๊กหรือการวิจารณ์จะทำในนามของโครงการเสมอ ไม่ใช่ในนามของบุคคล
นอกจากนี้ บั๊กในอดีตก็จะไม่มีการนำมาหาความนักพัฒนา การที่บั๊กได้รับการแก้ไขแล้ว เป็นข้อเท็จจริงที่ถือว่าสำคัญกว่าการที่มันเคยมีอยู่ มีผู้แสดงความเห็นท่านหนึ่งตั้งข้อสังเกตว่า คนคนหนึ่งสามารถได้สถานภาพมาด้วยการแก้ `บั๊กของ Emacs' ไม่ใช่ด้วยการแก้ `บั๊กของริชาร์ด สตอลแมน' และถือเป็นการเสียมารยาทที่จะวิพากษ์วิจารณ์สตอลแมนเกี่ยวกับบั๊ก <emphasis>เก่า</emphasis> ใน Emacs ที่ได้รับการแก้ไขไปแล้ว
เรื่องนี้มีความแตกต่างที่น่าสนใจกับหลายๆ ส่วนของภาคการศึกษา ที่ซึ่งการโละงานเก่าที่เห็นกันว่าบกพร่องของคนอื่นเป็นรูปแบบหนึ่งที่สำคัญของการเลื่อนสถานภาพ ในวัฒนธรรมแฮ็กเกอร์ พฤติกรรมดังกล่าวค่อนข้างเป็นข้อห้ามที่หนักแน่น หนักแน่นเสียจนการไม่มีอยู่ของมันไม่ได้แวบเข้ามาในข้อมูลดิบของผู้เขียนเลย จนกระทั่งผู้แสดงความเห็นผู้มีทัศนะที่ไม่ธรรมดาท่านหนึ่งชี้ให้เห็น หลังจากที่ประกาศบทความนี้ครั้งแรกถึงหนึ่งปีเต็ม!
ข้อห้ามต่อการโจมตีความสามารถ (ที่ไม่ได้มีร่วมกับภาคการศึกษา) นี้ ชัดเจนเสียยิ่งกว่าข้อห้าม (ที่มีร่วมกัน) ต่อการเก๊กท่า เพราะเราสามารถเชื่อมโยงข้อห้ามนี้กับความแตกต่างระหว่างภาคการศึกษากับแวดวงแฮ็กเกอร์เรื่องโครงสร้างของการสื่อสารและการสนับสนุน
สื่อกลางของวัฒนธรรมแฮ็กเกอร์เป็นสิ่งที่ไม่มีรูปร่างให้จับต้องได้ ช่องทางการสื่อสารของแฮกเกอร์ไม่อำนวยต่อการแสดงความละเอียดอ่อนทางอารมณ์ และการพบกันตัวเป็นๆ ของสมาชิกก็เป็นข้อยกเว้นมากกว่าเรื่องปกติ จึงทำให้มีความอดทนต่อคลื่นรบกวนต่ำกว่าวัฒนธรรมการให้อื่นๆ และเรื่องนี้ก็ช่วยอธิบายได้เป็นอย่างดี ทั้งเรื่องข้อห้ามต่อการเก๊กท่า และข้อห้ามต่อการโจมตีความสามารถ การเกิดการปรามาสความสามารถของแฮ็กเกอร์บ่อยๆ จะล้มตารางคะแนนเรื่องชื่อเสียงในชุมชน ซึ่งน่ารำคาญจนยอมรับไม่ได้
ความเปราะบางต่อคลื่นรบกวนอย่างเดียวกันนี้ สามารถอธิบายความต้องการความถ่อมตนจากสมาชิกอาวุโสในชุมชนแฮ็กเกอร์ได้ด้วย เขาเหล่านั้นจำเป็นต้องมีภาพที่ปราศจากการอวดตัวและการเก๊กท่า เพื่อที่จะให้ข้อห้ามต่อคลื่นรบกวนนี้มีผลต่อไป <link linkend="dc">[DC]</link>
การพูดอย่างนุ่มนวลก็เป็นอีกปัจจัยหนึ่งถ้าใครมุ่งหวังจะเป็นผู้ดูแลของโครงการที่ประสบความสำเร็จ โดยต้องทำให้ชุมชนเชื่อว่าคุณมีวิจารณญาณที่ดี เพราะงานส่วนใหญ่ของผู้ดูแลก็คือการตัดสินโค้ดของคนอื่น จะมีใครอยากร่วมสมทบงานกับคนที่เห็นได้ชัดว่าไม่สามารถประเมินคุณภาพของโค้ดของพวกเขาได้ หรือกับคนที่มีพฤติกรรมบ่งชี้ว่าจะฮุบเอาชื่อเสียงที่มีต่อโครงการไว้เองอย่างไม่เป็นธรรม? ผู้ร่วมสมทบงานต้องการผู้นำโครงการที่มีความถ่อมตนพอ และเป็นชนิดที่สามารถจะพูดเมื่อสมควรพูดได้ด้วยว่า ``ถูกแล้วครับ แบบนั้นดีกว่าแบบของผม ผมจะใช้อันนี้แหละ'' และสามารถให้เครดิตต่อผู้ที่สมควรได้รับด้วย
อีกเหตุผลหนึ่งต่อพฤติกรรมถ่อมตนก็คือ ในโลกโอเพนซอร์สนั้น คุณมักไม่อยากจะแสดงภาพของโครงการในลักษณะที่มัน `เสร็จสมบูรณ์แล้ว' เพราะนั่นอาจทำให้ผู้ร่วมสมทบไม่รู้สึกว่าตนเป็นที่ต้องการ วิธีที่จะบริหารงานอย่างได้ผลเต็มที่ก็คือ อ่อนน้อมถ่อมตนเกี่ยวกับสถานะของโปรแกรม ถ้ามีใครอวดโค้ด แล้วจบด้วยการพูดว่า ``เฮ้อ! มันยังทำเรื่อง ก ข และ ค ไม่ได้เลย มันก็เลยยังไม่ดีอย่างที่ว่า'' แล้วล่ะก็ แพตช์สำหรับ ก ข และ ค จะตามมาอย่างรวดเร็ว
ท้ายที่สุดนี้ ผู้เขียนยังได้ลอบสังเกตเห็นว่า พฤติกรรมการถ่อมตัวของแฮ็กเกอร์ชั้นนำหลายคน ยังสะท้อนถึงความกลัวอย่างแท้จริง (ซึ่งไม่ใช่ว่าไร้เหตุผล) ต่อการกลายเป็นวัตถุของการบูชาตัวบุคคล ทั้ง ไลนัส ทอร์วาลดส์ และ ลาร์รี วอลล์ ได้แสดงพฤติกรรมการหลีกเลี่ยงเช่นนั้นเป็นตัวอย่างที่ชัดเจนมาแล้วมากมาย ครั้งหนึ่ง ในการเดินหาร้านอาหารเย็นกับ ลาร์รี วอลล์ ผู้เขียนหยอกว่า ``ในนี้ คุณเป็นแฮ็กเกอร์มือหนึ่ง คุณควรเป็นคนเลือกร้าน'' เขาสะดุ้งอย่างเห็นได้ชัด และอย่างที่เห็น การไม่ตระหนักถึงความแตกต่างของความสำคัญของตนเอง เทียบกับบุคลิกภาพของผู้นำของตน ได้ทำลายชุมชนอาสาสมัครดีๆ มาแล้วมากมาย ซึ่งลาร์รีและไลนัสไม่อาจไม่รับรู้ และในทางกลับกัน แฮ็กเกอร์ส่วนมากอยากจะมีปัญหาเดียวกับลาร์รี ถ้าเพียงแต่พวกเขายอมรับสารภาพ
นัยในภาพรวมของโมเดลเกมแห่งชื่อเสียง
การวิเคราะห์เกมแห่งชื่อเสียงมีนัยที่อาจไม่เห็นชัดในทันที นัยเหล่านี้มาจากข้อเท็จจริงที่ว่า การตั้งโครงการใหม่ได้สำเร็จทำให้ได้ชื่อเสียงมากกว่าการร่วมมือกับโครงการที่มีอยู่ และโครงการที่เป็นนวัตกรรมชั้นยอด ก็ย่อมให้ชื่อเสียงมากกว่าการพัฒนาเพิ่มจากซอฟต์แวร์ที่มีอยู่ในลักษณะ `ด้วยคนสิ' ในทางกลับกัน ซอฟต์แวร์ที่ไม่มีใครเข้าใจหรือต้องการใช้นอกจากผู้เขียน ก็ไม่ใช่จุดเริ่มต้นที่ดีของการเล่นเกมแห่งชื่อเสียงเช่นกัน และการดึงดูดความสนใจด้วยการเข้าร่วมในโครงการที่มีอยู่ ก็ง่ายกว่าการดึงดูดผู้คนมายังโครงการใหม่ และสุดท้าย การแข่งขันกับโครงการที่ประสบความสำเร็จแล้วย่อมยากกว่าการเติมช่องว่างเล็กๆ มากนัก
ด้วยเหตุนี้ จึงมีระยะห่างที่เหมาะสมกับเพื่อนบ้าน (คือโครงการที่คล้ายกันและอาจแข่งกันอยู่) ถ้าใกล้เกินไป ก็กลายเป็นประเภท ``ด้วยคนสิ'' และไม่ค่อยมีคุณค่า เป็นของขวัญแย่ๆ (ซึ่งการเข้าร่วมกับโครงการที่มีอยู่ อาจจะได้ประโยชน์มากกว่า) หรือถ้าไกลกันเกินไป ก็ไม่มีใครใช้เป็น หรือเข้าใจ หรือมองเห็นความเกี่ยวโยงของงาน (เป็นของขวัญแย่ๆ อีกเช่นกัน) เงื่อนไขนี้ ทำให้เกิดรูปแบบของการปักหลักใน noosphere ที่คล้ายคลึงกับการตั้งหลักแหล่งของผู้คนในเขตแดนจริง คือไม่สุ่มเสี่ยง แต่คล้ายกับแฟร็กทัลที่จำกัดการแพร่กระจาย โครงการต่างๆ มีแนวโน้มจะเริ่มจากเติมช่องว่างใกล้กับบริเวณชายขอบ (ดู <link linkend="no">[NO]</link> สำหรับการอภิปรายเพิ่มเติมเรื่องแรงดึงดูดของนวัตกรรม)
โครงการที่ประสบความสำเร็จอย่างสูงบางโครงการ ได้กลายเป็น `ผู้พิชิต' (category killer) ไม่มีใครต้องการปักหลักใกล้ เพราะการแข่งขันกับฐานที่สร้างเสร็จแล้วในการดึงดูดความสนใจของแฮ็กเกอร์นั้นยากเกินไป กลุ่มคนที่อาจจะคิดตั้งโครงการต่างหากหากปราศจากโครงการดังกล่าว ก็จะลงเอยด้วยการเพิ่มส่วนขยายให้กับโครงการใหญ่ที่สำเร็จเหล่านี้แทน ตัวอย่างอมตะของ `ผู้พิชิต' ก็คือ GNU Emacs โดยที่ชนิดต่างๆ ของมันได้เติมช่องว่างอย่างสมบูรณ์ในส่วนของโปรแกรมบรรณาธิกรณ์ที่โปรแกรมได้ สมบูรณ์เสียจนไม่มีคู่แข่งรายใดสามารถก้าวผ่านขั้นของโครงการบินเดี่ยวได้มากนักมาตั้งแต่ต้นทศวรรษ 1980 โดยสิ่งที่เกิดขึ้นแทนก็คือ ผู้คนหันมาเขียนโหมด Emacs กัน
ในภาพรวมแล้ว แนวโน้มทั้งสอง (การเติมช่องว่าง และผู้พิชิต) ได้ขับดันแนวโน้มที่คาดการณ์ได้กว้างๆ ของการเริ่มโครงการในช่วงเวลาต่างๆ ในทศวรรษ 1970 โอเพนซอร์สส่วนใหญ่ที่มีอยู่เป็นแค่ของเล่นหรือเดโม ในทศวรรษ 1980 แรงผลักดันคือการพัฒนาซอฟต์แวร์และเครื่องมืออินเทอร์เน็ต ในทศวรรษ 1990 กิจกรรมได้ข้ามมาเป็นระบบปฏิบัติการ ในแต่ละกรณี ปัญหาที่แก้เป็นระดับใหม่และยากขึ้น เมื่อความเป็นไปได้ต่างๆ ของปัญหาเดิมได้ถูกแก้จนเกือบหมดแล้ว
แนวโน้มนี้มีนัยที่น่าสนใจสำหรับอนาคตอันใกล้ ในช่วงต้นปี 1998 ลินุกซ์ดูคล้ายกับจะเป็นผู้พิชิตเอามากๆ ในช่องว่างของ `ระบบปฏิบัติการโอเพนซอร์ส' กล่าวคือ ผู้คนที่อาจจะคิดเขียนระบบปฏิบัติการแข่งไปแล้ว ก็ได้หันมาเขียนตัวขับอุปกรณ์และส่วนขยายสำหรับลินุกซ์แทน และเครื่องมือระดับล่างเกือบทั้งหมดที่วัฒนธรรมจะสามารถคิดได้ว่าน่าจะมีเป็นโอเพนซอร์สก็มีแล้ว แล้วยังจะเหลืออะไรอีก?
คำตอบคือโปรแกรมประยุกต์ เมื่อเริ่มสหัสวรรษที่สาม ดูเหมือนจะปลอดภัยที่จะทำนายว่า การพัฒนาโอเพนซอร์สจะค่อยๆ ย้ายไปสู่ดินแดนสุดท้ายที่ยังบริสุทธิ์ผุดผ่อง คือโปรแกรมสำหรับผู้ที่ไม่ใช่นักเทคนิค จุดบ่งชี้แรกๆ ที่ชัดเจนก็คือการพัฒนาของ <ulink url="http://www.gimp.org">GIMP</ulink> โปรแกรมแต่งภาพที่คล้ายกับ Photoshop ซึ่งนับเป็นโปรแกรมประยุกต์ที่สำคัญโปรแกรมแรกของโอเพนซอร์สสำหรับผู้ใช้ปลายทาง คือใช้ GUI ที่เป็นมิตรที่ถือว่า <emphasis>เป็นสิ่งจำเป็น</emphasis> ในโปรแกรมเชิงพาณิชย์ในทศวรรษที่แล้ว อีกตัวอย่างหนึ่งคือปริมาณของเสียงอื้ออึงรอบๆ โครงการทูลคิทสำหรับโปรแกรมประยุกต์อย่าง <ulink url="http://www.kde.org">KDE</ulink> และ <ulink url="http://www.gnome.org">GNOME</ulink>
ผู้แสดงความเห็นท่านหนึ่งต่อบทความนี้ได้ชี้ว่า การอุปมาอุปไมยเรื่องการปักหลักยังสามารถอธิบายได้ ถึงการที่แฮ็กเกอร์โต้ตอบด้วยความโกรธที่อัดแน่นต่อนโยบาย ``เขมือบแล้วขยาย'' (embrace and extend) ของไมโครซอฟท์ ที่มาสร้างความซับซ้อน แล้วก็ปิดโปรโตคอลอินเทอร์เน็ต วัฒนธรรมแฮ็กเกอร์สามารถอยู่ร่วมกับซอฟต์แวร์ปิดได้แทบทุกเจ้า ตัวอย่างเช่น การมีอยู่ของ Adobe Photoshop ก็ไม่ได้ทำให้เขตแดนข้างเคียงของ GIMP (โปรแกรมเทียบเท่าที่เป็นโอเพนซอร์ส) ดูน่าสนใจน้อยลงไป แต่เมื่อไมโครซอฟท์ประสบความสำเร็จในการทำลายตลาด <link linkend="HD">[HD]</link> โปรโตคอล เพื่อที่จะมีเพียงโปรแกรมเมอร์ของไมโครซอฟท์เท่านั้นที่สามารถเขียนซอฟต์แวร์สนับสนุนได้นั้น มันไม่ได้เป็นแค่การทำร้ายผู้บริโภคด้วยการขยายการครอบงำตลาด แต่ยังลดปริมาณและคุณภาพของ noosphere ที่เหลือสำหรับให้แฮ็กเกอร์ปักหลักและพัฒนาอีกด้วย จึงไม่น่าแปลก ที่แฮ็กเกอร์มักจะเรียกกลยุทธ์ของไมโครซอฟท์ว่า ``มลภาวะของโปรโตคอล'' แฮ็กเกอร์ตอบโต้เรื่องนี้เหมือนกับชาวนาที่จ้องมองคนที่ทำลายน้ำในแม่น้ำที่พวกเขาใช้ทำนาไม่มีผิด!
และท้ายที่สุด การวิเคราะห์เกมแห่งชื่อเสียงยังอธิบายคติพจน์ที่มักอ้างกันบ่อยๆ ด้วยว่า คุณไม่สามารถเป็นแฮ็กเกอร์ด้วยการเรียกตัวเองว่าแฮ็กเกอร์ แต่คุณเป็นแฮ็กเกอร์เมื่อ <emphasis>แฮ็กเกอร์คนอื่น</emphasis> เรียกคุณว่าแฮ็กเกอร์ <link linkend="KN">[KN]</link> `แฮ็กเกอร์' เมื่อพิจารณาตามแนวนี้ จึงหมายถึงผู้ที่ได้แสดงให้เห็น (ด้วยการร่วมสมทบของขวัญ) ว่าเขาหรือเธอมีทั้งความสามารถทางเทคนิค และความเข้าใจในการทำงานของเกมแห่งชื่อเสียง การพิพากษานี้ ส่วนมากเป็นเรื่องของการรับรู้หรือการรับเอาวัฒนธรรมมาใช้ ซึ่งสามารถให้ได้โดยผู้ที่อยู่ในวัฒนธรรมเป็นอย่างดีแล้วเท่านั้น
ของขวัญนั้นดีแค่ไหน?
มีรูปแบบตายตัวที่วัฒนธรรมแฮ็กเกอร์จะให้คุณค่าแก่การร่วมสมทบงาน และให้ความเคารพกลับคืนแก่เจ้าของผลงาน กฎต่อไปนี้สังเกตได้ไม่ยากเลย:
1. ถ้ามันทำไม่ได้อย่างที่ชี้นำให้คาดหวัง ก็ถือว่าใช้ไม่ได้ ไม่ว่ามันจะดูฉลาดหรือใหม่เอี่ยมขนาดไหนก็ตาม
โปรดสังเกตวลี `ชี้นำให้คาดหวัง' กฎนี้ไม่ใช่ว่าต้องการความสมบูรณ์แบบ ซอฟต์แวร์ทดสอบและทดลองนั้นมีบั๊กได้ แต่เป็นความจำเป็นอย่างหนึ่ง ที่ต้องให้ผู้ใช้สามารถประเมินความเสี่ยงจากสถานะของโครงการ และการนำเสนอของนักพัฒนาได้
กฎนี้อยู่เบื้องหลังข้อเท็จจริงที่ว่า ซอฟต์แวร์โอเพนซอร์สมักจะอยู่ในขั้นทดสอบเป็นเวลานาน และจะไม่ถึงรุ่น 1.0 เสียที จนกว่านักพัฒนาจะมั่นใจมากๆ ว่ามันจะไม่ทำให้ผู้คนตกใจร้องยี้ ในโลกซอร์สปิดนั้น รุ่น 1.0 หมายความว่า ``อย่าเพิ่งแตะต้อง ถ้าคุณยังไม่แน่ใจ'' แต่ในโลกโอเพนซอร์สนั้น มันมีความหมายคล้ายกับ ``นักพัฒนาเต็มใจที่จะเดิมพันมันด้วยชื่อเสียงของพวกเขาเอง'' มากกว่า
2. งานที่ขยายขอบเขตของ noosphere ถือว่าดีกว่างานที่ซ้ำกับงานในขอบเขตเดิมที่ทำได้ดีอยู่แล้ว
พูดง่ายๆ ก็คือ: <emphasis>งานใหม่ย่อมดีกว่างานที่ซ้ำกับหน้าที่ของซอฟต์แวร์เดิมที่มีอยู่</emphasis> แต่ความเป็นจริงอาจไม่ง่ายอย่างนั้น การซ้ำซ้อนกับหน้าที่ของซอฟต์แวร์ <emphasis>ปิด</emphasis> เดิมที่มีอยู่ ก็ถือว่ามีความใหม่เทียบเท่ากับงานที่คิดขึ้นใหม่จริงๆ ได้ ถ้างานนั้นเป็นการแกะโปรโตคอลหรือฟอร์แมตปิด และทำให้ใช้งานได้เป็นครั้งแรก
ด้วยเหตุนี้ โครงการหนึ่งที่ได้รับเกียรติยศสูงสุดในโลกโอเพนซอร์สก็คือ แซมบา (Samba) ซึ่งช่วยให้เครื่องยูนิกซ์สามารถเป็นเครื่องลูกข่ายหรือสถานีบริการสำหรับโปรโตคอล SMB ซึ่งเป็นโปรโตคอลปิดสำหรับใช้ไฟล์ร่วมกันของไมโครซอฟท์ได้ งานในโครงการนี้ มีความสร้างสรรค์น้อยมาก ส่วนมากเป็นเรื่องของการทำวิศวกรรมย้อนรอยให้ถูกต้อง แม้กระนั้น สมาชิกกลุ่มแซมบาก็ได้รับการยอมรับให้เป็นวีรบุรุษ เพราะเป็นการสลายพลังหนึ่งของไมโครซอฟท์ที่จะกักขังกลุ่มผู้ใช้ทั้งหมด และปิดล้อมภาคที่ใหญ่มากๆ ภาคหนึ่งของ noosphere
3. งานที่สามารถเข้าไปอยู่ในดิสทริบิวชันหลักได้ ย่อมดีกว่างานที่ไม่ได้เข้า งานที่รวมอยู่ในดิสทริบิวชันหลักทุกเจ้า ถือว่าได้รับเกียรติยศสูงสุด
ดิสทริบิวชันหลักไม่ได้หมายถึงแค่ดิสทริบิวชันลินุกซ์ใหญ่ๆ อย่าง Red Hat, Debian, Caldera และ SuSE เท่านั้น แต่รวมไปถึงการรวบรวมอื่นที่เป็นที่เข้าใจกันว่ามีชื่อเสียงที่ต้องรักษา ซึ่งหมายความถึงการรับรองคุณภาพในตัวเอง อย่างเช่น ดิสทริบิวชันต่างๆ ของ BSD หรือแหล่งรวบรวมซอฟต์แวร์ของมูลนิธิซอฟต์แวร์เสรี
4. การใช้งานจริง คือวิธียกย่องที่จริงใจที่สุด และผู้พิชิตย่อมดีกว่างานที่ทำคล้ายกัน
การเชื่อมั่นในวิจารณญาณของผู้อื่น คือพื้นฐานของกระบวนการตรวจสอบโดยหมู่ชน ความเชื่อมั่นดังกล่าวมีความสำคัญ เพราะไม่มีใครมีเวลาตรวจสอบทางเลือกทุกทาง ดังนั้น งานที่มีผู้ใช้จำนวนมากจึงถือว่าดีกว่างานที่มีผู้ใช้ไม่กี่คน
การทำงานที่ดีเสียจนไม่มีใครสนใจใช้ตัวเลือกอื่นอีกต่อไป จึงถือเป็นการได้รับเกียรติยศอันยิ่งใหญ่ ความเคารพอันสูงสุดจากหมู่ชนที่จะพึงมีได้ จึงมาจากการได้ทำงานที่เป็นที่นิยมอย่างกว้างขวาง เป็นงานใหม่เอี่ยมที่พิชิตใจผู้ใช้ และถูกรวมอยู่ในดิสทริบิวชันหลักทุกเจ้า ผู้ใดก็ตามที่สามารถทำเรื่องแบบนี้ได้มากกว่าหนึ่งครั้ง จะถูกขนานนามแบบทีเล่นทีจริงว่า `กึ่งเทพเจ้า'
5. การอุทิศตนอย่างต่อเนี่องกับงานที่หนักและน่าเบื่อ (เช่น การดีบั๊ก หรือการเขียนเอกสาร) ถือว่าน่ายกย่องกว่าการเด็ดชิมเฉพาะงานแฮ็กที่สนุกและง่ายดาย
บรรทัดฐานนี้ คือวิธีที่ชุมชนให้รางวัลแก่งานที่จำเป็นที่แฮ็กเกอร์มักไม่อยากเข้าใกล้ แต่บางทีก็ขัดแย้งกับเรื่องต่อไปนี้พอสมควร:
6. การขยายความสามารถที่เด่นๆ ถือว่าดีกว่าการแก้ไขและดีบั๊กในระดับล่าง
การทำงานของข้อนี้ดูจะเป็นในลักษณะที่ว่า ในเฉพาะเบื้องหน้านั้น การเพิ่มความสามารถมีแนวโน้มจะได้รางวัลมากกว่าการแก้บั๊ก นอกเสียจากบั๊กนั้นจะเลวร้ายหรือลึกลับมากๆ จนทำให้แค่การซ่อมแซมก็ถือเป็นการแสดงความเชี่ยวชาญและเชาวน์ปัญญาที่ไม่ธรรมดา แต่เมื่อพฤติกรรมทั้งสองผ่านไปตามกาลเวลา บุคคลที่มีประวัติยาวนานในการทุ่มเทและซ่อมแซมแม้บั๊กธรรมดา ก็สามารถจะแซงหน้าคนที่ใช้แรงพอๆ กัน ในการเพิ่มความสามารถง่ายๆ ได้
ผู้แสดงความเห็นท่านหนึ่งชี้ว่า กฎเหล่านี้มีผลต่อกันอย่างน่าสนใจ และไม่จำเป็นต้องให้รางวัลต่ออรรถประโยชน์สูงสุดเสมอไป ลองถามแฮ็กเกอร์สักคนดูสิ ว่าเขามีแนวโน้มจะเป็นที่รู้จักจากเครื่องมือใหม่ล่าสุดที่ทำเอง หรือจากการเพิ่มขยายงานของคนอื่นมากกว่ากัน ไม่ต้องสงสัยว่าคำคอบคือ ``เครื่องมือใหม่'' แน่ๆ แต่ลองถามว่าระหว่าง (ก) เครื่องมือใหม่เอี่ยมที่ถูก OS เรียกใช้แค่วันละสองสามครั้งอย่างเงียบๆ แต่กลายเป็นผู้พิชิตอย่างรวดเร็ว กับ (ข) ส่วนขยายหลายๆ ชิ้นต่อเครื่องมือที่มีอยู่แล้ว ซึ่งไม่ได้เป็นนวัตกรรมหรือเป็นผู้พิชิตแต่อย่างใด แต่มีผู้ใช้จำนวนมากเรียกใช้ทุกวัน มองเห็นทุกวัน อย่างไหนจะดังกว่า
แล้วคุณก็น่าจะได้เห็นความลังเลนิดหน่อย ก่อนที่แฮ็กเกอร์คนนั้นจะมาลงเอยที่ (ก) ทางเลือกเหล่านี้ดูจะซ้อนกันมาอย่างเท่าเทียม
ผู้แสดงความเห็นท่านนี้แสดงเจตนาที่จะถามคำถามนี้กับตัวผู้เขียนเอง ด้วยการเสริมว่า ``กรณี (ก) คือ fetchmail ส่วนกรณี (ข) คือส่วนขยาย Emacs ทั้งหลายของคุณเอง อย่างเช่น <filename>vc.el</filename> และ <filename>gud.el</filename>'' และเขาก็พูดถูกจริงๆ ผู้เขียนมักจะถูกติดป้ายว่าเป็น ``คนเขียน fetchmail'' มากกว่า ``คนเขียนโหมด Emacs กองพะเนิน'' แม้ว่าอย่างหลังน่าจะถูกเรียกใช้มากกว่า
สิ่งที่อาจสรุปได้ตรงนี้ก็แค่ง่ายๆ ว่างานที่มี `เอกลักษณ์ยี่ห้อ' ใหม่ จะเป็นที่สังเกตมากกว่างานที่ถูกรวมเข้าไปใน `ยี่ห้อ' ที่มีอยู่แล้ว การอธิบายกฎเหล่านี้อย่างละเอียด พร้อมทั้งสิ่งบ่งชี้เกี่ยวกับระบบการให้คะแนนของวัฒนธรรมแฮ็กเกอร์ จะเป็นหัวข้อที่ดีที่จะวินิจฉัยกันต่อไป
ทรัพย์สินใน Noosphere กับพฤติกรรมการประกาศถิ่น
เพื่อที่จะทำความเข้าใจในเหตุและผลของจารีตประเพณีทรัพย์สินของล็อค เราลองมามองจากอีกมุมหนึ่งซึ่งช่วยทำความเข้าใจได้ คือจากพฤติกรรมสัตว์ โดยมุ่งเฉพาะพฤติกรรมเรื่องการประกาศถิ่น
ทรัพย์สินก็คือการสร้างนามธรรมของการประกาศถิ่นของสัตว์ ซึ่งพัฒนาขึ้นในฐานะของเครื่องมือลดความรุนแรงภายในเผ่าพันธุ์ การทำเครื่องหมายเขตแดน และเคารพเขตแดนของตัวอื่น ช่วยให้หมาป่าลดโอกาสที่จะต้องต่อสู้กัน อันอาจทำให้แต่ละตัวต้องอ่อนล้าหรือตายลง และทำให้การสืบพันธุ์ไม่ประสบความสำเร็จ ด้วยลักษณะคล้ายกัน หน้าที่ของทรัพย์สินในสังคมมนุษย์ก็คือ ป้องกันข้อขัดแย้งระหว่างมนุษย์ ด้วยการขีดเส้นแบ่งแยกพฤติกรรมสันติกับก้าวร้าวออกจากกันอย่างชัดเจน
อาจฟังดูหรูในบางวงการที่จะบรรยายทรัพย์สินมนุษย์ว่าเป็นข้อตกลงทางสังคมแบบอำเภอใจ แต่นั่นเป็นความคิดที่ผิดอย่างจัง ใครก็ตามที่เคยมีสุนัขที่เห่าคนแปลกหน้าที่เข้าใกล้ทรัพย์สินของเจ้าของ จะรู้สึกได้ถึงความต่อเนื่องที่สำคัญ ระหว่างการประกาศถิ่นของสัตว์กับทรัพย์สินของมนุษย์ ญาติหมาป่าที่มาอยู่บ้านของเรารู้โดยสัญชาตญาณ ว่าทรัพย์สินไม่ได้เป็นเพียงข้อตกลงทางสังคมหรือว่าเกมใดๆ แต่เป็นกลไกที่สำคัญอย่างยิ่งยวดที่ได้พัฒนาขึ้นเพื่อหลีกเลี่ยงความรุนแรง (ความรู้นี้ทำให้สุนัขเหล่านี้ฉลาดกว่านักทฤษฎีการเมืองที่เป็นมนุษย์หลายคนนัก)
การอ้างความเป็นเจ้าของทรัพย์สิน (ซึ่งเหมือนกับการทำเครื่องหมายเขตแดน) เป็นการกระทำที่มีผลตามคำพูด คือเป็นวิธีประกาศเขตแดนที่จะปกป้อง การสนับสนุนการอ้างโดยชุมชน ก็เป็นวิธีลดแรงต้านให้น้อยที่สุด และเพิ่มพฤติกรรมการร่วมมือให้มากที่สุด สิ่งเหล่านี้เป็นจริงแม้ในกรณีที่ ``การอ้างความเป็นเจ้าของทรัพย์สิน'' เป็นนามธรรมกว่ารั้วหรือการเห่าของสุนัข หรือแม้ในกรณีที่เป็นแค่ถ้อยแถลงประกาศชื่อของผู้ดูแลโครงการในไฟล์ README ทั้งหมดยังคงเป็นนามธรรมของการประกาศเขตแดน และ (เหมือนกับทรัพย์สินรูปแบบอื่น) อยู่บนพื้นฐานของสัญชาตญาณการประกาศถิ่นที่พัฒนาขึ้นเพื่อช่วยยุติข้อขัดแย้ง
การวิเคราะห์พฤติกรรมประกาศถิ่นนี้ แรกๆ อาจจะดูเป็นนามธรรม และยากจะเกี่ยวโยงกับพฤติกรรมจริงของแฮ็กเกอร์ แต่มันก็ให้ผลลัพธ์ที่สำคัญ หนึ่งในนั้นคือการอธิบายความเป็นที่นิยมของเว็บไซต์ต่างๆ และโดยเฉพาะการที่โครงการโอเพนซอร์สที่มีเว็บไซต์ดูเป็น `ของจริง' และมีหลักฐานกว่าโครงการที่ไม่มี
เมื่อพิจารณาอย่างเป็นกลาง เรื่องนี้ดูจะอธิบายยาก เพราะเมื่อเทียบกับความพยายามที่ใช้ในการตั้งและดูแลแม้โครงการเล็กๆ แล้ว การดูแลเว็บนั้นง่ายกว่ามาก จึงยากที่จะถือว่าเว็บเป็นหลักฐานของความพยายามที่หนักหรือไม่ธรรมดา
หรือแม้แต่ลักษณะหน้าที่ของเว็บเอง ก็ไม่ใช่คำอธิบายที่เพียงพอ การสื่อสารต่างๆ ของหน้าเว็บก็สามารถให้บริการผ่านการทำงานร่วมกันของ FTP, เมลลิงลิสต์ และกลุ่มข่าว Usenet ได้เหมือนกัน ซึ่งในความเป็นจริง ออกจะดูผิดปกติด้วยซ้ำสำหรับการติดต่อสื่อสารประจำวันของโครงการ ที่จะทำผ่านเว็บแทนเมลลิงลิสต์หรือกลุ่มข่าว เช่นนั้นแล้ว ทำไมล่ะ จึงยังมีความนิยมให้เว็บไซต์แทนที่อยู่ของโครงการ?
อุปมาอุปมัยที่แฝงอยู่ในคำว่า `โฮมเพจ' (home page) นั่นเอง ที่บอกใบ้ถึงคำตอบ ในขณะที่การก่อตั้งโครงการโอเพนซอร์สเป็นการอ้างเขตแดนใน noosphere (โดยได้รับการยอมรับตามจารีตประเพณี) แต่ก็ไม่ใช่เขตแดนชนิดที่เด่นชัดในระดับจิตวิทยา เพราะในที่สุด ซอฟต์แวร์ก็ไม่มีที่อยู่โดยธรรมชาติของมันเอง และสามารถทำซ้ำได้ทันทีที่ต้องการ เรื่องนี้เราอาจเข้าใจได้ด้วยสามัญสำนึกในรูปของ `เขตแดน' และ `ทรัพย์สิน' แต่ก็ต้องออกแรงกันสักหน่อย
โฮมเพจของโครงการทำให้การปักหลักแบบนามธรรมในโลกของโปรแกรมเป็นรูปเป็นร่างขึ้นมา ด้วยการประกาศตัวเองว่าเป็นเขต `บ้าน' (home) ในโลกของเวิร์ลด์ไวด์เว็บที่มีการจัดที่อยู่เป็นหลักแหล่งกว่า การลงจาก noosphere มาสู่ `ไซเบอร์สเปซ' ยังไม่ได้นำเราไปถึงโลกแห่งความเป็นจริงที่มีรั้วและสุนัขเห่าทั้งหมดก็จริง แต่ก็ได้ยึดการกล่าวอ้างทรัพย์สินแบบนามธรรมเข้ากับสามัญสำนึกเกี่ยวกับเขตแดนของเราไว้แน่นหนากว่า และนี่จึงเป็นเหตุผลที่โครงการที่มีเว็บดูเป็น `ของจริง' กว่า
ประเด็นนี้ได้รับการเสริมแรงอีกมาก ด้วยไฮเพอร์ลิงก์และการมีเครื่องมือค้นหาที่ดี โครงการที่มีหน้าเว็บสามารถเป็นที่สังเกตของคนที่กำลังสำรวจเพื่อนบ้านใน nooshpere ได้มากกว่า เพราะหน้าอื่นก็เชื่อมโยงมา และการค้นหาก็จะพบ หน้าเว็บจึงเป็นการโฆษณาที่ดีกว่า เป็นการกระทำที่มีผลตามคำพูดที่ได้ผลกว่า และเป็นการกล่าวอ้างเขตแดนที่หนักแน่นกว่า
การวิเคราะห์พฤติกรรมการประกาศถิ่นนี้ ยังได้ชวนให้พิจารณากลไกการจัดการข้อขัดแย้งในวัฒนธรรมโอเพนซอร์สให้ละเอียดขึ้นอีก โดยได้ชี้นำให้คาดหวังว่า นอกจากการเพิ่มแรงกระตุ้นจากชื่อเสียงให้สูงสุดแล้ว จารีตประเพณีการถือครองก็ควรมีบทบาทในการป้องกันและยุติข้อขัดแย้งด้วยเช่นกัน
สาเหตุของข้อขัดแย้ง
ในบรรดาข้อขัดแย้งในซอฟต์แวร์โอเพนซอร์ส เราสามารถระบุเรื่องหลักๆ ได้สี่เรื่อง:
ใครคือผู้ตัดสินใจเกี่ยวกับพันธกรณีของโครงการ?
ใครได้เครดิตหรือคำตำหนิเรื่องอะไร?
จะลดการทำงานซ้ำซ้อน และป้องกันเวอร์ชันเถื่อนไม่ให้มารบกวนการติดตามบั๊กได้อย่างไร?
อะไรคือสิ่งที่ถูกต้องในทางเทคนิค?
อย่างไรก็ดี ถ้าเรากลับไปพิจารณาเรื่อง ``อะไรคือสิ่งที่ถูกต้อง'' อีกครั้ง เรื่องนี้ก็อาจจะหายไป เพราะสำหรับคำถามเช่นนี้ จะมีวิธีตัดสินที่เป็นกลางและเป็นที่ยอมรับของทุกฝ่าย หรือไม่ก็ไม่มีเลย ซึ่งถ้ามี เรื่องก็จบ ทุกคนได้ประโยชน์ แต่ถ้าไม่มี เรื่องก็กลายมาเป็น ``ใครคือผู้ตัดสิน?'' นั่นเอง
เมื่อเป็นเช่นนี้ ปัญหาสามข้อที่ทฤษฎีการยุติข้อขัดแย้งต้องแก้ในโครงการก็คือ (ก) ความรับผิดชอบในการตัดสินใจเรื่องการออกแบบตกอยู่ที่ใคร (ข) จะตัดสินอย่างไรว่าผู้ร่วมสมทบคนไหนได้เครดิตอย่างไร และ (ค) จะป้องกันกลุ่มโครงการไม่ให้เกิดการแยกตัวออกไปหลายแขนงอย่างไร
บทบาทของจารีตประเพณีเรื่องการถือครองในการยุติกรณี (ก) และ (ค) นั้นชัดเจน เพราะจารีตประเพณีให้การรับรองเจ้าของโครงการให้เป็นผู้ตัดสินใจเกี่ยวกับพันธกรณี เราได้สังเกตมาก่อนแล้วว่า จารีตประเพณียังได้ให้แรงกดดันต้านการสลายตัวจากการฟอร์กอีกด้วย
เรายังเรียนรู้ได้อีกจากการสังเกตว่าจารีตประเพณีเหล่านี้ยังใช้ได้ แม้จะละเลยผลของเกมแห่งชื่อเสียงแล้วตรวจสอบจากมุมมองแบบ `ช่างฝีมือ' ล้วนๆ เกี่ยวกับวัฒนธรรมแฮ็กเกอร์ ในมุมมองนี้ จารีตประเพณีให้แรงจูงใจต่อการแยกตัวน้อยกว่าการปกป้องสิทธิของช่างฝีมือที่จะทำตามวิสัยทัศน์ของตนในวิธีที่ตนเลือก
อย่างไรก็ดี คำอธิบายแบบช่างฝีมือก็ยังไม่เพียงพอที่จะอธิบายวัฒนธรรมแฮ็กเกอร์เกี่ยวกับข้อ (ข) ใครได้เครดิตในเรื่องไหน เพราะช่างฝีมือบริสุทธิ์ผู้ไม่สนใจเกมแห่งชื่อเสียง จะไม่มีแรงกระตุ้นให้มาสนใจเรื่องเครดิต การวิเคราะห์เรื่องนี้ จึงต้องคิดต่อจากทฤษฎีของล็อคไปอีกขั้น แล้วตรวจสอบข้อขัดแย้ง กับการทำงานของสิทธิในทรัพย์สิน <emphasis>ภายใน</emphasis> โครงการ และ <emphasis>ระหว่าง</emphasis> โครงการต่างๆ
โครงสร้างของโครงการและการถือครอง
กรณีที่เล็กน้อยก็คือกรณีที่โครงการมีเจ้าของเพียงคนเดียว ในกรณีดังกล่าว ย่อมไม่มีข้อขัดแย้ง เจ้าของโครงการเป็นผู้ตัดสินใจและรับทั้งผิดและชอบทุกอย่าง ข้อขัดแย้งที่เป็นไปได้เพียงอย่างเดียวคือเรื่องการสืบทอดโครงการ คือคำถามว่าใครจะเป็นเจ้าของคนใหม่ ถ้าเจ้าของคนเดิมหายตัวไป หรือเลิกสนใจทำ นอกจากนี้ ชุมชนยังมีความสนใจตามข้อ (ค) เรื่องการป้องกันการฟอร์ก ความสนใจเหล่านี้ แสดงออกมาในรูปบรรทัดฐานของวัฒนธรรมที่ว่า เจ้าของหรือผู้ดูแลโครงการควรส่งทอดกรรมสิทธิ์ให้กับผู้อื่นอย่างเปิดเผย เมื่อไม่สามารถดูแลโครงการต่ออีกแล้ว
กรณีสำคัญที่ง่ายที่สุดคือ เมื่อโครงการมีผู้ร่วมดูแลหลายคนทำงานภายใต้ `เผด็จการใจดี' คนเดียว ซึ่งเป็นเจ้าของโครงการ จารีตประเพณีนิยมใช้รูปแบบนี้กับโครงการกลุ่ม และก็ปรากฏว่าสามารถทำงานได้ดีกับโครงการใหญ่ๆ ขนาดเคอร์เนลลินุกซ์ หรือ Emacs และสามารถแก้ปัญหา ``ใครเป็นผู้ตัดสิน'' ได้ด้วยหนทางที่ไม่ได้ด้อยกว่าวิธีอื่นเลย
โดยปกติแล้ว โครงสร้างแบบเผด็จการใจดีนี้ จะพัฒนามาจากแบบเจ้าของเป็นผู้ดูแล หลังจากที่ผู้ก่อตั้งได้ผู้ร่วมสมทบมากขึ้น แม้เจ้าของโครงการจะยังคงเป็นเผด็จการอยู่ แต่โครงสร้างแบบนี้ก็ได้เพิ่มระดับใหม่ของกรณีพิพาทที่อาจเกิดขึ้นได้ ว่าใครจะได้เครดิตสำหรับส่วนไหนของโครงการ
ภายใต้เงื่อนไขเช่นนี้ จารีตประเพณีได้มอบหน้าที่แก่เจ้าของ/เผด็จการ ที่จะให้เครดิตต่อผู้ร่วมสมทบอย่างยุติธรรม (เช่น ด้วยการอ้างถึงในไฟล์ README หรือไฟล์ประวัติโครงการอย่างเหมาะสม) ตามแบบจำลองทรัพย์สินของล็อคแล้ว การให้เครดิตดังกล่าวก็หมายความว่า การร่วมสมทบในโครงการจะทำให้คุณได้ส่วนแบ่งของชื่อเสียงที่มีต่อโครงการด้วย (ไม่ว่าแง่บวกหรือแง่ลบ)
ตามตรรกะนี้ เราจะเห็นว่า `เผด็จการใจดี' แท้ที่จริงแล้ว ก็ไม่ได้เป็นเจ้าของโครงการทั้งหมดอย่างเบ็ดเสร็จ แม้เขาจะมีสิทธิ์ที่จะตัดสินใจเกี่ยวกับพันธกรณี แต่ผลก็คือ เขาก็ให้ส่วนแบ่งในชื่อเสียงออกไปเพื่อแลกกับงานของผู้อื่นเหมือนกัน จึงทำให้อดนึกถึงการเปรียบเทียบกับการลงแขกเกี่ยวข้าวไม่ได้ เว้นก็แต่ว่า ชื่อของผู้ร่วมสมทบจะคงอยู่ในเครดิต และยังคงได้รับอยู่ในระดับหนึ่ง แม้หลังจากที่ผู้ร่วมสมทบคนนั้นไม่ได้ร่วมทำงานอีกต่อไปแล้ว
เมื่อโครงการที่นำโดยเผด็จการใจดีมีผู้เข้าร่วมมากขึ้น ก็มีแนวโน้มจะสร้างชั้นของผู้สมทบขึ้นสองชั้น คือผู้ร่วมสมทบปกติ กับนักพัฒนาร่วม หนทางปกติที่จะนำไปสู่การเป็นนักพัฒนาร่วม ก็คือการรับผิดชอบในองค์ประกอบใหญ่ๆ ของโครงการ และอีกทางหนึ่งคือ การรับบท `เซียนนักซ่อม' คือเป็นผู้ชี้สาเหตุและแก้บั๊กจำนวนมาก ด้วยวิธีนี้หรือวิธีใดก็ตาม นักพัฒนาร่วมก็คือ ผู้ร่วมสมทบที่ได้อุทิศเวลาจำนวนมากอย่างต่อเนื่องให้กับโครงการนั่นเอง
บทบาทของการเป็นเจ้าขององค์ประกอบย่อย มีความสำคัญโดยเฉพาะต่อการวิเคราะห์ของเรา และสมควรจะพิจารณาต่อ แฮ็กเกอร์มักจะชอบพูดว่า `อำนาจมาตามความรับผิดชอบ' โดยทั่วไปแล้ว นักพัฒนาร่วมที่รับผิดชอบดูแลองค์ประกอบที่ได้รับมอบหมาย ก็จะต้องควบคุมทั้งการทำงานภายในองค์ประกอบนั้น และการเชื่อมต่อกับส่วนที่เหลือของโครงการ ซึ่งเป็นเรื่องที่มีเพียงหัวหน้าโครงการเท่านั้นที่จะวิจารณ์แก้ไขได้ (ในฐานะสถาปนิก) เรายังสังเกตอีกว่า กฎนี้มีผลในการสร้างทรัพย์สินตามแบบจำลองของล็อคซ้อนภายในโครงการ และมีบทบาทในการป้องกันข้อขัดแย้งเหมือนกับขอบเขตของทรัพย์สินอื่นทุกประการ
โดยจารีตประเพณีแล้ว `เผด็จการ' หรือหัวหน้าโครงการในโครงการที่มีนักพัฒนาร่วม จะถูกคาดหวังให้ปรึกษานักพัฒนาร่วมก่อนตัดสินใจครั้งสำคัญๆ เสมอ โดยเฉพาะถ้าการตัดสินใจนั้นเกี่ยวข้องกับองค์ประกอบที่นักพัฒนาร่วม `เป็นเจ้าของ' (คือใช้เวลาและรับผิดชอบดูแล) อยู่ หัวหน้าที่ฉลาดและเข้าใจหน้าที่ของเขตแดนทรัพย์สินภายในของโครงการ จะไม่ก้าวก่ายหรือล้มเลิกการตัดสินใจที่กระทำโดยเจ้าขององค์ประกอบแม้แต่น้อย
โครงการที่ใหญ่มากบางโครงการไม่สนใจรูปแบบ `เผด็จการใจดี' โดยสิ้นเชิง วิธีหนึ่งก็คือ เปลี่ยนนักพัฒนาร่วมทั้งหลายให้เป็นคณะกรรมการลงคะแนนเสียง (เช่นใน Apache) อีกวิธีหนึ่งคือหมุนเวียนกันเป็นเผด็จการ ซึ่งอำนาจควบคุมจะถูกส่งต่อจากสมาชิกคนหนึ่งไปยังอีกคนหนึ่งภายในวงนักพัฒนาร่วมอาวุโส นักพัฒนา Perl จัดโครงสร้างด้วยวิธีนี้
การจัดการที่ซับซ้อนเช่นนี้ ถือกันทั่วไปว่าไม่มีเสถียรภาพ และจัดการยาก ความยุ่งยากที่เห็นได้ชัดเจนก็คือ เรื่องของความวุ่นวายที่รู้จักกันในนามของ `การออกแบบโดยคณะกรรมการ' และความวุ่นวายของคณะกรรมการเอง ปัญหาเหล่านี้เป็นที่เข้าใจกันดีในวัฒนธรรมแฮ็กเกอร์ อย่างไรก็ดี ผู้เขียนคิดว่า ความไม่สบายใจที่แฮ็กเกอร์รู้สึกต่อการใช้คณะกรรมการหรือการหมุนเวียนเก้าอี้ก็คือ มันเข้ากันได้ยากกับรูปแบบของล็อคในจิตใต้สำนึกที่แฮ็กเกอร์ใช้ในการให้เหตุผลต่อกรณีที่ง่ายกว่า จึงเป็นปัญหาในองค์กรที่ซับซ้อนเหล่านี้ที่จะรับรองการถือครอง ไม่ว่าในแง่ของการมีอำนาจควบคุมหรือการได้รับชื่อเสียง เป็นการยากที่จะเห็นการแบ่งเขตภายใน ซึ่งทำให้ยากที่จะหลีกเลี่ยงข้อขัดแย้ง นอกเสียจากว่า กลุ่มจะอยู่ในสภาพที่กลมเกลียวกันและเชื่อใจกันในระดับสูงเป็นพิเศษ
ข้อขัดแย้งและวิธียุติข้อขัดแย้ง
เราได้เห็นแล้วว่าในโครงการต่างๆ นั้น ความซับซ้อนที่เพิ่มขึ้นของบทบาทต่างๆ ถูกแสดงออกมาด้วยการกระจายอำนาจการออกแบบและสิทธิในทรัพย์สินบางส่วน ในขณะที่การกระจายนี้ถือเป็นการกระจายแรงจูงใจที่ได้ผล แต่ก็เป็นการลดทอนอำนาจของหัวหน้าโครงการไปด้วย และที่สำคัญที่สุด คือลดทอนอำนาจของหัวหน้าที่จะขจัดข้อขัดแย้งที่อาจเกิดขึ้น
ในขณะที่การถกเถียงในทางเทคนิคเกี่ยวกับการออกแบบอาจดูเป็นความเสี่ยงที่ชัดเจนต่อความขัดแย้งภายใน แต่ก็มีน้อยมากที่จะกลายเป็นสาเหตุที่ร้ายแรงของความไม่ลงรอยกัน เรื่องนี้มักจะยุติโดยง่ายด้วยกฎของเขตแดนที่ว่าอำนาจมาตามความรับผิดชอบ
อีกทางหนึ่งของการยุติข้อขัดแย้งคืออาศัยความมีอาวุโส ถ้าผู้ร่วมสมทบสองคนหรือสองกลุ่มทะเลาะกัน และการทะเลาะนั้นไม่อาจยุติอย่างเป็นกลางได้ และไม่มีฝ่ายใดเป็นเจ้าของเขตแดนที่กำลังทะเลาะกันเลย ฝ่ายที่ได้ช่วยงานในโครงการโดยรวมมามากที่สุด (กล่าวคือ ฝ่ายที่มีสิทธิในทรัพย์สินในโครงการโดยรวมมากที่สุด) ควรเป็นฝ่ายชนะ
(พูดอีกอย่างก็คือ ฝ่ายที่ได้ลงแรงมาน้อยที่สุดจะพ่ายแพ้ ซึ่งน่าสนใจที่กฎนี้บังเอิญเป็นเคล็ดเดียวกับที่ระบบฐานข้อมูลเชิงสัมพันธ์หลายระบบใช้ในการแก้ไขการติดตาย เมื่อสายงานสองสายติดตายกันในการใช้ทรัพยากร ฝ่ายที่มีการลงทุนในรายการเปลี่ยนแปลงปัจจุบันน้อยที่สุดจะถูกเลือกเป็นผู้ต้องหาที่ทำให้เกิดการติดตาย และจะถูกจบ วิธีนี้จึงเลือกรายการเปลี่ยนแปลงที่ทำงานมานานที่สุด หรือมีอาวุโสที่สุด ให้เป็นผู้ชนะเสมอ)
กฎเหล่านี้โดยทั่วไปก็เพียงพอต่อการยุติกรณีพิพาทเกือบทั้งหมดในโครงการ เมื่อไรที่มันยุติไม่ได้ ประกาศิตของหัวหน้าโครงการก็มักจะเพียงพอ หาได้ยากที่จะมีกรณีพิพาทที่สามารถผ่านด่านเหล่านี้มาได้
ตามหลักแล้ว ข้อขัดแย้งจะไม่ร้ายแรงขึ้นมานอกเสียจากเกณฑ์ทั้งสอง ("อำนาจมาตามความรับผิดชอบ" และ "ผู้มีอาวุโสชนะ") จะชี้ไปคนละทาง <emphasis>และ</emphasis> อำนาจของหัวหน้าโครงการมีน้อยหรือไม่มี กรณีที่ชัดเจนที่สุดที่เงื่อนไขนี้อาจเกิดได้ ก็คือการทะเลาะเรื่องการสืบทอด หลังจากที่หัวหน้าโครงการหายตัวไป ผู้เขียนเคยอยู่ในเหตุการณ์แบบนี้ครั้งหนึ่ง เป็นเหตุการณ์ที่น่าเกลียด เจ็บปวด ยืดเยื้อ และยุติได้ก็ต่อเมื่อทุกฝ่ายเหนื่อยหน่ายจนต้องส่งการควบคุมไปให้กับคนนอก และผู้เขียนหวังเป็นอย่างยิ่งว่าตัวเองจะไม่กรายใกล้กับเรื่องแบบนี้อีกเลย
ที่สุดแล้ว กลไกการยุติข้อขัดแย้งเหล่านี้ ก็อาศัยความพยายามของชุมชนแฮ็กเกอร์ทั้งหมดที่จะบังคับใช้ กลไกบังคับที่มีอยู่มีเพียงการด่าและหมางเมิน ซึ่งเป็นการประนามของสาธารณชนต่อผู้ที่ฝ่าฝืนจารีตประเพณี และการปฏิเสธที่จะร่วมสังฆกรรมหลังการฝ่าฝืนเท่านั้น
กลไกการถ่ายทอดวัฒนธรรมและความเชื่อมโยงกับวงการการศึกษา
รุ่นแรกๆ ของบทความนี้ได้ตั้งคำถามสำหรับค้นคว้าเพิ่มเติมว่า ชุมชนได้บอกกล่าวและชี้แนะสมาชิกเกี่ยวกับจารีตประเพณีอย่างไร? จารีตประเพณีปรากฏชัดเจนในตัวหรือว่าก่อรูปเองในระดับที่ไม่ได้เจตนาเต็มที่? หรือว่าใช้การสอนด้วยการทำให้ดูเป็นตัวอย่าง? หรือว่าใช้คำชี้แนะอย่างโจ่งแจ้ง?
แน่นอนว่าการชี้แนะอย่างโจ่งแจ้งนั้นไม่ค่อยมีให้เห็น เพราะมีคำบรรยายอย่างชัดเจนของบรรทัดฐานของวัฒนธรรมไว้ใช้ชี้แนะน้อยเกินไปนั่นเอง
บรรทัดฐานหลายอย่างจะถูกสอนด้วยตัวอย่าง ยกตัวอย่างกรณีที่ง่ายมากกรณีหนึ่งคือ เป็นธรรมเนียมที่ชุดแจกจ่ายซอฟต์แวร์ทุกชุดจะต้องมีไฟล์ชื่อ README หรือ READ.ME ที่ให้คำชี้แนะเบื้องต้นสำหรับการสำรวจส่วนต่างๆ ของชุดซอฟต์แวร์ ธรรมเนียมนี้ฝังรากเป็นอย่างดีมาตั้งแต่ต้นทศวรรษ 1980 เป็นอย่างน้อย และมีการเขียนบัญญัติไว้เป็นบางโอกาสด้วย แต่นักพัฒนาโดยทั่วไปจะทำตามแบบอย่างที่เห็นในชุดซอฟต์แวร์ทั้งหลายมากกว่า
ในทางตรงกันข้าม จารีตประเพณีบางอย่างของแฮ็กเกอร์ ก็ก่อร่างขึ้นเองเมื่อแต่ละคนได้เกิดความเข้าใจพื้นฐาน (และอาจจะโดยไม่รู้ตัว) เกี่ยวกับเกมแห่งชื่อเสียง แฮ็กเกอร์ส่วนใหญ่ไม่จำเป็นต้องมีใครสอนเลย ถึงเรื่องข้อห้ามสามข้อที่ผู้เขียนได้แสดงมาก่อนแล้วในบทความนี้ หรืออย่างน้อย ถ้าถูกถามก็จะตอบว่ามันชัดเจนในตัวเองอยู่แล้ว มากกว่าจะได้รับการถ่ายทอดจากคนอื่น ปรากฏการณ์นี้ชวนให้วิเคราะห์เจาะลึกลงไปอีก และบางทีเราอาจพบคำอธิบายจากกระบวนการที่แฮ็กเกอร์ได้เรียนรู้เกี่ยวกับจารีตประเพณีก็เป็นได้
หลายวัฒนธรรมใช้เคล็ดลับที่ปกปิด (หรือที่ถูกต้องกว่า คือ `ความลึกลับ' ในแง่ความเชื่อและศาสนา) เป็นกลไกถ่ายทอดวัฒนธรรม เคล็ดลับเหล่านี้เป็นความลับที่ไม่เปิดเผยต่อคนนอก แต่คาดหวังให้ผู้เริ่มต้นที่ศรัทธาได้ค้นพบหรืออนุมานเอาเอง และเพื่อที่จะได้รับการยอมรับเข้าในกลุ่ม บุคคลจะต้องแสดงให้เห็น ว่าตนนั้นทั้งเข้าใจความลึกลับนั้น และได้เรียนรู้มันด้วยวิธีที่ถูกต้องตามครรลองของวัฒนธรรม
วัฒนธรรมแฮ็กเกอร์ใช้เคล็ดลับหรือการทดสอบประเภทนี้อย่างหนักและจงใจอย่างไม่ธรรมดา เราสามารถเห็นกระบวนการนี้ทำงานในสามระดับเป็นอย่างน้อย:
ความลึกลับบางชนิดที่คล้ายรหัสผ่าน ตัวอย่างหนึ่งก็คือ มีกลุ่มข่าว Usenet ชื่อ alt.sysadmin.recovery ที่มีความลับชนิดนี้อย่างชัดเจน คุณจะไม่สามารถโพสต์ได้ถ้าไม่รู้ความลับนั้น และการรู้ความลับนั้น ก็ถือเป็นหลักฐานแสดงว่าคุณมีความเหมาะสมพอที่จะโพสต์ ขาประจำจะมีกฎเหล็กห้ามเปิดเผยความลับนี้อย่างเด็ดขาด
เงื่อนไขพื้นฐานของการเริ่มต้นเข้าสู่ความลึกลับทางเทคนิค บุคคลต้องซึมซับความรู้ทางเทคนิคพอประมาณ ก่อนที่จะสามารถให้ของขวัญที่มีค่าได้ (ตัวอย่างเช่น ต้องรู้ภาษาคอมพิวเตอร์หลักๆ อย่างน้อยหนึ่งภาษา) เงื่อนไขนี้ทำหน้าที่ต่อสังคมใหญ่ในลักษณะเดียวกับที่เคล็ดลับทำกับสังคมเล็ก โดยเป็นตัวกลั่นกรองคุณภาพต่างๆ (เช่น ความสามารถในการคิดเชิงนามธรรม ความมุ่งมั่น และความยืดหยุ่นทางอารมณ์) ที่มีความสำคัญต่อการทำงานภายในวัฒนธรรม
ความลึกลับเกี่ยวกับบริบทของสังคม บุคคลจะเข้ามามีส่วนร่วมในวัฒนธรรมด้วยการผูกพันตัวเองกับโครงการบางโครงการ แต่ละโครงการก็คือบริบททางสังคมสดๆ ของแฮ็กเกอร์ ที่ผู้ที่จะมาร่วมสมทบจะต้องติดตามวิเคราะห์และทำความเข้าใจในแง่สังคมพอๆ กับในแง่เทคนิคเพื่อที่จะเริ่มทำตัวให้เป็นประโยชน์ได้ (พูดให้เป็นรูปธรรมก็คือ ทางหนึ่งที่จะเรียนรู้ ก็ด้วยการอ่านหน้าเว็บ และ/หรือ บันทึกเมลของโครงการ) ด้วยกลุ่มโครงการเหล่านี้นี่เอง ที่ผู้เริ่มต้นจะเรียนรู้ตัวอย่างพฤติกรรมของแฮ็กเกอร์ที่มีประสบการณ์
ในกระบวนการเรียนรู้ความลึกลับเหล่านี้ ผู้ที่จะเป็นแฮ็กเกอร์จะเก็บเกี่ยวความรู้ที่ (หลังจากเรียนรู้มาระยะหนึ่ง) ทำให้ข้อห้ามสามข้อและจารีตประเพณีอื่นๆ ดู `ชัดเจนในตัวเอง'
อย่างไรก็ดี บางคนอาจแย้งว่า ตัวโครงสร้างของวัฒนธรรมการให้ของแฮ็กเกอร์เองนั่นแหละ ที่เป็นความลึกลับที่สำคัญที่สุด คุณจะไม่ถูกนับว่าได้เข้าร่วมวัฒนธรรม (พูดให้เป็นรูปธรรมก็คือ จะไม่มีใครเรียกคุณว่าแฮ็กเกอร์) จนกว่าคุณจะแสดงให้เห็นถึงความเข้าใจอย่างถึงกึ๋น เกี่ยวกับเกมแห่งชื่อเสียง พร้อมทั้งนัยเกี่ยวกับจารีตประเพณี ข้อห้าม และการปฏิบัติ แต่ประเด็นนี้ไม่ได้เป็นเรื่องใหญ่อะไร ทุกวัฒนธรรมต่างก็ต้องการความเข้าใจเช่นว่าจากผู้ที่จะเข้าร่วมอยู่แล้ว นอกจากนี้ วัฒนธรรมแฮ็กเกอร์ก็ยังไม่แสดงความปรารถนาที่จะเก็บความคิดและครรลองของมันไว้เป็นความลับแต่อย่างใด หรืออย่างน้อยที่สุด ก็ยังไม่มีใครด่าผู้เขียนที่ได้เปิดเผยเรื่องเหล่านี้เลย!
ผู้แสดงความเห็นต่อบทความนี้จำนวนมากจนสาธยายไม่หมด ได้ชี้ว่า จารีตประเพณีเรื่องการถือครองของแฮ็กเกอร์ดูจะเกี่ยวข้องอย่างใกล้ชิดกับ (และอาจได้โดยตรงมาจาก) ธรรมเนียมปฏิบัติของวงการการศึกษา โดยเฉพาะแวดวงวิจัยทางวิทยาศาสตร์ แวดวงวิจัยนี้มีปัญหาที่คล้ายกันในการวินิจฉัยความคิดต่างๆ ที่อาจให้ผลิตผลสูง และได้แสดงคำตอบแบบยืดหยุ่นที่คล้ายกันต่อปัญหาที่ว่า ด้วยวิธีที่ใช้การประเมินผลโดยหมู่ชนและชื่อเสียง
เนื่องจากแฮ็กเกอร์หลายคนผ่านการบ่มเพาะมาจากโลกการศึกษา (เป็นเรื่องปกติที่จะฝึกแฮ็กตั้งแต่ขณะเรียนในโรงเรียน) ระดับที่การศึกษามีรูปแบบร่วมกันกับวัฒนธรรมแฮ็กเกอร์จึงน่าสนใจไม่น้อย ในการทำความเข้าใจการประยุกต์จารีตประเพณีเหล่านี้
ความคล้ายคลึงกันที่ชัดเจนกับ `วัฒนธรรมการให้' ของแฮ็กเกอร์เท่าที่ผู้เขียนสังเกตได้ มีอยู่มากมายในวงการการศึกษา เมื่อนักวิจัยได้ตำแหน่งงานแล้ว ก็ไม่จำเป็นต้องกังวลเรื่องความอยู่รอดอีก (อันที่จริงแล้ว แนวคิดเรื่องตำแหน่งงานนี้ อาจสืบย้อนกลับไปในวัฒนธรรมการให้ระยะแรกๆ ที่ ``นักปรัชญาธรรมชาติ'' ทั้งหลาย โดยมากก็เป็นพวกผู้ดีมีฐานะที่มีเวลาพอที่จะอุทิศให้กับงานวิจัยได้) เมื่อไม่มีห่วงเรื่องความอยู่รอด การสร้างชื่อเสียงจึงกลายเป็นเป้าหมายขับดัน ซึ่งกระตุ้นให้เกิดการแบ่งปันความคิดใหม่ๆ และงานวิจัย ผ่านวารสารวิชาการและสื่ออื่นๆ เรื่องนี้น่าเชื่อถืออย่างเป็นกลางได้ เพราะงานวิจัยทางวิทยาศาสตร์ซึ่งเหมือนกับวัฒนธรรมแฮ็กเกอร์นั้น อาศัยแนวคิด `ยืนบนไหล่ยักษ์' และไม่ต้องค้นคว้าเรื่องพื้นฐานซ้ำแล้วซ้ำเล่าเป็นหลักนั่นเอง
บางท่านไปไกลถึงขนาดชี้แนะว่า จารีตประเพณีของแฮ็กเกอร์เป็นแค่ภาพสะท้อนหนึ่งของครรลองของแวดวงวิจัยเท่านั้น และ (โดยส่วนใหญ่) ได้ถูกนำไปใช้โดยแฮ็กเกอร์แต่ละคน ความเห็นนี้อาจจะเกินเลยไปหน่อย เพราะเด็กมัธยมเก่งๆ หลายคนก็ดูเหมือนจะรับเอาจารีตประเพณีของแฮ็กเกอร์ไปใช้เรียบร้อยแล้ว!
การให้ดีกว่าการแลกเปลี่ยน
ตรงจุดนี้มีเรื่องเป็นไปได้ที่น่าสนใจกว่านั้นอยู่ ผู้เขียนตั้งข้อสงสัยว่า การที่วงการการศึกษากับวัฒนธรรมแฮ็กเกอร์มีรูปแบบร่วมกัน ไม่น่าจะเป็นเพราะมีความเกี่ยวพันกันโดยกำเนิด แต่น่าจะเป็นเพราะทั้งสองวงการต่างพัฒนาโครงสร้างทางสังคมที่เหมาะสมที่สุดสำหรับสิ่งที่มุ่งจะทำ ภายใต้กฎแห่งธรรมชาติ และการเชื่อมโยงอย่างแนบแน่นกับสัญชาตญาณของมนุษย์ คำตัดสินของประวัติศาสตร์ดูเหมือนจะบอกว่า ทุนนิยมแบบตลาดเสรีเป็นวิธีที่ดีที่สุดในการร่วมมือเพื่อให้เกิดประสิทธิภาพทางเศรษฐกิจ และบางที ด้วยวิธีที่คล้ายกัน วัฒนธรรมการให้ที่อาศัยเกมแห่งชื่อเสียงก็อาจเป็นวิธีที่ดีที่สุดในการร่วมมือเพื่อสร้าง (และตรวจสอบ!) งานสร้างสรรค์ที่มีคุณภาพสูงเช่นกัน
สิ่งที่สนับสนุนแนวคิดนี้ มาจากการศึกษาทางจิตวิทยาจำนวนมาก เกี่ยวกับการส่งผลระหว่างงานศิลปะกับรางวัล <link linkend="GNU">[GNU]</link> การศึกษาเหล่านี้ได้รับความสนใจน้อยกว่าที่ควร ส่วนหนึ่งอาจเป็นเพราะผู้เผยแพร่ได้แสดงเจตนาที่จะตีความเกินจริง จนกลายเป็นการโจมตีต่อตลาดเสรีและทรัพย์สินทางปัญญา อย่างไรก็ดี ผลการศึกษาเหล่านี้ได้บ่งชี้ว่า การให้รางวัลตามแบบเศรษฐศาสตร์ที่ขาดแคลนนั้น แท้ที่จริงแล้วได้ลดผลิตภาพของคนทำงานสร้างสรรค์อย่างโปรแกรมเมอร์ลง
Theresa Amabile นักจิตวิทยาของมหาวิทยาลัย Brandeis ได้สรุปไว้อย่างรัดกุมเกี่ยวกับผลของการศึกษาในปี 1984 เรื่องแรงกระตุ้นกับรางวัล โดยตั้งข้อสังเกตว่า ``เป็นไปได้ที่งานที่ให้ส่วนแบ่งค่าตอบแทนโดยทั่วไปจะสร้างสรรค์น้อยกว่างานที่มาจากความสนใจล้วนๆ'' Amabile สังเกตต่อไปว่า ``ยิ่งกิจกรรมซับซ้อนเท่าใด ก็จะถูกบั่นทอนด้วยรางวัลภายนอกได้มากเท่านั้น'' ซึ่งน่าสนใจว่าการศึกษานี้บ่งชี้ว่าการจ่ายเงินเดือนระดับเดียว ไม่ได้ลดแรงกระตุ้นลงเลย แต่การจ่ายเป็นรายชิ้นและโบนัสสามารถลดแรงกระตุ้นได้
ดังนั้น จึงอาจเป็นความฉลาดทางเศรษฐกิจที่จะให้โบนัสตอบแทนประสิทธิภาพกับพนักงานปิ้งเบอร์เกอร์หรือขุดท้องร่อง แต่อาจฉลาดกว่าถ้าจะแยกเงินเดือนออกจากประสิทธิภาพในแผนกเขียนโปรแกรม แล้วให้พนักงานเลือกโครงการเอง (เป็นแนวโน้มสองอย่างที่โลกโอเพนซอร์สได้ข้อสรุปตามเหตุผล) อันที่จริงแล้ว ผลการศึกษาเหล่านี้ยังบอกด้วยว่า เวลาเดียวที่สมควรจะให้รางวัลประสิทธิภาพดีในงานเขียนโปรแกรม ก็คือตอนที่โปรแกรมเมอร์มีความกระตือรือร้นมากเสียจนสามารถทำงานได้โดยไม่ต้องมีรางวัล!
นักวิจัยคนอื่นในสาขาเดียวกันพร้อมจะชี้ตรงไปที่ประเด็นที่เกาะกุมจิตใจของแฮ็กเกอร์มากๆ เกี่ยวกับความเป็นเอกเทศและการควบคุมความคิดสร้างสรรค์ ``ยิ่งแฮ็กเกอร์รู้สึกว่าสามารถตัดสินใจด้วยตัวเองได้จำกัดเท่าไร'' Richard Ryan ผู้ช่วยศาสตราจารย์สาขาจิตวิทยาของมหาวิทยาลัยโรเชสเตอร์กล่าว ``ความคิดสร้างสรรค์ของเขาก็จะลดลงมากเท่านั้น''
โดยทั่วไปแล้ว การทำให้เห็นว่างานใดก็ตามเป็นเพียงหนทาง แทนที่จะเป็นเป้าหมายในตัวเอง จะทำให้ขาดแรงกระตุ้น แม้แต่การชนะการแข่งขันกับผู้อื่น หรือการได้ความเคารพจากผู้อื่น ก็สามารถลดแรงกระตุ้นในทำนองเดียวกันนี้ได้ ถ้ามีความรู้สึกว่าชัยชนะเป็นการทำงานเพื่อรางวัล (ซึ่งอาจใช้อธิบายได้ว่า ทำไมวัฒนธรรมจึงห้ามแฮ็กเกอร์แสวงหาหรือกล่าวตู่ความเคารพจากคนอื่น)
ความซับซ้อนในงานบริหารยังไม่จบแค่นั้น การควบคุมการตอบกลับด้วยคำพูด ก็ดูจะทำลายแรงกระตุ้นพอๆ กับการจ่ายค่าตอบแทนเป็นชิ้นงาน Ryan พบว่า พนักงานบริษัทที่หัวหน้าบอกว่า ``ดีแล้ว คุณทำในสิ่งที่ <emphasis>สมควร</emphasis> แล้ว'' นั้น ``ให้แรงจูงใจภายในน้อยกว่าคนที่ได้รับคำตอบที่มีข้อมูลมากนัก''
การให้แรงจูงใจก็ยังเป็นสิ่งที่ฉลาด แต่จะต้องไม่มีอะไรพ่วงท้ายอันจะทำให้มันไม่ได้ผล มีความแตกต่างอย่างมาก (Ryan ตั้งข้อสังเกต) ระหว่างการพูดว่า ``ผมให้รางวัลนี้แก่คุณ เพราะผมเห็นคุณค่าในงานของคุณ'' กับ ``คุณได้รับรางวัลนี้ เพราะคุณสามารถทำได้ตามมาตรฐานที่ตั้งไว้'' อย่างแรกนั้นไม่ทำลายแรงกระตุ้น แต่อย่างหลังนั้นทำลายแน่นอน
ด้วยการสังเกตการณ์ทางจิตวิทยาเหล่านี้ เราสามารถระบุกรณีที่กลุ่มพัฒนาโอเพนซอร์สจะมีผลิตผลมากกว่า (โดยเฉพาะในระยะยาว ซึ่งความคิดสร้างสรรค์จะมีความสำคัญมากขึ้นๆ ในฐานะปัจจัยเพิ่มผลิตผล) กลุ่มโปรแกรมเมอร์ซอร์สปิดที่มีขนาดและความเชี่ยวชาญเท่าๆ กัน ที่ได้รับ (การบั่นทอน) แรงกระตุ้นจากรางวัลภายใต้ข้อสมมุติของความขาดแคลน
ข้อสังเกตนี้มองจากมุมมองที่ต่างกันเล็กน้อยจากการคาดเดาใน <citetitle>มหาวิหารและตลาดสด</citetitle> ชี้ว่า ในที่สุดแล้ว วิธีการสร้างซอฟต์แวร์แบบโรงงานอุตสาหกรรมนั้น ถูกกำหนดไว้แล้วให้พ่ายแพ้ โดยเริ่มตั้งแต่จุดที่ทุนนิยมเริ่มสร้างความมั่งคั่งมากพอที่โปรแกรมเมอร์จะสามารถอยู่ได้ในวัฒนธรรมการให้ในยุคหลังความขาดแคลน
อันที่จริงแล้ว ดูเหมือนว่าสูตรแห่งผลิตภาพสูงสุดของการสร้างซอฟต์แวร์นี้ แทบจะเป็นปริศนาเซ็นทีเดียว ถ้าคุณต้องการจะทำการผลิตอย่างมีประสิทธิภาพสูงสุด คุณต้องเลิกพยายามที่จะ <emphasis>ทำ</emphasis> ให้โปรแกรมเมอร์ทำการผลิต จัดการกับความพออยู่พอกินของพวกเขา ให้พวกเขาได้ใช้สมองเต็มที่ แล้วก็ลืมเรื่องเส้นตายไปเสีย สำหรับผู้จัดการปกติ เรื่องนี้ดูจะเป็นความเคยตัวที่บ้าบอ และจะต้องล่มจมในที่สุด แต่ก็ <emphasis>เป็น</emphasis> สูตรที่วัฒนธรรมโอเพนซอร์สกำลังใช้เพื่อเอาชนะการแข่งขันอยู่ทุกวันนี้
ข้อสรุป: จากจารีตประเพณีสู่กฎจารีต
เราได้ตรวจสอบจารีตประเพณีต่างๆ ที่คอยกำหนดกฎเกณฑ์การถือครองและการควบคุมโครงการซอฟต์แวร์โอเพนซอร์สมาแล้ว เราได้เห็นว่าจารีตประเพณีเหล่านี้แฝงนัยของทฤษฎีทรัพย์สินเบื้องหลังที่คล้ายกับทฤษฎีของล็อคว่าด้วยกรรมสิทธิ์ที่ดิน เราได้เชื่อมโยงเรื่องนี้ไปสู่การวิเคราะห์วัฒนธรรมแฮ็กเกอร์ว่าเป็น `วัฒนธรรมการให้' ที่ผู้เข้าร่วมจะแข่งขันเพื่อเกียรติยศ ด้วยการอุทิศเวลา แรงกายแรงใจ และความคิดสร้างสรรค์ให้ เราได้ตรวจสอบนัยของการวิเคราะห์นี้ต่อการยุติข้อขัดแย้งในวัฒนธรรมด้วย
คำถามที่ตามมาก็คือ "ทำไมเรื่องนี้จึงสำคัญ?" แฮ็กเกอร์ได้พัฒนาจารีตประเพณีเหล่านี้โดยปราศจากการวิเคราะห์โดยเจตนา และ (จวบจนปัจจุบัน) ได้ประพฤติตามโดยปราศจากการวิเคราะห์โดยเจตนาเช่นกัน จึงยังไม่เป็นที่กระจ่างทันทีทันใดว่าการวิเคราะห์โดยเจตนาได้ให้ประโยชน์อะไรในทางปฏิบัติ นอกจากเราจะสามารถเคลื่อนจากการสาธยายมาเป็นบทบัญญัติ และสรุปหนทางที่จะเพิ่มบทบาทหน้าที่ของจารีตประเพณีเหล่านี้
เราได้เห็นอุปมาอุปมัยที่ใกล้เคียงของจารีตประเพณีของแฮ็กเกอร์ในทฤษฎีกรรมสิทธิ์ที่ดิน ภายใต้ธรรมเนียมกฎหมายจารีตประเพณีของแองโกล-อเมริกันมาแล้ว ตามประวัติศาสตร์แล้ว <link linkend="miller">[Miller]</link> วัฒนธรรมชนเผ่าของชาวยุโรปที่ได้สร้างธรรมเนียมนี้ขึ้นมา ได้พัฒนาระบบตัดสินข้อพิพาทต่อไปอีก ด้วยการเคลื่อนจากระบบของจารีตประเพณีที่ไม่มีการบอกกล่าว ไม่บังคับโดยเจตนา มาเป็นกฎจารีตที่ชัดเจนที่ท่องจำโดยนักปราชญ์ของชนเผ่า และจดบันทึกเป็นลายลักษณ์อักษรในที่สุด
จากการที่ประชากรของวัฒนธรรมเราเพิ่มมากขึ้น และการถ่ายทอดวัฒนธรรมให้กับสมาชิกใหม่ก็ยากขึ้น บางทีอาจถึงเวลาแล้ว ที่วัฒนธรรมแฮ็กเกอร์จะทำสิ่งที่คล้ายกัน คือการร่างบทบัญญัติของวิธีปฏิบัติที่ดี สำหรับการติดสินข้อพิพาทชนิดต่างๆ ที่อาจมีขึ้นโดยเกี่ยวข้องกับโครงการโอเพนซอร์ส และประเพณีของการไกล่เกลี่ย ซึ่งสมาชิกอาวุโสของชุมชนอาจถูกขอร้องให้เป็นคนกลางไกล่เกลี่ยข้อพิพาท
การวิเคราะห์ในบทความนี้ได้แนะแนวทางต่อเค้าโครงของบทบัญญัติดังกล่าว และได้ตีแผ่สิ่งที่เคยแฝงตัวอยู่ให้ปรากฏชัดเจน เราไม่สามารถจะเขียนบทบัญญัติใดๆ จากการวิเคราะห์ที่ผ่านมา แต่จะต้องอาศัยความสมัครใจของผู้ก่อตั้งหรือเจ้าของโครงการต่างๆ ที่จะนำไปใช้เอง และทั้งหมดก็ไม่ใช่เป็นกฎตายตัว เพราะแรงกดดันต่อวัฒนธรรมก็มีแนวโน้มจะเปลี่ยนไปตามกาลเวลา และท้ายที่สุด เพื่อที่จะให้การบังคับใช้ของบทบัญญัติดังกล่าวมีผล ก็จำเป็นต้องสะท้อนประชามติในวงกว้างของชนเผ่าแฮ็กเกอร์ด้วย
ผู้เขียนได้เริ่มร่างบทบัญญัติดังกลาวแล้ว โดยอาจจะใช้ชื่อว่า "ระเบียบพิธีมาลเวิร์น" (Malvern Protocol) ตามชื่อเมืองเล็กๆ ที่ผู้เขียนอาศัยอยู่ ถ้าการวิเคราะห์ทั่วไปในบทความนี้ได้รับการยอมรับมากพอ ผู้เขียนอาจปล่อยระเบียบวิธีมาลเวิร์นสู่สาธารณะ เพื่อเป็นบทบัญญัติตุ๊กตาสำหรับการตัดสินข้อพิพาท ผู้ที่สนใจที่จะวิจารณ์และร่วมปรับปรุงบทบัญญัตินี้ หรือเพียงให้ข้อเสนอแนะว่าควรทำหรือไม่ ก็ขอเชิญ <ulink url="mailto:esr@thyrsus.com">ติดต่อผู้เขียนทางอี-เมล</ulink> ได้
คำถามเพื่อการค้นคว้าเพิ่มเติม
ความเข้าใจของตัววัฒนธรรม (และของผู้เขียนเอง) เกี่ยวกับโครงการขนาดใหญ่ที่ไม่ได้ใช้การจัดการแบบเผด็จการใจดี ยังไม่ค่อยชัดเจนนัก โครงการส่วนใหญ่จะล้มเหลว แต่ก็มีโครงการจำนวนหนึ่งประสบความสำเร็จอย่างงดงาม และกลายเป็นโครงการที่สำคัญ (Perl, Apache, KDE) ยังไม่มีใครเข้าใจอย่างแท้จริง ว่าความแตกต่างอยู่ที่ไหน มีเพียงความรู้สึกเลือนๆ โดยทั่วไปว่า โครงการเหล่านี้ต่าง <emphasis>มีเอกลักษณ์เฉพาะตัว</emphasis> ซึ่งจะตั้งอยู่หรือล้มไปก็แล้วแต่ความเปลี่ยนแปลงในกลุ่มของสมาชิกแต่ละคน แต่เรื่องนี้เป็นความจริงหรือ? หรือว่ายังมีกุศโลบายแบบอย่างที่กลุ่มอื่นสามารถดำเนินตามได้อีก?
เชิงอรรถ
<anchor id="N"/><emphasis>[N]</emphasis> คำว่า `noosphere' เป็นศัพท์ชั้นสูงของศิลปวิทยาการในสาขาปรัชญา คำนี้ออกเสียงว่า โน-โอ-สเฟียร์ (เสียงโอสองพยางค์ พยางค์แรกยาวและเน้น พยางค์ที่สองสั้นและไม่เน้น คล้ายเสียง schwa) ถ้าคุณเคร่งครัดเรื่องการเขียนมากๆ คำนี้ก็อาจจะสะกดโดยใช้ diaresis บน `o' ตัวที่สอง เพื่อกำกับการแยกพยางค์
ในรายละเอียดแล้ว คำซึ่งแทน ``โลกแห่งความคิดของมนุษย์'' คำนี้ มาจากรากศัพท์กรีก `noos' ซึ่งหมายถึง `ความคิด' (mind), `ความฉลาด' (intelligence), หรือ `โลกทัศน์' (perception) คิดขึ้นโดย E. LeRoy ใน <emphasis>Les origines humaines et l'evolution de l'intelligence</emphasis> (Paris 1928) และเผยแพร่ให้เป็นที่รู้จักโดยนักชีววิทยาและนักนิเวศวิทยารุ่นบุกเบิกชาวรัสเซีย ชื่อ Vladimir Ivanovich Vernadsky, (1863–1945) และจากนั้นก็โดยนักบรรพชีวินวิทยาและนักปรัชญาเยซูอิด ชื่อ Pierre Teilhard de Chardin (1881–1955) ซึ่งก็ด้วยทฤษฎีของ Teilhard de Chardin เกี่ยวกับวิวัฒนาการในอนาคตของมนุษย์ไปสู่รูปแบบของการพัฒนาทางจิตใจขั้นสุดยอดร่วมกับพระผู้เป็นเจ้านี่เอง ที่ทำให้ศัพท์คำนี้มีความเชื่อมโยงอย่างมากในปัจจุบัน
<anchor id="DF"/><emphasis>[DF]</emphasis> David Friedman นักคิดที่แจ่มชัดและเข้าใจง่ายที่สุดคนหนึ่งในแวดวงเศรษฐศาสตร์ปัจจุบัน ได้เขียน <ulink url="http://www.best.com/~ddfr/Academic/Course_Pages/L_and_E_LS_98/Why_Is_Law/Why_Is_Law_Chapter_11.html">เค้าโครง</ulink> อันยอดเยี่ยมของประวัติศาสตร์และตรรกะของกฎหมายทรัพย์สินทางปัญญา ผู้เขียนขอแนะนำบทความนี้ สำหรับเป็นจุดเริ่มต้นของผู้ที่สนใจในหัวข้อดังกล่าว
<anchor id="BSD"/><emphasis>[BSD]</emphasis> ความแตกต่างหนึ่งที่น่าสนใจระหว่างโลกของลินุกซ์และ BSD ก็คือ เคอร์เนลลินุกซ์ (และโปรแกรมอรรถประโยชน์ข้างเคียง) ไม่เคยมีการฟอร์ก แต่ BSD นั้นฟอร์กมาแล้วอย่างน้อยสามครั้ง สิ่งที่ทำให้ความแตกต่างนี้น่าสนใจก็คือว่า โครงสร้างทางสังคมของกลุ่ม BSD ทั้งหลายนั้น รวมศูนย์โดยมีเจตนาที่จะกำหนดสายอำนาจหน้าที่ที่ชัดเจน และเพื่อป้องกันการฟอร์ก ในขณะที่ชุมชนลินุกซ์ซึ่งกระจายอำนาจและรวมกันแบบหลวมๆ นั้น ไม่มีมาตรการเหล่านั้นเลย กลายเป็นว่า โครงการที่เปิดกว้างด้านการพัฒนาที่สุด ในความเป็นจริงกลับมีแนวโน้ม <emphasis>น้อยที่สุด</emphasis> ที่จะเกิดการฟอร์ก!
Henry Spencer <email>henry@spsystems.net</email> ชี้แนะว่า โดยทั่วไปแล้ว เสถียรภาพของระบบการเมืองจะแปรผกผันกับความสูงของกำแพงที่ขวางกั้นกระบวนการทางการเมือง การวิเคราะห์ของเขาสมควรจะนำมากล่าวอ้างในที่นี้:
จุดแข็งที่สำคัญจุดหนึ่งของประชาธิปไตยที่เปิดก็คือ กลุ่มต่างๆ ที่มีแนวโน้มที่จะปฏิวัติ จะพบว่าการดำเนินการเพื่อบรรลุจุดประสงค์โดยผ่านระบบนั้น ง่ายกว่าการโจมตีระบบ จุดแข็งนี้จะถูกทำลายลงอย่างง่ายดาย ถ้ามีกลุ่มบุคคลตั้งตัวกระทำการร่วมกันที่จะ `ก่อกำแพง' และทำให้กลุ่มเล็กๆ บางกลุ่มมองเห็นความคืบหน้า <emphasis>บางอย่าง</emphasis> ที่นำไปสู่เป้าหมายของพวกเขาได้ยากยิ่งขึ้น
(หลักการที่คล้ายกันนี้ พบได้ในเศรษฐศาสตร์เช่นกัน ตลาดเปิดจะมีการแข่งขันที่เข้มข้นที่สุด และโดยทั่วไปจะทำให้ได้สินค้าที่ดีและถูกที่สุดด้วย ด้วยเหตุนี้ จึงเป็นความสนใจหลักของบริษัทที่ปักหลักได้แล้ว ที่จะพยายามทำให้การเข้าสู่ตลาดทำได้ยากยิ่งขึ้น เช่น ด้วยการโน้มน้าวรัฐบาลให้กำหนดการทดสอบ RFI กับคอมพิวเตอร์ หรือด้วยการสร้างมาตรฐาน `ประชามติ' ที่ยุ่งยากซับซ้อน จนไม่สามารถทำให้เป็นจริงจากการเริ่มต้นใหม่ได้โดยปราศจากทรัพยากรมหาศาล ตลาดที่มีกำแพงขวางกั้นการเข้าสู่ตลาดที่แข็งที่สุด ก็จะต้องเผชิญกับการโจมตีที่รุนแรงที่สุดจากการปฏิวัติเช่นกัน ตัวอย่างเช่น กรณีอินเทอร์เน็ตและกระทรวงยุติธรรม กับ Bell System เป็นต้น)
กระบวนการเปิดที่มีกำแพงขวางกั้นการเข้าร่วมที่ต่ำ จะเชื้อเชิญให้ผู้คนเข้าร่วมมากกว่าแยกตัว เพราะสามารถได้ผลลัพธ์โดยไม่ต้องสิ้นเปลืองกับการแยกตัว ผลลัพธ์ที่ได้อาจไม่ประทับใจเท่ากับที่ได้จากการแยกตัว แต่ก็ได้มาด้วยต้นทุนที่ต่ำกว่า และคนส่วนใหญ่ก็จะถือว่านั่นเป็นการแลกเปลี่ยนที่ยอมรับได้ (เมื่อรัฐบาลสเปนยกเลิกกฎหมายต่อต้านชาวบาสก์ของนายพลฟรังโก และสร้างโรงเรียนให้จังหวัดต่างๆ ของชาวบาสก์ พร้อมทั้งให้มีการปกครองส่วนท้องถิ่นเป็นเอกเทศ ปรากฏว่า ความเคลื่อนไหวแบ่งแยกดินแดนของชาวบาสก์อันตรธานไปสิ้นแทบจะในชั่วข้ามคืน มีเพียงพวกมาร์กซิสต์หัวรุนแรงเท่านั้นที่ยังยืนยันว่านั่นยังไม่เพียงพอ)
<anchor id="rp"/><emphasis>[RP]</emphasis> มีรายละเอียดปลีกย่อยนิดหน่อยเกี่ยวกับแพตช์เถื่อน เราอาจแบ่งประเภทแพตช์เถื่อนออกเป็นแบบที่ `เป็นมิตร' และแบบที่ `ไม่เป็นมิตร' แพตช์ที่ `เป็นมิตร' นั้น มุ่งหมายที่จะรวมกลับเข้าไปในซอร์สสายหลักของโครงการ ภายใต้การควบคุมของผู้ดูแล (ไม่ว่าการรวมนั้นจะเกิดขึ้นหรือไม่ก็ตาม) ส่วนแพตช์ที่ `ไม่เป็นมิตร' นั้น มุ่งที่จะดึงเอาโครงการไปในทิศทางที่ผู้ดูแลไม่เห็นด้วย บางโครงการ (โดยเฉพาะเคอร์เนลลินุกซ์เอง) ค่อนข้างจะปล่อยตามสบายกับแพตช์ที่เป็นมิตร หรือกระทั่งเชื้อเชิญให้แจกจ่ายแยกต่างหาก โดยถือเป็นส่วนหนึ่งของขั้นตอนการทดสอบแพตช์ ในทางกลับกัน แพตช์ที่ไม่เป็นมิตรเป็นการแสดงถึงการตัดสินใจที่จะแข่งกับฉบับดั้งเดิม และถือเป็นเรื่องที่ร้ายแรง การดูแลแพตช์ที่ไม่เป็นมิตรทั้งกระบุง มีแนวโน้มที่จะนำไปสู่การฟอร์กได้
<anchor id="lw"/><emphasis>[LW]</emphasis> ผู้เขียนเป็นหนี้ต่อ Michael Funk <email>mwfunk@uncc.campus.mci.net</email> ที่ชี้ให้เห็นว่า ความตรงข้ามกันระหว่างวัฒนธรรมแฮกเกอร์กับจารชนนั้น ช่วยให้คำอธิบายที่ดีอย่างไร Linus Walleij ได้โพสต์การวิเคราะห์พลวัตของวัฒนธรรมของพวกเขา ซึ่งต่างจากที่ผู้เขียนวิเคราะห์ (ที่บรรยายวัฒนธรรมนั้นว่าเป็นวัฒนธรรมบนพื้นฐานของความขาดแคลน) ไว้ในบทความ <ulink url="http://www.df.lth.se/~triad/papers/Raymond_D00dz.html">A Comment on `Warez D00dz' Culture</ulink>
ความต่างนี้อาจกำลังหมดไป Andrej Brandt <email>andy@pilgrim.cs.net.pl</email> อดีตนักเจาะระบบรายงานว่า เขาเชื่อว่าวัฒนธรรมนักเจาะระบบ หรือ warez d00dz กำลังเหี่ยวแห้งตายไป เมื่อคนเก่งๆ และนักเจาะชั้นนำได้ค่อยๆ ย้ายมาสู่โลกโอเพนซอร์ส อีกหลักฐานหนึ่งเกี่ยวกับเรื่องนี้ก็คือ ปฏิบัติการ กรกฎาคม 1999 ซึ่งทำลายแบบอย่างเดิมๆ ทิ้ง โดยกลุ่มที่เรียกตัวเองว่า `Cult of the Dead Cow' พวกเขาได้ปล่อย `Back Orifice 2000' ที่ใช้ทำลายระบบความปลอดภัยของวินโดวส์ ภายใต้สัญญาอนุญาต GPL
<anchor id="HT"/><emphasis>[HT]</emphasis> ในแง่ของวิวัฒนาการแล้ว แรงผลักดันของช่างฝีมือเอง (อย่างเดียวกับการเกิดคุณธรรมภายใน) อาจจะเป็นผลมาจากการที่การหลอกลวงนั้น มีความเสี่ยงสูงและสิ้นเปลือง นักจิตวิทยาเชิงวิวัฒนาการได้รวมรวมหลักฐานจากการทดลอง <link linkend="BCT">[BCT]</link> ว่ามนุษย์มีตรรกะของสมองที่สร้างมาเฉพาะเพื่อตรวจจับการหลอกลวงในสังคม และก็เข้าใจได้ไม่ยากเลย ว่าทำไมบรรพบุรุษของเราจึงควรถูกเลือกไว้เพราะความสามารถในการตรวจจับการโกงนี้ ดังนั้น ถ้าใครอยากจะมีชื่อเสียงในด้านบุคลิกลักษณะที่นำมาซึ่งข้อได้เปรียบ แต่มีความเสี่ยงและต้นทุนสูง ก็เป็นการดีกว่าถ้าจะเลือกแนวทางของการมีความสามารถนั้นๆ จริงๆ แทนที่จะมีแบบปลอมๆ (``ความซื่อสัตย์คือกุศโลบายที่ดีที่สุด'')
นักจิตวิทยาเชิงวิวัฒนาการได้ชี้แนะว่า หลักการนี้อธิบายพฤติกรรมเหมือนการต่อสู้ในบาร์ ในหมู่มนุษย์ผู้ชายที่โตเต็มวัยนั้น การมีชื่อเสียงในความแข็งแรงมีประโยชน์ทั้งในทางสังคมและทางเพศ (แม้ในบรรยากาศที่เต็มไปด้วยอิทธิพลของนักสิทธิสตรีอย่างทุกวันนี้) อย่างไรก็ดี ความแข็งแรงที่จอมปลอมกลับเป็นความเสี่ยงอย่างมาก ผลทางลบของการถูกเปิดโปงจะทำให้คนคนนั้นอยู่ในฐานะที่แย่ยิ่งกว่าการไม่เคยกล่าวอ้างอะไรเลย ต้นทุนของการหลอกลวงนั้นสูงเสียจนบางทีการปรับให้เป็นการสร้างความแข็งแรงภายใน แล้วเสี่ยงรับความบาดเจ็บสาหัสในการต่อสู้เพื่อพิสูจน์ให้เห็นเลยยังจะดีเสียกว่า มีการการสังเกตที่คล้ายกันนี้ต่อเรื่องที่เป็นที่กังขาน้อยกว่าอย่างความซื่อสัตย์ด้วย
แม้ไม่ควรดูถูกรางวัลในลักษณะที่คล้ายการฝึกสมาธิของงานสร้างสรรค์ แต่ความปรารถนาของช่างฝีมืออย่างน้อยก็อาจมีลักษณะบางส่วนคล้ายกับการสร้างความแข็งแรงภายในดังกล่าว (โดยที่ลักษณะที่เป็นพื้นฐานก็คือ `ความอดทนต่องานยากลำบาก' หรืออะไรที่คล้ายกัน)
ทฤษฎีการต่อแต้มก็อาจมีความเกี่ยวข้องด้วย หางอันฉูดฉาดของนกยูง และกิ่งก้านจำนวนมากของเขากวางตัวผู้นั้น แลดูเซ็กซี่ในสายตาของตัวเมีย เพราะมันสื่อสารออกมาถึงสุขภาพที่ดีของตัวผู้ (ซึ่งหมายถึงความเหมาะสมที่จะเป็นพ่อพันธุ์ของลูกๆ ที่แข็งแรงด้วย) สิ่งที่มันพูดก็คือ: "ฉันแข็งแรงมากเสียจนสามารถจะเสียพลังงานไปมากมายสำหรับการโชว์อันฟุ่มเฟือยนี้" การให้ซอร์สโค้ดออกไปมากมาย ก็เหมือนกับการมีรถสปอร์ตสักคัน คือคล้ายกับอาภรณ์อันโอ่อ่าฟู่ฟ่าเหล่านั้น มันเป็นการให้ที่ไร้ผลตอบแทนที่ชัดเจน และอย่างน้อยก็ทำให้ผู้ให้ดูเซ็กซี่มากๆ ในทางทฤษฎี
<anchor id="MH"/><emphasis>[MH]</emphasis> มีการสรุปที่กระชับเกี่ยวกับลำดับชั้นของมาสโลว์และทฤษฎีที่เกี่ยวข้องบนเว็บที่ <ulink url="http://www.valdosta.peachnet.edu/~whuitt/psy702/regsys/maslow.html">Maslow's Hierarchy of Needs</ulink>
<anchor id="dc"/><emphasis>[DC]</emphasis> อย่างไรก็ดี ความต้องการความอ่อนน้อมถ่อมตนของผู้นำ อาจเป็นลักษณะของวัฒนธรรมการให้หรือวัฒนธรรมเหลือเฟือที่มีโดยทั่วไปมากกว่านั้น David Christie <email>dc@netscape.com</email> รายงานการเดินทางไปยังเกาะรอบนอกของฟิจิไว้ว่า:
``ในตัวหัวหน้าหมู่บ้านทั้งหลายในฟิจินั้น เราสังเกตได้ถึงสไตล์ความเป็นผู้นำที่ลดตัวลงต่ำ ชนิดเดียวกับที่คุณบรรยายผู้นำโครงการโอเพนซอร์ส [...] แม้จะได้รับความเคารพอย่างมาก และแน่นอนว่าย่อมมีอำนาจแท้จริงทุกอย่างที่มีในฟิจิ แต่พวกหัวหน้าที่เราได้พบต่างแสดงความอ่อนน้อมอย่างจริงใจ และมักจะยอมรับในภาระหน้าที่ของตนราวกับนักบุญ เรื่องนี้ยิ่งน่าสนใจเข้าไปอีก เมื่อการเป็นหัวหน้าเป็นบทบาทที่สืบทอดโดยสายเลือด ไม่ได้มาจากการเลือกตั้ง หรือจากการประกวดประขันคะแนนนิยมแต่อย่างใด พวกเขาถูกฝึกฝนด้วยวิถีทางบางอย่างของตัววัฒนธรรมเอง ถึงแม้พวกเขาจะเกิดมาเพื่อเป็นผู้นำโดยตรง ไม่ได้มาจากการเลือกของผองชน'' เขาเน้นต่อไปว่า เขาเชื่อว่าคุณลักษณะของผู้นำชาวฟิจินี้ เกิดจากความยากลำบากของการบังคับขอความร่วมมือ กล่าวคือ หัวหน้าไม่มี ``บำเหน็จรางวัลชิ้นใหญ่หรือคทาอาญาสิทธิ์''
<anchor id="no"/><emphasis>[NO]</emphasis> จากการสังเกตแล้ว ผู้ที่สามารถก่อตั้งโครงการที่ประสบความสำเร็จ จะได้รับเกียรติยศมากกว่าผู้ที่อาจจะทำงานในปริมาณที่เทียบเท่ากันในการแก้บั๊กหรือช่วยพัฒนาโครงการที่ประสบความสำเร็จ บทความนี้ฉบับเผยแพร่รุ่นก่อนได้ตั้งคำถามไว้ว่า ``เรื่องนี้ถือเป็นการให้คุณค่าของความพยายามอย่างสมเหตุสมผลแล้ว หรือว่าเป็นผลทางอ้อมของหลักการประกาศถิ่นอย่างไม่เจตนาที่เราได้เสนอไป ณ ที่นี้?'' มีผู้แสดงความเห็นหลายท่านได้เสนอแนะทฤษฎีที่น่าเชื่อถือ และมีใจความหลักเหมือนกัน การวิเคราะห์โดย Ryan Waldron <email>rew@erebor.com</email> ต่อไปนี้ เป็นตัวอย่างที่ดี:
ในบริบทของทฤษฎีที่ดินของล็อคแล้ว ผู้ที่ก่อตั้งโครงการใหม่ที่ประสบความสำเร็จนั้น ถือว่าได้ค้นพบหรือบุกเบิกดินแดนใหม่ ซึ่งผู้อื่นสามารถเข้าไปปักหลักได้ สำหรับโครงการที่ประสบความสำเร็จทั้งหลาย จะมีรูปแบบผลตอบแทนที่ค่อยๆ ลดลง ซึ่งทำให้เมื่อเวลาผ่านไประยะหนึ่ง เครดิตของการร่วมพัฒนาโครงการก็จะถูกเจือจาง จนยากที่ผู้มาทีหลังจะไต่เต้าจนได้ชื่อเสียงได้ ไม่ว่างานของเขาจะยอดเยี่ยมเพียงใดก็ตาม
ตัวอย่างเช่น ผมจะต้องทำงานดีขนาดไหน ในการแก้โค้ดของ perl เพื่อให้คนอื่นมองเห็นแม้เศษเสี้ยวของความมีส่วนร่วมของผม อย่างที่ Larry, Tom, Randall และคนอื่นๆ ได้รับมาแล้ว?
อย่างไรก็ดี ถ้าพรุ่งนี้มีโครงการใหม่ตั้งขึ้นมา [โดยคนอื่น] แล้วผมก็เป็นผู้เข้าร่วมคนแรกๆ และบ่อยๆ โอกาสที่ผมจะมีส่วนร่วมในชื่อเสียงที่มากับโครงการที่ประสบความสำเร็จนั้น ย่อมเพิ่มขึ้นอย่างมาก ในฐานะที่ผมเข้าร่วมแต่เนิ่นๆ (โดยสมมุติว่า คุณภาพของงานที่เข้าร่วมนั้น พอๆ กัน) ผมคิดว่า เรื่องนี้คล้ายกันกับกรณีผู้ร่วมลงทุนกับไมโครซอฟท์ตอนต้นๆ เมื่อเทียบกับผู้ที่เข้าร่วมในภายหลัง ทุกคนอาจได้กำไรทั้งนั้น แต่คนที่เข้าร่วมก่อนย่อมได้มากกว่า ดังนั้น ผมจึงสนใจในระดับหนึ่งที่จะเข้าร่วม IPO ที่ใหม่และประสบความสำเร็จ มากกว่าจะเข้าร่วมในการเพิ่มทุนของหุ้นบริษัทที่มีอยู่แล้ว
การเปรียบเปรยของ Ryan Waldron สามารถขยายต่อไปได้อีก ผู้ก่อตั้งโครงการจำเป็นต้องเร่ขายความคิด ซึ่งอาจได้รับการยอมรับหรือนำไปใช้หรือไม่ก็ได้ ดังนั้น เขาจึงต้องพบกับบางสิ่งที่คล้ายกับความเสี่ยงของ IPO (ที่จะเสื่อมเสียชื่อเสียง) มากกว่าคนอื่นๆ ที่เข้าช่วยโครงการที่ได้สั่งสมความเชื่อถือจากหมู่ชนมาแล้ว รางวัลสำหรับผู้ก่อตั้งจึงคงที่ แม้ว่าโดยแท้จริงแล้ว ผู้ร่วมพัฒนาจะทำงานเพิ่มเข้าไปมากกว่า เรื่องนี้เห็นได้ชัดว่าคล้ายกันกับเรื่องความสัมพันธ์ระหว่างความเสี่ยงกับรางวัลในเศรษฐศาสตร์แบบแลกเปลี่ยน
ผู้ร่วมแสดงความเห็นท่านอื่นๆ ยังได้สังเกตว่า ระบบประสาทของเรา ถูกปรับมาเพื่อให้สัมผัสกับความแตกต่าง ไม่ใช่กับสถานะคงที่ การเปลี่ยนแปลงแบบปฏิวัติวงการโดยมีโครงการใหม่เป็นหลักฐาน จึงสังเกตได้ง่ายกว่าผลสะสมของการพัฒนาที่ต่อเนื่องอย่างคงที่ ดังนั้น ไลนัสจึงได้รับความเคารพในฐานะบิดาแห่งลินุกซ์ แม้ว่าผลสุทธิของการพัฒนาจากผู้เข้าร่วมอื่นๆ เรือนพัน จะมีส่วนช่วยในความสำเร็จของ OS นี้เกินกว่าที่งานของคนคนหนึ่งจะทำได้ก็ตาม
<anchor id="HD"/><emphasis>[HD]</emphasis> คำว่า ``ทำลายตลาด'' (de-commoditize) นี้ อ้างไปถึง <ulink url="http://www.opensource.org/halloween/">เอกสารวันฮัลโลวีน</ulink> ซึ่งไมโครซอฟท์ได้ใช้คำว่า ``ทำลายตลาด'' อย่างตรงไปตรงมา ในการเรียกนโยบายระยะยาวที่ทรงประสิทธิภาพที่สุดในการผูกมัดลูกค้าไว้ โดยอาศัยการผูกขาดอย่างแกมโกง
<anchor id="KN"/><emphasis>[KN]</emphasis> ผู้ร่วมแสดงความเห็นท่านหนึ่งชี้ว่า คุณค่าที่อยู่รอบๆ บรรทัดฐานที่ว่า ``คุณจะไม่เป็นแฮ็กเกอร์จนกว่าแฮ็กเกอร์คนอื่นจะเรียกคุณว่าแฮ็กเกอร์'' นี้ คล้ายกันกับอุดมคติที่กล่าวอ้าง (ถ้าไม่ใช่บรรลุ) โดยสังคมอื่นที่เชื่อมั่นในความสำเร็จด้วยตนเอง ในกลุ่มผู้นำทางสังคมซึ่งร่ำรวยพอที่จะหนีพ้นเศรษฐกิจแบบขาดแคลนที่รายล้อม ตัวอย่างเช่น ในอุดมคติของยุโรปสมัยกลางเกี่ยวกับความเป็นอัศวินนั้น อัศวินผู้ใฝ่ฝันจะถูกคาดหวังให้ต่อสู้เพื่อความถูกต้อง ให้แสวงหาเกียรติศักดิ์ศรีแทนที่จะได้มาเฉยๆ ให้ยืนหยัดเคียงข้างผู้ที่อ่อนแอและถูกกดขี่ และให้แสวงหาความท้าทายอย่างสม่ำเสมอ ที่จะทดสอบความเก่งกล้าของตนอย่างถึงที่สุด สิ่งที่ผู้ใฝ่ฝันจะเป็นอัศวินจะได้รับเป็นการตอบแทน คือสามารถเรียกตัวเอง (และโดยผู้อื่น) ว่าเป็นหนึ่งในสุดยอดผู้กล้า แต่ต้องหลังจากที่ความสามารถและคุณค่าของเขาได้รับการยอมรับและรับรองจากอัศวินคนอื่นแล้วเท่านั้น ในอุดมคติของอัศวินที่ได้รับการสรรเสริญจากเรื่องกษัตริย์อาเธอร์และ Chansons de Geste นั้น เราจะพบการคละเคล้าของอุดมการณ์ การท้าทายตัวเองอย่างต่อเนื่อง และการแสวงหาสถานภาพ คล้ายกับสิ่งที่อยู่ในตัวแฮ็กเกอร์ทั้งหลายในทุกวันนี้ จึงดูเป็นไปได้ ที่คุณค่าและบรรทัดฐานการปฏิบัติที่คล้ายกัน จะพัฒนาเกี่ยวเนื่องกับความสามารถที่ทั้งต้องการการอุทิศตนอย่างใหญ่หลวง และเกี่ยวข้องกับอำนาจบางอย่าง
<anchor id="GNU"/><emphasis>[GNU]</emphasis> เว็บไซต์หลักของมูลนิธิซอฟต์แวร์เสรีได้เสนอ <ulink url="http://www.gnu.org/philosophy/motivation.html">บทความหนึ่ง</ulink> ซึ่งสรุปผลของการศึกษาเหล่านี้จำนวนมาก คำพูดทั้งหลายเกี่ยวกับเรื่องนี้ในบทความนี้ ก็คัดลอกมาจากบทความดังกล่าว
บรรณานุกรม
<anchor id="miller"/><emphasis>[Miller]</emphasis> Miller, William Ian; <emphasis>Bloodtaking and Peacemaking: Feud, Law, and Society in Saga Iceland</emphasis>; University of Chicago Press 1990, ISBN 0-226-52680-1. การศึกษาที่น่าตื่นตาตื่นใจเกี่ยวกับกฎชุมนุมชนของชาวไอซ์แลนด์ ซึ่งทั้งให้ความกระจ่างเกี่ยวกับบรรพบุรุษของทฤษฎีทรัพย์สินของล็อค และบรรยายถึงช่วงหลังๆ ของกระบวนการทางประวัติศาสตร์ ซึ่งจารีตประเพณีได้กลายมาเป็นกฎหมายจารีตประเพณี แล้วจึงเป็นกฎหมายลายลักษณ์อักษร
<anchor id="Mal"/><emphasis>[Mal]</emphasis> Malaclypse the Younger; <emphasis>Principia Discordia, or How I Found Goddess and What I Did To Her When I Found Her</emphasis>; Loompanics, ISBN 1-55950-040-9. มีความเปิ่นที่เร้าใจมากมายที่สามารถพบได้ใน Discordianism ในจำนวนนี้ `หลักการ SNAFU' ได้วิเคราะห์อย่างค่อนข้างตรงไปตรงมา ว่าทำไมระบบยศศักดิ์จึงไม่สามารถปรับตัวตามขนาดได้ดี มี <ulink url="http://www.cs.cmu.edu/~tilt/principia/">ฉบับ HTML</ulink> ด้วย
<anchor id="BCT"/><emphasis>[BCT]</emphasis> J. Barkow, L. Cosmides, and J. Tooby (Eds.); <emphasis>The Adapted Mind: Evolutionary Psychology and the Generation of Culture.</emphasis> New York: Oxford University Press 1992. หนังสือปูพื้นอันยอดเยี่ยมเกี่ยวกับจิตวิทยาเชิงวิวัฒนาการ บทความบางเรื่องในนี้ เกี่ยวข้องโดยตรงกับเรื่องของวัฒนธรรมสามชนิดที่ผู้เขียนได้กล่าวถึง (ยศศักดิ์/แลกเปลี่ยน/การให้) โดยได้ชี้แนะว่ารูปแบบเหล่านี้ ผูกพันแนบแน่นในจิตใจมนุษย์อย่างลึกล้ำพอสมควร
<anchor id="MHG"/><emphasis>[MHG]</emphasis> Goldhaber, Michael K.; <ulink url="http://www.firstmonday.dk/issues/issue2_4/goldhaber">The Attention Economy and the Net</ulink>. ผู้เขียนไปพบบทความนี้หลังจากที่ได้เขียนบทความของผู้เขียนเองรุ่นที่ 1.7 ไปแล้ว บทความนี้มีข้อผิดพลาดที่เห็นได้ชัดอยู่ (ในเรื่องการให้เหตุผลของ Goldhaber เกี่ยวกับความไร้ผลของการใช้เหตุผลเชิงเศรษฐศาสตร์กับเรื่องการให้ความสนใจ ซึ่งไม่มีการตรวจสอบอย่างละเอียดเท่าที่ควร) แต่ Goldhaber ก็ยังมีสิ่งขบขันและลุ่มลึกที่จะพูด เกี่ยวกับบทบาทของการเรียกร้องความสนใจต่อการจัดโครงสร้างของพฤติกรรม เกียรติยศหรือชื่อเสียงในหมู่ชนที่ผู้เขียนได้พูดถึง อาจมองอย่างแตกฉานได้ว่าเป็นเพียงกรณีเฉพาะกรณีหนึ่งของการให้ความสนใจในมุมมองของเขา
<anchor id="HH"/><emphasis>[HH]</emphasis> ผู้เขียนได้สรุปประวัติศาสตร์ของวัฒนธรรมแฮ็กเกอร์ใน <ulink url="http://www.tuxedo.org/~esr/faqs/hacker-hist.html">A Brief History Of Hackerdom</ulink>. หนังสือที่จะอธิบายได้ดีจริงๆ ยังต้องเขียนกันต่อไป อาจจะไม่ใช่โดยผู้เขียนเอง
กิตติกรรมประกาศ
Robert Lanphier <email>robla@real.com</email> ได้ร่วมสมทบมากมายในการอภิปรายเรื่องพฤติกรรมที่ไร้อัตตา Eric Kidd <email>eric.kidd@pobox.com</email> ได้ช่วยเน้นบทบาทของการให้ความสำคัญกับความอ่อนน้อมถ่อมตน ในการป้องกันการบูชาตัวบุคคล หัวข้อเกี่ยวกับผลต่อภาพรวมได้รับแรงบันดาลใจจากความเห็นของ Daniel Burn <email>daniel@tsathoggua.lab.usyd.edu.au</email> Mike Whitaker <email>mrw@entropic.co.uk</email> ได้ให้แรงบันดาลใจต่อเนื้อหาหลักในหัวข้อกลไกการถ่ายทอดวัฒนธรรม Chris Phoenix <email>cphoenix@best.com</email> ได้ชี้ถึงความสำคัญของการที่แฮ็กเกอร์ไม่อาจได้ชื่อเสียงด้วยการถล่มแฮ็กเกอร์คนอื่น A.J. Venter <email>JAVenter@africon.co.za</email> ได้ชี้ให้เห็นความคล้ายคลึงกับอุดมคติของอัศวินในยุคกลาง Ian Lance Taylor <email>ian@airs.com</email> ได้วิจารณ์อย่างระมัดระวังเกี่ยวกับโมเดลเกมแห่งชื่อเสียง ซึ่งกระตุ้นให้ผู้เขียนต้องคิดทบทวน และอธิบายข้อสมมุติของผู้เขียนให้ชัดเจนยิ่งขึ้น
Theppitak Karoonboonyanan <thep@linux.thai.net>, 2006 | https://linux.thai.net/~thep/catb/homesteading/ | Open Publication License v2 |
คำตาม | คำตาม : พ้นไปกว่าซอฟต์แวร์?
เอริก
สตีเวน
เรย์มอนด์
Thyrsus Enterprises
esr@thyrsus.com
$Date: 2004-06-21 05:19:15 $
นี่คือรุ่น 3.0
2543
เอริก เอส. เรย์มอนด์
สงวนลิขสิทธิ์
อนุญาตให้ทำสำเนา แจกจ่าย และ/หรือ แก้ไขเอกสารนี้ได้ ภายใต้เงื่อนไขของ Open Publication License รุ่น 2.0
1.1
16 สิงหาคม 2542
esr
รุ่นนี้ถูกใช้ในฉบับพิมพ์ครั้งแรก
บรรดาความเรียงต่าง ๆ ในหนังสือเล่มนี้เป็นจุดเริ่มต้น แต่ไม่ใช่จุดสิ้นสุด ยังมีคำถามมากมายที่ยังไม่ได้รับคำตอบเกี่ยวกับซอฟต์แวร์โอเพนซอร์ส และยังมีคำถามอีกมากมายเกี่ยวกับงานสร้างสรรค์และทรัพย์สินทางปัญญาประเภทอื่น ๆ ที่ปรากฏการณ์โอเพนซอร์สได้จุดประเด็นขึ้น แต่ไม่ได้เสนอแนะถึงคำตอบที่ดีอย่างจริงจัง
ผมมักถูกถามว่า ผมเชื่อหรือไม่ว่าตัวแบบโอเพนซอร์สนั้นสามารถประยุกตใช้ให้เป็นประโยชน์กับผลิตภัณฑ์อื่น ๆ นอกเหนือจากซอฟต์แวร์ได้ โดยส่วนใหญ่คำถามมักถามเกี่ยวกับงานดนตรี หรือเนื้อหาทำนองหนังสือ หรือการออกแบบคอมพิวเตอร์หรือฮาร์ดแวร์อิเล็กทรอนิกส์ บ่อยเกือบพอ ๆ กัน ที่ผมถูกถามว่าผมคิดหรือไม่ว่าตัวแบบโอเพนซอร์สนั้นมีความหมายโดยนัยทางการเมือง
ไม่ใช่ว่าผมไม่มีความคิดเห็นเกี่ยวกับงานดนตรี หนังสือ ฮาร์ดแวร์ หรือการเมือง แม้ความคิดเห็นเหล่านั้นบางอันก็เกี่ยวข้องอย่างยิ่งกับแนวคิดเกี่ยวกับการตรวจสอบโดยผู้มีฐานะเสมอกัน การกระจายไม่รวมศูนย์ และความเปิดกว้างซึ่งถูกสำรวจในหนังสือเล่มนี้ ขอเชิญผู้อ่านที่สนใจเยี่ยมชม<ulink url="http://www.tuxedo.org/~esr">หน้าเว็บของผม</ulink>และคิดต่อจากนั้นด้วยตัวเอง อย่างไรก็ตาม ผมจงใจหลีกเลี่ยงการคาดเดาในสิ่งเหล่านั้นโดยเชื่อมโยงจากงานของผม ในฐานะที่ผมเป็นนักทฤษฎีและทูตของโอเพนซอร์ส
หลักการนั้นเรียบง่าย: <emphasis>รบทีละสนาม</emphasis> พวกผมเข้าร่วมการต่อสู้อันยากลำบาก เพื่อจะยกระดับความคาดหวังต่อคุณภาพและความน่าเชื่อถือของผู้บริโภคซอฟต์แวร์ และเพื่อจะโค่นกระบวนการมาตรฐานที่เป็นอยู่ในอุตสาหกรรมซอฟต์แวร์ เราพบคู่ต่อสู้ที่ตั้งป้อมป้องกันอย่างแน่นหนา มีทั้งทุนมหาศาล ทั้งผู้คนที่เห็นพ้องกัน และทั้งอำนาจผูกขาด นี่ไม่ใช่การต่อสู้ที่ง่ายเลย แต่ทั้งตรรกะและเศรษฐศาสตร์นั้นชัดเจน เราชนะได้ และเราจะชนะ <emphasis>ถ้า</emphasis>เราไม่ละสายตาจากเป้าหมายนั้น
การมีสมาธิกับจุดมุ่งหมายดังกล่าวนั้น ต้องอาศัยความแน่วแน่ไม่วอกแวกกับสิ่งไม่สำคัญเล็ก ๆ น้อย ๆ นี่เป็นประเด็นที่ผมมักต้องเน้นเสมอเวลาผมพูดกับแฮกเกอร์คนอื่น ๆ เพราะที่ผ่านมาตัวแทนของเราได้แสดงแนวโน้มที่จะทำอะไรแบบอุดมการณ์ ในขณะที่พวกเขาจะมีประสิทธิภาพกว่านี้มาก ถ้ายึดอยู่กับข้อถกเถียงที่เฉพาะเจาะจงและไปในแนวปฏิบัติมากกว่า
ใช่ ความสำเร็จของโอเพนซอร์สที่กล่าวมานั้น นำไปสู่คำถามต่อสาระประโยชน์ของระบบสั่งการและควบคุม ของการเก็บเป็นความลับ ของการรวมศูนย์ และของทรัพย์สินทางปัญญาบางชนิด จะว่าเสแสร้งก็คงได้ หากจะไม่ยอมรับว่ามันแนะให้เห็นถึง (หรืออย่างน้อยก็ไปกันได้ดีกับ) มุมมองเสรีนิยมอย่างกว้าง ๆ ของความสัมพันธ์ระหว่างเหล่าปัจเจกและเหล่าสถาบัน
อย่างไรก็ดี แม้จะมีประเด็นเหล่านี้ สำหรับผมแล้ว ผมเห็นว่ามันเหมาะสมกว่าที่จะพยายามเลี่ยงการนำเอาความคิดเหล่านี้ไปใช้อย่างเกินพอดีในตอนนี้ ตัวอย่างในกรณีนี้คือหนังสือส่วนใหญ่และงานดนตรีนั้นไม่เหมือนกับซอฟต์แวร์ เพราะโดยทั่วไปแล้วมันไม่จำเป็นต้องมีการดีบั๊กหรือดูแลรักษา ในเมื่อไม่มีความต้องการดังกล่าว ประโยชน์ของการตรวจสอบโดยผู้มีฐานะเสมอกันก็น้อยลงไปมาก และแรงกระตุ้นที่สมเหตุผลสำหรับการโอเพนซอร์สก็แทบจะหมดไป ผมไม่ต้องการจะทำให้ข้อโต้แย้งที่มีแววชนะจะต้องอ่อนลง ด้วยการนำเอาไปใช้ในที่ที่มีทางจะแพ้
ผมคาดหวังให้ขบวนการโอเพนซอร์สชนะเป้าประสงค์เกี่ยวกับซอฟต์แวร์ภายในสามถึงห้าปี (นั่นคือ ภายในปี 2546–2548) เมื่อเป้าดังกล่าวสำเร็จ และผลลัพธ์ของมันได้แสดงให้เห็นอย่างชัดเจนเป็นระยะเวลาหนึ่ง พวกเขาจะกลายเป็นส่วนหนึ่งของวัฒนธรรมเบื้องหลังของกลุ่มที่ไม่ใช่โปรแกรมเมอร์ และ ณ <emphasis>จุดนั้น</emphasis>นั่นเอง ที่จะเหมาะสมกว่าที่จะเริ่มใช้ทัศนะแบบโอเพนซอร์สกับงานด้านอื่น ๆ
ในระหว่างนี้ แม้พวกเราเหล่าแฮกเกอร์จะไม่ได้พร่ำบ่นอุดมการณ์เกี่ยวกับเรื่องเหล่านี้เลย พวกเราก็ยังกำลังเปลี่ยนแปลงโลกอยู่ดี
Arthit Suriyawongkul <arthit@gmail.com>, 2009. | https://linux.thai.net/~thep/catb/afterword/ | Open Publication License b2 |
คู่มือภาษาไทย Ubuntu Desktop Guide | Ubuntu desktop guide
ubuntuclub.com
คำนำ
ทุกวันนี้คงปฏิเสธไม่ได้แล้วว่าระบบปฏิบัติการลินุกซ์นั้นเข้ามามีบทบาทในชีวิตของเรามากขึ้นทุกที ทั้งเว็บไซต์ต่างๆที่เราเข้าไปใช้งานที่นิยมใช้ Apache เป็นเว็บเซิร์ฟเวอร์กันเป็นส่วนใหญ่ หรือแม้แต่เว็บไซต์เสริชเอ็นจิ้นอันดับหนึ่งของโลกอย่าง Google ก็ยังใช้ Python ในการเขียนโปรแกรม ซึ่งเราคงต้องยกความดีให้แก่ Open Source, โครงการ GNU และนักพัฒนาทั้งหลายที่ร่วมสร้างสรรค์ซอฟต์แวร์ Open Source ให้พัฒนาขึ้นมาได้อย่างรวดเร็ว ถ้าเราจะลองมองย้อนกลับไปถึงช่วงที่ IBM เปิดมาตรฐานของเครื่องคอมพิวเตอร์ส่วนบุคคล ทำให้เกิดบริษัทมากมายเข้ามาผลิตเครื่องคอมพิวเตอร์ในแบบที่เราเรียกว่า IBM Compatible จนกระทั่งเกิดการแข่งขันสูงขึ้น ส่งผลให้คอมพิวเตอร์ส่วนบุคคลมีการพัฒนาไปอย่างรวดเร็ว มองกลับมาที่โมเดลของ Open Source ที่มีการเปิดเผยรหัสพัฒนาให้ทุกคนเข้าถึง และต่อยอดการพัฒนาต่อไปได้อย่างไม่มีข้อจำกัด ซึ่งก็มีความคล้ายคลึงกันกับกรณีของ IBM
เกี่ยวกับหนังสือเล่มนี้ ผมเขียนขึ้นมาอย่างไม่ละเอียดเหมือนกับหนังสือเล่มอื่นที่คุณได้เคยอ่าน ซึ่งผมเลือกเขียนและอธิบายเฉพาะส่วนที่สำคัญๆ และในส่วนที่เป็นรายละเอียดปลีกย่อม ผมเลือกที่จะละไว้ โดยผมเข้าใจว่ากลุ่มผู้ที่อ่านหนังสือเล่มนี้ จะเป็นผู้ที่ใช้ระบบปฏิบัติการ Windows มาในระดับหนึ่งแล้ว หมายความว่าไม่ได้เริ่มศึกษาคอมพิวเตอร์จากศูนย์ ฉะนั้นบางอย่างที่คุณผู้อ่านจะมีทักษะมาจากการใช้ Windows บ้างแล้ว ผมจึงขออนุญาตไม่อธิบาย
ศิระ นกยูงทอง
สารบัญ
Unit 1: เกริ่นนำ 8
พูดคุย 8
แนะนำ Ubuntu 8
จุดเด่น 9
Unit 2: ติดตั้ง 11
ดาวน์โหลด 11
ตรวจสอบความสมบูรณ์ของไฟล์ 13
สร้างแผ่นซีดี 15
ติดตั้ง 18
Unit3: การใช้งานเบื้องต้น 22
รู้จักกับระบบไฟล์และโฟลเดอร์ 22
เปิดเครื่อง 24
หน้าจอการทำงาน 25
เมนูหลักของ Ubuntu 26
เมนู Applications 26
เมนู Places 28
เมนู System 28
ปรับแต่งการแสดงผล 29
ความละเอียดหน้าจอ 29
เปลี่ยนภาพพื้นหลัง 30
เปลี่ยนและตั้งชุดตกแต่ง 31
องค์ประกอบของชุดตกแต่ง 32
เพิ่มและปรับแต่ง Panel 33
เพิ่ม/ลบ/ย้าย Panel 33
Object Panel 33
เปลี่ยนฟอนต์ที่ใช้แสดงผล 34
แนะนำโปรแกรมพื้นฐาน 35
File Manager 35
ส่วนต่างๆใน Nautilus 35
เทคนิคในการใช้งาน 36
Web Browser 36
ตั้งค่าภาษาไทย 37
Movie Player 38
Music Player 38
Image Editor 39
Image Viewer 39
Office Suite 40
การตั้งค่าเพื่อใช้งานภาษาไทย 41
Chat MSN 42
ตั้งค่าแชท MSN 42
Email Client 43
ตั้งค่าเพื่อใช้งานภาษาไทย 44
Dictionary 44
ตั้งค่าเพื่อแปลภาษาไทย 45
การติดตั้งโปรแกรมเพิ่มเติม 45
เพิ่ม Repository 45
ทดลองติดตั้งโปรแกรม 47
Unit 4: Tips 49
กู้คืนไฟล์ที่ถูกลบ 49
พิมพ์ภาษาไทย 49
ปรับแต่งให้แสดงผลภาษาไทย 50
จับภาพหน้าจอ 51
ดูหนังฟังเพลง 52
เขียนซีดี 52
ล๊อกอินเข้าระบบแบบอัตโนมัติ 54
Startup Programs (เปิดโปรแกรมอัตโนมัติ) 55
เพิ่ม User 55
การบีบอัดไฟล์ และคลายไฟล์ที่ถูกบีบอัด 56
เพิ่มแบบอักษร 57
ตั้งค่าส่วนตัวและเปลี่ยนรหัสผ่าน 58
กู้รหัสผ่าน 58
/etc/book 59
ก่อนที่เราจะไปลงเนื้อหาในส่วนต่างๆนั้น ในบทแรกผมจะเกริ่นนำ ในส่วนของเรื่องราวต่างๆที่เกี่ยวกับลินุกซ์และ Ubuntu กันก่อนนะครับ เพื่อให้ท่านผู้อ่านที่ยังไม่คุ้นเคยกับลินุกซ์หรือ Ubuntu ได้ทำความเข้าใจกันก่อน สำหรับท่านที่มีความรู้พื้นฐานดีอยู่แล้วจะข้ามไปบทต่อไปเลยก็ได้ครับ ไม่ว่ากัน
ผมเชื่อว่าทุกท่านที่กำลังอ่านหนังสือเล่มนี้อยู่ น่าจะพอรู้จักลินุกซ์ดีอยู่แล้วในระดับหนึ่ง ใช่ครับ อย่างที่คุณรู้ดีอยู่แล้ว ว่าลินุกซ์เป็นระบบปฏิบัติการชั้นยอดตัวหนึ่งของโลก ไม่ว่าจะเป็นการใช้งานในด้านใดก็ตาม เพราะฉะนั้นไม่มีเหตุผลใดๆที่เราจะไม่ควรใช้ลินุกซ์ แม้ว่าในขณะนี้เราจะเห็นว่าลินุกซ์นั้น ยังไม่เป็นที่แพร่หลายในการใช้งานด้านเดสก์ทอปก็ตาม แต่ไม่นานความนิยมในการใช้งานลินุกซ์ในฝั่งเดสก์ทอปจะเพิ่มมากขึ้นอย่างแน่นอน เพราะผู้คนส่วนใหญ่เริ่มให้ความสนใจกับระบบปฏิบัติการตัวนี้กันอย่างต่อเนื่อง แม้แต่คุณผู้อ่านเองก็ตาม
Ubuntu นั้นเป็นลินุกซ์ดิสโทรที่กำลังเป็นที่นิยมที่สุดในขณะนี้ คำว่าลินุกซ์ดิสโทร (Linux Distribution) หมายถึงลินุกซ์สำเร็จรูปที่มีการปรับแต่งเพื่อให้เหมาะแก่การใช้งานแล้วในระดับหนึ่ง ลินุกซ์ดิสโทรที่เป็นที่รู้จักกันดีก็คงจะหนีไม่พ้นลินุกซ์ตัวดังๆ เช่น Redhat, SUSE, Mandriva เป็นต้น เหล่านี้จัดว่าเป็นลินุกซ์ดิสโทรตัวหนึ่ง ส่วน Ubuntu นั้นจัดเป็นดิสโทรที่พัฒนาโดยอิงจาก Debian GNU/Linux เป็นฐานในการพัฒนา หรือจะเรียกว่าเป็นการต่อยอดก็ดูจะไม่ผิดนัก
สาเหตุที่ทำให้ Ubuntu เป็นที่นิยมอย่างรวดเร็วนั้นคงเป็นเพราะ Ubuntu คัดโปรแกรมที่ใช้สำหรับงานต่างๆมาให้เป็นอย่างดีแล้ว แทนที่จะเป็นเหมือนดิสโทรอื่นที่ยัดโปรแกรมประเภทเดียวกันมาหลายตัวเกินความจำเป็น ทำให้ผู้ใช้อาจเกิดความสับสนว่าควรจะใช้โปรแกรมไหนเพื่อทำงานนั้นๆดี ทำให้ Ubuntu นั้นมีแผ่นติดตั้งเพียงหนึ่งแผ่นเท่านั้น และยังแยกแผ่นสำหรับใช้งานในรูปแบบเดสก์ทอป กับแบบเซิร์ฟเวอร์ออกจากกันอีกด้วย เพื่อให้ง่ายแก่การดาวน์โหลดและป้องกันความสับสน
นอกจากที่ได้กล่าวมาแล้วนั้น อีกเหตุผลหนึ่งซึ่งทำให้ Ubuntu เป็นที่นิยมคือ บริษัท Canonical ผู้พัฒนา Ubuntu ได้ให้สัญญากับผู้ใช้ไว้ว่า Ubuntu จะเป็นลินุกซ์ที่เสรีตลอดไป ทำให้ผู้ใช้มั่นใจได้ว่าจะสามารถใช้งาน Ubuntu โดยปราศจากค่าใช้จ่ายได้ตลอดไป ซึ่งจะแตกต่างจาก Redhat หรือ Mandriva ในบางเวอร์ชั่นที่ต้องเสียเงินซื้อมาใช้เสียแล้ว
ความนิยมของ Ubuntu ไม่ได้หยุดอยู่แค่กับกลุ่มผู้ใช้ชาวต่างชาติเท่านั้น ปัจจุบันความนิยมและข้อดีต่างๆของ Ubuntu ได้ถูกบรรจุลงใน LinuxTLE 8 ของไทยเป็นที่เรียบร้อยแล้ว และด้วยความที่ NECTEC ยังไว้ใจในการนำ Ubuntu มาต่อยอดในการพัฒนาลินุกซ์ของไทย แล้วเหตุไฉนคุณจะไม่ไว้ใจใน Ubuntu
เนื่องจาก Ubuntu เป็นลินุกซ์สายพันธุ์ Debian จึงใช้ระบบ APT (Advanced Package Tool) ในการจัดการแพคเกจ ซึ่งระบบนี้มีข้อดีที่สามารถอัพเดทหรือติดตั้งแพคเกจเพิ่มเติมผ่านอินเทอร์เน็ตได้ตลอดเวลา แถมยังจัดการปรับแต่งค่าพื้นฐานให้โดยอัตโนมัติอีกด้วย
Ubuntu มีระบบการติดตั้งแบบ GUI (Graphic User Interface) ทำให้ง่ายมากๆในการที่จะติดตั้ง Ubuntu ซึ่งบอกได้เลยว่าง่ายกว่าการติดตั้ง Windows XP เสียอีก
คุณสามารถทดลองใช้งาน Ubuntu ก่อนได้ โดยที่ไม่ต้องติดตั้งลงในเครื่องคอมพิวเตอร์ของคุณ ซึ่งคุณสามารถแน่ใจได้เลยว่าข้อมูลในเครื่องคอมพิวเตอร์ของคุณจะปลอดภัย และเมื่อคุณทดลองจนพอใจและตัดสินใจที่จะใช้ เมื่อนั้นคุณค่อยติดตั้งลงในฮาร์ดดิสก์ก็ไม่เป็นปัญหาแต่อย่างใด
Ubuntu คัดสรรโปรแกรมที่ดีที่สุดมาให้คุณแล้ว ทำให้ไฟล์และโปรแกรมทั้งหมดสำหรับติดตั้งน้อยจนสามารถบรรจุลงได้ในหนึ่งแผ่นซีดีเท่านั้น และเพื่อป้องกันความสับสนแก่ผู้ใช้ที่จะเลือกใช้โปรแกรมดีๆสักตัวเพื่อทำงานอย่างใดอย่างหนึ่ง Ubuntu จึงไม่ใส่โปรแกรมที่ใช้สำหรับทำงานประเภทเดียวกันมาให้ซ้ำซ้อนกัน
ด้วยการที่ Ubuntu ออกเวอร์ชั่นใหม่ทุกๆ 6 เดือน ทำให้คุณมั่นใจได้ว่า คุณจะได้ใช้โปรแกรมในเวอร์ชั่นที่ใหม่ล่าสุดตลอดเวลา รวมทั้งสามารถมั่นใจได้ในเรื่องของระบบรักษาความปลอดภัยที่อัพเดทกันแบบรายวัน
ในบทนี้ก็ถึงเวลาที่เราจะมาลงภาคปฏิบัติกันแล้วครับ (พร้อมยังเอ่ย) โดยที่เราจะเริ่มกันตั้งแต่ยังไม่มีแผ่น Ubuntu ไปจนถึงการนำ Ubuntu ร้อนๆเสริฟลงเครื่องคอมพิวเตอร์ของคุณกันเลยครับ พร้อมแล้วก็ไปกันเลย
เป็นเรื่องดีอย่างยิ่งที่ Ubuntu เป็นระบบปฏิบัติการเสรี ฉะนั้นเราจึงสามารถหามาใช้ได้อย่างไม่ต้องลำบากยากเข็นสักเท่าใดนักแถมยังไม่ต้องจ่ายเงินสักแดงเดียวอีกต่างหาก เพียงแค่คุณมีคอมพิวเตอร์ที่พร้อมจะเข้าถึงอินเทอร์เน็ตได้ก็เพียงพอแล้ว
สถานที่ดาวน์โหลดที่หลักนั้น ต้องเป็น ubuntulinux.org อย่างแน่นอนอยู่แล้ว สิ่งที่คุณต้องทำก็คือ เปิดโปรแกรมเว็บเบราเซอร์อย่าง IE หรือ Firefox ขึ้นมา แล้วเข้าไปที่ http://releases.ubuntulinux.org (หรือคุณอาจใช้บริการที่ ftp://mirror.in.th/ubuntu เพื่อความเร็วที่มากกว่า) ที่หน้านี้คุณจะเห็นเวอร์ชั่นต่างๆของ Ubuntu เรียงอยู่อย่างมากมาย (ตามภาพที่ 2.1) ให้คุณมองหาโฟลเดอร์ที่มีเลขเวอร์ชั่นสูงที่สุด เมื่อเจอแล้วให้คลิกเข้าไปเลยครับ
Picture 2.1
Picture 2.1
เมื่อคุณเข้ามาถึงข้างในของโฟลเดอร์ที่เก็บ Ubuntu เวอร์ชั่นล่าสุดแล้ว ในนี้จะมีไฟล์ดาวน์โหลดของ Ubuntuสำหรับ CPU หลากหลายประเภท แต่ถ้าเครื่องของคุณเป็นเครื่องคอมพิวเตอร์หรือ Laptop ที่ใช้ CPU จำพวก Intel หรือ AMD ที่นิยมใช้กันทั่วไปในปัจจุบัน คุณจะต้องดาวน์โหลดไฟล์สำหรับ CPU รุ่น i386 ครับ หรือที่เขียนว่า PC Intel x86 นั่นเอง ซึ่งไฟล์ที่มีให้ดาวน์โหลดสำหรับ CPU แต่ละประเภทนั้น จะมีด้วยกัน 3 รูปแบบด้วยกันคือ
DesktopCD: ไฟล์ในรูปแบบนี้ จะสร้างออกมาเป็นแผ่นที่สามารถใช้งานได้โดยไม่ต้องติดตั้ง หรือใช้สำหรับติดตั้งด้วยก็ได้ ซึ่งจะเป็นการติดตั้งผ่านอินเทอร์เฟสแบบ GUI ที่สามารถใช้เมาส์คลิกเพื่อติดตั้ง และกำหนดค่าต่างๆระหว่างติดตั้งได้
AlternateCD: ไฟล์นี้จะสร้างออกมาเป็นแผ่นที่ทำมาสำหรับติดตั้งโดยเฉพาะ และเป็นการติดตั้งผ่าน Text base UI (คล้ายการติดตั้ง Windows XP) แต่เมื่อติดตั้งเสร็จเรียบร้อยแล้ว จะได้เหมือนกับที่ติดตั้งผ่านแผ่น DesktopCD ทุกประการ
Server: เป็นไฟล์ที่ทางผู้พัฒนาได้คัดเลือกเฉพาะแพคเกจที่ทำงานด้านเซิร์ฟเวอร์ไว้ จึงไม่เหมาะสำหรับผู้ใช้ตามบ้านอย่างเราๆสักเท่าไรนัก
แผ่นที่เราจะใช้ในการติดตั้งตามคู่มือนี้ผมแนะนำให้ใช้เป็นแผ่น DesktopCD ครับ ให้คลิกที่ลิงก์ของไฟล์ (ตามภาพที่ 2.2) เพื่อทำการดาวน์โหลดได้เลย ซึ่งคุณควรจะใช้โปรแกรมช่วยดาวน์โหลดเพื่อป้องกันความผิดพลาดของไฟล์ คุณอาจใช้โปรแกรมที่เป็นฟรีแวร์ อย่างเช่น FlashGet หรือโปรแกรมช่วยดาวน์โหลดที่เป็น Open Source สำหรับ Windows อย่าง TrueDownloader ที่สามารถดาวน์โหลดมาใช้ได้ฟรีจาก http://sourceforge.net/projects/downloadplus
Picture 2.2ในส่วนของการดาวน์โหลดไฟล์นี้ นอกจากที่คุณจะดาวน์โหลดจากเว็บไซต์ ubuntulinux.org แล้วนั้น คุณยังสามารถที่จะดาวน์โหลดที่ ftp://mirror.in.th/ubuntu ได้ด้วยเพื่อความรวดเร็วในการดาวน์โหลด เพราะเครื่องเซิร์ฟเวอร์นี้จะตั้งอยู่ในประเทศเรา ซึ่งจะส่งข้อมูลได้เร็วกว่า
Picture 2.2
เนื่องจากไฟล์ที่ดาวน์โหลดมามีขนาดใหญ่มาก (เกือบ 700 MB) และใช้เวลาในการเดินทางอย่างยาวนานกว่าจะมาถึงเครื่องของเราจนครบ ข้อมูลอาจเกิดความเสียหายในระหว่างเดินทางได้ ฉะนั้นเราจึงควรที่จะตรวจสอบความสมบูรณ์ของไฟล์ที่เราได้ดาวน์โหลดมาเสียก่อน ก่อนที่จะสร้างเป็นแผ่น CD เพื่อจะได้ไม่ต้องเสียแผ่นไปเปล่าๆ หากว่าไฟล์ที่คุณดาวน์โหลดมานั้นเกิดความผิดพลาด
ในโลกของ Open Source นั้น จะมีระบบการตรวจสอบความถูกต้องของไฟล์ที่เรียกว่า MD5SUM เป็นการคำนวนค่าของตัวเลขชุดหนึ่งออกมาจากไฟล์ วิธีที่ใช้กันโดยทั่วไปนี้เป็นเรื่องที่ทำความเข้าใจได้ไม่ยาก คือ ฝั่งเซิร์ฟเวอร์ที่ปล่อยไฟล์ออกมาให้ดาวน์โหลด จะสร้างชุดตัวเลข MD5SUM ของไฟล์นั้นๆขึ้นมา ซึ่งจะมีค่าตัวเลขจำนวนหนึ่งเป็นค่าเฉพาะ และเมื่อเราดาวน์โหลดมาแล้ว เราก็ทำการเช็คค่า MD5SUM ของไฟล์ที่เราดาวน์โหลดมาด้วยเช่นเดียวกัน ถ้าค่าตัวเลขออกมาตรงกัน ก็แสดงว่าไฟล์นั้นสมบูรณ์ นำไปใช้งานได้เลย
MD5SUM ฝั่งเซิร์ฟเวอร์
Picture 2.3ในขั้นแรกให้เราตรวจสอบชุดตัวเลขนี้ในฝั่งเซิร์ฟเวอร์ก่อน ที่เว็บเบราเซอร์ให้คุณไปหน้าเดียวกับที่ดาวน์โหลดไฟล์ DesktopCD ให้เลื่อนลงมาล่างๆหน้าเว็บสักหน่อย คุณจะเห็นลิงก์ของไฟล์ที่เขียนว่า MD5SUM (ตามภาพที่ 2.3) ให้คุณคลิกเข้าไปเพื่อดูชุดตัวเลขที่ว่านั้น
Picture 2.3
Picture 2.4ภายในไฟล์ MD5SUM นี้จะมีชุดตัวเลขอยู่หลายบรรทัด บรรทัดที่คุณต้องดูคือ บรรทัดที่เขียนว่า desktop-i386.iso ให้คุณจดค่าตัวเลขนั้นไว้ เพื่อใช้ตรวจสอบกับ MD5SUM ของไฟล์ในเครื่องเรา ที่จะทำการตรวจสอบในขั้นต่อไป
Picture 2.4
MD5SUM ไฟล์ในเครื่องของเรา
การตรวจสอบค่า MD5SUM ให้กับไฟล์ในเครื่องเรานั้น จะต้องใช้โปรแกรมเพื่อช่วยในการคำนวนค่าของชุดตัวเลขออกมา ซึ่งผมแนะนำโปรแกรมชื่อ MD5summer ซึ่งเป็นซอฟต์แวร์ Open Source เช่นเดียวกับ Ubuntu ครับ
เปิดเข้าไปที่ http://www.md5summer.org/download.html แล้วทำการดาวน์โหลดโปรแกรม MD5summer มา ไฟล์ที่ได้จะอยู่ในรูปแบบของไฟล์ zip ให้คุณทำการคลายไฟล์ออกมา เมื่อคุณคลายไฟล์ zip ออกมาแล้วคุณจะเห็นไฟล์ที่ชื่อว่า md5summer.exe ให้คุณดับเบิลคลิกที่ไฟล์นั้น โปรแกรมจะถูกเรียกขึ้นมาทำงานโดยไม่ต้องติดตั้ง
Picture 2.5เมื่อคุณเรียกโปรแกรมขึ้นมาแล้ว จะพบหน้าต่างของโปรแกรม MD5summer ที่แสดงพาธต่างๆบนเครื่องของคุณ ให้คุณคลิกเลือกที่โฟลเดอร์ที่ได้เก็บไฟล์ของ Ubuntu ที่ได้ทำการดาวน์โหลดมา จากนั้นคลิกที่ปุ่ม Create sums
Picture 2.5
ถัดมาโปรแกรมจะทำงานต่อไปในขั้นตอนที่สอง ในขั้นตอนนี้หน้าต่างจะถูกแบ่งออกเป็นสองส่วน หน้าจอทางด้านซ้านนั้น จะแสดงไฟล์ต่างๆที่เก็บอยู่ในโฟลเดอร์ที่คุณคลิกเลือกในขั้นตอนที่ผ่านมา ให้คุณคลิกเลือกไฟล์ Ubuntu ที่ได้ทำการดาวน์โหลดมา จากนั้นกดที่ Add ชื่อไฟล์ Ubuntu จะแสดงขึ้นมาที่หน้าจอทางด้านขวา เรียบร้อยแล้วให้คลิกที่ OK
ในขั้นตอนนี้จะเป็นขั้นตอนสุดท้ายคือการแสดงค่าที่คำนวนออกมา เมื่อโปรแกรมคำนวนจนเสร็จจะแสดงหน้าต่างขึ้นมาหน้าต่างหนึ่ง เพื่อให้คุณเซฟค่าที่ได้ทำการคำนวนลงในไฟล์ ให้คุณคลิก Cancel เมื่อ Cancel แล้ว คุณจะเห็นหน้าต่างโปรแกรมที่แสดงค่าตัวเลขยาวๆที่ได้คำนวนเสร็จเป็นที่เรียบร้อยแล้ว ให้คุณเปรียบเทียบค่านี้กับชุดตัวเลขที่ได้จดมา ถ้าหากตรงกันก็ไปอ่านตอนต่อไปได้เลย แต่ถ้าไม่ผ่านคุณก็จำเป็นที่จะต้องดาวน์โหลดใหม่อีกครั้ง
เมื่อได้ไฟล์และได้ทำการตรวจสอบความสมบูรณ์ของไฟล์เป็นที่เรียบร้อยแล้ว ก็ถึงเวลาที่จะสร้างแผ่น Ubuntu ขึ้นมาจากไฟล์ .iso ที่เราได้ทำการดาวน์โหลดมาเสียที สำหรับวิธีในการสร้างแผ่นซีดีนั้นผมจะเขียนโดยอิงวิธีของโปรแกรม Nero Burning ROM เป็นหลักนะครับ เพราะคิดว่าน่าจะเป็นโปรแกรมที่มีคนใช้มากที่สุด
ให้เปิดโปรแกรม Nero ขึ้นมาเลยครับ ที่เมนูหลักของโปรแกรม เลือกที่ Recorder แล้วคลิกเลือกที่ Burn Image... ครับ จากนั้นให้ทำการเลือกไฟล์ .iso ที่เราได้ดาวน์โหลดมา เลือกความเร็วในการเขียนแผ่นที่เหมาะสม ไม่ต้องเร็วจนเกินไปนัก อาจเป็น 16x ก็ได้ จากนั้นให้สั่ง Burn ก็เป็นอันเสร็จในขั้นตอนนี้
Picture 2.6
เมื่อได้แผ่นซีดีมาเป็นที่เรียบร้อยแล้วเราก็พร้อมที่จะไปทดลองใช้งาน และติดตั้งกันแล้วครับ สิ่งแรกที่คุณต้องทำคือ ต้องตั้งค่าไบออสให้บูตจากซีดีเสียก่อน ซึ่งวิธีการตั้งค่าของแต่ละเครื่องนั้นขอให้คุณดูคู่มือของ Mainboard จะดีกว่า เมื่อตั้งค่าแล้วให้ใส่แผ่นซีดี พร้อมเปิดเครื่องขึ้นมาใหม่ เครื่องจะบูตซีดีขึ้นมา คุณจะเห็นหน้าจอที่เป็นเมนูของ Ubuntu ให้คุณเลือกที่เมนู Start or install Ubuntu ได้ทันที จากนั้นรอสักครู่ คุณจะเข้ามาสู่หน้าจอการทำงานของ Ubuntu ทันที
Picture 2.7
Picture 2.7
Picture 2.8ที่หน้าจอการทำงานนี้คุณจะเห็นไอคอน Install อยู่ทางด้านซ้ายมือ ให้คุณดับเบิลคลิกเพื่อติดตั้งได้เลย (หากคุณต้องการทดลองใช้งานก่อน ให้ข้ามไปอ่านในบทถัดไปก่อนได้ครับ) หน้าจอช่วยเหลือการติดตั้งจะเปิดขึ้นมา ซึ่งคุณสามารถติดตั้งไปตามขั้นตอนที่โปรแกรมแนะนำได้เลย ผมจะคอยแนะนำคุณเป็นขั้นตอนๆไปอย่างหยาบๆ แต่จะเน้นในส่วนที่สำคัญเท่านั้น
Picture 2.8
Picture 2.9ขั้นตอนที่ 1-3 จะเป็นการเลือกภาษาปริยายสำหรับระบบและการเลือกโซนเวลา ซึ่งค่านี้จะส่งผลกับทั้งระบบ คือถ้าเลือกเป็นภาษาไทย หน้าจอการแสดงผลก็จะแสดงข้อความภาษาไทยไปด้วย ซึ่งในการติดตั้งนี้ผมจะเลือกเป็น English ไว้ก่อน เพราะอย่างไรแล้ว ผมจะแนะนำการติดตั้งเพื่อใช้งานภาษาไทยในตอนท้ายอยู่ดีครับ ส่วนเขตเวลาก็ให้เลือกตามแผนที่ได้เลย ซึ่งของประเทศไทยนั้น จะมีให้เลือกแค่ Bangkok เท่านั้นครับ
Picture 2.9
Picture 2.10ในส่วนขั้นตอนที่ 4 จะเป็นการเลือกผังแป้นพิมพ์ เมื่อคุณเลือกที่ Thailand แล้ว จะมีชื่อผังแป้นพิมพ์ปรากฏขึ้นมาให้คุณเลือก ซึ่งจะมี Thailand, Thailand-Pattachote และ Thailand-TIS-820.2538 ให้คุณเลือกที่ Thailand ตัวเลือกแรกครับ เมื่อคุณคลิกเลือกแล้ว ที่ด้านล่างของหน้าต่างนี้จะมีให้คุณทดสอบพิมพ์ครับ โดยคุณสามารถสลับผังแป้นพิมพ์ระหว่างภาษาไทยกับภาษาอังกฤษได้ โดยกด Alt+Shift ครับ
Picture 2.10
Picture 2.11ขั้นตอนที่ 5 นี้จะเป็นการตั้งชื่อผู้ใช้และชื่อของเครื่อง ในช่องแรกจะเป็นชื่อของคุณ กรอกได้ตามสะดวก ส่วนช่องถัดมาจะเป็นชื่อที่ใช้ในการเข้าระบบ ให้คุณจำให้ดีครับ เพราะถ้าลืมจะไม่สามารถเข้าระบบได้ ถัดมาจะเห็นเป็นช่องคู่กันสองช่อง สองช่องนี้คือรหัสผ่านครับ ทั้งสองช่องกรอกให้ตรงกันนะครับ ไม่งั้นจะติดตั้งไม่ผ่าน ส่วนช่องสุดท้ายคือชื่อเครื่องครับ
Picture 2.11
ชื่อผู้ใช้ที่คุณสร้างนี้ให้จำรหัสไว้ให้ดีครับ เพราะนอกจากจำเป็นที่จะต้องใช้ในการเข้าระบบแล้ว ผู้ใช้คนนี้ยังมีสิทธิ์ในฐานะผู้ดูแลของเครื่องนี้ด้วยครับ ที่จะติดตั้งโปรแกรมเพิ่มเติม เพิ่มผู้ใช้คนอื่นหรือทำอย่างอื่นที่เกี่ยวข้องกับการเปลี่ยนแปลงระบบครับ
ขั้นตอนที่ 6 ในขั้นตอนนี้สำคัญและต้องใช้ความระมัดระวังเป็นอย่างมากครับ ถ้าคุณต้องการติดตั้งใช้งาน Ubuntu เพียงอย่างเดียว หรือเครื่องคุณเป็นเครื่องเปล่าที่เพิ่งซื้อมาใหม่ ให้คุณเลือกที่ "Erase entire disk" ได้เลย ซึ่งระบบจะลบข้อมูลในฮาร์ดดิสก์ทั้งหมด และทำการติดตั้ง Ubuntu ลงไป
Picture 2.12
Picture 2.12
แต่ถ้าหากเครื่องของคุณติดตั้งระบบปฏิบัติการอื่นอยู่ เช่น Windows และคุณยังต้องการที่จะใช้มันอยู่ คุณสามารถติดตั้ง Ubuntu คู่ไปกับวินโดวส์ได้ โดยเลือกที่ "Resize ..." ตามภาพได้เลยครับ ซึ่งระบบจะปรับขนาดพาร์ทิชั่นที่ใช้อยู่เดิมให้เล็กลง และติดตั้ง Ubuntu ลงไปในพื้นที่ว่างหลังจากที่พาร์ทิชั่นเดิมถูกปรับขนาดลงไปแล้ว
Picture 2.13เมื่อเสร็จสิ้นขั้นตอนทั้งหมดแล้วโปรแกรมติดตั้ง จะจัดการติดตั้ง Ubuntu ลงในฮาร์ดดิสก์ของคุณ ซึ่งจะต้องใช้เวลาสักครู่ ขึ้นอยู่กับความเร็วของเครื่องคุณ จนเมื่อระบบได้ทำการติดตั้งเรียบร้อยแล้ว จะมีกล่องข้อความขึ้นมาถามว่า "Continue using the live CD"หรือ"Restart now" ซึ่งผมแนะนำใหคุณรีสตาร์ทเครื่องก่อน แล้วค่อยกลับมาใช้งานต่อจะดีกว่าครับ
Picture 2.13
ในบทนี้จะแนะนำเรื่องของการใช้งานในเบื้องต้น ตั้งแต่แนะนำให้คุณรู้จักกับส่วนต่างๆบนหน้าจอ การปรับแต่งค่าพื้นฐานเล็กๆน้อยๆ ไปจนถึงแนะนำโปรแกรมสำหรับใช้งานทั่วไป ที่ได้รวบรวมมาแล้วพร้อมกันในแผ่น Ubuntu
หลังจากที่เราติดตั้งกันเป็นที่เรียบร้อยแล้ว ก่อนที่เราจะเปิดเครื่องเพื่อทำความรู้จักกับส่วนต่างๆของ Ubuntu นั้น สิ่งแรกที่คุณควรรู้และทำความเข้าใจไว้ก่อนคือเรื่องของระบบไฟล์และโฟลเดอร์ของ Ubuntu ครับ
ระบบไฟล์ของ Ubuntu หรือแม้แต่ลินุกซ์ตัวอื่นๆก็ตาม จะไม่เหมือนกับ Windows ที่เราจะเห็นว่ามี Drive C, Drive D นะครับ ซึ่งเป็นเรื่องที่ต้องทำความเข้าใจไว้ก่อน เดี๋ยวจะงง
เมื่อถึงตอนที่คุณเริ่มใช้งานแล้ว คุณจะเห็นพาธต่างๆของ Ubuntu ซึ่งผมจะอธิบายคร่าวๆไว้ เฉพาะพาธที่สำคัญๆ ว่าพาธไหนคืออะไรครับ
/ : root path พาธที่เป็นต้นราก
bin : เก็บไบนารี่คำสั่งต่างๆของระบบไว้
boot : เก็บไฟล์ที่จำเป็นสำหรับการบูตระบบ
etc : เก็บการตั้งค่าที่จำเป็นสำหรับโปรแกรมต่างๆ
home : คล้าย My Document
user1 : My Document ของผู้ใช้ชื่อ user1
Desktop : Desktop ของ user1
.Trash : ถังขยะของ user1
gumara : My Document ของ gumara
Desktop : Desktop ของ gumara
.Trash : ถังขยะของ gumara
media : อุปกรณ์ต่างๆเรียกใช้ได้ที่นี่ เช่น CD, Floppy
cdrom : Drive CD
fda0 : Floppy
sbin : เก็บคำสั่งสำคัญของระบบ เช่น ปิดเครื่อง, รีสตาร์ท
tmp : ที่เก็บไฟล์ชั่วคราว จะถูกลบเมื่อรีสตาร์ท
usr : ที่เก็บไฟล์ต่างๆที่ผู้ใช้จะใช้
bin : เก็บคำสั่งต่างๆ
firefox : คำสั่งเรียก Firefox
openoffice : คำสั่งเรียก OpenOffice.org
ทั้งหมดนี้เป็นพาธสำคัญๆที่น่าจะรู้จักไว้ แต่ในความเป็นจริงแล้ว เมื่อใช้งานคุณคงไม่ได้ยุ่งกับพาธเหล่านี้โดยตรงสักเท่าไหร่ ซึ่งจริงๆแล้วผมแค่อยากให้คุณรู้จักไว้เท่านั้น เผื่อว่าเปิดเข้ามาเจอว่ามันไม่เหมือนที่เคยใช้บน Windows จะได้ไม่ต้องตกใจ
Picture 3.1หลังจากที่ได้ทำการติดตั้ง Ubuntu เป็นที่เรียบร้อยแล้ว เมื่อคุณทำการเปิดเครื่องคอมพิวเตอร์ คุณจะได้พบกับเมนูสำหรับเลือกระบบปฏิบัติการ (กรณีติดตั้งคู่กับ Windows) เพื่อที่คุณจะสามารถเลือกได้ว่าจะเข้าใช้งาน Ubuntu หรือ Windows ตามภาพจะเห็นว่าในเมนูจะมีให้เลือกอยู่หลายตัว ซึ่งจะมีอยู่ 3 ตัวเลือกที่สำคัญคือ
Picture 3.1
Ubuntu : สำหรับเข้าใช้งาน Ubuntu
Recovery mode : เพื่อแก้ไขปัญหาสำหรับ Ubuntu
Windows : สำหรับเข้าใช้งาน Windows
เมื่อผ่านจากเมนูสำหรับเลือกระบบปฏิบัติการมาแล้ว คุณจะพบกับหน้าต่างล๊อกอิน เพื่อเข้าระบบ ที่หน้าจอนี้คุณจะเห็นช่องสำหรับกรอกชื่อผู้ใช้ ที่ด้านบนเขียนกำกับไว้ว่า Username: ให้คุณกรอกชื่อที่ตั้งไว้ในตอนที่ติดตั้ง จากนั้น Enter หนึ่งครั้ง คำว่า Username: ที่เขียนกำกับไว้จะเปลี่ยนเป็น Password: ให้คุณกรอกรหัสผ่านลงไป เสร็จแล้วระบบจะพาคุณเข้าสู่หน้าจอการใช้งาน Ubuntu
Picture 3.2
Picture 3.2
Picture 3.3หน้าจอของ Ubuntu แม้จะมีความเรียบง่ายมากแล้ว แต่สำหรับผู้ที่เพิ่งเริ่มใช้ ก็ไม่น่าแปลกใจอะไรหากจะหยิบจับอะไรไม่ค่อยถูกเพราะความไม่เคยชิน เพราะฉะนั้นผมจะพาไปทำความรู้จักกับส่วนต่างๆของหน้าจอกันสักเล็กน้อยครับ
Picture 3.3
เมนูต่างๆสำหรับเรียกโปรแกรม ซึ่งเดี๋ยวจะอธิบายอีกทีครับ
Application Launcher สำหรับเรียกโปรแกรม
ตัวแจ้งเตือนการอัพเดทระบบ
System tray สำหรับแสดงสถานะของระบบ และโปรแกรมที่ทำการซ่อนตัวอยู่
ปุ่มปิดเครื่องและออกจากระบบ
ปุ่มแสดงหน้าจอ สำหรับซ่อนและแสดงหน้าต่างทั้งหมด
Window List จะแสดงโปรแกรมต่างๆที่กำลังทำงานอยู่
Workspaces Switcher สำหรับสลับหน้าจอการทำงานเสมือน
Trash ถังขยะเก็บไฟล์ที่ถูกลบแล้ว
จากภาพ ในลำดับที่หนึ่งจะเห็นเมนูอยู่ทั้งหมด 3 เมนูคือ Applications, Places และ System ซึ่งเมนูแต่ละอย่างจะมีหน้าที่ต่างกันดังนี้ครับ
โปรแกรมต่างๆจะถูกจัดหมวดหมู่เก็บไว้เป็นอย่างดีในเมนูนี้ ซึ่งคุณสามารถเรียกใช้โปรแกรมต่างๆที่มีได้ ผ่านทางเมนู Applications นี้เลยครับ
Picture 3.4
Picture 3.4
ที่เมนูนี้จะเก็บ Shortcut สำหรับเข้าถึงโฟลเดอร์สำคัญต่างๆไว้ เช่น Home (คล้าย My Document), Computer (คล้าย My Computer) หรืออื่นๆ ที่เห็นตามในเมนูครับ
Picture 3.5
Picture 3.5
ในเมนู System จะมีอยู่สองส่วนสำคัญคือการตั้งค่า Preferences หมายถึงการตั้งค่าส่วนตัว และ Administration หมายถึงการปรับแต่งค่าของระบบ
Picture 3.6
Picture 3.6
ทั้งหมดนี้คือส่วนประกอบหลักๆบนหน้าจอของ Ubuntu เมื่อเราติดตั้งเสร็จ และด้วยความยืดหยุ่นของ Linux ทำให้เราสามารถปรับแต่งได้ตามใจชอบครับ
ในตอนนี้เราจะมาปรับแต่ง Ubuntu ของเราในส่วนของการแสดงผลกันครับ เช่นเดียวกับระบบปฏิบัติการอื่นๆ Ubuntu สามารถปรับแต่งการแสดงผลได้ในระดับหนึ่ง ซึ่งก็เพียงพอต่อความต้องการแล้วครับ
เมื่อคุณติดตั้ง Ubuntu เสร็จ Ubuntu จะเลือกความละเอียดมากที่สุด ที่จอภาพและการ์ดแสดงผลรองรับ ซึ่งบางครั้งมันก็ละเอียดมากซะจนทำให้ไอคอนและตัวหนังสือต่างๆนั้นดูเล็กไปซะหมด ซึ่งเราสามารถปรับความละเอียดของหน้าจอให้ตรงตามความต้องการได้ครับ การปรับค่าความละเอียดหน้าจอนั้นสามารถทำได้ โดยไปที่ เมนู System > Preferences > Screen Resolution หน้าต่างการตั้งค่าความละเอียดหน้าจอจะถูกเรียกขึ้นมา ซึ่งคุณสามารถเลือกความละเอียดได้ตามต้องการครับ เสร็จแล้วกดที่ Apply เพื่อใช้งานค่าที่เลือกได้ทันทีครับ
Picture 3.7
ก่อนที่จะเริ่มเปลี่ยนภาพพื้นหลังกันได้นั้น (หรือที่เราเรียกกันอย่างติดปากว่า wallpaper) แน่นอนว่าก่อนอื่นคุณต้องมีภาพพื้นหลังที่จะใช้ก่อน คุณสามารถใช้ภาพในฟอร์แมทใดมาทำเป็นภาพพื้นหลังก็ได้ แค่พยายามหาให้ภาพนั้นมีความละเอียดไม่น้อยไปกว่า Resolution ของหน้าจอเป็นดี
เมื่อได้ภาพที่ต้องการมาแล้วให้คุณไปที่เมนู System > Preferences > Desktop Background หรือคลิกขวาบนที่ว่างบนหน้าจอแล้วเลือก Change Desktop Background ก็ได้ครับ ระบบจะทำการเรียกโปรแกรม Desktop Background Preferences ขึ้นมา
ภายในหน้าจอของนี้ คุณจะเห็นภาพหน้าจอที่มีให้อยู่แล้วจำนวนหนึ่ง ซึ่งคุณสามารถเลือกที่ภาพและใช้งานได้ทันที แต่ถ้าคุณไม่อยากใช้ภาพพื้นหลัง คุณสามารถเซตให้เป็นสีเดียวก็ได้ โดยที่ช่อง Wallpaper ให้เลือก No Wallpaper และเลือกสีที่ต้องการที่ช่อง Desktop Colors
Picture 3.8
Picture 3.8
ส่วนการนำภาพที่ต้องการมาทำ Wallpaper นั้นให้คลิกที่ปุ่ม Add Wallpaper แล้วเลือกไฟล์ภาพที่คุณต้องการ เพียงเท่านี้ภาพที่คุณต้องการก็จะปรากฏขึ้นมาเป็น Wallpaper แล้วครับ
หน้าตาของ Ubuntu ที่คุณเห็นอยู่นี้ เป็นการจัดวางองค์ประกอบลักษณะหนึ่ง คือการจัดวาง Panel ในรูปแบบที่เห็น และในส่วนของหน้าต่าง ไอคอน หรือปุ่มกดต่างๆที่เราเห็นว่ามีหน้าตาเช่นนี้นั้น เกิดขึ้นจากการจัดการของชุดตกแต่ง หรือที่เรียกว่า Theme ซึ่ง Theme มาตรฐานที่ Ubuntu ใช้อยู่นี้ จะมีชื่อว่า Human ที่มีสีออกไปในโทนน้ำตาล Theme นี้ Ubuntu ใช้มาตั้งแต่ Ubuntu เวอร์ชั่นแรก (4.10)
แต่นอกจากชุดตกแต่งในแบบที่เราเห็นอยู่ในตอนนี้ Ubuntu สามารถเปลี่ยน Theme ได้ตามต้องการครับ วิธีเปลี่ยน Theme นั้นให้ไปที่ เมนู System > Preference > Theme หน้าต่าง Theme Preference จะถูกเรียกขึ้นมา ซึ่งจะมี Theme แบบต่างๆให้คุณเลือกใช้ได้อยู่จำนวนหนึ่ง คุณสามารถเลือกใช้ได้ตามสะดวกเลยครับ หรือถ้ายังไม่ตรงกับความต้องการจะหามาติดตั้งเพิ่มเติมก็ไม่เป็นปัญหาแต่อย่างใดครับ เพียงแต่ว่า Theme ที่เราจะนำมาติดตั้งนั้น จะประกอบไปด้วยองค์ประกอบต่างๆ จึงจะเห็นออกมาเป็นหน้าตาในรูปแบบนี้ครับ
Picture 3.9
ก่อนที่คุณจะติดตั้ง Theme ได้ คุณต้องเข้าใจองค์ประกอบของมันก่อนครับ ว่าใน Theme หนึ่งชุดที่เราเลือกขึ้นมาใช้นั้นประกอบด้วยอะไรบ้าง ให้คุณลองคลิกที่ Theme สักชุดนึง แล้วคลิกที่ปุ่ม Customize... ครับ คุณจะเห็นว่าในหนึ่ง Theme จะประกอบด้วย
Controls: ส่วนประกอบต่างๆ ของหน้าต่างโปรแกรม เช่น Scroll bar, ปุ่มกดต่างๆ
Colors: เป็นการปรับสีส่วนต่างๆของ Theme จะปรับได้ต่อเมื่อ Theme นั้นๆ รองรับ
Window Border: ส่วนขอบของหน้าต่าง
Icons: ไอคอนที่เราเห็นทั่วไปบนหน้าจอ ในเมนู
องค์ประกอบต่างๆนี้ คุณสามารถหยิบเอาส่วนที่ต้องการ เช่น Window Border ของอีก Theme มาประกอบกับ Icons ของอีก Theme เพื่อใช้เป็น Theme ใหม่ได้ครับ
ตามภาพผมปรับแต่งให้คล้ายกับหน้าจอการทำงานของ Windows เพื่อให้คนที่เพิ่งหันมาลองใช้ ที่แต่เดิมใช้ Windows อยู่จะคุ้นเคยได้ง่ายกว่า ซึ่งคุณผู้อ่านคงจะพอเห็นเป็นแนวทางแล้วว่าหน้าตาของ Ubuntu นั้น สามารถปรับแต่งได้และยืดหยุ่นพอสมควร อย่างไรแล้วก็ทดลองปรับแต่งกันให้ตรงตามที่ชอบใจนะครับ
Picture 3.10
Picture 3.10
จากที่ได้แนะนำให้รู้จัก Panel ไปแล้วในส่วนของ “หน้าจอการทำงาน” Panel นี้เราสามารถปรับได้ครับ ไม่ว่าจะเป็น ตำแหน่งของ Panel หรือส่วนต่างๆที่อยู่ใน Panel
ตัว Panel เองเราสามารถย้ายตำแหน่งได้ด้วยการคลิกค้างที่พื้นที่ว่างบน Panel จากนั้นลากไปไว้ที่มุมใดของหน้าจอก็ได้ เมื่ออยู่ในตำแหน่งที่ต้องการแล้วให้ทำการปล่อยเมาส์ Panel จะถูกวางลงในตำแหน่งที่เลือก
ส่วนการเพิ่มและลบนั้น ให้คุณคลิกขวาที่พื้นที่ว่างของ Panel คุณจะพบเมนูสำหรับจัดการ Panel โดยปุ่ม New Panel จะเป็นการสร้าง Panel ใหม่ ส่วน Delete This Panel หมายถึงลบ Panel ที่เลือกทิ้งไป นอกจากนี้คุณยังตั้งค่ารายละเอียดของ Panel ได้โดยการเลือกที่ Properties จะปรากฏหน้าต่าง Panel Properties ขึ้นมา ให้คุณทดลองตั้งค่าได้ตามชอบใจครับ
Picture 3.11
Picture 3.11
พวกไอคอนเรียกโปรแกรม, ปุ่มปิดเครื่อง, ถังขยะและอื่นๆที่อยู่บน Panel จะเรียกรวมๆว่า Object Panel ครับ พวกนี้เราสามารถเพิ่ม, ลบ หรือย้ายได้ตามต้องการ
หากโปรแกรมที่คุณต้องการเพิ่มลงในไอคอนมีอยู่ใน เมนู Applications แล้ว คุณสามารถคลิกค้างที่ปุ่มเรียกโปรแกรมในเมนูนั้นๆแล้วนำมาวางใน Panel ได้ทันที ส่วนการย้าย, ลบ หรือล๊อกติดกับ Panel สามารถทำได้โดยการคลิกขวาที่ไอคอนนั้นๆ แล้วเลือกทำตามที่ต้องการครับ
แบบอักษร หรือที่เรียกว่าฟอนต์ที่ใช้ในการแสดงผล ในส่วนต่างๆของ Ubuntu เราสามารถเปลี่ยนเป็นรูปแบบอักษรแบบอื่นได้ตามใจชอบ วิธีการเปลี่ยนแบบอักษรนี้ให้ไปที่ เมนู System > Preferences > Font หน้าต่างการตั้งค่า Font Preferences จะเปิดขึ้นมา ซึ่งคุณสามารถเลือกแบบอักษรให้กับส่วนประกอบต่างๆของหน้าจอได้ ในขั้นตอนนี้ให้คุณเลือกและทดสอบการตั้งค่าต่างๆด้วยตนเองเลยครับ
Picture 3.12
Picture 3.12
ในส่วนของ Font Rendering นั้น เป็นรูปแบบวิธีในการแสดงผลของแบบอักษรบนหน้าจอ วิธีการเลือกที่ง่ายและดีที่สุดนั้นคือ ให้เลือกแบบที่คุณมองแล้วสบายตาเป็นใช้ได้ครับ
ถ้าหากคุณใช้หน้าจอเป็นภาษาไทย (จะแนะนำการตั้งค่าหน้าจอภาษาไทยใน Unit 4) คุณต้องเลือกแบบอักษรที่เป็นภาษาไทยด้วยเช่นเดียวกัน ซึ่งแบบอักษรภาษาไทยที่มีให้ใช้ใน Ubuntu จะมีแบบอักษรต่างๆดังนี้ครับ
Norasi
Garuda
Loma
Purisa
Freeserif
TLWG mono
เมื่อคุณทำการติดตั้ง Ubuntu เป็นที่เรียบร้อยแล้ว จะมีโปรแกรมพื้นฐานมาให้พร้อมใช้ในทันที ซึ่งไม่จำเป็นต้องติดตั้งเพิ่มแต่อย่างใด สำหรับในตอนนี้ ผมจะแนะนำโปรแกรมพื้นฐานแต่ละตัวให้รู้จักกันครับ เพื่อจะได้เลือกใช้งานได้อย่างถูกต้อง
โปรแกรมจัดการไฟล์ใน Ubuntu จะมีชื่อเรียกว่า Nautilus ครับ ทุกครั้งที่คุณเปิดโฟลเดอร์บ้าน หรือดับเบิลคลิกที่โฟลเดอร์ใดๆก็ตาม Nautilus จะถูกเรียกขึ้นมาทำงาน โปรแกรม Nautilus นี้มีหน้าตาไม่แตกต่างจาก File Manager ของ Windows มากนัก การเรียนรู้จึงไม่ยาก
Picture 3.13
Picture 3.13
เมนูหลัก
แถบเครื่องมือ
ตำแหน่ง
ย่อ/ขยาย และมุมมอง
เมนูข้าง
ไฟล์และโฟลเดอร์
แถบสถานะ
การแสดงแฟ้มซ่อนให้คุณกด Ctrl+H โปรแกรมจะแสดงไฟล์และแฟ้มที่ถูกซ่อนขึ้นมา ซึ่งส่วนใหญ่จะเป็นไฟล์ที่ใช้ในการบันทึกการตั้งค่าส่วนตัว การสร้างแฟ้มซ่อนนั้นเพียงแค่เปลี่ยนชื่อไฟล์หรือแฟ้มนั้นๆ แล้วใส่ “จุด” นำหน้า เช่น โฟลเดอร์ชื่อ hidden เปลี่ยนชื่อเป็น .hidden ไฟล์หรือแฟ้มนั้นๆ จะถูกซ่อนในทันที
ในส่วนของตำแหน่งในหมายเลข 3 ถ้าคุณรู้ตำแหน่งที่แน่นอนที่ต้องการไป เช่น /media/cdrom คุณสามารถพิมพ์ตำแหน่งลงไปได้เลย โดยการกด Ctrl+L แถบที่ใช้บอกตำแหน่งด้วยปุ่มจะเปลี่ยนเป็นแถบยาวๆคล้ายของ Web Browser เพื่อให้คุณพิมพ์ตำแหน่งที่ต้องการได้เลย
เมนูด้านข้างคุณสามารถเปลี่ยนจากสถานที่สำคัญ เป็นข้อมูลของแฟ้มหรือมุมมองแบบรากไม้ก็ได้ ด้วยการคลิกที่ข้อความที่เขียนว่า Places แล้วเลือกตัวเลือกที่ต้องการ
โปรแกรม Web Browser หรือที่เรียกกันติดปากว่าโปรแกรมท่องอินเทอร์เน็ตนั้น จะเป็นโปรแกรม Firefox ซึ่งวิธีการใช้งานนั้นเหมือนกับ Firefox ที่เป็นเวอร์ชั่นของ Windows อยู่แล้ว วิธีเรียกใช้โปรแกรม Firefox นี้ สามารถเรียกได้จาก เมนู Applications > Internet > Firefox Web Browser
Picture 3.14
Picture 3.14
การตั้งค่าภาษาไทยสำหรับ Firefox เพื่อใช้เว็บไซต์ภาษาไทยนั้น เราจะต้องทำการตั้งค่าเพื่อใช้งานสำหรับการเข้ารหัสสองแบบคือ UTF-8 และ TIS-620
วิธีการตั้งค่าให้คุณคลิกที่ Edit > Preferences หน้าต่างการตั้งค่าจะถูกเปิดขึ้นมา ให้คุณเลือกที่ Content (ที่มีไอคอน ลูกโลก) โปรแกรมจะแสดงส่วนปรับตั้งค่าสำหรับการแสดงผลของเว็บไซต์ขึ้นมา ดูที่กรอบ Fonts & Colors ที่ช่อง Default Font ผมแนะนำให้เลือก Loma ซึ่งเป็นฟอนต์ที่สวยมากๆตัวหนึ่ง จากนั้นท้ายช่อง Default Font ให้คลิกที่ Advanced...
หน้าต่างสำหรับตั้งค่าฟอนต์จะเปิดขึ้นมา ที่ช่องบนสุดให้คลิกเลือกเป็น Thai ก่อน เพื่อปรับแต่งค่าสำหรับเว็บไซต์ที่เข้ารหัสแบบ TIS-620 ที่ช่อง Serif และ Sans-serif ให้เลือกฟอนต์เป็น Loma เสร็จแล้ว ที่ช่อง Fonts for ที่เราได้เลือกเป็น Thai เมื่อสักครู่ ให้เปลี่ยนเป็น Western เพื่อตั้งค่าการแสดงผลสำหรับเว็บที่เข้ารหัสแบบ UTF-8 ที่ช่อง Serif และ Sans-serif ให้เลือกเป็น Loma เช่นเดิม เสร็จแล้วที่กรอบ Character Encoding ด้านล่าง ให้เลือกเป็น Thai (TIS-620) เพื่อให้หน้าเว็บที่ไม่ได้กำหนดรหัสภาษาใช้การเข้ารหัสแบบ TIS-620 โดยอัตโนมัติ เพียงเท่านี้ก็เป็นอันเสร็จสิ้นการตั้งค่าภาษาของ FireFox ครับ
Picture 3.15
Picture 3.15
โปรแกรมดูหนังใน Ubuntu จะมีชื่อว่า Totem ครับ ใช้สำหรับเล่นไฟล์ภาพยนต์ต่างๆ รวมถึง CD และ DVD ด้วย ตัวโปรแกรมสามารถเรียกได้ทาง เมนู Applications > Sound & Video > Movie Player โดยในเบื้องต้นหลังจากที่ติดตั้ง Ubuntu เสร็จแล้ว โปรแกรมจะไม่สามารถเล่นไฟล์บางประเภทได้ เนื่องจากการเข้ารหัสของไฟล์บางประเภทนั้นติดสิทธิบัตร ฉะนั้น Ubuntu จึงไม่ได้รวมตัวถอดรหัสมาให้จึงไม่สามารถชมภาพยนตร์ได้ทันที จำเป็นต้องติดตั้งแพคเกจบางอย่างเพิ่ม ซึ่งผมจะแนะนำไว้ใน Unit 4 ครับ
Picture 3.16
Picture 3.16
โปรแกรมสำหรับฟังเพลงใน Ubuntu นั้น มีชื่อว่า Rhythmbox ครับ สามารถเรียกใช้งานได้ผ่าน เมนู Applications > Sound & Video > Rhythmbox Music Player และเช่นเดียวกับโปรแกรม Movie Player ที่โปรแกรมจะยังไม่สามารถเล่นไฟล์ได้ในบางประเภท เนื่องจากปัญหาเดียวกันคือเรื่องของ สิทธิบัตร ส่วนวิธีแก้ไขนั้นผมจะแนะนำไว้ใน Unit 4 ครับ
Picture 3.17
Picture 3.17
โปรแกรมสำหรับตัดต่อและตกแต่งภาพนั้น Ubuntu เลือกเอาโปรแกรม GIMP เข้ามารวมไว้เป็นโปรแกรมหลักที่ใช้สำหรับตกแต่งภาพครับ ซึ่งมีความสามารถไม่แพ้โปรแกรมตกแต่งภาพชั้นนำในท้องตลาดเลย ทั้งการทำงานแบบเลเยอร์ ฟิลเตอร์ต่างๆที่มีให้เลือกใช้ แถมยังรองรับไฟล์หลากหลายรูปแบบที่เป็นที่นิยม ไม่เว้นแม้แต่ไฟล์ .psd ของโปรแกรม Photoshop ก็ตาม การเรียกโปรแกรมนั้นให้ไปที่ เมนู Applications > Graphics > GIMP Image Editor ครับ
Picture 3.18
Picture 3.18
โปรแกรมดูภาพใน Ubuntu จะแบ่งออกเป็นสองโปรแกรมด้วยกันคือ eog (Eye Of Gnome ตามภาพที่ 3.19) โปรแกรมขนาดเล็กสำหรับดูภาพ และการปรับแต่งระดับพื้นฐาน เช่น หมุนภาพ ปรับขนาด และอีกโปรแกรมคือโปรแกรมดูรูปภาพที่มีความสามาถขึ้นมาอีกระดับคือ gThumb (ภาพที่ 3.20) โปรแกรม gThumb มีความสามารถมากกว่า eog คือ สามารถจัด Catalogs ให้รูปภาพได้ ปรับความมืด สว่าง และค่าต่างๆเกี่ยวกับสีได้ ตัดภาพให้เหลือเฉพาะส่วนที่ต้องการได้ แปลงภาพไปเป็นไฟล์ภาพสกุลอื่นได้
Picture 3.19
Picture 3.19
การเรียกใช้งาน eog สามารถเรียกได้โดยการดับเบิ้ลคลิกที่ภาพที่ต้องการดูได้เลย โปรแกรม eog จะถูกเรียกขึ้นมาทำงานพร้อมกับแสดงภาพที่ต้องการขึ้นมา ส่วนการเรียกโปรแกรม gThumb นั้นเรียกได้จาก เมนู Applications > Graphics > gThumb Image Viewer
Picture 3.20
โปรแกรมด้านสำนักงาน (การพิมพ์เอกสาร, ตารางคำนวน ฯลฯ) ใน Ubuntu จะมีโปรแกรมที่ชื่อ OpenOffice.org ให้ใช้ ซึ่งในชุดของ OpenOffice.org จะรวมโปรแกรมสำหรับทำงานต่างๆไว้ภายใน ดังต่อไปนี้
Writer : พิมพ์เอกสาร
Calc : ตารางคำนวน
Impress : การนำเสนอ
Base : ฐานข้อมูล
Draw : วาดกราฟ, ไดอะแกรมอย่างง่าย
Picture 3.21
Picture 3.21
การเรียกใช้โปรแกรม OpenOffice.org ให้คุณไปที่ เมนู Applications > Office คุณจะเห็นโปรแกรมคำสั่งเพื่อเรียกโปรแกรม OpenOffice.org ด้วยกันสี่คำสั่งดังนี้
OpenOffice.org Database
OpenOffice.org Presentation
OpenOffice.org Spreadsheet
OpenOffice.org Word Processor
จากคำสั่งเรียกโปรแกรมทั้งสี่ คุณสามารถเรียก OpenOffice.org ขึ้นมาทำงานนั้นๆได้ทันที ส่วนการเรียกใช้ OpenOffice.org Draw ซึ่งไม่มีให้เรียกผ่านเมนูนั้น คุณต้องเปิด OpenOffice.org ตัวใดตัวหนึ่งขึ้นมาก่อน แล้วคลิกที่ File > New > Drawing
เพื่อการใช้งานภาษาไทยที่สมบูรณ์แบบ คุณต้องไปเปิดใช้งานในส่วนของ ภาษาประเภท CTL เสียก่อน ที่โปรแกรม OpenOffice.org คลิกที่ Tools > Options... หน้าต่าง Options จะเปิดขึ้นมาเพื่อให้คุณตั้งค่าต่างๆ ในการตั้งค่าภาษานั้นให้คุณคลิกเลือกที่ Language Settings > Languages ให้คุณตั้งค่าตามนี้
Locale setting : Thai
Default currency : THB ฿ Thai
CTL : Thai
เพียงเท่านี้การใช้งานภาษาไทยในงานเอกสารของคุณก็จะสมบูรณ์ยิ่งขึ้นแล้วครับ
Picture 3.22
Picture 3.22
หลายครั้งที่ผมชวนให้คนหันมาใช้ Ubuntu สิ่งหนึ่งที่คนส่วนใหญ่กังวลคือจะไม่ได้แชทกับเพื่อนผ่านทาง MSN Messenger แต่ที่จริงแล้วใน Ubuntu มีโปรแกรมสำหรับแชทที่ชื่อ Gaim ซึ่งรองรับการแชทในแทบจะทุกเครื่อข่ายที่เป็นที่นิยม ตั้งแต่ MSN, Yahoo, Gmail, ICQ, IRC, AOL etc. และยังสามารถที่จะออนไล์หลายเครือข่ายพร้อมกันได้อีกด้วย
Picture 3.23
Picture 3.23
Picture 3.24แม้จะมีข้อจำกัดอยู่บ้าง เช่น ตั้งชื่อได้ด้วยความยาวที่จำกัด ใช้เอฟเฟกต์ต่างๆไม่ได้ (เช่น สั่นหน้าต่าง) เป็นต้น แต่ในการใช้งานพื้นฐาน เช่น พูดคุย หรือส่งไฟล์ให้กันนั้นสามารถทำได้เป็นอย่างดี
Picture 3.24
เปิดโปรแกรม Gaim ขึ้นมา โดยคลิกที่ เมนู Applications > Internet > Gaim Internet Messenger
จะมีหน้าต่างของโปรแกรม Gaim ปรากฏขึ้นมาสองหน้าต่างคือ Buddy List และ Accounts
ที่หน้าต่าง Accounts ให้คลิกที่ Add จะเป็นการสร้างบัญชีผู้ใช้สำหรับออนไลน์
โปรแกรมเพิ่มบัญชีผู้ใช้จะถูกเรียกขึ้นมา ให้ป้อนค่าตามนี้
Protocal : MSN
Screen Name : ใส่อีเมล์ของคุณ
Password : รหัสผ่านของคุณ (รอกรอกตอน Login ก็ได้)
ในส่วนของ User Options จะสามารถใส่ภาพได้ ซึ่งจะใส่หรือไม่ก็ได้
เสร็จแล้วคลิกที่ Save เพื่อทำการบันทึก
คุณจะกลับมาที่หน้า Account อีกครั้งให้คลิกเลือกที่ช่อง Enabled เพื่อออนไลน์
รอระบบทำการเชื่อมต่อ แล้วก็แชทได้เลย
โปรแกรม Email Client ใน Ubuntu จะมี Evolution มาให้ใช้ครับ สามารถได้ใช้ได้ผ่านทาง เมนู Applications > Internet > Evolution Mail ครับ Evolution เป็นโปรแกรมที่มีความสามารถมากกว่าที่จะใช้สำหรับรับส่งอีเมล์เพียงอย่างเดียว มันสามารถเป็นทั้งสมุดจดชื่อที่อยู่ ตารางปฏิทิน จดบันทึกต่างๆ ฯลฯ
Picture 3.25วิธีการตั้งค่าเพื่อใช้งานอีเมล์นั้น จะคล้ายกับโปรแกรม Email Client ตัวอื่นๆ ซึ่งค่าที่จะตั้งนั้น คุณต้องสอบถามกับผู้ดูแลระบบของหน่วยงานของคุณเอง
Picture 3.25
เช่นเดียวกับโปรแกรม Firefox ที่เราต้องตั้งค่าภาษาไทยเสียก่อนจึงจะอ่านภาษาไทยออก แต่สำหรับ Evolution จะตั้งค่าการเข้ารหัสภาษาแบบ UTF-8 มาอย่างดีแล้ว ที่เราต้องทำคือปรับค่าเพิ่มเติมสำหรับอีเมล์ที่ถูกส่งมาโดยเข้ารหัสแบบ TIS-620 ครับ
ไปที่ Edit > Preferences
เลือก Mail Preferences
ช่อง Default character encoding เลือก Thai (TIS-620)
ช่อง Message Fonts เลือกฟอนต์ตามต้องการ
Picture 3.26
Ubuntu มีโปรแกรมแปลภาษา (หรือที่เรียกกันว่าดิกชั่นนารี่) มาให้แล้ว เพียงแต่เราต้องทำการปรับแต่งเพิ่มเติมอีกเล็กน้อย เพื่อให้โปรแกรมสามารถแปลคำศัพท์ภาษาไทยได้ การเรียกใช้โปรแกรมนั้น ให้ไปที่ เมนู Applications > Accessories > Dictionary
Picture 3.27
Picture 3.27
คลิกที่ Edit > Preferences
คลิกเลือกที่ Longdo Thai-English Dictionaries
เมื่อทำการตั้งค่าตามขั้นตอนข้างตนแล้ว โปรแกรมจะทำการแปลข้อความที่ป้อนจาก ไทย > อังกฤษ และ อังกฤษ > ไทย โดยอัตโนมัติ
นอกเหนือจากโปรแกรมที่ได้แนะนำมาแล้วนั้น เรายังสามารถติดตั้งโปรแกรมเพิ่มเติมลงไปได้อีกด้วย ซึ่งการติดตั้งโปรแกรมเพิ่มเติมบน Ubuntu นั้นง่ายมากๆ เพราะคุณไม่ต้องไปหาดาวน์โหลดโปรแกรมมาจากเว็บไซต์ไหนเลย เพียงแค่คุณเปิดโปรแกรม Add/Remove Applications เลือกโปรแกรมที่ต้องการ แล้วกดติดตั้ง เพียงเท่านี้โปรแกรมที่คุณต้องการก็จะถูกนำมาเสริฟไว้ตรงหน้าของคุณทันที
การติดตั้งโปรแกรมเพิ่มเติมผ่านระบบจัดการแพคเกจของ Ubuntu นั้น จะขึ้นอยู่กับแหล่งจัดเก็บซอฟต์แวร์หรือ Repository ที่จะเป็นตัวบอกว่ามีโปรแกรมอะไรบ้างที่เราจะติดตั้งได้ผ่านระบบจัดการแพคเกจ ซึ่ง Repository ในค่าตั้งต้นที่ Ubuntu ตั้งไว้จะตั้งไปที่ Repository ที่มีเฉพาะซอฟต์แวร์โอเพนซอร์สและส่วนของไดร์เวอร์ฮาร์ดแวร์ต่างๆเท่านั้น แต่เราก็สามารถเพิ่ม Repository ให้ชี้ไปที่ที่มีซอฟต์แวร์ที่ไม่ใช่โอเพนซอร์สได้ด้วย ซึ่ง Repository ที่เราจะเพิ่มเข้ามานี้ แม้จะมีซอฟต์แวร์ที่ไม่ใช่โอเพนซอร์สรวมอยู่ แต่ก็เป็นโปรแกรมที่ถูกต้องตามลิขสิทธิ์ทั้งสิ้นครับ ซึ่งการทำแบบนี้จะทำให้มีซอฟต์แวร์ให้เราเลือกได้หลายหลายมากยิ่งขึ้นครับ
วิธีการทำงานของระบบจัดการแพคเกจคือ ระบบจะดูว่า Repository ที่เราตั้งไว้ชี้ไปที่ไหน ซึ่งระบบก็จะวิ่งไปอัพเดทรายชื่อซอฟต์แวร์ที่นั่น (บนเซิร์ฟเวอร์ตามที่ระบุไว้ใน Repository) และเราจะสามารถติดตั้งซอฟต์แวร์ได้ตามรายชื่อซอฟต์แวร์ที่ได้ทำการอัพเดท
การเพิ่มเติม Repository นั้น ให้ไปที่ เมนู System > Administration > Software Sources จะปรากฏหน้าต่าง Software Sources ขึ้นมา ให้มองที่ส่วนของ Internet จะถูกเลือกอยู่ที่บางช่องเท่านั้น ซึ่งแต่ละช่องนั้นมีความหมายดังนี้
Picture 3.28
Picture 3.28
Community Maintained .... หมายถึง Repository ที่เก็บซอฟต์แวร์ที่เป็นโอเพนซอร์สไว้ ดูแลโดยนักพัฒนาอิสระ
Canonical supported .... หมายถึง Repository ที่เก็บซอฟต์แวร์โอเพนซอร์สไว้ ซึ่งดูแลโดยทีมพัฒนา Ubuntu เอง
Software restricted .... หมายถึง Repository ที่เก็บซอฟต์แวร์ที่อาจติดเรื่องของสิทธิบัตรหรือลิขสิทธิ์ไว้ด้วย
Proprietary .... หมายถึง Repository ที่เก็บไดรว์เวอร์ต่างๆจากผู้ผลิตฮาร์ดแวร์เอาไว้
Source code หมายถึง ระบบจะทำการรวมซอร์สโค้ดจาก Repository ต่างๆ ไว้ในรายชื่อซอฟต์แวร์ด้วยเมื่อคุณทำการอัพเดท
Download from หมายถึง เซิร์ฟเวอร์ที่จะทำการอัพเดทซอฟต์แวร์ลิสต์ ซึ่งถ้าเป็น Thailand ก็แน่นอนว่าจะเร็วกว่าต่างประเทศครับ
เมื่อคุณเข้าใจแล้วว่ารายการไหนคืออะไรคุณก็สามารถเลือกได้ตามสะดวกเลยครับ แต่ถ้าคุณไม่เข้าใจเลยสักนิดและยังงงๆอยู่ก็ไม่เป็นไรครับ ลบไปจากหัวได้เลย และคลิกเลือกให้หมดไปเลยยกเว้ย Source code ครับ เพราะเราคงไม่ได้ใช้ Source code ของโปรแกรมในการใช้งานทั่วๆไปอยู่แล้ว
หลังจากปรับแต่ง Repository แล้ว เรามาลองติดตั้งโปรแกรมกันครับ ให้คุณคลิกที่ เมนู Applications > Add/Remove... โปรแกรม Add/Remove Applications จะถูกเรียกขึ้นมาทันที ที่หน้าต่างของโปรแกรมนี้จะถูกแบ่งออกเป็นสามส่วนด้วยกัน
Picture 3.29
Picture 3.29
ช่องซ้ายจะเป็นการแบ่งกลุ่มของโปรแกรมซึ่งจะช่วยให้คุณเลือกโปรแกรมที่ต้องการได้ง่ายขึ้น
ช่องขวาบน เป็นรายชื่อของโปรแกรม ซึ่งจะแสดงขึ้นมาตามกลุ่มที่คุณได้เลือกไว้จากช่องทางซ้าย
ช่องขวาล่าง รายละเอียดของโปรแกรมที่คุณคลิกเลือกจากช่องทางขวาบน
โปรแกรมที่ผมแนะนำเพื่อทดสอบการติดตั้งจะมีชื่อว่า Frozen-Bubble ให้คุณคลิกเลือกที่กลุ่มโปรแกรม Games ครับ จากนั้นให้เลื่อนหาโปรแกรม Frozen-Bubble เมื่อเจอแล้วคลิกที่เช็คบ๊อกด้านหน้า จากนั้นให้กดที่ OK โปรแกรมจะให้ข้อมูลเกี่ยวกับการติดตั้งโปรแกรมในครั้งนี้ว่า มีโปรแกรมใดถูกติดตั้งบ้าง เมื่อมั่นใจแล้วให้กด Apply โปรแกรมจะถามพาสเวิร์ดของผู้ดูแล ซึ่งถ้าคุณมีสิทธิ์ในฐานะของผู้ดูแลเครื่องนั้น (Administrator) ให้ใส่พาสเวิร์ดของคุณลงไปครับ เสร็จแล้วให้รอสักครู่ ระบบจะทำการดาวน์โหลดโปรแกรมจาก Repositories ผ่านทางอินเทอร์เน็ต ให้คุณรอจนเสร็จ
เมื่อเสร็จแล้วคุณสามารถใช้งานโปรแกรมที่ติดตั้งได้ทันที ในกรณีนี้คือเกม Frozen-Bubble คุณสามารถเรียกเกมนี้ขึ้นมาเล่นได้โดยไปที่ เมนู Games > Frozen-Bubble
สำหรับการติดตั้งโปรแกรมอื่นๆนั้น จะใช้วิธีเดียวกันกับในขั้นตอนที่ผ่านมานี้ครับ ซึ่งโปรแกรมดีๆและเกมสนุกๆนั้นมีอยู่เยอะ ลองเลือกดูและติดตั้งใช้งานกันนะครับ
ในบทนี้จะแนะนำเทคนิคในการใช้งานเล็กๆน้อยๆ ที่จะเป็นประโยชน์ในการใช้งานจริง เพื่อให้คุณใช้งานได้อย่างเต็มประสิทธิภาพยิ่งขึ้นครับ
เช่นเดียวกับ Windows ที่ไฟล์หรือโฟลเดอร์ ที่ถูกลบจะถูกนำไปไว้ในถังขยะก่อน ซึ่งถังขยะนี้จะอยู่ในโฟลเดอร์บ้านของคุณนั่นเอง เพียงแต่ว่าอยู่ในรูปแบบของแฟ้มซ่อน ซึ่งในหน้าต่างโปรแกรม File Manager (Nautilus) ให้คุณกด Ctrl+h คุณจะพบโฟลเดอร์ที่ชื่อว่า .Trash เมื่อคุณเปิดขึ้นมาดู คุณจะพบไฟล์ต่างๆที่ลบไปแล้ว ซึ่งสามารถย้ายออกไปไว้ในตำแหน่งที่คุณต้องการ และใช้งานไฟล์นั้นได้ทันที
อีกทางหนึ่งที่น่าจะสะดวกกว่าที่จะเข้าถึงถังขยะได้คือไอคอนที่ Panel ด้านขวาล่าง เมื่อคุณคลิก จะเปิดโปรแกรม File Manager พร้อมแสดงไฟล์ที่ถูกลบไปแล้วเช่นเดียวกัน
Picture 4.1
ในขั้นตอนการติดตั้งที่ผมแนะนำให้เลือกคีย์บอร์ดภาษาไทย คุณจะสามารถพิมพ์ภาษาไทยได้ในทันที แต่ผมจะแนะนำเรื่องของการติดตั้งการพิมพ์ภาษาอื่นๆเพิ่มเติมอีกครั้ง เผื่อว่าคุณอาจต้องการใช้ภาษาอื่นนอกจากภาษาไทยในการทำงานด้วย
Picture 4.2
Picture 4.2
วิธีเพิ่มภาษาสำหรับการพิมพ์นั้น ให้ไปที่ เมนู System > Preferences > Keyboard หน้าต่าง Keyboard Preferences จะถูกเรียกขึ้นมา ให้คุณคลิกเลือกที่แถบ Layouts คุณจะเห็น Layouts ของภาษาไทยและอังกฤษอยู่ ให้คลิกที่ Add จะมีหน้าต่าง Choose a Layouts ขึ้นมา คุณสามารถเลือกผังคีย์บอร์ดที่ต้องการใช้ได้ทันที
ส่วนของปุ่มสลับภาษานั้นสามารถเปลี่ยนได้ที่หน้าต่าง Keyboard Preferences เช่นเดียวกัน โดยให้คลิกเลือกที่แถบ Layout Options ส่วนของคีย์ลัดสำหรับสลับภาษาจะอยู่ที่ Group Shift/Lock behavior ซึ่งสามารถเปลี่ยนได้ตามที่ระบบมีให้เลือกเท่านั้น
บน Windows เราจะเห็นปุ่มสลับภาษาอยู่ที่ Panel ด้านล่างติดกับ System tray ซึ่ง Ubuntu นั้นสามารถเพิ่มปุ่มในลักษณะเดียวกันนี้ลงใน Panel ได้เช่นเดียวกัน ปุ่มสลับภาษานี้นอกจากจะใช้ในการคลิกสลับภาษาแล้ว ยังสามารถใช้บอกภาษาปัจจุบันที่เรากำลังใช้อยู่ได้อีกด้วย การเพิ่มปุ่มสลับภาษานี้ให้คุณคลิกขวาบน Panel ในตำแหน่งที่ต้องการวางปุ่มสลับภาษา จากนั้นเลือก Add to Panel หน้าต่าง Add to Panel จะปรากฏขึ้นมา ให้คุณมองหาไอคอนรูปธงที่มีข้อความกำกับว่า Keyboard Indicator จากนั้นกด Add หนึ่งครั้ง และคลิกที่ Close เพื่อปิดหน้าต่างได้เลย เพียงเท่านี้ปุ่มสลับภาษาก็จะอยู่บน Panel ตามที่เราต้องการแล้วครับ
Picture 4.3
ในขณะที่เราใช้งาน Ubuntu อยู่นี้ เราสามารถพิมพ์ภาษาไทยได้แล้วก็จริง แต่ว่าในส่วนภาษาของระบบ เช่น เมนู หรือที่โปรแกรมต่างๆนั้น สามารถแสดงข้อความเป็นภาษาไทยได้ด้วย ซึ่งจะมีประโยชน์มากสำหรับผู้ใช้คอมพิวเตอร์ที่ไม่มีความรู้ด้านภาษาอังกฤษ หรืออาจจะไม่ถนัดในการใช้ภาษาอังกฤษ
Picture 4.4
Picture 4.4
การปรับแต่งระบบให้แสดงผลภาษาไทยนั้นให้ไปที่ เมนู System > Administration > Language Support ระบบจะถามรหัสผ่านของผู้ดูแลก่อน เพราะการเปลี่ยนแปลงนี้จะมีผลต่อระบบทั้งหมด เมื่อป้อนรหัสผ่านแล้ว หน้าต่าง Language Support จะเปิดขึ้นมา ให้คุณเลือกภาษาไทยแล้วคลิก OK ได้เลย แต่หากคุณต้องการใช้ภาษาไทยเป็น ภาษาปริยายของระบบ ให้คุณคลิก Apply ก่อนหนึ่งครั้ง เพื่อให้ระบบดาวน์โหลดแพคเกจภาษาไทยลงมาก่อน เสร็จแล้วที่ช่อง Default Language จึงจะมีภาษาไทยให้เลือกครับ
เมื่อคุณได้ติดตั้งให้ใช้งานภาษาไทยแล้ว คุณจะยังไม่เห็นผลในทันที คุณจะต้องออกจากระบบโดยการล๊อกเอาท์เสียก่อน หรือจะรีสตาร์ทก็ตามแต่ จนคุณมาถึงหน้าล๊อกอินเพื่อเข้าระบบอีกครั้ง ก่อนที่คุณจะล๊อกอินให้สังเกตุที่มุมซ้ายล่าง จะเห็นข้อความที่เขียนว่า Options ให้คลิกลงไปแล้วเลือกที่ Select Language จากนั้นให้เลือกเป็น Thai หรือจะเลือกเป็น System Default ก็ได้ หากคุณตั้งให้ภาษาไทยเป็น Default Language ไว้ในขั้นตอนที่ผ่านมา
Picture 4.5
Picture 4.5
ใน Ubuntu จะมีโปรแกรมจับภาพหน้าจออยู่ โดยสามารถเรียกโปรแกรมได้จาก เมนู Applications > Accessories > Take Screenshot โปรแ กรมจับภาพหน้าจอจะถูกเรียกขึ้นมา จะมี 2 ตัวเลือกให้คุณเลือกคือ Grab the whole desktop หมายถึงการจับภาพหน้าจอทั้งหน้าจอ และอีกตัวเลือกหนึ่งคือ Grab the current window หมายถึง จับภาพเฉพาะหน้าต่างที่กำลังทำงานอยู่เท่านั้น ส่วนของ Grab after a delay of ... หมายถึงจะให้จับภาพหลังจากที่คลิก Take Screenshot แล้วกี่วินาที ซึ่งคุณสามารถจัดสภาพแวดล้อมก่อนที่จะจับภาพได้ด้วยตัวเลือกการหน่วงเวลานี้
Picture 4.6
Picture 4.6
นอกจากการเรียกตามวิธีด้านบนแล้ว คุณยังสามารถจับภาพหน้าจอด้วยคีย์ลัดได้ด้วย ด้วยการกดปุ่ม Print Screen บนคีย์บอร์ด โปรแกรมจะจับภาพพร้อมแสดงหน้าต่างโปรแกรมขึ้นมาเช่นเดียวกับวิธีในข้างต้น หรือคุณอาจจับภาพเฉพาะหน้าต่างที่ทำงานอยู่ได้ด้วย โดยการคลิกเลือกหน้าต่างที่ต้องการก่อน จากนั้นกดปุ่ม Alt+ Print Screen โปรแกรมจะจับภาพเฉพาะหน้าต่างที่คุณเลือก
ดังที่ผมได้กล่าวไว้ใน Unit 3 เรื่องของโปรแกรม Movie Player และ Music Player ว่าไฟล์บางประเภทนั้นจะไม่สามารถเล่นได้ในทันทีจะต้องติดตั้งแพคเกจเพิ่มเติมเสียก่อน วิธีนั้นอาจยุ่งยากนิดหน่อย แต่แลกกับผลลัพภ์ที่ได้แล้วคุ้มค่าแน่นอนครับ
ทำการ "เพิ่ม Repository" (ตาม Unit 3) เสียก่อน
เปิดโปรแกรม Add/Remove Applications ขึ้นมา
ที่หน้าจอทางซ้ายให้เลือกหมวดหมู่เป็น Sound & Video
ให้ติดตั้ง Plugin 3 ชุด คือ
Gstreamer extra plugins
Gstreamer ffmpeg video plugin
Xine extra plugins
ด้วยปลั๊กอินสามชุดที่คุณได้ทำการติดตั้ง เพียงเท่านี้คุณก็พร้อมที่จะเล่นไฟล์ภาพยนต์และเพลงในรูปแบบต่างๆได้แล้วครับ
การเขียนซีดีใน Ubuntu นั้น เราสามารถเขียนได้ผ่านโปรแกรม File Manager ได้ทันที โดยถ้าหากคุณใส่แผ่นซีดีเปล่าเข้ามาในเครื่อง จะมีหน้าต่างขึ้นมาถามคุณเองว่าคุณต้องการที่จะ สร้างซีดีเพลงจากไฟล์เพลงดิจิตอล (Make Audio CD) เช่น จากไฟล์ WAV หรือสร้างซีดีข้อมูล (Make Data CD) หรือไม่ทำอะไรเลย (Ignore)
Picture 4.7
Picture 4.7
หากคุณเลือกที่เขียนซีดีเพลง จะมีโปรแกรม Serpentine เข้ามาทำหน้าที่ในส่วนนี้ ซึ่งวิธีใช้งานนั้นผมขอข้ามไป เพราะไม่ยากอยู่แล้วสำหรับคุณที่คิดจะใช้ Ubuntu ส่วนโปรแกรม Serpentine นั้น คุณสามารถเรียกโปรแกรมนี้ขึ้นมาทำงานเองก็ได้ โดยเรียกที่ เมนู Applications > Sound & Video > Serpentine Audio CD Creator ซึ่งก็ได้ผลลัพภ์เดียวกัน
ย้อนกลับมาที่อีกทางเลือกหนึ่งเมื่อคุณใส่แผ่นซีดีเปล่าเข้าไปคือ สร้างแผ่นซีดีข้อมูล (Make Data CD) หากคุณเลือกตัวเลือกนี้ โปรแกรม File Manager จะถูกเรียกขึ้นมา พร้อมกับไปที่ส่วนของการสร้างซีดีข้อมูล ในหน้าต่างนี้คุณสามารถลากไฟล์ใส่ลงไปได้เลย จนเมื่อคุณพร้อมแล้วให้กดที่ปุ่ม Write to Disc เพื่อเขียนข้อมูลลงแผ่นซีดี ส่วนการเรียกโปรแกรม File Manager ขึ้นมาเขียนซีดีโดยไม่ผ่านหน้าต่างตัวเลือกนั้น คุณสามารถเรียกได้ที่ เมนู Places > CD/DVD Creator
Picture 4.8
Picture 4.8
Picture 4.9ส่วนการเขียนซีดีจากไฟล์ .iso เช่นเดียวกับตอนที่เราสร้างแผ่น Ubuntu จากโปรแกรม nero บนวินโดวส์ก็สามารถทำได้เช่นเดียวกันครับ โดยหลังจากที่คุณใส่แผ่นซีดีเปล่าลงในเครื่องแล้ว ให้คุณคลิกขวาที่ไฟล์ .iso ที่คุณต้องการ จากนั้นเลือก Write to Disc... เพียงเท่านี้ครับ
Picture 4.9
กรณีที่แผ่นของคุณเป็นแผ่น RW (ลบและเขียนใหม่ได้) ไม่ต้องมองหาโปรแกรมลบข้อมูลใน CD แต่อย่างใดครับ ให้คุณลบไฟล์ในซีดีเหมือนกับว่าเป็นไฟล์ที่อยู่ในฮาร์ดดิสก์ได้เลย และเมื่อถึงตอนที่จะเขียนข้อมูลลงแผ่น โปรแกรมจะลบข้อมูลเดิมที่อยู่ในซีดีก่อนที่จะเขียนข้อมูลลงไปใหม่ให้เองโดยอัตโนมัติ
ทุกครั้งที่คุณเปิดเครื่อง คุณจำเป็นที่จะต้องป้อนชื่อผู้ใช้และรหัสผ่านก่อนทุกครั้งจึงจะมีสิทธิ์เข้าใช้งานเครื่อง เพื่อยืนยันว่าคุณเป็นใครและมีสิทธิ์ทำอะไรได้บ้าง ซึ่งมันจะมีประโยชน์มากถ้าคุณใช้เครื่องคอมพิวเตอร์ด้วยกันหลายคน แต่ถ้าคุณเป็นเจ้าของเครื่อง และใช้อยู่คนเดียว คงน่ารำคาญไม่น้อยที่ต้องมาคอยกรอกชื่อและรหัสผ่านเพื่อบอกว่าคุณเป็นใครในเมื่อคุณใช้เครื่องอยู่แค่คนเดียว
คุณสามารถตั้งค่าให้เข้าระบบอัตโนมัติได้ โดยเลือกชื่อผู้ใช้ของคุณเป็นชื่อผู้ใช้หลักเพื่อทำการเข้าระบบอัตโนมัติได้ ให้คุณไปที่ เมนู System > Administration > Login Window หน้าต่างนี้จะเป็นส่วนของการตั้งค่าการเข้าระบบ เช่น เปลี่ยนหน้าตาต้อนรับตอนเข้าระบบ ที่คุณต้องทำคือ ไปที่ Tab Security ให้คุณเช็คบ็อกซ์ที่ช่อง Enable Automatic Login จากนั้นให้เลือกชื่อผู้ใช้ของคุณเสร็จแล้วทำการ Close เพื่อปิดหน้าต่างการตั้งค่าได้ทันที
Picture 4.10
Picture 4.10
เช่นเดียวกับบน Windows ที่เราสามารถสั่งให้โปรแกรมใดสักโปรแกรม ทำงานเองโดยอัตโนมัติเมื่อระบบพร้อมทำงานหลังจากที่เราเข้าสู่ระบบ วิธีนั้นทำได้ไม่ยากเพียงแต่คุณต้องรู้ชื่อคำสั่งที่ใช้เรียกโปรแกรมนั้นด้วยเท่านั้น วิธีตั้งค่านั้นให้คุณไปที่ เมนู System > Preferences > Sessions หน้าต่างการตั้งค่า Session จะถูกเปิดขึ้นมา
ในหน้านี้คุณจะเห็นรายชื่อโปรแกรมที่ถูกสั่งให้ทำงานทันทีเมื่อเปิดเครื่องและระบบพร้อมที่จะทำงาน เช่น update-notifier ซึ่งเป็นตัวเตือนให้คุณอัพเดทระบบ ถ้าหากว่าคุณรู้สึกรำคาญคุณสามารถ Delete ออกไป หรือจะ Disable ไว้ก่อนก็ได้เช่นกัน ส่วนการเพิ่มโปรแกรมแกรมที่ต้องการให้ทำงานเมื่อเปิดเครื่องนั้น ให้คุณกด Add ระบบจะถามถึงคำสั่งที่ใช้ในการเรียกโปรแกรมนั้น ซึ่งคุณอาจต้องศึกษาดูเองว่าโปรแกรมที่คุณต้องการเรียกมีคำสั่งที่จะเรียกขึ้นมาทำงานอย่างไร ซึ่งโปรแกรมส่วนใหญ่นั้นจะมีคำสั่งเรียกใช้งานตรงกับชื่อโปรแกรมเอง เช่น firefox, gimp เป็นต้น
Picture 4.11
Picture 4.11
หลังจากติดตั้ง Ubuntu เสร็จแล้ว จะมีชื่อผู้ใช้เพียงชื่อเดียวเท่านั้น ซึ่งหากคุณใช้คอมพิวเตอร์ด้วยกันหลายคนในเครื่องเดียว การสร้างชื่อผู้ใช้เพิ่มตามจำนวนคนย่อมสมเหตุสมผลกว่า เพื่อที่การตั้งค่าตามความต้องการของแต่ละคนจะได้เป็นไปอย่างอิสระ
การเพิ่มผู้ใช้ใหม่ ให้คุณไปที่ เมนู System > Administration > Users and Groups ระบบจะถามรหัสผ่านของผู้ดูแลระบบก่อน ให้คุณใส่รหัสผ่านของคุณลงไป โปรแกรมจัดการ Users and Groups จะแสดงขึ้นมา วิธีเพิ่ม User ให้คุณคลิกเลือกที่ Add User จากนั้นหน้าต่าง New user account จะเปิดขึ้นมาให้คุณใส่รายละเอียดของผู้ใช้คนใหม่ให้เรียบร้อย หรืออาจใส่แค่ Username กับ Password ก็ได้ ส่วนค่าอื่นๆนั้น ผู้ใช้สามารถเปลี่ยนแปลงได้ด้วยตนเอง เมื่อเพิ่ม User เสร็จแล้วอย่าเพิ่งปิดหน้าต่าง ให้เลือกที่แถบ User privileges เพื่อมอบสิทธิ์ให้แก่ผู้ใช้ที่เพิ่มเข้ามาใหม่ว่าจะให้ทำอะไรได้บ้าง ซึ่งคุณอาจกำหนดให้มีสิทธิ์ในระดับ Administrator เช่นเดียวกับคุณเลยก็ได้
Picture 4.12
Picture 4.12
โปรแกรมบีบอัดไฟล์นั้น Ubuntu ได้จัดเตรียมมาให้เป็นที่เรียบร้อยแล้ว เพียงแต่ไม่มีเมนูหรือไอคอนสำหรับเรียกโปรแกรมขึ้นมาทำงานโดยตรงเท่านั้น วิธีเรียกใช้โปรแกรมบีบอัดไฟล์ เพียงแค่คุณดับเบิลคลิกที่ไฟล์บีบอัดโปรแกรมบีบอัดไฟล์จะถูกเรียกขึ้นมาเอง
Picture 4.13
Picture 4.13
การบีบอัดไฟล์ คุณสามารถทำได้ง่ายๆโดยการคลิกขวาที่ไฟล์หรือโฟลเดอร์ที่ต้องการบีบอัด จากนั้นเลือก Create Archive... จะมีหน้าต่างให้ตั้งชื่อไฟล์บีบอัดและสกุลของไฟล์เพียงเท่านี้การบีบอัดไฟล์ก็เป็นที่เรียบร้อยแล้ว ในทางกลับกัน คุณสามารถคลายไฟล์บีบอัดด้วยการคลิกขวาแล้วเลือก Extract Here ได้เช่นกัน
Picture 4.14
แม้ว่า Ubuntu จะได้จัดเตรียมแบบอักษรไทย มาให้ใช้อย่างดีแล้วก็ตาม แต่หากคุณมีแบบอักษรที่คุณต้องการใช้ คุณก็สามารถติดตั้งลงไปได้เช่นกัน
การติดตั้งแบบใช้คนเดียวหมายถึงผู้ใช้คนอื่นจะไม่สามารถใช้แบบอักษรที่คุณเพิ่มลงไปได้ แต่จะสะดวกตรงที่ผู้ไม่มีสิทธิ์ในฐานะ Administrator ก็สามารถเพิ่มแบบอักษรเพื่อใช้เองได้ วิธีเพิ่มแบบอักษรนั้นให้คุณเปิดโฟลเดอร์บ้าน โดยไปที่ เมนู Places > Home Folders โปรแกรม File Manager จะเปิดขึ้นมา ให้คุณกด Ctrl+h เพื่อแสดงแฟ้มซ่อน จากนั้นให้สร้างโฟลเดอร์ชื่อ .fonts แล้วให้คุณนำไฟล์ฟอนต์ที่เตรียมมา ใส่ลงในโฟลเดอร์ที่สร้างขึ้นมาใหม่ ก็เป็นอันเรียบร้อย
การติดตั้งแบบใช้ทั้งระบบ คุณจำเป็นจะต้องมีสิทธิ์ในฐานะ Administrator ด้วยจึงจะใส่ฟอนต์ลงในระบบได้ การติดตั้งฟอนต์ด้วยวิธีนี้ ผู้ใช้ทุกคนในเครื่องจะสามารถใช้งานฟอนต์นี้ได้ วิธีติดตั้งฟอนต์ ให้คุณกดปุ่ม Alt+F2 หน้าต่าง Run Application จะถูกเปิดขึ้นมา ให้คุณพิมพ์คำสั่งลงไปว่า sudo nautilus /usr/share/fonts พร้อมทั้งทำเครื่องหมายถูกที่ช่อง Run in terminal จากนั้นคลิกที่ Run จะมีหน้าต่าง Terminal (คล้ายหน้าต่างดอส) ขึ้นมาให้คุณป้อนรหัสผ่านแล้ว Enter โปรแกรม File Manager จะถูกเรียกขึ้นมา ให้คุณนำฟอนต์ใส่ลงไปเลยครับ
Picture 4.15
Picture 4.15
เราสามารถตั้งค่าส่วนตัวของเรารวมถึงเปลี่ยนรหัสผ่านที่ใช้สำหรับล๊อกอินเข้าระบบได้ครับ วิธีการตั้งค่านั้นให้ไปที่ เมนู System > Preferences > About Me จะปรากฏหน้าต่าง About you ขึ้นมา คุณสามารถตั้งค่าได้ตามต้องการครับ ส่วนการเปลี่ยนรหัสผ่านนั้น คุณต้องกรอกรหัสผ่านเดิมก่อนด้วย เพื่อเป็นการยืนยันตน
Picture 4.16
เป็นเรื่องปกติที่คนเราจะลืมรหัสผ่านเข้าระบบได้ ซึ่ง Ubuntu ก็ได้เตรียมส่วนของ Recovery mode ไว้แล้ว สิ่งที่คุณต้องทำคือ เมื่อเปิดเครื่องขึ้นมาแล้ว ที่เมนูสำหรับเลือกระบบปฏิบัติการให้เลือกที่เมนูที่มีวงเล็บว่า recovery mode ต่อท้าย ระบบจะทำงานไปเรื่อยๆจนไปจบที่หน้า Command line ซึ่งมีข้อความว่า root@computer-name:~# เมื่อขึ้นมาแล้ว คุณสามารถเปลี่ยนรหัสผ่านได้ทันที ด้วยการพิมพ์คำสั่งว่า passwd user-name จากนั้น Enter แล้วพิมพ์รหัสผ่านใหม่ที่ต้องการลงไป (ขณะพิมพ์จะไม่เห็นอักษรใดทั้งสิ้น คล้ายว่ากดไม่ติด ให้พิมพ์ไปเลย) เสร็จแล้ว Enter แล้วพิมพ์รหัสผ่านซ้ำอีกครั้ง ระบบจะแจ้งว่า passwd: password update successfully หมายความว่าเรียบร้อยแล้ว (ถ้าไม่ได้ ให้เริ่มพิมพ์คำสั่งใหม่ตั้งแต่ต้น) จากนั้นพิมพ์คำสั่งว่า reboot เพื่อรีสตาร์ทเครื่องแล้วเข้าระบบด้วยรหัสผ่านใหม่ได้เลย
Picture 4.17
Picture 4.17
ผู้เขียน: ศิระ นกยูงทอง
การศึกษา: ปริญญาตรีคณะสถาปัตยกรรม สถาบันราชภัฏพระนคร
ปัจจุบัน:
พนักงานฝ่ายโอเพนซอร์ส SIPA
ผู้ก่อตั้ง ubuntuclub.com
CEO By Doing Co., Ltd.
License: GFDL
Ubuntu desktop guide : Basic Desktop
By Doing Co., Ltd. 4 | https://web.archive.org/web/20080828013052/http://wiki.ubuntuclub.com/wiki/Ubuntu_Desktop_Guide | CC-BY |
Ubuntu Desktop Guide | Ubuntu Desktop Guide นี้ ตัดมาจากหนังสือ[http://wiki.ubuntuclub.com/wiki/Image:Ubuntu-desktop-guide.pdf คู่มือการใช้ ubuntu] ให้มาอยู่ในรูปแบบวิกิเพื่อให้ง่ายต่อการปรับปรุง, เปลี่ยนแปลง , และแก้ไข ต่อไปในอนาคต
=คำนำ=
ทุกวันนี้คงปฏิเสธไม่ได้แล้วว่าระบบปฏิบัติการลินุกซ์นั้นเข้ามามีบทบาทในชีวิตของเรามากขึ้นทุกที ทั้งเว็บไซต์ต่างๆ ที่เราเข้าไปใช้งานที่นิยมใช้ Apache เป็นเว็บเซิร์ฟเวอร์กันเป็นส่วนใหญ่ หรือแม้แต่เว็บไซต์เสริชเอ็นจิ้นอันดับหนึ่งของโลกอย่าง Google ก็ยังใช้ Python ในการเขียนโปรแกรม ซึ่งเราคงต้องยกความดีให้แก่ Open Source, โครงการ GNU และนักพัฒนาทั้งหลายที่ร่วมสร้างสรรค์ซอฟต์แวร์ Open Source ให้พัฒนาขึ้นมาได้อย่างรวดเร็ว ถ้าเราจะลองมองย้อนกลับไปถึงช่วงที่ IBM เปิดมาตรฐานของเครื่องคอมพิวเตอร์ส่วนบุคคล ทำให้เกิดบริษัทมากมายเข้ามาผลิตเครื่องคอมพิวเตอร์ในแบบที่เราเรียกว่า IBM Compatible จนกระทั่งเกิดการแข่งขันสูงขึ้น ส่งผลให้คอมพิวเตอร์ส่วนบุคคลมีการพัฒนาไปอย่างรวดเร็ว มองกลับมาที่โมเดลของ Open Source ที่มีการเปิดเผยรหัสพัฒนาให้ทุกคนเข้าถึง และต่อยอดการพัฒนาต่อไปได้อย่างไม่มีข้อจำกัด ซึ่งก็มีความคล้ายคลึงกันกับกรณีของ IBM
เกี่ยวกับหนังสือเล่มนี้ ผมเขียนขึ้นมาอย่างไม่ละเอียดเหมือนกับหนังสือเล่มอื่นที่คุณได้เคยอ่าน ซึ่งผมเลือกเขียนและอธิบายเฉพาะส่วนที่สำคัญๆ และในส่วนที่เป็นรายละเอียดปลีกย่อย ผมเลือกที่จะละไว้ โดยผมเข้าใจว่ากลุ่มผู้ที่อ่านหนังสือเล่มนี้ จะเป็นผู้ที่ใช้ระบบปฏิบัติการ Windows มาในระดับหนึ่งแล้ว หมายความว่าไม่ได้เริ่มศึกษาคอมพิวเตอร์จากศูนย์ ฉะนั้นบางอย่างที่คุณผู้อ่านจะมีทักษะมาจากการใช้ Windows บ้างแล้ว ผมจึงขออนุญาตไม่อธิบาย
=เกริ่นนำ=
ก่อนที่เราจะไปลงเนื้อหาในส่วนต่างๆนั้น ในบทแรกผมจะเกริ่นนำ ในส่วนของเรื่องราวต่างๆที่เกี่ยวกับลินุกซ์และ Ubuntu กันก่อนนะครับ เพื่อให้ท่านผู้อ่านที่ยังไม่คุ้นเคยกับลินุกซ์หรือ Ubuntu ได้ทำความเข้าใจกันก่อน สำหรับท่านที่มีความรู้พื้นฐานดีอยู่แล้วจะข้ามไปบทต่อไปเลยก็ได้ครับ ไม่ว่ากัน
==พูดคุย==
ผมเชื่อว่าทุกท่านที่กำลังอ่านหนังสือเล่มนี้อยู่ น่าจะพอรู้จักลินุกซ์ดีอยู่แล้วในระดับหนึ่ง ใช่ครับ อย่างที่คุณรู้ดีอยู่แล้ว ว่าลินุกซ์เป็นระบบปฏิบัติการชั้นยอดตัวหนึ่งของโลก ไม่ว่าจะเป็นการใช้งานในด้านใดก็ตาม เพราะฉะนั้นไม่มีเหตุผลใดๆที่เราจะไม่ควรใช้ลินุกซ์ แม้ว่าในขณะนี้เราจะเห็นว่าลินุกซ์นั้น ยังไม่เป็นที่แพร่หลายในการใช้งานด้านเดสก์ทอปก็ตาม แต่ไม่นานความนิยมในการใช้งานลินุกซ์ในฝั่งเดสก์ทอปจะเพิ่มมากขึ้นอย่างแน่นอน เพราะผู้คนส่วนใหญ่เริ่มให้ความสนใจกับระบบปฏิบัติการตัวนี้กันอย่างต่อเนื่อง แม้แต่คุณผู้อ่านเองก็ตาม
==แนะนำ Ubuntu==
Ubuntu นั้นเป็นลินุกซ์ดิสโทรที่กำลังเป็นที่นิยมที่สุดในขณะนี้ คำว่าลินุกซ์ดิสโทร (Linux Distribution) หมายถึงลินุกซ์สำเร็จรูปที่มีการปรับแต่งเพื่อให้เหมาะแก่การใช้งานแล้วในระดับหนึ่ง ลินุกซ์ดิสโทรที่เป็นที่รู้จักกันดีก็คงจะหนีไม่พ้นลินุกซ์ตัวดังๆ เช่น Redhat, SUSE, Mandriva เป็นต้น เหล่านี้จัดว่าเป็นลินุกซ์ดิสโทรตัวหนึ่ง ส่วน Ubuntu นั้นจัดเป็นดิสโทรที่พัฒนาโดยอิงจาก Debian GNU/Linux เป็นฐานในการพัฒนา หรือจะเรียกว่าเป็นการต่อยอดก็ดูจะไม่ผิดนัก
สาเหตุที่ทำให้ Ubuntu เป็นที่นิยมอย่างรวดเร็วนั้นคงเป็นเพราะ Ubuntu คัดโปรแกรมที่ใช้สำหรับงานต่างๆมาให้เป็นอย่างดีแล้ว แทนที่จะเป็นเหมือนดิสโทรอื่นที่ยัดโปรแกรมประเภทเดียวกันมาหลายตัวเกินความจำเป็น ทำให้ผู้ใช้อาจเกิดความสับสนว่าควรจะใช้โปรแกรมไหนเพื่อทำงานนั้นๆดี ทำให้ Ubuntu นั้นมีแผ่นติดตั้งเพียงหนึ่งแผ่นเท่านั้น และยังแยกแผ่นสำหรับใช้งานในรูปแบบเดสก์ทอป กับแบบเซิร์ฟเวอร์ออกจากกันอีกด้วย เพื่อให้ง่ายแก่การดาวน์โหลดและป้องกันความสับสน
นอกจากที่ได้กล่าวมาแล้วนั้น อีกเหตุผลหนึ่งซึ่งทำให้ Ubuntu เป็นที่นิยมคือ บริษัท Canonical ผู้พัฒนา Ubuntu ได้ให้สัญญากับผู้ใช้ไว้ว่า Ubuntu จะเป็นลินุกซ์ที่เสรีตลอดไป ทำให้ผู้ใช้มั่นใจได้ว่าจะสามารถใช้งาน Ubuntu โดยปราศจากค่าใช้จ่ายได้ตลอดไป ซึ่งจะแตกต่างจาก Redhat หรือ Mandriva ในบางเวอร์ชั่นที่ต้องเสียเงินซื้อมาใช้เสียแล้ว
ความนิยมของ Ubuntu ไม่ได้หยุดอยู่แค่กับกลุ่มผู้ใช้ชาวต่างชาติเท่านั้น ปัจจุบันความนิยมและข้อดีต่างๆของ Ubuntu ได้ถูกบรรจุลงใน LinuxTLE 8 ของไทยเป็นที่เรียบร้อยแล้ว และด้วยความที่ NECTEC ยังไว้ใจในการนำ Ubuntu มาต่อยอดในการพัฒนาลินุกซ์ของไทย แล้วเหตุไฉนคุณจะไม่ไว้ใจใน Ubuntu
==จุดเด่น==
;ระบบอัพเดท:เนื่องจาก Ubuntu เป็นลินุกซ์สายพันธุ์ Debian จึงใช้ระบบ APT (Advanced Package Tool) ในการจัดการแพคเกจ ซึ่งระบบนี้มีข้อดีที่สามารถอัพเดทหรือติดตั้งแพคเกจเพิ่มเติมผ่านอินเทอร์เน็ตได้ตลอดเวลา แถมยังจัดการปรับแต่งค่าพื้นฐานให้โดยอัตโนมัติอีกด้วย
;การติดตั้งแบบกราฟิก:Ubuntu มีระบบการติดตั้งแบบ GUI (Graphic User Interface) ทำให้ง่ายมากๆในการที่จะติดตั้ง Ubuntu ซึ่งบอกได้เลยว่าง่ายกว่าการติดตั้ง Windows XP เสียอีก
;ทดลองก่อนติดตั้งจริง:คุณสามารถทดลองใช้งาน Ubuntu ก่อนได้ โดยที่ไม่ต้องติดตั้งลงในเครื่องคอมพิวเตอร์ของคุณ ซึ่งคุณสามารถแน่ใจได้เลยว่าข้อมูลในเครื่องคอมพิวเตอร์ของคุณจะปลอดภัย และเมื่อคุณทดลองจนพอใจและตัดสินใจที่จะใช้ เมื่อนั้นคุณค่อยติดตั้งลงในฮาร์ดดิสก์ก็ไม่เป็นปัญหาแต่อย่างใด
;หนึ่งแผ่นเท่านั้น:Ubuntu คัดสรรโปรแกรมที่ดีที่สุดมาให้คุณแล้ว ทำให้ไฟล์และโปรแกรมทั้งหมดสำหรับติดตั้งน้อยจนสามารถบรรจุลงได้ในหนึ่งแผ่นซีดีเท่านั้น และเพื่อป้องกันความสับสนแก่ผู้ใช้ที่จะเลือกใช้โปรแกรมดีๆสักตัวเพื่อทำงานอย่างใดอย่างหนึ่ง Ubuntu จึงไม่ใส่โปรแกรมที่ใช้สำหรับทำงานประเภทเดียวกันมาให้ซ้ำซ้อนกัน
;ทันสมัย:ด้วยการที่ Ubuntu ออกเวอร์ชั่นใหม่ทุกๆ 6 เดือน ทำให้คุณมั่นใจได้ว่า คุณจะได้ใช้โปรแกรมในเวอร์ชั่นที่ใหม่ล่าสุดตลอดเวลา รวมทั้งสามารถมั่นใจได้ในเรื่องของระบบรักษาความปลอดภัยที่อัพเดทกันแบบรายวัน
=ติดตั้ง=
ในบทนี้ก็ถึงเวลาที่เราจะมาลงภาคปฏิบัติกันแล้วครับ (พร้อมยังเอ่ย) โดยที่เราจะเริ่มกันตั้งแต่ยังไม่มีแผ่น Ubuntu ไปจนถึงการนำ Ubuntu ร้อนๆเสริฟลงเครื่องคอมพิวเตอร์ของคุณกันเลยครับ พร้อมแล้วก็ไปกันเลย
==ดาวน์โหลด==
เป็นเรื่องดีอย่างยิ่งที่ Ubuntu เป็นระบบปฏิบัติการเสรี ฉะนั้นเราจึงสามารถหามาใช้ได้อย่างไม่ต้องลำบากยากเข็นสักเท่าใดนักแถมยังไม่ต้องจ่ายเงินสักแดงเดียวอีกต่างหาก เพียงแค่คุณมีคอมพิวเตอร์ที่พร้อมจะเข้าถึงอินเทอร์เน็ตได้ก็เพียงพอแล้ว
สถานที่ดาวน์โหลดที่หลักนั้น ต้องเป็น ubuntulinux.org อย่างแน่นอนอยู่แล้ว สิ่งที่คุณต้องทำก็คือ เปิดโปรแกรมเว็บเบราเซอร์อย่าง IE หรือ Firefox ขึ้นมา แล้วเข้าไปที่ http://releases.ubuntulinux.org (หรือคุณอาจใช้บริการที่ ftp://mirror.in.th/ubuntu เพื่อความเร็วที่มากกว่า) ที่หน้านี้คุณจะเห็นเวอร์ชั่นต่างๆของ Ubuntu เรียงอยู่อย่างมากมาย (ตามภาพที่ 2.1) ให้คุณมองหาโฟลเดอร์ที่มีเลขเวอร์ชั่นสูงที่สุด เมื่อเจอแล้วให้คลิกเข้าไปเลยครับ
เมื่อคุณเข้ามาถึงข้างในของโฟลเดอร์ที่เก็บ Ubuntu เวอร์ชั่นล่าสุดแล้ว ในนี้จะมีไฟล์ดาวน์โหลดของ Ubuntuสำหรับ CPU หลากหลายประเภท แต่ถ้าเครื่องของคุณเป็นเครื่องคอมพิวเตอร์หรือ Laptop ที่ใช้ CPU จำพวก Intel หรือ AMD ที่นิยมใช้กันทั่วไปในปัจจุบัน คุณจะต้องดาวน์โหลดไฟล์สำหรับ CPU รุ่น i386 ครับ หรือที่เขียนว่า PC Intel x86 นั่นเอง ซึ่งไฟล์ที่มีให้ดาวน์โหลดสำหรับ CPU แต่ละประเภทนั้น จะมีด้วยกัน 3 รูปแบบด้วยกันคือ
*'''DesktopCD''': ไฟล์ในรูปแบบนี้ จะสร้างออกมาเป็นแผ่นที่สามารถใช้งานได้โดยไม่ต้องติดตั้ง หรือใช้สำหรับติดตั้งด้วยก็ได้ ซึ่งจะเป็นการติดตั้งผ่านอินเทอร์เฟสแบบ GUI ที่สามารถใช้เมาส์คลิกเพื่อติดตั้ง และกำหนดค่าต่างๆระหว่างติดตั้งได้
*'''AlternateCD''': ไฟล์นี้จะสร้างออกมาเป็นแผ่นที่ทำมาสำหรับติดตั้งโดยเฉพาะ และเป็นการติดตั้งผ่าน Text base UI (คล้ายการติดตั้ง Windows XP) แต่เมื่อติดตั้งเสร็จเรียบร้อยแล้ว จะได้เหมือนกับที่ติดตั้งผ่านแผ่น DesktopCD ทุกประการ
*'''Server''': เป็นไฟล์ที่ทางผู้พัฒนาได้คัดเลือกเฉพาะแพคเกจที่ทำงานด้านเซิร์ฟเวอร์ไว้ จึงไม่เหมาะสำหรับผู้ใช้ตามบ้านอย่างเราๆสักเท่าไรนัก
แผ่นที่เราจะใช้ในการติดตั้งตามคู่มือนี้ผมแนะนำให้ใช้เป็นแผ่น DesktopCD ครับ ให้คลิกที่ลิงก์ของไฟล์ (ตามภาพที่ 2.2) เพื่อทำการดาวน์โหลดได้เลย ซึ่งคุณควรจะใช้โปรแกรมช่วยดาวน์โหลดเพื่อป้องกันความผิดพลาดของไฟล์ คุณอาจใช้โปรแกรมที่เป็นฟรีแวร์ อย่างเช่น FlashGet หรือโปรแกรมช่วยดาวน์โหลดที่เป็น Open Source สำหรับ Windows อย่าง TrueDownloader ที่สามารถดาวน์โหลดมาใช้ได้ฟรีจาก http://sourceforge.net/projects/downloadplus
ในส่วนของการดาวน์โหลดไฟล์นี้ นอกจากที่คุณจะดาวน์โหลดจากเว็บไซต์ ubuntulinux.org แล้วนั้น คุณยังสามารถที่จะดาวน์โหลดที่ ftp://mirror.in.th/ubuntu ได้ด้วยเพื่อความรวดเร็วในการดาวน์โหลด เพราะเครื่องเซิร์ฟเวอร์นี้จะตั้งอยู่ในประเทศเรา ซึ่งจะส่งข้อมูลได้เร็วกว่า
แต่ถ้าคุณใช้เน็ต 56K และไม่มีโปรแกรมช่วยโหลด คุณก็สามารถขอแผ่นได้ที่http://shipit.ubuntu.com ครับ(ฟรี ไมเสียค่าส่ง)
==ตรวจสอบความสมบูรณ์ของไฟล์==
เนื่องจากไฟล์ที่ดาวน์โหลดมามีขนาดใหญ่มาก (เกือบ 700 MB) และใช้เวลาในการเดินทางอย่างยาวนานกว่าจะมาถึงเครื่องของเราจนครบ ข้อมูลอาจเกิดความเสียหายในระหว่างเดินทางได้ ฉะนั้นเราจึงควรที่จะตรวจสอบความสมบูรณ์ของไฟล์ที่เราได้ดาวน์โหลดมาเสียก่อน ก่อนที่จะสร้างเป็นแผ่น CD เพื่อจะได้ไม่ต้องเสียแผ่นไปเปล่าๆ หากว่าไฟล์ที่คุณดาวน์โหลดมานั้นเกิดความผิดพลาด
ในโลกของ Open Source นั้น จะมีระบบการตรวจสอบความถูกต้องของไฟล์ที่เรียกว่า MD5SUM เป็นการคำนวนค่าของตัวเลขชุดหนึ่งออกมาจากไฟล์ วิธีที่ใช้กันโดยทั่วไปนี้เป็นเรื่องที่ทำความเข้าใจได้ไม่ยาก คือ ฝั่งเซิร์ฟเวอร์ที่ปล่อยไฟล์ออกมาให้ดาวน์โหลด จะสร้างชุดตัวเลข MD5SUM ของไฟล์นั้นๆขึ้นมา ซึ่งจะมีค่าตัวเลขจำนวนหนึ่งเป็นค่าเฉพาะ และเมื่อเราดาวน์โหลดมาแล้ว เราก็ทำการเช็คค่า MD5SUM ของไฟล์ที่เราดาวน์โหลดมาด้วยเช่นเดียวกัน ถ้าค่าตัวเลขออกมาตรงกัน ก็แสดงว่าไฟล์นั้นสมบูรณ์ นำไปใช้งานได้เลย
===MD5SUM ฝั่งเซิร์ฟเวอร์===
ในขั้นแรกให้เราตรวจสอบชุดตัวเลขนี้ในฝั่งเซิร์ฟเวอร์ก่อน ที่เว็บเบราเซอร์ให้คุณไปหน้าเดียวกับที่ดาวน์โหลดไฟล์ DesktopCD ให้เลื่อนลงมาล่างๆหน้าเว็บสักหน่อย คุณจะเห็นลิงก์ของไฟล์ที่เขียนว่า MD5SUM (ตามภาพที่ 2.3) ให้คุณคลิกเข้าไปเพื่อดูชุดตัวเลขที่ว่านั้น
ภายในไฟล์ MD5SUM นี้จะมีชุดตัวเลขอยู่หลายบรรทัด บรรทัดที่คุณต้องดูคือ บรรทัดที่เขียนว่า desktop-i386.iso ให้คุณจดค่าตัวเลขนั้นไว้ เพื่อใช้ตรวจสอบกับ MD5SUM ของไฟล์ในเครื่องเรา ที่จะทำการตรวจสอบในขั้นต่อไป
===MD5SUM ไฟล์ในเครื่องของเรา===
การตรวจสอบค่า MD5SUM ให้กับไฟล์ในเครื่องเรานั้น จะต้องใช้โปรแกรมเพื่อช่วยในการคำนวนค่าของชุดตัวเลขออกมา ซึ่งผมแนะนำโปรแกรมชื่อ MD5summer ซึ่งเป็นซอฟต์แวร์ Open Source เช่นเดียวกับ Ubuntu ครับ
เปิดเข้าไปที่ http://www.md5summer.org/download.html แล้วทำการดาวน์โหลดโปรแกรม MD5summer มา ไฟล์ที่ได้จะอยู่ในรูปแบบของไฟล์ zip ให้คุณทำการคลายไฟล์ออกมา เมื่อคุณคลายไฟล์ zip ออกมาแล้วคุณจะเห็นไฟล์ที่ชื่อว่า md5summer.exe ให้คุณดับเบิลคลิกที่ไฟล์นั้น โปรแกรมจะถูกเรียกขึ้นมาทำงานโดยไม่ต้องติดตั้ง
เมื่อคุณเรียกโปรแกรมขึ้นมาแล้ว จะพบหน้าต่างของโปรแกรม MD5summer ที่แสดงพาธต่างๆบนเครื่องของคุณ ให้คุณคลิกเลือกที่โฟลเดอร์ที่ได้เก็บไฟล์ของ Ubuntu ที่ได้ทำการดาวน์โหลดมา จากนั้นคลิกที่ปุ่ม Create sums
ถัดมาโปรแกรมจะทำงานต่อไปในขั้นตอนที่สอง ในขั้นตอนนี้หน้าต่างจะถูกแบ่งออกเป็นสองส่วน หน้าจอทางด้านซ้านนั้น จะแสดงไฟล์ต่างๆที่เก็บอยู่ในโฟลเดอร์ที่คุณคลิกเลือกในขั้นตอนที่ผ่านมา ให้คุณคลิกเลือกไฟล์ Ubuntu ที่ได้ทำการดาวน์โหลดมา จากนั้นกดที่ Add ชื่อไฟล์ Ubuntu จะแสดงขึ้นมาที่หน้าจอทางด้านขวา เรียบร้อยแล้วให้คลิกที่ OK
ในขั้นตอนนี้จะเป็นขั้นตอนสุดท้ายคือการแสดงค่าที่คำนวนออกมา เมื่อโปรแกรมคำนวนจนเสร็จจะแสดงหน้าต่างขึ้นมาหน้าต่างหนึ่ง เพื่อให้คุณเซฟค่าที่ได้ทำการคำนวนลงในไฟล์ ให้คุณคลิก Cancel เมื่อ Cancel แล้ว คุณจะเห็นหน้าต่างโปรแกรมที่แสดงค่าตัวเลขยาวๆที่ได้คำนวนเสร็จเป็นที่เรียบร้อยแล้ว ให้คุณเปรียบเทียบค่านี้กับชุดตัวเลขที่ได้จดมา ถ้าหากตรงกันก็ไปอ่านตอนต่อไปได้เลย แต่ถ้าไม่ผ่านคุณก็จำเป็นที่จะต้องดาวน์โหลดใหม่อีกครั้ง
==สร้างแผ่นซีดี==
เมื่อได้ไฟล์และได้ทำการตรวจสอบความสมบูรณ์ของไฟล์เป็นที่เรียบร้อยแล้ว ก็ถึงเวลาที่จะสร้างแผ่น Ubuntu ขึ้นมาจากไฟล์ .iso ที่เราได้ทำการดาวน์โหลดมาเสียที สำหรับวิธีในการสร้างแผ่นซีดีนั้นผมจะเขียนโดยอิงวิธีของโปรแกรม Nero Burning ROM เป็นหลักนะครับ เพราะคิดว่าน่าจะเป็นโปรแกรมที่มีคนใช้มากที่สุด
ให้เปิดโปรแกรม Nero ขึ้นมาเลยครับ ที่เมนูหลักของโปรแกรม เลือกที่ Recorder แล้วคลิกเลือกที่ Burn Image... ครับ จากนั้นให้ทำการเลือกไฟล์ .iso ที่เราได้ดาวน์โหลดมา เลือกความเร็วในการเขียนแผ่นที่เหมาะสม ไม่ต้องเร็วจนเกินไปนัก อาจเป็น 16x ก็ได้ จากนั้นให้สั่ง Burn ก็เป็นอันเสร็จในขั้นตอนนี้
==ติดตั้ง==
เมื่อได้แผ่นซีดีมาเป็นที่เรียบร้อยแล้วเราก็พร้อมที่จะไปทดลองใช้งาน และติดตั้งกันแล้วครับ สิ่งแรกที่คุณต้องทำคือ ต้องตั้งค่าไบออสให้บูตจากซีดีเสียก่อน ซึ่งวิธีการตั้งค่าของแต่ละเครื่องนั้นขอให้คุณดูคู่มือของ Mainboard จะดีกว่า เมื่อตั้งค่าแล้วให้ใส่แผ่นซีดี พร้อมเปิดเครื่องขึ้นมาใหม่ เครื่องจะบูตซีดีขึ้นมา คุณจะเห็นหน้าจอที่เป็นเมนูของ Ubuntu ให้คุณเลือกที่เมนู Start or install Ubuntu ได้ทันที จากนั้นรอสักครู่ คุณจะเข้ามาสู่หน้าจอการทำงานของ Ubuntu ทันที
ที่หน้าจอการทำงานนี้คุณจะเห็นไอคอน Install อยู่ทางด้านซ้ายมือ ให้คุณดับเบิลคลิกเพื่อติดตั้งได้เลย (หากคุณต้องการทดลองใช้งานก่อน ให้ข้ามไปอ่านในบทถัดไปก่อนได้ครับ) หน้าจอช่วยเหลือการติดตั้งจะเปิดขึ้นมา ซึ่งคุณสามารถติดตั้งไปตามขั้นตอนที่โปรแกรมแนะนำได้เลย ผมจะคอยแนะนำคุณเป็นขั้นตอนๆไปอย่างหยาบๆ แต่จะเน้นในส่วนที่สำคัญเท่านั้น
ขั้นตอนที่ 1-3 จะเป็นการเลือกภาษาปริยายสำหรับระบบและการเลือกโซนเวลา ซึ่งค่านี้จะส่งผลกับทั้งระบบ คือถ้าเลือกเป็นภาษาไทย หน้าจอการแสดงผลก็จะแสดงข้อความภาษาไทยไปด้วย ซึ่งในการติดตั้งนี้ผมจะเลือกเป็น English ไว้ก่อน เพราะอย่างไรแล้ว ผมจะแนะนำการติดตั้งเพื่อใช้งานภาษาไทยในตอนท้ายอยู่ดีครับ ส่วนเขตเวลาก็ให้เลือกตามแผนที่ได้เลย ซึ่งของประเทศไทยนั้น จะมีให้เลือกแค่ Bangkok เท่านั้นครับ
ในส่วนขั้นตอนที่ 4 จะเป็นการเลือกผังแป้นพิมพ์ เมื่อคุณเลือกที่ Thailand แล้ว จะมีชื่อผังแป้นพิมพ์ปรากฏขึ้นมาให้คุณเลือก ซึ่งจะมี Thailand, Thailand-Pattachote และ Thailand-TIS-820.2538 ให้คุณเลือกที่ Thailand ตัวเลือกแรกครับ เมื่อคุณคลิกเลือกแล้ว ที่ด้านล่างของหน้าต่างนี้จะมีให้คุณทดสอบพิมพ์ครับ โดยคุณสามารถสลับผังแป้นพิมพ์ระหว่างภาษาไทยกับภาษาอังกฤษได้ โดยกด Alt+Shift ครับ
ขั้นตอนที่ 5 นี้จะเป็นการตั้งชื่อผู้ใช้และชื่อของเครื่อง ในช่องแรกจะเป็นชื่อของคุณ กรอกได้ตามสะดวก ส่วนช่องถัดมาจะเป็นชื่อที่ใช้ในการเข้าระบบ ให้คุณจำให้ดีครับ เพราะถ้าลืมจะไม่สามารถเข้าระบบได้ ถัดมาจะเห็นเป็นช่องคู่กันสองช่อง สองช่องนี้คือรหัสผ่านครับ ทั้งสองช่องกรอกให้ตรงกันนะครับ ไม่งั้นจะติดตั้งไม่ผ่าน ส่วนช่องสุดท้ายคือชื่อเครื่องครับ
ชื่อผู้ใช้ที่คุณสร้างนี้ให้จำรหัสไว้ให้ดีครับ เพราะนอกจากจำเป็นที่จะต้องใช้ในการเข้าระบบแล้ว ผู้ใช้คนนี้ยังมีสิทธิ์ในฐานะผู้ดูแลของเครื่องนี้ด้วยครับ ที่จะติดตั้งโปรแกรมเพิ่มเติม เพิ่มผู้ใช้คนอื่นหรือทำอย่างอื่นที่เกี่ยวข้องกับการเปลี่ยนแปลงระบบครับ
ขั้นตอนที่ 6 ในขั้นตอนนี้สำคัญและต้องใช้ความระมัดระวังเป็นอย่างมากครับ ถ้าคุณต้องการติดตั้งใช้งาน Ubuntu เพียงอย่างเดียว หรือเครื่องคุณเป็นเครื่องเปล่าที่เพิ่งซื้อมาใหม่ ให้คุณเลือกที่ "Erase entire disk" ได้เลย ซึ่งระบบจะลบข้อมูลในฮาร์ดดิสก์ทั้งหมด และทำการติดตั้ง Ubuntu ลงไป
แต่ถ้าหากเครื่องของคุณติดตั้งระบบปฏิบัติการอื่นอยู่ เช่น Windows และคุณยังต้องการที่จะใช้มันอยู่ คุณสามารถติดตั้ง Ubuntu คู่ไปกับวินโดวส์ได้ โดยเลือกที่ "Resize ..." ตามภาพได้เลยครับ ซึ่งระบบจะปรับขนาดพาร์ทิชั่นที่ใช้อยู่เดิมให้เล็กลง และติดตั้ง Ubuntu ลงไปในพื้นที่ว่างหลังจากที่พาร์ทิชั่นเดิมถูกปรับขนาดลงไปแล้ว
เมื่อเสร็จสิ้นขั้นตอนทั้งหมดแล้วโปรแกรมติดตั้ง จะจัดการติดตั้ง Ubuntu ลงในฮาร์ดดิสก์ของคุณ ซึ่งจะต้องใช้เวลาสักครู่ ขึ้นอยู่กับความเร็วของเครื่องคุณ จนเมื่อระบบได้ทำการติดตั้งเรียบร้อยแล้ว จะมีกล่องข้อความขึ้นมาถามว่า "Continue using the live CD"หรือ"Restart now" ซึ่งผมแนะนำใหคุณรีสตาร์ทเครื่องก่อน แล้วค่อยกลับมาใช้งานต่อจะดีกว่าครับ
=การใช้งานเบื้องต้น=
ในบทนี้จะแนะนำเรื่องของการใช้งานในเบื้องต้น ตั้งแต่แนะนำให้คุณรู้จักกับส่วนต่างๆบนหน้าจอ การปรับแต่งค่าพื้นฐานเล็กๆน้อยๆ ไปจนถึงแนะนำโปรแกรมสำหรับใช้งานทั่วไป ที่ได้รวบรวมมาแล้วพร้อมกันในแผ่น Ubuntu
==รู้จักกับระบบไฟล์และโฟลเดอร์==
หลังจากที่เราติดตั้งกันเป็นที่เรียบร้อยแล้ว ก่อนที่เราจะเปิดเครื่องเพื่อทำความรู้จักกับส่วนต่างๆของ Ubuntu นั้น สิ่งแรกที่คุณควรรู้และทำความเข้าใจไว้ก่อนคือเรื่องของระบบไฟล์และโฟลเดอร์ของ Ubuntu ครับ
ระบบไฟล์ของ Ubuntu หรือแม้แต่ลินุกซ์ตัวอื่นๆก็ตาม จะไม่เหมือนกับ Windows ที่เราจะเห็นว่ามี Drive C, Drive D นะครับ ซึ่งเป็นเรื่องที่ต้องทำความเข้าใจไว้ก่อน เดี๋ยวจะงง
เมื่อถึงตอนที่คุณเริ่มใช้งานแล้ว คุณจะเห็นพาธต่างๆของ Ubuntu ซึ่งผมจะอธิบายคร่าวๆไว้ เฉพาะพาธที่สำคัญๆ ว่าพาธไหนคืออะไรครับ
*/ : root path พาธที่เป็นต้นราก
**bin : เก็บไบนารี่คำสั่งต่างๆของระบบไว้
**boot : เก็บไฟล์ที่จำเป็นสำหรับการบูตระบบ
**etc : เก็บการตั้งค่าที่จำเป็นสำหรับโปรแกรมต่างๆ
**home : คล้าย My Document
***user1 : My Document ของผู้ใช้ชื่อ user1
****Desktop : Desktop ของ user1
****.Trash : ถังขยะของ user1
***gumara : My Document ของ gumara
****Desktop : Desktop ของ gumara
****.Trash : ถังขยะของ gumara
**media : อุปกรณ์ต่างๆเรียกใช้ได้ที่นี่ เช่น CD, Floppy
***cdrom : Drive CD
***fda0 : Floppy
**sbin : เก็บคำสั่งสำคัญของระบบ เช่น ปิดเครื่อง, รีสตาร์ท
**tmp : ที่เก็บไฟล์ชั่วคราว จะถูกลบเมื่อรีสตาร์ท
**usr : ที่เก็บไฟล์ต่างๆที่ผู้ใช้จะใช้
**bin : เก็บคำสั่งต่างๆ
***firefox : คำสั่งเรียก Firefox
***openoffice : คำสั่งเรียก OpenOffice.org
ทั้งหมดนี้เป็นพาธสำคัญๆที่น่าจะรู้จักไว้ แต่ในความเป็นจริงแล้ว เมื่อใช้งานคุณคงไม่ได้ยุ่งกับพาธเหล่านี้โดยตรงสักเท่าไหร่ ซึ่งจริงๆแล้วผมแค่อยากให้คุณรู้จักไว้เท่านั้น เผื่อว่าเปิดเข้ามาเจอว่ามันไม่เหมือนที่เคยใช้บน Windows จะได้ไม่ต้องตกใจ
==เปิดเครื่อง==
หลังจากที่ได้ทำการติดตั้ง Ubuntu เป็นที่เรียบร้อยแล้ว เมื่อคุณทำการเปิดเครื่องคอมพิวเตอร์ คุณจะได้พบกับเมนูสำหรับเลือกระบบปฏิบัติการ (กรณีติดตั้งคู่กับ Windows) เพื่อที่คุณจะสามารถเลือกได้ว่าจะเข้าใช้งาน Ubuntu หรือ Windows ตามภาพจะเห็นว่าในเมนูจะมีให้เลือกอยู่หลายตัว ซึ่งจะมีอยู่ 3 ตัวเลือกที่สำคัญคือ
*Ubuntu : สำหรับเข้าใช้งาน Ubuntu
*Recovery mode : เพื่อแก้ไขปัญหาสำหรับ Ubuntu
*Windows : สำหรับเข้าใช้งาน Windows
เมื่อผ่านจากเมนูสำหรับเลือกระบบปฏิบัติการมาแล้ว คุณจะพบกับหน้าต่างล๊อกอิน เพื่อเข้าระบบ ที่หน้าจอนี้คุณจะเห็นช่องสำหรับกรอกชื่อผู้ใช้ ที่ด้านบนเขียนกำกับไว้ว่า Username: ให้คุณกรอกชื่อที่ตั้งไว้ในตอนที่ติดตั้ง จากนั้น Enter หนึ่งครั้ง คำว่า Username: ที่เขียนกำกับไว้จะเปลี่ยนเป็น Password: ให้คุณกรอกรหัสผ่านลงไป เสร็จแล้วระบบจะพาคุณเข้าสู่หน้าจอการใช้งาน Ubuntu
==หน้าจอการทำงาน==
หน้าจอของ Ubuntu แม้จะมีความเรียบง่ายมากแล้ว แต่สำหรับผู้ที่เพิ่งเริ่มใช้ ก็ไม่น่าแปลกใจอะไรหากจะหยิบจับอะไรไม่ค่อยถูกเพราะความไม่เคยชิน เพราะฉะนั้นผมจะพาไปทำความรู้จักกับส่วนต่างๆของหน้าจอกันสักเล็กน้อยครับ
;อธิบายตามภาพนะครับ
#เมนูต่างๆสำหรับเรียกโปรแกรม ซึ่งเดี๋ยวจะอธิบายอีกทีครับ
#Application Launcher สำหรับเรียกโปรแกรม
#ตัวแจ้งเตือนการอัพเดทระบบ
#System tray สำหรับแสดงสถานะของระบบ และโปรแกรมที่ทำการซ่อนตัวอยู่
#ปุ่มปิดเครื่องและออกจากระบบ
#ปุ่มแสดงหน้าจอ สำหรับซ่อนและแสดงหน้าต่างทั้งหมด
#Window List จะแสดงโปรแกรมต่างๆที่กำลังทำงานอยู่
#Workspaces Switcher สำหรับสลับหน้าจอการทำงานเสมือน
#Trash ถังขยะเก็บไฟล์ที่ถูกลบแล้ว
==เมนูหลักของ Ubuntu==
จากภาพ ในลำดับที่หนึ่งจะเห็นเมนูอยู่ทั้งหมด 3 เมนูคือ Applications, Places และ System ซึ่งเมนูแต่ละอย่างจะมีหน้าที่ต่างกันดังนี้ครับ
===เมนู Applications===
โปรแกรมต่างๆจะถูกจัดหมวดหมู่เก็บไว้เป็นอย่างดีในเมนูนี้ ซึ่งคุณสามารถเรียกใช้โปรแกรมต่างๆที่มีได้ ผ่านทางเมนู Applications นี้เลยครับ
===เมนู Places===
ที่เมนูนี้จะเก็บ Shortcut สำหรับเข้าถึงโฟลเดอร์สำคัญต่างๆไว้ เช่น Home (คล้าย My Document), Computer (คล้าย My Computer) หรืออื่นๆ ที่เห็นตามในเมนูครับ
===เมนู System===
ในเมนู System จะมีอยู่สองส่วนสำคัญคือการตั้งค่า Preferences หมายถึงการตั้งค่าส่วนตัว และ Administration หมายถึงการปรับแต่งค่าของระบบ
ทั้งหมดนี้คือส่วนประกอบหลักๆบนหน้าจอของ Ubuntu เมื่อเราติดตั้งเสร็จ และด้วยความยืดหยุ่นของ Linux ทำให้เราสามารถปรับแต่งได้ตามใจชอบครับ
==ปรับแต่งการแสดงผล==
ในตอนนี้เราจะมาปรับแต่ง Ubuntu ของเราในส่วนของการแสดงผลกันครับ เช่นเดียวกับระบบปฏิบัติการอื่นๆ Ubuntu สามารถปรับแต่งการแสดงผลได้ในระดับหนึ่ง ซึ่งก็เพียงพอต่อความต้องการแล้วครับ
===ความละเอียดหน้าจอ===
เมื่อคุณติดตั้ง Ubuntu เสร็จ Ubuntu จะเลือกความละเอียดมากที่สุด ที่จอภาพและการ์ดแสดงผลรองรับ ซึ่งบางครั้งมันก็ละเอียดมากซะจนทำให้ไอคอนและตัวหนังสือต่างๆนั้นดูเล็กไปซะหมด ซึ่งเราสามารถปรับความละเอียดของหน้าจอให้ตรงตามความต้องการได้ครับ การปรับค่าความละเอียดหน้าจอนั้นสามารถทำได้ โดยไปที่ เมนู System > Preferences > Screen Resolution หน้าต่างการตั้งค่าความละเอียดหน้าจอจะถูกเรียกขึ้นมา ซึ่งคุณสามารถเลือกความละเอียดได้ตามต้องการครับ เสร็จแล้วกดที่ Apply เพื่อใช้งานค่าที่เลือกได้ทันทีครับ
===เปลี่ยนภาพพื้นหลัง===
ก่อนที่จะเริ่มเปลี่ยนภาพพื้นหลังกันได้นั้น (หรือที่เราเรียกกันอย่างติดปากว่า wallpaper) แน่นอนว่าก่อนอื่นคุณต้องมีภาพพื้นหลังที่จะใช้ก่อน คุณสามารถใช้ภาพในฟอร์แมทใดมาทำเป็นภาพพื้นหลังก็ได้ แค่พยายามหาให้ภาพนั้นมีความละเอียดไม่น้อยไปกว่า Resolution ของหน้าจอเป็นดี
เมื่อได้ภาพที่ต้องการมาแล้วให้คุณไปที่เมนู System > Preferences > Desktop Background หรือคลิกขวาบนที่ว่างบนหน้าจอแล้วเลือก Change Desktop Background ก็ได้ครับ ระบบจะทำการเรียกโปรแกรม Desktop Background Preferences ขึ้นมา
ภายในหน้าจอของนี้ คุณจะเห็นภาพหน้าจอที่มีให้อยู่แล้วจำนวนหนึ่ง ซึ่งคุณสามารถเลือกที่ภาพและใช้งานได้ทันที แต่ถ้าคุณไม่อยากใช้ภาพพื้นหลัง คุณสามารถเซตให้เป็นสีเดียวก็ได้ โดยที่ช่อง Wallpaper ให้เลือก No Wallpaper และเลือกสีที่ต้องการที่ช่อง Desktop Colors
ส่วนการนำภาพที่ต้องการมาทำ Wallpaper นั้นให้คลิกที่ปุ่ม Add Wallpaper แล้วเลือกไฟล์ภาพที่คุณต้องการ เพียงเท่านี้ภาพที่คุณต้องการก็จะปรากฏขึ้นมาเป็น Wallpaper แล้วครับ
===เปลี่ยนและตั้งชุดตกแต่ง===
หน้าตาของ Ubuntu ที่คุณเห็นอยู่นี้ เป็นการจัดวางองค์ประกอบลักษณะหนึ่ง คือการจัดวาง Panel ในรูปแบบที่เห็น และในส่วนของหน้าต่าง ไอคอน หรือปุ่มกดต่างๆที่เราเห็นว่ามีหน้าตาเช่นนี้นั้น เกิดขึ้นจากการจัดการของชุดตกแต่ง หรือที่เรียกว่า Theme ซึ่ง Theme มาตรฐานที่ Ubuntu ใช้อยู่นี้ จะมีชื่อว่า Human ที่มีสีออกไปในโทนน้ำตาล Theme นี้ Ubuntu ใช้มาตั้งแต่ Ubuntu เวอร์ชั่นแรก (4.10)
แต่นอกจากชุดตกแต่งในแบบที่เราเห็นอยู่ในตอนนี้ Ubuntu สามารถเปลี่ยน Theme ได้ตามต้องการครับ วิธีเปลี่ยน Theme นั้นให้ไปที่ เมนู System > Preference > Theme หน้าต่าง Theme Preference จะถูกเรียกขึ้นมา ซึ่งจะมี Theme แบบต่างๆให้คุณเลือกใช้ได้อยู่จำนวนหนึ่ง คุณสามารถเลือกใช้ได้ตามสะดวกเลยครับ หรือถ้ายังไม่ตรงกับความต้องการจะหามาติดตั้งเพิ่มเติมก็ไม่เป็นปัญหาแต่อย่างใดครับ เพียงแต่ว่า Theme ที่เราจะนำมาติดตั้งนั้น จะประกอบไปด้วยองค์ประกอบต่างๆ จึงจะเห็นออกมาเป็นหน้าตาในรูปแบบนี้ครับ
====องค์ประกอบของชุดตกแต่ง====
ก่อนที่คุณจะติดตั้ง Theme ได้ คุณต้องเข้าใจองค์ประกอบของมันก่อนครับ ว่าใน Theme หนึ่งชุดที่เราเลือกขึ้นมาใช้นั้นประกอบด้วยอะไรบ้าง ให้คุณลองคลิกที่ Theme สักชุดนึง แล้วคลิกที่ปุ่ม Customize... ครับ คุณจะเห็นว่าในหนึ่ง Theme จะประกอบด้วย
*Controls: ส่วนประกอบต่างๆ ของหน้าต่างโปรแกรม เช่น Scroll bar, ปุ่มกดต่างๆ
*Colors: เป็นการปรับสีส่วนต่างๆของ Theme จะปรับได้ต่อเมื่อ Theme นั้นๆ รองรับ
*Window Border: ส่วนขอบของหน้าต่าง
*Icons: ไอคอนที่เราเห็นทั่วไปบนหน้าจอ ในเมนู
องค์ประกอบต่างๆนี้ คุณสามารถหยิบเอาส่วนที่ต้องการ เช่น Window Border ของอีก Theme มาประกอบกับ Icons ของอีก Theme เพื่อใช้เป็น Theme ใหม่ได้ครับ
ตามภาพผมปรับแต่งให้คล้ายกับหน้าจอการทำงานของ Windows เพื่อให้คนที่เพิ่งหันมาลองใช้ ที่แต่เดิมใช้ Windows อยู่จะคุ้นเคยได้ง่ายกว่า ซึ่งคุณผู้อ่านคงจะพอเห็นเป็นแนวทางแล้วว่าหน้าตาของ Ubuntu นั้น สามารถปรับแต่งได้และยืดหยุ่นพอสมควร อย่างไรแล้วก็ทดลองปรับแต่งกันให้ตรงตามที่ชอบใจนะครับ
===เพิ่มและปรับแต่ง Panel===
จากที่ได้แนะนำให้รู้จัก Panel ไปแล้วในส่วนของ “หน้าจอการทำงาน” Panel นี้เราสามารถปรับได้ครับ ไม่ว่าจะเป็น ตำแหน่งของ Panel หรือส่วนต่างๆที่อยู่ใน Panel
====เพิ่ม/ลบ/ย้าย Panel====
ตัว Panel เองเราสามารถย้ายตำแหน่งได้ด้วยการคลิกค้างที่พื้นที่ว่างบน Panel จากนั้นลากไปไว้ที่มุมใดของหน้าจอก็ได้ เมื่ออยู่ในตำแหน่งที่ต้องการแล้วให้ทำการปล่อยเมาส์ Panel จะถูกวางลงในตำแหน่งที่เลือก
ส่วนการเพิ่มและลบนั้น ให้คุณคลิกขวาที่พื้นที่ว่างของ Panel คุณจะพบเมนูสำหรับจัดการ Panel โดยปุ่ม New Panel จะเป็นการสร้าง Panel ใหม่ ส่วน Delete This Panel หมายถึงลบ Panel ที่เลือกทิ้งไป นอกจากนี้คุณยังตั้งค่ารายละเอียดของ Panel ได้โดยการเลือกที่ Properties จะปรากฏหน้าต่าง Panel Properties ขึ้นมา ให้คุณทดลองตั้งค่าได้ตามชอบใจครับ
====Object Panel====
พวกไอคอนเรียกโปรแกรม, ปุ่มปิดเครื่อง, ถังขยะและอื่นๆที่อยู่บน Panel จะเรียกรวมๆว่า Object Panel ครับ พวกนี้เราสามารถเพิ่ม, ลบ หรือย้ายได้ตามต้องการ
หากโปรแกรมที่คุณต้องการเพิ่มลงในไอคอนมีอยู่ใน เมนู Applications แล้ว คุณสามารถคลิกค้างที่ปุ่มเรียกโปรแกรมในเมนูนั้นๆแล้วนำมาวางใน Panel ได้ทันที ส่วนการย้าย, ลบ หรือล๊อกติดกับ Panel สามารถทำได้โดยการคลิกขวาที่ไอคอนนั้นๆ แล้วเลือกทำตามที่ต้องการครับ
===เปลี่ยนฟอนต์ที่ใช้แสดงผล===
แบบอักษร หรือที่เรียกว่าฟอนต์ที่ใช้ในการแสดงผล ในส่วนต่างๆของ Ubuntu เราสามารถเปลี่ยนเป็นรูปแบบอักษรแบบอื่นได้ตามใจชอบ วิธีการเปลี่ยนแบบอักษรนี้ให้ไปที่ เมนู System > Preferences > Font หน้าต่างการตั้งค่า Font Preferences จะเปิดขึ้นมา ซึ่งคุณสามารถเลือกแบบอักษรให้กับส่วนประกอบต่างๆของหน้าจอได้ ในขั้นตอนนี้ให้คุณเลือกและทดสอบการตั้งค่าต่างๆด้วยตนเองเลยครับ
ในส่วนของ Font Rendering นั้น เป็นรูปแบบวิธีในการแสดงผลของแบบอักษรบนหน้าจอ วิธีการเลือกที่ง่ายและดีที่สุดนั้นคือ ให้เลือกแบบที่คุณมองแล้วสบายตาเป็นใช้ได้ครับ
ถ้าหากคุณใช้หน้าจอเป็นภาษาไทย (จะแนะนำการตั้งค่าหน้าจอภาษาไทยใน Unit 4) คุณต้องเลือกแบบอักษรที่เป็นภาษาไทยด้วยเช่นเดียวกัน ซึ่งแบบอักษรภาษาไทยที่มีให้ใช้ใน Ubuntu จะมีแบบอักษรต่างๆดังนี้ครับ
#Norasi
#Garuda
#Loma
#Purisa
#Freeserif
#TLWG mono
==แนะนำโปรแกรมพื้นฐาน==
เมื่อคุณทำการติดตั้ง Ubuntu เป็นที่เรียบร้อยแล้ว จะมีโปรแกรมพื้นฐานมาให้พร้อมใช้ในทันที ซึ่งไม่จำเป็นต้องติดตั้งเพิ่มแต่อย่างใด สำหรับในตอนนี้ ผมจะแนะนำโปรแกรมพื้นฐานแต่ละตัวให้รู้จักกันครับ เพื่อจะได้เลือกใช้งานได้อย่างถูกต้อง
===File Manager===
โปรแกรมจัดการไฟล์ใน Ubuntu จะมีชื่อเรียกว่า Nautilus ครับ ทุกครั้งที่คุณเปิดโฟลเดอร์บ้าน หรือดับเบิลคลิกที่โฟลเดอร์ใดๆก็ตาม Nautilus จะถูกเรียกขึ้นมาทำงาน โปรแกรม Nautilus นี้มีหน้าตาไม่แตกต่างจาก File Manager ของ Windows มากนัก การเรียนรู้จึงไม่ยาก
====ส่วนต่างๆใน Nautilus====
#เมนูหลัก
#แถบเครื่องมือ
#ตำแหน่ง
#ย่อ/ขยาย และมุมมอง
#เมนูข้าง
#ไฟล์และโฟลเดอร์
#แถบสถานะ
====เทคนิคในการใช้งาน====
การแสดงแฟ้มซ่อนให้คุณกด Ctrl+H โปรแกรมจะแสดงไฟล์และแฟ้มที่ถูกซ่อนขึ้นมา ซึ่งส่วนใหญ่จะเป็นไฟล์ที่ใช้ในการบันทึกการตั้งค่าส่วนตัว การสร้างแฟ้มซ่อนนั้นเพียงแค่เปลี่ยนชื่อไฟล์หรือแฟ้มนั้นๆ แล้วใส่ “จุด” นำหน้า เช่น โฟลเดอร์ชื่อ hidden เปลี่ยนชื่อเป็น .hidden ไฟล์หรือแฟ้มนั้นๆ จะถูกซ่อนในทันที
ในส่วนของตำแหน่งในหมายเลข 3 ถ้าคุณรู้ตำแหน่งที่แน่นอนที่ต้องการไป เช่น /media/cdrom คุณสามารถพิมพ์ตำแหน่งลงไปได้เลย โดยการกด Ctrl+L แถบที่ใช้บอกตำแหน่งด้วยปุ่มจะเปลี่ยนเป็นแถบยาวๆคล้ายของ Web Browser เพื่อให้คุณพิมพ์ตำแหน่งที่ต้องการได้เลย
เมนูด้านข้างคุณสามารถเปลี่ยนจากสถานที่สำคัญ เป็นข้อมูลของแฟ้มหรือมุมมองแบบรากไม้ก็ได้ ด้วยการคลิกที่ข้อความที่เขียนว่า Places แล้วเลือกตัวเลือกที่ต้องการ
===Web Browser===
โปรแกรม Web Browser หรือที่เรียกกันติดปากว่าโปรแกรมท่องอินเทอร์เน็ตนั้น จะเป็นโปรแกรม Firefox ซึ่งวิธีการใช้งานนั้นเหมือนกับ Firefox ที่เป็นเวอร์ชั่นของ Windows อยู่แล้ว วิธีเรียกใช้โปรแกรม Firefox นี้ สามารถเรียกได้จาก เมนู Applications > Internet > Firefox Web Browser
====ตั้งค่าภาษาไทย====
การตั้งค่าภาษาไทยสำหรับ Firefox เพื่อใช้เว็บไซต์ภาษาไทยนั้น เราจะต้องทำการตั้งค่าเพื่อใช้งานสำหรับการเข้ารหัสสองแบบคือ UTF-8 และ TIS-620
วิธีการตั้งค่าให้คุณคลิกที่ Edit > Preferences หน้าต่างการตั้งค่าจะถูกเปิดขึ้นมา ให้คุณเลือกที่ Content (ที่มีไอคอน ลูกโลก) โปรแกรมจะแสดงส่วนปรับตั้งค่าสำหรับการแสดงผลของเว็บไซต์ขึ้นมา ดูที่กรอบ Fonts & Colors ที่ช่อง Default Font ผมแนะนำให้เลือก Loma ซึ่งเป็นฟอนต์ที่สวยมากๆตัวหนึ่ง จากนั้นท้ายช่อง Default Font ให้คลิกที่ Advanced...
หน้าต่างสำหรับตั้งค่าฟอนต์จะเปิดขึ้นมา ที่ช่องบนสุดให้คลิกเลือกเป็น Thai ก่อน เพื่อปรับแต่งค่าสำหรับเว็บไซต์ที่เข้ารหัสแบบ TIS-620 ที่ช่อง Serif และ Sans-serif ให้เลือกฟอนต์เป็น Loma เสร็จแล้ว ที่ช่อง Fonts for ที่เราได้เลือกเป็น Thai เมื่อสักครู่ ให้เปลี่ยนเป็น Western เพื่อตั้งค่าการแสดงผลสำหรับเว็บที่เข้ารหัสแบบ UTF-8 ที่ช่อง Serif และ Sans-serif ให้เลือกเป็น Loma เช่นเดิม เสร็จแล้วที่กรอบ Character Encoding ด้านล่าง ให้เลือกเป็น Thai (TIS-620) เพื่อให้หน้าเว็บที่ไม่ได้กำหนดรหัสภาษาใช้การเข้ารหัสแบบ TIS-620 โดยอัตโนมัติ เพียงเท่านี้ก็เป็นอันเสร็จสิ้นการตั้งค่าภาษาของ FireFox ครับ
===Movie Player===
โปรแกรมดูหนังใน Ubuntu จะมีชื่อว่า Totem ครับ ใช้สำหรับเล่นไฟล์ภาพยนต์ต่างๆ รวมถึง CD และ DVD ด้วย ตัวโปรแกรมสามารถเรียกได้ทาง เมนู Applications > Sound & Video > Movie Player โดยในเบื้องต้นหลังจากที่ติดตั้ง Ubuntu เสร็จแล้ว โปรแกรมจะไม่สามารถเล่นไฟล์บางประเภทได้ เนื่องจากการเข้ารหัสของไฟล์บางประเภทนั้นติดสิทธิบัตร ฉะนั้น Ubuntu จึงไม่ได้รวมตัวถอดรหัสมาให้จึงไม่สามารถชมภาพยนตร์ได้ทันที จำเป็นต้องติดตั้งแพคเกจบางอย่างเพิ่ม ซึ่งผมจะแนะนำไว้ใน Unit 4 ครับ
===Music Player===
โปรแกรมสำหรับฟังเพลงใน Ubuntu นั้น มีชื่อว่า Rhythmbox ครับ สามารถเรียกใช้งานได้ผ่าน เมนู Applications > Sound & Video > Rhythmbox Music Player และเช่นเดียวกับโปรแกรม Movie Player ที่โปรแกรมจะยังไม่สามารถเล่นไฟล์ได้ในบางประเภท เนื่องจากปัญหาเดียวกันคือเรื่องของ สิทธิบัตร ส่วนวิธีแก้ไขนั้นผมจะแนะนำไว้ใน Unit 4 ครับ
===Image Editor===
โปรแกรมสำหรับตัดต่อและตกแต่งภาพนั้น Ubuntu เลือกเอาโปรแกรม GIMP เข้ามารวมไว้เป็นโปรแกรมหลักที่ใช้สำหรับตกแต่งภาพครับ ซึ่งมีความสามารถไม่แพ้โปรแกรมตกแต่งภาพชั้นนำในท้องตลาดเลย ทั้งการทำงานแบบเลเยอร์ ฟิลเตอร์ต่างๆที่มีให้เลือกใช้ แถมยังรองรับไฟล์หลากหลายรูปแบบที่เป็นที่นิยม ไม่เว้นแม้แต่ไฟล์ .psd ของโปรแกรม Photoshop ก็ตาม การเรียกโปรแกรมนั้นให้ไปที่ เมนู Applications > Graphics > GIMP Image Editor ครับ
===Image Viewer===
โปรแกรมดูภาพใน Ubuntu จะแบ่งออกเป็นสองโปรแกรมด้วยกันคือ eog (Eye Of Gnome ตามภาพที่ 3.19) โปรแกรมขนาดเล็กสำหรับดูภาพ และการปรับแต่งระดับพื้นฐาน เช่น หมุนภาพ ปรับขนาด และอีกโปรแกรมคือโปรแกรมดูรูปภาพที่มีความสามาถขึ้นมาอีกระดับคือ gThumb (ภาพที่ 3.20) โปรแกรม gThumb มีความสามารถมากกว่า eog คือ สามารถจัด Catalogs ให้รูปภาพได้ ปรับความมืด สว่าง และค่าต่างๆเกี่ยวกับสีได้ ตัดภาพให้เหลือเฉพาะส่วนที่ต้องการได้ แปลงภาพไปเป็นไฟล์ภาพสกุลอื่นได้
การเรียกใช้งาน eog สามารถเรียกได้โดยการดับเบิ้ลคลิกที่ภาพที่ต้องการดูได้เลย โปรแกรม eog จะถูกเรียกขึ้นมาทำงานพร้อมกับแสดงภาพที่ต้องการขึ้นมา ส่วนการเรียกโปรแกรม gThumb นั้นเรียกได้จาก เมนู Applications > Graphics > gThumb Image Viewer
===Office Suite===
โปรแกรมด้านสำนักงาน (การพิมพ์เอกสาร, ตารางคำนวน ฯลฯ) ใน Ubuntu จะมีโปรแกรมที่ชื่อ OpenOffice.org ให้ใช้ ซึ่งในชุดของ OpenOffice.org จะรวมโปรแกรมสำหรับทำงานต่างๆไว้ภายใน ดังต่อไปนี้
*Writer : พิมพ์เอกสาร
*Calc : ตารางคำนวน
*Impress : การนำเสนอ
*Base : ฐานข้อมูล
*Draw : วาดกราฟ, ไดอะแกรมอย่างง่าย
การเรียกใช้โปรแกรม OpenOffice.org ให้คุณไปที่ เมนู Applications > Office คุณจะเห็นโปรแกรมคำสั่งเพื่อเรียกโปรแกรม OpenOffice.org ด้วยกันสี่คำสั่งดังนี้
*OpenOffice.org Database
*OpenOffice.org Presentation
*OpenOffice.org Spreadsheet
*OpenOffice.org Word Processor
จากคำสั่งเรียกโปรแกรมทั้งสี่ คุณสามารถเรียก OpenOffice.org ขึ้นมาทำงานนั้นๆได้ทันที ส่วนการเรียกใช้ OpenOffice.org Draw ซึ่งไม่มีให้เรียกผ่านเมนูนั้น คุณต้องเปิด OpenOffice.org ตัวใดตัวหนึ่งขึ้นมาก่อน แล้วคลิกที่ File > New > Drawing
====การตั้งค่าเพื่อใช้งานภาษาไทย====
เพื่อการใช้งานภาษาไทยที่สมบูรณ์แบบ คุณต้องไปเปิดใช้งานในส่วนของ ภาษาประเภท CTL เสียก่อน ที่โปรแกรม OpenOffice.org คลิกที่ Tools > Options... หน้าต่าง Options จะเปิดขึ้นมาเพื่อให้คุณตั้งค่าต่างๆ ในการตั้งค่าภาษานั้นให้คุณคลิกเลือกที่ Language Settings > Languages ให้คุณตั้งค่าตามนี้
*Locale setting : Thai
*Default currency : THB ฿ Thai
*CTL : Thai
เพียงเท่านี้การใช้งานภาษาไทยในงานเอกสารของคุณก็จะสมบูรณ์ยิ่งขึ้นแล้วครับ
===Chat MSN===
หลายครั้งที่ผมชวนให้คนหันมาใช้ Ubuntu สิ่งหนึ่งที่คนส่วนใหญ่กังวลคือจะไม่ได้แชทกับเพื่อนผ่านทาง MSN Messenger แต่ที่จริงแล้วใน Ubuntu มีโปรแกรมสำหรับแชทที่ชื่อ Gaim ซึ่งรองรับการแชทในแทบจะทุกเครื่อข่ายที่เป็นที่นิยม ตั้งแต่ MSN, Yahoo, Gmail, ICQ, IRC, AOL etc. และยังสามารถที่จะออนไล์หลายเครือข่ายพร้อมกันได้อีกด้วย
====ตั้งค่าแชท MSN====
แม้จะมีข้อจำกัดอยู่บ้าง เช่น ตั้งชื่อได้ด้วยความยาวที่จำกัด ใช้เอฟเฟกต์ต่างๆไม่ได้ (เช่น สั่นหน้าต่าง) เป็นต้น แต่ในการใช้งานพื้นฐาน เช่น พูดคุย หรือส่งไฟล์ให้กันนั้นสามารถทำได้เป็นอย่างดี
*เปิดโปรแกรม Gaim ขึ้นมา โดยคลิกที่ เมนู Applications > Internet > Gaim Internet Messenger
*จะมีหน้าต่างของโปรแกรม Gaim ปรากฏขึ้นมาสองหน้าต่างคือ Buddy List และ Accounts
*ที่หน้าต่าง Accounts ให้คลิกที่ Add จะเป็นการสร้างบัญชีผู้ใช้สำหรับออนไลน์
*โปรแกรมเพิ่มบัญชีผู้ใช้จะถูกเรียกขึ้นมา ให้ป้อนค่าตามนี้
**Protocal : MSN
**Screen Name : ใส่อีเมล์ของคุณ
**Password : รหัสผ่านของคุณ (รอกรอกตอน Login ก็ได้)
**ในส่วนของ User Options จะสามารถใส่ภาพได้ ซึ่งจะใส่หรือไม่ก็ได้
*เสร็จแล้วคลิกที่ Save เพื่อทำการบันทึก
*คุณจะกลับมาที่หน้า Account อีกครั้งให้คลิกเลือกที่ช่อง Enabled เพื่อออนไลน์
*รอระบบทำการเชื่อมต่อ แล้วก็แชทได้เลย
===Email Client===
โปรแกรม Email Client ใน Ubuntu จะมี Evolution มาให้ใช้ครับ สามารถได้ใช้ได้ผ่านทาง เมนู Applications > Internet > Evolution Mail ครับ Evolution เป็นโปรแกรมที่มีความสามารถมากกว่าที่จะใช้สำหรับรับส่งอีเมล์เพียงอย่างเดียว มันสามารถเป็นทั้งสมุดจดชื่อที่อยู่ ตารางปฏิทิน จดบันทึกต่างๆ ฯลฯ
วิธีการตั้งค่าเพื่อใช้งานอีเมล์นั้น จะคล้ายกับโปรแกรม Email Client ตัวอื่นๆ ซึ่งค่าที่จะตั้งนั้น คุณต้องสอบถามกับผู้ดูแลระบบของหน่วยงานของคุณเอง
====ตั้งค่าเพื่อใช้งานภาษาไทย====
เช่นเดียวกับโปรแกรม Firefox ที่เราต้องตั้งค่าภาษาไทยเสียก่อนจึงจะอ่านภาษาไทยออก แต่สำหรับ Evolution จะตั้งค่าการเข้ารหัสภาษาแบบ UTF-8 มาอย่างดีแล้ว ที่เราต้องทำคือปรับค่าเพิ่มเติมสำหรับอีเมล์ที่ถูกส่งมาโดยเข้ารหัสแบบ TIS-620 ครับ
*ไปที่ Edit > Preferences
*เลือก Mail Preferences
*ช่อง Default character encoding เลือก Thai (TIS-620)
*ช่อง Message Fonts เลือกฟอนต์ตามต้องการ
===Dictionary===
Ubuntu มีโปรแกรมแปลภาษา (หรือที่เรียกกันว่าดิกชั่นนารี่) มาให้แล้ว เพียงแต่เราต้องทำการปรับแต่งเพิ่มเติมอีกเล็กน้อย เพื่อให้โปรแกรมสามารถแปลคำศัพท์ภาษาไทยได้ การเรียกใช้โปรแกรมนั้น ให้ไปที่ เมนู Applications > Accessories > Dictionary
====ตั้งค่าเพื่อแปลภาษาไทย====
*คลิกที่ Edit > Preferences
*คลิกเลือกที่ Longdo Thai-English Dictionaries
เมื่อทำการตั้งค่าตามขั้นตอนข้างตนแล้ว โปรแกรมจะทำการแปลข้อความที่ป้อนจาก ไทย > อังกฤษ และ อังกฤษ > ไทย โดยอัตโนมัติ
==การติดตั้งโปรแกรมเพิ่มเติม==
นอกเหนือจากโปรแกรมที่ได้แนะนำมาแล้วนั้น เรายังสามารถติดตั้งโปรแกรมเพิ่มเติมลงไปได้อีกด้วย ซึ่งการติดตั้งโปรแกรมเพิ่มเติมบน Ubuntu นั้นง่ายมากๆ เพราะคุณไม่ต้องไปหาดาวน์โหลดโปรแกรมมาจากเว็บไซต์ไหนเลย เพียงแค่คุณเปิดโปรแกรม Add/Remove Applications เลือกโปรแกรมที่ต้องการ แล้วกดติดตั้ง เพียงเท่านี้โปรแกรมที่คุณต้องการก็จะถูกนำมาเสริฟไว้ตรงหน้าของคุณทันที
===เพิ่ม Repository===
การติดตั้งโปรแกรมเพิ่มเติมผ่านระบบจัดการแพคเกจของ Ubuntu นั้น จะขึ้นอยู่กับแหล่งจัดเก็บซอฟต์แวร์หรือ Repository ที่จะเป็นตัวบอกว่ามีโปรแกรมอะไรบ้างที่เราจะติดตั้งได้ผ่านระบบจัดการแพคเกจ ซึ่ง Repository ในค่าตั้งต้นที่ Ubuntu ตั้งไว้จะตั้งไปที่ Repository ที่มีเฉพาะซอฟต์แวร์โอเพนซอร์สและส่วนของไดร์เวอร์ฮาร์ดแวร์ต่างๆเท่านั้น แต่เราก็สามารถเพิ่ม Repository ให้ชี้ไปที่ที่มีซอฟต์แวร์ที่ไม่ใช่โอเพนซอร์สได้ด้วย ซึ่ง Repository ที่เราจะเพิ่มเข้ามานี้ แม้จะมีซอฟต์แวร์ที่ไม่ใช่โอเพนซอร์สรวมอยู่ แต่ก็เป็นโปรแกรมที่ถูกต้องตามลิขสิทธิ์ทั้งสิ้นครับ ซึ่งการทำแบบนี้จะทำให้มีซอฟต์แวร์ให้เราเลือกได้หลายหลายมากยิ่งขึ้นครับ
วิธีการทำงานของระบบจัดการแพคเกจคือ ระบบจะดูว่า Repository ที่เราตั้งไว้ชี้ไปที่ไหน ซึ่งระบบก็จะวิ่งไปอัพเดทรายชื่อซอฟต์แวร์ที่นั่น (บนเซิร์ฟเวอร์ตามที่ระบุไว้ใน Repository) และเราจะสามารถติดตั้งซอฟต์แวร์ได้ตามรายชื่อซอฟต์แวร์ที่ได้ทำการอัพเดท
การเพิ่มเติม Repository นั้น ให้ไปที่ เมนู System > Administration > Software Sources จะปรากฏหน้าต่าง Software Sources ขึ้นมา ให้มองที่ส่วนของ Internet จะถูกเลือกอยู่ที่บางช่องเท่านั้น ซึ่งแต่ละช่องนั้นมีความหมายดังนี้
*Community Maintained .... หมายถึง Repository ที่เก็บซอฟต์แวร์ที่เป็นโอเพนซอร์สไว้ ดูแลโดยนักพัฒนาอิสระ
*Canonical supported .... หมายถึง Repository ที่เก็บซอฟต์แวร์โอเพนซอร์สไว้ ซึ่งดูแลโดยทีมพัฒนา Ubuntu เอง
*Software restricted .... หมายถึง Repository ที่เก็บซอฟต์แวร์ที่อาจติดเรื่องของสิทธิบัตรหรือลิขสิทธิ์ไว้ด้วย
*Proprietary .... หมายถึง Repository ที่เก็บไดรว์เวอร์ต่างๆจากผู้ผลิตฮาร์ดแวร์เอาไว้
*Source code หมายถึง ระบบจะทำการรวมซอร์สโค้ดจาก Repository ต่างๆ ไว้ในรายชื่อซอฟต์แวร์ด้วยเมื่อคุณทำการอัพเดท
*Download from หมายถึง เซิร์ฟเวอร์ที่จะทำการอัพเดทซอฟต์แวร์ลิสต์ ซึ่งถ้าเป็น Thailand ก็แน่นอนว่าจะเร็วกว่าต่างประเทศครับ
เมื่อคุณเข้าใจแล้วว่ารายการไหนคืออะไรคุณก็สามารถเลือกได้ตามสะดวกเลยครับ แต่ถ้าคุณไม่เข้าใจเลยสักนิดและยังงงๆอยู่ก็ไม่เป็นไรครับ ลบไปจากหัวได้เลย และคลิกเลือกให้หมดไปเลยยกเว้ย Source code ครับ เพราะเราคงไม่ได้ใช้ Source code ของโปรแกรมในการใช้งานทั่วๆไปอยู่แล้ว
===ทดลองติดตั้งโปรแกรม===
หลังจากปรับแต่ง Repository แล้ว เรามาลองติดตั้งโปรแกรมกันครับ ให้คุณคลิกที่ เมนู Applications > Add/Remove... โปรแกรม Add/Remove Applications จะถูกเรียกขึ้นมาทันที ที่หน้าต่างของโปรแกรมนี้จะถูกแบ่งออกเป็นสามส่วนด้วยกัน
*ช่องซ้ายจะเป็นการแบ่งกลุ่มของโปรแกรมซึ่งจะช่วยให้คุณเลือกโปรแกรมที่ต้องการได้ง่ายขึ้น
*ช่องขวาบน เป็นรายชื่อของโปรแกรม ซึ่งจะแสดงขึ้นมาตามกลุ่มที่คุณได้เลือกไว้จากช่องทางซ้าย
*ช่องขวาล่าง รายละเอียดของโปรแกรมที่คุณคลิกเลือกจากช่องทางขวาบน
โปรแกรมที่ผมแนะนำเพื่อทดสอบการติดตั้งจะมีชื่อว่า Frozen-Bubble ให้คุณคลิกเลือกที่กลุ่มโปรแกรม Games ครับ จากนั้นให้เลื่อนหาโปรแกรม Frozen-Bubble เมื่อเจอแล้วคลิกที่เช็คบ๊อกด้านหน้า จากนั้นให้กดที่ OK โปรแกรมจะให้ข้อมูลเกี่ยวกับการติดตั้งโปรแกรมในครั้งนี้ว่า มีโปรแกรมใดถูกติดตั้งบ้าง เมื่อมั่นใจแล้วให้กด Apply โปรแกรมจะถามพาสเวิร์ดของผู้ดูแล ซึ่งถ้าคุณมีสิทธิ์ในฐานะของผู้ดูแลเครื่องนั้น (Administrator) ให้ใส่พาสเวิร์ดของคุณลงไปครับ เสร็จแล้วให้รอสักครู่ ระบบจะทำการดาวน์โหลดโปรแกรมจาก Repositories ผ่านทางอินเทอร์เน็ต ให้คุณรอจนเสร็จ
เมื่อเสร็จแล้วคุณสามารถใช้งานโปรแกรมที่ติดตั้งได้ทันที ในกรณีนี้คือเกม Frozen-Bubble คุณสามารถเรียกเกมนี้ขึ้นมาเล่นได้โดยไปที่ เมนู Games > Frozen-Bubble
สำหรับการติดตั้งโปรแกรมอื่นๆนั้น จะใช้วิธีเดียวกันกับในขั้นตอนที่ผ่านมานี้ครับ ซึ่งโปรแกรมดีๆและเกมสนุกๆนั้นมีอยู่เยอะ ลองเลือกดูและติดตั้งใช้งานกันนะครับ
=Tips=
ในบทนี้จะแนะนำเทคนิคในการใช้งานเล็กๆน้อยๆ ที่จะเป็นประโยชน์ในการใช้งานจริง เพื่อให้คุณใช้งานได้อย่างเต็มประสิทธิภาพยิ่งขึ้นครับ
==กู้คืนไฟล์ที่ถูกลบ==
เช่นเดียวกับ Windows ที่ไฟล์หรือโฟลเดอร์ ที่ถูกลบจะถูกนำไปไว้ในถังขยะก่อน ซึ่งถังขยะนี้จะอยู่ในโฟลเดอร์บ้านของคุณนั่นเอง เพียงแต่ว่าอยู่ในรูปแบบของแฟ้มซ่อน ซึ่งในหน้าต่างโปรแกรม File Manager (Nautilus) ให้คุณกด Ctrl+h คุณจะพบโฟลเดอร์ที่ชื่อว่า .Trash เมื่อคุณเปิดขึ้นมาดู คุณจะพบไฟล์ต่างๆที่ลบไปแล้ว ซึ่งสามารถย้ายออกไปไว้ในตำแหน่งที่คุณต้องการ และใช้งานไฟล์นั้นได้ทันที
อีกทางหนึ่งที่น่าจะสะดวกกว่าที่จะเข้าถึงถังขยะได้คือไอคอนที่ Panel ด้านขวาล่าง เมื่อคุณคลิก จะเปิดโปรแกรม File Manager พร้อมแสดงไฟล์ที่ถูกลบไปแล้วเช่นเดียวกัน
==พิมพ์ภาษาไทย==
ในขั้นตอนการติดตั้งที่ผมแนะนำให้เลือกคีย์บอร์ดภาษาไทย คุณจะสามารถพิมพ์ภาษาไทยได้ในทันที แต่ผมจะแนะนำเรื่องของการติดตั้งการพิมพ์ภาษาอื่นๆเพิ่มเติมอีกครั้ง เผื่อว่าคุณอาจต้องการใช้ภาษาอื่นนอกจากภาษาไทยในการทำงานด้วย
วิธีเพิ่มภาษาสำหรับการพิมพ์นั้น ให้ไปที่ เมนู System > Preferences > Keyboard หน้าต่าง Keyboard Preferences จะถูกเรียกขึ้นมา ให้คุณคลิกเลือกที่แถบ Layouts คุณจะเห็น Layouts ของภาษาไทยและอังกฤษอยู่ ให้คลิกที่ Add จะมีหน้าต่าง Choose a Layouts ขึ้นมา คุณสามารถเลือกผังคีย์บอร์ดที่ต้องการใช้ได้ทันที
ส่วนของปุ่มสลับภาษานั้นสามารถเปลี่ยนได้ที่หน้าต่าง Keyboard Preferences เช่นเดียวกัน โดยให้คลิกเลือกที่แถบ Layout Options ส่วนของคีย์ลัดสำหรับสลับภาษาจะอยู่ที่ Group Shift/Lock behavior ซึ่งสามารถเปลี่ยนได้ตามที่ระบบมีให้เลือกเท่านั้น
===ปุ่มสลับภาษา===
บน Windows เราจะเห็นปุ่มสลับภาษาอยู่ที่ Panel ด้านล่างติดกับ System tray ซึ่ง Ubuntu นั้นสามารถเพิ่มปุ่มในลักษณะเดียวกันนี้ลงใน Panel ได้เช่นเดียวกัน ปุ่มสลับภาษานี้นอกจากจะใช้ในการคลิกสลับภาษาแล้ว ยังสามารถใช้บอกภาษาปัจจุบันที่เรากำลังใช้อยู่ได้อีกด้วย การเพิ่มปุ่มสลับภาษานี้ให้คุณคลิกขวาบน Panel ในตำแหน่งที่ต้องการวางปุ่มสลับภาษา จากนั้นเลือก Add to Panel หน้าต่าง Add to Panel จะปรากฏขึ้นมา ให้คุณมองหาไอคอนรูปธงที่มีข้อความกำกับว่า Keyboard Indicator จากนั้นกด Add หนึ่งครั้ง และคลิกที่ Close เพื่อปิดหน้าต่างได้เลย เพียงเท่านี้ปุ่มสลับภาษาก็จะอยู่บน Panel ตามที่เราต้องการแล้วครับ
==ปรับแต่งให้แสดงผลภาษาไทย==
ในขณะที่เราใช้งาน Ubuntu อยู่นี้ เราสามารถพิมพ์ภาษาไทยได้แล้วก็จริง แต่ว่าในส่วนภาษาของระบบ เช่น เมนู หรือที่โปรแกรมต่างๆนั้น สามารถแสดงข้อความเป็นภาษาไทยได้ด้วย ซึ่งจะมีประโยชน์มากสำหรับผู้ใช้คอมพิวเตอร์ที่ไม่มีความรู้ด้านภาษาอังกฤษ หรืออาจจะไม่ถนัดในการใช้ภาษาอังกฤษ
การปรับแต่งระบบให้แสดงผลภาษาไทยนั้นให้ไปที่ เมนู System > Administration > Language Support ระบบจะถามรหัสผ่านของผู้ดูแลก่อน เพราะการเปลี่ยนแปลงนี้จะมีผลต่อระบบทั้งหมด เมื่อป้อนรหัสผ่านแล้ว หน้าต่าง Language Support จะเปิดขึ้นมา ให้คุณเลือกภาษาไทยแล้วคลิก OK ได้เลย แต่หากคุณต้องการใช้ภาษาไทยเป็น ภาษาปริยายของระบบ ให้คุณคลิก Apply ก่อนหนึ่งครั้ง เพื่อให้ระบบดาวน์โหลดแพคเกจภาษาไทยลงมาก่อน เสร็จแล้วที่ช่อง Default Language จึงจะมีภาษาไทยให้เลือกครับ
เมื่อคุณได้ติดตั้งให้ใช้งานภาษาไทยแล้ว คุณจะยังไม่เห็นผลในทันที คุณจะต้องออกจากระบบโดยการล๊อกเอาท์เสียก่อน หรือจะรีสตาร์ทก็ตามแต่ จนคุณมาถึงหน้าล๊อกอินเพื่อเข้าระบบอีกครั้ง ก่อนที่คุณจะล๊อกอินให้สังเกตุที่มุมซ้ายล่าง จะเห็นข้อความที่เขียนว่า Options ให้คลิกลงไปแล้วเลือกที่ Select Language จากนั้นให้เลือกเป็น Thai หรือจะเลือกเป็น System Default ก็ได้ หากคุณตั้งให้ภาษาไทยเป็น Default Language ไว้ในขั้นตอนที่ผ่านมา
==จับภาพหน้าจอ==
ใน Ubuntu จะมีโปรแกรมจับภาพหน้าจออยู่ โดยสามารถเรียกโปรแกรมได้จาก เมนู Applications > Accessories > Take Screenshot โปรแ กรมจับภาพหน้าจอจะถูกเรียกขึ้นมา จะมี 2 ตัวเลือกให้คุณเลือกคือ Grab the whole desktop หมายถึงการจับภาพหน้าจอทั้งหน้าจอ และอีกตัวเลือกหนึ่งคือ Grab the current window หมายถึง จับภาพเฉพาะหน้าต่างที่กำลังทำงานอยู่เท่านั้น ส่วนของ Grab after a delay of ... หมายถึงจะให้จับภาพหลังจากที่คลิก Take Screenshot แล้วกี่วินาที ซึ่งคุณสามารถจัดสภาพแวดล้อมก่อนที่จะจับภาพได้ด้วยตัวเลือกการหน่วงเวลานี้
นอกจากการเรียกตามวิธีด้านบนแล้ว คุณยังสามารถจับภาพหน้าจอด้วยคีย์ลัดได้ด้วย ด้วยการกดปุ่ม Print Screen บนคีย์บอร์ด โปรแกรมจะจับภาพพร้อมแสดงหน้าต่างโปรแกรมขึ้นมาเช่นเดียวกับวิธีในข้างต้น หรือคุณอาจจับภาพเฉพาะหน้าต่างที่ทำงานอยู่ได้ด้วย โดยการคลิกเลือกหน้าต่างที่ต้องการก่อน จากนั้นกดปุ่ม Alt+ Print Screen โปรแกรมจะจับภาพเฉพาะหน้าต่างที่คุณเลือก
==ดูหนังฟังเพลง==
ดังที่ผมได้กล่าวไว้ใน Unit 3 เรื่องของโปรแกรม Movie Player และ Music Player ว่าไฟล์บางประเภทนั้นจะไม่สามารถเล่นได้ในทันทีจะต้องติดตั้งแพคเกจเพิ่มเติมเสียก่อน วิธีนั้นอาจยุ่งยากนิดหน่อย แต่แลกกับผลลัพภ์ที่ได้แล้วคุ้มค่าแน่นอนครับ
;ทำการ "เพิ่ม Repository" (ตาม Unit 3) เสียก่อน
*เปิดโปรแกรม Add/Remove Applications ขึ้นมา
*ที่หน้าจอทางซ้ายให้เลือกหมวดหมู่เป็น Sound & Video
*ให้ติดตั้ง Plugin 3 ชุด คือ
**Gstreamer extra plugins
**Gstreamer ffmpeg video plugin
**Xine extra plugins
ด้วยปลั๊กอินสามชุดที่คุณได้ทำการติดตั้ง เพียงเท่านี้คุณก็พร้อมที่จะเล่นไฟล์ภาพยนต์และเพลงในรูปแบบต่างๆได้แล้วครับ
==เขียนซีดี==
การเขียนซีดีใน Ubuntu นั้น เราสามารถเขียนได้ผ่านโปรแกรม File Manager ได้ทันที โดยถ้าหากคุณใส่แผ่นซีดีเปล่าเข้ามาในเครื่อง จะมีหน้าต่างขึ้นมาถามคุณเองว่าคุณต้องการที่จะ สร้างซีดีเพลงจากไฟล์เพลงดิจิตอล (Make Audio CD) เช่น จากไฟล์ WAV หรือสร้างซีดีข้อมูล (Make Data CD) หรือไม่ทำอะไรเลย (Ignore)
หากคุณเลือกที่เขียนซีดีเพลง จะมีโปรแกรม Serpentine เข้ามาทำหน้าที่ในส่วนนี้ ซึ่งวิธีใช้งานนั้นผมขอข้ามไป เพราะไม่ยากอยู่แล้วสำหรับคุณที่คิดจะใช้ Ubuntu ส่วนโปรแกรม Serpentine นั้น คุณสามารถเรียกโปรแกรมนี้ขึ้นมาทำงานเองก็ได้ โดยเรียกที่ เมนู Applications > Sound & Video > Serpentine Audio CD Creator ซึ่งก็ได้ผลลัพภ์เดียวกัน
ย้อนกลับมาที่อีกทางเลือกหนึ่งเมื่อคุณใส่แผ่นซีดีเปล่าเข้าไปคือ สร้างแผ่นซีดีข้อมูล (Make Data CD) หากคุณเลือกตัวเลือกนี้ โปรแกรม File Manager จะถูกเรียกขึ้นมา พร้อมกับไปที่ส่วนของการสร้างซีดีข้อมูล ในหน้าต่างนี้คุณสามารถลากไฟล์ใส่ลงไปได้เลย จนเมื่อคุณพร้อมแล้วให้กดที่ปุ่ม Write to Disc เพื่อเขียนข้อมูลลงแผ่นซีดี ส่วนการเรียกโปรแกรม File Manager ขึ้นมาเขียนซีดีโดยไม่ผ่านหน้าต่างตัวเลือกนั้น คุณสามารถเรียกได้ที่ เมนู Places > CD/DVD Creator
ส่วนการเขียนซีดีจากไฟล์ .iso เช่นเดียวกับตอนที่เราสร้างแผ่น Ubuntu จากโปรแกรม nero บนวินโดวส์ก็สามารถทำได้เช่นเดียวกันครับ โดยหลังจากที่คุณใส่แผ่นซีดีเปล่าลงในเครื่องแล้ว ให้คุณคลิกขวาที่ไฟล์ .iso ที่คุณต้องการ จากนั้นเลือก Write to Disc... เพียงเท่านี้ครับ
กรณีที่แผ่นของคุณเป็นแผ่น RW (ลบและเขียนใหม่ได้) ไม่ต้องมองหาโปรแกรมลบข้อมูลใน CD แต่อย่างใดครับ ให้คุณลบไฟล์ในซีดีเหมือนกับว่าเป็นไฟล์ที่อยู่ในฮาร์ดดิสก์ได้เลย และเมื่อถึงตอนที่จะเขียนข้อมูลลงแผ่น โปรแกรมจะลบข้อมูลเดิมที่อยู่ในซีดีก่อนที่จะเขียนข้อมูลลงไปใหม่ให้เองโดยอัตโนมัติ
==ล๊อกอินเข้าระบบแบบอัตโนมัติ==
ทุกครั้งที่คุณเปิดเครื่อง คุณจำเป็นที่จะต้องป้อนชื่อผู้ใช้และรหัสผ่านก่อนทุกครั้งจึงจะมีสิทธิ์เข้าใช้งานเครื่อง เพื่อยืนยันว่าคุณเป็นใครและมีสิทธิ์ทำอะไรได้บ้าง ซึ่งมันจะมีประโยชน์มากถ้าคุณใช้เครื่องคอมพิวเตอร์ด้วยกันหลายคน แต่ถ้าคุณเป็นเจ้าของเครื่อง และใช้อยู่คนเดียว คงน่ารำคาญไม่น้อยที่ต้องมาคอยกรอกชื่อและรหัสผ่านเพื่อบอกว่าคุณเป็นใครในเมื่อคุณใช้เครื่องอยู่แค่คนเดียว
คุณสามารถตั้งค่าให้เข้าระบบอัตโนมัติได้ โดยเลือกชื่อผู้ใช้ของคุณเป็นชื่อผู้ใช้หลักเพื่อทำการเข้าระบบอัตโนมัติได้ ให้คุณไปที่ เมนู System > Administration > Login Window หน้าต่างนี้จะเป็นส่วนของการตั้งค่าการเข้าระบบ เช่น เปลี่ยนหน้าตาต้อนรับตอนเข้าระบบ ที่คุณต้องทำคือ ไปที่ Tab Security ให้คุณเช็คบ็อกซ์ที่ช่อง Enable Automatic Login จากนั้นให้เลือกชื่อผู้ใช้ของคุณเสร็จแล้วทำการ Close เพื่อปิดหน้าต่างการตั้งค่าได้ทันที
==Startup Programs (เปิดโปรแกรมอัตโนมัติ)==
เช่นเดียวกับบน Windows ที่เราสามารถสั่งให้โปรแกรมใดสักโปรแกรม ทำงานเองโดยอัตโนมัติเมื่อระบบพร้อมทำงานหลังจากที่เราเข้าสู่ระบบ วิธีนั้นทำได้ไม่ยากเพียงแต่คุณต้องรู้ชื่อคำสั่งที่ใช้เรียกโปรแกรมนั้นด้วยเท่านั้น วิธีตั้งค่านั้นให้คุณไปที่ เมนู System > Preferences > Sessions หน้าต่างการตั้งค่า Session จะถูกเปิดขึ้นมา
ในหน้านี้คุณจะเห็นรายชื่อโปรแกรมที่ถูกสั่งให้ทำงานทันทีเมื่อเปิดเครื่องและระบบพร้อมที่จะทำงาน เช่น update-notifier ซึ่งเป็นตัวเตือนให้คุณอัพเดทระบบ ถ้าหากว่าคุณรู้สึกรำคาญคุณสามารถ Delete ออกไป หรือจะ Disable ไว้ก่อนก็ได้เช่นกัน ส่วนการเพิ่มโปรแกรมแกรมที่ต้องการให้ทำงานเมื่อเปิดเครื่องนั้น ให้คุณกด Add ระบบจะถามถึงคำสั่งที่ใช้ในการเรียกโปรแกรมนั้น ซึ่งคุณอาจต้องศึกษาดูเองว่าโปรแกรมที่คุณต้องการเรียกมีคำสั่งที่จะเรียกขึ้นมาทำงานอย่างไร ซึ่งโปรแกรมส่วนใหญ่นั้นจะมีคำสั่งเรียกใช้งานตรงกับชื่อโปรแกรมเอง เช่น firefox, gimp เป็นต้น
==เพิ่ม User==
หลังจากติดตั้ง Ubuntu เสร็จแล้ว จะมีชื่อผู้ใช้เพียงชื่อเดียวเท่านั้น ซึ่งหากคุณใช้คอมพิวเตอร์ด้วยกันหลายคนในเครื่องเดียว การสร้างชื่อผู้ใช้เพิ่มตามจำนวนคนย่อมสมเหตุสมผลกว่า เพื่อที่การตั้งค่าตามความต้องการของแต่ละคนจะได้เป็นไปอย่างอิสระ
การเพิ่มผู้ใช้ใหม่ ให้คุณไปที่ เมนู System > Administration > Users and Groups ระบบจะถามรหัสผ่านของผู้ดูแลระบบก่อน ให้คุณใส่รหัสผ่านของคุณลงไป โปรแกรมจัดการ Users and Groups จะแสดงขึ้นมา วิธีเพิ่ม User ให้คุณคลิกเลือกที่ Add User จากนั้นหน้าต่าง New user account จะเปิดขึ้นมาให้คุณใส่รายละเอียดของผู้ใช้คนใหม่ให้เรียบร้อย หรืออาจใส่แค่ Username กับ Password ก็ได้ ส่วนค่าอื่นๆนั้น ผู้ใช้สามารถเปลี่ยนแปลงได้ด้วยตนเอง เมื่อเพิ่ม User เสร็จแล้วอย่าเพิ่งปิดหน้าต่าง ให้เลือกที่แถบ User privileges เพื่อมอบสิทธิ์ให้แก่ผู้ใช้ที่เพิ่มเข้ามาใหม่ว่าจะให้ทำอะไรได้บ้าง ซึ่งคุณอาจกำหนดให้มีสิทธิ์ในระดับ Administrator เช่นเดียวกับคุณเลยก็ได้
==การบีบอัดไฟล์ และคลายไฟล์ที่ถูกบีบอัด==
โปรแกรมบีบอัดไฟล์นั้น Ubuntu ได้จัดเตรียมมาให้เป็นที่เรียบร้อยแล้ว เพียงแต่ไม่มีเมนูหรือไอคอนสำหรับเรียกโปรแกรมขึ้นมาทำงานโดยตรงเท่านั้น วิธีเรียกใช้โปรแกรมบีบอัดไฟล์ เพียงแค่คุณดับเบิลคลิกที่ไฟล์บีบอัดโปรแกรมบีบอัดไฟล์จะถูกเรียกขึ้นมาเอง
การบีบอัดไฟล์ คุณสามารถทำได้ง่ายๆโดยการคลิกขวาที่ไฟล์หรือโฟลเดอร์ที่ต้องการบีบอัด จากนั้นเลือก Create Archive... จะมีหน้าต่างให้ตั้งชื่อไฟล์บีบอัดและสกุลของไฟล์เพียงเท่านี้การบีบอัดไฟล์ก็เป็นที่เรียบร้อยแล้ว ในทางกลับกัน คุณสามารถคลายไฟล์บีบอัดด้วยการคลิกขวาแล้วเลือก Extract Here ได้เช่นกัน
==เพิ่มแบบอักษร==
แม้ว่า Ubuntu จะได้จัดเตรียมแบบอักษรไทย มาให้ใช้อย่างดีแล้วก็ตาม แต่หากคุณมีแบบอักษรที่คุณต้องการใช้ คุณก็สามารถติดตั้งลงไปได้เช่นกัน
===ติดตั้งแบบใช้คนเดียว===
การติดตั้งแบบใช้คนเดียวหมายถึงผู้ใช้คนอื่นจะไม่สามารถใช้แบบอักษรที่คุณเพิ่มลงไปได้ แต่จะสะดวกตรงที่ผู้ไม่มีสิทธิ์ในฐานะ Administrator ก็สามารถเพิ่มแบบอักษรเพื่อใช้เองได้ วิธีเพิ่มแบบอักษรนั้นให้คุณเปิดโฟลเดอร์บ้าน โดยไปที่ เมนู Places > Home Folders โปรแกรม File Manager จะเปิดขึ้นมา ให้คุณกด Ctrl+h เพื่อแสดงแฟ้มซ่อน จากนั้นให้สร้างโฟลเดอร์ชื่อ .fonts แล้วให้คุณนำไฟล์ฟอนต์ที่เตรียมมา ใส่ลงในโฟลเดอร์ที่สร้างขึ้นมาใหม่ ก็เป็นอันเรียบร้อย
===ติดตั้งแบบใช้ทั้งระบบ===
การติดตั้งแบบใช้ทั้งระบบ คุณจำเป็นจะต้องมีสิทธิ์ในฐานะ Administrator ด้วยจึงจะใส่ฟอนต์ลงในระบบได้ การติดตั้งฟอนต์ด้วยวิธีนี้ ผู้ใช้ทุกคนในเครื่องจะสามารถใช้งานฟอนต์นี้ได้ วิธีติดตั้งฟอนต์ ให้คุณกดปุ่ม Alt+F2 หน้าต่าง Run Application จะถูกเปิดขึ้นมา ให้คุณพิมพ์คำสั่งลงไปว่า sudo nautilus /usr/share/fonts พร้อมทั้งทำเครื่องหมายถูกที่ช่อง Run in terminal จากนั้นคลิกที่ Run จะมีหน้าต่าง Terminal (คล้ายหน้าต่างดอส) ขึ้นมาให้คุณป้อนรหัสผ่านแล้ว Enter โปรแกรม File Manager จะถูกเรียกขึ้นมา ให้คุณนำฟอนต์ใส่ลงไปเลยครับ
==ตั้งค่าส่วนตัวและเปลี่ยนรหัสผ่าน==
เราสามารถตั้งค่าส่วนตัวของเรารวมถึงเปลี่ยนรหัสผ่านที่ใช้สำหรับล๊อกอินเข้าระบบได้ครับ วิธีการตั้งค่านั้นให้ไปที่ เมนู System > Preferences > About Me จะปรากฏหน้าต่าง About you ขึ้นมา คุณสามารถตั้งค่าได้ตามต้องการครับ ส่วนการเปลี่ยนรหัสผ่านนั้น คุณต้องกรอกรหัสผ่านเดิมก่อนด้วย เพื่อเป็นการยืนยันตน
==กู้รหัสผ่าน==
เป็นเรื่องปกติที่คนเราจะลืมรหัสผ่านเข้าระบบได้ ซึ่ง Ubuntu ก็ได้เตรียมส่วนของ Recovery mode ไว้แล้ว สิ่งที่คุณต้องทำคือ เมื่อเปิดเครื่องขึ้นมาแล้ว ที่เมนูสำหรับเลือกระบบปฏิบัติการให้เลือกที่เมนูที่มีวงเล็บว่า recovery mode ต่อท้าย ระบบจะทำงานไปเรื่อยๆจนไปจบที่หน้า Command line ซึ่งมีข้อความว่า root@computer-name:~# เมื่อขึ้นมาแล้ว คุณสามารถเปลี่ยนรหัสผ่านได้ทันที ด้วยการพิมพ์คำสั่งว่า passwd user-name จากนั้น Enter แล้วพิมพ์รหัสผ่านใหม่ที่ต้องการลงไป (ขณะพิมพ์จะไม่เห็นอักษรใดทั้งสิ้น คล้ายว่ากดไม่ติด ให้พิมพ์ไปเลย) เสร็จแล้ว Enter แล้วพิมพ์รหัสผ่านซ้ำอีกครั้ง ระบบจะแจ้งว่า passwd: password update successfully หมายความว่าเรียบร้อยแล้ว (ถ้าไม่ได้ ให้เริ่มพิมพ์คำสั่งใหม่ตั้งแต่ต้น) จากนั้นพิมพ์คำสั่งว่า reboot เพื่อรีสตาร์ทเครื่องแล้วเข้าระบบด้วยรหัสผ่านใหม่ได้เลย | https://web.archive.org/web/20080716093752/http://wiki.ubuntuclub.com:80/wiki/Ubuntu_Desktop_Guide | CC-BY |