Web App com Machine Learning
Desenvolver um web app com machine learning não precisa ser uma tarefa difícil. Streamlit é uma biblioteca Python excelente para a criação de web apps com rapidez e facilidade. Ela é particularmente adequada para aplicações web de análise e visualização de dados e também aplicativos alimentados por algoritmos de machine learning e IA. Neste post, ilustraremos como implementar um aplicativo web com Streamlit e um modelo de machine learning.
Bibliotecas Python
Usaremos três bibliotecas:
- Streamlit — para fazer o app
- Scikit-learn — para machine learning
- NumPy — para criar arrays
Passo 1: Definição do Objetivo do Modelo e do Conjunto de Dados
O primeiro passo para qualquer web app com machine learning é ter um modelo! É possível usar modelos pré-treinados, como os milhares disponíveis na plataforma Hugging Face, ou treinar o seu próprio modelo. Essa segunda opção é a que faremos. Treinaremos um modelo para classificar o conjunto de dados Iris usando Scikit-learn.
Passo 2: Separação dos Conjuntos de Treinamento e Teste
O conjunto de dados Iris está disponível em vários repositórios e APIs. Usaremos a versão que a própria biblioteca Scikit-learn possui. Portanto, num código Python, importe a biblioteca e carregue os dados como mostrado abaixo:
from sklearn.datasets import load_iris
iris = load_iris()
Eles já estão separados em atributos (iris.data) e rótulos (iris.target). Essa separação é usada para criar as variáveis X (atributos) e as variáveis-alvo y.
X = iris.data # atributos
y = iris.target # alvos
Depois, precisamos dividir o conjunto de dados originais em conjuntos de treinamento e teste. Usaremos a função train_test_split da biblioteca Scikit-learn para isso. Ela já randomiza os dados automaticamente para garantir uma distribuição homogênea das classes em cada conjunto.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
Passo 3 – Escolha do Modelo
Vários modelos clássicos de machine learning classificam o conjunto de dados Iris com alta acurácia. Para este post, usaremos o algoritmo k-Nearest Neighbors (kNN). Ele é um algoritmo bastante intuitivo de aprendizagem supervisionada usado para tarefas de classificação e regressão. Leia mais sobre ele aqui.
Passo 4 – Treinamento do Modelo
A biblioteca Scikit-learn possui a maioria dos algoritmos de machine learning já implementados. Para usá-los, a implementação geral envolve definir um classificador e aplicá-lo. Como classificador, definimos o algoritmo kNN. Ele tem apenas um parâmetro k que precisa ser escolhido. Ele se refere ao número de vizinhos. Usaremos 5, mas você pode variar esse valor para explorar o modelo.
from sklearn.neighbors import KNeighborsClassifier
k = 5 # vizinhos do kNN
knn = KNeighborsClassifier(n_neighbors=k) # cria o classificador
Depois é só treinar o modelo usando os conjuntos de dados de treinamento.
knn.fit(X_train, y_train) # treina o modelo
Passo 5 – Teste do Modelo
Após o modelo ser treinado, é hora de testá-lo nos conjuntos de teste. Isso também será feito com a ajuda da excelente biblioteca Scikit-learn.
y_pred = knn.predict(X_test) # testa modelo
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, y_pred) # verifica desempenho
print("Acurácia:", accuracy)
O nosso modelo é bastante acurado (acurácia ~ 1). Pode ser que seu valor não seja exatamente igual ao nosso porque a seleção dos dados é randômica e isso altera os resultados.
Passo 6 – Salvamento do Modelo
O modelo já está pronto. Agora é preciso salvá-lo para que ele possa alimentar um web app. Para esse salvamento, o modelo será convertido em um arquivo pickle como mostrado abaixo:
import pickle
# Salva modelo
with open('knn_model.pkl', 'wb') as f:
pickle.dump(knn, f)
Passo 7 – Iniciando o Web App
O objetivo do nosso web app é demonstrar como usar um modelo de machine learning com Streamlit. Portanto, utilizaremos um layout minimalista. Crie um novo código Python (app.py). Faça as importações necessárias:
import numpy as np
import pickle
import streamlit as st
Carregue o modelo treinado. Para evitar que o modelo seja recarregado a cada recarregamento do app, usaremos o decorador st.cache_resource para salvá-lo em cache.
# Carrega o modelo
@st.cache_resource
def carrega_modelo():
''' função que carrega o modelo treinado e o armazena no cache'''
with open('knn_model.pkl', 'rb') as f:
model = pickle.load(f)
return model
model = carrega_modelo()
Passo 8 – A Tarefa do App
A ideia desse app é bem simples. As flores Iris podem ser classificadas a partir de apenas 4 atributos. Cada atributo varia em uma faixa específica. Essas faixas podem ser verificadas na análise exploratória dos dados (EDA), como explicado aqui. Abaixo, um pequeno resumo estatístico do conjunto de dados Iris é mostrado para ilustrar que cada atributo varia em uma faixa própria de valores.
# Resumo estatístico do conjunto de dados Iris
sepal_length sepal_width petal_length petal_width
count 150.000000 150.000000 150.000000 150.000000
mean 5.843333 3.057333 3.758000 1.199333
std 0.828066 0.435866 1.765298 0.762238
min 4.300000 2.000000 1.000000 0.100000
25% 5.100000 2.800000 1.600000 0.300000
50% 5.800000 3.000000 4.350000 1.300000
75% 6.400000 3.300000 5.100000 1.800000
max 7.900000 4.400000 6.900000 2.500000
Nosso objetivo é possibilitar que os usuários do app variem os valores desses atributos para verificar a que categorias de iris eles correspondem. Para isso, precisaremos de uma função que recebe os atributos indicados pelos usuários e realiza predições usando o modelo treinado. Essa função utiliza um array NumPy com os valores dos atributos para alimentar o modelo.
# Cria uma função para realizar predição usando o modelo treinado
def predict(model, sepal_length, sepal_width, petal_length, petal_width):
''' função que realiza predição usando o modelo treinado'''
features = np.array([[sepal_length, sepal_width, petal_length, petal_width]])
prediction = model.predict(features)
return prediction[0]
Passo 9 – Layout
Como nosso objetivo é possibilitar que os usuários entrem com valores de atributos para receber predições, precisamos de uma forma de limitar esses valores a faixas de variações próximas às observadas no conjunto de dados Iris. As faixas do dataset foram mostradas no resumo estatístico acima.
Para cada atributo, adicionaremos um slider no nosso app. Portanto, nosso layout consiste em um título para o app e quatro sliders, já que o modelo da Iris possui quatro atributos de entrada. Cada slider será utilizado para possibilitar que os usuários variem os valores dos atributos em faixas aproximadas de seus valores no conjunto de dados Iris.
# Cria layout do app
st.title("Aplicativo de Predição de Flores Iris")
sepal_length = st.slider("comprimento da sépala", 0.0, 10.0, 3.0)
sepal_width = st.slider("largura da sépala", 0.0, 5.0, 1.0)
petal_length = st.slider("comprimento da pétala", 0.0, 10.0, 1.0)
petal_width = st.slider("largura da pétala", 0.0, 5.0, 0.2)
Por último, adicionamos um botão para chamar a função de predição. Como as predições são dadas em números, converteremos os valores obtidos para os nomes das Iris:
if st.button("Gerar Predição"):
species = predict(model, sepal_length, sepal_width, petal_length, petal_width)
# Para converter predição de número para nome
if species == 0:
species_name = "Iris setosa"
if species == 1:
species_name = "Iris versicolor"
if species == 2:
species_name = "Iris virginica"
st.write(f"A espécie prevista é: {species_name}")
Salve o código e o execute com o seguinte comando digitado em seu terminal: streamlit run app.py. Isso iniciará o aplicativo Streamlit em seu navegador. No aplicativo, você pode ajustar os sliders para inserir diferentes valores de atributos de Iris e clicar no botão “Gerar Predição” para ver as espécies previstas com base em seu modelo treinado. A imagem abaixo mostra o app realizando predições.
