Что делает умный API?

Я практикую машинное обучение уже почти 3–4 года. За это время я обучил множество моделей, реализовал множество конвейеров данных и многое другое. Примечание: я определенно собрал и очистил гораздо больше данных, чем количество моделей, которые мне когда-либо приходилось строить .

Один из важнейших аспектов участия в спектре машинного обучения — возможность сделать ваши мысли или реализации доступными для других .

Позвольте мне объяснить это.

Это может быть объяснение неспециалисту, как алгоритм работает с точки зрения непрофессионала, как обслуживать ваши модели в API или даже документирование вашей работы, чтобы кто-то, кто плохо знаком с вашими проектами, мог легко освоить то, что вы сделали. далеко и многое другое. В этой статье мы сосредоточимся на API .

API (интерфейс прикладного программирования) — это не что иное, как средство, облегчающее связь между источником и конечным пользователем . Почти все приложения, которые мы используем в нашей повседневной жизни, состоят из сотен (если не больше) API-интерфейсов, выполняющих тяжелую работу в серверной части, чтобы вы могли легко использовать приложение. API ведет себя как запрос-ответ . Это может варьироваться от нескольких миллисекунд до нескольких минут.

Представьте, что вы идете в Starbucks и заказываете карамельный фраппучино с дополнительными сливками (мой личный фаворит ) прямо перед тем, как отправиться на эту очень долгую встречу.

Что будет дальше? Хорошо,

Вы, вероятно, будете ждать следующие 4–5 минут , в течение которых будет оформлен ваш заказ, затем он будет приготовлен на кухне, и официант принесет вам вкусный фраппучино. В этом случае вы являетесь конечным пользователем, кухня становится источником , а официант, который приносит вам фраппучино с кухни, выступает в роли API .

Звучит достаточно ясно?

Теперь предположим, что прошло более 30 минут, а фраппучино вам еще не отдали. Вы бы не потеряли терпение? Или, по крайней мере, вы бы не пошли на собрание, которое у вас запланировано через 10 минут, все время чувствуя себя очень разочарованным?

Именно так будет себя чувствовать конечный пользователь вашего приложения, если произойдет большая задержка с возвратом ответа. Задержка является ключевым фактором, когда речь идет о разработке идеального приложения.

Теперь предположим, что даже у лучшего кофейного мастера приготовление карамельного фраппучино займет не менее 30 минут. Вы бы по-прежнему заказывали фраппучино или выбрали альтернативный вариант, который требует меньше времени на приготовление? В большинстве случаев вы выберете альтернативный вариант, не так ли?

Но что, если бариста скажет, как я цитирую: «Просто иди на эту встречу, я позабочусь о том, чтобы фраппучино был в твоем конференц-зале до того, как ты туда доберешься!»

Звучит как интересная сделка, не так ли?

Почему мы не можем создать API, который вел бы себя так же?

Позволь мне объяснить.

Вы можете создать API, который будет мгновенно возвращать ответ , когда пользователь отправляет запрос в API. Но тяжелая работа выполняется в фоновом режиме ( это может занять некоторое время ). С таким API вы можете гарантировать, что время выполнения никогда не повлияет на общее время, необходимое для возврата ответа.

Celery и FastAPI обеспечивают оптимизированный механизм обмена сообщениями. В этой статье мы сосредоточимся только на FastAPI (спасибо Себастьяну Рамиресу за создание этого GEM), который также является моей любимой инфраструктурой API Python. Он поддерживает фоновые задачи, что идеально согласуется с тем, что мы сейчас обсуждали.

Если вы новичок в 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 с, и оператор печати также примерно в то же время.

Ниже показано время, затраченное на 10 вызовов API, которые я сделал.

Среднее время составляет около 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 с гораздо меньшим временем обработки. До скорой встречи с более интересными статьями.