Deep Learning para Sistemas de Recomendação (Parte 3) — Recomendação por Similaridade
Como utilizar Embeddings para recomendar conteúdos relevantes
Outros artigos da série de Deep Learning para Sistemas de Recomendação:
Neste artigo iremos abordar o problema da Filtragem Baseada em Conteúdo e como modelar uma solução utilizando Embeddings gerados por Deep Learning.
Os principais tópicos desse artigo são:
- Introdução a Filtragem Baseada em Conteúdo
- O que são Embeddings?
- Como utilizar Embeddings para Recomendação?
- Conclusão
1. Introdução a Filtragem Baseada em Conteúdo (Content-Based)
Já apresentamos as principais características da Filtragem Baseada em Conteúdo na 1º Parte dessa série. Iremos apenas complementar essa alguns pontos aqui.
O princípio básico da filtragem baseada em conteúdo está na ideia de que
se você gosta de algo, você também vai gostar de algo similar que ainda não conhece…
Faz bastante sentido pensar dessa forma, afinal, muita das nossas decisões de consumo são baseadas nessa ideia. Estamos propensos a consumir algo que já validamos, como filmes e músicas do mesmo gênero que já gostamos, um curso ou um vídeo no YouTube sobre o mesmo assunto que acabamos de assistir, livros do mesmo autor ou assunto que gostamos de estudar… e por aí vai.
Dessa forma, um processo para criar recomendações baseadas em conteúdo segue os seguintes passos:
- Conhecer os conteúdos que já foram consumidos pelo usuário.
- Definir a similaridade entre diferentes conteúdos.
- Buscar os conteúdos que o usuário ainda não consumiu
- Ordenar esses conteúdos pela métrica de similaridade.
- Recomendar os mais similares.
Seguindo os passos acima teremos recomendações personalizadas pelo próprio comportamento de consumo do usuário dentro do sistema. É fácil organizar um sistema para seguir esses passos, a parte problemática do Content-Based se resume a como definir a similaridade para o tipo de conteúdo a ser recomendado, o resto é busca e ordenação. Na verdade, a pergunta está mais para:
como fazer a máquina entender o que é um conteúdo similar?
1.1. Similaridade
Como iremos utilizar a similaridade para ordenar os conteúdos e depois recomendar, o conceito de similaridade precisa ser algo mensurável e quantitativo.
Você consegue dizer o quanto essas imagens são similares entre si?
Imagino que você não saiba o quanto, mas consegue identificar o par de imagens mais similares do conjunto. Qual atributo usou para chegar nessa conclusão?
Se mudarmos o conteúdo para livros, qual dos livros tem o conceito mais distante dos demais?
Qual atributo usou para chegar nessa conclusão? Consegue dizer o quanto ele é diferente?
Poderíamos fazer isso com qualquer mídia recomendável, como música, vídeo, notícias, comida.. etc. E para cada uma dessas mídias você utilizaria um conjunto de atributos diferentes para definir e comparar com os demais exemplos para chegar em uma percepção de similaridade.
Esse nosso exercício mental teve o objetivo de chegar na conclusão que,
precisamos definir pelo menos duas coisas quando falamos de similaridade, os atributos e a métrica.
Atributos
Os atributos são as informações que caracterizam o conteúdo (cores, palavras, notas musicais, autor, gênero, etc.). Geralmente é diferente para cada mídia ou contexto de recomendação e a escolha dos atributos tem grande efeito na percepção de similaridade. A questão é que dependendo do atributo que escolhermos, o item A pode ser similar ao item B ou similar ao item C.
Na prática, a tarefa de escolher os atributos certos para caracterizar o conteúdo não é nada trivial. A escolha errada pode levar o sistema a recomendar conteúdo não relevante para o usuário. Veja no exemplo abaixo a quantidade de informações e diferentes tipos de dados que podem ser utilizados para modelar uma recomendação de restaurante, qual utilizar?
Antes de escolher a métrica é importante garantir que todas as features escolhidas estejam definidas numericamente em um vetor de features.
Esse processo acontece na etapa de Engenharia de Features e tem como objetivo transformar diferentes tipos de dados em valores contínuos para criar o vetor de features do objeto.
Essa etapa é importante pois as métricas e técnicas de machine learning necessitam que o vetor de features seja numérico.
Métricas
Partindo do princípio que cada conteúdo pode ser representado por seus atributos em um vetor de features, podemos usar algumas métricas para calcular distância entre diferentes conteúdos.
Para exemplificar como as métricas funcionam iremos utilizar três itens. Cada item contém apenas duas features para visualizar o espaço-vetorial em 2D.
Item A = [5, 2]
Item B = [2, 4]
Item C = [4, 1]A distância euclidiana é a mais simples de entender, pois é a que utilizamos com mais frequência para mensurar a distância entre dois objetos. Basicamente é o tamanho da linha reta que liga os dois pontos no espaço vetorial.
A matriz de distância é a métrica calculada entre todos os itens, é uma matriz quadrada em que a diagonal é constante. Podemos utiliza-la para ter a informação da distância de todos os pontos presentes no espaço-vetorial e assim recomendar o que tiver menor distância.
A Similaridade do Cosseno é a métrica que calcula o angulo gerado entre dois vetores com relação a origem.
Diferente da distância euclidiana que não tem limite superior, vai de 0 a inf, a similaridade do cosseno é uma métrica normalizada e varia entre 0 e 1, onde 0 é quando os itens são opostos e 1 quando os itens são iguais.
Existem diversas métricas de similaridade ou distância bem definidas na algebra e todas podem ser utilizadas no contexto de RecSys, escolher a ideal depende muito do problema e das features em questão e na prática é normal testar mais de uma. Veja os links em anexo para mais informações e explicações de outras métricas.
2. O que são Embeddings?
A introdução sobre similaridade teve o objetivo de reforçar o quanto é difícil definir se dois itens são semelhantes, dependendo do tipo do dado a escolha dos atributos para caracteriza-lo pode ser complexa e levar a semelhanças falsas.
É aqui que os embeddings entram para simplificar e otimizar esse processo. A definição que uso é a que o
embedding é uma representação de features em um espaço dimensional reduzido, com tamanho fixo, denso e que contém propriedades semânticas sobre o objeto.
Em outras palavras, o embedding é um vetor de feature do objeto. A grande diferença desse vetor de features é que eles são criamos por redes neurais em vez de definidos pelo usuário. Dessa forma,
- os embeddings carregam muito mais informação útil em menos espaço (dimensionalidade reduzida) pois são lapidados na sua criação;
- o vetor pode conter qualquer tamanho independente da quantidade de features raw utilizadas, o que facilita as operações como manipulação, comparação, concatenação, etc. entre diferentes tipos de dados. Na prática tudo vira um embedding para a rede;
- são vetores densos, ou seja, são vetores com valores reais que representação a posição em um espaço vetorial N-dimensional, o que garante que ainda exista o conceito de similaridade e distância entre eles;
- e contém propriedades semânticas, dependendo de como foi treinado é possível obter similaridade de conceitos ou semântica do objeto além das features utilizadas, ressaltando propriedades intrínsecas do objeto.
Qualquer tipo de dado (texto, imagem, áudio, ID, categórico, etc..) pode ser gerado um embedding que o represente nesse novo espaço vetorial. Essa característica é importante para um RecSys pois independente do tipo do conteúdo a ser recomendado o algoritmo não muda, ao utilizar embeddings podemos pular a parte de escolha de atributos e engenharia de features e focar apenas na similaridade e como recomendar conteúdo relevante.
Vamos a alguns exemplos de embeddings…
Word Embeddings
Os embeddings mais conhecidos são as Word Embeddings, que são uma forma de codificar texto em um vetor de features. Em problemas de NLP a utilização de Word Embs é fundamental para modelar a linguagem de forma o mais natural possível, com semântica e contexto embutidos na palavra.
A maior característica das Word Embeddings é que elas conseguem modelar a similaridade de palavras de forma semântica, onde a distância entre os vetores fazem sentido em um determinado contexto, por exemplo, a distância entre o vetor que representa a palavra “king” e a “queen” é a mesma entre as palavras “man” e “woman”.
Existem diferentes processos de criação de Word Embs como Word2Vec, GloVe, FastText, Wang2Vec, Doc2Vec, etc. A utilização desses modelos de linguagem se dão de forma semelhante, todas elas transformam texto em um vetor de características de N-dimensões.
Utilizando a biblioteca Gensim do Python é possível treinar uma Word2Vec e manipular as embeddings. Por exemplo, as palavras mais próximas da palavra “esporte” no espaço N-dimensional são “futebol”, “natação”, “judô”…
In [1]: model.wv["esporte"]
Out [1]: [ 4.566 1.582 0. ... 2.626 0. 9.533 ]In [2]: model.wv.most_similar("esporte")
Out [2]:[('futebol', 0.6404122114181519),
('natação', 0.6078230142593384),
('judô', 0.6062663793563843),
('esportes', 0.6025530099868774),
('atleta', 0.5962207317352295),
('boxe', 0.5770080089569092),]
E as palavras mais próximas da palavra “propina” são “propinas”, “suborno” e “empreiteira”…
In [3]: model.wv.most_similar("propina")
Out [3]: [('propinas', 0.7854447364807129),
('suborno', 0.7552727460861206),
('empreiteira', 0.7447404861450195),
('petrobras', 0.7168297171592712),
('oas', 0.701270341873169),
('odebrecht', 0.6847391128540039),]
É importante perceber que a similaridade das Word Embs é muito mais do que sinônimos, elas carregam semântica sobre um tema a nível que só um humano conseguiria colocar, pois, a depender de como foi criada tem muito de contexto embutido também.
Se ficou curioso sobre as palavras similares a “propina”, pense sobre o dataset que foi utilizado. Os exemplos apresentados podem ser encontrados no notebook abaixo.
O melhor site para encontrar Word Embeddings já treinadas em pt-br é o do NILC.
Imagem
Embeddings de Imagens funcionam da mesma forma e têm as mesmas propriedades das Word Embs.
Uma das formas de criação das Image Embs é utilizando Redes Convolucionais (ConvNets). Se você não sabe nada sobre ConvNets dá uma olhada no tutorial do Alan Melo Clappis e na série mais aprofundada escrita pelo Arthur Lamblet Vaz. Nosso objetivo nesse artigo é a aplicação em RecSys e não vamos nos aprofundar na temática.
Mas explicando o básico de ConvNets, uma Rede Convolucional pode ser dividida em duas etapas, a de extração de características e a de classificação. A etapa de extração de característica utiliza de filtros convolucionais para extrair os principais padrões da imagem que podem ser utilizadas para caracteriza-la, a rede aprende a fazer isso devido o processo de treinamento. Ao final dessa etapa o que sobra é um vetor de features, de tamanho fixo e reduzido, denso e com propriedades semânticas do objeto. Afinal, é isso que a parte de classificação vai utilizar para identificar o objeto.
Então, na prática qualquer ConvNet treinada pode ser um gerador de embedding, desde que a etapa de classificação seja retirada da rede. A qualidade do embedding gerado vai depender do domínio em que a rede foi treinada e o domínio que utilizaremos os embeddings. Se a rede foi treinada para classificar gatos e cachorros os embeddings gerados são de features que discriminam esses animais, utiliza-la para gerar embeddings de carros não é algo inteligente.
Utilizando o keras é possível carregar uma ConvNet pré treinada, retirar o topo da rede (o classificador) e utiliza-la como gerador de embeddings de imagens. No exemplo abaixo utilizamos a ResNet50, mas poderia ser qualquer arquitetura de ConvNet.
from tensorflow.keras.applications.resnet50 import ResNet50# Pre-Trained Model
base_model = ResNet50(weights='imagenet',
include_top=False,
input_shape = (img_width, img_height, 3))
base_model.trainable = False
# Flatten Embedding Layer
model = tf.keras.Sequential([
base_model,
GlobalMaxPooling2D()
])
Nesse exemplo, os pesos utilizados foram da ‘imagenet’, a rede foi treinada para classificar centenas de objetos diferentes no dataset da imagenet então deve ser um baseline útil para qualquer contexto. Se o nosso problema de RecSys tiver imagens bem específicas, é possível treinar qualquer ConvNet e fazer o mesmo processo de retirar o classificador da rede depois.
Uma função para extrar o embedding usando a ConvNet segue os mesmos passos que seria para classificar a imagem, como o classificador foi retirado da rede a saida passa a ser o embedding em vez da classe.
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.resnet50 import preprocess_inputdef get_embedding(model, img_name):
img = image.load_img(img_path(img_name),
target_size=(img_width, img_height)) # Resize
x = image.img_to_array(img) # Img to Array
x = np.expand_dims(x, axis=0) # Expand Dim (1, w, h)
x = preprocess_input(x) # Pre process Input
return model.predict(x).reshape(-1) # Predict return model.predict(x).reshape(-1)
O tamanho do embedding depende da arquitetura utilizada como ConvNet, no exemplo apresentando a ResNet50 gera um embedding de 2048D. Esse tamanho pode ser modificado ao retreinar a rede por exemplo.
In [5]: emb = get_embedding(model, df.iloc[0].image)In [6]: emb.shape
Out [7]: (2048,)In [6]: emb
Out [7]: [ 5.306 2.1582 0. ... 1.8626 0. 10.533 ]
Ao gerar os embeddings de imagens usando uma ConvNet estamos criando uma forma de comparar as imagens independendo do tamanho e conteúdo delas, deixamos a Rede Neural extrair as características intrínsecas da imagem e utilizamos as métricas de similaridade para quantificar a semelhança. Desse modo é possível recomendar itens semelhantes sem ter que definir em momento algum quais atributos iremos utilizar.
Veja as imagens dos embeddings mais similares ao exemplo anterior,
todos os itens poderiam ser recomendados ao usuário que comprou a primeira camisa devido a similaridade com a mesma.
Embedding com AutoEncoder
Arquiteturas de AutoEncoders são ótimas para gerar embeddings. Se você ainda não percebeu, no segundo artigo (Deep Learning para Sistemas de Recomendação (Parte 2) — Filtragem Colaborativa com AutoEncoder) treinamos um AutoEncoder onde a entrada eram os jogos comprados pelo usuário. Se utilizarmos apenas o Encoder da rede podemos criar embeddings de usuários, pois ele comprime as features em um espaço-latente de tamanho fixo, denso e com informações semânticas.
Em outras palavras, podemos utilizar os embeddings em um RecSys para identificar os usuários próximos e trocar recomendações relevantes entre eles.
A visualização do espaço-latente mostra que os usuários com preferências semelhantes ficam próximos.
A modelagem de embeddings é extremamente útil para extrair similaridade entre conceitos e conteúdos sem a necessidade de escolher os atributos manualmente, podemos deixar para uma Rede Neural mapear as principais características do objeto em um embedding.
3. Como utilizar Embeddings para Recomendação?
Se você chegou até aqui provavelmente já sabe essa resposta. As recomendações de Content-Based são baseadas no conteúdo e na similaridade entre elas, os embeddings são a melhor forma de representar as características de qualquer tipo de dado, após gerado, o problema de recomendação se torna um problema de busca.
Vamos supor que trabalhamos em um Marketplace e precisamos desenvolver um algoritmo de RecSys para recomendar itens semelhantes quando o usuário acessa a página de um produto. O dataset que temos acesso é algo semelhante ao do Fashion Product, contém diferentes itens em diversas categorias com informações de metadados e a imagem do item.
Podemos usar a mesma ConvNet do exemplo anterior para gerar os embeddings de todas as imagens do dataset e depois calcular a similaridade entre os itens. Em um sistema em produção a extração do embedding é realizada no momento do cadastro do item e armazenada para consultas futuras.
# Parallel apply
map_embeddings = df['image'].apply(lambda img: get_embedding(model, img))# Explode Features
df_embs = map_embeddings.apply(pd.Series)
df_embs.head()
Agora que todos os embeddings foram gerados é possível calcular a distância de todos X todos. Desse forma a recomendação baseada em um item se torna um problema de ordenação de índices. A matriz de similaridade pode ser calculada uma única vez para ordenar os itens mais similares e utilizada sempre que houver recomendação.
A biblioteca “pairwise_distances” do sklearn conta com diversas métricas de similaridade/distância que podem ser utilizadas. O retorno é uma matriz quadrada com a similaridade de todos X todos.
from sklearn.metrics.pairwise import pairwise_distances
# Calcule Distance Matriz
In [3]: cosine_sim = 1 - pairwise_distances(df_embs,
metric='cosine')
In [3]: cosine_sim[:4, :4]Out [3]:
array([[1. , 0.7134498 , 0.45427227, 0.6797061 ],
[0.7134498 , 0.9999999 , 0.41515315, 0.833309 ],
[0.45427227, 0.41515315, 0.9999989 , 0.44629472],
[0.6797061 , 0.833309 , 0.44629472, 0.9999994 ]], dtype=float32)
Depois do cálculo da matriz de similaridade a função de recomendação é apenas uma ordenação dos itens mais semelhantes, a função “get_recommender” recebe um ID do item e retorna quais seriam os itens com maior similaridade e o quanto é similar.
# Indices dos conteúdos originais
indices = pd.Series(range(len(df)), index=df.index)
indices
# Function that get recommendations based on the cosine similarity score
def get_recommender(idx, df, top_n = 5):
sim_idx = indices[idx]
sim_scores = list(enumerate(cosine_sim[sim_idx]))
sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
sim_scores = sim_scores[1:top_n+1]
idx_rec = [i[0] for i in sim_scores]
idx_sim = [i[1] for i in sim_scores]
return indices.iloc[idx_rec].index, idx_simRecomendação 1
In [3]: get_recommender(2993, df, top_n = 6)Out [3]:([251, 659, 2400, 0, 1821],
[0.923, 0.922, 0.919, 0.915, 0.913])
Ao consultar os itens similares ao ID:2993 é possível observar que além de recomendar apenas tênis (o dataset é variada), os modelos são similares em cor ou formato.
Recomendação 2
In [3]: get_recommender(2993, df, top_n = 6)Out [3]:([1365, 2007, 4185, 4712, 1723, 4961],
[0.923, 0.922, 0.919, 0.915, 0.913, 0.90])
Ao usar o embedding de outro item podemos verificar que os itens recomendados também são semelhantes.
Todos os exemplos apresentados estão descritos no Kernel abaixo para reprodução do processo de recomendação com embeddings.
4. Conclusão
Nesse artigo abordamos o funcionamento de algoritmos de RecSys baseados em conteúdo e como podemos utilizar os embeddings para simplificar a construção do vetor de features.
Embora existam diferentes formas de criar embeddings, a utilização independe do tipo do dado a ser recomendado e as características semânticas dos embeddings adicionam mais informações ao problema de RecSys.
Por fim, fica claro que a utilização de embeddings no contexto de recomendação é extremamente benéfico, seja usando imagens, texto, categorias ou todos os embeddings juntos para caracterizar o conteúdo recomendável.
O código apresentado no artigo pode ser replicado no Jupyter Notebook .
Referências
Outras referências interessantes
