Co sprawia, że ​​inteligentne API?

Uczeniem maszynowym zajmuję się od prawie 3-4 lat. W tym okresie wytrenowałem wiele modeli, zaimplementowałem wiele potoków danych i wiele więcej. Uwaga: zdecydowanie zebrałem i wyczyściłem znacznie więcej danych niż liczba modeli, które kiedykolwiek zbudowałem .

Jednym z kluczowych aspektów bycia w spektrum ML jest możliwość udostępniania innym swoich pomysłów lub implementacji .

Pozwól mi to wyjaśnić.

Może to być wyjaśnienie osobie nietechnicznej, jak algorytm działa w kategoriach laika, jak obsługiwać modele w interfejsie API, a nawet udokumentowanie swojej pracy, aby ktoś nowy w twoich projektach mógł łatwo zorientować się w tym, co zrobiłeś. daleko i wiele innych. W tym artykule skupimy się na interfejsach API .

API (ang. Application Programming Interface) to nic innego jak medium ułatwiające komunikację pomiędzy źródłem a użytkownikiem końcowym . Prawie wszystkie aplikacje, z których korzystamy na co dzień, składają się z setek (jeśli nie więcej) interfejsów API wykonujących ciężką pracę w zapleczu, dzięki czemu możesz swobodnie korzystać z aplikacji. Interfejs API zachowuje się w sposób żądanie-odpowiedź . Może to trwać od kilku milisekund do znacznie ponad kilku minut.

Wyobraź sobie, że idziesz do Starbucksa i zamawiasz karmelowe frappuccino z dodatkową śmietanką (mój osobisty faworyt ) tuż przed tym, jak masz zamiar uczestniczyć w tym bardzo długim spotkaniu

Co się potem dzieje? Dobrze,

Prawdopodobnie poczekałbyś kolejne 4–5 minut , w ciągu których zamówienie zostanie złożone, a następnie zostałoby przygotowane w kuchni, a kelner dostarczył Ci pyszne Frappuccino. W tym przypadku jesteś użytkownikiem końcowym, kuchnia staje się źródłem , a kelner, który przynosi frappuccino z kuchni, działa jako API .

Brzmi wystarczająco jasno?

A teraz załóżmy, że minęło ponad 30 minut, a Twoje Frappuccino jeszcze nie zostało podane. Nie straciłbyś cierpliwości? A przynajmniej nie wyszedłbyś na spotkanie, które masz za 10 minut, cały czas czując się bardzo rozczarowany?

Dokładnie tak czułby się użytkownik końcowy Twojej aplikacji, gdyby wystąpiło duże opóźnienie w zwróceniu odpowiedzi. Opóźnienie jest kluczem do zaprojektowania idealnej aplikacji.

Załóżmy teraz, że nawet najlepszy kawowy artysta, zrobienie karmelowego Frappuccino zajmie nie mniej niż 30 minut. Czy nadal zamówiłbyś Frappuccino, czy wybrałbyś alternatywną opcję, która ma krótszy czas przygotowania? W większości przypadków wybierzesz opcję alternatywną, prawda?

Ale co, jeśli barista powie, jak cytuję: Po prostu idź na to spotkanie, dopilnuję, aby Frappuccino było w twojej sali konferencyjnej, zanim dotrzesz!

Brzmi jak ciekawa umowa, prawda?

Dlaczego nie możemy stworzyć interfejsu API, który zachowywałby się w ten sam sposób?

Pozwól mi wyjaśnić.

Możesz zbudować interfejs API, który natychmiast zwróci odpowiedź , gdy użytkownik wyśle ​​żądanie do interfejsu API. Ale ciężka praca jest wykonywana w tle ( może to zająć trochę czasu ). Dzięki takiemu interfejsowi API możesz mieć pewność, że czas wykonania nigdy nie wpłynie na całkowity czas potrzebny do zwrócenia odpowiedzi.

Seler i FastAPI zapewniają zoptymalizowany mechanizm przesyłania wiadomości. W tym artykule skupimy się tylko na FastAPI (pozdrowienia dla Sebastiána Ramíreza za stworzenie tego klejnotu), który jest również moim ulubionym frameworkiem API Pythona. Obsługuje zadania w tle, co doskonale pasuje do tego, o czym teraz rozmawialiśmy.

Jeśli jesteś nowy w FastAPI, zajrzyj na ten blog o FastAPI, aby uzyskać szybki start w zrozumieniu tego, co zamierzam wyjaśnić w tym artykule.

Pierwsze kroki z FastAPI

Od tego momentu zakładam, że wiesz, jak zbudować podstawowe API za pomocą FastAPI.

Powinniśmy zaczynać?

Stwórzmy API, które po 10 sekundach zwróci „Hello world”.

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

Możesz zauważyć, że odpowiedź API jest zwracana po 10.0037s , a instrukcja print jest również mniej więcej w tym samym czasie

Poniżej znajduje się czas potrzebny na 10 wywołań API, które wykonałem

Średni czas wynosi około 10,002 s

Teraz dodajmy możliwość wykonywania zadań w tle w tym samym interfejsie API. Aby to zrobić, możesz użyć funkcji Zadania w tle w FastAPI. Po prostu utwórz funkcję o nazwie return_response , która wypisuje „Witaj, świecie!” po wywołaniu go. Wywołaj tę funkcję za pomocą metody BackgroundTasks wewnątrz API i gotowe!

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
        }

Natomiast instrukcja print jest widoczna w terminalu po 10 sekundach

Widać tutaj, że czas potrzebny API na zwrócenie odpowiedzi skrócił się z 10,002 s do zaledwie 0,00034 s, podczas gdy instrukcja print jest podawana po 10,0043 s

Tworzenie interfejsu API w ten sposób gwarantuje, że Twoja odpowiedź zostanie udzielona niemal natychmiast, przenosząc ciężką pracę w tle.

Pamiętaj, że funkcja BackgroundTasks działa najlepiej tylko w przypadkach, gdy Twoja aplikacja może przechowywać odpowiedź API w zewnętrznym źródle (MySQL, DynamoDB itp.) i nie wymaga od użytkownika końcowego przeglądania jej w momencie otrzymania odpowiedzi.

Mam nadzieję, że pomoże to w restrukturyzacji interfejsu API przy znacznie krótszym czasie przetwarzania. Do zobaczenia wkrótce z bardziej interesującymi artykułami.