O documento discute sistemas de recomendação utilizando machine learning e deep learning. Ele descreve o pré-processamento de dados, a aplicação de vários algoritmos de machine learning como kNN, XGBoost e random forest, e o desenvolvimento de um modelo de autoencoder para filtragem colaborativa usando deep learning. O documento conclui que o naive bayes teve o melhor desempenho entre os algoritmos de machine learning, mas que deep learning é uma boa solução para lidar com grandes volumes de dados.

1. Sistemas de Recomendação
Guttenberg Ferreira Passos
O presente artigo tem como objetivo o estudo de modelos de Inteligência Artificial
para sistemas de recomendação, case Santander do Kaggle, utilizando algoritmos de
Machine Learning e Deep Learning para fazer a recomendação de produtos com base
na história dos clientes do banco.
A solução foi projetada para ser implementada em duas etapas: Aprendizado de
Máquina e Aplicação, de acordo com o diagrama abaixo da Data Science Academy.
Fonte: Data Science Academy
Na etapa de Aplicação algumas ferramentas podem ser fundamentais, dada a
complexidade dos ambientes de produção on-premises ou na nuvem, como sugerido
por Felipe Santana nesta proposta de arquitetura:
Fonte: Stack Tecnologias

2. O foco desse artigo é a etapa de Aprendizado de Máquina, o desenvolvimento da
aplicação está fora do escopo e poderá ser objeto de um trabalho futuro.
O projeto de elaboração dos algoritmos da etapa de Aprendizado de Máquina foi
dividido em três fases:
1) Pré processamento dos dados.
2) Elaboração de modelo utilizando diversos algoritmos de Machine Learnig.
3) Elaboração de modelo de Deep Learning.
Os modelos foram adaptados dos trabalhos de Marlesson Santana, Rakan Frijat e Ian
Commerford, disponível em:
https://github.com/marlesson/recsys_autoencoders/blob/master/notebooks/DeepAut
oEncoder%20-%20Simple%20Train.ipynb
https://github.com/rakan41/santanderbankrecommender-
1) Pré processamento dos dados.
Na fase de pré processamento é feita a análise exploratória dos dados (EDA) podendo
contemplar os seguintes passos:
 Identificar variáveis/atributos e tipos de dados. Numéricas (discretas,
contínuas) ou categóricas (ordinais, nominais).
 Identificar as variáveis dependentes e independentes ou preditoras e variável
alvo.
 Análise de métricas básicas. Contagens, percentis, média, desvio padrão,
valores máximos e mínimos.
 Análise Univariada. Valores únicos, duplicados, valores faltantes, assimetria,
distribuição, filtragens e condições.
 Análise Univariada Gráfica. Distribuição (Histogramas), Identificação de
Outliers: Box-plot e outras técnicas.
 Análise Multivariada Gráfica. Dispersão (relação linear), gráficos de barras,
pilha…
 Transformação e limpeza de dados. Alteração de tipos de dados (realizar
cálculos, concatenações, remoção de caracteres especiais etc.
 Tratamento de Valores Faltantes (Missing Values) Preenchimento de valores
(média, mediana, conhecimento local), exclusão de registros.
 Análise/Tratamento de Outliers. Identificar ruídos, discrepâncias, anomalias,
erros.
 Análise de Correlação.

3.  Redução de dimensionalidade.
Utilizou-se a ferramenta Sweetviz para auxiliar na análise dos dados com os relatórios
gerados em HTML:
Outra opção é fazer uma análise individual de cada produto como target e as
correlações com as variáveis preditoras, como no exemplo abaixo considerando a
variável Cartão de crédito (ind_tjcr_fin_ult1):
No Pré processamento, de acordo com Rakan Frijat e Ian Commerford, foram
realizados os seguintes passos:
 Separação dos dados em partições menores para executar os algoritmos on
pemises, em função da limitação de hardware. Outra opção seria rodar os
modelos na nuvem.

4.  Ajuste das múltiplas compras com a criação de uma nova coluna com o número
de novos produtos, união de todas as colunas de produtos em uma única
coluna, aplicação de filtro para valores falsos, criação de uma chave temporária
e, em seguida, a volta para várias colunas, mesclar o pivô de volta em
df_changed e mesclar tudo de volta em um df.
 Descarte dos rótulos que raramente são usados.
 Codificação das variáveis categóricas.
 Eliminação dos outliers.
 Discretização das variáveis contínuas.
 Converção das variáveis categóricas.
 Seleção dos variáveis para treinar o modelo.
 Utilização apenas de clientes que compraram algo para treinamento.
 Remoção das colunas duplicadas.
 Configuração dos conjuntos de treinamento e avaliação
2) Elaboração de modelo utilizando diversos algoritmos de Machine Learnig.
Algoritmos de Machine Learning utilizados, de acordo com Rakan Frijat e Ian
Commerford:
 kNN
 XGBoost
 Logistic Regression
 Naive Bayes
 Decision Tree
 Random Forest
Fonte dos algoritmos de Machine Learning: Wikipédia
kNN
É um algoritmo de aprendizado de máquina, o algoritmo kNN procura k exemplos de
treinamento mais próximos no espaço de recursos e usa sua média como previsão.
XGBoost
XGBoost é uma biblioteca de software de código aberto que fornece um framework de
"gradient boosting".

5. Logistic Regression
O algoritmo de classificação de regressão logística com regularização LASSO (L1) ou
crista (L2). A regressão logística aprende um modelo de regressão logística a partir dos
dados. Funciona apenas para tarefas de classificação.
Naive Bayes
Um classificador probabilístico rápido e simples baseado no teorema de Bayes com a
suposição de independência de recurso. Funciona apenas para tarefas de classificação.
Decision Tree
Uma árvore de decisão é uma ferramenta de suporte à decisão que usa um modelo de
decisões em forma de árvore e suas possíveis consequências, incluindo resultados de
eventos casuais, custos de recursos e utilidade. É uma maneira de exibir um algoritmo
que contém apenas instruções de controle condicional. Árvores de decisão são
comumente usadas em pesquisa operacional, especificamente em análise de decisão,
para ajudar a identificar uma estratégia com maior probabilidade de atingir um
objetivo, mas também são uma ferramenta popular em aprendizado de máquina.
Random Forest
A Random Forest constrói um conjunto de árvores de decisão. Cada árvore é
desenvolvida a partir de uma amostra de bootstrap dos dados de treinamento. Ao
desenvolver árvores individuais, um subconjunto arbitrário de atributos é desenhado
(daí o termo “Aleatório”), a partir do qual o melhor atributo para a divisão é
selecionado. O modelo final é baseado na maioria dos votos de árvores desenvolvidas
individualmente na floresta.
Elaboração do mapa das métricas com a acurácia de cada algoritmo:
 kNN: Não terminou a execução
 XGBoost 0.0235
 Logistic Regression: 0.0232
 Naive Bayes: 0.0218
 Decision Tree: 0.0219
 Random Forest: 0.0229
Foram gerados arquivos com o código do cliente e os sete melhores produtos
recomendados, para cada algoritmo.

6. 3) Elaboração de modelo de Deep Learning.
Utilizou-se a modelagem do Autoencoder para Filtragem Colaborativa, no modelo de
Deep Learning, baseado na arquitetura da solução Deep RecSys com Autoencoders
(AE), de Marlesson Santana.
O princípio da Filtragem Colaborativa é utilizar a informação das interações que
ocorrem entre os usuários e os conteúdos para que, de forma coletiva, essa
informação seja útil para inferir as preferências dos indivíduos. Dessa forma é possível
gerar recomendações como: “usuários que gostaram do Jogo B também gostaram de
Jogo D”.
Matriz de Interação, cada registro é o valor associado a interação do usuário com o
conteúdo.
Algoritmo de Deep Learning:
# Input
input_layer = Input(shape=(X.shape[1],), name='UserScore')
# Encoder
enc = Dense(512, activation='selu', name='EncLayer1')(input_layer)
# Latent Space
lat_space = Dense(256, activation='selu', name='LatentSpace')(enc)
lat_space = Dropout(0.8, name='Dropout')(lat_space) # Dropout
# Decoder
dec = Dense(512, activation='selu', name='DecLayer1')(lat_space)
# Output
output_layer = Dense(X.shape[1], activation='linear', name='UserScorePred')(dec)
# this model maps an input to its reconstruction
model = Model(input_layer, output_layer)
model = autoEncoder(X)
model.compile(optimizer = Adam(lr=0.0001), loss='mse')
model.summary()

7. Model: "model"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
UserScore (InputLayer) [(None, 24)] 0
_________________________________________________________________
EncLayer1 (Dense) (None, 512) 12800
_________________________________________________________________
LatentSpace (Dense) (None, 256) 131328
_________________________________________________________________
Dropout (Dropout) (None, 256) 0
_________________________________________________________________
DecLayer1 (Dense) (None, 512) 131584
_________________________________________________________________
UserScorePred (Dense) (None, 24) 12312
=================================================================
Total params: 288,024
Trainable params: 288,024
Non-trainable params: 0
Treinamento:
hist = model.fit(x=X, y=y, epochs=10, batch_size=64, shuffle=True, validation_split=0.1)
Epoch 1/10
87843/87843 [==============================] - 468s 5ms/step - loss: 0.0050 - val_loss: 2.5569e-04
Epoch 2/10
87843/87843 [==============================] - 463s 5ms/step - loss: 0.0016 - val_loss: 2.1522e-04
Epoch 3/10
87843/87843 [==============================] - 466s 5ms/step - loss: 0.0014 - val_loss: 1.7110e-04
Epoch 4/10
87843/87843 [==============================] - 466s 5ms/step - loss: 0.0012 - val_loss: 1.3251e-04
Epoch 5/10
87843/87843 [==============================] - 467s 5ms/step - loss: 0.0010 - val_loss: 1.1520e-04
Epoch 6/10
87843/87843 [==============================] - 468s 5ms/step - loss: 9.3472e-04 - val_loss: 8.4248e-05
Epoch 7/10
87843/87843 [==============================] - 468s 5ms/step - loss: 8.7468e-04 - val_loss: 7.6334e-05
Epoch 8/10
87843/87843 [==============================] - 470s 5ms/step - loss: 8.3305e-04 - val_loss: 6.8077e-05
Epoch 9/10
87843/87843 [==============================] - 466s 5ms/step - loss: 8.0756e-04 - val_loss: 7.1352e-05
Epoch 10/10
87843/87843 [==============================] - 466s 5ms/step - loss: 7.8332e-04 - val_loss: 6.1677e-05
A quantidade de épocas, tamanho do batch, entre outros parâmetros vai depender do
problema também. O ideal é treinar até que a curva de loss se estabilize e o erro pare
de reduzir:
Recomendação
Produtos adquiridos anteriormente pelo cliente
recommender_for_user(
user_id = 918221,
interact_matrix = users_items_matrix_df,

8. df_content = articles_df)
Produtos recomendados para o cliente
recommender_for_user(
user_id = 918221,
interact_matrix = new_users_items_matrix_df,
df_content = articles_df)
Conclusão
Neste trabalho, sem pretensão alguma de esgotar o assunto, demonstrou-se que
dentre os algoritmos de Machine Learning o Naive Bayes obteve melhor desempenho
com acurácia de 0.0218. Entretanto, devido ao grande volume de dados a solução
exige uma infraestrutura on-premises robusta para suportar o processamento.
A solução de Deep Learning com modelagem do Autoencoder para Filtragem
Colaborativa apresenta também uma ótima solução para o problema, pois utiliza
processamento paralelo em GPU, aliviando a carga sobre a memória RAM e
permitindo a execução de modelos mais complexos com grande volume de dados.
No entanto há sempre a limitação do hardware na infraestrutura on-premises, o
cenário ideal é a utilização de uma arquitetura desenhada para suportar a migração
para provedores em nuvem.