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

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

โปรแกรมภาษาไพธอนนั้นเขียนง่าย อ่านง่าย แต่ขึ้นชื่อเรื่องความช้าเมื่อต้องทำงานมากๆเมื่อเทียบกับภาษาอื่นเช่น C หรือ Java

ปกติเรายินดีที่จะเขียนโปรแกรมด้วยภาษาไพธอนเพราะงานส่วนใหญ่คอมพิวเตอร์ประมวลผลแป๊บเดียว จุดเด่นที่ภาษาไพธอนเขียนง่ายและอ่านง่ายเป็นข้อได้เปรียบที่สำคัญ

ในกรณีที่โปรแกรมภาษาไพธอนใช้เวลานานในการประมวลผล เราก็มีทางออกหลายทาง เช่นใช้ Numpy คำนวณให้เมื่อมีข้อมูลหลายๆตัวอยู่ด้วยกันเป็นลิสต์หรืออาเรย์ (รวมทั้งพวกหลายมิติแบบเวคเตอร์, แมตริกซ์, และอื่นๆ) เชิญศึกษาวิธีใช้ได้ที่เว็บนี้ครับ

ถ้าโปรแกรมเราไม่ได้เขียนให้ใช้ Numpy แต่เราอยากให้มันวิ่งเร็วขึ้น โดยไม่อยากดัดแปลงโปรแกรม เราสามารถลองใช้ PyPy มาเรียกโปรแกรมของเรา เมื่อเราติดตั้ง PyPy แล้วเราสามารถเรียกโปรแกรมของเราชื่อ my_program.py ด้วยคำสั่ง pypy my_program.py หรือ pypy3 my_program.py แทน python my_program.py ได้เลย ส่วนใหญ่โปรแกรมจะเร็วขึ้นหลายเท่าเหมือนกัน

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

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

import random

def prob_triangle(ntrials):
    """
    ประมาณความน่าจะเป็นที่เส้นตรงที่ถูกแบ่งเป็นสามส่วนแบบสุ่มๆ
    จะสามารถประกอบเป็นสามเหลี่ยมได้
    
    ทำการทดลอง ntrials ครั้ง
    """
    
    # ntriangles เก็บจำนวนครั้งที่ประกอบเป็นสามเหลี่ยมได้
    ntriangles = 0 
    
    # ทำการทดลองแบ่งเส้นตรงความยาว 1 หน่วยเป็นสามส่วน
    # ทั้งหมดntrials ครั้ง
    
    for n in range(ntrials):
        
        # x, y คือตำแหน่งที่เราสุ่มตัดเส้นตรงสองตำแหน่ง
        # ทำให้แบ่งเส้นตรงเป็นสามส่วน
        # เราจะเรียงตำแหน่งให้ x <= y
        # ถ้าไม่เป็นอย่างนั้นเราจะสลับ x และy
        
        x = random.random()
        y = random.random()
        if x > y:
            x, y = y, x
        
        # เมื่อเราสุ่ม x, y มาตัดเส้นตรงได้แล้ว
        # เราจะมีเส้นตรงสามชิ้นยาว x, y-x, และ 1-y
        # เราจะเรียกชิ้นที่ยาวที่สุดว่า longest
        
        longest = max(x, y-x, 1-y)
        
        # ถ้าชิ้นที่ยาวที่สุดมีความยาวไม่เกิน 1/2 ของ
        # ความยาวเส้นตรงดั้งเดิม เราจะสามารถเอา
        # ทั้งสามชิ้นมาประกอบเป็นสามเหลี่ยมได้
        # และเราก็จะเพิ่มจำนวนครั้งที่ประกอบเป็นสามเหลี่ยมสำเร็จ
        
        if longest < 0.5:
            ntriangles += 1
            
         # ประมาณความน่าจะเป็นที่เป็นสามเหลี่ยมสำเร็จ
         # เท่ากับ (จำนวนสามเหลี่ยม)/(จำนวนครั้งที่ทดลอง)
            
    return ntriangles/ntrials

ลองจับเวลาให้ทดลองกับเส้นตรง 10 ล้านเส้นใช้เวลา 3.67 วินาที:

%time prob_triangle(10_000_000)

CPU times: user 3.66 s, sys: 8.11 ms, total: 3.67 s
Wall time: 3.67 s

0.2499737

เราใช้ Numba โดยพิมพ์เพิ่ม 2 บรรทัดดังนี้ (บรรทัดที่ 1 และ 4)

from numba import njit #เรียกใช้ฟังก์ชั่นต่างๆใน numba
import random

@njit() #เพิ่มบรรทัดนี้เหนือฟังก์ชั่นที่เราเขียนไว้ มักจะทำงานได้เร็วขึ้น
def prob_triangle_numba(ntrials):
    """
    ประมาณความน่าจะเป็นที่เส้นตรงที่ถูกแบ่งเป็นสามส่วนแบบสุ่มๆ
    จะสามารถประกอบเป็นสามเหลี่ยมได้
    
    ทำการทดลอง ntrials ครั้ง
    """
    
    # ntriangles เก็บจำนวนครั้งที่ประกอบเป็นสามเหลี่ยมได้
    ntriangles = 0 
    
    # ทำการทดลองแบ่งเส้นตรงความยาว 1 หน่วยเป็นสามส่วน
    # ทั้งหมดntrials ครั้ง
    
    for n in range(ntrials):
        
        # x, y คือตำแหน่งที่เราสุ่มตัดเส้นตรงสองตำแหน่ง
        # ทำให้แบ่งเส้นตรงเป็นสามส่วน
        # เราจะเรียงตำแหน่งให้ x <= y
        # ถ้าไม่เป็นอย่างนั้นเราจะสลับ x และy
        
        x = random.random()
        y = random.random()
        if x > y:
            x, y = y, x
        
        # เมื่อเราสุ่ม x, y มาตัดเส้นตรงได้แล้ว
        # เราจะมีเส้นตรงสามชิ้นยาว x, y-x, และ 1-y
        # เราจะเรียกชิ้นที่ยาวที่สุดว่า longest
        
        longest = max(x, y-x, 1-y)
        
        # ถ้าชิ้นที่ยาวที่สุดมีความยาวไม่เกิน 1/2 ของ
        # ความยาวเส้นตรงดั้งเดิม เราจะสามารถเอา
        # ทั้งสามชิ้นมาประกอบเป็นสามเหลี่ยมได้
        # และเราก็จะเพิ่มจำนวนครั้งที่ประกอบเป็นสามเหลี่ยมสำเร็จ
        
        if longest < 0.5:
            ntriangles += 1
            
         # ประมาณความน่าจะเป็นที่เป็นสามเหลี่ยมสำเร็จ
         # เท่ากับ (จำนวนสามเหลี่ยม)/(จำนวนครั้งที่ทดลอง)
            
    return ntriangles/ntrials

เมื่อเราจับเวลาจะพบว่าฟังก์ชั่นแบบใช้ Numba ของเราเร็วขึ้นมาก ใช้เวลาเพียง 0.149 วินาที แทนที่จะเป็น 3.67 วินาที หรือเร็วเป็น 25 เท่า

%time prob_triangle_numba(10_000_000)

CPU times: user 148 ms, sys: 798 µs, total: 149 ms
Wall time: 149 ms

0.2499591

ถ้าเราเรียกฟังก์ชั่นเราครั้งเดียว ผลต่างระหว่าง 3 วินาที กับ 0.15 วินาทีจะดูไม่มาก แต่เมื่อเราให้คอมพิวเตอร์เรียกฟังก์ชั่นนั้นซ้ำๆกันเป็นพันครั้ง (เช่นเมื่อเราต้องการวาดฮิสโตแกรม) เวลาที่ใช้ก็จะต่างกันมากแบบ 1 ชั่วโมง vs. 2.5 นาที ดังนั้นเราควรรู้จักเทคนิคพวกนี้เมื่อสั่งให้คอมพิวเตอร์ทำงานหนักๆแทนเรา อาจจะประหยัดเวลาได้มาก

ถ้าคอมพิวเตอร์เรามีหลายๆคอร์ซีพียู (ซึ่งคอมปัจจุบันมักจะมีอย่างน้อยสองคอร์ขึ้นไปอยู่แล้ว) เราอาจขอให้ Numba พยายามใช้คอร์หลายๆคอร์ช่วยคำนวณด้วยคำสั่ง njit(parallel=True) และใช้ prange แทน range ในการคำนวณแบบนี้ (สังเกตบรรทัดที่ 1, 4, และ 23) เมื่อจับเวลาก็พบว่าเร็วขึ้นประมาณ 6 เท่าสำหรับซีพียูแบบ 8 คอร์:

from numba import njit, prange #เรียกใช้ฟังก์ชั่นต่างๆใน numba
import random

@njit(parallel=True) #เพิ่มบรรทัดนี้เหนือฟังก์ชั่นที่เราเขียนไว้ ฟังก์ชั่นเรามักจะทำงานได้เร็วขึ้น
def prob_triangle_numba_parallel(ntrials):
    """
    ประมาณความน่าจะเป็นที่เส้นตรงที่ถูกแบ่งเป็นสามส่วนแบบสุ่มๆ
    จะสามารถประกอบเป็นสามเหลี่ยมได้
    
    ทำการทดลอง ntrials ครั้ง
    """
    
    # ntriangles เก็บจำนวนครั้งที่ประกอบเป็นสามเหลี่ยมได้
    ntriangles = 0 
    
    # ทำการทดลองแบ่งเส้นตรงความยาว 1 หน่วยเป็นสามส่วน
    # ทั้งหมดntrials ครั้ง
    
    # มีการใช้ prange แทน range เพื่อทำงานแบบพร้อมๆกัน
    # ตามจำนวนคอร์ใน CPU
    
    #ใช้ prange แทน range
    for n in prange(ntrials):
        
        # x, y คือตำแหน่งที่เราสุ่มตัดเส้นตรงสองตำแหน่ง
        # ทำให้แบ่งเส้นตรงเป็นสามส่วน
        # เราจะเรียงตำแหน่งให้ x <= y
        # ถ้าไม่เป็นอย่างนั้นเราจะสลับ x และy
        
        x = random.random()
        y = random.random()
        if x > y:
            x, y = y, x
        
        # เมื่อเราสุ่ม x, y มาตัดเส้นตรงได้แล้ว
        # เราจะมีเส้นตรงสามชิ้นยาว x, y-x, และ 1-y
        # เราจะเรียกชิ้นที่ยาวที่สุดว่า longest
        
        longest = max(x, y-x, 1-y)
        
        # ถ้าชิ้นที่ยาวที่สุดมีความยาวไม่เกิน 1/2 ของ
        # ความยาวเส้นตรงดั้งเดิม เราจะสามารถเอา
        # ทั้งสามชิ้นมาประกอบเป็นสามเหลี่ยมได้
        # และเราก็จะเพิ่มจำนวนครั้งที่ประกอบเป็นสามเหลี่ยมสำเร็จ
        
        if longest < 0.5:
            ntriangles += 1
            
         # ประมาณความน่าจะเป็นที่เป็นสามเหลี่ยมสำเร็จ
         # เท่ากับ (จำนวนสามเหลี่ยม)/(จำนวนครั้งที่ทดลอง)
            
    return ntriangles/ntrials

ถ้าจะใช้ parallel และ prange ควรอ่านเอกสารคู่มือเรื่องนี้ของ Numba ก่อนนะครับว่ามีข้อควรระวังอะไรบ้าง

หวังว่าผู้อ่านจะได้ไอเดียหรือประโยชน์บ้าง ถ้ามีคำแนะนำหรือข้อสงสัยส่งข้อความอินบ๊อกซ์ไปที่เพจวิทย์พ่อโก้บนเฟซบุ๊คได้ครับ: https://www.facebook.com/witpokosci/

(ตอนที่แล้วอยู่ที่ https://witpoko.com/?p=7485)