Apa yang membuat API pintar?

Saya telah mempraktikkan Pembelajaran Mesin selama hampir 3–4 tahun sekarang. Selama periode tersebut saya telah melatih banyak model, mengimplementasikan banyak saluran data, dan banyak lagi. Catatan: Saya benar-benar mengumpulkan dan membersihkan lebih banyak data dari jumlah model yang pernah saya buat .

Salah satu aspek penting dalam spektrum ML adalah mampu membuat pemikiran atau implementasi Anda tersedia bagi orang lain .

Mari saya jelaskan itu.

Itu bisa menjelaskan kepada orang non-teknis bagaimana algoritme bekerja dalam istilah awam, bagaimana melayani model Anda di API, atau bahkan mendokumentasikan pekerjaan Anda sehingga seseorang yang baru dalam proyek Anda dapat dengan mudah mempercepat apa yang telah Anda lakukan. jauh, dan banyak lagi. Pada artikel ini, Kami akan fokus pada API .

API (Application Programming Interface) tidak lain adalah media yang memfasilitasi komunikasi antara sumber dan pengguna akhir . Hampir semua aplikasi yang kami gunakan dalam kehidupan sehari-hari terdiri dari 100 (jika tidak, lebih) API yang melakukan pekerjaan berat di back-end sehingga Anda dapat menggunakan aplikasi dengan nyaman. API berperilaku dengan cara permintaan-respons . Ini bisa berkisar antara beberapa milidetik dan lebih dari beberapa menit.

Bayangkan Anda pergi ke Starbucks dan memesan Frappuccino Karamel dengan krim ekstra (Favorit pribadi saya ) tepat sebelum Anda akan menghadiri pertemuan yang sangat panjang itu

Apa yang terjadi selanjutnya? Sehat,

Anda mungkin akan menunggu selama 4–5 menit berikutnya saat pesanan Anda ditempatkan, kemudian akan disiapkan di dapur dan pelayan mengantarkan Frappuccino lezat Anda kepada Anda. Dalam hal ini, Anda adalah pengguna akhir, dapur menjadi sumber dan pelayan yang membawakan Frappuccino dari dapur kepada Anda bertindak sebagai API .

Kedengarannya cukup jelas?

Sekarang anggap sudah lebih dari 30 menit dan Frappuccino Anda belum diberikan kepada Anda. Apakah Anda tidak kehilangan kesabaran? Atau setidaknya tidakkah Anda pergi untuk menghadiri pertemuan yang Anda adakan dalam 10 menit sambil merasa sangat kecewa?

Persis seperti itulah perasaan pengguna akhir aplikasi Anda jika ada banyak penundaan yang terjadi untuk mengembalikan respons. Latensi adalah kunci dalam mendesain Aplikasi yang sempurna.

Sekarang mari kita asumsikan bahkan dengan artis kopi terbaik, menyiapkan Frappuccino karamel akan memakan waktu tidak kurang dari 30 menit. Apakah Anda masih memesan Frappuccino atau memilih opsi alternatif yang memiliki waktu persiapan lebih sedikit? Dalam kebanyakan kasus, Anda akan memilih opsi alternatif bukan?

Tetapi bagaimana jika barista mengatakan seperti yang saya kutip, Pergi saja ke pertemuan itu, saya akan memastikan Frappuccino ada di ruang konferensi Anda sebelum Anda tiba!

Kedengarannya seperti kesepakatan yang menarik bukan?

Mengapa kita tidak bisa membuat API yang bisa berperilaku dengan cara yang sama?

Mari saya jelaskan.

Anda dapat membuat API yang akan mengembalikan respons secara instan saat pengguna mengirim permintaan ke API. Tetapi pekerjaan berat dilakukan di latar belakang ( ini mungkin/mungkin tidak memakan waktu lama ). Dengan API semacam itu, Anda dapat memastikan waktu eksekusi tidak pernah memengaruhi keseluruhan waktu yang dibutuhkan untuk mengembalikan respons.

Celery dan FastAPI menyediakan mekanisme perpesanan yang dioptimalkan. Pada artikel ini, kita akan fokus hanya pada FastAPI (berteriak kepada Sebastián Ramírez untuk membuat GEM ini), yang juga merupakan framework API python favorit pribadi saya. Ini mendukung tugas Latar Belakang yang sangat selaras dengan apa yang kita diskusikan sekarang.

Jika Anda baru mengenal FastAPI, silakan lihat blog ini tentang FastAPI untuk mendapatkan lompatan untuk memahami apa yang akan saya jelaskan di artikel ini.

Memulai Dengan FastAPI

Mulai sekarang saya akan berasumsi bahwa Anda tahu cara membuat API dasar menggunakan FastAPI.

Dapatkah kita memulai?

Mari kita buat API yang akan mengembalikan "Halo dunia" setelah 10 detik.

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!"}

Anda dapat melihat bahwa respons API dikembalikan setelah 10,0037 detik dan pernyataan cetak juga sekitar waktu yang sama

Di bawah ini adalah waktu yang dibutuhkan untuk 10 panggilan API yang saya buat

Waktu rata-rata yang ditempuh sekitar 10,002 detik

Sekarang mari kita tambahkan kemampuan tugas latar belakang pada API yang sama. Untuk melakukannya, Anda dapat menggunakan fitur Tugas latar belakang di FastAPI. Buat saja fungsi yang disebut return_response yang mencetak "Halo dunia!" setelah memanggilnya. Panggil fungsi itu menggunakan metode BackgroundTasks di dalam API dan hanya itu!

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
        }

Sedangkan pernyataan cetak dapat dilihat di terminal setelah 10 detik

Anda dapat melihat di sini bahwa waktu yang dibutuhkan oleh API untuk mengembalikan respons telah berkurang dari 10,002 detik menjadi hanya 0,00034 detik sedangkan pernyataan cetak diberikan setelah 10,0043 detik

Membuat API dengan cara ini memastikan bahwa respons Anda diberikan hampir secara instan dengan memindahkan pekerjaan berat agar terjadi di latar belakang.

Ingat, fitur BackgroundTasks hanya akan berfungsi paling baik jika aplikasi Anda dapat menyimpan respons API di sumber eksternal (MySQL, DynamoDB, dll.) dan tidak mengharuskan pengguna akhir untuk melihatnya pada saat mendapatkan respons.

Saya harap ini membantu Anda merestrukturisasi API Anda dengan waktu pemrosesan yang jauh lebih sedikit. Sampai jumpa lagi dengan artikel yang lebih menarik.