APIs e Machine Learning: colocar modelos do notebook em produção com Flask e FastAPI

Introdução às APIs e início do projeto - Apresentação

Apresentando a instrutora e a audiodescrição

Olá! Meu nome é Ariel, e serei a pessoa instrutora neste curso de dados e APIs com Flask e FastAPI: do Notebook à produção.

Audiodescrição: Sou uma pessoa de pele morena, visto uma camiseta preta, tenho cabelo curto e cacheado e barba curta. À esquerda, há uma estante com livros e alguns objetos; atrás de mim, uma estante de livros; à direita, uma parede branca.

Apresentando a experiência e introduzindo as aulas

Primeiro, vou me apresentar um pouco mais. Sou cientista de dados há algum tempo e já trabalhei em várias empresas — bancos, startups e consultorias. Tenho bastante experiência em modelagem preditiva, em colocar modelos preditivos e modelos de machine learning (aprendizado de máquina) em produção e em lançar produtos de dados em produção. Meu trabalho envolve transformar produtos de dados ou tecnologias que desenvolvemos ao longo do tempo em soluções em produção, o que, de fato, entrega valor ao negócio.

Agora, vamos analisar as aulas. Nesta primeira aula, vamos abordar a introdução às APIs. Começaremos com uma parte mais teórica e, em seguida, avançaremos para as partes práticas.

Motivando a necessidade de APIs e diagnosticando limitações

Antes de definir ou entender como funciona uma API, vamos retomar um problema simples, do nosso dia a dia: quando nos deparamos com a necessidade de ter uma API?

Por que os modelos não se tornam produto? Para quem trabalha com modelos de machine learning (aprendizado de máquina), muitas vezes desenvolvemos um modelo simples que permanece no Jupyter Notebook. Esse é o ponto do isolamento: o modelo fica confinado ao Jupyter Notebook ou a um script (roteiro) em Python. Independentemente de onde o desenvolvemos, ele permanece ali e não conseguimos utilizá-lo de forma adequada em escala.

Na realidade, até poderíamos executá-lo localmente. O problema é o que isso impede em termos de acesso e valor para o negócio. Provavelmente, a área de negócio não terá acesso ao modelo. Teríamos de ficar executando tudo manualmente.

Vamos ao outro problema: a falta de consumo. Se não tivermos uma interface simples e universal para que todas as pessoas possam consumir as previsões que gerarmos, o modelo se torna obsoleto antes mesmo de ser utilizado. Ele acaba sendo descartado, indo para uma prateleira e acumulando pó. Isso ocorre na maioria dos casos, ou ocorria com frequência no passado.

Enfrentamos uma dificuldade grande: escalar. Pela ausência de infraestrutura, se tivermos um modelo no qual uma pessoa usuária precise fazer uma solicitação, comunicar-se com outra pessoa ou serviço, ou enviar alguma informação para obter outra, apenas com um notebook, apenas no computador local, nós não vamos conseguir; o uso do modelo se torna inviável. E, nesse cenário, não conseguimos de fato entregar valor ao negócio.

O ideal é fazermos esse modelo sair da nossa máquina, parar de executá-lo manualmente repetidas vezes, automatizá-lo e disponibilizá-lo em um ambiente onde as pessoas possam utilizá-lo sem nossa intervenção manual. Assim, conseguimos realmente entregar valor ao negócio.

Apresentando os frameworks e preparando a prática

Dentro do ciclo de Machine Learning, o que vamos fazer aqui? Comentaremos isso ao longo do curso, mas neste curso trabalharemos com dois frameworks para uso de APIs. Não são frameworks de projeto, e sim para o uso de APIs: Flask e FastAPI. Entenderemos por que usar um ou outro. Adiantando um ponto: na maior parte do tempo utilizaremos FastAPI. Flask será empregado no início para entendermos como funciona, qual é a dinâmica com a qual trataremos a API, como organizamos esses códigos e como os utilizamos. Em seguida, seguiremos diretamente com FastAPI. Também explicaremos por que usaremos mais FastAPI do que Flask, tema que deixaremos para as próximas aulas.

No próximo vídeo, já vamos mostrar como isso fica. Utilizaremos PyCharm. Depois, apresentaremos na prática como tudo vai funcionar.

Introdução às APIs e início do projeto - Visão geral do projeto

Saudando e apresentando o fluxo de APIs

Olá a todas as pessoas.

Dando continuidade aos nossos vídeos sobre APIs, vamos prosseguir com a introdução, sem entrar necessariamente na API agora. Nosso objetivo é compreender um fluxo específico de funcionamento: solicitação, processamento, predição e resposta.

Na solicitação, o cliente realiza o pedido; a API faz o processamento; o modelo realiza a predição; e obtemos uma resposta. Esse é sempre o mesmo fluxo, independentemente da API utilizada. Aqui temos um esquema simplificado de como funciona. Não se trata de uma API real, tampouco de um modelo efetivamente carregado; serve apenas para termos uma ideia. Vamos observar isso na prática para compreendermos melhor.

Configurando o projeto no PyCharm

Agora estamos no ambiente do PyCharm. Não sabemos se todas as pessoas já o conhecem, então faremos passo a passo para que todas possam acompanhar. No menu File > New Project, definimos onde o projeto será salvo em uma pasta local e nomeamos como _test1.

Em seguida, escolhemos a versão do Python. Preferimos não selecionar a versão mais recente, pois atualizações muito novas podem introduzir mudanças; assim, optamos por uma versão imediatamente anterior. Neste caso, vamos usar a 3.11.

Criamos o projeto, abrimos nesta janela e aguardamos a configuração. Pronto: temos um projeto Python disponível para uso.

Iniciando a simulação de API e preparando a função

Agora, vamos criar outro arquivo Python e nomeá-lo test. Aqui, vamos apenas simular como uma API funciona. Essa parte será detalhada nas próximas aulas.

Primeiro, vamos criar uma função com def para prever preços. Vamos simular a previsão de preços do mercado imobiliário — quanto vamos pagar em um caso determinado por um apartamento, dependendo do valor por metro quadrado, ou melhor dizendo, da área. Para isso, definimos o parâmetro area_M2, que representa a metragem em metros quadrados.
Observação: no código abaixo, vamos adotar a convenção de nomes em Python (PEP 8) e usar area_m2 como nome do parâmetro.

Definindo a função de previsão de preços

Começamos definindo a assinatura da função:

def prever_precos(area_m2):

Essa função devolverá area_m2 multiplicado por 5000. Primeiro, adicionamos o retorno vazio para estruturar a função:

def prever_precos(area_m2):
    return

Em seguida, completamos a lógica de retorno, multiplicando a área pelo valor de referência (5000):

def prever_precos(area_m2):
    return area_m2 * 5000

Criando a entrada e gerando a saída

Em seguida, vamos criar uma entrada: definimos a variável entrada igual a 70, representando um apartamento de 70 metros quadrados. A saída será a chamada da função prever_precos, passando entrada como argumento. Nesse ponto, descrevemos que o usuário informa o metro quadrado e o valor é multiplicado por 5000.

Primeiro, declaramos a entrada:

entrada = 70

Depois, geramos a saída chamando a função:

saida = prever_precos(entrada)

Exibindo o resultado no console

Além disso, vamos incluir um print. Esse print exibirá: Preço previsto: seguido de saida.

Primeiro, imprimimos apenas o rótulo (texto):

print("Preço Previsto: ")

Na sequência, imprimimos o rótulo junto com o valor calculado:

print("Preço Previsto: ", saida)

Conectando a função ao fluxo de API e indicando próximos passos

Isso é uma lógica simplificada de como nossa API funcionará e terá um formato muito parecido. Nos próximos vídeos, vamos compreender esse funcionamento: faremos uma solicitação a partir do cliente, haverá um processamento na API, um modelo realizará a previsão e teremos uma resposta. Ao observar essa função, percebemos um formato similar ao fluxo descrito. É exatamente isso que está sendo feito. Vale lembrar que, aqui, não estamos utilizando um modelo.

Na próxima aula, começaremos a trabalhar com a API e iniciaremos a previsão. Também vamos começar a trabalhar com Flask.

Nos vemos na próxima aula.

Flask como base: entendendo o funcionamento de uma API - Criando a primeira aplicação Flask

Relembrando o papel da API e apresentando o Flask

Na aula anterior, vimos que uma API funciona como uma ponte entre uma lógica de dados e outros sistemas que precisam consumir essa lógica ou dados. Basicamente, isso é o que é uma API.

Agora, vamos começar a construir essa ponte na prática e, para isso, utilizaremos Flask, que é uma ferramenta simples em Python para criar essas APIs. Antes de pensarmos em um modelo de aprendizado de máquina, vamos entender o básico. Vamos criar uma aplicação em Python que responda quando acessarmos um endereço.

Flask é chamado de microframework (estrutura mínima), porque oferece uma estrutura leve para criar aplicações web com Python. Isso ajuda no início, pois conseguimos ver com clareza o papel de cada parte do código. Com ele, podemos criar uma aplicação que executa localmente e responde às chamadas feitas pelo navegador, pelo Postman ou por qualquer outro código Python. Pensemos assim: uma função em Python, que antes era invocada a partir do código, agora responde por meio de um endereço.

Retomando a função de previsão e executando exemplos

Vamos, inclusive, retomar o exemplo da outra aula, em que não executamos o código, para observar como funciona dentro da função. Provavelmente isso já é conhecido. Depois, construiremos como isso vai funcionar na API.

Antes de ir ao Flask, vamos relembrar a lógica isolada da função de previsão, executando-a no Python para ver o fluxo completo de entrada e saída:

def prever_precos(area_m2):
    return area_m2 * 5000


entrada = 180
saida = prever_precos(entrada)

print("Preço Previsto: ", saida)

Antes disso, vamos executar apenas esta parte para entendermos melhor. Por exemplo, inserimos os metros quadrados com o básico que fizemos antes: colocamos 120 metros quadrados, executamos, fazemos a solicitação e obtemos uma resposta que, neste caso, seria 600.000. Isso mesmo, 600.000.

Para refletir essa alteração no código, ajustamos a variável de entrada para 120:

entrada = 120

Com essa mudança (e mantendo as linhas que chamam a função e imprimem o resultado), a saída será 600000, como mencionado.

Explicando rotas no Flask e planejando a aplicação

Como a API funciona no Flask? No Flask, associamos uma rota a uma função em Python. Uma rota é um caminho na URL do site; a barra (/) representa o caminho principal da aplicação. Quando alguém acessa essa rota, o Flask executa a função associada e devolve uma resposta. Guardemos essa ideia: a API recebe uma solicitação, executa uma lógica e devolve uma resposta.

Agora, vamos ao PyCharm e criar nossa primeira aplicação Flask. Ela será pequena e terá uma estrutura básica: aplicação, rota e resposta.

Criando o projeto no PyCharm e preparando o arquivo

Em seguida, vamos utilizar as ferramentas do PyCharm. Vamos em Arquivo, Novo Projeto. No nosso ambiente há vários projetos, pois às vezes fazemos alguns testes. Como vamos utilizar Flask, vamos escolher novamente Python 3.11. Em seguida, criamos o projeto com o nome padrão "Flask Project 1". Se quisermos mudar o nome, podemos escolher outro; isso depende de você.

Vamos criar este arquivo nesta mesma janela, para evitar abrir outra. Vamos aguardar um momento; o editor já abriu, apenas demorou um pouco. Queremos um novo arquivo Python e vamos nomeá-lo test API.

Construindo a aplicação Flask linha a linha

Primeiro, vamos entender a estrutura e explicar linha por linha o que é importante. Na primeira linha, importamos a classe principal do Flask. Importamos Flask, que é a classe usada para criar nossa aplicação.

from flask import Flask

Na sequência (é a terceira linha do arquivo, mas a segunda de código), criamos a aplicação Flask. A variável app passa a representar nossa API (Interface de Programação de Aplicações). O name — com sublinhado duplo antes e depois — é uma convenção do Python que ajuda o Flask a identificar o arquivo principal.

app = Flask(__name__)

Em seguida, definimos uma rota com @app.route("/"). Se deixarmos o mouse parado sobre esse elemento, o editor mostra uma pequena explicação. A barra / representa a rota principal da aplicação.

@app.route('/')

Quando alguém acessa essa rota, o Flask executa a função definida logo abaixo do decorador. Dentro dessa função, usamos return. O return aqui funciona como nas outras funções que já utilizamos, quando devolvíamos, por exemplo, o preço do imóvel (casa ou apartamento) com o qual estávamos trabalhando.

Uma função mínima para essa rota pode ser:

def hello_world():  # put application's code here
    return 'Hello World!'

Para destacar a linha que efetivamente envia a resposta ao cliente, observe o retorno:

return 'Hello World!'

Executando o servidor local e entendendo o fluxo de resposta

Mais adiante, há uma verificação para saber se o arquivo está sendo executado diretamente. Por isso há um if nessa parte do código. Se essa condição for verdadeira, o Python executa o bloco abaixo, no qual chamamos app.run(). Nessa chamada, instruímos a aplicação a ser executada.

if __name__ == '__main__':
    app.run()

O comando que aciona o servidor local é:

app.run()

Ao executar o arquivo, o Flask levanta um servidor local; assim, a aplicação passa a rodar em nossa própria máquina. Quando acessamos o endereço indicado no terminal, a função correspondente — no exemplo, a que retorna Hello, World! (Olá, Mundo) — é executada e a resposta aparece no navegador.

Consolidando o código e encerrando a aula

Consolidando tudo o que montamos passo a passo, o arquivo completo fica assim:

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello_world():  # put application's code here
    return 'Hello World!'


if __name__ == '__main__':
    app.run()

Neste primeiro exemplo, vimos a estrutura mínima de uma API (Interface de Programação de Aplicações) com Flask. Criamos uma aplicação (o PyCharm gerou a base para nós), definimos uma rota e devolvemos uma resposta.

No próximo vídeo, vamos criar uma nova rota para entender melhor os endpoints (pontos de extremidade). Nos vemos no próximo vídeo.

Sobre o curso APIs e Machine Learning: colocar modelos do notebook em produção com Flask e FastAPI

O curso APIs e Machine Learning: colocar modelos do notebook em produção com Flask e FastAPI possui 196 minutos de vídeos, em um total de 60 atividades. Gostou? Conheça nossos outros cursos de Engenharia de Dados em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Introdução às APIs e início do projeto
• Flask como base: entendendo o funcionamento de uma API
• Construindo a API principal com FastAPI
• Preparando o modelo de Machine Learning
• Integrando o modelo à API
• Segurança na prática: protegendo a API com JWT
• Finalização do projeto e visão de produção