Como implantar um modelo de aprendizado de máquina?

Nos últimos anos, o aprendizado de máquina e a inteligência artificial ganharam grande popularidade. É provável que isso seja atribuído aos avanços no processamento de linguagem natural e nos sistemas de recomendação.

Este artigo apresenta o aprendizado de máquina, seus aplicativos, opções de implantação e demonstra como implantar um modelo simples de aprendizado de máquina nos contêineres do Back4app.

O que é aprendizado de máquina?

O aprendizado de máquina é um subcampo da inteligência artificial. Em sua essência, ele utiliza algoritmos estatísticos para aprender com os dados e fazer previsões sobre dados novos e não vistos.

Em outras palavras, ele dá aos computadores a capacidade de aprender sem serem explicitamente programados.

Embora o aprendizado de máquina e a inteligência artificial sejam frequentemente usados de forma intercambiável, eles não são a mesma coisa.

O aprendizado de máquina se concentra em algoritmos e estruturas de dados, enquanto a inteligência artificial é uma tentativa geral de criar máquinas capazes de pensar de forma semelhante à humana.

As técnicas típicas de aprendizado de máquina são a regressão (previsão de um valor contínuo, por exemplo, o preço de uma casa) e a classificação (previsão de uma classe a partir de um conjunto finito de classes, por exemplo, um gênero de filme).

Em termos gerais, podemos dividir o aprendizado de máquina em três tipos:

• Aprendizagem supervisionada: os algoritmos aprendem usando um conjunto de dados rotulados. Cada exemplo no conjunto de dados contém um rótulo (ou a chamada variável-alvo). O algoritmo usa isso para prever rótulos para exemplos não vistos. Os algoritmos de aprendizado supervisionado incluem kNN, árvores de decisão, etc.

• Aprendizagem não supervisionada: os algoritmos aprendem sem nenhuma orientação explícita. Cabe ao algoritmo encontrar padrões nos dados e fazer previsões com base neles. Um exemplo de algoritmo é o k-means clustering.

• Aprendizado por reforço – os algoritmos aprendem por tentativa e erro. Normalmente, eles se baseiam em recompensas, e o objetivo do algoritmo é maximizar a recompensa. Exemplo: algoritmos genéticos.

Na parte prática do artigo, passaremos por um processo típico de criação de modelos. Resolveremos uma tarefa de classificação usando o aprendizado supervisionado.

Aplicativos de aprendizado de máquina

Vamos dar uma olhada em alguns aplicativos de aprendizado de máquina do mundo real!

Sistemas de recomendação

Os sistemas de recomendação sugerem quais itens (filmes, produtos, etc.) um usuário deve consumir. Esses sistemas podem ser baseados em conteúdo ou em colaboração.

Atualmente, os sistemas de recomendação são usados por quase todas as empresas. Eles permitem que as empresas aumentem o sucesso dos negócios, criem demanda adicional, aumentem o envolvimento do usuário, aprendam sobre os clientes e muito mais.

A Netflix, por exemplo, os utiliza para recomendar filmes, o Spotify para recomendar músicas e o YouTube para sugerir vídeos que você deve assistir com base em seus interesses.

Processamento de linguagem natural (NLP)

O processamento de linguagem natural (NLP) permite que os computadores processem e entendam a linguagem humana. A geração de linguagem natural (NLG) permite que os computadores gerem linguagem humana.

Essa tecnologia é usada por chatbots, ferramentas de tradução de idiomas, ferramentas de análise de sentimentos e muito mais. O ChatGPT é um dos exemplos mais famosos que utiliza NLP e NLG.

Deseja saber mais sobre o ChatGPT? Confira nosso outro artigo chamado Como criar um aplicativo usando o ChatGPT?

Visão computacional e reconhecimento de imagens

A visão computacional dá aos computadores a capacidade de “ver” e “entender” imagens e vídeos. Ela permite que eles realizem segmentação (em tempo real), reconheçam objetos, rostos e até mesmo emoções.

Essa é a tecnologia usada pelos aplicativos de fotos para marcar seus amigos automaticamente. Além disso, ela é usada por sistemas de vigilância para detectar comportamentos suspeitos.

Detecção de fraudes

As empresas empregam o aprendizado de máquina para detectar atividades suspeitas em transações ou no comportamento do usuário. Esses sistemas podem detectar atos potencialmente fraudulentos estudando tendências e anormalidades, protegendo empresas e clientes contra fraudes e crimes cibernéticos.

Carros autônomos

A condução autônoma de carros é um dos problemas mais complicados de aprendizado de máquina. Ele combina vários aplicativos, como visão computacional, detecção de anomalias, previsão de comportamento, planejamento de caminhos, etc.

No momento em que este artigo foi escrito, não estamos nem perto de carros totalmente autônomos. Os carros “autônomos” atuais só funcionam bem em áreas geográficas restritas.

Opções de implementação de aprendizado de máquina

Para implantar um modelo de aprendizado de máquina, você geralmente o serve a partir de um aplicativo da Web. Portanto, as opções de implementação do modelo de aprendizado de máquina são praticamente as mesmas da implementação de aplicativos da Web. Vamos dar uma olhada nelas!

No local

A implementação no local implica a hospedagem e o gerenciamento de equipamentos de TI, como servidores e dispositivos de armazenamento, nas instalações reais de uma empresa.

Essa estratégia tradicional exige um investimento inicial considerável em hardware e software, além de manutenção e suporte contínuos.

Seus prós incluem um nível mais alto de controle e segurança e uma personalização mais acessível. Por outro lado, as desvantagens são o custo, a escalabilidade e a manutenção.

Nuvem

Por outro lado, a implementação da nuvem emprega serviços de terceiros para hospedar a infraestrutura e os aplicativos via Internet.

Esse modelo permite que os usuários paguem conforme o uso de recursos e serviços escalonáveis, que são administrados pelos provedores de serviços em nuvem.

Seus prós incluem escalabilidade, facilidade de uso e nenhum custo inicial. Por outro lado, as desvantagens são um nível mais baixo de controle, menos flexibilidade e possível dependência do fornecedor.

Exemplos de plataformas baseadas em nuvem incluem:

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Microsoft Azure

Algoritmos populares de aprendizado de máquina

Os algoritmos populares de aprendizado de máquina são:

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

No exemplo prático, usaremos o k-Nearest Neighbours.

Como implementar um modelo de aprendizado de máquina?

Nesta seção do artigo, criaremos um modelo de aprendizado de máquina, o serviremos com o FastAPI, o dockerizaremos e, por fim, o implantaremos nos contêineres do Back4app.

Pré-requisitos

• Conhecimento básico de aprendizado de máquina
• Experiência com Python e FastAPI
• Conhecimento básico do Docker e da tecnologia de contêineres
• Git e Docker Desktop instalados em seu computador local

Visão geral do projeto

Antes de demonstrar como implantar um modelo de aprendizado de máquina, vamos criar um. Criaremos um classificador kNN simples usando o popular conjunto de dados Iris. O objetivo do modelo será prever se uma observação é “setosa”, “versicolor” ou “virginica” com base em diferentes recursos.

Em seguida, salvaremos o modelo em um arquivo, o carregaremos no FastAPI e o serviremos por meio de um endpoint. Depois disso, vamos dockerizar o aplicativo, enviá-lo para o GitHub e implantá-lo no Back4app Containers.

Criar modelo

Para criar o modelo, usaremos o Jupyter Notebooks. Você pode instalar o Jupyter em seu computador local ou usar o Google Colab gratuitamente.

Primeiro, crie um novo notebook Jupyter.

Cada bloco de código nesta seção do artigo representa uma célula do Jupyter. Você pode criá-las no menu ou usando a tecla “B” (no modo de comando).

Além disso, não se esqueça de executá-los (no menu ou usando “ALT + ENTER”).

Adicione as seguintes importações na primeira célula:

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Carregar conjunto de dados

O conjunto de dados Iris está incluído no Scikit-learn por padrão. Tudo o que você precisa fazer é chamar a função load_iris() e transformar o objeto em um quadro.

Criar uma nova célula:

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Quando você carrega o conjunto de dados do Iris, ele é ordenado pela variável de destino. Isso não é bom porque nosso modelo de aprendizado de máquina pode ver apenas alguns tipos de exemplos na fase de treinamento. Por exemplo, somente “setosa” e “versicolour”.

Para evitar esse problema, podemos embaralhá-lo:

df = df.sample(frac=1, random_state=42)

O atributo random_state é usado para reprodutibilidade. Você pode usar qualquer número que desejar.

Explorar conjunto de dados

Antes de criar um modelo, é uma boa ideia explorar os dados com os quais você está lidando. Para fazer isso, você pode usar as funções internas do Pandas, como head(), describe() e assim por diante.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

Além disso, você deve visualizar o conjunto de dados para descobrir quais recursos separam melhor os exemplos e qual algoritmo de aprendizado de máquina pode ser útil para o seu problema.

A imagem acima foi emprestada do artigo Guide to Data Visualization with Python (Guia para visualização de dados com Python ). Não deixe de dar uma olhada nele para saber mais sobre visualização de dados.

A imagem mostra que os pontos “vermelhos” são linearmente separáveis dos outros dois. Os pontos “azul” e “verde”, por outro lado, não são linearmente separáveis.

Conjunto de dados dividido

Continuando, vamos definir os recursos (preditores) e a variável de destino:

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

Em seguida, extraia-os em X (dados de recursos) e y (dados da variável de destino) e teste e treine a divisão:

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

Ao usar test_size=0,25, 25% do conjunto de dados é usado para teste, enquanto 75% é usado para treinamento.

Modelo de construção

Em seguida, crie um pipeline que primeiro dimensione os dados e depois use o classificador kNN:

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

Para saber por que o dimensionamento é essencial, confira este artigo.

Em seguida, use a validação cruzada 10 vezes e verifique o erro de validação:

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Avalie o modelo no conjunto de teste:

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

A precisão da validação e do teste são praticamente iguais. Isso indica que o nosso modelo não está se ajustando de forma insuficiente ou excessiva.

Salvar modelo

Por fim, treine novamente o modelo usando todos os dados e salve-o no arquivo model.pkl:

knn.fit(X, y)
dump(knn, "model.pkl")

Se estiver usando o Google Colab, faça o download do arquivo model.pk, pois precisaremos dele na próxima etapa.

Modelo de serviço

Conforme mencionado anteriormente, usaremos a FastAPI para atender ao modelo.

Vá em frente e crie um novo projeto FastAPI e substitua o main.py da seguinte forma:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Inicie o servidor de desenvolvimento:

$ uvicorn app.main:app --reload

Navegue até http://localhost:8000/ e você deverá obter a seguinte resposta:

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Modelo de carga

Em seguida, vamos carregar o modelo e definir as model_classes.

Primeiro, copie o model.pkl da etapa anterior para a raiz do seu projeto. Em seguida, carregue o modelo e defina as classes logo abaixo da inicialização do aplicativo FastAPI, da seguinte forma:

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Usaremos model_classes para traduzir a variável de destino de numérica para texto.

Modelo de carga

Em seguida, crie o ponto de extremidade /predict, que recebe os recursos e usa o modelo carregado para fazer uma previsão:

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

O ponto de extremidade retorna a previsão numérica, bem como a previsão de teste de fácil utilização.

Não se esqueça das importações na parte superior do arquivo:

from joblib import load
from pydantic import BaseModel

Seu main.py final deve ter a seguinte aparência.

Reinicie o servidor de desenvolvimento e navegue até http://localhost:8000/docs em seu navegador da Web favorito. O FastAPI gera automaticamente uma documentação interativa para todos os seus pontos de extremidade.

Teste o modelo enviando uma solicitação como esta:

Ótimo, nosso aplicativo da Web agora está funcionando plenamente!

Aplicativo Dockerize

Nesta seção do artigo, vamos dockerizar o aplicativo Web. Criaremos um Dockerfile e configuraremos o arquivo .dockerignore.

Dockerfile

Um Dockerfile é um arquivo que contém instruções para o Docker Engine seguir para criar a imagem.

Isso geralmente inclui a transferência de arquivos, a definição da imagem base, a configuração do diretório de trabalho, a execução de comandos personalizados e muito mais.

Os comandos do Dockerfile geralmente são escritos em letras maiúsculas e são seguidos diretamente por seus argumentos correspondentes.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Visite a referência do Dockerfile para saber mais sobre todas as instruções.

Na raiz do projeto, crie um Dockerfile:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

Ao trabalhar com o Docker, você deve criar imagens que sejam tão pequenas quanto possível.

Uma maneira de reduzir o tamanho da imagem é utilizar um arquivo .dockerignore. Esse arquivo funciona de forma semelhante a um arquivo .gitignore. Ele permite que você omita arquivos que não precisam ser incluídos na imagem.

Na raiz do projeto, crie um .dockerignore:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

Certifique-se de adaptar o arquivo .dockerignore de acordo com os requisitos do seu projeto (por exemplo, se estiver usando um IDE diferente).

Criar, executar, testar

Antes de enviar a imagem para a nuvem, é uma boa ideia testá-la localmente.

Para acompanhar o processo, você precisará do Docker Desktop instalado em seu computador.

Abra o terminal e verifique as imagens atualmente instaladas:

$ docker images

Em seguida, crie a imagem usando o Dockerfile:

$ docker build -t iris-webapp:1.0 .

O Docker levará um bom tempo para criar a imagem. Isso ocorre principalmente porque o Scikit-learn não é otimizado para contêineres do Docker. Sinta-se à vontade para fazer uma rápida pausa para o café.

Após a conclusão do comando, verifique novamente as imagens. A imagem recém-criada deve estar lá.

Por fim, use a imagem para criar um novo contêiner:

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

É isso aí!

Seu aplicativo Web agora está em contêiner. Ele deve estar acessível em http://localhost:8000/ e funcionar da mesma forma que antes.

Enviar para o GitHub

Primeiro, navegue até o GitHub e crie um novo repositório. Anote a URL remota, pois precisaremos dela em uma etapa posterior.

Em seguida, retorne à raiz do projeto.

Antes de enviar o código-fonte para a nuvem, crie um arquivo .gitignore. Um arquivo .gitignore permite especificar quais arquivos e diretórios devem ser omitidos do controle de versão.

Esse tipo de arquivo funciona da mesma forma que os arquivos .dockerignore.

Na raiz do projeto, crie um arquivo .gitignore:

#.dockerignore

.idea/
__pycache__/
venv/

Abra o terminal e execute o seguinte comando para inicializar o Git:

$ git init

Adicione todos os arquivos ao VCS e faça o commit deles:

$ git add .
$ git commit -m "first commit"

Por fim, adicione a origem remota do GitHub usando a URL anterior e faça push do código-fonte:

$ git remote add origin <remote_url>
$ git push origin master

Certifique-se de que o URL remoto da etapa anterior seja usado no lugar de .

É isso aí. Se você visitar a página do repositório do GitHub agora, verá que todos os arquivos foram adicionados.

Implantar aplicativo

Para implantar um aplicativo no Back4app Containers, você deve primeiro se registrar ou fazer login (se já tiver uma conta).

Ao se autenticar com sua conta Back4app, você será levado ao painel do aplicativo. Para criar um novo aplicativo, clique em “Build new app” (Criar novo aplicativo).

O Back4app permite a implementação de Backend como serviço e de Contêineres como serviço. Como estamos implantando um aplicativo em contêiner, escolheremos a última opção.

Em seguida, você terá que conectar sua conta do GitHub ao Back4app. Isso permitirá que o Back4app extraia o código-fonte de seus repositórios. Você pode conceder acesso a todos os repositórios ou escolher alguns específicos.

Depois que os repositórios forem importados, clique em “Select” (Selecionar).

A configuração do ambiente é desnecessária, além de fornecer um nome descritivo para o aplicativo.

Em seguida, clique em “Create” (Criar).

O Back4app precisará de alguns minutos para criar a imagem, enviá-la para o registro de contêineres e ativar um contêiner. Depois que a implantação for concluída, o status do seu aplicativo deverá mudar para “Ready” (Pronto).

Para visitar seu aplicativo, clique no URL conforme indicado na imagem abaixo.

Ótimo, você implantou com sucesso um modelo de aprendizado de máquina no Back4app Containers. O aplicativo Web deve funcionar da mesma forma que funcionava localmente. Certifique-se de testar o aplicativo mais uma vez.

Resumo

Neste artigo, você aprendeu os conceitos básicos do aprendizado de máquina, suas aplicações e como implantar um modelo de aprendizado de máquina.

Agora você deve ser capaz de criar seus próprios modelos simples, servi-los com FastAPI e implantá-los nos contêineres do Back4app.

Obtenha o código-fonte final do repositório back4app-deploy-ml-model do GitHub.