Delply Machine Learning Model com Heroku e FastAPI

Este artigo foi publicado como parte do Data Science Blogathon

Introdução

Eu irei guiá-lo através do processo de Implementar um modelo de aprendizado de máquina como uma API usando FastAPI e Heroku. Coisas abordadas neste artigo:

1. Uma introdução rápida ao conjunto de dados e modelo
2. Noções básicas de FastAPI
3. Como estruturar seu código para usar o modelo de ML
4. Como testar e recuperar esta API?
5. Implementação em Heroku
6. Bono: Geração de documentos

O conjunto de dados e o modelo

A declaração do problema que escolhi para esta série de artigos é a Classificação do gênero musical. O conjunto de dados foi compilado por um grupo de pesquisa chamado The Echo Nest. Contém vários detalhes técnicos sobre a música. Esses incluem Acústica, dança, Energia, instrumentalidade, vivacidade, fala, tempo e valência. A variável objetiva desses dados é se a música pertence ao gênero Rock ou Hip-Hop.. A seguir, alguns detalhes sobre o conjunto de dados são mostrados:

A identificação de faixa não foi útil para nossa análise e, portanto, foi deletado. Genre_top é nossa variável de destino e contém “Rocha” o “Hip-Hop”. Treinei um classificador de árvore de decisão para este conjunto de dados e obtive uma boa pontuação de precisão. (Eu não tentei outros modelos de conjunto como Random Forest, mas você pode tentar).

Depois de terminar de ajustar o modelo e testá-lo com dados aleatórios, é hora de selecionar o modelo. A remoção é o processo de conversão de um objeto Python em um fluxo de bytes. Salve o modelo como um arquivo para que possa ser acessado / carregue mais tarde. Aqui está o código para o mesmo, caso você não esteja familiarizado:

pkl_filename ="model.pkl"
com aberto(pkl_filename, 'wb') como f:
    pickle.dump(modelo, f)

Introdução ao FastAPI

É uma estrutura da web que acelera o desenvolvimento de back-end de um site usando Python. Esta moldura é totalmente nova, adaptável e fácil de aprender. Permite que os usuários configurem rapidamente a API, gera documentos automáticos para todos os terminais, oferece autenticação, data de validade, permite código assíncrono e muito mais. É construído em Starlette, o que é uma moldura / kit de ferramentas ASGI leve e fornece código pronto para produção.

Por outro lado, O Flask é mais antigo que FastAPI, mas ainda é usado para muitos projetos. Sua abordagem minimalista é promissora e criar APIs com flask também não é tão difícil. Ambas as estruturas têm seus prós e contras.

Confira este artigo para uma comparação detalhada de FastAPI: A substituição certa para frascos?

Para implementar nosso modelo de aprendizado de máquina, vamos usar a abordagem FastAPI. Antes de mergulhar no código para criar o modelo de API, vamos entender alguns princípios básicos de FastAPI que ajudarão a entender melhor a base de código.

Noções básicas de FastAPI

A estrutura do código FastAPI é muito semelhante à estrutura do aplicativo Flask. Você precisa criar endpoints onde nosso atendimento ao cliente possa fazer solicitações e obter os dados necessários. Veja a implementação de código básico abaixo:

importar uvicórnio

de importação fastapi FastAPI

app = FastAPI()

@ app.get('/')

índice def():

    Retorna {'mensagem': "Esta é a página inicial desta API. Vá para / apiv1 / ou / apiv2 /?nome ="}

@ app.get('/ apiv1 /{nome}')

def api1(nome: str):

    Retorna {'mensagem': alô! @{nome}'}

@ app.get('/ apiv2 /')

def api2(nome: str):

    Retorna {'mensagem': alô! @{nome}'}

if __name__ == '__main__':

    uvicorn.run(aplicativo, host ="127.0.0.1", porta = 4000, debug = True)

1. As primeiras duas linhas importam FastAPI e uvicorn. O Uvicorn é usado para implementar o servidor e lidar com todas as chamadas em Python.
2. A seguir, uma instância do aplicativo FastAPI é criada.
3. Para adicionar rotas / endpoints para esta instância do aplicativo, uma função é criada e um decorador de rota é adicionado. Este decorador registra a função para a rota definida para que quando aquela rota particular for solicitada, a função é chamada e seu resultado é retornado ao cliente. Geralmente, retornamos um objeto JSON para que ele possa ser analisado em qualquer linguagem.
4. A melhor parte do FastAPI é que você pode definir essas rotas diretamente para métodos HTTP. No frasco, você tem que adicioná-los manualmente a uma lista de métodos (atualizado no frasco 2.0).
5. Para obter informações do cliente, você pode usar parâmetros de caminho, parâmetros de consulta ou corpos de solicitação. O caminho “/ apiv1 / {Nome}”Implementa uma abordagem baseada em rota onde os parâmetros são passados ​​como rotas. A rota “/ apiv2 /” implementa uma abordagem baseada em consulta onde os parâmetros são passados ​​adicionando o “?” no final do URL e usando “&” para adicionar vários parâmetros.

Veja essas rotas em ação:

Solicitar foco corporal

Com esta abordagem, os dados do cliente podem ser passados ​​para nossa API. E FastAPI, para simplificar as coisas, usamos modelos Pydantic para definir a estrutura de dados para os dados de recebimento. O Pydantic executa todas as verificações de tipo dos parâmetros e retorna erros explicáveis ​​se o tipo de parâmetro incorreto for recebido. Vamos adicionar uma classe de dados ao nosso código existente e criar um caminho para o corpo da solicitação:

.

.

# Depois de outras importações
from pydantic import BaseModel
detalhes da classe(BaseModel):
    f_name: str
    l_name: str
    número de telefone: int
app = FastAPI()

.
.
.

# Depois de velhas rotas
@ app.post('/ apiv3 /')
def api3(dados: Detalhes):
    Retorna {'mensagem': dados}

A função de caminho declara um parâmetro “dados” do tipo “Detalhes” definido acima. Este modelo de “Detalhes” herda do modelo de base do Pydantic e oferece validação de dados. Para testar esta rota, Estou usando a extensão de código VS do cliente Thunder para fazer uma solicitação de postagem para nosso caminho de API “/ apiv3 /”:

Envolvendo o modelo

Agora que removemos os conceitos do FastAPI, é hora de integrar o modelo à estrutura de código FastAPI para fazer solicitações de previsão. Vamos criar uma rota “/ predição” que pegará os dados enviados pelo corpo da solicitação do cliente e nossa API retornará a resposta como um objeto JSON contendo o resultado. Vejamos o código primeiro e depois explicarei a mecânica:

importar uvicórnio

importar picles

de importação fastapi FastAPI

from pydantic import BaseModel

aula de musica(BaseModel):

    acústico: flutuador

    dança: flutuador

    energia: flutuador

    instrumentalidade: flutuador

    vivacidade: flutuador

    discurso: flutuador

    tempo: flutuador

    valência: flutuador

app = FastAPI()




com aberto("./Arquivos FastAPI / model.pkl", "rb") como f:

    model = pickle.load(f)

@ app.get('/')

índice def():

    Retorna {'mensagem': 'Esta é a página inicial da API'}

@ app.post('/predição')

def get_music_category(dados: Música):

    recebido = data.dict()

    acústico = recebido['acústico']

    danceabilidade = recebido['danceability']

    energia = recebida['energia']

    instrumentalidade = recebido['instrumentalidade']

    vivacidade = recebido['vivacidade']

    discurso = recebido['discurso']

    tempo = recebido['clima']

    valência = recebido['valência']

    pred_name = model.predict([[acústico, dança, energia,

                                instrumentalidade, vivacidade, discurso, clima, valência]]).listar()[0]

    Retorna {'predição': pred_name}

if __name__ == '__main__':

    uvicorn.run(aplicativo, host ="127.0.0.1", porta = 4000, debug = True)

1. Criamos uma classe Music Model que define todos os parâmetros do nosso modelo de ML. Todos os valores são do tipo float.
2. A seguir, carregamos o modelo desanexando-o e salvando o modelo como “modelo”. Este objeto modelo será usado para obter as previsões.
3. A função do caminho “/ predição” declare um parâmetro chamado “dados” do tipo de modelo “Música”. Este parâmetro pode ser acessado como um dicionário. O objeto de dicionário nos permitirá acessar os valores dos parâmetros como pares de valores-chave.
4. Agora, estamos salvando todos os valores dos parâmetros enviados pelo cliente. Esses valores agora são alimentados na função de previsão do modelo e temos nossa previsão para os dados fornecidos.

Todos os códigos discutidos neste artigo estão disponíveis em meu repositório GitHub.

Teste de API de modelo

Agora é a hora de testar a API. Você pode testar a API por meio de dois métodos:

Cliente Thunder / Carteiro

Estamos usando o cliente thunder para enviar uma solicitação de postagem para o caminho “/ predição” com um corpo de solicitação. O corpo da solicitação contém os pares de valores-chave dos parâmetros e devemos esperar uma resposta JSON com o gênero musical classificado.

Faça uma solicitação usando o módulo de solicitação

Se você não quiser usar as extensões VSCode ou qualquer software de teste de API, você pode apenas criar um programa python separado para chamar esta API. O módulo de solicitações Python permite chamar APIs.

pedidos de importação
importar json

url = "<local-host-url>/predição"

carga útil = json.dumps({
  "acústico": 0.344719513,
  "dança": 0.758067547,
  "energia": 0.323318405,
  "instrumentalidade": 0.0166768347,
  "vivacidade": 0.0856723112,
  "discurso": 0.0306624283,
  "clima": 101.993,
  "valência": 0.443876228
})

cabeçalhos = {
  'Tipo de conteúdo': 'application / json'
}

resposta = solicitações.request("PUBLICAR", url, headers = headers, dados = carga útil)

imprimir(response.text)

Substituir “local-host-url” com o seu url que você obtém após executar o arquivo API do modelo FastAPI. A saída para isso é:

Viva! Você criou com sucesso uma API para seu modelo de aprendizado de máquina usando FastAPI.

Implementação em Heroku

Nossa API está pronta para ser usada por qualquer tipo de programa que faça uma chamada para nossa API. Mas você não pode executar este programa o dia todo em seu sistema local, isso é praticamente impossível. Portanto, você precisa implantar seu serviço em uma plataforma de nuvem que pode executar seu código e retornar retornos.

Heroku é uma daquelas plataformas que oferece hospedagem gratuita. Para implementar nossa API no Heroku, precisamos criar esses arquivos:

1. Requisitos.txt: Este arquivo deve listar todos os módulos externos que você usou em seu aplicativo. Para o nosso caso, era FastAPI, scikit-learn, uvicorn e alguns outros módulos auxiliares.
2. runtime.txt: Este arquivo especifica a versão do Python que o Heroku irá instalar em seu endpoint.
3. Procfile: Este arquivo é o arquivo de interface entre nosso código Python e a plataforma Heroku. Observação: a maioria de vocês não cria este arquivo corretamente. Não é um arquivo de texto. Este arquivo não tem extensão. Para criar esses arquivos, você pode usar GitHub adicionar arquivos ou código Vs ou cmd no Windows ou terminal no Linux. Este arquivo conteria o seguinte comando para FastAPI:

rede: gunicorn -w 4 -k uvicorn.workers.UvicornWorker :aplicativo

Aqui, substitua file_name pelo nome do arquivo Python onde você criou o código FastAPI. Depois disto:

1. Coloque todos esses arquivos (modelo, arquivo python, requisitos.txt, Procfile) em um repositório GitHub
2. Faça login no Heroku e crie um novo aplicativo. Conecte seu repositório GitHub
3. Clique em Deploy Branch e sua API estará instalada e funcionando para qualquer pessoa usar com o link.

Bono: Geração de documentos

FastAPI tem um recurso especial. Gere documentos automaticamente para endpoints de API criados. Para acessar esses documentos, apenas visite o ponto final “/ docs” e você obterá uma interface gráfica de usuário atraente criada com Swagger e OpenAI. Agora que implementamos o serviço, a captura de tela abaixo é do aplicativo Heroku implantado. (Ligação: https://kivymlapp.herokuapp.com/)

conclusão

Neste artigo detalhado, o FastAPI apresentado, seus fundamentos, como criar arquivo API para modelo de aprendizado de máquina, como testar esta API e como implementar esta API na plataforma Heroku. Também vimos como acessar o endpoint do documento que FastAPI gera automaticamente.

No próximo artigo, Mostrarei como usar a API criada neste artigo para criar um aplicativo de predição de música Android usando Python e também converteremos esse arquivo de Python em APK.

Observação: você pode usar este link, Link mestre para todos os meus artigos na Internet, que atualiza toda vez que eu posto um novo artigo para encontrá-lo.

Se você tem qualquer dúvida, inquérito ou oportunidade potencial, então você pode se comunicar comigo através

1. Linkedin – sobre / Kaustubh-gupta /

2. Twitter – @ Kaustubh1828

3. GitHub – Kaustubhgupta

Relacionado