DEV Community: CopyPasteEngineer

Python Genetic Algorithm - เลือกทำเลร้านขายลูกชิ้นในม็อบด้วย AI 😂

CopyPasteEngineer — Sun, 25 Oct 2020 12:09:48 +0000

ขอเริ่มจากเล่านิทานก่อนนะครับ 555 สมมุติว่าเราอยู่ในองค์กรสายลับระดับชาติในชื่อ "ภาคีลูกชิ้นทอด" ที่กำลังวางแผนแทรกซึมเข้าไปในม็อบเพื่อขายลูกชิ้นและไก่ทอดในม็อบให้ได้มากที่สุด แน่นอนว่าเมื่อเราส่งสายลับมืออาชีพของเราลงไปแล้ว ไม่ว่าใครก็ต้องอดใจไม่ไหว ด้วยลูกชิ้นทอดและน้ำจิ้มสูตรเด็ด ที่ส่งกลิ่นหอมแพร่กระจายออกไปเป็นกิโล ทำให้ผู้ร่วมชุมนุมที่อยู่ในรัศมีทุกคนจะตามกลิ่นมาซื้ออย่างแน่นอน!

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

โชคดีที่เรารู้จักเทคนิคที่เรียกว่า Genetic Algorithm จึงสามารถนำมาใช้หาตำแหน่งที่ดีได้เสมอ ทำให้องค์กรสามารถทำภารกิจแทรกซึมได้สำเร็จทุกครั้งไป...

...ในบทความนี้ มาดูกันว่า Genetic Algorithm คืออะไร แล้วมันจะช่วยองค์กรได้อย่างไรนะครับ??

จาก https://mgronline.com/live/detail/9630000108268

note: สำหรับท่านที่งง ๆ ว่าลูกชิ้นทอดเกี่ยวอะไร ลองอ่านเนื้อเรื่องเพิ่มเติมได้ครับ 5555: เปิดใจ CIA หน่วยเคลื่อนที่เร็วประจำม็อบ “ลูกชิ้นทอด-ไก่ทอด” ยอดขายพุ่งเฉียดวันละหมื่น!

Genetic Algorithm

พักเรื่องนิทานเอาไว้สักครู่ มารู้จักกับ Genetic Algorithm กันก่อน Genetic Algorithm (GA) เนี่ยก็เป็น algorithm อย่างหนึ่งที่เอาไว้ใช้หาคำตอบ (solution) ที่ให้ค่าของผลลัพธ์มากที่สุด จริง ๆ มันก็คือ algorithm สำหรับการทำ optimization อย่างหนึ่งนั่นเองครับ

ตัวอย่าง Use Case

การหาเส้นทางนำของคลังสินค้าไปส่งตามจุดต่าง ๆ โดยใช้ต้นทุนน้อยที่สุด
เราก็จะนิยามโจทย์ให้ Genetic Algorithm (GA) ว่าให้หา คำตอบ (solution) ซึ่งก็คือลำดับการเดินทาง เช่น [คลังสินค้า, ร้าน1, ร้าน7, ร้าน3, คลังสินค้า, ร้าน5, ...] ออกมา โดยต้องเป็นคำตอบที่ใช้ ต้นทุน (cost) หรือ objective value น้อยที่สุด ซึ่งอาจจะเป็นค่าน้ำมันหรือเวลา ก็ตามแต่ที่เราจะกำหนด จากนั้น GA ก็จะไปทำการลองผิดลองถูกเพื่อหาคำตอบที่ดีที่สุดที่มันหาได้มาให้เราครับ

จาก https://zenodo.org/record/1247385#.X5QTB50zZD8

ลองมาดูตัวอย่างที่ให้ความรู้สึกเป็น AI มากขึ้นหน่อยดีกว่าครับ

MarI/O bot เล่นเกม Mario
ความน่าสนใจของงานนี้อยู่ตรงที่ว่า คนสร้างไม่ได้สอนตัว AI เลยแม้แต่น้อย ว่ากดปุ่มอะไรแล้วจะเกิดอะไร หรือกลไกของเกมส์ Mario เป็นอย่างไร หรือโดนโจมตี/เก็บของแล้วจะเป็นอะไร นั่นคือเริ่มต้นมา AI ไม่รู้อะไรเลย แต่มันจะค่อย ๆ ลองเล่น ลองผิดลองถูกไปเรื่อย ๆ จนเก่งขึ้นตามภาพครับ

จาก https://www.youtube.com/watch?v=qv6UVOQ0F44

เบื้องหลังความเทพของ bot ตัวนี้ก็คือ Genetic Algorithm นี่แหละ เอาไปรวมกับ Neural Network เพื่อให้มันสามารถอ่าน input จาก pixel บนหน้าจอ แล้วทำหน้าที่เป็นเหมือนกับสมองในการสั่งการตัว Mario ว่าเมื่อเห็นภาพบนหน้าจอแบบนี้ แล้วจะต้องกดปุ่มอะไรต่อ

การนิยามโจทย์สำหรับ GA ก็จะเป็นว่า คำตอบ (solution) ที่ต้องการก็คือ โครงสร้างของ Neural Network ที่สามารถควบคุม Mario ได้ดีที่สุด ทำให้ Mario สามารถเดินทางไปได้ เป็นระยะทางไกลที่สุด (objective value) นั่นเองครับ

แล้วก็ยังมีตัวอย่างน่าสนใจอีกมาก ที่ GA สามารถทำได้ ถ้าสนใจลองหาเพิ่มเติมได้ครับ
keywords: genetic algorithm, evolutionary algorithm
อันนี้ลองหาใน Youtube มาไว ๆ ครับ

จะเห็นได้ว่า GA สามารถเอาไปประยุกต์ใช้กับปัญหาได้หลากหลายมาก ถ้าเราสามารถนิยามปัญหาของเราเป็นการหาคำตอบที่ดีที่สุด (เท่าที่จะหาได้) จากบรรดาคำตอบที่เป็นไปได้ทั้งหมด (search space) เช่น ใช้ต้นทุนน้อยสุด หรือให้ค่าความเหมาะสม (fitness) มากที่สุด

Genetic Algorithm ทำงานอย่างไร

ทีนี้ แล้วอะไรล่ะที่ทำให้ GA มันเทพขนาดนั้น ถึงขนาดนำมาควบคุม Mario หรือช่วยสายลับลูกชิ้นทอดของเราได้เลย ...เริ่มจากมาทำความเข้าใจหลักการทำงานของ algorithm กันก่อนนะครับ

Genetic Algorithm (GA) จะใช้แนวคิดคล้าย ๆ กับการวิวัฒนาการของสิ่งมีชีวิตเลยครับ คือเป็น Natural Selection สิ่งมีชีวิตที่อ่อนแอจะถูกกำจัด ตัวที่แข็งแกร่งจะอยู่รอด และได้สืบพันธุ์ต่อไป แล้วก็จะมีกลไกของการกลายพันธุ์ (mutate) ของ Gene ทีละนิดในแต่ละครั้งที่สืบพันธุ์ เหมือนเป็นการลองผิดลองถูก คล้าย ๆ กับที่มนุษย์ค่อย ๆ มีการกลายพันธุ์/วิวัฒนาการ ให้หางของเราหายไปทีละนิดจนเป็นมนุษย์อย่างในปัจจุบัน คือค่อย ๆ สร้างความแตกต่างออกไปจากพ่อ-แม่ ของมัน เพื่อสร้างความหลากหลายครับ

มาทบทวนวิชาชีวะมัธยมกันสักหน่อยนะครับ 555

โครโมโซม (Chromosome)

โดยสิ่งมีชีวิตแต่ละตัวจะมี สารพันธุกรรม (Chromosome) อยู่ครับ สิ่งนี้จะเป็นตัวกำหนดลักษณะของมัน ซึ่งสิ่งนี้ สำหรับใน GA ก็คือตัว คำตอบ ที่เราจะให้มันหานั่นเองครับ เราอยากให้ Algorithm มันค่อย ๆ พัฒนา Chromosome ของมันไปเรื่อย ๆ จนในท้ายที่สุดจะได้ Chromosome ที่แข็งแกร่งที่สุดที่อยู่รอดออกมาเป็นคำตอบ ก็คือ Chromosome ที่ทำให้ได้ cost ต่ำที่สุด หรือมีค่า fitness สูงสุด ตามที่เราคุยกันไปตอนต้นนั่นเองครับ

ถ้าเป็นโจทย์การหาเส้นทางฯ Chromosome 1 อันก็อาจจะเป็น
ลำดับของการเดินทาง 1 รอบ [คลังสินค้า, ร้าน1, ร้าน2, คลังสินค้า, ร้าน3]

หรือถ้าเป็นโจทย์เกมส์ MarI/O Chromosome 1 อันก็อาจจะเป็น โครงสร้าง Neural Network แบบหนึ่ง อย่างนี้เป็นต้น

การคัดเลือกโดยธรรมชาติ (Natural Selection)

ทีนี้ในการทำ GA เราก็จะมีกลไกในการคัดเลือกตัวที่เก่งที่สุดอยู่ครับ โดยเราสร้าง ประชากร ของสิ่งมีชีวิตขึ้น แบ่งเป็น รุ่น (generation) เริ่มจากรุ่น 0 หรือ generation 0 เราจะสร้าง Chromosome ขึ้นมาเยอะ ๆ แบบสุ่มมั่ว ๆ เลยนะครับ สมมุติว่าสร้างมา 500 Chromosomes โดย Chromosome แต่ละอันก็จะแทนสิ่งมีชีวิต 1 ตัว ที่เกิดมาแบบสุ่ม อาจจะมีทั้งตัวที่แข็งแกร่ง และตัวที่อ่อนแอปน ๆ กันอยู่

จากนั้นเราก็จะทำการคำนวนครับว่า Chromosome แต่ละอันมีความแข็งแกร่ง หรือ ความเหมาะสม (Fitness) มากแค่ไหน ออกมาเป็นตัวเลข 1 ตัวสำหรับแต่ละอัน เช่น Mario ตัวนี้เดินไปได้ไกล 50 เมตร แบบนี้เป็นต้น

ทีนี้พอเรารู้แล้วว่าตัวไหนเก่งเท่าไหร่ เราก็จะทำการกำจัดตัวที่อ่อนแอออกไปครับ เช่นถ้าเราบอกว่าเราต้องการ Fitness ให้สูงที่สุด ตัวที่อ่อนแอของเราก็คือตัวที่ Fitness ต่ำ ๆ เราก็จะกำจัดตัวที่ Fitness ต่ำ ๆ ออกไปส่วนหนึ่ง อาจจะบอกว่าเอาออกสัก 50% ของประชากรทั้งหมด หรือมากน้อยกว่านั้นก็ได้

พอเรากำจัดตัวที่อ่อนแอออกไปแล้ว เราก็จะให้ตัวที่เหลือรอดเนี่ย ได้มาทำการ สืบพันธุ์ เพื่อสร้างลูกหลานและส่งต่อ Chromosome ที่ดีต่อไปครับ (เดี๋ยวจะอธิบายในส่วนของการสืบพันธุ์เพิ่มเติมครับ)

แล้วเราก็จะทำอย่างนี้ไปเรื่อย ๆ ใน generation ต่อ ๆ ไป ทำให้ Chromosome หรือคำตอบที่ดีแต่ละอันที่สุ่มมาได้เกิดการผสมกันไปมา ถ้าผสมแล้วไม่ดีก็จะถูกกำจัดออก แล้วเหลือไว้แต่อันที่ดี เพื่อไปผสมกันให้ดีขึ้นไปอีกเรื่อย แล้วสุดท้ายคำตอบที่ดีที่สุดที่เราได้จาก Algorithm ก็คือ Chromosome ที่ให้ค่า Fitness ดีที่สุดใน generation สุดท้าย นั่นเองครับ

ภาพการเกิด Natural Selection โดยยีราฟตัวที่มี Chromosome คอสั้นจะโดนแย่งอาหาร และค่อย ๆ อดอาหารตายไป ทำให้ยีราฟที่มี Chromosome คอยาวอยู่รอด และสืบพันธุ์ส่งต่อ "ความคอยาว" ให้รุ่นลูกหลานถัดไป จนยีราฟทุกตัวใน generation หลังก็จะคอยาวกันหมด จาก https://www.toppr.com/content/story/amp/natural-selection-and-polymorphism-73211/

การสืบพันธุ์ และการกลายพันธุ์ (Reproduction and Mutation)

การสืบพันธุ์ (Reproduction) ถ้าเป็นตามที่เราเรียนมาก็คือเราจะเอา Chromosome จากพ่อกับแม่ มา crossover กัน โดยสลับหน่วยย่อยของ Chromosome กันบางส่วนเพื่อแลกเปลี่ยนสารพันธุกรรมกัน ก่อนจะส่งต่อไปให้กับรุ่นลูกใช่ไหมครับ

Chromosomes Crossing Over จาก https://ib.bioninja.com.au/standard-level/topic-3-genetics/33-meiosis/crossing-over.html

ใน Genetic Algorithm เราก็จะทำเช่นเดียวกันครับ คือเราเอาตัวที่แข็งแกร่ง 2 ตัวมาทำการแลกเปลี่ยนบางส่วนของคำตอบกัน โดยคาดหวังว่ามันอาจจะได้ Combination ที่ดีขึ้นออกมาในรุ่นลูกครับ

ภาพการ cross chromosomes แบบหนึ่ง ใน GA จาก https://www.tutorialspoint.com/genetic_algorithms/genetic_algorithms_crossover.htm

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

ภาพ Swap Mutation จาก https://www.tutorialspoint.com/genetic_algorithms/genetic_algorithms_mutation.htm

สรุปกระบวนการ Genetic Algorithm

เริ่มจากสร้างประชากร Chromosomes ขึ้นมาแบบสุ่ม สมมุติ 500 ตัว
คำนวนค่า Cost หรือ Fitness ของ Chromosome แต่ละตัว
ถ้าเงื่อนไขในการหยุดเป็นจริง ให้หยุดทำงาน ถ้ายังไม่จริงก็ทำต่อ
กำจัดตัวที่อ่อนแอออกไป สมมุติครึ่งหนึ่ง ก็จะเหลือตัวที่แข็งแกร่งอยู่ 250 ตัว
เอาตัวที่เหลืออยู่มาสืบพันธ์และสุ่มกลายพันธุ์ เพื่อเพิ่มจำนวนของประชากรให้ Chromosomes ทั้งหมดกลับมามีจำนวน 500 เท่าเดิม
ทำซ้ำตั้งแต่ข้อ 2

จาก https://www.researchgate.net/figure/Genetic-algorithm-flowchart_fig2_263224226

ผมละรายละเอียดบางส่วนเอาไว้ คิดว่าไปดูในโค้ดน่าจะเห็นภาพมากกว่าครับ

แล้วจะขายลูกชิ้นที่ไหนดี...

ก่อนที่ภาคีลูกชิ้นทอดของเราจะรอนานไปมากกว่านี้ ถ้าพอจะเข้าใจแนวคิดของ Genetic Algorithm คร่าว ๆ แล้ว เรามาเริ่มเขียนโค้ดเพื่อช่วยองค์กรหาตำแหน่งขายลูกชิ้นกันดีกว่าครับ

โค้ดเต็ม ๆ ทั้งหมดดูได้ใน Google Colab ตามลิ้งนี้เลยครับ สามารถเปิดขึ้นลองรันดู ไปพร้อม ๆ กับอ่านบทความได้เลยครับ https://colab.to/1K6qosp_HcGmgBy8dVqSlpooYLBSeEnbA

ก่อนอื่นกำหนดค่าคงตัวต่าง ๆ กันก่อน

POPULATION_SIZE: ให้ในหนึ่ง Generation มีประชากรเป็น 500 chromosomes
N_SHOPS: ให้ Chromosome 1 ตัว หรือก็คือ คำตอบ 1 คำตอบที่เราต้องการหา ประกอบด้วยตำแหน่ง xy ของร้านค้า จำนวน 10 ร้านค้า เพราะเรามีสายลับทั้งหมด 10 คน
EFFECT_RADIUS: ให้รัศมีของกลิ่นหอมกระจายไปไกล เป็นระยะทาง 1.0 หน่วย (Euclidean Distance = 1.0)
CAPACITY: ให้ร้านค้า 1 ร้าน สามารถขายให้ได้แค่ ไม่เกิน 150 คนเท่านั้น

ข้อมูลที่อยู่ของคนในม็อบ

เนื่องจากเราไม่มีข้อมูลจริง ก็จะเริ่มจากสร้างข้อมูลตำแหน่งของคนในม็อบขึ้นมาก่อนได้เป็นแบบนี้นะครับ สมมุติว่า 1 จุดแทน 1 คนยืนอยู่เลย จะมีอยู่ 3 กลุ่ม clusters ขนาดเล็ก กลาง ใหญ่ รวมทั้งหมด 1,250 คนครับ

note: รายละเอียดว่าสร้างออกมาแบบนี้ได้ยังไงไม่ได้น่าสนใจมากขออนุญาตข้ามนะครับ สามารถไปดูได้ในโค้ดเต็มครับ

ฟังก์ชันต่าง ๆ

สำหรับ project นี้ไม่ได้ซับซ้อนมากนัก ผมจะขอเริ่มแบบง่าย ๆ โดยการ implement logic ของส่วนต่าง ๆ ที่ยุ่ง ๆ ให้เป็นฟังก์ชันย่อย ๆ ออกมาตามนี้ครับ

ฟังก์ชัน get_customers(positions, mob) สำหรับรับตำแหน่งของร้านค้าและม็อบ เพื่อไปคำนวณว่าเมื่อตั้งร้านตามตำแหน่งต่อไปนี้แล้ว คนไหนบ้างในม็อบจะมาซื้อ และเป็นจำนวนเท่าไหร่ในแต่ละร้าน
ฟังก์ชัน create_initial_population() สำหรับสุ่มสร้าง population ของ chromosomes เริ่มต้น
ฟังก์ชัน calculate_objective(mob, population) สำหรับคำนวณค่า fitness
ฟังก์ชัน reproduce(parents, count) สำหรับนำ population ที่ผ่านการคัดเลือกมาเป็น parents เพื่อทำการสืบพันธุ์และกลายพันธุ์ต่อไป

get_customers(positions, mob)

ฟังก์ชันนี้ใช้สำหรับคำนวณว่าเมื่อตั้งร้านตามตำแหน่ง positions แล้วใครในม็อบจะมาซื้อบ้าง (เลข index ของ array mob) และได้จำนวนการขายของแต่ละร้านเท่าไหร่ โดยที่ mob คือ array ของตำแหน่ง (x, y) ของคนในม็อบ

ผมวนลูปเพื่อเอาตำแหน่งของร้านค้า p มาทีละร้าน จาก positions
คำนวณระยะห่างของแต่ละคนในม็อบกับร้าน p (Euclidean Distance)
เลือกคนที่อยู่ใกล้ที่สุดมาจำนวนไม่เกิน 150 คน (เท่ากับจำนวนคนที่ร้าน 1 ร้านสามารถขายให้ได้ CAPACITY = 150) และอยู่ห่างจากร้าน p เป็นระยะทางไม่เกิน 1.0 หน่วย (คือระยะทางที่กลิ่นหอมจากร้าน p สามารถลอยไปได้ไกลที่สุด EFFECT_RADIUS = 1.0) เราจะนับไปเลยว่าคนพวกนี้จะเข้ามาซื้อร้าน p เพราะไม่มีใครทนต่อกลิ่นหอมได้
นับจำนวนของคนที่ผ่านเงื่อนไขในข้อ 3 แล้วเพิ่มไปใน customer_counts ของร้าน p เพื่อใช้บอกว่าร้าน p ได้ลูกค้าไปจำนวนกี่คน
ลบคนที่เป็นลูกค้าของร้าน p ไปแล้วออกจาก mob นั่นคือเราให้คนคนหนึ่งซื้อลูกชิ้นทอดได้แค่ครั้งเดียว จากร้านเดียวเท่านั้น

หลังจบการทำงาน ฟังก์ชัน get_customers(positions, mob) จะ return output ออกมา 2 อย่าง คือ

customer_indexes: เป็น array 1 มิติ เก็บ index ของคนในม็อบ ที่ได้ซื้อลูกชิ้นทอดจากร้านใดร้านหนึ่งไป
customer_counts: เป็น array 1 มิติ เป็นจำนวนของลูกค้าที่เข้าไปซื้อลูกชิ้นทอดจากร้านแต่ละร้าน มีขนาดเท่ากับจำนวนร้านค้าที่ใส่เข้าไป (positions)

เหตุผลที่ผมเริ่มทำฟังก์ชันนี้ก่อน ก็เพื่อให้สามารถเขียนฟังก์ชัน report(mob, positions) ที่จะ report performance ของแต่ละร้านใน positions ว่าขายได้เท่าไหร่ และ plot ออกมาเป็นกราฟให้ดูง่าย จะได้เขียนโค้ดให้เห็นภาพได้มากขึ้นครับ

ทดสอบฟังก์ชัน report()

จุดสีน้ำเงิน คือคนที่ยังไม่ได้เป็นลูกค้าร้านใด
จุดสีเขียว คือคนที่เป็นลูกค้าซื้อไปเรียบร้อยแล้ว
กากบาทสีแดง คือตำแหน่งร้านค้าที่ input เข้าไป (positions)
วงกลมสีแดง คือรัศมีของกลิ่นหอมแต่ละร้าน (มีรัศมีเท่ากับ EFFECT_RADIUS = 1.0)

create_initial_population()

ฟังก์ชันนี้ใช้สำหรับสร้าง population ของ Chromosomes เริ่มต้นโดยสุ่มค่า xy ขึ้นมา การ implement ก็ค่อนข้างง่าย ก็คือวนลูปเป็นจำนวนเท่ากับจำนวนของประชากรที่เราอยากได้ ซึ่งผมกำหนดไว้เป็น 500 ตัว (POPULATION_SIZE = 500 Chromosomes) สำหรับ Chromosome แต่ละตัว ก็จะทำการสุ่มตำแหน่งพิกัด xy ของร้าน 10 ร้าน (N_SHOPS = 10) ออกมา แทนคำตอบ 1 คำตอบ โดยใช้ฟังก์ชัน np.random.uniform() ของ library NumPy ในการสุ่มเลขแบบ uniform

ตัวอย่าง Chromosomes 5 ตัวแรกใน population ก็คือเป็น array ของ (x, y) ทั้งหมด 10 ตัว

ลองเอา population ที่สร้างได้ ตัวที่ 0 กับตัวที่ 1 มา plot ดู ก็จะเห็นว่า แต่ละตัวมีตำแหน่งของร้านจำนวน 10 ร้าน และกระจายกันแบบมั่ว ๆ

calculate_objective(mob, population)

ฟังก์ชันนี้ใช้สำหรับคำนวณค่า Fitness ของ Chromosome แต่ละตัวจากใน population ซึ่ง Fitness ของ Chromosome แต่ละตัว ก็คือยอดขายรวมของแต่ละร้านใน Chromosome นั้นนั่นเอง

เนื่องจากเรามีฟังก์ชัน get_customers() ที่สามารถคำนวณ customer_counts ของร้านค้าแต่ละร้านใน 1 Chromosome ได้อยู่แล้ว จึงสามารถเอามาใช้ได้ตามนี้ครับ

ไป ๆ มา ๆ เหมือนว่าฟังก์ชันที่ยากที่สุดจะเป็น get_customers() นี่แหละครับ 555

reproduce(parents, count)

สุดท้ายก็คือฟังก์ชัน reproduce() ครับ โดยฟังก์ชันนี้มี 2 ขั้นตอนคือขั้นตอนการสุ่ม crossover chromosomes ทีละคู่ และขึ้นตอนของการสุ่มกลายพันธุ์ ผมจึงสร้าง 2 ขั้นตอนนั้นออกมาเป็นอีก 2 ฟังก์ชันย่อย ๆ คือ cross_chromosome(a, b) และ mutate_population(population, prob, scale) ตามนี้ครับ

cross_chromosome(a, b)

สุ่มตำแหน่งที่จะทำการ cross โดยใช้ np.random.choice() โดยผลลัพธ์จะออกมาเป็น array ของค่า Boolean True หรือ False อย่างใดอย่างหนึ่ง โดยในตำแหน่งร้านที่ will_cross เป็น True ก็จะถูกสลับระหว่าง chromosome a และ chromosome b

ตัวอย่างผลลัพธ์การ cross ระหว่าง chromosome a และ b

mutate_population(population, prob, scale)

ในส่วนของการกลายพันธุ์ ผมใช้แบบง่าย ๆ คือเป็นการเลื่อนตำแหน่ง (x, y) ของร้านค้าแบบสุ่ม
ขั้นแรกผมสุ่มก่อนว่าจะให้เกิดการกลายพันธุ์ที่ Chromosome ตัวไหนบ้างจากใน population โดยมีความน่าจะเป็นของการกลายพันธุ์เท่ากับ prob (default prob = 0.2)

จากนั้นก็สุ่ม noise ขึ้นมา คือเป็นค่าสุ่มเล็ก ๆ ที่จะเอาไปบวกกับ (x, y) ของร้านใน population โดยใช้ np.random.normal ที่จะสุ่มค่าตัวเลขออกมาจาก normal distribution โดยใช้ scale = 0.3 (ยิ่งเยอะ ยิ่งมีโอกาสที่ค่าที่สุ่มออกมาจะเลขใหญ่ ๆ) โดย noise ในตำแหน่งที่เราเลือกว่าจะไม่กลายพันธุ์ ก็จะ set ให้เป็น 0 ไป จากนั้นก็เอา noise ไปบวกเข้ากับ population

ตัวอย่างของ chromosome ที่ถูกทำให้กลายพันธุ์ จะเห็นว่าบางร้านก็ถูกเลื่อนออกไปไกลจากเดิม แต่บางร้านก็ไม่ไกล คละกันไป

ฟังก์ชันหลัก reproduce(parents, count)

เมื่อเราได้ฟังก์ชันย่อยทั้งสองครบแล้ว ตอนนี้เราก็สามารถเขียน reproduce() ได้ดังนี้

ก็คือวนลูปเพื่อสุ่มหยิบ chromosomes มาทีละคู่ จาก parents เอามา cross กันด้วย cross_chromosome() จากนั้นก็เก็บผลลัพธ์ไว้ใน children จนได้จำนวนตามที่ต้องการคือเท่ากับ count

จากนั้นก็เอา children ไปสุ่มกลายพันธุ์ด้วย mutate_population() ที่เราสร้างเอาไว้ แล้วก็ return children ซึ่งเป็น array ของลูกที่ได้กลับไป

เท่านี้เราก็ได้ฟังก์ชันทั้งหมดที่ต้องการเรียบร้อยแล้ว เขียนไปเขียนมาก็เริ่มยาวแล้วเหมือนกัน 555 ต่อไปก็จะเขียนโค้ดการทำงานหลักที่ใช้หาคำตอบกันครับ

เขียนโค้ดการทำงานหลักเพื่อหาคำตอบ...สักที

เมื่อยึดตามกระบวนการทำงานของ Genetic Algorithm ที่เราสรุปเอาไว้ด้านบน เราก็พอจะร่างโครงขึ้นมาเป็น outline ได้ประมาณนี้

# 1. สร้าง population เริ่มต้น

generation = 0
while True:
    # 2. คำนวณ fitness
    objective = ...

    # 3. ตรวจสอบเงื่อนไขการหยุดการทำงาน

    # 4. กำจัดตัวที่อ่อนแอ คัดเลือกตัวที่แข็งแกร่ง
    population = ...

    # 5. สืบพันธุ์ และกลายพันธุ์
    population = ...

    print(f'generation {generation:2}: {objective.max()}')
    generation += 1

ทีนี้เราก็เติมโค้ดแต่ละส่วนลงไปด้วยฟังก์ชันที่เราเขียนเอาไว้แล้ว ตามนี้

ใช้ฟังก์ชัน create_initial_population()
ใช้ฟังก์ชัน calculate_objective()
...ขออนุญาตข้ามไปก่อน
ให้ใช้ค่า fitness จากตัวแปร objective ในการเรียงลำดับจากมากไปน้อย แล้วตัดให้เหลือแค่ครึ่งแรก ที่มีค่า fitness สูง
ใช้ฟังก์ชัน reproduce() ได้ children ออกมา จากนั้นเอา children ไปรวมกับ population ที่เหลืออยู่

ได้เป็นโค้ดที่สมบูรณ์มากขึ้นดังนี้

# 1. สร้าง population เริ่มต้น
np.random.seed(random_state)
population = create_initial_population()

generation = 0
while True:
    # 2. คำนวณ fitness
    objective = calculate_objective(mob, population)

    # 3. ตรวจสอบเงื่อนไขการหยุดการทำงาน

    # 4. กำจัดตัวที่อ่อนแอ คัดเลือกตัวที่แข็งแกร่ง
    rank_indexes = (-objective).argsort()[:int(POPULATION_SIZE/2)]
    population = population[rank_indexes]

    # 5. สืบพันธุ์ และกลายพันธุ์
    children = reproduce(population, count=POPULATION_SIZE/2)
    population = np.vstack((population, children))

    print(f'generation {generation:2}: {objective.max()}')
    generation += 1

ซึ่งจริง ๆ โค้ดด้านบนนี้ก็สามารถรันได้จริงแล้วนะครับ ทำงานได้ถูกต้องทุกอย่าง ปัญหาอย่างเดียวก็คือมันไม่รู้ว่าจะต้องหยุดทำงานเมื่อไหร่ ถ้าลองสั่งรันดูมันก็จะทำงานไปเรื่อย ๆ ครับ 555

ดังนั้นเราต้องเขียนส่วนที่ 3 ที่เราได้ข้ามไป เพื่อบอกมันว่าเมื่อไหร่ถึงจะหยุดได้
ซึ่งจริง ๆ สามารถทำได้หลายวิธีมากครับ เราอาจจะบอกว่าให้มันทำไปเป็นจำนวน 100 generations แล้วหยุดก็ได้
วิธีที่ผมชอบใช้ก็คือ ให้มันทำงานไปเรื่อย ๆ จนกว่ามันจะไม่สามารถหา chromosome ที่ดีขึ้นได้เป็นระยะเวลาหนึ่ง เช่นไม่เพิ่มเป็นจำนวน 10 generation ก็ให้หยุดนั่นเองครับ

พูดอีกอย่างก็คือเมื่อเราไม่สามารถหา chromosome ที่ดีขึ้นได้ ภายใน 10 generations ก็ให้หยุดการทำงาน

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

ถ้าเจอค่า objective ที่ดีที่สุดอันใหม่ n_not_improve ก็จะถูก reset กลับเป็น 0 แต่ถ้า n_not_improve ถึง 10 เมื่อไหร่ นั่นคือมันไม่ได้เกิดการ improve เป็นเวลานานเกินไปแล้ว ก็จะ break ออกจากลูปแล้วจบการทำงานของโปรแกรมครับ

โค้ดในส่วนที่เพิ่มเข้ามาก็จะเป็นประมาณนี้

...

max_so_far = float('-inf')
n_not_improve = 0

generation = 0
while True:
    ...

    # 3. ตรวจสอบเงื่อนไขการหยุดการทำงาน
    max_local = objective.max()
    if max_local > max_so_far:
        max_so_far = max_local
        n_not_improve = 0
    else:
        n_not_improve += 1
        if n_not_improve >= 10:  # ถ้าไม่มี improvement เป็นจำนวน 10 gen
            break
    ...
    print(f'generation {generation:2}: {objective.max()}')
    generation += 1

ขออนุญาตลงแบบย่อ เนื่องจากรู้สึกว่าโค้ดเต็ม ๆ ใหญ่ไปหน่อยครับ 55 สามารถดูทั้งหมดจากใน Colab ได้ครับ

เท่านี้โค้ด Genetic Algorithm ของเราก็สมบูรณ์แล้วครับ ถ้าลองกดรันดู แต่ละ generation มันก็จะ print ค่าของ fitness (ยอดขาย) ของตัวที่เก่งที่สุดใน generation นั้นออกมา ก็จะเห็นว่ามันค่อย ๆ เพิ่มขึ้นทีละนิด แล้วไปหยุด generation 78 ซึ่งได้ยอดขายรวมเป็น 1235 คน จาก 1250 คน คิดเป็น 98.8%!

จาก report คำตอบที่ดีที่สุด จะเห็นว่าเหลือแค่ 15 คนเท่านั้นนะครับที่ไม่ซื้อลูกชิ้นทอดของเรา 55

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

ดูพัฒนาการของคำตอบในแต่ละ generation

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

จะเห็นได้ว่าตั้งแต่สุ่ม population ออกมาใน generation แรก ก็ได้ยอดขายค่อนข้างเยอะอยู่แล้ว อาจจะเป็นเพราะว่าจำนวนประชากร POPULATION_SIZE ของเราเยอะมาก ทำให้มีโอกาสโชคดีสุ่มแล้วเจอคำตอบดี ๆ แต่แรกแบบนี้ หรือไม่ก็เป็นเพราะว่าข้อมูลตำแหน่งม็อบของเรามันกระจุกมากเกินไปก็ได้ครับ ถ้าสนใจก็สามารถลองแก้โค้ดปรับตัวแปรต่าง ๆ เล่นดูเพิ่มเติม แล้วเอาผลลัพธ์มาแชร์กันได้นะครับ

Summary

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

ซึ่ง Genetic Algorithm ก็เป็นแค่ algorithm หนึ่งที่ใช้ในการหาคำตอบของปัญหาประเภท Search Problem คือเป็นปัญหาที่ให้ algorithm หาคำตอบ จาก set ของคำตอบที่เป็นไปได้ออกมา ที่ satisfy เงื่อนไขบางอย่างที่เรากำหนดเอาไว้ ซึ่งยังมี algorithm อื่น ๆ อีกมาก ถ้าสนใจศึกษาเพิ่มเติมอาจจะเริ่มจากการ search โดยดูตาม link นี้ เป็น guide ก็ได้ครับ

ถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

Python Web Scraping part 5 - วิธีเลียนแบบการรับส่งข้อมูลของเว็บเป้าหมาย

CopyPasteEngineer — Wed, 12 Aug 2020 15:05:27 +0000

บทความนี้คิดว่าจะเป็น part สุดท้าย สำหรับการสอน scraping เบื้องต้นแล้วนะครับ หลังจากนี้ ถ้ายังสนใจกันอยู่ คิดว่าจะพา "ทำโจทย์จริง" กันดู อาจจะเป็นบทความแบบนี้อีก หรืออาจจะมาเป็นคลิป เดี๋ยวจะประกาศให้ทราบนะครับ

ก่อนอื่น ขอทบทวนเนื้อหา parts ก่อน ๆ สักเล็กน้อยนะครับ

part 1: เราพูดถึงภาพหยาบ ๆ ของการ scrape ไว้ ว่าเราอาจจะมองได้เป็น 2 ขั้นตอน ก็คือ การ scrape คือดึงข้อมูลดิบ ๆ ลงมาให้ได้ และ การ extract คือการสกัดส่วนที่เราสนใจ ออกมาจากข้อมูลดิบนั้น

part 2: ก็จะพูดถึงเรื่องของการ extract ข้อมูลก่อน โดยจะแนะนำเครื่องมือที่ช่วยให้สามารถ ตรวจดูโครงสร้างของหน้า web ได้แบบไว ๆ เพื่อหาวิธีสกัดข้อมูลที่เราต้องการออกมา

part 3: จะสอนการสกัดข้อมูลด้วย XPath เบื้องต้น โดยใช้ประโยชน์จากโครงสร้างของหน้า web ที่เราได้เรียนรู้มา

part 4: จะเล่าเกี่ยวกับส่วน scrape บ้าง และได้แนะนำ 7 เทคนิค ที่ช่วยให้เราสามารถ ดึงข้อมูลจากหลาย ๆ เว็บ ที่มีระบบซับซ้อน หรือมีกลไกการป้องกันการ scrape เอาไว้

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

อธิบายก่อนว่า อย่างเช่นตัวอย่างใน part ที่ 1 เว็บเป้าหมายของเราเป็นเว็บ Wikipedia ใช่ไหมครับ ซึ่งเว็บ Wikipedia เนี่ยไม่ได้ซับซ้อนมากนัก ข้อมูลทุกอย่างแสดงอยู่บนหน้าเว็บตั้งแต่ต้นแล้ว เราก็สามารถที่จะดึงทั้งหน้านั้นมาตรง ๆ ได้เลย

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

ตัวอย่าง: เว็บ Pantip จะค่อย ๆ โหลดข้อมูลมาเพิ่มเมื่อ scroll ลง

วิธีการหนึ่งที่ทำได้คือเราก็ต้องเข้าไปดูว่า ข้อมูลที่มันโหลดมาเพิ่มเนี่ย มันโหลดมาจากไหน โหลดมาอย่างไร จากนั้นเราก็แค่เลียนแบบมันก็จบ! ในบทความนี้จึงจะมาแนะนำ Network Inspector เครื่องมือชิ้นหนึ่งใน Google Chrome DevTools สำหรับการตรวจสอบการโหลดข้อมูลให้ได้รู้จักกันครับ

Get Started!

ถ้ายังจำกันได้ใน part ที่ 2 เราก็ได้พูดถึงเครื่องมือชิ้นหนึ่งของ Google Chrome DevTools กันไปแล้ว คือตัว Code Inspector ที่เอาไว้ใช้สำหรับตรวจสอบโครงสร้างของหน้าเว็บได้ เอาไว้ให้ developer ได้ตรวจสอบ ว่าโค้ดที่เขียนสามารถ render ออกมาเป็น HTML ได้ถูกต้องหรือเปล่า

ตัว Network Inspector ที่จะแนะนำให้รู้จักนี้ก็มีเอาไว้ด้วยเหตุผลคล้าย ๆ กันครับ ก็คือเพื่อให้ developer สามารถตรวจสอบได้ ว่าหน้าเว็บที่สร้างเนี่ย ได้ทำการรับส่งข้อมูลได้ถูกต้องตามที่ออกแบบเอาไว้หรือไม่ครับ เช่น เมื่อกดปุ่ม submit แล้ว ข้อมูลใน form ที่กรอกเอาไว้ ถูกส่งไปที่ server ได้ถูก URL ไหม และข้อมูลอยู่ใน format ที่ถูกต้องหรือเปล่านั่นเองครับ

และเช่นเดียวกับ Code Inspector คือเราสามารถใช้เครื่องมือตัวนี้ ให้เป็นประโยชน์ในการทำ scraping ได้ครับ!

เว็บข่าวไทยรัฐ

เว็บที่จะใช้เป็นตัวอย่างครั้งนี้คือเว็บข่าวของไทยรัฐ หน้านี้นะครับ thairath.co.th/news/politic ครับ โดยให้เราเลื่อนหน้าจอลงมาที่ส่วนที่เขียนว่า ข่าวอื่นๆ ตามในภาพด้านล่าง จะเห็นว่าหน้าเว็บนี้เลือกที่จะแสดงแค่ 12 ข่าวล่าสุดเท่านั้น โดยจะมีปุ่ม ดูเพิ่ม ที่ด้านล่างให้กด เพื่อให้เว็บทำการโหลดข่าวมาแสดงเพิ่มครับ

ในกรณีแบบนี้ ถ้าเรายิง requests ไปที่ URL https://www.thairath.co.th/news/politic โดยตรง เราจะไม่ได้ข้อมูลตรงนี้ีมาครับ เนื่องจากข้อมูลมันจะยังไม่ถูกโหลดเข้ามาในตอนแรก เพราะฉะนั้นเราจะต้อง ทำการเลียนแบบการ request ของปุ่ม "ดูเพิ่ม" (ขั้นตอนที่ 4 ใน diagram ตรงลูกศรสีแดง) ดูว่ามันโหลดข้อมูลใหม่มาเพิ่มได้อย่างไร แล้วเราก็ทำตามนั่นเองครับ

diagram แสดงการรับส่งข้อมูล ของเว็บ Thairath กับฝั่ง server

1. เปิด Network Inspector

ขั้นแรกให้เราไปที่ หน้าเว็บ ก่อนนะครับ แล้วกดปุ่ม F12 เพื่อเปิด Chrome DevTools ขึ้นมา จะมีหน้าต่างด้านขวาคล้าย ๆ ในภาพขึ้นมาครับ

จากนั้นให้เราเลือกเครื่อง Network Inspector โดยคลิกที่คำว่า Network จากแทบด้านบน (ของบางท่านอาจจะถูกย่อเอาไว้อยู่ ให้ลองเปิดหาดูจากตรงลูกศร >>) เมื่อเปิดมาแล้วจะเห็นเป็นหน้าว่าง ๆ แบบในรูปครับ นี่คือ Network Inspector พร้อมใช้งานแล้วครับ

2. ลองโหลดข้อมูล

ตอนนี้เมื่อเปิดหน้า Inspector ขึ้นมาแล้ว ถ้าหากมีการโหลดข้อมูลอะไรก็ตามเกิดขึ้น รายละเอียดของการโหลดข้อมูลจะแสดงขึ้นมาทันทีครับ

ให้ลองกดปุ่ม "ดูเพิ่ม" เพื่อโหลดข่าวมาแสดงเพิ่มเติม ก็จะเห็นข้อมูลหลายอย่างถูกโหลดขึ้นมาพร้อมกันดังภาพ

แถบสีด้านบนจะบอกว่าข้อมูลแต่ละชิ้น ถูกโหลดมาตอนไหน และใช้เวลาในการโหลดนานเท่าไหร่ ส่วนตารางรายการด้านล่างจะบอกว่ามันโหลดอะไรมาบ้างครับ

3. ดูข้อมูลของการ request

จากในรายการจะเห็นว่าตั้งแต่ข้อมูลบรรทัดที่ 2 เป็นต้นไป จะเป็นชื่อมั่ว ๆ ทั้งนั้น ซึ่งเป็นรูปภาพของแต่ละข่าวครับ สังเกตุได้จากที่คอลัมน์ Type จะเขียนว่าเป็นไฟล์ jpeg หรือลอง double คลิกเข้าไปก็จะสามารถดูภาพแต่ละภาพได้ครับ

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

ให้ลองคลิกเข้าไปที่ข้อมูลบรรทัดแรก จะเห็นว่ามันจะแสดงรายละเอียดที่สำคัญที่ใช้ request ไปทั้งหมดออกมา

ซึ่งข้อมูลที่แสดงออกมานี้ เพียงพอให้เราสามารถนำไป request เลียนแบบเองใน python ได้ครับ ตั้งแต่ URL คือปลายทางที่เราส่งข้อมูลไป, method คือวิธีการส่ง ซึ่งสำหรับกรณีนี้คือ GET request, headers ที่ใช้ request หรือถ้าบางที method ที่ใช้เป็น POST request ในส่วนท้ายสุดของหน้าก็จะแสดง Form Data พ่วงมาให้ด้วยครับ

ตัวอย่าง Form Data ที่จะถูกแสดงออกมาสำหรับ POST request (ไม่เกี่ยวกับเว็บนี้นะครับ เอามาให้ดูตัวอย่างเฉย ๆ)

ก่อนอื่นเลยนะครับ ให้เราเช็คให้แน่ใจก่อนว่าอันนี้เป็น URL ที่เราต้องการจริง ๆ คือมันจะให้ข้อมูลที่เราต้องการจริง ๆ ก่อน โดยการกดไปที่แทบ Preview ครับ เพื่อดูว่ามันให้ข้อมูลอะไรกลับมา

ก็จะเห็นว่าข้อมูลที่ถูกส่งกลับมา เป็น JSON ครับ โดยมี items เป็น array ของรายละเอียดแต่ละข่าวที่ถูกโหลดขึ้นมาจริง ๆ เพราะฉะนั้น อันนี้ก็คือ URL ของ API ที่เราต้องการจริง ๆ นั่นเองครับ

4. เลียนแบบ request

ต่อไปเราก็เอารายละเอียดของ request ตัวนั้นมาลอกเลียนแบบใน Python นะครับ ก็จะได้เป็นตามโค้ดด้านล่าง

import requests
url = 'https://www.thairath.co.th/loadmore&section=/news/politic&ts=1597188900&limit=8'

resp = requests.get(url)
data = resp.json()  # เนื่องจากผลลัพธ์ที่ออกมาเป็น JSON เราสามารถใช้ .json() เพื่อแปลงให้เป็น dict ใน Python ได้เลย

จะได้ข้อมูล data ออกมาเป็น dict หน้าตาประมาณนี้นะครับ

...

5. Pagination?

เพิ่มเติมอีกเล็กน้อยครับ จากข้อก่อนเราได้ข้อมูลมาเสร็จแล้วก็จริงครับ แต่มันได้มาแค่หน้าเดียว ทีนี้ถ้าเราอยากจะเก็บให้หมดทุกหน้าเลย ก็ต้องใช้ Inspector ไปก๊อปมาทุกหน้าเรื่อย ๆ หรือ??? คำตอบคือไม่ใช่ครับ

เนื่องจากว่าเราได้รู้ตัว API ของเว็บที่ใช้เป็นตัวโหลดข้อมูลแต่ละหน้ามาเรียบร้อย วิธีการโหลดหน้าอื่น ๆ เราก็แค่เปลี่ยนข้อมูลที่ส่งให้ถูกต้องเท่านั้นครับ

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

อย่างในกรณีนี้ ถ้าเราดู URL ที่เราใช้ดี ๆ ก็จะเห็นว่ามันส่งข้อมูลไป 2 อย่าง ได้แก่ ts=1597188900 และ limit=8 ตัว limit=8 เนี่ยเราเดาได้ใช่ไหมครับ ว่ามันหมายถึงจำนวนของข่าวที่ขอไป คือให้โหลดมาแค่ 8 ข่าวต่อครั้งก็พอ แล้ว ts ล่ะ??

คำใบ้อยู่ที่ข้อมูลที่ส่งกลับมาครับ จะเห็นว่าในแต่ละครั้งที่ request ข้อมูลที่ส่งกลับมาจะมีค่า minTs อยู่ด้วย ซึ่งจำนวนหลักและตัวเลขมันก็ดูคล้าย ๆ กับ ts ที่เราส่งไปนะครับ

ถ้าเราลองใช้ minTs ที่ส่งมา เอาไปยิงต่อดูตามโค้ดด้านล่างก็จะเห็นว่าจะได้ข้อมูลของหน้าถัดไปมาพอดีครับ เพราะฉะนั้นต่อให้เราไม่รู้ว่า ts คืออะไร เราก็จะพอเดาได้ว่า minTs ที่ส่งมาเนี่ย เอาไว้สำหรับให้เราสามารถโหลดข้อมูลของหน้าต่อ ๆ ไปได้นั่นเองครับ

url = 'https://www.thairath.co.th/loadmore&section=/news/politic&ts=1597149600&limit=8'
resp = requests.get(url)
data2 = resp.json()

note: จริง ๆ แล้ว ts ก็คือ timestamp นั่นเองครับ เห็นตัวย่อ และเห็นตัวแรกแล้ว หลาย ๆ ท่านน่าจะเดาได้ตั้งแต่แรกใช่ไหมครับ 55

เพราะฉะนั้นเราสามารถที่จะ automate การดึงข่าวมาหลาย ๆ หน้าดังโค้ดด้านล่าง

import requests

def get_url(ts=None):
    if ts is None:
        return 'https://www.thairath.co.th/loadmore&section=/news/politic&limit=8'

    return f'https://www.thairath.co.th/loadmore&section=/news/politic&ts={ts}&limit=8'

url = get_url()                   # ใช้ url เริ่มต้น คือไม่ต้องส่งค่า ts ไป
for i in range(10):               # วนไป 10 หน้า
    resp = requests.get(url)      # โหลดข้อมูล
    data = resp.json()            # แปลงเป็น dict

    for x in data['items']:       # ไล่ print title ของแต่ละข่าว
        print(x['title'])

    url = get_url(data['minTs'])  # สร้าง url ใหม่ โดยส่ง ts ให้มีค่าเท่ากับ minTs

Summary

จบไปแล้วนะครับ 5 parts สำหรับพื้นฐานทั้งหมดในการทำ Web Scraping ด้วย Python ถ้าเข้าใจทั้งหมดก็น่าจะสามารถดึงข้อมูลจากเว็บส่วนใหญ่ได้เยอะแล้วครับ แล้วก็อย่าลืมติดตามบทความต่อ ๆ ไปเกี่ยวกับการ scraping ด้วยนะครับ เดี๋ยวเรามาลองวิชากับเว็บจริง ๆ กัน

และก็ขอย้ำอีกครั้ง <เหมือนที่ย้ำอยู่ตลอดตั้งแต่ part แรก> ก็คือบทความนี้ทำขึ้นเพื่อการศึกษานะครับ ในการนำไปใช้จริง ควรคำนึงถึงความเหมาะสม และไม่ทำให้ผู้อื่นเดือดร้อนนะครับ

ถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

part อื่น ๆ ใน series
- part 1: การดูดข้อมูลเบื้องต้น ด้วย Python
- part 2: Chrome's Code Inspector
- part 3: เทคนิคการ extract ข้อมูลด้วย XPath
- part 4: ทำไมถึง scrape บางเว็บไม่ได้??? 7 เทคนิคง่าย ๆ ให้ scrape เว็บส่วนใหญ่ได้ลื่นปรื๊ด
- part 5: วิธีเลียนแบบการรับส่งข้อมูลของเว็บเป้าหมาย

Google Cloud Run - deploy docker แบบง่าย ๆ ราคาถูก แต่รับ traffic คนได้ทั้งประเทศ!

CopyPasteEngineer — Sat, 27 Jun 2020 14:42:43 +0000

อย่างที่ทราบกันว่า Google Cloud นี่มี services ให้เล่นกันเยอะมาก สำหรับทั้งงานในด้านเว็บ ทำระบบ data science และอื่น ๆ วันนี้จะมาแนะนำ service ตัวหนึ่งครับ เอาไว้สำหรับ deploy docker container ของ web app เรา ซึ่งเหมาะสำหรับทั้ง dev มือใหม่ที่อยากจะลอง deploy web app ดูเล่น ๆ ยันมือโปรที่จะเอาไปใช้งานบน production จริง เนื่องจากการใช้งานค่อนข้างง่าย แต่สามารถ scale ให้รองรับงานใหญ่ ๆ ระดับทั้งประเทศได้สบาย และที่สำคัญยังราคาไม่แพงอีกด้วย ก็คือตัว Google Cloud Run นี่เองครับ

ตัวอย่าง products ต่าง ๆ ของ Google ที่เกี่ยวข้อง สำหรับการ deploy apps แบบ serverless จาก Journey to Serverless on Google Cloud Platform

Google Cloud Run

Google Cloud Run เป็น serverless service ตัวหนึ่ง ในกลุ่มของ Compute Platform คล้าย ๆ กับพวก Google App Engine หรือ Google Kubernetes Engine ที่หลาย ๆ ท่านอาจจะคุ้นเคยกันดี คือเป็น product ที่ให้เราใช้เป็นส่วนของ compute เพื่อ deploy application ของเราเช่นเดียวกัน โดย Cloud Run นี้เป็น service ใหม่ที่ Google เพิ่งออกมาไม่นานนี้ครับ

ซึ่งจะมีส่วนคล้ายกับตัว Kubernetes ตรงที่จะ deploy โดยใช้ Docker image ทำให้สามารถ scale เพื่อเพิ่มจำนวนของ container ให้รับ traffic จำนวนมากได้เหมือนกัน แต่ต่างกันตรงที่ Cloud Run App หนึ่ง ๆ จะสามารถ deploy Docker image ได้แค่ image เดียวเท่านั้น ในขณะที่ Kubernetes สามารถ deploy หลาย ๆ image เพื่อมาทำงานร่วมกันได้ในทีเดียวครับ ทำให้ในบาง app ที่มีหลาย ๆ image ทำงานร่วมกัน เราก็ต้อง deploy ลง Cloud Run ทีละ image

แต่สิ่งที่ Cloud Run จะได้เปรียบกว่า Kubernetes ก็คือ Cloud Run นั้น มีความซับซ้อนน้อยกว่า และก็ ไม่ต้องเขียน config ให้ยุ่งยาก แบบ Kubernetes ครับ ซึ่งไม่ว่าจะเรื่องของการทำ auto-scaling หรือ load-balancing นี่ Google Cloud Run จัดการให้เองทั้งหมดครับ

จุดเด่น

1. คือ Google Cloud Run สามารถ deploy ได้ง่ายมาก ไม่ต้อง config เพียงแค่เรา push docker image ขึ้นไปใน project เรา จากนั้นก็สั่ง deploy คำสั่งเดียว ก็จบครับ

2. ทำ auto-scaling ให้อัตโนมัติ สามารถเพิ่มจำนวน instances จำนวนมากได้ภายในเวลาอันสั้น

ภาพการทดสอบ auto-scaling ของ Cloud Run จาก คลิปงาน Cloud Next '19 โดยใช้วิธีการจำลอง user ขึ้นมา แล้วให้ยิง request ไปที่ Cloud Run App เดียวกัน ไปเรื่อย ๆ โดยจำนวนของ user จะค่อย ๆ เพิ่มขึ้นเรื่อย ๆ จนไปถึง 15,000 คน!

จากกราฟ แกนตั้งคือเวลาที่ใช้ในการ request (latency) ส่วนแกนนอนคือเวลาที่ผ่านไป จะเห็นว่าในช่วงแรก latency ค่อนข้างสูง เนื่องจากว่าอยู่ ๆ user ก็เพิ่มจำนวนขึ้นกระทันหัน และยังเพิ่มขึ้นเรื่อย ๆ แต่เมื่อผ่านไปสักพัก ที่ประมาณวินาทีที่ 25 latency ก็ drop ลง และค่อนข้างจะคงที่หลังจากนั้น นั่นคือ Google Cloud Run สามารถ handle burst ของ load หลักหมื่นได้ภายในไม่กี่วินาที!

3. เป็น Serverless Service หมายความว่า Google จะ manage ตัว infrastructure ให้หมด ทำให้เราไม่ต้องสนใจว่าจะต้อง setup เครื่องยังไง หรือจะเอาไปลงเครื่องไหน ให้เราคิดเสมือนว่าไม่มี server อยู่นั่นเองครับ

4. เนื่องจากว่าเป็น serverless การคิดราคาจึงไม่ได้คิดจากเวลาที่เครื่อง server ทำงาน แบบ service อื่น ๆ (เช่น App Engine) แต่จะคิดเงินเฉพาะจากเวลาที่ใช้งานจริงเท่านั้น หมายความว่าถ้าวันไหนไม่มีคนเข้าเว็บเรา เราก็ไม่เสียเงินเลยครับ

ภาพของช่วงเวลาที่จะคิดเงิน คือจะคิดเงินช่วงที่มีคนยิง request เข้ามาและประมวลผลเท่านั้น (สีฟ้า) ช่วงที่ไม่มี request ก็ไม่คิดเงิน (สีเทา)

5. รองรับโค้ดทุกภาษา เนื่องจากว่าใช้ docker image ในการ deploy ครับ ดังนั้นจะโค้ดด้วยภาษาอะไร ถ้าเอาใส่ docker ได้ ก็จบ ซึ่งต่างกับตัว App Engine ที่ Support แค่บางภาษาเท่านั้น

วิธี deploy

สิ่งที่ต้องเตรียม

1. Google Cloud project ซึ่งเปิดอนุญาตการ Billing ไว้แล้ว; ถ้ายังไม่เปิด สามารถทำตามขั้นตอนใน link นี้ ได้ครับ แค่คลิก ๆ ไม่นาน

2. Google Cloud SDK เพื่อความสะดวกในการใช้งาน products ทุก product ของ Google ควรจะต้องติดตั้ง program นี้ไว้ครับ เมื่อติดตั้งแล้ว เราจะสามารถควบคุม services ต่าง ๆ ของ Google ได้ผ่านคำสั่งใน command line สามารถติดตั้งได้ตาม link นี้ เลยครับ

การ deploy

1. submit docker image ให้เข้าไปที่ directory ที่มี Dockerfile ที่เราเตรียมเอาไว้อยู่ครับ เสร็จแล้ว run คำสั่งนี้ เพื่อทำการ submit โค้ดต่าง ๆ ขึ้นไป และ build Container Image บน Google Cloud ด้วย service ที่ชื่อ Cloud Build ครับ

gcloud builds submit --tag asia.gcr.io/PROJECT_ID/IMAGE_NAME

ให้เปลี่ยน PROJECT_ID เป็น ชื่อ Google Cloud project ของเรา และเปลี่ยน
IMAGE_NAME เป็น ชื่อ app ของเรา นะครับ

ถ้าใช้ Cloud Build ครั้งแรก มันจะถามว่าให้ enable API cloudbuild.googleapis.com ของ Cloud Build ไหม ก็ให้กด y แล้ว ENTER ไป มันก็จะทำงานต่อ

Cloud Build จะทำการ build ตาม Dockerfile ที่เราเขียนไว้ แล้ว push image ไปที่ registry ใน project ของเรา (ที่ asia.gcr.io/PROJECT_ID/IMAGE_NAME)

note: ผมใช้ hostname เป็น asia.gcr.io หมายความว่า เราจะเก็บ image ของเราไว้ใน registry ที่อยู่ใน asia ครับ ซึ่งเราสามารถเปลี่ยน location ไปที่อื่น ๆ ได้ เช่น us.gcr.io, หรือ eu.gcr.io ตาม location ที่เราใช้งานครับ

2. deploy image ลง Cloud Run ตอนนี้เรา build app ของเราเป็น container image ไปเก็บเอาไว้แล้วนะครับ ทีนี้ก็แค่บอก Google Cloud Run ว่าเอา image อันนี้ไปใช้ที เท่านั้นครับ

gcloud run deploy IMAGE_NAME \
    --image asia.gcr.io/PROJECT_ID/IMAGE_NAME \
    --platform managed \
    --region asia-east1 \
    --allow-unauthenticated \
    --port PORT

อธิบายคำสั่งทีละบรรทัด
1. ให้ deploy โดยใช้ชื่อ IMAGE_NAME

2. ด้วย image จาก asia.gcr.io/PROJECT_ID/IMAGE_NAME

3. ด้วย mode managed คือให้ Google managed ให้อัตโนมัติ ซึ่งจะมี mode อื่น ๆ ที่ไปใช้ cluster ที่เรามีมารันแทน แต่ง่ายสุด ก็ใช้ managed ไปก่อนครับ

4. ไปที่ region asia-east1 จะอยู่ที่ Taiwan ซึ่งเป็นที่ location หนึ่งที่ไม่ไกลจากไทยมาก ที่สามารถใช้ Google Cloud Run ได้ (location ที่ใกล้ไทยที่สุดคือ asia-southeast2 ที่ Jakarta แต่ ณ ตอนนี้ยังไม่สามารถใช้ Cloud Run ได้ครับ)
5. allow-unauthenticated คือ อนุญาตคนอื่นสามารถใช้ app นี้ได้ แต่ถ้าอยากทำเพื่อใช้เฉพาะ dev ที่ได้รับอนุญาตเท่านั้น ก็สามารถเปลี่ยนเป็น --no-allow-unauthenticated แทนได้ครับ

6. application เราจะรันจาก port PORT แทนค่า PORT เป็น port ที่เราจะใช้งานนะครับ

อันนี้ก็เหมือนกัน คือถ้าเราไม่เคยใช้ Cloud Run มาก่อน มันก็จะถามว่าให้ enable API run.googleapis.com ของ Cloud Run ไหม ก็กด y<ENTER> ไป

note: เพิ่มเติมนิดนึง คือมี options อื่น ๆ ที่ปรับได้อีกนะครับเช่นจำนวน CPU ว่าจะเอากี่ตัว หรือ ขนาดของ RAM ว่าจะใช้กี่ MB สามารถดูเพิ่มเติมได้ใน link นี้ เลยครับ

ถ้า deploy สำเร็จ ก็จะ message ประมาณนี้ขึ้นมา

Done.                                                                                                                                                                                                             
Service [myapp] revision [myapp-00003-gej] has been deployed and is serving 100 percent of traffic at https://myapp-cee6n4roda-de.a.run.app

เราก็เอา link ที่มันให้มา มาเปิดดูใน browser ได้เลยครับ ก็จะเห็น app ของที่เราเขียนไว้ อย่างของผม ลิ้งคือ https://myapp-cee6n4roda-de.a.run.app พอไปเปิดใน browser ก็จะเป็น Django app ขึ้นมาแบบนี้

ก็เป็นอันเสร็จสิ้นครับ แค่ 2 ขั้นตอน สามารถแชร์ลิ้งให้เพื่อนไปเล่น หรือนำไปใช้งานจริงได้เลย

หน้า UI สำหรับจัดการต่าง ๆ

เราได้ลอง deploy โดยใช้ command line ไปแล้วนะครับ ซึ่งโดยปกติเราก็คงจะใช้วิธีนั้นการทำงานจริงใช่ไหมครับ ทั้งเวลาทำ ci/cd เขียน pipeline ให้ deploy อัตโนมัติ ก็จะใช้คำสั่งตามด้านบนในการทำ

แต่ Google Cloud ก็ยังมีหน้า GUI ให้ใช้ผ่าน browser เพื่ออำนวยความสะดวกทุกคน ให้สามารถ deploy และตั้งค่าต่าง ๆ ได้แบบง่าย ๆ อีกด้วย สามารถเข้าผ่าน link นี้ได้เลยครับ https://console.cloud.google.com/run

จะเห็นว่ามีปุ่มให้ สร้างบริการ (สร้าง service) ก็คือทำการ deploy ผ่าน UI นี้ได้ และสามารถที่ดู แก้ไข หรือลบ service ที่เราสร้างเอาไว้แล้วได้ง่าย ๆ ผ่านหน้านี้เลยครับ

การเก็บเงิน

อย่างที่ทราบคือ Cloud Run นั้นเป็น serverless service ดังนั้นการเก็บเงิน ก็จะเก็บตามปริมาณที่เราใช้ไปเท่านั้น โดยจะมีด้วยกัน 4 ส่วนครับ
1. CPU ก็คือ ยิ่งเราใช้ CPU แรง และทำการคำนวณนานใน request แต่ละครั้ง ราคาก็จะแพงครับ

โดย Google จะใจดี ให้ฟรีเดือนละ 180,000 vCPU-seconds
หลังจากนั้นก็จะคิดราคา $0.00002400 / vCPU-seconds

note: หน่วย vCPU-seconds หมายถึงจำนวน CPU ที่ app เราใช้ คูณกับเวลาที่ใช้รันทั้งหมดครับ อย่างที่บอกด้านบนว่าจำนวน CPU และ RAM ที่เราจะ allocate ไว้นี่ สามารถปรับได้

ตัวอย่างเช่น ถ้าเราเลือก 2 CPU แล้วในเดือนหนึ่งเรารันไปเป็นเวลา 100,000 วินาที
ก็จะคิดเป็น 2 vCPU x 100,000 seconds = 200,000 vCPU-seconds ครับ
ซึ่ง Google ให้ฟรีมา 180,000 vCPU-seconds
เพราะฉะนั้นในเดือนนั้นเราก็ต้องจ่ายที่เหลือ 20,000 vCPU-seconds x $0.00002400 = $0.48 เท่านั้นครับ

2. Memory อันนี้ก็คิดคล้าย ๆ กับ CPU เลยครับ คือนับเป็นหน่วย GiB-seconds ก็คือเอา GB ของ RAM ที่เราจองไว้ มาคูณเวลาที่ใช้นั่นเอง

โดย Google จะให้ฟรีเดือนละ 360,000 GiB-seconds

แล้วหลังจากนั้น จะคิดราคา $0.00000250 / GiB-second

3. จำนวนครั้งที่ Requests ฟังดูงกหน่อย ๆ นะครับ ที่คิดเวลาที่รัน แล้วยังมาคิดจำนวนครั้งอีก 555

แต่ Google ก็ให้ ฟรีตั้ง 2 ล้านครั้งต่อเดือน ครับ

แล้วหลังจากนั้น ก็แค่ $0.40 / หนึ่งล้านครั้ง เท่านั้น

ทั้ง 3 ข้อด้านบนสามารถสรุปได้ตามตารางนี้ครับ

*rate นี้ไม่รวม australia และ northamerica นะครับ อ่านเพิ่มเติม ได้ที่ link นี้

4. Network ส่วน network นี่จะคิดเงินแค่ขาออก คือจาก application ออกไปข้างนอกเท่านั้น แต่จะค่อนข้างซับซ้อน เพราะขึ้นกับ geo location ของทั้ง source และ destination ตามภาพครับ

อ่านเพิ่มเติมได้ที่ link นี้ ครับ

Summary

คิดว่าผู้อ่านคงพอได้เห็นภาพคร่าว ๆ ของตัว Cloud Run นี้ไปแล้วนะครับ ทั้งในเรื่องการทำงานของ service นี้, auto-scaling, วิธีการ deploy, และการคิดราคา

โดย Cloud Run นี่เหมาะกับงานหลายอย่างมากครับ ทั้งในการทำ microservice ที่ไม่ซับซ้อนมาก หรือพวก frontend หรือเป็น job เล็ก ๆ ที่ตั้งเวลาให้รัน ผ่าน Cloud Scheduler ก็ได้ครับ

ซึ่งด้วยความที่มันสามารถ deploy ได้ง่าย ไม่ต้อง config มาก คิดว่าอาจจะเหมาะกับนักศึกษาที่ต้องการ deploy งาน หรือทำ prototype แบบไว ๆ ด้วยครับ

แต่ข้อเสียก็มีเช่นมันบังคับให้ access ผ่าน HTTP เท่านั้น แล้วยังจำกัดเวลาในการรันแต่ละ request ไว้ที่ 15 นาทีเท่านั้น

ในระบบที่ซับซ้อนหน่อย Kubernetes ก็อาจจะยังเป็นตัวเลือกที่ดี

ถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

อ้างอิง
https://cloud.google.com/run
https://cloud.google.com/run/pricing
https://www.youtube.com/watch?v=xVuuvZkYiNM
https://cloud.google.com/blog/products/containers-kubernetes/when-to-use-google-kubernetes-engine-vs-cloud-run-for-containers

Google BigQuery - explore ข้อมูล Pantip ดูแบบง่าย ๆ

CopyPasteEngineer — Fri, 12 Jun 2020 13:15:33 +0000

ต่อเนื่องจากบทความคราวก่อนเรื่อง ส่องกระทู้ชาวพันทิปแบบ real-time ด้วย Google Cloud ฟรี (deploy เสร็จสรรพใน 5 นาที!) เราได้ระบบที่เก็บข้อมูล Pantip ทุก ๆ 10 นาที ลงบน Google BigQuery ซึ่งเป็น Data Warehouse บน Google Cloud Platform แล้วนะครับ ในบทความนี้จะขอแนะนำวิธีการ explore ข้อมูลที่เรามีบน BigQuery และทำ Dashboard แบบง่าย ๆ ทำเสร็จภายในไม่กี่นาที โดยใช้เครื่องมือที่มีมาใน Google BigQuery อยู่แล้ว ไม่ต้อง install อะไรเพิ่มเติมทั้งสิ้นครับ

เริ่มกันเลย

ถ้าจะทำตามไปด้วย ให้ไปทำตามขั้นตอนใน บทความก่อนหน้า ก่อนนะครับ ไม่อย่างนั้นจะไม่มี data ใน BigQuery ทำไม่นานเลยครับมีโค้ดให้เสร็จสรรพ ไม่ต้อง install อะไรลงในเครื่องเลย

พอมี data แล้วก็เริ่มจากไปที่ หน้า console ของ BigQuery ก็จะเป็นตามภาพด้านล่างนะครับ คือด้านซ้ายล่างจะเป็นส่วนที่ให้ explore Dataset ที่เรามี ส่วนกล่องข้อความตรงกลางเอาไว้ให้เราพิมพ์คำสั่ง SQL เพื่อทำการ query ข้อมูลจาก table ของเรา ออกมาแสดงได้ครับ

ตัวนี้แหละครับก็คือเครื่องมือหลักที่เราจะใช้เพื่อ explore ข้อมูลกัน โดยการเขียน SQL

เนื่องจาก BigQuery เป็น serverless data warehouse ที่ optimized มาเพื่อสำหรับการทำ analytics โดยเฉพาะครับ ทำให้เราสามารถ process ข้อมูลขนาดใหญ่ได้อย่างรวดเร็ว (ข้อมูลเป็นระดับเป็นสิบ ๆ Gigabytes ก็อาจจะใช้เวลาประมวลผลไม่กี่วินาทีเท่านั้น) และยังราคาไม่แพงมาก ไม่ต้องซื้อ hardware มาตั้งและ maintain เอง Google จะทำการ scale ให้อัตโนมัติครับ

ต่อไป จากทางด้านกล่องซ้ายล่าง กดเลือก Dataset และ Table ที่เรา scrape มา ก็จะเห็นรายละเอียดของ Table นั้น ๆ ครับ

รูปแสดง schema ของ table ตรงนี้ผมแก้จากโค้ดในบทความก่อนเล็กน้อยครับ คือให้มันเก็บข้อมูลมาทุก tag ที่มี แล้วเก็บตัวแปร tags มาด้วย เป็น array type ของ tags ใน schema เลยเป็น STRING REPEATED

ที่แถบด้านบนก็สามารถคลิกดูรายละเอียดของ Table และดูตัวอย่างข้อมูลได้ครับ

จะเห็นจากใน detail ว่าข้อมูลผมตอนนี้มีประมาณ 255,000 แถว
ทีนี้ลองมา query เพื่อดู stats ของข้อมูลเพิ่มเติมกันนะครับ

เริ่มจากลองดูช่วงของข้อมูลก่อน ว่ามีข้อมูลตั้งแต่วันไหนถึงวันไหน ก็คือหา min, max ของ field created_time ธรรมดาครับ โดยการพิมพ์คำสั่ง SQL ลงในกล่องข้อความตรงกลาง แล้วกปุ่ม เรียกใช้ ผลลัพธ์ก็จะออกมาเป็นตารางด้านล่างตามภาพนะครับ

SELECT
  MIN(DATE(created_time)) min_date,
  MAX(DATE(created_time)) max_date,
FROM SCRAPE.PANTIP

ต่อไปผมอยากรู้ว่า ในช่วง 3 เดือนนี้เนี่ย tag ไหนมีจำนวนกระทู้มากน้อยอย่างไรบ้าง
ขอไม่ลงรายละเอียด SQL มากนะครับ ไอเดียก็คือ field tags เนี่ยมันเป็น array เราต้องใช้ UNNEST() ในการ "กระจาย" มันออกมา จากนั้นก็ GROUP BY tag แต่ละ tag แล้ว count ออกมา แล้วก็ให้เรียงลำดับ ORDER ตาม count จากมากไปน้อยครับ

SELECT
  T AS tag,
  COUNT(*) AS count
FROM SCRAPE.PANTIP P
JOIN UNNEST(P.tags) T
GROUP BY tag
ORDER BY count DESC
LIMIT 10

ก็จะได้ผลลัพธ์เป็น tags 10 อันดับแรก ที่มีจำนวนกระทู้มากที่สุดในสามเดือนนี้นะครับ

จากภาพ ด้านบนก็จะมีแสดงเวลาที่ใช้ในการคำนวณด้วยนะครับ จะเห็นว่าใช้เวลาไปแค่ 1 วินาทีนิด ๆ เท่านั้น

เหมือนว่าส่วนใหญ่จะเป็นเรื่องความรักนะครับ ไม่ค่อยน่าแปลกใจเท่าไหร่ 555 แล้วก็มี COVID ก็ติดอันดับด้วย

ทีนี้เราลองหยิบมาดูด้วยตาว่า tag COVID นี่เขาคุยอะไรกันนะครับ

SELECT
  created_time,
  title,
FROM SCRAPE.PANTIP P
WHERE EXISTS(
  SELECT TRUE FROM UNNEST(P.tags) T
  WHERE T = 'โรคติดเชื้อไวรัสโคโรนาสายพันธุ์ใหม่_2019_(COVID-19)'
)
ORDER BY created_time DESC

ถ้าเป็นของไม่กี่วันนี้ก็ดูไม่ค่อยมีอะไรนะครับ เป็นประมาณอัพเดตข่าวกันมากกว่า

แต่ถ้า scroll ย้อนกลับไปประมาณเดือน 3 ก็จะเห็นกระทู้ประมาณว่า ถ้าติดโควิทจะทำยังไงดี หรือแชร์วิธีการปฏิบัติตัวต่าง ๆ เป็นสังคมที่ค่อนข้าง active เลยครับ

ทีนี้ถ้าจะ explore ดูข้อมูลโดยการไล่ดูตารางแบบนี้คงจะไม่สะดวกใช่ไหมครับ ต่อไปเราลองสร้าง graph เพื่อ visualize ข้อมูลออกมาดูกันดีกว่า

ไม่ต้องไปเปิดโปรแกรมไหนเพิ่มเลยครับ BigQuery มีเครื่องมือที่เอาไว้ช่วย visualize และทำ dashboard แบบง่าย ๆ ไว้อยู่แล้ว ชื่อว่า Google Data Studio เราสามารถเอา result จากคำสั่ง SQL ที่เรารัน เข้าไปใน Data Studio ได้เลย โดยการคลิกที่ปุ่ม สำรวจข้อมูล ด้านบน result แล้วเลือก สำรวจด้วย Data Studio ตามในภาพครับ

ทีนี้เราก็จะเด้งมาที่หน้าของ Data Studio ซึ่งพื้นที่ทางด้านซ้ายนี่จะเป็นที่เอาไว้สร้าง dashboard แบบ drag-and-drop ซึ่งตอนนี้ก็จะค้างข้อมูล "กระทู้ COVID" ที่เรา query เอาไว้เมื่อกี้อยู่ ส่วนด้านขวาคือเป็นเหมือน tools box ครับให้เราสามารถเลือกประเภทของ chart และปรับค่าค่าต่าง ๆ ได้ เช่นตัวแปรที่จะเอามาแสดง จำนวน dimensions สี แสงเงาต่าง ๆ

ทีนี้สมมุติว่าผมอยากจะ plot จำนวนของกระทู้ (ซึ่งก็คือกระทู้ใน tag COVID ที่เรา query มาเมื่อกี้) อย่างแรกก็เลือกประเภทของ chart เป็น "อนุกรมเวลา" (time series) แล้วก็ให้ "มิติข้อมูล" (dimension) คือแกน X เป็น created_time ส่วน "เมตริก" (metric) คือแกน Y เป็น Record Count ตามภาพ

พอเลือกเสร็จปุ๊ปก็จะเห็นว่าพื้นที่ dashboard ก็จะโหลดใหม่ได้เป็น time series plot จำนวนของกระทู้กับเวลาตามที่เราต้องการ และเป็น interactive ด้วย คือเราสามารถจะเลื่อน cursor ไปชี้ เพื่อให้แสดงรายละเอียดข้อมูลของ data point ออกมาได้

จะเห็ฺนว่า data studio ช่วย aggregate ข้อมูลให้เราเป็นระดับ "วัน" อัตโนมัติด้วยนะครับ เพราะ created_time นี่เดิมทีเป็นระดับวินาทีเลย ถ้า plot ไปตรง ๆ ก็จะดูไม่รู้เรื่อง แต่ Data Studio คิดส่วนนี้ไว้ให้เราแล้ว เลยไม่ต้องไปแก้เองเลยครับ

จะเห็นว่าด้วยเครื่องมือสองอย่างนี้ ช่วยให้เราทำงานกับข้อมูลขนาดใหญ่ได้รวดเร็วมากเมื่อเทียบกับการโหลดข้อมูลไป process ใน Python แล้วยังสามารถ visualize ได้ง่ายมากอีกด้วย แค่ลาก ๆ วาง ๆ แปปเดียว

แต่ข้อเสียก็คือต้องใช้ SQL คล่องหน่อยครับ และอาจจะไม่สามารถคำนวณบางอย่างที่ซับซ้อน ๆ ได้

Demo

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

1. จำนวนกระทู้แต่ละ tag ตามเวลา

SELECT
    created_time,
    T AS tag,
FROM SCRAPE.PANTIP P
JOIN UNNEST(P.tags) AS T
WHERE T IN ('ปัญหาความรัก', 'หุ้น', 'ประสบการณ์ความรัก', 'ปัญหาชีวิต', 'ความรักวัยรุ่น')

2. สัดส่วนของแต่ละ tag

SELECT
    T AS tag,
    COUNT(*) AS count
FROM SCRAPE.PANTIP P
JOIN UNNEST(P.tags) AS T
WHERE T IN ('ปัญหาความรัก', 'หุ้น', 'ประสบการณ์ความรัก', 'ปัญหาชีวิต', 'ความรักวัยรุ่น')
GROUP BY 1

3. ช่วงเวลาที่โพส

SELECT
    EXTRACT(HOUR FROM created_time) AS hour_num,
    CONCAT(EXTRACT(HOUR FROM created_time), '.00น.') AS hour,
    T AS tag,
    COUNT(*) AS count
FROM SCRAPE.PANTIP P
JOIN UNNEST(P.tags) AS T
WHERE T IN ('ปัญหาความรัก', 'หุ้น', 'ประสบการณ์ความรัก', 'ปัญหาชีวิต', 'ความรักวัยรุ่น')
GROUP BY 1, 2, 3

พอได้ charts ที่เราสนใจออกมาแล้วเราสามารถเอามารวมกัน ให้กลายเป็น dashboard อันหนึ่งได้อีกด้วย ใน Data Studio mode Report

ซึ่ง dashboard อันนี้ พอทำเสร็จแล้วก็สามารถที่จะแชร์ให้คนอื่นเข้ามาดู หรือเข้ามาแก้ไขได้ (คล้าย ๆ Google Docs นั่นเอง) และยัง update ตามข้อมูลบน BigQuery อัตโนมัติอีกด้วย ไม่ต้องมานั่งสร้าง dashboard ใหม่ทุกครั้งที่เพิ่มข้อมูล สะดวกมาก ๆ ทีเดียว

Summary

บทความนี้ก็แนะนำ Google BigQuery และ Data Studio สำหรับการ explore ข้อมูลคร่าว ๆ นะครับ ขออภัยถ้าเลือกใช้ chart บางอันผิดประเภทไปหน่อย อย่างเช่น pie chart ในข้อ 2 ควรจะใช้เป็น bar chart มากกว่า ถึงจะเปรียบเทียบความแตกต่างได้ชัดเจนกว่า หรืออย่างข้อ 3 ควรจะ normalize ในแต่ละ tag ก่อน เพื่อให้เทียบสัดส่วนได้ง่ายกว่า เป็นต้น แต่เนื่องจากบทความนี้เป็นแค่ demo เล็ก ๆ เท่านั้น เลยเอาแบบที่ง่าย และให้เห็น chart หลาย ๆ ประเภทมากกว่าครับผม

สำหรับตัว BigQuery และ Data Studio นี้ ขอแนะนำมาก ๆ เลยครับ ทำงานได้รวดเร็ว เพราะ dashboard ที่ทำด้านบนเนี่ย ใช้เวลาทำประมาณไม่ถึงครึ่งชั่วโมงเท่านั้นครับ สะดวกมาก ๆ แล้วยังมี features ที่น่าสนใจอื่น ๆ อีกเยอะครับ ไว้ในบทความหน้า ๆ จะมาแนะนำกันต่อนะครับ

ถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

Python Web Scraping part 4 - ทำไมถึง scrape บางเว็บไม่ได้??? 7 เทคนิคง่าย ๆ ให้ scrape เว็บส่วนใหญ่ได้ลื่นปรื๊ด

CopyPasteEngineer — Thu, 14 May 2020 11:29:38 +0000

ใน parts ก่อน ๆ เราก็ได้พูดถึงเรื่องการ scrape เว็บแบบง่าย ๆ ไปแล้วนะครับ ซึ่งผู้อ่านบางท่านอาจจะไปลองทำดูเองกับเว็บอื่น ๆ แล้วก็อาจจะพบว่ามันใช้ไม่ได้ ทำไม content สิ่งที่ scrape มา ถึงไม่เหมือนกับที่แสดงบน browser ล่ะ??? หรือบางทีพอจะดูดข้อมูลก็จะพบ error บอกว่า Forbidden บ้าง

สาเหตุก็เป็นไปได้หลายอย่างครับ อาจจะเป็นเพราะเราส่ง parameter บางอย่างไปไม่ครบ, กำหนด header ไม่ถูก, บนหน้าเว็บมีการใช้ javascript ในการ render, หรือเขาอาจจะหาวิธีกันไม่ให้เรา scrape จริง ๆ ก็ได้

ในบทความนี้จะขอแนะนำเทคนิคง่าย ๆ ที่อาจจะช่วยให้สามารถ scrape เว็บส่วนใหญ่ได้โดยไม่ติด error page นะครับ และก็จะสาธิตให้ดูโดยการ scrape เว็บต่าง ๆ ด้วยเทคนิคที่แนะนำไปนะครับ

โค้ดทั้งหมดที่ใช้ในบทความ แชร์ไว้ใน Google Colab link นี้ นะครับ สามารถลองรันและแก้โค้ดดูพร้อม ๆ กับอ่านบทความไปได้เลย วิธีการรันก็เขียนอยู่ใน link แล้วนะครับ

Scraping Techniques

1. ถ้าเว็บมีการใช้ javascript เพื่อ render ให้ลองหาตัว API ดู

เพราะว่าเว็บส่วนใหญ่นะครับ จะไม่ได้ฝังข้อมูลลงในหน้าเว็บตรง ๆ ครับ แต่จะใช้ html เป็นเหมือนแค่ template แล้วใช้ javascript ในการโหลดข้อมูลเข้ามาจาก API ที่ทำแยกไว้ต่างหากแทน ในกรณีนี้แทนที่เราจะโหลดหน้าเว็บหลักที่มีแค่โครง HTML เข้ามา ก็ให้เราโหลดเฉพาะตัวข้อมูลจาก API โดยตรงแทนเลยนั่นเองครับ

ตัวอย่างเช่น ในเว็บ www.skooldio.com/browse ถ้าเราเข้าไปด้วย browser ของเรา ก็จะเห็น course ต่าง ๆ ตามปกติครับ แต่ถ้าเราลอง requests ด้วย python แบบที่เราเคยทำใน parts ก่อน ๆ ดู ก็จะพบว่ามันไม่ได้มีข้อมูลของ course ต่าง ๆ อยู่นะครับ

url = 'https://www.skooldio.com/browse'
resp = requests.get(url)

print('SQL for Data Analytics' in resp.content.decode('utf-8'))

# Output: False

หรือถ้าเราอยากลองเช็คดูให้แน่ใจ ก็สั่งให้ print HTML ที่ได้มาดูด้วยตาก็ได้ครับ

print(resp.content.decode('utf-8'))

ถ้าลองรันดู ก็จะเห็นว่าเป็นแค่โค้ด HTML กับ css เท่านั้น ไม่ได้มีเนื้อหาอะไรที่เราต้องการอยู่เลย

เป็นเพราะว่าข้อมูลของ course ต่าง ๆ จะถูกโหลดมาทีหลัง ด้วย API api.skooldio.com/store/graphql นั่นเองครับ ดังนั้นเราจึงเปลี่ยนไปดึงข้อมูลจากตัว API แทน อย่างใน code ตัวอย่างด้านล่างผมดึง courses ในหมวดของ "คอร์สออนไลน์" จาก API มาครับ

url = 'https://api.skooldio.com/store/graphql'

payload = {"operationName": "products",
           "variables": {"type": "COURSE", "searchParams": {}},
           "extensions":{"persistedQuery": {"version": 1,
                                            "sha256Hash": "2521f2486bdbf3e7d44a5ccb706699e2c8cca1aeaa8f42edd5b17f96a08b7b79"}}}

headers = {'content-type': 'application/json'}

resp = requests.post(url, data=json.dumps(payload), headers=headers)

data = resp.json()

ตรงนี้ผมใส่ header เข้าไปด้วย เพื่อบอกว่า content เป็นประเภท json นะครับ ถ้าไม่ใส่ตรงนี้ให้ถูกต้องก็จะ error ครับ

ถ้าเราลอง print ตัว data ออกมาดูก็จะเห็นเป็น dict ที่เก็บข้อมูลของ course ต่าง ๆ เอาไว้อย่างเป็นระเบียบเรียบร้อยแล้วนะครับ นี่ก็ถือเป็นข้อดีอีกอย่าง เวลาที่ web เป้าหมายมี API ให้เราใช้นะครับ 55

ทีนี้ผู้อ่านอาจจะสงสัยว่าผมทราบได้อย่างไรว่าต้องใส่ payload เป็นอย่างไร และต้องมี headers อะไรบ้างใช่ไหมครับ วิธีการก็คือผมใช้ DevTools ตัวหนึ่งของ Google Chrome ชื่อว่า Chrome Network Inspector ในการ monitor network ครับ ว่าตั้งแต่ที่โหลดหน้าเว็บ Skooldio มาเนี่ย มีการโหลดไฟล์อะไรบ้าง ซึ่งเราก็จะสามารถดูได้หมดเลยครับ ตั้งแต่ ไฟล์ชื่ออะไร content เป็นอย่างไร มี headers อะไร payload อะไร สิ่งที่ต้องทำก็แค่ "copy มาถูก" เท่านั้นครับ

ซึ่งในบทความนี้ ก็จะสอนว่าจะ "copy มาให้ถูก" ได้อย่างไรก่อน แล้วในบทความหน้า ๆ เราจะได้เล่นเจ้า Network Inspector แน่นอนครับ

ภาพ Network Inspector (แทบทางขวา) โชว์ payload ของตัว API

2. ลองใส่ user-agent ปลอม

ในบาง website ก็อาจจะมีกลไกที่ป้องกัน bot ไม่ให้มา scrape ข้อมูลแตกต่างกันไปนะครับ แบบที่ง่ายที่สุดก็คือ block user-agent ครับ

user-agent เนี่ยเอาไว้บอกกับ server ว่า browser ที่เราใช้อยู่เนี่ยเป็น browser ตัวไหน เช่นเป็น Chrome หรือ Firefox หรือเป็น Safari ใน IOS เป็นต้น ซึ่งมีประโยชน์คือเผื่อบางทีทาง server อาจจะอยาก render หน้าเว็บให้ IOS แตกต่างจาก Android เป็นต้น

แล้วถ้าเรา requests จาก Python ล่ะ??? คำตอบก็คือ server ก็จะรู้นั่นแหละครับว่าเราเป็น Python user-agent ก็จะเป็นคล้าย ๆ แบบนี้

{
    'user-agent': 'python-requests/2.23.0'
}

เพราะฉะนั้นบาง website อนุญาตให้เข้าถึงได้แค่เฉพาะพวก browser จริง ๆ เท่านั้น

แต่เราก็มีวิธีหลอก server อยู่ครับ ง่ายมาก ก็แค่แก้ header ตรงนั้นให้เป็น Google Chrome นั่นเอง

{
    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36'
}

มาดูตัวอย่างเว็บกันดีกว่าครับ
อย่างเช่น API การ search ของ Shopee (shopee.co.th/api/v2/search_items) เป็นต้น

ก็คือถ้าเรา requests เข้าไปตรง ๆ แบบนี้จะใช้ไม่ได้ครับ

url = 'https://shopee.co.th/api/v2/search_items/?by=relevancy&keyword=ไฟฉาย&limit=50&newest=0&order=desc&page_type=search&version=2'

resp = requests.get(url)

ถ้าเป็นในเว็บส่วนใหญ่ก็จะแจ้งเป็น error code ออกมา เช่น 400 Bad Request เป็นต้น

แต่สำหรับกรณีของ Shopee จะพิเศษหน่อยครับ คือ เราจะยังได้ status code เป็น 200 อยู่ คือไม่มี error นะ แต่ข้อมูลที่ส่งมาจะเป็น None หมดครับ

print('status code:', resp.status_code)
print('count of results:', resp.json()['total_count'])

# Output: status code: 200
#         count of results: None

resp.json()

# Output: {'adjust': None,
#          'algorithm': None,
#          'error': None,
#          'hint_keywords': None,
#          'items': None,
#          'json_data': None,
#          'nomore': None,
#          'price_adjust': None,
#          'query_rewrite': None,
#          'reserved_keyword': None,
#          'show_disclaimer': None,
#          'suggestion_algorithm': None,
#          'total_ads_count': None,
#          'total_count': None,
#          'version': 'b1c94828d525e526ff969f451cc3ac33'}

เพราะว่า server กัน user-agent ของเรานั่นเองครับ ในกรณีนี้แค่ใส่ user-agent ใหม่ก็เรียบร้อยครับ

headers = {'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36'}

resp = requests.get(url, headers=headers)

print('status code:', resp.status_code)
print('count of results:', resp.json()['total_count'])


# Output: status code: 200
#         count of results: 81724

3. ลองตรวจสอบ headers อื่น ๆ เพิ่มเติม

ถ้าทำข้อด้านบน ๆ ไปแล้วยังไม่ได้ผลก็ให้ลองตรวจสอบวิธีการ requests อีกครั้งนะครับ ว่าลืมใส่ headers อะไรไปหรือเปล่า โดยวิธีการตรวจสอบก็คือใช้ Network Inspector ที่พูดถึงไปด้านบนนั่นแหละครับ ดูว่ามี headers ไหนที่อาจจะจำเป็นอีกบ้าง ตรงนี้อาจจะต้องใช้ความรู้เรื่องการทำเว็บเล็กน้อยนะครับ หรือไม่ก็ skill การเดาขั้นเทพนิดนึง 5555

อย่างเช่นเว็บ pantip ที่เคย scrape ให้ดูในบทความก่อนนะครับ

ทีแรกผมก็ลอง requests ไปที่ตัว API ตรง ๆ ดูก่อน

url = 'https://pantip.com/api/forum-service/forum/tag_topic?tag_name=ปัญหาความรัก&limit=50'
resp = requests.get(url)

print('status code:', resp.status_code)

# Output: status code: 401

ก็พบว่ามันไม่ได้นะครับ

ก็เลยลองเช็คที่ Network Inspector ดูอีกที ก็เจอว่าใน header มี field ชื่อ authorization อยู่ด้วย ซึ่งเก็บ credential สำหรับการ access API ไว้อยู่ครับ

พอใส่ authorization ไปใน headers ด้วย ก็ใช้ได้เลยครับ

headers = {'authorization': 'Basic dGVzdGVyOnRlc3Rlcg=='}
resp = requests.get(url, headers=headers)

print('status code:', resp.status_code)

# Output: status code: 200

ซึ่งจริง ๆ ในหลาย ๆ ครั้ง header authorization เนี่ย ไม่ได้เป็นค่าคงตัวแบบนี้นะครับ บางทีมันอาจจะถูก generate ใหม่เรื่อย ๆ หรืออาจจะต้อง requests ไปขอ token จากอีก endpoint หนึ่งก่อน แล้วอาจจะมีเวลาหมดอายุอีก ต้องคอยขออันใหม่เรื่อย ๆ ก็มี แล้วแต่เว็บเลยครับ เพราะฉะนั้นการ monitor network เพื่อดูว่า data มัน flow อย่างไรนี่สำคัญมาก แล้วก็ไม่ง่ายเท่าไหร่นะครับ เดี๋ยวจะพูดถึงเพิ่มเติมในบทความเกี่ยวกับ Network นะครับ

4. สร้าง Session เพื่อเข้าถึงข้อมูลสำหรับสมาชิก

ในบางเว็บ ข้อมูลบางอย่าง page บาง page จะสามารถเรียกดูได้เฉพาะสมาชิกเท่านั้นครับ ถ้าเรา requests ไปโดยที่ยังไม่ได้ login ก็จะไม่สามารถดูข้อมูลนั้นได้ครับ

วิธีการก็คือ อย่างแรก แน่นอน เราต้องเป็นสมาชิกก่อนครับ ถึงจะดูได้ ไม่ได้จะสอนให้ hack เว็บเขานะครับ

ต่อไปเราก็จะใช้ Session ครับ สำหรับการเก็บ state การสร้าง Session ขึ้นมาอันหนึ่งเนี่ย เหมือนเราเปิด web browser ขึ้นมาหน้าหนึ่งแหละครับ มันจะสามารถจำ cookies จำ settings ต่าง ๆ ไว้ให้เราได้ และถ้าทำการ login เสร็จครั้งหนึ่งแล้ว การ request ครั้งต่อ ๆ ไป เว็บเป้าหมายก็จะเห็นว่าเราเป็นสมาชิกแล้วนั่นเองครับ

ดูตัวอย่างจากเว็บ skilllane นะครับ ที่ใช้เว็บนี้เพราะเราสามารถสมัครสมาชิกได้ง่ายดีครับ สามารถลองสมัครสมาชิกดูแล้วทำตามได้เลยครับ (เขาไม่ได้มาจ้างให้ผมเพิ่มยอดสมาชิกให้นะครับ555)

โดยเป้าหมายคือหน้า mycourses นะครับ ซึ่งดูได้เฉพาะสมาชิกเท่านั้น

ถ้า requests เข้าไปตรง ๆ ก็จะได้ status code เป็น 200 นั่นแหละครับ แต่เราไม่สามารถเข้าถึงหน้านั้นได้จริง ๆ สังเกตุได้จาก content ที่ได้มา ไม่มีคำว่า "คอร์สของฉัน" นะครับ

url = 'https://www.skilllane.com/user/mycourses'

resp = requests.get(url)

print('status code:', resp.status_code)
print('accessable:', 'คอร์สของฉัน' in resp.text)

# Output: status code: 200
#         accessable: False

ดังนั้นเราจึงต้องสร้าง Session ขึ้นมา โดยใช้คำสั่ง requests.Session() และทำการ login เข้าไปก่อน โดยส่ง requests ผ่าน session ของเราไปที่ endpoint sign_id ครับ

email = ...     # ใส่ email ที่สมัครไว้
password = ...  # ใส่ password

data = {
    'utf8': '✓',
    'user[email]': email,
    'user[password]': password,
    'user[last_visit_url]': '',
    'user[redirect_method]': '',
    'button': '',
}

url = 'https://www.skilllane.com/user/sign_in'

session = requests.Session()
resp = session.post(url, data=data)  # ใช้ session.post แทน requests.post
print('login ok:', resp.status_code == 200)

# Output: login ok: True

พอ login สำเร็จแล้ว ตอนนี้ถ้า requests ด้วย session เดิมไป เว็บ skilllane ก็จะจำได้แล้วครับว่าเป็นเรา เพราะฉะนั้นก็จะดูหน้า mycourses ได้

# ลองอีกครั้ง
url = 'https://www.skilllane.com/user/mycourses'

resp = session.get(url)  # ใช้ session.get แทน requests.get

print('status code:', resp.status_code)
print('accessable:', 'คอร์สของฉัน' in resp.text)

# Output: status code: 200
#         accessable: True

5. Official API

เอามาเขียนไว้ข้อ 5 แต่จริง ๆ ก่อนจะเริ่ม scrape เว็บใด ๆ นะครับ ควรเช็คดูก่อนว่าเว็บนั้นมี official API ให้เราใช้หรือเปล่า ถ้ามีก็แค่เอาของเขามาใช้ง่ายกว่าเยอะครับ555

ซึ่งเว็บดัง ๆ ส่วนใหญ่ก็มีให้ใช้ทั้งสิ้นครับ เช่น Facebook Twitter Instagram Google ไม่ต้องเสียเวลางมหาวิธี scrape เลยครับ

ข้อเสียก็คือต้องยอมรับ constraints ต่าง ๆ ของ API เขาครับ เช่น Twitter อาจจะ limit ไว้ว่า ใน 15 นาที ห้าม requests มาเกิน "เท่านี้" ครั้งนะ หรืออย่าง Facebook ก็จะไม่อนุญาตให้เก็บข้อมูลในส่วนที่เป็น private เป็นต้น

6. เปลี่ยน IP ด้วย Proxy

บนเว็บทั่ว ๆ ไปอาจจะไม่ค่อยเจอนะครับ แต่บางเว็บเนี่ย ถ้าเราไป requests มาก ๆ ทำพฤติกรรมผิดปกติ ๆ ฉี่ ๆ เขาถึงขั้นจำ IP เราไว้ว่า IP นี้น่าสงสัย หรืออาจจะดูด้วยบริการของ Google ที่ detect พฤติกรรมการท่องเว็บที่น่าสงสัย แล้วก็ทำการ block ไม่ให้เราใช้งานได้เลยก็ได้นะครับ

วิธีหนึ่งที่อาจจะช่วยได้บางทีก็คือใช้ Proxy ครับ Proxy นี่เป็นเหมือนคอมพ์อีกเครื่อง ที่มี IP และประวัติการใช้ internet ของตัวเองนะครับ วิธีการใช้ Proxy ก็คือ แทนที่เราจะ requests ไปที่เว็บเป้าหมายโดยตรงนะครับ เราส่ง requests ไปให้ Proxy แทน แล้วให้ Proxy ข่วย requests ไปที่เป้าหมายแทนเราครับ เพราะฉะนั้นทางเว็บเป้าหมายก็จะไม่รู้ว่าจริง ๆ เป็นเครื่องเรา requests ไป

ซึ่งตัว Proxy นี่จริง ๆ ก็มีของฟรีให้ใช้อยู่นะครับ แต่มันก็จะช้าเพราะต้องแชร์กับคนอื่น ๆ จำนวนมาก แล้วก็อาจจะไม่ได้มีประโยชน์เท่าไหร่ด้วย เพราะคนอื่น ๆ ที่ใช้เนี่ย ส่วนใหญ่ก็คงเป็น bot scrape เหมือนกับเราแหละครับ เพราะงั้น Proxy ฟรี ก็คงโดนแบนไปก่อนตั้งแต่เรายังไม่ได้ใช้ด้วยซ้ำ

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

ส่วนวิธีการใช้ สมมุติว่าซื้อมาแล้วและ setup บนเครื่องเราเรียบร้อยแล้ว เราก็จะได้ IP ของ Proxy มานะครับ วิธี requests จาก Python ก็แค่ส่ง proxies เข้าไปตอน requests เท่านั้นเองครับ


proxies = {
 “http”: “http://11.11.11.11:1234”,
 “https”: “https://11.11.11.11:1234”,
}
resp = requests.get(“http://target-website.com”, proxies=proxies)

ซึ่งปกติเราก็จะซื้อเอาไว้หลาย ๆ IP นะครับ แล้วก็วนลูปเปลี่ยนสลับกันไปเรื่อย ๆ ครับ

7. Automated Web Browser

สุดท้ายถ้าหลาย ๆ เทคนิคก็ยังไม่ได้ผลอีก ก็มีอีกตัวเลือกหนึ่งครับ คือใช้ web browser นี่แหละทำ แต่แทนที่เรานั่งกดเอง เราเขียน script บอกเอาครับ ว่าจะให้เลื่อน mouse ไปที่ element ไหน รอเป็นเวลากี่วินาที คลิกที่ปุ่มไหน จะให้กดอะไร ให้พิมพ์อะไร ก็เขียน script ให้มันทำให้ได้เลยครับ ถ้าเขียน script ได้เนียนพอ ก็อาจจะสามารถหลอกบางเว็บได้เหมือนกันนะครับ

สำหรับใน Python ตัวที่ผมใช้ก็คือ Selenium สามารถลองไปศึกษาต่อดูได้ เนื่องจากต้อง setup เยอะ และมีเนื้อหาพอสมควรจะขอยังไม่พูดถึงในบทความนี้นะครับ

Summary

ขอติดเรื่อง Network Inspector กับ Selenium เอาไว้ก่อนนะครับ บทความนี้เอาแค่ให้เห็นภาพเฉย ๆ

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

และถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

Google Cloud + Scraping Project: ส่องกระทู้ชาวพันทิปแบบ real-time ด้วย Google Cloud ฟรี (deploy เสร็จสรรพใน 5 นาที!)

CopyPasteEngineer — Tue, 28 Apr 2020 11:02:57 +0000

อย่างที่เคยเล่าในบทความก่อน ๆ เรื่องการ scrape ครับ มี use-case หลายอย่างที่สามารถทำได้ เช่น ใช้เพื่อสร้าง dataset สำหรับ train machine learning model ใช้เพื่อทำงานวิจัย หรือใช้ทำ social monitoring เพื่อเก็บรวบรวม comment จากลูกค้าไปพัฒนา product ของบริษัทต่อไป

บทความนี้เป็นบทความสั้น ๆ (แต่พอเขียน ๆ ไปแล้วก็ไม่สั้นเท่าไหร่ 555) ที่จะทำการ deploy Python script ขึ้นบน Google Cloud เพื่อทำการ scrape เว็บแบบอัตโนมัติ พร้อมทั้งพูดถึง services ต่าง ๆ ของ Google Cloud Platform แบบคร่าว ๆ (คร่าว ๆ จริง ๆ ครับ แล้วถ้ามีโอกาสก็จะมาอธิบายในรายละเอียดของแต่ละ service แยกกันไปอีกที)

บทความจะแบ่งเป็น 2 ส่วนนะครับ ส่วนแรกจะอธิบายเกี่ยวกับ Google Cloud services และ architecture ที่เราใช้ สั้น ๆ และส่วนที่ 2 ก็จะมี script ให้ สามารถนำไป deploy ได้ทันทีภายใน 5 นาทีเท่านั้นครับ

โดยในบทความนี้จะ focus ที่ตัว Google Cloud เป็นหลักนะครับ สำหรับท่านที่สนใจเกี่ยวกับการ scrape ทางเพจของเรา Copy Paste Engineer ก็กำลังทำบทความสอนอยู่ ทยอยอัพเรื่อย ๆ สามารถติดตามได้นะครับ อ่าน part 1 ได้ที่นี่

Cloud Platform

สำหรับท่านที่ไม่ทราบ พูดแบบไม่เป็นทางการ ก็คือ Cloud Platform เนี่ย เหมือนเป็น "บ่อ" ใหญ่ ๆ ครับ ที่มี resource อยู่แบบไม่จำกัด หรือมีเยอะมาก เช่นเป็นบ่อของ CPUs ก็มี CPUs กองเอาไว้รวมกันอยู่เต็มไปหมด และก็มีบ่อของ hard disks มีบ่อของ RAMs ...

ทีนี้ Cloud Platform เจ้าต่าง ๆ เนี่ยก็จะเสนอให้เราเช่า resource ต่าง ๆ ของเขาได้ โดยให้เรา request ขอเช่าไปผ่านหน้าเว็บได้เลย เช่น เราอยากได้ VM สักตัวหนึ่งมา deploy web application ของเรา เราก็แค่เข้าไปที่หน้าเว็บของ Cloud Provider อย่างเช่นใน Google Cloud บนหน้าเว็บเราก็สามารถคลิกเลือก spec ได้ว่าอยากได้ RAM กี่ GB มี CPUs กี่ cores จะเอา hard disk กี่ GB จะเอา OS เป็นอะไร พอกรอกข้อมูลเสร็จก็รอไม่กี่นาที เราก็จะมี VM ตาม spec ที่ระบุไปมาให้ใช้ผ่าน SSH protocol

ซึ่ง Cloud Provider ก็จะมีระบบ Cloud Manager ที่ใช้จัดการกับ request การเช่า resource ต่าง ๆ ภายใน "บ่อ" ให้อัตโนมัติ คือระบบก็จะไปหา physical resource ตามที่เราต้องการมาเช่น RAM, CPUs, และ disks แล้วก็เอา VM ไปลง จากนั้นก็เปิด access ให้กับเราเข้าใช้งาน และถ้าเราต้องการจะปรับเปลี่ยน spec ของ VM เรา เช่นอยากเพิ่ม RAM จาก 8 GB เป็น 16 GB ก็สามารถทำได้ผ่านหน้าเว็บเช่นกัน ระบบ Cloud Manager ก็อาจจะทำการย้าย VM ของเราไป physical machine ที่มี resource เพียงพอให้เราใช้ได้ภายในเวลาไม่กี่นาที

และนอกจากการเช่า resource โดยตรง ซึ่งเป็นบริการพื้นฐานของ Cloud Platform แล้ว Cloud Provider แต่ละเจ้าก็จะมี services ที่เป็น high-level ขึ้นมาอีกแตกต่างกันไป

เช่น บริการ Platform as a Service (PaaS) คือแทนที่เราจะเอา VM เปล่ามา install Python เอง install dependencies ต่าง ๆ setup ต่าง ๆ เอาเอง เราก็แค่บอกบริการ PaaS ว่า เราจาก deploy application ภาษา Python นะ! ทาง Cloud ก็จะจัดเตรียม environment สำหรับการทำ application ภาษา Python ไว้ให้ เราก็แค่เอา code แปะเข้าไป หรือ upload container ขึ้นไปก็ใช้งานได้ทันที

หรือแทนที่เราจะต้อง install และ setup Database ด้วยตัวเอง Provider บางเจ้าก็จะมีบริการให้เลย คลิก ๆ สองสามทีก็ได้เครื่อง VM ที่มี Database ติดตั้งไว้เรียบร้อย พร้อมให้ใช้งานได้เลยครับ

และยังมี service ที่เป็น Serverless ต่าง ๆ ที่เราสามารถ develop application ของเราได้ โดยไม่ต้องกังวลเรื่องตัว VM เลย คือ คิดสะว่าไม่มีเครื่อง เพราะ Cloud Provider จะเป็นคน manage ตัว VM ให้ทั้งหมด รวมถึงอาจจะทำ auto-scaling ให้ด้วย เป็นต้น

ตัวอย่าง Google Cloud services บางส่วน จากหนังสือ Building Google Cloud Platform Solutions

Google Cloud Services

สำหรับ services ใน Google Cloud Platform ทั้งหมดนี่ก็มีเยอะมากนะครับ ในบทความนี้จะแนะนำเฉพาะ services ที่ต้องใช้ในการ deploy code ของเรา แบบคร่าว ๆ ไว ๆ เท่านั้นนะครับ ส่วนรายละเอียดของแต่ละอย่างจริง ๆ เนี่ย คิดว่าถ้ามีโอกาสจะแนะนำเพิ่มเติมในบทความต่อ ๆ ไปครับ services ที่นำมาแนะนำได้แก่

Cloud Functions
Cloud Scheduler
Cloud Pub/Sub
Cloud Datastore
BigQuery

Cloud Functions

Cloud Functions เป็น service แบบ serverless ตัวหนึ่ง ที่ช่วยเชื่อม service ต่าง ๆ ของ Google Cloud เข้าด้วยกัน เหมาะสำหรับ deploy script งานเล็ก ๆ ที่จะถูกรันเมื่อมี "event" บางอย่างครับ ตัวอย่าง "event" เช่น มี HTTP requests เข้ามาที่ Cloud Function, มีการ update ข้อมูลใน storage, หรือมี message จาก Pub/Sub (เดี๋ยวจะพูดถึงต่อไปครับ)

ยกตัวอย่างเช่น ในบางครั้งเราอาจจะอยาก export ข้อมูลจาก database ลงใน data warehouse ทุก ๆ วัน เวลาเที่ยงคืน เพื่อให้ฝ่าย BI นำไป analyze ในเช้าวันถัดไปได้ ถ้าต้องให้ Data Engineer ไปรอกด export ข้อมูลเองทุกวันตอนเที่ยงคืน น่าจะลำบากนะครับ วิธีแก้ก็คือเราสามารถเขียน script การ export ข้อมูลใส่ Cloud Functions เอาไว้ แล้วก็ตั้งเวลาให้ทำงานทุก ๆ วันตอนเที่ยงคืน Data Engineer ของเราก็จะมีเวลาพักผ่อนมากขึ้นแล้วครับ

หรือสมมุติว่าใน Google Cloud Platform ของเรามี VMs อยู่หลายตัว แล้วเราอยากให้ VMs เหล่านี้ เปิดทุก ๆ วันจันทร์ ตอน 9:00น. และปิดทุก ๆ วันศุกร์ ตอน 21:00น. แทนที่เราจะให้พนักงานมานั่งเปิด-ปิดเอง มันก็เสียเวลาใช่ไหมครับ แต่ด้วย Cloud Functions เราสามารถที่จะใส่ script สำหรับ เปิด-ปิด VMs พวกนั้นเอาไว้ แล้วตั้งเวลาให้มันทำงานตามที่กำหนดได้นั่นเอง

หรือแม้แต่การใช้ Cloud Functions ในการทำเป็น backend endpoint อันเล็ก ๆ สำหรับ query ข้อมูลจาก database, insert data, หรือ clean data ก็ทำได้ครับ

ตัวอย่างการใช้ Cloud Functions ในการทำ Slack notification คือ เมื่อมีคน push commit ใน git ของเรา ให้ Github push "event" มาที่ Cloud Functions เพื่อให้ Cloud Functions ได้ process และส่งการแจ้งเตือนไปที่ Slack
จาก https://cloud.google.com/functions

เนื่องจาก เราสามารถ trigger Cloud Functions ให้ทำงานได้หลายทาง (มี event ที่ใช้ trigger หลายอย่าง) และเราไม่ต้อง manage ตัว server เอง (serverless) สามารถทำ auto-scaling ได้เอง และราคาถูก จึงทำให้มีคนนำเอา cloud function ไปประยุกต์ใช้งานหลายอย่างมาก ทั้งในด้าน Data processing, Webhooks, หรือ IoT แต่ Cloud Functions ก็มีข้อจำกัดเล็กน้อยเช่นในเรื่องของขนาด Memory ในแต่ละ instance และ execution time คือ script ต้องใช้ RAM ได้สูงสุดแค่ 2GB และทำการประมวลผลได้มากสุดไม่เกิน 540 วินาทีเท่านั้น

Cloud Scheduler

Cloud Scheduler ก็ตามชื่อเลยครับ คือเป็นตัวตั้งเวลา เพื่อสร้าง "event" บางอย่างขึ้นมา ซึ่งในที่นี้จะใช้เป็นตัวที่คอยสร้าง Pub/Sub event เพื่อ trigger Cloud Functions ให้ทำงานครับ (เช่น ทุก ๆ 3 นาที, ทุก ๆ 6 ชั่วโมง, หรือ ทุก ๆ 7 วัน) ถ้าเปรียบเทียบ ก็เหมือนการเขียน cron job บน Linux server นั่นเองครับ (แถมวิธีการตั้งเวลาก็ใช้เป็นแบบ 5 tokens เหมือนกับ cron เป๊ะ ๆ ด้วย)

5 tokens ที่ใช้ในการ config Cloud Scheduler จาก https://cloud.google.com/scheduler/docs/configuring/cron-job-schedules

Cloud Pub/Sub

บทบาทของ Cloud Pub/Sub ก็เป็นอย่างที่ได้พูดถึงใน 2 services ข้างต้นนะครับ คือ Cloud Scheduler จะสร้าง event Pub/Sub ขึ้น และตัว event Pub/Sub นี้ ก็จะ trigger ให้ Cloud Functions ทำงาน

ทีนี้มาพูดถึงตัว Pub/Sub กัน จริง ๆ แล้ว Pub/Sub เนี่ย เป็น message broker เหมือนพวก Kafka อะไรแบบนั้นครับ พูดแบบไม่เป็นทางการก็คือ คล้าย ๆ เป็น "ไปรษณี" ที่ผู้ส่งสามารถส่งข้อความ หรือข้อมูล ไปหาผู้รับ ที่รออยู่ได้ แต่ต่างกันตรงที่ว่า Pub/Sub จะใช้ "topic name" ในการอ้างอิงครับ

หมายความว่า สมมุติมีโปรแกรม A รอรับข้อมูล (subscribe) อยู่ที่ topic ชื่อ "scraper-trigger" โปรแกรม A ก็จะรอไปเรื่อย ๆ ครับ จนกว่าจะมีใครส่ง message มาที่ topic "scraper-trigger" นี้ สมมุติ P push ข้อมูล (publish) ไปที่ topic "scraper-trigger" Pub/Sub ก็จะไปเรียกโปรแกรม A ให้ทำงาน พร้อมกับส่งข้อมูลที่ P pushed ไปให้ครับ ซึ่ง topic "scraper-trigger" นั้นก็สามารถมี subscriber หลายคนได้ครับ Pub/Sub ก็จะส่งข้อมูลให้ทุกคนได้รับข้อมูลเดียวกันเหมือนกันหมดนั่นเองครับ

note: อันนี้เป็นการ subscribe topic แบบหนึ่งเท่านั้นนะครับ ยังมีรูปแบบอื่น แต่จะไว้กล่าวถึงในโอกาสถัดไปครับ

diagram แสดงลำดับการทำงานของ Pub/Sub
จาก https://cloud.google.com/pubsub/docs/overview

Cloud Datastore

Cloud Datastore นี่เป็น serverless NoSQL Database ครับ ทำ auto-scale และมี replication ให้ ปกติพวกข้อมูล JSON ที่ต้องอ่านและอัพเดตบ่อย ๆ แต่ไม่รู้จะเอาไว้ไหน เช่นพวก config ค่าต่าง ๆ ผมก็จะเอามาใส่ในนี้แหละครับ เพราะมันไม่ต้อง setup อะไรเลย สามารถใช้งานได้ทันทีและราคาถูก แต่ feature การ query การ update อะไรต่าง ๆ มันจะค่อนข้างน้อยไปหน่อย ถ้าเคยใช้ MongoDB มาก่อนแล้วมา Cloud Datastore ก็อาจจะหงุดหงิดหน่อยนะครับ 555 แต่เข้าใจว่า Google กำลังพัฒนาอยู่ครับ

BigQuery

BigQuery เป็น data warehouse แบบ serverless ก็คือจะเอาไว้ใช้เก็บ structured data ที่มีการ optimize ให้สามารถ query ได้เร็ว เพื่อนำไปใช้ในการ analyze และทำ dashboard ได้อย่างมีประสิทธิภาพ และเช่นเดียวกัน ก็คือเราไม่ต้อง manage ตัว server ครับ ไม่ต้องสนใจว่ามันจะใช้เครื่องไหนประมวลผลอะไรยังไง เพราะภายในมันจะทำการ auto-scaling และ optimize ให้เองครับ และก็ราคาค่อนข้างถูก

Pantip Scraper

สำหรับตัว Python script ของ scraper เนี่ยจะไม่ลงรายละเอียดลึก ๆ นะครับ เพราะทางเพจก็กำลังมี series Python Web Scraping อยู่แล้ว

คร่าว ๆ ก็คือเป็น script ที่จะ scrape กระทู้ล่าสุดใน tag ความรักวัยรุ่น ซึ่งเป็นที่นิยม โดยข้อมูลที่ดูดมาได้แก่ "ชื่อหัวข้อ" ของกระทู้ใน Pantip, id ของหัวข้อ, เวลาที่เขียน, user ที่เขียน, ฯลฯ ออกมาเรื่อย ๆ จนกว่าจะถึง last_id ก็คือ id ของหัวข้อที่เคย scrape เอาไว้ล่าสุด

ดังนั้นสิ่งที่เราต้องการจากระบบของเราก็มีดังนี้

ส่วนที่ใช้ในการรัน Python script โดยจะตั้ง limit ไว้ให้ scrape มาในแต่ละครั้ง มากที่สุดแค่ 50 กระทู้เท่านั้น
ส่วนที่ใช้ในการตั้งเวลา เพื่อเรียก Python script ขึ้นมารัน โดยจะตั้งเวลาให้รันทุก ๆ 10 นาที เพราะอัตราการสร้างกระทู้ไม่ได้สูงมาก ไม่มีความจำเป็นต้องทำถี่กว่านี้
ส่วนที่เก็บ last_id ของการ scrape ครั้งล่าสุด
ส่วนที่เก็บข้อมูลผลลัพธ์

note: ผู้เขียนจงใจนะครับ ทั้งเรื่องที่จะ scrape แค่ชื่อหัวข้อเท่านั้น, ตั้ง limit จำนวนกระทู้ต่อครั้ง แค่ 50 กระทู้, และตั้งเวลาให้ไม่ถี่มาก เหตุผลก็เพื่อไม่ให้รบกวนเว็บ Pantip ครับ และถ้า scrape ข้อมูลส่วนอื่น ๆ ไปมากกว่านี้คงจะไม่เหมาะสมครับ

ดังนั้นเราจึงออกแบบ architecture คร่าว ๆ ได้ตามนี้ครับ

คือ

ใช้ Cloud Functions ในการ run Python script
ใช้ Cloud Scheduler ในการตั้งเวลา เพื่อเรียก Cloud Functions
ใช้ Cloud Datastore ในการเก็บ last_id ของการ scrape ครั้งล่าสุด
ใช้ BigQuery ในการเก็บผลลัพธ์สุดท้าย เผื่อจะเอาไปทำ dashboard หรือ export เป็นไฟล์ csv ออกมาใช้งานต่อได้

สิ่งที่ต้องเตรียม

account gmail ที่รับ credit Google Cloud $300 ฟรี เรียบร้อยแล้ว จาก บทความก่อนหน้านี้ ครับ ถ้ายังไม่มีก็ให้ดำเนินการตามในบทความนั้นก่อนนะครับ ถึงจะสามารถ deploy ได้

Deploy Pantip Scraper

ผู้เขียนได้เตรียม script ทั้งหมดของระบบไว้ให้ใน Colab notebook นี้ แล้วนะครับ สามารถรันเพื่อได้ทันที พร้อม ๆ กับที่อ่านบทความนี้ครับ วิธีการรันเขียนไว้ใน notebook แล้วนะครับ

อย่างที่ได้บอกข้างต้นนะครับ เราจะ focus ที่ Cloud Platform เพราะฉะนั้นจะไม่ขออธิบาย Python script ที่ใช้ scrape ในบทความนี้ และจะอธิบายเฉพาะส่วนที่สำคัญนะครับ

ตรงนี้ไม่เชิงว่าเป็นคำเตือนนะครับ แต่แนะนำว่าขณะที่รันแต่ละคำสั่ง ให้สังเกตุ output ของมันด้วยครับ ถ้ามีตรงไหนที่เหมือนเป็น ERROR ควรหยุดรันทันทีแล้วลองเริ่มรันใหม่ดูแต่แรกนะครับ เพราะเป็นไปได้ว่าอาจจะลืมรันบรรทัดไหนไป
ซึ่งจริง ๆ แล้วมันไม่มีอันตรายใด ๆ ทั้งสิ้นแหละครับ เพราะเราใช้ credit free $300 อยู่ แล้ว และราคาของแต่ละ service ที่เราใช้ก็ถูกมาก และถ้ามีปัญหายังไงก็สามารถมาปรึกษาในเพจได้นะครับ

1. สร้าง Python script

ขั้นแรกนะครับให้รัน code ในส่วน เขียน scraping script ทั้งหมดก่อนครับ เมื่อทำเสร็จ ไฟล์ script สำหรับ scrape จะถูกสร้างขึ้นครับ ได้แก่ main.py, requirements.txt, และ scraper.py

พอรัน ls script จะต้องได้ผลลัพธ์แบบนี้ครับ

$ ls script/
main.py  requirements.txt  scraper.py

ซึ่ง script เหล่านี้จะถูก deploy ขึ้นไปที่ Cloud Functions ครับ โดยไฟล์ main.py จะเป็น script หลักที่จะถูกเรียกไปรัน ส่วน requirements.txt จะเอาไว้บอก Cloud Functions ว่าเราต้องใช้ module อะไร version เท่าไหร่บ้าง Cloud Functions ก็จะ install รอเอาไว้ให้ครับ

2. Login เพื่อใช้ gcloud CLI

ต่อไปให้รันคำสั่งนี้เพื่อ login ครับ

$ gcloud auth login
Go to the following link in your browser:

    https://accounts.google.com/o/oauth2/auth?code_challenge=...


Enter verification code:

มันก็จะสร้าง link ขึ้นมา link หนึ่ง ให้กดเข้าไปแล้ว login ด้วย gmail ที่เราเพิ่งได้รับ credit free $300 มาครับ

จากนั้นมันก็จะ generate code มั่ว ๆ ขึ้นมา ให้ copy code ตรงนั้นมาวางในกล่องสีขาว ๆ หลังคำว่า Enter verification code: แล้วกด Enter ครับ

ตรงนี้คือการยืนยันให้สิทธ์ Colab notebook ที่รันอยู่นี้ให้สามารถ manage Google Cloud Account ของเราได้ครับ

3. สร้าง project ใหม่ และผูก project กับ billing account

ให้รัน script ในส่วน สร้าง Project ใหม่ เพื่อสร้าง project ใหม่ขึ้นมา และจะเห็น output ที่เขียนว่า your new Project ID: ... ให้ copy Project ID เก็บเอาไว้ด้วยนะครับ เพื่อเวลาที่เราจะลบ project ทิ้ง จะได้ลบถูก project

จากนั้นก็รัน script ในส่วน เปิด Billing Account ครับ ตรงนี้ผูก Billing Account ที่เรามี credit ฟรี $300 เข้ากับ project ที่สร้างใหม่นี้ครับ

4. ต่อไปก็เปิดใช้งาน services ต่าง ๆ ที่เราใช้ใน project ทั้ง 4 ตัวครับ

$ gcloud services enable cloudscheduler.googleapis.com
$ gcloud services enable cloudfunctions.googleapis.com
$ gcloud services enable datastore.googleapis.com
$ gcloud services enable bigquery.googleapis.com

5. สร้าง scheduler

ให้รันโค้ดในส่วน ตั้ง Scheduler ทั้งหมดครับ คำสั่งนี้ก็จะสร้าง scheduler ขึ้นมา โดยตั้งชื่อ scheduler ตามค่าของตัวแปร SCHEDULER_NAME ครับ

$ gcloud scheduler jobs create pubsub $SCHEDULER_NAME \
    --topic=$PUBSUB_TOPIC_NAME \
    --schedule="*/10 * * * *" \
    --message-body="start"  # ตรงนี้คือตัวข้อความ จะใส่อะไรก็ได้ครับ ไม่สำคัญ

*/10 * * * * อันนี้เป็นการตั้งเวลาตามแบบ Cron ปกติครับ หมายความว่าให้รันทุก ๆ ครั้งที่ เวลามีเลขบอกนาทีหาร 10 ลงตัว (เช่น 13:10น., 09:00น., 21:50น.)

โดย scheduler ตัวนี้เมื่อทำงาน จะส่ง message ไปที่ Pub/Sub ที่ topic ชื่อ "scraper-pantip-trigger" (ค่าของตัวแปร PUBSUB_TOPIC_NAME)

6. deploy Cloud Functions สะที 555

ต่อไปเราก็ deploy Cloud Functions ชื่อ "pantip-scraper" โดยทำงานเมื่อมีข้อความส่งมาที่ Pub/Sub topic ชื่อ "scraper-pantip-trigger" (จากตัวแปร PUBSUB_TOPIC_NAME ซึ่งเป็นชื่อเดียวกับที่ scheduler ส่ง message ไปหา)

$ yes n | gcloud functions deploy pantip-scraper \
    --region=asia-east2 \
    --trigger-topic=$PUBSUB_TOPIC_NAME \
    --source=./script \
    --set-env-vars GCLOUD_PROJECT=$GCLOUD_PROJECT \
    --entry-point=main \
    --runtime=python37 \
    --timeout=540

โดยให้ใช้ code ที่อยู่ใน folder ./script ที่เราสร้างขึ้นมาตอนแรกสุด และให้รัน function ชื่อ main ใน main.py

(yes n นี่ใส่มาเพราะเวลา deploy มันจะถามว่าจะ allow unauthorized access หรือไม่ ใส่ yes n เพื่อให้ตอบ No ให้เราครับ)

หลังจาก run code ด้านบนเสร็จหมด เท่านี้ก็ deploy ทุกอย่างเสร็จเรียบร้อยครับ ให้รอสัก 10 นาที หรือรอให้ผ่านเวลาที่หาร 10 ลงตัว เพื่อให้แน่ใจว่า Cloud Functions เราได้ถูกรันแล้วครั้งหนึ่งนะครับ

จากนั้นก็ให้รันโค้ดบรรทัดต่อไป

print(f'link to BigQuery table: https://console.cloud.google.com/bigquery?project=...

ก็จะ generate link ไปหาข้อมูลใน BigQuery ที่ Cloud Functions scrape มาให้ครับ
ถ้าเข้าไปแล้วยังไม่เห็น อาจจะต้องรออีกสักพักแล้วลอง refresh ดูนะครับ

ตัวอย่างข้อมูลในตารางที่ scrape ออกมานะครับ

ส่วนด้านบน สามารถเขียน SQL เพื่อ query ข้อมูลออกมา analyze หรือสร้าง dashboard ได้นะครับ จะพูดถึงในบทความถัด ๆ ไปครับ

7. delete Project

สุดท้าย พอเราเล่นจนพอใจแล้วก็ delete project ทิ้งด้วยคำสั่งนี้ครับ

$ gcloud projects delete $GCLOUD_PROJECT --quiet

Pricing

ถึงจะบอกว่าฟรีก็จริงครับ แต่ลองมาเช็คราคาดูจริง ๆ กันหน่อย ว่าใน service แต่ละตัวถ้ารันจริง ๆ จะต้องใช้เงินเท่าไหร่ต่อเดือนนะครับ

ซึ่งใน document ของ service แต่ละตัวก็จะมี detail การคิดเงินที่ต่างกันออกไป แล้วก็ซับซ้อน แต่ Google ก็มีบริการ Price Calculator ออกมาให้ เพื่อให้สามารถคำนวณกันเองได้ง่าย ๆ ครับ เข้าไปตามลิ้งนี้เลย > Google Cloud Price Calculator

Cloud Functions

เนื่องจากเราตั้งเวลาให้ Cloud Functions ทำงานทุก 10 นาทีนะครับ เพื่อฉะนั้นจำนวนครั้งการ invocation ใน 1 เดือน ก็จะเป็น 6 * 24 * 30 = 4,320 ครั้ง แล้วก็ใส่ spec ของ Functions ที่เราใช้ลงไป ได้แก่ CPU 400MHz และ RAM 256MB ตัว calculator ก็จะคำนวน GiB-seconds และ GHz-seconds ต่อเดือนออกมาให้เรานะครับ แล้วก็ผมประมาณปริมาณข้อมูลขาออกเป็นครั้งละ 1MB พอกด estimate calculator ก็จะบอกว่าใช้เงินเท่าไหร่

$0 ต่อเดือน! เพราะว่าแต่ละ service ของ Google เขาก็จะมี quotas ฟรีต่อเดือนให้กับทุกคนอยู่ครับ ซึ่งการใช้งานของเราต่ำกว่า quotas ที่เขาตั้งเอาไว้ เพราะฉะนั้นก็เลยใช้ได้ฟรีครับ

โดย quotas ฟรีต่อเดือนตรงนี้ไม่เกี่ยวกับ credits $300 ของเรานะครับ หมายความว่าเราสามารถรันตัวนี้ไปได้เรื่อย ๆ โดยที่ยังไม่ต้องเสีย credits $300 นี้ไปด้วยซ้ำครับ

BigQuery

BigQuery นี้ผมสมมุติให้เราเก็บข้อมูลนี้ไปเรื่อย ๆ แบบนานมาก ๆ เลยนะครับ จนพื้นที่ storage ของเรามีขนาดเป็น 10GB ไปแล้ว (ในปัจจุบันถ้าลองรันทิ้งไว้สัก 1 วัน พื้นที่ storage จริงจะใช้แค่ไม่กี่สิบ kB เท่านั้นครับ เพราะฉะนั้น 10GB นี่เป็น upper bound มาก ๆ ครับ น่าจะต้องเก็บไว้หลายสิบปีอยู่ 5555) แล้วก็ประมาณว่า ข้อมูลที่อัพโหลดขึ้นไปในแต่ละครั้งเฉลี่ยประมาณ 5 kB ดังนั้นในหนึ่งเดือนก็จะมีข้อมูลที่ insert เข้าไปเป็น 4,320 * 5 = 21,600 kB = 21.094 MB ครับ

เช่นกันก็คือเป็น $0 ต่อเดือน เพราะต่ำกว่า quotas ฟรีที่ให้นะครับ

service อื่น ๆ ก็เช่นกันครับ อย่าง Scheduler เขาก็ให้รันได้ฟรี 3 ตัวในแต่ละเดือน ส่วน Datastore เขาก็ฟรี storage 1GB และอ่าน/เขียนได้ฟรีเป็นหมื่นครั้งเลยครับ ซึ่งเราใช้เก็บแค่ last_id เป็นตัวเลขตัวเดียวเท่านั้น ก็ไม่มีทางเกินครับ เช่นเดียวกันกับ Pub/Sub ครับ คือมี quotas ขนาดของ message ตั้ง 10GB ไม่มีทางเกินเช่นกัน

Summary

บทความนี้อาจจะยาวนิดนึงนะครับ 55 คิดว่าน่าจะพอให้เห็นภาพคร่าว ๆ ของ Google Cloud service บางตัวว่าเอาไปใช้ทำอะไรได้บ้าง

แล้วก็ย้ำอีกครั้งนะครับ ตัว scraper นี้เอาไว้เพื่อการทดลองเท่านั้นนะครับ ไม่ควรไปปรับให้มันถี่ขึ้น หรือ scrape ข้อมูลเพื่อไปใช้หากำไรจนทำให้ผู้อื่นเดือดร้อนนะครับ

แล้วถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

อ้างอิง:

Cloud Functions Pricing - https://cloud.google.com/functions/pricing
Cloud Scheduler Pricing - https://cloud.google.com/scheduler/pricing
Cloud Pub/Sub Pricing - https://cloud.google.com/pubsub/pricing
Cloud Datastore Pricing - https://cloud.google.com/datastore/pricing
BigQuery Pricing - https://cloud.google.com/bigquery/pricing

Python Coding ขำ ๆ: ลอง simulate สถานการณ์ COVID-19 แบบง่าย ๆ ด้วย Python part 1

CopyPasteEngineer — Sun, 19 Apr 2020 05:34:21 +0000

สำหรับสถานการณ์ช่วงนี้ที่ทั้งโลกกำลังเผชิญหน้ากับ COVID-19 เจ้าหน้าที่ที่มีหน้าที่รับผิดชอบในเรื่องนี้คงต้องคิดกันจนปวดหัวนะครับ ว่าจะ take action หรือออก policy อย่างไร ภายใต้ทรัพยากรที่จำกัด เงินจำกัด และคนก็จำกัด ควรจะลงทุนกับการวิจัย vaccine ก่อนดี หรือจะแก้เฉพาะหน้าไปก่อนดี และแต่ละ action จะส่งผลอย่างไร มากหรือน้อย

ในการจะตอบคำถามต่าง ๆ นั้น ส่วนหนึ่งก็จำเป็นอาศัยการสร้าง model ทางคณิตศาสตร์ที่แม่นยำเพื่อทำนายผลในอนาคตล่วงหน้าเพื่อให้ทราบว่าสถานการณ์ข้างหน้ากำลังจะเป็นไปอย่างไร และถ้าทำอย่างนี้ไป จะเกิดอะไรขึ้น

ซึ่งงานในส่วนนี้โดยทั่วไปก็จะมี นักระบาดวิทยา (Epidemiologist) คอยทำหน้าที่ในการเก็บข้อมูลจริง เพื่อมาสร้างโมเดล หรือออกมาตรการรับมือต่าง ๆ อยู่แล้วครับ และยังมี model ทางคณิตศาตร์อื่น ๆ อีกมากที่สามารถใช้ในการทำนายได้จากหลากหลายสายงาน เช่น Data Scientist หรือ Economist ซึ่งสามารถให้ผลที่แม่นยำ และมี performance ในการคำนวณที่ดี เช่นกัน

ตัวอย่างโมเดลโรคระบาดในมุมของระบาดวิทยา: สมการ differential equation ของ SEIR Model (simplified)
(https://towardsdatascience.com/social-distancing-to-slow-the-coronavirus-768292f04296)

ในบทความนี้ เพื่อให้เข้าใจถึงความซับซ้อนของปัญหา และปัจจัยต่าง ๆ ที่ต้องคำนึงถึง จึงลองทำเป็น project simulation เล็ก ๆ ง่าย ๆ ขึ้นมาเล่น ๆ ให้มองว่าเป็น project ฝึกฝีมือเขียนโปรแกรมแบบ OOP ขำ ๆ โดยมีเป้าหมายเพื่อศึกษาดูการแพร่กระจายของ virus สมมุติชนิดหนึ่ง ชื่อว่า DIVOC-91 ซึ่งแพร่ระบาดบนโลกสมมุติแห่งหนึ่ง แล้วดูว่าถ้าเราเป็นรัฐบาลหรือเจ้าหน้าที่จะตัดสินใจออกมาตรการรับมืออย่างไร แบบง่าย ๆ ก่อน แล้วจากนั้นจะค่อย ๆ เพิ่มความซับซ้อนของ simulation ขึ้นเรื่อย ๆ ใน part ต่อ ๆ ไป เพื่อให้ใกล้เคียงกับโลกความเป็นจริงมากขึ้นครับ

Scenario

ใน part ที่ 1 นี้เพื่อความง่าย เราลองเริ่มจากสร้างโลกขึ้นมาแบบง่าย ๆ โดยการกำหนดเป็น rules ต่าง ๆ ออกมาดังนี้ครับ

โลกนี้มีประชากร 7,000 คน
คนแต่ละคนจะมี 3 สถานะ คือ สุขภาพดี, ติดเชื้อ, และ เสียชีวิต
ในแต่ละวัน คนที่ยังไม่เสียชีวิต (แน่นอน 555) แต่ละคนจะเดินทางไปพบเจอคนอื่นที่ยังไม่เสียชีวิต แบบสุ่ม 10 คน
ถ้าคนที่ ติดเชื้อ และคนที่ สุขภาพดี พบกัน คนที่สุขภาพดีจะมีโอกาสติดเชื้อ 10%
ในแต่ละวัน คนที่ ติดเชื้อ จะมีโอกาสเสียชีวิต 0.01% (ใจดีมาก)
แต่ถ้าไม่เสียชีวิต ในแต่ละวัน ผู้ติดเชื้อคนดังกล่าว จะมีโอกาสหาย กลับมาเป็น สุขภาพดี 1%
โดยจะเริ่มจากให้มีผู้ติดเชื้อ 1 คน ในวันแรกนะครับ

ใน part นี้ให้เงื่อนไขเป็นแบบง่าย ๆ ตามนี้ก่อน ซึ่งอาจจะดูไม่ค่อยสมจริงบ้าง ใน part ต่อ ๆ ไปก็จะค่อย ๆ เพิ่มเงื่อนไขเข้าไปนะครับ

Get Started

โค้ดของบทความนี้จะแชร์ไว้บน Google Colab ใน link นี้ นะครับ เพื่อความสะดวก สามารถแก้โค้ดและรันบน browser ได้ทันที ไม่ต้อง download หรือ install อะไรลงบนเครื่อง ผู้อ่านสามารถรันโค้ดจริงไปพร้อมกับอ่านบทความนี้ได้เลยครับ

วิธีการรันโค้ดใน colab notebook

ให้คลิกที่ File มุมซ้ายบน แล้วเลือก Save a copy in drive... ก่อนนะครับ
จากนั้นให้คลิกเลือก block ที่ต้องการจะรันแล้วกด Ctrl+Enter นะครับ

โดยในบทความจะหยิบเฉพาะโค้ดใน part ที่สำคัญ ๆ เช่น modelling บางส่วนมาอธิบายนะครับ และจะข้ามส่วนที่เป็นรายละเอียดเล็ก ๆ น้อย ๆ ไป เช่น function เสริมบางส่วน หรือการ plot graph แนะนำให้ลองดูโค้ดใน Colab ไปพร้อม ๆ กัน จะช่วยให้เข้าใจมากขึ้นครับ

เริ่มกันเลยนะครับ

ใส่ค่าคงตัวต่าง ๆ

จาก rules ต่าง ๆ ที่เรากำหนดขึ้นมา อย่างแรกผมเอาแค่คงตัวต่าง ๆ ใส่เข้าไปในโปรแกรมก่อนครับ ได้แก่

จำนวนประชากร (N_POPULATION)
จำนวนผู้ติดเชื้อเริ่มต้น (N_INFECTED_INIT)
จำนวนคนที่ไปพบเจอในแต่ละวัน (N_MEETINGS)
โอกาสติดเชื้อ (PROB_INFECT)
โอกาสเสียชีวิต (PROB_DIE)
โอกาสหาย (PROB_CURED)

โดยจะเก็บเป็น dict และส่งเป็น parameter เข้าไปให้กับตัว simulator นะครับ เพื่อให้สะดวก เวลาทดลองแก้ค่าต่าง ๆ

default_config = {
    'N_POPULATION': 7_000,
    'N_INFECTED_INIT': 1,

    'N_MEETINGS': 10,

    'PROB_INFECT': 0.1,
    'PROB_DIE': 0.0001,
    'PROB_CURED': 0.01,
}

สร้างตัว Simulator

ต่อไปเราจะมาสร้างตัว Simulator กันนะครับ โดยตัว Simulator เนี่ย มีหน้าที่วนลูปเพื่ออัพเดตค่าต่าง ๆ ในแต่ละวัน และ monitor status ในแต่ละว่ามีคนสุขภาพดี ติดเชื้อ หรือเสียชีวิตกี่คนแล้ว นะครับ

อันนี้โค้ดในส่วนของการวนลูปเพื่ออัพเดตค่าต่าง ๆ ในแต่ละวันนะครับ จะใช้ method ชื่อ run() และรัน input เป็น จำนวนวันที่จะทำการคำนวณ

class Simulator:
    ...
    def run(self, max_days):
        for self.days in range(1, max_days+1):
            random.shuffle(self.people)

            self.meet_friends()

            for person in self.people:
                person.update()

            self.monitor()
    ...

โดยในแต่ละรอบลูปของ method run() เนี่ย ก็จะทำการ shuffle list ของคนนะครับ เพื่อให้ลำดับของคนใน list แตกต่างกันออกไปในแต่ละวัน จากนั้น self.meet_friends() ก็จะทำการสุ่มคนออกมาและจับให้เจอกันนะครับ

แล้วก็เรียก person.update() เพื่ออัพเดตสถานะของคนนั้น เช่น อัพเดตสถานะจาก ติดเชื้อ เป็น สุขภาพดี หรือ เสียชีวิต

สุดท้ายก็ monitor ค่าต่าง ๆ ในวันนั้น ๆ และเก็บเอาไว้เพื่อไป plot graph ตอนจบนะครับ

อันนี้เป็น method meet_friends() ก็ไม่มีอะไรซับซ้อน แค่วนลูปคนแต่ละคน แล้ว sample คนออกมา เท่ากับ N_MEETINGS ก็คือ sample คนออกมา 10 คน แล้วก็ให้เจอกัน โดยเรียกคำสั่ง person.meet_with(friend)

class Simulator:
    ...
    def meet_friends(self):
        for person in self.people:

            friends = random.sample(self.people, self.config['N_MEETINGS'])

            for friend in friends:
                person.meet_with(friend)
    ...

สร้างคน (Person)

ต่อไปก็จะสร้าง class Person ขึ้นมา โดยสิ่งที่ Person ต้องทำก็จะมี 2 method ที่ต้องเขียน (1) คือ method update() คือใช้ในการ update สถานะว่าหลังจากติดเชื้อ จะให้ติดเชื้อต่อไป หรือหายดี หรือเสียชีวิต ตามความน่าจะเป็นที่เราได้นิยามเอาไว้ใน scenario และ (2) คือ method meet_with() ใช้เป็นตัวแทนของการเจอกัน ของคนสองคนนะครับ โดยถ้าหากคนใดคนหนึ่งมีสถานะเป็น ติดเชื้อ อีกคนจะมีโอกาสติดเชื้อ เป็น PROB_INFECT ครับ

เริ่มจาก method update() มี logic เป็นอย่างนี้ครับ

ถ้าสถานะเป็น เสียชีวิต หรือ สุขภาพดี: ไม่ต้องทำอะไร
สุ่มเลขตั้งแต่ 0 ถึง 1 ถ้ามีค่าน้อยกว่า PROB_DIE (0.0001) จะเปลี่ยนสถานะเป็น เสียชีวิต ก็คือจะมีโอกาส 0.01% ที่จะเสียชีวิตนั้นเองครับ
แต่ถ้าไม่เสียชีวิต: ให้สุ่มเลขตั้งแต่ 0 ถึง 1 ถ้ามีค่าน้อยกว่า PROB_CURED (0.01) จะเปลี่ยนสถานะกลับเป็น สุขภาพดี ก็คือจะมีโอกาส 1% ที่จะหายเป็นปกติ ตามที่เรากำหนดเอาไว้ครับ

class Person:
    ...
    def update(self):
        if self.is_died or not self.is_infected:
            return

        # random result whether this infected one will die!!!
        if get_binary_random(prob=self.config['PROB_DIE']):
            self.is_died = True

        # random result whether this infected one will be cured!!!
        elif get_binary_random(prob=self.config['PROB_CURED']):
            self.cured()
    ...

ในโค้ดที่ใช้สุ่มเลขผมสร้างเป็น function ชื่อ get_binary_random() มาใช้แทนนะครับ เพราะคิดว่ามันสื่อความหมายมากกว่า ซึ่งตัว function ถูกประกาศเอาไว้อยู่ด้านบนนะครับ ตรงส่วน util สามารถเลื่อนขึ้นไปดูได้ครับ

ต่อไป method meet_with() ครับ การทำงานก็คือ ถ้ามีคนใดคนหนึ่งติดเชื้อ ส่วนอีกคนไม่ติด ก็จะสามารถมีการเพร่เชื้อได้ครับ โดยมีโอกาสแพร่เชื้อเป็น 10%

ในส่วนของเงื่อนไขผมเขียนเป็น condition แบบนี้

        if self.is_infected + other.is_infected == 1:

self.is_infected จะให้ค่าเป็น True หรือ False ครับ ซึ่งถ้าเอามาบวกกัน ใน Python True จะมีค่าเป็นเลข 1 และ False จะมีค่าเป็นเลข 0 ในโค้ดจึงใช้การบวกกันแล้วตั้งเงื่อนไขเป็นเมื่อผลบวกเป็น 1 ซึ่งหมายถึงเมื่อมีผู้ติดเชื้อเป็นคนใดคนหนึ่ง แค่หนึ่งคนนั่นเองครับ

ส่วนในการแพร่เชื้อ ก็ใช้วิธีการสุ่มเลขแบบเดิมครับ ก็คือถ้าค่าสุ่มน้อยกว่า 0.1 สุดท้ายทั้งสองคนก็จะมีสถานะเป็น ติดเชื้อ ครับ

ได้โค้ดเต็ม ๆ เป็นดังนี้

class Person:
    ...
    def meet_with(self, other):
        # condition: one is healthy and the other is sick (XOR)
        if self.is_infected + other.is_infected == 1:

            # random result whether the healthy one will be infected
            if get_binary_random(prob=self.config['PROB_INFECT']):
                self.infect()
                other.infect()
    ...

เท่านี้ก็ได้โค้ดที่ model โครงสร้างของโลกสมมุติ และโรคสมมุติของเราเรียบร้อยแล้วครับ ต่อไปก็มาลอง run จริงกันเลย

ลอง Simulate

เพื่อความสะดวก ผมสร้าง function สำหรับการรัน simulation ขึ้นมา โดยรับ input เป็น dict ของ configuration ที่ต้องการใช้ และจำนวนวันที่ให้รันนะครับ

โดยใน function มีการทำงานดังนี้ครับ

สร้าง Simulator ขึ้นมา
add คนเข้าไปใน Simulator โดยให้ คนจำนวน N_INFECTED_INIT คนแรก มีสถานะเป็นติดเชื้อ (ใน default config ของเราก็คือให้คนที่ 1 เป็นผู้ติดเชื้อนั้นเองครับ)
run simulation

def simulate(config, max_days):
    simulator = Simulator(config)

    n_population = config['N_POPULATION']
    for i in range(n_population):
        person = Person(config)

        # ทำให้คน N คนแรกมีสถานะ `ติดเชื้อ`
        if i < config['N_INFECTED_INIT']:
            person.infect()

        simulator.add_person(person)

    simulator.run(max_days)

    return simulator

ทีนี้ก็เริ่มลองรันจริงดูเลยครับ โดยใช้ default config ที่เรากำหนดเอาไว้ตอนแรกสุดก่อน เป็นเวลา 30 วัน

simulator = simulate(default_config, 30)

ก็ใช้เวลารันสักพักนะครับ จากนั้น result ของ simulation คือ status ของระบบในแต่ละวัน ซึ่งมาจาก function monitor() สามารถเรียกดูได้แบบนี้ครับ

report = simulator.report
print(report)

ก็จะได้เป็น list ของ dict อันใหญ่ ๆ ออกมา ซึ่งเป็นจำนวนของผู้ที่มีสุขภาพดี จำนวนของผู้ติดเชื้อ และจำนวนผู้เสียชีวิตรวมทั้งหมด ของแต่ละวันนะครับ เพื่อให้ดูง่ายก็จะ plot ออกมาเป็น graph ได้แบบนี้ครับ

ในส่วนของการ plot graph ตรงนี้ ผมใช้ module pandas และ matplotlib นะครับ ถ้าสนใจสามารถศึกษาดูเพิ่มเติมได้ครับ

จะเห็นว่าใน 30 วันแรก จำนวนผู้เสียชีวิตไม่ค่อยเพิ่มขึ้นมาเท่าไหร่ เพราะเรากำหนดให้ความน่าจะเป็นในการเสียชีวิตค่อนข้างต่ำครับ แต่เพียงแค่ประมาณ 6 วันแรก แทบจะทุกคนกลายเป็นผู้ติดเชื้อไปเกือบหมดแล้ว ถ้ากลับไปดูจากข้อมูลดิบ จะเห็นว่าในวันที่ 7 จำนวนผู้ติดเชื้อกลายเป็น 6804 คน จาก 7,000 คน อย่างรวดเร็ว คิดเป็น 97% ภายใน 1 สัปดาห์ โชคดีนะครับที่ไวรัสตัวนี้อยู่แค่ในโลกสมมุติ 5555

สรุปรวมยอดของ DIVOC-91 ใน 1 เดือนแรก เหลือคนสุขภาพดีอยู่ 63 คน เป็นผู้ติดเชื้ออยู่ 6913 คน และเสียชีวิตไปแล้ว 24 คนครับ

ลองเป็นรัฐบาล แล้วแก้ปัญหาดูเองเลย!

คำถามครับ สมมุติว่าเราเป็นรัฐบาลที่ฉลาดครับ รู้ล่วงหน้าตั้งแต่วันแรกละ ว่าในอีก 1 เดือนข้างหน้าจะเกิดอะไรขึ้น แล้วเรามีงบอยู่ก้อนหนึ่ง ถามว่าเราจะทำอย่างไร มี choice ให้ครับ:
1. ลดการรวมกลุ่ม
2. ปรับปรุงการรักษา
3. แจกหน้ากากและเจลล้างมือ

วิธีการเลือกเนี่ย เราก็ต้องวิเคราะห์ดูว่าแต่ละตัวเลือก จะส่งผลกับ parameter ตัวไหนในโมเดล ให้เปลี่ยนแปลงไปอย่างไรครับ

ทีนี้สมมุติมีทีมนักวิจัยเอาข้อมูลของแต่ละตัวเลือกมาให้เพิ่ม เป็นอย่างนี้ครับ
1. ลดการรวมกลุ่ม น่าจะส่งผลให้จำนวนของคนที่เจอในแต่ละวัน (N_MEETINGS) ลดลง จาก 10 คน เป็น 6 คน

2. ปรับปรุงการรักษา จะช่วยให้ผู้ติดเชื้อเนี่ยเข้าถึงการรักษาได้ง่ายขึ้น และช่วยสนับสนุนเครื่องมือแพทย์ต่าง ๆ จะทำให้โอกาสการหายติดเชื้อ (PROB_CURED) เพิ่มขึ้น จาก 1% เป็น 10%

3. แจกหน้ากากและเจลล้างมือ แจกหน้ากากเนี่ยก็จะทำให้เวลาเจอกันมีโอกาสการติดเชื้อต่ำลง และทำความสะอาดด้วยเจลล้างมือก็จะป้องกันไวรัสจากการสัมผัสได้อีก จะทำให้ PROB_INFECT ลดลง จาก 10% เป็น 3% เท่านั้น

ถ้าได้ตัวเลขประมาณแบบนี้ก็สบายแล้วใช่ไหมครับ เราก็สามารถใช้โมเดลที่เรามีมา simulate ดูเอาได้เลย ว่าเมื่อทำแต่ละ choice อีก 30 วัน จะเกิดอะไรขึ้น

ผมสร้าง function ชื่อ try_new_config() ขึ้นมา เพื่อให้สามารถแก้ config และรันได้ง่าย ๆ นะครับ โค้ดข้างในก็คือเอาโค้ดที่เรา simulate และ plot มาต่อกันเฉย ๆ ครับ ไม่มีอะไร

1. ลดการรวมกลุ่ม

N_MEETINGS: 10 -> 6

จะเห็นว่าการลดการรวมกลุ่มช่วยชะลอการแพร่เชื้อได้เล็กน้อยครับ สังเกตุได้จากจุดตัดของจำนวนคนสุขภาพดี (สีฟ้า) และจำนวนผู้ติดเชื้อ (สีเหลือง) จะอยู่ที่ประมาณวันที่ 8 ในขณะที่กราฟเดิมของเราจะอยู่ที่ประมาณวันที่ 4 แต่เมื่อผ่านไป 30 วัน จำนวนผู้ป่วยก็ไม่ต่างกันมาก ส่วนจำนวนผู้เสียชีวิตลดลงมาเป็น 19 คน จาก 24 คนครับ

2. ปรับปรุงการรักษา

PROB_CURED: 0.01 -> 0.1

ที่น่าสนใจคือจุดพีคของเส้นจำนวนผู้ติดเชื้อ (สีเหลือง) ต่ำกว่ากราฟเดิม ประมาณ 700 คน เนื่องจากผู้ป่วยฟื้นตัวกลับมาสุขภาพดีได้เร็วมากขึ้นนั่นเองครับ

3. แจกหน้ากากและเจลล้างมือ

PROB_INFECT: 0.1 -> 0.03

ผลกระทบที่ดูจากกราฟนี้จะ คล้ายกับมาตรการลดการรวมกลุ่ม คือเป็นการชะลอการแพร่เชื้อออกไป แต่ไกลกว่า ทำให้จำนวนผู้เสียชีวิตต่ำกว่ามาก คือแค่ 9 คน จากเดิม 24 คนครับ ถ้ามองหาการแก้ปัญหาเฉพาะหน้าสำหรับ 1 เดือน วิธีนี้ก็อาจจะไม่เลว

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

ส่วนจะเลือก choice ไหนนั้น ให้ผู้อ่านตัดสินใจเองได้เลยครับ ว่าจะเลือกจากจำนวนผู้เสียชีวิตในระยะสั้น หรือการรักษาในระยะยาว หรือแม้แต่ choice อื่น เช่นเลือกทั้งการรักษาและแจกหน้ากากเป็นต้น ก็สามารถลองเล่นดูได้ใน colab notebook ได้เลยครับ

Summary

ใน part นี้เราก็ได้สร้าง model แบบง่าย ๆ เพื่อ simulate การแพร่กระจายของโรคระบาดไปแล้วนะครับ ซึ่งหลาย ๆ ท่านก็จะเห็นว่าตัว model เอง มีความไม่สมเหตุสมผลอีกมาก เช่น

ในแต่ละวัน model ใช้การสุ่มให้คนคนหนึ่งเจอใครก็ได้ แต่ในความเป็นจริงแล้วเราอาจจะไม่ได้มีโอกาสเจอทุกคนบนโลก อาจจะเจอได้เฉพาะคนที่อยู่ในบริเวณใกล้เคียงหรือทำงานที่เดียวกันเท่านั้น นี่อาจจะเป็นสาเหตุให้ DIVOC-91 แพร่กระจายอย่างรวดเร็วเกินจริงครับ
ปกติเราอาจจะไม่ได้ออกจากบ้านและเจอคนถึง 10 คนทุกวัน บางวันเราอาจจะแค่ไปจ่ายตลาดแล้วกลับมาบ้านก็ได้
model นี้เรายังไม่ได้รวมการแพร่กระจายที่อาจจะเกิดขึ้นได้ จากคนที่อาศัยอยู่ในบ้านเดียวกัน

และอื่น ๆ อีกมาก ซึ่งใน part ต่อ ๆ ไป เราก็จะ implement model ให้ซับซ้อนยิ่งขึ้น เพื่อแก้ไขประเด็นดังกล่าวกันนะครับ

สุดท้ายนี้ ย้ำอีกสักเล็กน้อยว่าอยากให้มอง project นี้เป็น OOP project แบบขำ ๆ นะครับ ผลลพธ์จาก model ที่เราลองรันเล่นกันในนี้ไม่สามารถเอาไปสรุปหรือแย้งการตัดสินใจของเจ้าหน้าที่จริงที่มีความรู้เฉพาะทางและข้อมูลที่แม่นยำได้นะครับ

note: ในการวิเคราะห์โดยทั่วไป เพื่อให้คำนวณได้อย่างมีประสิทธิภาพ ปกติก็จะต้อง formulate ออกมาเป็นโมเดลคณิตศาสตร์ และ derive ออกมาเป็นสมการ จะสามารถคำนวณผลลัพธ์ ณ จุดเวลาใด ๆ ได้เร็วกว่า แต่ใน project นี้ตั้งใจจะเขียนเป็น OOP project ครับ และใน part สุดท้ายก็คิดว่าจะ visualize ออกมาภาพเคลื่อนไหวสั้น ๆ อันหนึ่ง ให้เห็นเป็นตัวคนวิ่งไปวิ่งมาจริง ๆ ก็น่าจะสนุกดีครับ

และถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

Python Web Scraping part 3 - เทคนิคการ extract ข้อมูลด้วย XPath

CopyPasteEngineer — Sun, 12 Apr 2020 05:35:39 +0000

มาต่อกันกับ series Python Web Scraping part 3 นะครับ หลังจากที่ใน part ที่แล้ว เราได้เรียนรู้วิธีการแกะ XPath ของแต่ละ element ออกมาจาก web browser แบบง่าย ๆ กันแล้ว แต่ทีนี้ในกรณีที่ข้อมูลที่เราสนใจมีหลายตำแหน่งมาก เราคงไม่อยากเสียเวลานั่ง extract แต่ละ element ด้วยมือทั้งหมดใช่ไหมครับ (เพราะถ้าจะทำด้วยมือทั้งหมด ก็ก๊อปตัวข้อมูลมาตรง ๆ เลยสะดีกว่า 555)

ท่านที่พอจะมีประสบการณ์การทำเว็บมาบ้าง พอเห็น XPath สัก 1 หรือ 2 อัน ก็อาจจะเดาได้แล้ว ว่า XPath ที่เหมาะสม ที่น่าจะครอบคลุมทุก ๆ element นั้น ควรจะเป็นอะไร แต่ถึงจะเดาไม่ออกก็ไม่เป็นไรครับ เพราะอย่างบาง website ที่ซับซ้อนขึ้นหน่อย ต่อให้มีประสบการณ์ก็คงเดาไม่ออกในทีแรกเช่นกัน

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

วิธีหนึ่งที่ผมทำก็คือ sample XPath ออกมาดู เอามา สำรวจ เพิ่มอีกเยอะ ๆ ก็จะช่วยให้เห็นภาพมากขึ้นครับ จากนั้นเราก็จะใช้ syntax ของ XPath ในการ select และระบุ condition เพื่อให้ครอบคลุมกรณีที่เรา sample ออกมา ให้มากที่สุดครับ

Get Started!

ทบทวนสักเล็กน้อย ใน part นี้เราก็ยังอยู่กับเว็บ Wikipedia https://th.wikipedia.org/wiki/รายชื่อเทศบาลตำบลในประเทศไทย กันเหมือนเดิมนะครับ โดยเป้าหมายคือ หา XPath สำหรับ extract รายชื่อเทศบาลตำบลทั้งหมด ซึ่งใน part ที่แล้ว เราใช้ Chrome Inspector ในการแกะ XPath ของ "Element" หนึ่ง ๆ มาได้แบบง่าย ๆ แล้วนะครับ ในตอนนี้เรากำลังจะหา XPath ที่สามารถ extract ข้อมูลทั้งหมดได้ (คือครอบคลุมทุก element ไม่ใช่แค่ 1 element)

1. Sample XPath มาเพิ่ม

อย่างในเว็บเป้าหมาย ถ้าลอง scroll เลื่อนขึ้นลงดู จะเห็นว่ามันมีหลายตาราง เพราะฉะนั้น เพื่อให้เราได้เห็นรูปแบบที่หลากหลาย แล้วก็ครอบคลุมข้อมูลทั้งหมดมากที่สุด ก็ควรจะหยิบ sample ออกมาจากหลาย ๆ ที่ กระจาย ๆ กันหน่อยนั่นเองครับ เช่น เอามาจากตาราง 1 บ้าง จากตาราง 8 บ้าง จากตารางสุดท้ายบ้าง หรือจากหัวตารางบ้าง จากท้ายตารางบ้าง ปน ๆ กันไป โดยหลักสถิติแล้วยิ่งเราสุ่มมามากเท่าไหร่ เราก็จะยิ่งมั่นใจได้ว่าเราได้เห็น pattern ที่เป็นไปได้ทั้งหมดแล้วมากขึ้นนั่นเองครับ (จะเรียกว่าหลักสถิติหรือดวงก็ได้นะครับ 555)

สำหรับท่านที่ยังไม่เข้าใจว่าจะเอา sample XPath ตรงนี้มาได้อย่างไร กรุณาอ่าน part 2 ด่วน ๆ เลยครับ! หรือถ้ามีข้อสงสัย สามารถคอมเม้นถามด้านล่าง หรือในเพจ Copy Paste Engineer ได้เลยนะครับ

ด้านล่างนี้เป็นตัวอย่างที่ผม sample ออกมา

 (1) //*[@id="mw-content-text"]/div/table[3]/tbody/tr[1]/td[3]/b/a    (ตาราง 1 บรรทัด 1)
 (2) //*[@id="mw-content-text"]/div/table[3]/tbody/tr[2]/td[3]/b/a    (ตาราง 1 บรรทัด 2)
 (3) //*[@id="mw-content-text"]/div/table[3]/tbody/tr[10]/td[3]/b/a   (ตาราง 1 บรรทัด 10)
 (4) //*[@id="mw-content-text"]/div/table[4]/tbody/tr[3]/td[3]/b/a    (ตาราง 2 บรรทัด 1)
 (5) //*[@id="mw-content-text"]/div/table[4]/tbody/tr[30]/td[2]/b/a   (ตาราง 2 บรรทัด 28)
 (6) //*[@id="mw-content-text"]/div/table[7]/tbody/tr[25]/td[2]/b/a/b (ตาราง 5 บรรทัด 23)
 (7) //*[@id="mw-content-text"]/div/table[10]/tbody/tr[41]/td[2]/b/a  (ตาราง 8 บรรทัดสุดท้าย)
 (8) //*[@id="mw-content-text"]/div/table[24]/tbody/tr[3]/td[3]/a/b   (ตาราง 22 บรรทัด 1)
 (9) //*[@id="mw-content-text"]/div/table[76]/tbody/tr[3]/td[3]/b/a   (ตารางสุดท้าย บรรทัด 1)
(10) //*[@id="mw-content-text"]/div/table[76]/tbody/tr[37]/td[2]/b/a  (ตารางสุดท้าย บรรทัดสุดท้าย)

จะเห็นว่า XPath จริง ๆ ของข้อมูลเรา มันไม่ได้ตรงไปตรงมาเสมอไปนะครับ อย่างเช่นตัวเลขของ table และ tr ใน XPath ของแต่ละ sample นั้น ก็อาจจะไม่ได้สัมพันธ์กับเลขตารางหรือเลขบรรทัดของข้อมูลเสมอไป หรือบางทีก็มี element b บ้าง บางทีก็ไม่มี ซึ่งในเหตุการณ์เช่นนี้สามารถพบเจอได้จริง ในเว็บทั่ว ๆ ไปนะครับ โดยอาจเกิดจาก developer ที่เขียนโค้ดไม่สัมพันธ์กันเอง หรืออย่างในกรณีของ Wikipedia นี้ คืออาจเกิดจาก user ซึ่งเป็นผู้เขียนบทความได้ใช้โครงสร้างของข้อมูลที่แตกต่างกันนั่นเองครับ

2. สำรวจ XPath

ในขั้นตอนนี้ เราจะทำการวิเคราะห์ XPath ที่เรา sample ออกมา แล้วก็ตั้งข้อสังเกตุถึง จุดที่เหมือน และ จุดที่แตกต่าง สำหรับแต่ละตัวอย่างนะครับ ซึ่งอาจจะต้องใช้ความรู้ HTML เล็กน้อยนะครับ แต่จะพยายามอธิบายให้เข้าใจง่ายที่สุดนะครับ

เมื่อเรา sample ออกมาดูเยอะ ๆ แล้วก็จะเห็นครับว่ามันมีส่วนที่เหมือนกันอยู่ คือ ขึ้นต้นด้วย element <table>

//*[@id="mw-content-text"]/div/table

ซึ่ง <table> ก็หมายถึงตัวตารางแต่ละตารางนั่นเองครับ

และจะสังเกตุได้จาก XPath ที่ได้มา ว่าข้อมูลที่เราต้องการ
1. จะเริ่มต้นที่ ตารางที่ 3 (เพราะในตารางที่ 1 บรรทัดที่ 1 ใช้ table[3])
2. แล้วตามด้วย <tbody>
3. ตามด้วย <tr> คือแต่ละ row ของ table นั้น ๆ
4. จากนั้นก็ <td> คือแต่ละ column ของ row นั้น ๆ ซึ่งอาจจะเป็น column ที่ 2 หรือ column ที่ 3 ก็ได้ (เช่น sample (4) และ (5))

(4) //*[@id="mw-content-text"]/div/table[4]/tbody/tr[3]/td[3]/b/a    (ตาราง 2 บรรทัด 1)
(5) //*[@id="mw-content-text"]/div/table[4]/tbody/tr[30]/td[2]/b/a   (ตาราง 2 บรรทัด 28)

5. แล้วก็อาจจะมี หรือไม่มี <b> ก็ได้ (กรณีที่ไม่มี <b> ดู sample ที่ (8))

(8) //*[@id="mw-content-text"]/div/table[24]/tbody/tr[3]/td[3]/a/b   (ตาราง 22 บรรทัด 1)

6. ตามด้วย <a> คือข้อความที่เป็น link
7. แล้วก็อาจจะมี หรือไม่มี <b> ก็ได้

นี่ก็เป็นข้อสังเกตุทั้งหมดที่เราได้จาก sample ของเรานะครับ

3. สร้าง XPath (จริง ๆ สักที 555)

ต่อไป จากข้อสังเกตุทั้ง 7 ข้อ ด้านบน เราก็ได้ทราบแล้วว่า elements ที่เราต้องการ จะมี XPath ลักษณะอย่างไร ทีนี้เรานำข้อสังเกตุทั้งหมดมารวมกัน เพื่อสร้าง XPath ขึ้นมา 1 อัน ที่สามารถครอบคลุม cases ที่กล่าวมาได้ทั้งหมด! โดยใช้การเขียน condition มาเพื่อช่วยเลือก elements ที่ต้องการนะครับ อันดับแรกก็เริ่มจาก XPath ที่ทุก sample มีร่วมกันก่อน ก็คือ

//*[@id="mw-content-text"]/div/table

ทีนี้ ก็จะเริ่มใส่ condition ตามข้อสังเกตุของเราข้างต้นแล้วนะครับ
1. เราต้องการเลือกตารางตั้งแต่ตารางที่ 3 ขึ้นไปเท่านั้น วิธีการคือให้ใส่ condition เข้าไป ว่า position ของ <table> เนี่ย ต้องมากกว่าหรือเท่ากับ 3 ครับ ซึ่งเขียนเป็น condition ได้ว่า position() >= 3 ก็จะได้ XPath เป็น

//*[@id="mw-content-text"]/div/table[position() >= 3]

2. ตามด้วย <tbody> และ <tr> ก็เติมเข้าไปตรง ๆ ได้เลยครับ

//*[@id="mw-content-text"]/div/table[position() >= 3]/tbody/tr

3. ตามด้วย <td> แต่เราจะเอาเฉพาะ column ที่ 2 หรือ 3 เท่านั้น วิธีหนึ่งที่ทำได้ก็คือ ใส่ condition ว่า position ของ <td> เนี่ย ต้อง >= 2 และ <= 3 ซึ่งเขียน condition ออกมาได้ว่า 2 <= position() and position() <= 3 จึงได้ XPath เป็น

//*[@id="mw-c.../tbody/tr/td[2 <= position() and position() <= 3]

4. อย่างที่สังเกตุว่าบาง sample ก็มี <b> ขึ้นก่อนแล้วตามด้วย <a> (/b/a/)
หรือบาง sample ก็เป็น <a> ขึ้นก่อน แล้วตามด้วย <b> (/a/b/)
แล้วยังมี <b> แล้ว <a> แล้ว <b> อีก (/b/a/b/)
โชคดีที่ใน XPath เราสามารถละได้ โดยการเขียนเป็น //a// จะหมายถึงว่าจะมี element อะไรขึ้นก่อน <a> ก็ได้ (กี่ elements ก็ได้ หรือจะไม่มีก็ได้) แล้วตามด้วย elements อะไรก็ได้ (กี่ elements ก็ได้ หรือจะไม่มีก็ได้) แล้วตัว engine ก็จะหาทุก ๆ elements ที่เป็นไปได้มาให้เองครับ

//*[@id="mw-c.../tbody/tr/td[2 <= position() and position() <= 3]//a//

note: ซึ่งการละใน XPath นี้ ต้องระวังในการใช้สักเล็กน้อยนะครับ อย่าง //a// อาจหมายถึง /b/a ก็ได้ หรือ /b/a/b ก็ได้ หรืออาจหมายถึง /b/div/a/div/b/a/b/div ก็ได้ คือในส่วนที่ละ จะแทนเป็นอะไรก็ได้นั่นเองครับ

5. สุดท้ายตามด้วย text() คือต้องการเอาเฉพาะข้อความที่อยู่ใน element นั้นออกมา

//*[@id="mw-c.../tbody/tr/td[2 <= position() and position() <= 3]//a//text()

ได้ XPath สุดท้ายเป็น

//*[@id="mw-content-text"]/div/table[position() >= 3]/tbody/tr/td[2 <= position() and position() <= 3]//a//text()

ซึ่งเป็น XPath ที่เรามั่นใจว่าและครอบคลุมทุกกรณีที่เรา sample ออกมา และ(หวังว่า)จะครอบคลุมข้อมูลที่เราต้องการจริง ๆ ทั้งหมด

และเป็น XPath ที่เราก็ได้นำไปใช้จริงแล้วในการ extract รายชื่อเทศบาลตำบล ใน บทความ part ที่ 1 นั่นเองครับ

Summary

สำหรับการสร้าง XPath นั้น วิธีการที่นำเสนอไปก็เป็นหนึ่งในวิธีที่สามารถทำได้ง่าย ๆ ซึ่งเราจะสามารถมั่นใจได้ในระดับหนึ่งว่า XPath ที่ได้มานั้น ครอบคลุมข้อมูลส่วนใหญ่ โดยทำการ sample ออกมาให้มากขึ้น และ sample ในหลาย ๆ จุดที่แตกต่างกัน กระจาย ๆ กันไป แต่อาจจะต้องอาศัยความรู้ในเรื่อง syntax และคำสั่งของ XPath สักเล็กน้อยสำหรับการเขียน condition เพื่อ select element ต่าง ๆ นะครับ

ซึ่งจริง ๆ แล้ว ผู้เขียนเองก็ไม่ได้จำคำสั่งของ XPath ได้ทั้งหมดจริง ๆ หรอกครับ เมื่อจำเป็นต้องใช้ที ก็ search หาจาก internet เอา โดยผู้เขียนพบว่า เว็บ w3school ได้ทำรายการของคำสั่งต่าง ๆ พร้อมคำอธิบายเอาไว้ได้ดีและครบถ้วนแล้ว ทุก ๆ ท่านสามารถนำไปใช้เพื่ออ้างอิงขณะที่เขียนได้เลยครับ link นี้เลยครับ

และถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

Python Web Scraping part 2 - Chrome's Code Inspector เว็บบราวเซอร์เรา ทำอะไรได้มากกว่าที่คิด

CopyPasteEngineer — Sun, 05 Apr 2020 08:25:47 +0000

ต่อเนื่องจาก บทความในตอนที่แล้ว part 1 เราได้ลองดึงข้อมูลจาก Wikipedia ด้วย Python แบบง่าย ๆ ดูแล้ว ถ้ายังจำได้ หลังจากที่เรา scrape ข้อมูลดิบ เป็นโค้ด HTML ยาว ๆ ลงมาใน Python แล้ว ในส่วนของการ extract ข้อมูล เราใช้ XPath เพื่อ select elements ที่ต้องการออกมา

ซึ่งผู้เขียนได้แอบบอกไว้แล้วว่า XPath ที่ได้มานั้น มาจากการแกะโค้ด HTML ของเว็บต้นทาง โดยใช้เครื่องมือ Code Inspector บน Google Chrome Browser

บทความนี้จะมาพูดถึงเครื่องมือตัวนี้กันครับ ว่ามันจะช่วยให้เราดูดข้อมูลได้ง่ายขึ้นอย่างไรบ้าง

จริง ๆ แล้วตัว Code Inspector นี่มันเป็นแค่หนึ่งในหลาย ๆ tools ที่ Google Chrome มีให้ใน Google Chrome DevTools เท่านั้นนะครับ โดยจุดประสงค์หลัก ๆ ของ tools ทั้งหลายก็คือใช้เพื่อ debug เว็บที่เราเขียนขึ้นเอง โดยผู้ใช้สามารถเรียกดูได้ทั้งโครงสร้าง การทำงาน และ data ของเว็บที่รันอยู่แบบ real-time เลย ซึ่งล้วนแล้วแต่เป็น information ที่มีประโยชน์ต่อการ scrape ข้อมูลทั้งสิ้นครับ

โดยในครั้งนี้จะมาแนะนำ Code Inspector ให้รู้จักกันคร่าว ๆ ว่ามันทำอะไรได้บ้าง แล้วจะใช้เพื่อแกะ XPath ออกมาจากโค้ดได้อย่างไรนะครับ แล้วในบทความถัด ๆ ไป จะสอน tool อีกตัวที่ช่วยให้เราเข้าใจการทำงานของเว็บนั้น ๆ มากขึ้น เช่น กดปุ่มนี้แล้วเว็บจะโหลดข้อมูลอะไรมาจากที่ไหน ด้วย tool ที่ชื่อว่า Network Inspector บน Google Chrome เช่นกันครับ

Get Started!

ตัว Code Inspector นี่ สำหรับ developer จะเอาไว้ใช้ตรวจสอบว่าหน้าเว็บที่เราเขียนนั้น render ออกมาเป็น code HTML ได้ถูกต้องหรือไม่ ทั้งโครงสร้างของ HTML และ attributes ต่าง ๆ

note: อธิบายสำหรับท่านที่ไม่ได้เป็น web developer นะครับ บางที web page ที่เราเห็นนั้นอาจจะไม่ได้เขียนด้วย HTML ไฟล์เดียวทั้งหมดนะครับ อาจจะมาจาก HTML หลายไฟล์มารวมกัน หรือถูก render ลงมาเป็น HTML จาก server ต้นทางอีกที ทำให้ในการ develop ฝั่ง server อาจจะต้องดูผลลัพธ์ไปพร้อม ๆ กัน ว่า HTML code ถูก rendered ออกมาตามที่ต้องการหรือไม่

ซึ่งประโยชน์หลัก ๆ ที่เราจะได้จาก Code Inspector ก็คือใช้หา XPath หรือหาวิธีการ extract ข้อมูลจากหน้าเว็บนั้น ๆ เช่น ดู id ของ elements ที่เราสนใจ

วิธีการเรียก Code Inspect คือให้เข้าไปที่ website ที่ต้องการ ด้วย Google Chrome Browser แล้วกด F12 ก็จะมีแถบด้านขวา (หรือด้านล่าง) ที่แสดง HTML elements ของ page ปัจจุบัน ปรากฎออกมาตามภาพ

Highlight ตำแหน่งของ Component จาก Element

โดยเราสามารถ คลิกเพื่อ expand elements ย่อย ๆ ออก แล้วเข้าไปดูโครงสร้างที่ซ่อนไว้ได้ หรือถ้าหากลองเอาเมาส์ไปชี้ที่ element ในนั้นดู Chrome ก็จะข่วย highlight บอกเราให้ด้วย ว่า element นั้น อยู่ตรงไหนบนหน้าเว็บ

Highlight Element จาก Component

หรือในกรณีที่เราอยากทราบว่าตัว component บนหน้าเว็บ เช่น ตารางที่เราเห็นอยู่นี้ มันคือ element ในโค้ด HTML ก็สามารถทำได้ โดยการ คลิกขวาที่ component นั้น ๆ แล้วเลือก Inspect จากนั้นตัว Code Inspector ก็จะไป highlight HTML element ของ component ให้ทันทีครับ

แกะ XPath ของ Component แบบเบสิก

เมื่อเราคลิกเลือก element ที่เราสนใจได้แล้ว หากเราอยากจะได้ XPath ของ element นั้น ๆ มา Inspector ก็สามารถหาให้เราแบบง่าย ๆ ได้ (แต่อาจจะไม่ค่อยตรงใจเราสักเท่าไหร่555)

เช่น สมมุติว่าเราอยากจะได้ XPath ของ เทศบาลตำบลบ้านดู่ ก็ให้หา element ของมันให้ได้ก่อนตามที่อธิบายไว้ด้านบน คือคลิกขวาที่ เทศบาลตำบลบ้านดู่ แล้วเลือก Inspect Inspector ก็จะ highlight element ของ เทศบาลตำบลบ้านดู่ ไว้ให้
จากนั้นก็หา XPath โดยการ คลิกขวาที่ element นั้น แล้วเลือก Copy แล้วก็ Copy XPath

ถ้าลอง paste ดูก็จะได้ XPath ของ เทศบาลตำบลบ้านดู่ แบบนี้ครับ

//*[@id="mw-content-text"]/div/table[3]/tbody/tr[1]/td[3]/b/a

แต่ XPath นี้เป็นแค่ของ เทศบาลตำบลบ้านดู่ เท่านั้นครับ แต่สิ่งที่ต้องการจริง ๆ คือ ชื่อเทศบาลทั้งหมด ถามว่าจะหามาได้อย่างไร?

ถ้ามีประสบการณ์การทำเว็บมาบ้าง พอเห็นข้างบนก็อาจจะเดาได้แล้วว่า XPath ที่เหมาะสมควรจะเป็นอะไรนะครับ แต่ถ้ายังเดาไม่ออกก็ไม่เป็นไรครับ เพราะอย่างบาง website ที่ซับซ้อนขึ้นหน่อย ถึงจะพอมีประสบการณ์ก็คงเดาไม่ออกในทีแรกเช่นกัน

วิธีหนึ่งที่ผมทำก็คือใช้ตัว Chrome Inspector นี่แหละ เอาตัวอย่างของ XPath จากเทศบาลตำบลอันอื่น ๆ ออกมาดูเพิ่มอีกเยอะ ๆ ก็จะช่วยให้เห็นภาพมากขึ้นครับ

 (1) //*[@id="mw-content-text"]/div/table[3]/tbody/tr[1]/td[3]/b/a    (ตาราง 1 บรรทัด 1)
 (2) //*[@id="mw-content-text"]/div/table[3]/tbody/tr[2]/td[3]/b/a    (ตาราง 1 บรรทัด 2)
 (3) //*[@id="mw-content-text"]/div/table[3]/tbody/tr[10]/td[3]/b/a   (ตาราง 1 บรรทัด 10)
 (4) //*[@id="mw-content-text"]/div/table[4]/tbody/tr[3]/td[3]/b/a    (ตาราง 2 บรรทัด 1)
 (5) //*[@id="mw-content-text"]/div/table[4]/tbody/tr[30]/td[2]/b/a   (ตาราง 2 บรรทัด 28)
 (6) //*[@id="mw-content-text"]/div/table[7]/tbody/tr[25]/td[2]/b/a/b (ตาราง 5 บรรทัด 23)
 (7) //*[@id="mw-content-text"]/div/table[10]/tbody/tr[41]/td[2]/b/a  (ตาราง 8 บรรทัดสุดท้าย)
 (8) //*[@id="mw-content-text"]/div/table[24]/tbody/tr[3]/td[3]/a/b   (ตาราง 22 บรรทัด 1)
 (9) //*[@id="mw-content-text"]/div/table[76]/tbody/tr[3]/td[3]/b/a   (ตารางสุดท้าย บรรทัด 1)
(10) //*[@id="mw-content-text"]/div/table[76]/tbody/tr[37]/td[2]/b/a  (ตารางสุดท้าย บรรทัดสุดท้าย)

...แล้วยังไงต่อ... ใช่ไหมครับ 555
ต่อไปเราก็จะสร้าง XPath 1 อัน ที่สามารถครอบคลุมทุกกรณีที่เราเจอมาโดยการใส่ condition เพื่อช่วยเลือก โดยผลลัพธ์สุดท้ายก็จะได้เป็น XPath ที่เราใช้จริง ใน part ที่ 1 นั่นเองครับ ซึ่งจะอธิบายวิธีการโดยละเอียดต่อใน part 3 นะครับ

Summary

สำหรับ part ที่ 2 นี้ จุดประสงค์หลัก ก็คือแนะนำ tool ที่ชื่อ Code Inspector ใน Google Chrome ครับ ซึ่งเป็น tool ที่ช่วยให้สามารถ extract ข้อมูลได้ง่ายขึ้นมาก และผู้เขียนได้ใช้หา XPath ไปจริง ๆ ใน บทความ part 1 ครับ

บทความนี้เราจะค้างเอาไว้ตรงที่เรา sample XPath ออกมาเยอะ ๆ นะครับ แล้วใน part ที่ 3 ก็จะมาอธิบายให้ฟังว่าจะทำยังไงต่อ เพื่อให้ได้ XPath ที่เราใช้ไปใน part ที่ 1 นะครับ

หรือถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

Python Web Scraping part 1 - การดูดข้อมูลเบื้องต้น ด้วย Python

CopyPasteEngineer — Sun, 29 Mar 2020 04:22:24 +0000

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

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

ช่วงหลัง ๆ มานี้ เพื่อน ๆ ของผมหลาย ๆ ท่านที่เป็น Data Scientist เอง ก็ทักมาถามค่อนข้างบ่อย เกี่ยวกับการทำ Web Scraping เพื่อเก็บข้อมูลที่มีอยู่ใน Internet มาทำการวิเคราะห์ เพราะสำหรับการวิเคราะห์ข้อมูล ซึ่งเป็นงานของ Data Scientist แล้ว สิ่งที่สำคัญที่สุดก็คงจะเป็น ข้อมูล นั่นแหละครับ
นอกจากนี้ บริษัทใหญ่ ๆ หลาย ๆ แห่ง ก็ยังใช้ประโยชน์จากการทำ Web Scraping ในการเก็บรวบรวมความคิดเห็นของ social เพื่อเอามาวิเคราะห์ปรับปรุงผลิตภัณฑ์ของตัวเองได้อีกด้วย เช่น เก็บ complains ต่าง ๆ เกี่ยวกับผลิตภัณฑ์ในแต่ละชนิด หรือแม้กระทั่งการทำ sentiment analysis ด้วย technique NLP เพื่อดูว่า ความรู้สึก ของลูกค้าหลังการใช้บริการเป็นอย่างไร จาก comment หรือ post ต่าง ๆ ในโลกออนไลน์แบบ real-time

ในบทความนี้ก็เลยอยากจะเล่า flow ของการดูดข้อมูลแบบง่าย ๆ ซึ่งเหมาะสำหรับท่านที่พอจะเขียน Python ได้บ้างจนถึงชำนาญ และสนใจศึกษาเกี่ยวกับการทำ Web Scraping ครับ โดยในตัวอย่างนี้จะใช้เว็บ Wikipedia ซึ่งสามารถ scrape ได้ง่าย เหมาะกับผู้เริ่มต้นครับ

โดยในบทความนี้จะนำเสนอเพียงแค่ basic เพื่อให้ผู้อ่านได้เห็นภาพรวมกว้าง ๆ ก่อน และจะกลับมาอธิบายลงลึกในแต่ละส่วนแยกกันไปในบทความถัด ๆ ไปอีกทีครับ

Get Started!

ก่อนอื่นจะขอแนะนำเครื่องมือที่ต้องใช้ก่อน จากนั้นก็จะแนะนำ flow ของการ scrape แบบง่าย ๆ พร้อมกับตัวอย่างโค้ดให้นำไปทดลองกันได้ง่าย ๆ ครับ

สึ่งที่ต้องเตรียม...

1. Python แน่นอนว่าถ้าจะเขียน Python script ก็ต้องมีโปรแกรมสำหรับ run script ก่อน ซึ่งตรงนี้สำหรับท่านที่ยังไม่มี Python ในเครื่อง ก็สามารถ install ได้จาก link นี้ โดยแนะนำให้ใช้ version ตั้งแต่ 3.6 ขึ้นไปครับ

แต่ถ้าหากไม่สะดวก install ลงในเครื่องที่ใช้อยู่ก็สามารถ execute Python script online ได้โดยใช้บริการ Google Colab Notebook ของ Google ซึ่งสามารถแก้ไข และ execute Python script ทีละ block ได้ ผ่าน web browser จึงไม่จำเป็นต้อง install หรือ download อะไรลงในเครื่องทั้งสิ้นครับ

โดยโค้ดทั้งหมดที่ใช้ในบทความนี้จะแชร์ผ่าน Google Colab ด้วยเช่นกัน เนื่องจาก Data Scientist ส่วนใหญ่น่าจะคุ้นเคยกับ interface ลักษณะนี้ดี

ภาพ Google Colab Notebook

2. modules สำหรับการ scrape Python modules ที่จำเป็นต้องใช้ในบทความนี้ ได้แก่ requests, และ lxml โดยสามารถ install ผ่านโปรแกรม pip ของ Python ได้จากคำสั่งต่อไปนี้

pip install requests lxml

สำหรับท่านที่ใช้โค้ดบน Google Colab จะมี modules เหล่านี้ installed ไว้อยู่แล้ว ดังนั้นจึงไม่ต้องทำอะไรเพิ่มเติมครับ

เริ่มกันเถอะ!

code สำหรับบทความนี้จะแชร์ไว้ใน Google Colab ตาม link นี้ นะครับ
ถ้าสะดวกสามารถเปิดโค้ดตามและทดลองแก้ไขและรันดูไปพร้อม ๆ กับที่อ่านบทความได้เลยนะครับ
โดยการคลิกแทบ File ด้านบนของ Colab แล้วเลือก Save a copy in Drive... ก็จะสามารถแก้ไขได้ และ save ลง Google Drive ให้อัตโนมัติครับ
ผู้อ่านสามารถรันโค้ดบน Colab ได้โดยการคลิกเลือกแต่ละ block แล้วกด Ctrl+Enter

Python Web Scraping

สมมุติว่า เราต้องการจะดูดข้อมูลจาก https://th.wikipedia.org/wiki/รายชื่อเทศบาลตำบลในประเทศไทย เพื่อเก็บรายชื่อของเทศบาลตำบลทั้งหมดในประเทศไทย ก็อาจจะแบ่งได้เป็น 2 ขั้นตอน คือ Scrape และ Extract

Wikipedia Page ที่จะทำการ scrape

1. Scrape ขั้นตอนแรกก็คือต้องเอาข้อมูลจากหน้าเว็บแบบดิบ ๆ เนี่ย ออกมาให้ได้ก่อน ซึ่งในเว็บอื่น ๆ ทั่ว ๆ ไป ก็จะมีความซับซ้อนหลาย ๆ อย่างที่ทำให้ไม่สามารถดึงออกมาได้ง่าย ๆ ซึ่งจะนำเสนอเทคนิคต่าง ๆ ที่ใช้รับมือแต่ละ cases ในบทความถัด ๆ ไปนะครับ
แต่เนื่องจากในส่วนนี้เราใช้ Web Wikipedia เป็นตัวอย่าง ซึ่งไม่ได้มีการป้องการ scrape หรือกลไกที่ซับซ้อนอะไรมาก เพราะงั้นสามารถส่ง GET request ไปที่ URL โดยตรงตามโค้ดด้านล่างได้เลยครับ

import requests

url = 'https://th.wikipedia.org/wiki/รายชื่อเทศบาลตำบลในประเทศไทย'
resp = requests.get(url)
print(resp)

# Output: <Response [200]>

จากโค้ดด้านบนเราจะได้ object ของ Response มาเก็บไว้ในตัวแปร resp
โดยเราสามารถเรียกดู content ของ response ที่ได้กลับมาได้โดยใช้ resp.content หรือ resp.text แตกต่างกันเล็กน้อย คือ .content จะให้ค่า content ที่เป็น bytes ออกมา ส่วน .text จะ decode ข้อมูล bytes ออกเป็น string ให้ จึงสามารถแสดงตัวอักษรภาษาต่าง ๆ ให้ดูได้ เช่นภาษาไทย

print(resp.text[:5_000])

คำสั่งด้านบนจะเรียกดูข้อมูลจำนวน 5,000 ตัวอักษรแรก (limit ไว้เพื่อไม่ให้มันรกเฉย ๆ)

จะเห็นว่าเราได้โค้ด HTML ของหน้า page นั้น ๆ มาทั้งหมด
นั่นคือตอนนี้เราดึงข้อมูลดิบของหน้าเว็บนั้นมาอยู่ใน Python เรียบร้อยแล้ว

2. Extract ต่อไปเราจะนำข้อมูลดิบที่ได้มา มากรองให้เหลือแค่ข้อมูลที่เราอยากได้เท่านั้น นั่นก็คือชื่อเทศบาลตำบล
โดยทั่วไปในการ extract ข้อมูล วิธีการที่จะใช้นั้นก็ขึ้นอยู่กับหน้าตาของข้อมูล เช่น เป็น HTML, เป็น JSON, หรือเป็น plain text ซึ่ง modules ใน Python ที่จะนำมาใช้กับข้อมูลแต่ละประเภทก็มีหลายอย่าง เช่น lxml, json, beautifulsoup, หรือ re
ในกรณีนี้ เนื่องจากข้อมูลดิบเราเป็น HTML ผู้เขียนจึงใช้ lxml เนื่องจาก lxml มีฟังก์ชันที่ใช้แปลงข้อมูล HTML ให้กลายเป็น tree ซึ่งช่วยให้เราสามารถ extract แต่ละ element ใน HTML ได้ง่าย (เป็นความเห็นส่วนตัวนะครับ บางท่านอาจจะถนัดใช้ beautifulsoup มากกว่า ซึ่งอาจจะเขียนถึงในบทความถัด ๆ ไป)

import lxml.etree

content = resp.content
tree = lxml.etree.fromstring(content, parser=lxml.etree.HTMLParser())
print(tree)

# Output: <Element html at 0x7f34c830e948>

note: เราต้องระบุ parser ให้เป็น HTMLParser เนื่องจากจริง ๆ แล้ว lxml สามารถใช้กับข้อมูลประเภทอื่นนอกจาก HTML ได้ด้วย

พอเราแปลงข้อมูลเป็น tree แล้ว ต่อไปเราก็จะสามารถระบุตำแหน่งของ element ที่เก็บข้อมูลที่เราต้องการได้โดยใช้ XPath
อธิบายแบบคร่าว ๆ XPath ก็คล้าย ๆ กับ path ของ folder ต่าง ๆ ในเครื่องคอมพิวเตอร์ ที่เอาไว้ระบุตำแหน่งไฟล์หรือ folder ที่เราต้องการ โดยเริ่มจาก root (C:/) แล้วก็ไปยัง folder ต่าง ๆ ตามลำดับ เช่น C:/Users/CopyPasteEng/Downloads แต่ XPath ในที่นี้จะใช้ระบุตำแหน่งของ HTML element บนโค้ด code แทน
ตัวอย่าง XPath เช่น //div[@id="mw-content-text"]/div/p/text() อันนี้จะแปลว่า

1. ให้เข้าไปหา element ประเภท div ที่มี id เป็น "mw-content-text"
2. จากนั้นเข้าต่อไปที่ child element ที่เป็นประเภท div
3. แล้วก็เข้าต่อไปที่ element ประเภท p
4. แล้วเอา content ที่เป็น text ทั้งหมดออกมา

note: div[...] คือการใส่เงื่อนไขในการเลือก div นั้น ๆ เข้าไป ในกรณีด้านบน เงื่อนไขก็คือ attribute id ต้องเท่ากับ mw-content-text

ทีนี้คำถามต่อมาก็คือจะเอา XPath ที่บอกตำแหน่งของข้อมูลที่เราต้องการมาได้อย่างไร
คำตอบก็คือต้องดูจาก code ของ page ครับ ไม่มีทางอื่น 555
ซึ่งเครื่องมือหนึ่งที่สามารถช่วยให้แกะโค้ดของ web ต่าง ๆ ได้ง่าย ๆ และฟรี ก็คือ Code Inspector บน Google Chrome ครับ สามารถเปิดขึ้นมาได้โดยคลิกขวาที่หน้าเว็บแล้วเลือก Inspect หรือกด F12

กลับมาที่เว็บตัวอย่างของเราครับ XPath ของชื่อเทศบาลตำบลทั้งหมดที่เราต้องการก็คือ //*[@id="mw-content-text"]/div/table[2 <= position()]/tbody/tr/td[2 <= position() and position() <= 3]//a//text()* เราจึงสามารถที่จะ extract ข้อมูลออกจาก tree ได้ด้วยคำสั่งต่อไปนี้ ก็จะได้ชื่อของเทศบาลตำบลในประเทศไทยจาก Wikipedia มาเก็บเป็น list เอาไว้ได้ตามต้องการครับ

xpath = '//*[@id="mw-content-text"]/div/table[2 <= position()]/tbody/tr/td[2 <= position() and position() <= 3]//a//text()'
tambon_list = tree.xpath(xpath)
print(tambon_list)

# Output: ['เทศบาลตำบลบ้านดู่', 'เทศบาลตำบลเวียงชัย', ...

*เดี๋ยวจะอธิบายที่มาและความหมายของ XPath ตัวนี้ใน part ที่ 3 นะครับ ตอนนี้ของข้ามไปก่อน

เพื่อให้บทความกระชับ ผู้จัดทำได้ละรายละเอียดบางส่วนเอาไว้
เพราะจริง ๆ แล้ว ทั้งในส่วนของการ scrape และ extract ก็มีรายละเอียดอีกมาก และมีเทคนิคที่อาจจะต้องใช้มากมายซึ่งแตกต่างกันตามแต่ละ website เช่น XPath ที่อยู่ใน code นี่ได้มาได้ยังไง? จะทำอย่างไรกับบาง website ที่มีกลไกที่ป้องกันการ scraping หรือบาง website ที่มี format ขอข้อมูลเป็นลักษณะอื่น

เพื่อให้ผู้อ่านได้รับข้อมูลครบถ้วน ในบทความนี้จึงนำเสนอเพียงแค่ basic ให้ผู้อ่านได้เห็นภาพรวมกว้าง ๆ ก่อน และคิดว่าจะกลับมาอธิบายลงลึกในแต่ละส่วนแยกกันไปอีกทีครับ

Summary

คิดว่าจากบทความนี้ ผู้อ่านน่าจะได้เห็นภาพของการ scrape แบบง่าย ๆ ไปแล้วสำหรับการเริ่มต้น ในบทความถัดไปเราก็จะสามารถไปดูเคสที่ซับซ้อนกันต่อได้ครับ

อย่างที่ได้กล่าวไปข้างต้นครับ ว่าในการวิเคราะห์ข้อมูลเพื่อทำนายเหตุการณ์ต่าง ๆ ให้ถูกต้องและแม่นยำสิ่งที่สำคัญที่สุดคือ ข้อมูล ที่อัพเดตตลอดเวลา
ซึ่งเราอาจจะมอง Internet เป็นเหมือนแหล่งข้อมูลฟรี ที่เราสามารถ scrape มายังไงก็ได้ แต่ควรคำนึงถึงเรื่องของกฎหมายและความเหมาะสมด้วยครับ สิ่งสำคัญก็คือต้องไม่ทำให้ใครเดือดร้อน

และสำหรับท่านที่สนใจอยากทราบรายละเอียดของแต่ละขั้นตอนอย่างละเอียด ก็สามารถติดตามได้ในบทความที่จะลงต่อ ๆ ไปนะครับ

หรือถ้ามีเรื่องไหนที่สนใจเพิ่มเติมสามารถ comment เอาไว้ได้นะครับ

FB Page: Copy Paste Engineer

- ขอบคุณที่อ่านครับ -

มาใช้ Google Cloud ฟรี 300 ดอลล่าร์กันเถอะ!!!

CopyPasteEngineer — Mon, 02 Mar 2020 12:31:43 +0000

คิดว่าหลาย ๆ ท่านน่าจะเคยได้ยินว่าบริษัทต่าง ๆ ในปัจจุบัน โดยเฉพาะพวก startup มักจะบ่นว่า developer นี่หายาก! ทั้ง ๆ ที่ตามเว็บต่าง ๆ หรือตามเพจโปรแกรมเมอร์หลาย ๆ กลุ่มก็มี developer อยู่เต็มไปหมด (หลายคนก็ว่างงานด้วยซ้ำ...)

ก็อาจจะเป็นเพราะว่าพวก startup เองเนี่ย มันเกิดขึ้นมาเรื่อย ๆ ยังเป็นเทรนอยู่ ก็มีเจ้าใหม่ ๆ ทั้งเกิดและตายทุกเดือน จึงมีจำนวนมากกว่า developer มาก

หรืออาจจะเป็นเพราะว่า developer เองเนี่ย ไม่มีความสามารถมากพอ ก็เป็นไปได้ (พูดในมุมมองคนจ้างนะครับ ไม่ใช่ผม 555)

หรืออาจจะเพราะทั้งสองเหตุผล

แต่ไม่ว่าอย่างไหน ก็ปฎิเสธไม่ได้ว่า ถึงแม้ในด้าน tech จะมีเทรนใหม่ ๆ เกิดขึ้นมามากมาย แต่ developer ก็ยังจำเป็น และมีความต้องการในตลาดสูงไม่เปลี่ยนจริง ๆ

แล้วความสามารถของ developer ในปัจจุบันล่ะ มีความพร้อมแค่ไหน?

ทำไมต้องใช้ Cloud

สำหรับเด็กจบใหม่หรือคนที่เพิ่งเริ่มศึกษา เคยไหมครับที่คิดอยากจะลองศึกษา อยากตามเทคโนโลยีใหม่ ๆ ดู เช่น แค่อยากทดลอง deploy ระบบอะไรบางอย่างให้มันสามารถทำงานได้จริง บน server จริง ๆ หรือทำ prototype ไปเสนองาน แต่พบว่ามันมีปัญหาอื่น ๆ ที่ซับซ้อนตามมา หรือหลาย ๆ ครั้ง จำเป็นต้องใช้เงินจำนวนมาก อย่างเช่น อยากลองทำ Kubernetes ให้ auto-scale ได้ อยากทดลอง false-tolerant แต่มันจำเป็นต้องใช้เงินมากในการซื้อ hardware มาตั้งเอง เพื่อสร้าง cluster ขึ้นมาจริง ๆ ซึ่งไม่คุ้มกับการทดลองแค่ครั้งสองครั้ง หรือต่อให้มี hardware แล้วก็ต้องยุ่งกับการ setup cluster ขึ้นมาซึ่งค่อนข้างวุ่นวาย และไม่เกี่ยวข้อง

ในตอนแรกที่เริ่มศึกษา ผมก็รู้สึกว่า cost ของ hardware อาจจะเป็นเหมือนกำแพงอันใหญ่ ๆ อีกอันนึงสำหรับ new comer ที่เริ่มศึกษาในด้านนี้ก็เป็นไปได้

ในอีกด้านหนึ่ง สำหรับบริษัท startup เอง ถ้าให้เริ่มต้นโดยการซื้อเครื่องแพง ๆ มาเพื่อตั้ง server เอง ก็อาจจะไม่เหมาะ เพราะ startup เองก็มีความเสี่ยงสูง คือไม่รู้ว่าจะมีลูกค้ามาเท่าไหร่

เช่น ถ้าเราซื้อ server มาน้อยไป user เยอะกว่ามาก application ก็อาจจะล่ม หรือถ้าซื้อมาเยอะกว่า user ก็ไม่คุ้มอีก

แล้วยังมีกรณีที่ลูกค้าเลิกเห่อในตอนหลังอีก อย่างเกมส์ Pokemon GO ที่ตอนแรก ๆ user เยอะมาก แต่ผ่านไปสักพัก กลับเหลือคนเล่นอยู่แค่บางกลุ่มเท่านั้น ในกรณีนี้เราอาจจะซื้อ hardware มาตั้งเองเยอะ ๆ ให้รับ user ในช่วงแรกได้ก็จริง แต่หลังจากที่คนเล่นเลิกเห่อแล้ว จะทำยังไงกับ hardware พวกนั้น?

จำนวน active users ของเกมส์ Pokemon GO ในช่วงปี 2016-2017 ที่ลดลงจากช่วงแรกมาก
ที่มา: Gen 2 Caused A Huge Spike In 'Pokémon GO' Play, But It's Fading Fast

ซึ่งปัญหานี้จะหมดไปถ้าเราใช้บริการ Cloud เนื่องจาก feature หลักของ Cloud Platform ไม่ว่าเจ้าไหนก็ตาม คือเราจะต้องสามารถ manage resource ต่าง ๆ ได้เอง ผ่าน online user interface เพราะฉะนั้น ไม่ว่าจะเป็นจำนวนเครื่อง server หรือ spec ของเครื่อง เราก็สามารถที่จะเพิ่มเมื่อจำเป็นต้องใช้มากขึ้น หรือลดลง หรือลบทิ้ง เมื่อไม่มีความจำเป็นต้องใช้แล้วได้ตลอดเวลา

อีกทั้งยังมี service ต่าง ๆ provide ให้ในหลาย ๆ ระดับ ตั้งแต่การเช่าเครื่องเปล่า (Infrastructure as a Service) ไปจนถึง deploy ในระดับ function เล็ก ๆ ที่ช่วยอำนวยความสะดวกให้เราส่งแค่โค้ดขึ้นไปรันได้เลย ไม่ต้อง manage infrastructure หรือ setup environment เอง (Function as a Service)

ภาพ User Interface ของ Google Cloud Platform สำหรับ manage VM instances

และ Cloud Providers ส่วนใหญ่ ไม่ว่าจะเป็น Google หรือ Amazon ก็มักจะมี quota ให้ทดลองใช้ฟรีกันทั้งสิ้น ซึ่งเหมาะอย่างมากกับการสร้าง prototype เล็ก ๆ เพื่อการศึกษา หรือ pitching

โดยสำหรับ Google Cloud Platform ที่เราจะพูดถึงกันในบทความนี้ มี quota ให้ใช้ฟรี $300 ต่อ account เป็นเวลา 12 เดือน และถึงจะใช้หมดแล้วก็ไม่ต้องกลัวว่าจะถูกหักเงินโดยไม่รู้ตัว เพราะ Google จะ stop service ต่าง ๆ ให้อัตโนมัติ หรือถ้าอยากจะเปลี่ยนไปใช้แบบเสียเงินหลักจากหมด quota แล้วก็สามารถ upgrade ได้ทันทีครับ

ต่อไปเราจะมาดูวิธีการสมัคร Google Cloud Platform ให้ได้เครดิต $300 กันนะครับ

Get Started!

ต่อไปเรามาดูสิ่งที่ต้องเตรียม และขั้นตอนการสมัครโดยละเอียด (ซึ่งอาจจะละเอียดเกินไป555)
หรือถ้าหากต้องการอ่านสรุปสั้น ๆ สามารถข้ามไปที่ส่วน Summary ได้เลยครับ

สิ่งที่ต้องเตรียม...

gmail ใหม่ ๆ 1 email ที่ยังไม่เคยเปิดใช้ Google Cloud Platform มาก่อน

ถ้ายังไม่มี หรือไม่แน่ใจว่าเคยใช้ Google Cloud มาก่อนหรือเปล่า ก็ไปสมัครใหม่ไว้เลยครับ >>> GMail
บัตรเครดิต หรือบัตรเดบิตที่สามารถตัดเงินได้ อันนี้ไม่ต้องตกใจนะครับ ตามหัวข้อของ blog นี้เลย เราจะไม่เสียเงินสักบาทแน่นอนครับ555 แค่ google ต้องการเลขบัตรเอาไว้เพื่อเช็คว่าเราเป็นคนจริง ๆ ไม่ใช่หุ่นยนต์ แล้วเผื่อหลังจากหมดช่วงฟรีแล้วเราอยากจะจ่ายเงินเพื่อใช้บริการต่อไปเลย ก็จะทำได้สะดวก ๆ เท่านั้นเองครับ

ย้ำอีกครั้ง เราจะไม่เสียตังสักบาท

ถ้าพร้อมแล้ว ก็เริ่มกันเลย

เข้าไปที่ console.cloud.google.com ก็จะเจอกับหน้าต้อนรับตามรูปด้านล่างนี้

เช็คเครื่องหมายถูกที่ I agree... แล้วก็กดปุ่ม Continue ได้เลย
ต่อไปคลิกที่ TRY FOR FREE เพื่อรับเครดิต $300
เลือกประเทศไทย, กด I have read and agree... แล้วกด Continue ต่อเลย
ตรงนี้ Google ก็จะถามข้อมูลส่วนตัวเราเล็กน้อย

ก็ให้กรอกข้อมูลลงไปให้ครบครับ account type ให้เลือกเป็น Individual แล้วด้านล่างก็กรอกที่อยู่ address, เมือง, จังหวัด ให้ครบ
ต่อมาส่วนด้านล่าง Google ก็จะถามข้อมูลบัตรเครดิต หรือเดบิตของเรา

อย่างที่บอกเมื่อข้างต้น กรอกไปได้เลยครับ การใช้งานทั้งหมดจะหักจากเครดิต $300 ก่อน แล้วถึงเครดิตจะหมด Services ต่าง ๆ ที่รันอยู่ ก็แค่จะหยุดทำงานไปให้เองครับ

อันนี้ไม่ต้องเชื่อผมก็ได้ ลองอ่านเงื่อนไขเองได้ที่กรอบด้านขวาเลยครับ แต่ก็จะเหมือนกับที่ผมบอกแหละ เพราะผมก็ก๊อปมาจากตรงนั้น555

Google จะไม่หักเงินเราโดยพลการแน่นอน ยกเว้นว่าเราเผลอไปกดยินยอมให้หักเงินได้ นะครับ

กรอกเสร็จแล้วก็คลิก START MY FREE TRIAL ได้เลยครับ

ถ้าหลังจากที่ทำตามแล้วพบว่าบัตรเครดิต หรือเดบิตมีการตัดเงินจาก Google ก็ไม่ต้องตกใจนะครับ บางที Google มันจะอยากยืนยันว่าบัตรที่เรากรอกมาเป็นบัตรที่ใช้งานได้จริงหรือเปล่า เลยลองตัดเงินดูเล่น ๆ แต่สักพักมันก็จะคืนเงินให้เท่าเดิมครับ

ระวัง1: ระวังว่าถ้าบัตรมีเงินน้อยเกินไป อาจจะไม่พอให้ Google ตัด แล้วมันก็จะยังไม่อนุญาตให้เราใช้ account นั้น วิธีแก้คือก็ใส่เงินเอาไว้สักหน่อยให้มันตัดได้ แล้วไปกรอกข้อมูลบัตรใหม่อีกทีครับ

ระวัง2: มีกรณีที่วงเงินของบัตรที่สามารถตัดได้นั้นไม่พอ ให้โทรติดต่อไปที่ธนาคารของบัตรที่เราใช้ แล้วขอขยายวงเงินได้ครับ
เสร็จแล้วก็จะขึ้น message welcome to GCP ขึ้นมา มันก็จะย้ำอีกครั้ง ว่าเราจะไม่ชาร์จคุณนะ ยกเว้นว่าคุณเปิด automatic billing - ถ้าใครอยากเปิด billing เลยก็คลิกเข้าไปตาม link ได้เลยครับ หรือถ้าไม่ก็กดข้ามเลย

พอเสร็จขั้นตอนทั้งหมดแล้วด้านซ้ายมือก็จะมี services ต่าง ๆ ให้ได้ลองใช้กันได้ฟรี ๆ ในงบ $300 ภายในเวลา 12 เดือน

Summary

Google Cloud: provides บริการต่าง ๆ ให้ สามารถสร้าง projects, deploy applications, หรือใช้งาน services ได้ทั้งแบบ manage เอง และ serverless
Goal: Google Cloud Account และ free credit $300
สิ่งที่ต้องเตรียม: gmail ใหม่ และบัตรเครดิต หรือเดบิตที่สามารถตัดเงินได้
วิธีทำ: เข้า console.cloud.google.com คลิก TRY FOR FREE แล้วก็กรอกข้อมูลไปเรื่อย ๆ (แค่นี้จริง ๆ 555)
ข้อควรระวัง: $300 credits จะมีระยะเวลาแค่ 12 เดือนเท่านั้น และถ้าไม่อยากเสียเงินหลังจากนั้น อย่าเผลอไปเปิด auto billing

- ขอบคุณที่อ่านครับ -