O que torna uma API inteligente?

Eu tenho praticado Machine Learning por quase 3-4 anos. Ao longo do período, treinei muitos modelos, implementei muitos pipelines de dados e muito mais. Nota: Eu definitivamente coletei e limpei muito mais dados do que o número de modelos que já construí .

Um dos aspectos cruciais de estar no espectro do ML é ser capaz de fazer com que seus pensamentos ou implementações estejam prontamente disponíveis para outras pessoas .

Deixe-me explicar isso.

Pode ser explicar para uma pessoa não técnica como um algoritmo funciona em termos leigos, como servir seus modelos em uma API ou até mesmo documentar seu trabalho para que alguém novo em seus projetos possa facilmente se atualizar com o que você fez. longe, e muito mais. Neste artigo, vamos nos concentrar em APIs .

API (Application Programming Interface) nada mais é do que um meio que facilita a comunicação entre a fonte e o usuário final . Quase todos os aplicativos que usamos em nossa vida diária são compostos por centenas (se não, mais) de APIs que fazem o trabalho pesado no back-end para que você possa usar o aplicativo com facilidade. Uma API se comporta de maneira solicitação-resposta . Isso pode variar entre alguns milissegundos e bem mais de alguns minutos.

Imagine que você vai ao Starbucks e pede um Caramel Frappuccino com creme extra (meu favorito ) logo antes de estar prestes a participar daquela longa reunião

O que acontece depois? Nós iremos,

Você provavelmente esperaria os próximos 4 a 5 minutos em que seu pedido é feito, então ele seria preparado na cozinha e o garçom entregaria seu delicioso Frappuccino para você. Nesse caso, você é o usuário final, a cozinha se torna a fonte e o garçom que traz o Frappuccino da cozinha até você atua como uma API .

Parece claro o suficiente?

Agora suponha que já se passaram mais de 30 minutos e seu Frappuccino ainda não foi entregue a você. Você não perderia a paciência? Ou pelo menos você não sairia para assistir àquela reunião que você tem em 10 minutos o tempo todo se sentindo muito desapontado?

É exatamente assim que o usuário final do seu aplicativo se sentiria se houvesse muito atraso para retornar a resposta. A latência é fundamental quando se trata de projetar o aplicativo perfeito.

Agora vamos supor que mesmo com o melhor café, preparar um Frappuccino de caramelo levaria nada menos que 30 minutos. Você ainda pediria o Frappuccino ou optaria por uma opção alternativa que tenha um tempo de preparo menor? Na maioria dos casos, você irá para a opção alternativa, não é?

Mas e se o barista disser, como cito, apenas vá àquela reunião, garantirei que o Frappuccino esteja em sua sala de conferências antes de você chegar!

Parece um negócio interessante, não é?

Por que não podemos criar uma API que se comporte da mesma maneira?

Deixe-me explicar.

Você pode criar uma API que retornará uma resposta instantaneamente quando o usuário enviar uma solicitação para uma API. Mas o trabalho pesado é feito em segundo plano ( isso pode/não pode demorar ). Com essa API, você pode garantir que o tempo de execução nunca afete o tempo total necessário para retornar uma resposta.

Celery e FastAPI fornecem mecanismo de mensagens otimizado. Neste artigo, vamos nos concentrar apenas no FastAPI (grito para Sebastián Ramírez por criar este GEM), que também é minha estrutura de API python favorita. Ele suporta tarefas em segundo plano que se alinham perfeitamente com o que discutimos agora.

Se você é novo no FastAPI, consulte este blog sobre o FastAPI para obter uma ajuda inicial para entender o que estou prestes a explicar neste artigo.

Introdução ao FastAPI

Daqui em diante, assumirei que você sabe como construir uma API básica usando FastAPI.

Começaremos?

Vamos criar uma API que retornará “Hello world” após 10s.

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

Você pode notar que a resposta da API é retornada após 10.0037s e a instrução de impressão também ocorre na mesma hora

Abaixo está o tempo necessário para 10 chamadas de API que fiz

O tempo médio gasto é de cerca de 10.002s

Agora vamos adicionar capacidade de tarefas em segundo plano na mesma API. Para fazer isso, você pode usar o recurso Tarefas em segundo plano no FastAPI. Basta criar uma função chamada return_response que imprima “Hello world!” ao chamá-lo. Invoque essa função usando o método BackgroundTasks dentro da API e pronto!

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
        }

Considerando que a instrução de impressão pode ser vista no terminal após 10 segundos

Você pode ver aqui que o tempo que a API leva para retornar a resposta foi reduzido de 10,002s para apenas 0,00034s, enquanto a instrução de impressão é fornecida após 10,0043s

Criar uma API dessa maneira garante que sua resposta seja dada quase instantaneamente, movendo o trabalho pesado para acontecer em segundo plano.

Lembre-se de que o recurso BackgroundTasks só funciona melhor nos casos em que seu aplicativo pode armazenar a resposta da API em uma fonte externa (MySQL, DynamoDB etc.) e não exige que o usuário final a visualize no momento de obter a resposta.

Espero que isso ajude você a reestruturar sua API com muito menos tempo de processamento. Vejo vocês em breve com mais artigos interessantes.