อะไรทำให้ API อัจฉริยะ

ฉันฝึกการเรียนรู้ของเครื่องมาเกือบ 3-4 ปีแล้ว ในช่วงเวลานี้ ฉันได้ฝึกฝนโมเดลมากมาย ติดตั้งดาต้าไปป์ไลน์มากมาย และอื่นๆ อีกมากมาย หมายเหตุ: ฉันรวบรวมและล้างข้อมูลมากกว่าจำนวนโมเดลที่ฉันเคยสร้างมาอย่างแน่นอน

สิ่งสำคัญประการหนึ่งของการอยู่ในสเปกตรัม ML คือการสามารถทำให้ความคิดหรือการใช้งานของคุณพร้อมใช้งานสำหรับผู้อื่น

ให้ฉันอธิบายสิ่งนั้น

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

API (Application Programming Interface) เป็นเพียงสื่อกลางที่อำนวยความสะดวกในการสื่อสารระหว่างต้นทางและผู้ใช้ปลายทาง แอปพลิเคชันเกือบทั้งหมดที่เราใช้ในชีวิตประจำวันของเราประกอบด้วย API กว่า 100 รายการ (หากไม่ใช่ อาจมีมากกว่านั้น) ที่ทำงานอย่างหนักในส่วนหลัง เพื่อให้คุณใช้งานแอปพลิเคชันได้อย่างสบายใจ API ทำงานในลักษณะตอบสนองคำขอ ซึ่งอาจอยู่ในช่วงระหว่างไม่กี่มิลลิวินาทีหรือมากกว่าสองสามนาที

ลองนึกภาพคุณไปที่ Starbucks แล้วสั่ง Caramel Frappuccino พร้อมครีมพิเศษ (ของโปรดส่วนตัว ) ก่อนที่คุณจะเข้าร่วมการประชุมที่ยาวนาน

จะเกิดอะไรขึ้นต่อไป? ดี,

คุณอาจจะรออีก4-5 นาทีหลังจากที่คุณสั่งอาหาร จากนั้นมันจะถูกจัดเตรียมในครัว และบริกรก็จะส่ง Frappuccino แสนอร่อยให้กับคุณ ในกรณีนี้ คุณคือผู้ใช้ปลายทางครัวจะกลายเป็นต้น ทาง และพนักงานเสิร์ฟที่นำ Frappuccino จากครัว มาให้คุณทำหน้าที่เป็นAPI

ฟังดูชัดเจนพอไหม?

ตอนนี้ถือว่าเกิน 30 นาทีแล้ว และ Frappuccino ของคุณยังไม่ได้รับ คุณจะไม่หมดความอดทนเหรอ? หรืออย่างน้อยคุณจะไม่ออกไปเข้าร่วมการประชุมที่คุณมีใน 10 นาทีในขณะที่รู้สึกผิดหวังมาก?

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

ตอนนี้ สมมติว่าแม้แต่ศิลปินกาแฟที่เก่งที่สุด การเตรียมคาราเมล Frappuccino จะใช้เวลาไม่น้อยกว่า 30 นาที คุณยังจะสั่ง Frappuccino ไหม หรือเลือกตัวเลือกอื่นที่มีเวลาเตรียมตัวน้อยกว่า ในกรณีส่วนใหญ่ คุณจะเลือกทางเลือกอื่นใช่หรือไม่?

แต่ถ้าบาริสต้าพูดตามที่ฉันพูดแค่ไปที่การประชุมนั้น ฉันจะแน่ใจว่า Frappuccino อยู่ในห้องประชุมของคุณก่อนที่คุณจะไปถึง!

ฟังดูเป็นข้อตกลงที่น่าสนใจใช่ไหม?

เหตุใดเราไม่สามารถสร้าง API ที่สามารถทำงานในลักษณะเดียวกันได้

ให้ฉันอธิบาย

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

CeleryและFastAPIให้กลไกการส่งข้อความที่ปรับให้เหมาะสม ในบทความนี้ เราจะมุ่งเน้นไปที่FastAPI เท่านั้น (ตะโกนถึงSebastián Ramírezสำหรับการสร้าง GEM นี้) ซึ่งเป็นเฟรมเวิร์ก python API ที่ฉันชื่นชอบด้วย รองรับการทำงานเบื้องหลังซึ่งสอดคล้องกับสิ่งที่เราพูดถึงตอนนี้อย่างสมบูรณ์แบบ

หากคุณยังใหม่กับ FastAPI โปรดดูบล็อกนี้เกี่ยวกับ FastAPI เพื่อเริ่มต้นอย่างรวดเร็วเพื่อทำความเข้าใจสิ่งที่ฉันจะอธิบายในบทความนี้

เริ่มต้นใช้งาน FastAPI

จากนี้ไปฉันจะถือว่าคุณรู้วิธีสร้าง API พื้นฐานโดยใช้ FastAPI

เรามาเริ่มกันเลยดีไหม?

ให้เราสร้าง API ที่จะส่งคืน "Hello world" หลังจากผ่านไป 10 วินาที

from fastapi import FastAPI
import time

app = FastAPI()

@app.post("/myApp/timer")
def read_item():
    
    start = time.time() # start time
    time.sleep(10)
    end = time.time() # end time
    
    print(end - start) # print the time taken to return the response
    
    return {"response": "Hello world!"}

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

ด้านล่างนี้เป็นเวลาสำหรับการเรียก API 10 ครั้งที่ฉันทำ

เวลาเฉลี่ยที่ใช้คือประมาณ10.002 วินาที

ตอนนี้ ให้เราเพิ่มความสามารถในการทำงานเบื้องหลังบน API เดียวกัน ในการทำเช่นนั้น คุณสามารถใช้ คุณสมบัติ งานเบื้องหลังใน FastAPI เพียงสร้างฟังก์ชันชื่อreturn_responseที่ พิมพ์ว่า “Hello world!” เมื่อเรียกมัน เรียกใช้ฟังก์ชันนั้นโดยใช้ เมธอด BackgroundTasksภายใน API เท่านี้ก็เสร็จแล้ว!

from fastapi import BackgroundTasks, FastAPI
import time

app = FastAPI()

def return_response():
    start = time.time() # start time
    time.sleep(10)
    end = time.time() # end time
    
    print({
        "response": "Hello world!", 
        "time_taken": end - start
        })

@app.post("/myApp/timer")
def read_item(background_tasks: BackgroundTasks):
    start = time.time() # start time
    background_tasks.add_task(return_response) # background processing the function
    end = time.time() # end time
    
    return {
        "status": "processing in background",
        "time_taken": end - start
        }

ในขณะที่คำสั่งการพิมพ์สามารถเห็นได้ในเทอร์มินัลหลังจากผ่านไป 10 วินาที

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

การสร้าง API ด้วยวิธีนี้ทำให้มั่นใจได้ว่าคุณจะได้รับการตอบสนองเกือบจะทันทีโดยการย้ายงานหนักให้เกิดขึ้นในเบื้องหลัง

โปรดจำไว้ว่า คุณลักษณะ BackgroundTasks จะทำงานได้ดีที่สุดในกรณีที่แอปพลิเคชันของคุณสามารถจัดเก็บการตอบสนองของ API ไว้ในแหล่งข้อมูลภายนอก (MySQL, DynamoDB เป็นต้น) และไม่ต้องการให้ผู้ใช้ปลายทางดูข้อมูลดังกล่าวเมื่อได้รับการตอบกลับ

ฉันหวังว่าสิ่งนี้จะช่วยให้คุณปรับโครงสร้าง API ของคุณโดยใช้เวลาดำเนินการน้อยลงมาก แล้วพบกันใหม่กับบทความที่น่าสนใจอีกเร็วๆ นี้