Requisitos
Para seguir esse tutorial espera-se que você tenha conhecimento suficiente da linguagem de programação Python e do uso de ferramentas como Google Colab ou Jupyter-notebook.
Ter lido os dois primeiros artigos da série de artigos sobre River que eu escrevi é desejável.
Instalação
A biblioteca River é feita para funcionar a partir do Python 3.8. A instalação pode ser feita usando o gerenciador de pacotes pip:
# Via notebook
!pip install river
# Via terminal
pip install river
Problema de Classificação
Nesse tutorial vamos explorar um problema de classificação usando o famoso dataset titanic.
💡 O motivo de eu usar um dataset tradicional e em lote para um tutorial de aprendizado em streaming é puramente educacional. Além disso, como dito no artigo anterior, a biblioteca River tem ferramentas para ler conjuntos de dados em lote no formato de streaming para avaliação do modelo e para propósitos de estudo, como o desse tutorial.
💡 Esse dataset poderia ser considerado um dataset proativo, pois temos controle direto sobre os dados. Para saber mais confira o artigo de introdução ao River: https://dev.to/nobrelucas/river-aprendizado-de-maquina-online-com-python-uma-introducao-conceitual-3bb2
Instale os três arquivos do dataset no link: https://www.kaggle.com/competitions/titanic/data
Adicione o dataset no seu workspace e vamos começar a trabalhar.
💡 Recomendo criar uma pasta “data” no seu workspace para adicionar todos os dados
Preparação dos Dados
Com o seu notebook aberto, vamos ao código. Começamos criando um DataFrame pandas com os dados de treino e observando as cinco primeiras linhas.
import pandas as pd
dataframe = pd.read_csv('data/train.csv')
dataframe.head()
Isso deve mostrar o seguinte resultado:
💡 Os detalhes de cada coluna desse dataset podem ser encontrados no link no qual você baixou o conjunto de dados.
Vamos nos concentrar em fazer um modelo simples. Nesse caso, as colunas que mais nos interessam são:
- Survived (Alvo): É uma coluna categórica com duas classes (1 para sobreviventes e 0 para não sobreviventes)
- Pclass: É uma coluna categórica com três classes (1 para primeira classe, 2 para segunda classe e 3 para terceira classe)
- Sex: Coluna categórica indicando o sexo do passageiro
Escolhi as features Pclass e Sex porque, historicamente, mulheres ricas foram as pessoas que mais sobreviveram.
Vamos filtrar essas colunas que são as únicas que nos interessam no momento
dataframe = dataframe[['Survived', 'Pclass', 'Sex']]
dataframe.head()
Mostrando o seguinte resultado:
Agora vamos transformar a coluna Sex em uma coluna numérica (1 para male e 2 para female)
dataframe['Sex'] = dataframe['Sex'].replace({'male': 1, 'female': 2})
dataframe.head()
Obtendo como resultado:
Por fim precisamos separar o dataset em features de treino e alvo (target). No nosso caso, Survived é o alvo e as demais colunas são as features de treino. Também irei transformar a coluna alvo de numérica para booleana para se adaptar ao modelo e a forma que o River trabalha.
features = dataframe[['Pclass', 'Sex']]
target = dataframe['Survived'].replace({0: False, 1: True})
Com todos nossos dados estando no formato desejado e separados em features e target, podemos começar a efetivamente trabalhar com o modelo.
Criação e treinamento do modelo online
O objetivo de um classificador é predizer qual a categoria de uma determinada amostra, predizer um alvo y para um conjunto de características x. Vamos fazer isso usando um modelo de regressão logística.
from river import linear_model
model = linear_model.LogisticRegression()
Com o código acima nós instanciamos o modelo.
💡 Eu irei frequentemente instanciar o modelo do começo para treiná-lo de formas diferentes.
Para treinar o modelo, basta alimentar ele com uma amostra dos dados por vez, mas como fazer isso se nossos dados são um grande lote? O módulo stream
do River nos ajuda a lidar com isso e tem uma função chamada iter_pandas, que nos permite iterar um dataframe ou uma série pandas como se os dados estivessem chegando para nós em stream.
Experimente:
from river import stream
for X, y in stream.iter_pandas(features, target):
print(X, y)
Cada print vai mostrar um dicionário com as features e um valor para cada uma delas e ao lado o valor do target para aquela amostra.
Mas o que queremos não é simplesmente ver as amostras e sim ensinar ao modelo a predizer se dada uma amostra um passageiro sobreviveu ou não.
Para isso, podemos usar o método learn_one(X, y)
. Entretanto, vamos criar um objeto iterável chamado “stream_dataset” ao invés de chamar a função iter_pandas diretamente no laço de repetição. A motivação para isso vai ficar mais clara futuramente.
from river import stream
stream_dataset = stream.iter_pandas(features, target)
for X, y in stream_dataset:
model.learn_one(X, y)
Como estamos em um ambiente de aprendizado, vamos usar o mesmo dataframe para testar o modelo. Para um primeiro teste, vamos tentar predizer a primeira amostra do dataframe (homem que estava na terceira classe do navio e que não sobreviveu).
stream_dataset = stream.iter_pandas(features, target)
x, y = next(stream_dataset)
model.predict_one(x)
💡 Notem que eu instancio o objeto stream_dataset novamente para poder iterar ele novamente desde o início. Isso irá se repetir durante o resto do tutorial para experimentar diversas abordagens de treino e de validação.
O resultado do código acima deve ser false
pois de fato esse passageiro não sobreviveu.
Verificar o que o modelo prediz uma amostra de cada vez não é uma boa estratégia, então vamos avaliar o modelo de uma forma bem comum para iniciantes em aprendizado de máquina: armazenando a predição do modelo para cada iteração e verificar a classe real para aquela amostra e depois calcular uma certa “acurácia” para essas predições.
💡 Nesse tutorial vou usar como métrica o ROC AUC, uma métrica muito comum para modelos de classificação. Você pode saber mais sobre essa métrica no link: https://mariofilho.com/guia-completo-sobre-roc-auc-em-machine-learning/
from river import metrics
metric = metrics.ROCAUC(n_thresholds=20)
stream_dataset = stream.iter_pandas(features, target)
for X, y in stream_dataset:
y_pred = model.predict_proba_one(X)
model.learn_one(X, y)
metric.update(y, y_pred)
metric
O resultado do código acima deve retornar algo por volta de 81%, o que não é um valor a se jogar fora. Mas vamos experimentar uma outra abordagem, mais próxima do padrão de treinamento e de validação do River.
A biblioteca River permite criar um modelo como uma Pipeline, ou seja, um processo de passos para o treinamento. Isso é feito simplesmente adicionando “|” entre os processos desejados.
Além disso, como dito no artigo de introdução do River, o aprendizado e a inferência acontecem na mesma ordem que acontece no ambiente de produção e para isso a biblioteca usa a função progressive_val_score, que recebe o dataset em formato de stream, o modelo e a métrica usada.
from river import evaluate
from river import optim
from river import preprocessing
from river import compose
stream_dataset = stream.iter_pandas(features, target)
model = (
preprocessing.StandardScaler() |
linear_model.LogisticRegression(optimizer=optim.SGD(.1))
)
metric = metrics.ROCAUC(n_thresholds=20)
evaluate.progressive_val_score(stream_dataset, model, metric)
Para otimizar o modelo, antes de os dados alimentarem o modelo, eles são redimensionados com o StandardScaler(). O modelo recebe um otimizador do tipo SGD para descida de gradiente estocástica simples. Por fim avaliamos o modelo com progressive_val_score.
O resultado retornado pela função na última linha deve ser por volta de 82%. Uma melhora não tão considerável em comparação à nossa versão anterior, mas uma melhora é uma melhora.
Por fim, caso você queira identificar com mais facilidade os elementos do seu pipeline do modelo, basta digitar model
em uma célula do seu notebook e ver a imagem que define o pipeline. No nosso caso, por exemplo, temos:
Conclusão
Com esse artigo você é capaz de experimentar várias das formas de trabalhar com a biblioteca River para treinar e avaliar modelos de aprendizado de máquina online. Você limpou um conjunto de dados e aprendeu desde como lidar com dados em lote para que funcionem como dados em streaming até como construir e avaliar um modelo de aprendizado online.
Se esse conteúdo foi do seu interesse, não esqueça de avaliá-lo de alguma forma e de me seguir para acompanhar os próximos artigos.
Dúvidas, sugestões ou correções são muito bem-vindas na seção de comentários abaixo. Até a próxima.
Top comments (0)