Beginner Tutorial: Sistemas recomendados em Python

Source

O propósito deste tutorial não é fazer de você um especialista em construir modelos de sistemas recomendados. Ao invés disso, o motivo é começar dando-lhe uma visão geral do tipo de sistemas de recomendação que existem e como você pode construir um por yo

>

Neste tutorial, você aprenderá como construir um modelo básico de sistemas de recomendação simples e baseados em conteúdo. Enquanto esses modelos não estarão em nenhum lugar próximo ao padrão da indústria em termos de complexidade, qualidade ou precisão, isso o ajudará a começar a construir modelos mais complexos que produzem resultados ainda melhores.

Os sistemasRecommender estão entre as aplicações mais populares da ciência dos dados atualmente. Eles são usados para prever a “classificação” ou “preferência” que um usuário daria a um item. Quase todas as grandes empresas de tecnologia já os aplicaram de alguma forma. A Amazon usa-o para sugerir produtos aos clientes, o YouTube usa-o para decidir que vídeo reproduzir a seguir no autoplay, e o Facebook usa-o para recomendar páginas para gostar e pessoas para seguir.

Além disso, para algumas empresas como Netflix, Amazon Prime, Hulu e Hotstar, o modelo de negócio e seu sucesso gira em torno da potência de suas recomendações. A Netflix até ofereceu um milhão de dólares em 2009 a qualquer pessoa que pudesse melhorar seu sistema em 10%.

Existem também sistemas populares de recomendação para domínios como restaurantes, filmes e encontros on-line. Os sistemas de recomendação também foram desenvolvidos para explorar artigos de pesquisa e especialistas, colaboradores e serviços financeiros. O YouTube utiliza o sistema de recomendação em larga escala para sugerir vídeos com base em sua história. Por exemplo, se você assistir a muitos vídeos educativos, ele sugere esses tipos de vídeos.

Mas quais são esses sistemas de recomendação?

Broadly, os sistemas de recomendação podem ser classificados em 3 tipos:

  • Recomendadores simples: oferecem recomendações generalizadas a cada usuário, com base na popularidade e/ou gênero do filme. A idéia básica por trás deste sistema é que filmes mais populares e aclamados pela crítica terão uma probabilidade maior de serem apreciados pelo público médio. Um exemplo poderia ser IMDB Top 250.
  • Recomendadores baseados em conteúdo: sugerir itens similares com base em um item em particular. Este sistema usa metadados de itens, tais como gênero, diretor, descrição, atores, etc. para filmes, para fazer estas recomendações. A idéia geral por trás desses sistemas de recomendação é que se uma pessoa gosta de um item em particular, ela também vai gostar de um item que seja similar a ele. E para recomendar isso, ele fará uso dos metadados de itens passados do usuário. Um bom exemplo poderia ser o YouTube, onde baseado em seu histórico, ele sugere novos vídeos que você poderia potencialmente assistir.

  • Motores de filtragem colaborativos: esses sistemas são amplamente utilizados, e eles tentam prever a classificação ou preferência que um usuário daria a um item baseado nas classificações e preferências passadas de outros usuários. Filtros colaborativos não requerem metadados de itens como seus contrapartes baseados em conteúdo.

Simples Recommenders

Como descrito na seção anterior, recomendáveis simples são sistemas básicos que recomendam os itens principais com base em uma determinada métrica ou pontuação. Nesta seção, você irá construir um clone simplificado do IMDB Top 250 Filmes usando metadados coletados do IMDB.

>

Os passos envolvidos são os seguintes:

  • Decida sobre a métrica ou pontuação para classificar os filmes.

  • Calcule a pontuação de cada filme.

  • Selecione os filmes com base na pontuação e produza os melhores resultados.

Sobre o conjunto de dados

Os arquivos do conjunto de dados contêm metadados para todos os 45.000 filmes listados em Full MovieLens Dataset. O conjunto de dados é composto por filmes lançados em ou antes de julho de 2017. Este conjunto de dados captura pontos como elenco, equipe, palavras-chave, orçamento, receita, cartazes, datas de lançamento, idiomas, empresas produtoras, países, contagem de votos da TMDB e médias de votos.

Estes pontos de características podem ser potencialmente usados para treinar os modelos de aprendizagem da sua máquina para conteúdo e filtragem colaborativa.

Este conjunto de dados consiste nos seguintes ficheiros:

  • movies_metadata.csv: Este ficheiro contém informação sobre ~45,000 filmes apresentados no conjunto de dados Full MovieLens. Os recursos incluem cartazes, cenários, orçamento, gênero, receita, datas de lançamento, idiomas, países de produção e empresas.
  • keywords.csv: Contém as palavras-chave do enredo do filme para os nossos filmes MovieLens. Disponível na forma de um objeto JSON de string.
  • créditos.csv: Consiste de Cast and Crew Information para todos os filmes. Disponível na forma de um objeto JSON em string.
  • links.csv: Este arquivo contém as IDs TMDB e IMDB de todos os filmes apresentados no conjunto de dados Full MovieLens.
  • links_small.csv: Contém as IDs TMDB e IMDB de um pequeno subconjunto de 9.000 filmes do conjunto de dados Full MovieLens.
  • >

  • classificações_small.csv: O subconjunto de 100.000 classificações de 700 usuários em 9.000 filmes.

O conjunto de dados Full MovieLens compreende 26 milhões de classificações e 750.000 aplicações de tags, de 270.000 usuários em todos os 45.000 filmes deste conjunto de dados. Ele pode ser acessado do site oficial do GroupLens.

Nota: O conjunto de dados do subconjunto usado no tutorial de hoje pode ser baixado daqui.

Para carregar o seu conjunto de dados, você estaria usando a biblioteca de Quadro de Dados pandas. pandas biblioteca é usada principalmente para manipulação e análise de dados. Ela representa seus dados em um formato linha-coluna. A biblioteca Pandas é apoiada pela matriz NumPy para a implementação de objetos de dados pandas. pandas oferece estruturas e operações de dados fora da prateleira para manipulação de tabelas numéricas, séries de tempo, imagens e conjuntos de dados de processamento de linguagem natural. Basicamente, pandas é útil para aqueles conjuntos de dados que podem ser facilmente representados de uma forma tabular.

Antes de executar qualquer um dos passos acima, vamos carregar o conjunto de dados de metadados do seu filme em um pandas DataFrame:

# Import Pandasimport pandas as pd# Load Movies Metadatametadata = pd.read_csv('movies_metadata.csv', low_memory=False)# Print the first three rowsmetadata.head(3)

>

>

>

>

>

>

adult belongs_to_collection budget genres homepage id imdb_id língua_original título_original visão geral release_date revenue runtime falar_línguas status tagline título vídeo vote_average vote_count
0 False {‘id’: 10194, ‘name’: ‘Toy Story Collection’, … 30000000 Largado NaN Toy Story False 7.7 5415.0
1 Falso NaN 65000000 Largado Gritar. Ainda a lutar. Ainda Pronto para… Velhinhos mais velhos Falso 6,5 92,0

3 linhas × 24 colunas

Uma das métricas mais básicas que você pode pensar é a classificação para decidir quais os 250 filmes que estão entre os melhores com base em suas respectivas classificações.

No entanto, usar uma classificação como métrica tem algumas advertências:

  • Para um, ela não leva em consideração a popularidade de um filme. Portanto, um filme com uma classificação de 9 de 10 eleitores será considerado ‘melhor’ que um filme com uma classificação de 8,9 de 10.000 eleitores.

    Por exemplo, imagine que você quer pedir comida chinesa, você tem um par de opções, um restaurante tem uma classificação de 5 estrelas por apenas 5 pessoas enquanto o outro restaurante tem uma classificação de 4,5 por 1000 pessoas. Qual restaurante você prefere? O segundo, à direita?

    Obviamente, poderia haver uma excepção que o primeiro restaurante abriu há apenas alguns dias; por isso, menos pessoas votaram nele enquanto, pelo contrário, o segundo restaurante está operacional durante um ano.

  • Em nota relacionada, esta métrica também tenderá a favorecer filmes com um número menor de eleitores com classificações enviesadas e/ou extremamente altas. À medida que o número de eleitores aumenta, a classificação de um filme regulariza e aproxima-se de um valor que reflete a qualidade do filme e dá ao usuário uma idéia muito melhor sobre qual filme ele deve escolher. Embora seja difícil discernir a qualidade de um filme com muito poucos eleitores, talvez você tenha que considerar fontes externas para concluir.

Levando em consideração essas deficiências, você deve chegar a uma classificação ponderada que leve em conta a classificação média e o número de votos que acumulou. Tal sistema irá garantir que um filme com 9 votos de 100.000 eleitores obtenha uma pontuação (muito) superior à de um filme com a mesma pontuação, mas com apenas algumas centenas de eleitores.

Desde que esteja a tentar construir um clone do Top 250 do IMDB, vamos usar a sua fórmula de pontuação ponderada como uma métrica/ pontuação. Matematicamente, ela é representada da seguinte forma:

>aquação de texto Weighted Rating (WR) = {\i1}esquerda(bff v}}sobre {\i} + {\i1}bf v} + {\i1}cdot Rright) + {\i1}esquerda(bf m) = {\i1}esquerda(bf v} + {\i1}cdot Cright){\i}

Na equação acima,

  • v é o número de votos para o filme;

  • m é o número mínimo de votos necessários para ser listado no gráfico;

  • R é a média de votos do filme;

  • C é a média de votos em todo o relatório.

Você já tem os valores para v (vote_count) e R (vote_average) para cada filme do conjunto de dados. Também é possível calcular diretamente C a partir destes dados.

Determinar um valor apropriado para m é um hiperparâmetro que você pode escolher de acordo, uma vez que não há um valor correto para m. Você pode considerá-lo como um filtro preliminar negativo que irá simplesmente remover os filmes que têm um número de votos inferior a um determinado limite m. A seletividade do seu filtro fica a seu critério.

Neste tutorial, você usará o corte m como o percentil 90. Em outras palavras, para que um filme seja apresentado nas tabelas, ele deve ter mais votos do que pelo menos 90% dos filmes da lista. (Por outro lado, se você tivesse escolhido o percentil 75, você teria considerado os 25% mais votados dos filmes em termos do número de votos obtidos. Conforme o percentil diminui, o número de filmes considerados aumentará).

Como primeiro passo, vamos calcular o valor de C, a classificação média de todos os filmes usando os pandas .mean() função:

# Calculate mean of vote average columnC = metadata.mean()print(C)
5.618207215133889

A partir da saída acima, você pode observar que a classificação média de um filme no IMDB é de cerca de 5.6 em uma escala de 10.

Próximo, vamos calcular o número de votos, m, recebidos por um filme no percentil 90. A biblioteca pandas torna esta tarefa extremamente trivial usando o método .quantile() de pandas:

160.0

Desde que agora você tem o m você pode simplesmente usar uma condição maior que igual para filtrar filmes com contagens maiores que 160 votos:

Você pode usar o método .copy() para garantir que o novo q_movies DataFrame criado é independente dos seus metadados originais DataFrame. Em outras palavras, qualquer alteração feita no q_movies DataFrame não afetará o quadro de dados dos metadados originais.

# Filter out all qualified movies into a new DataFrameq_movies = metadata.copy().loc >= m]q_movies.shape
(4555, 24)
metadata.shape
(45466, 24)

Da saída acima, fica claro que existem cerca de 10% de filmes com contagem de votos superior a 160 e se qualificam para estar nesta lista.

Próximo e o passo mais importante é calcular a classificação ponderada para cada filme qualificado. Para fazer isso, você vai:

  • Definir uma função, weighted_rating();
  • Desde que já tenha calculado m e C irá simplesmente passá-los como argumento para a função;
  • Então irá seleccionar a coluna vote_count(v) e vote_average(R) a partir do quadro de dados q_movies;
  • Finalmente, irá calcular a média ponderada e devolver o resultado.

Você irá definir um novo recurso score, do qual você irá calcular o valor aplicando esta função ao seu DataFrame de filmes qualificados:

# Function that computes the weighted rating of each moviedef weighted_rating(x, m=m, C=C): v = x R = x # Calculation based on the IMDB formula return (v/(v+m) * R) + (m/(m+v) * C)
# Define a new feature 'score' and calculate its value with `weighted_rating()`q_movies = q_movies.apply(weighted_rating, axis=1)

Finalmente, vamos ordenar o DataFrame em ordem decrescente com base na coluna de recursos score e emitir o título, contagem de votos, média de votos e classificação ponderada (pontuação) dos 20 melhores filmes.

#Sort movies based on score calculated aboveq_movies = q_movies.sort_values('score', ascending=False)#Print the top 15 moviesq_movies].head(20)
title vote_count vote_average score
314 A Redenção Shawshank 8358.0 8.5 8.445869
834 O Padrinho 6024,0 8,5 8.425439
10309 Dilwale Dulhania Le Jayenge 661.0 9.1 8.421453
12481 O Cavaleiro das Trevas 12269.0 8.3 8.265477
2843 Clube de Luta 9678.0 8.3 8.256385
292 Pulp Fiction 8670.0 8,3 8,251406
522 Lista de Schindler 4436,0 8.3 8.206639
23673 Whiplash 4376.0 8.3 8.205404
5481 Spirited Away 3968.0 8.3 8.196055
2211 Life Is Beautiful 3643.0 8.3 8.187171
1178 O Padrinho: Parte II 3418.0 8.3 8.180076
1152 One Flew Over the Cuckoo’s Nest 3001.0 8.3 8.3 8.164256
351 Forrest Gump 8147.0 8.2 8.150272
1154 The Empire Strikes Back 5998.0 8.2 8.132919
1176 Psycho 2405.0 8.3 8.132715
18465 Os Intouchables 5410.0 8.2 8.125837
40251 Seu Nome. 1030.0 8.5 8.112532
289 Leão: O Profissional 4293.0 8.2 8.107234
3030 Linha Verde 4166.0 8.2 8.2 8.104511
1170 GoodFellas 3211.0 8.2 8.077459

Bem, pela saída acima, você pode ver que o simple recommender fez um ótimo trabalho!

Desde que o gráfico tem muitos filmes em comum com o gráfico Top 250 do IMDB: por exemplo, seus dois filmes top, “Shawshank Redemption” e “The Godfather”, são os mesmos do IMDB e todos nós sabemos que são de fato filmes incríveis, na verdade, todos os filmes top 20 merecem estar nessa lista, não é mesmo?

Content-Based Recommender

Plot Description Based Recommender

Nesta seção do tutorial, você aprenderá como construir um sistema que recomenda filmes que são similares a um filme em particular. Para conseguir isso, você irá computar em pares pontuações de similaridade para todos os filmes com base nas descrições de seus enredos e recomendar filmes baseados naquele limiar de pontuação de similaridade.

A descrição do enredo está disponível para você como a característica overview no seu conjunto de dados metadata. Vamos inspecionar os enredos de alguns filmes:

#Print plot overviews of the first 5 movies.metadata.head()
0 Led by Woody, Andy's toys live happily in his ...1 When siblings Judy and Peter discover an encha...2 A family wedding reignites the ancient feud be...3 Cheated on, mistreated and stepped on, the wom...4 Just when George Banks has recovered from his ...Name: overview, dtype: object

O problema em questão é um problema de Processamento de Linguagem Natural. Portanto, você precisa extrair algum tipo de recurso dos dados de texto acima antes de poder calcular a similaridade e/ou dissemelhança entre eles. Para simplificar, não é possível computar a similaridade entre quaisquer duas visões gerais em suas formas brutas. Para fazer isso, você precisa calcular os vetores das palavras de cada visão geral ou documento, como será chamado a partir de agora.

Como o nome sugere, os vetores das palavras são representação vetorial das palavras em um documento. Os vetores carregam um significado semântico com ele. Por exemplo, man & king terá representações vetoriais próximas umas das outras enquanto man & woman teria representação longe uma da outra.

You will compute Term Frequency-Inverse Document Frequency (TF-IDF) vectores para cada documento. Isto dar-lhe-á uma matriz onde cada coluna representa uma palavra no vocabulário geral (todas as palavras que aparecem em pelo menos um documento), e cada coluna representa um filme, como antes.

Na sua essência, a pontuação TF-IDF é a frequência com que uma palavra ocorre num documento, ponderada pelo número de documentos em que ela ocorre. Isto é feito para reduzir a importância das palavras que ocorrem frequentemente nas sínteses das tramas e, portanto, o seu significado no cálculo da partitura de similaridade final.

Felizmente, scikit-learn dá-lhe uma classe incorporada TfIdfVectorizer que produz a matriz TF-IDF em algumas linhas.

  • Importar o módulo Tfidf usando scikit-learn;
  • Remover palavras stop como ‘the’, ‘an’, etc. já que eles não dão nenhuma informação útil sobre o tópico;
  • Substituir valores não numéricos por uma string em branco;
  • Finalmente, construa a matriz TF-IDF nos dados.
#Import TfIdfVectorizer from scikit-learnfrom sklearn.feature_extraction.text import TfidfVectorizer#Define a TF-IDF Vectorizer Object. Remove all english stop words such as 'the', 'a'tfidf = TfidfVectorizer(stop_words='english')#Replace NaN with an empty stringmetadata = metadata.fillna('')#Construct the required TF-IDF matrix by fitting and transforming the datatfidf_matrix = tfidf.fit_transform(metadata)#Output the shape of tfidf_matrixtfidf_matrix.shape
(45466, 75827)
#Array mapping from feature integer indices to feature name.tfidf.get_feature_names()

Da saída acima, você observa que 75.827 vocabulários ou palavras diferentes em seu conjunto de dados têm 45.000 filmes.

Com esta matriz em mãos, você pode agora computar uma partitura de similaridade. Há várias métricas de similaridade que você pode usar para isso, como a manhattan, euclidean, a Pearson, e as partituras de similaridade cosseno. Mais uma vez, não há uma resposta certa para qual pontuação é a melhor. Pontuações diferentes funcionam bem em cenários diferentes, e muitas vezes é uma boa idéia experimentar com métricas diferentes e observar os resultados.

Você estará usando o cosine similarity para calcular uma quantidade numérica que denota a similaridade entre dois filmes. Você usará a pontuação de similaridade co-seno já que ela é independente da magnitude e é relativamente fácil e rápida de calcular (especialmente quando usada em conjunto com a pontuação TF-IDF, que será explicada mais tarde). Matematicamente, é definida da seguinte forma:

Desde que tenha utilizado o vectorizador TF-IDF, o cálculo do produto ponto entre cada vector dar-lhe-á directamente a partitura de semelhança cosseno. Portanto, você usará sklearn's linear_kernel() ao invés de cosine_similarities() já que é mais rápido.

Isto retornaria uma matriz de forma 45466×45466, o que significa que cada filme overview partitura de similaridade cosseno com todos os outros filmes overview. Assim, cada filme será um vector de coluna 1×45466 onde cada coluna será uma partitura de similaridade com cada filme.

# Import linear_kernelfrom sklearn.metrics.pairwise import linear_kernel# Compute the cosine similarity matrixcosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)

cosine_sim.shape
(45466, 45466)
cosine_sim
array()

Vai definir uma função que aceita um título de filme como uma entrada e produz uma lista dos 10 filmes mais semelhantes. Primeiro, para isso, você precisa de um mapeamento reverso dos títulos dos filmes e índices DataFrame. Em outras palavras, você precisa de um mecanismo para identificar o índice de um filme em seu metadata DataFrame, dado seu título.

#Construct a reverse map of indices and movie titlesindices = pd.Series(metadata.index, index=metadata).drop_duplicates()
indices
titleToy Story 0Jumanji 1Grumpier Old Men 2Waiting to Exhale 3Father of the Bride Part II 4Heat 5Sabrina 6Tom and Huck 7Sudden Death 8GoldenEye 9dtype: int64

Você agora está em boa forma para definir sua função de recomendação. Estes são os seguintes passos que irá seguir:

  • >

    Pega no índice do filme dado o seu título.

  • Pega na lista de partituras de similaridade cosseno para aquele filme em particular com todos os filmes. Converta-o em uma lista de tuplos onde o primeiro elemento é a sua posição, e o segundo é a pontuação de similaridade.

  • Selecione a lista de tuplos acima mencionada com base nas pontuações de similaridade; ou seja, o segundo elemento.

  • Obtenha os 10 primeiros elementos desta lista. Ignore o primeiro elemento pois ele se refere a si mesmo (o filme mais parecido com um determinado filme é o próprio filme).

  • Retornar os títulos correspondentes aos índices dos elementos superiores.

# Function that takes in movie title as input and outputs most similar moviesdef get_recommendations(title, cosine_sim=cosine_sim): # Get the index of the movie that matches the title idx = indices # Get the pairwsie similarity scores of all movies with that movie sim_scores = list(enumerate(cosine_sim)) # Sort the movies based on the similarity scores sim_scores = sorted(sim_scores, key=lambda x: x, reverse=True) # Get the scores of the 10 most similar movies sim_scores = sim_scores # Get the movie indices movie_indices = for i in sim_scores] # Return the top 10 most similar movies return metadata.iloc
get_recommendations('The Dark Knight Rises')
12481 The Dark Knight150 Batman Forever1328 Batman Returns15511 Batman: Under the Red Hood585 Batman21194 Batman Unmasked: The Psychology of the Dark Kn...9230 Batman Beyond: Return of the Joker18035 Batman: Year One19792 Batman: The Dark Knight Returns, Part 13095 Batman: Mask of the PhantasmName: title, dtype: object
get_recommendations('The Godfather')
1178 The Godfather: Part II44030 The Godfather Trilogy: 1972-19901914 The Godfather: Part III23126 Blood Ties11297 Household Saints34717 Start Liquidation10821 Election38030 A Mother Should Be Loved17729 Short Sharp Shock26293 Beck 28 - FamiljenName: title, dtype: object

Você vê que, embora seu sistema tenha feito um trabalho decente de encontrar filmes com descrições de enredo similares, a qualidade das recomendações não é tão boa assim. “The Dark Knight Rises” retorna todos os filmes do Batman enquanto é mais provável que as pessoas que gostaram desse filme estejam mais inclinadas a gostar de outros filmes de Christopher Nolan. Isto é algo que não pode ser capturado pelo seu sistema atual.

Credits, Genres, and Keywords Based Recommender

A qualidade do seu recommender seria aumentada com o uso de melhores metadados e com a captura de mais detalhes finos. Isso é precisamente o que você vai fazer nesta seção. Você irá construir um sistema de recomendação baseado nos seguintes metadados: os 3 principais atores, o diretor, gêneros relacionados e as palavras-chave do enredo do filme.

As palavras-chave, elenco e dados da equipe não estão disponíveis em seu conjunto de dados atual, então o primeiro passo seria carregá-los e fundi-los em seu DataFrame principal metadata.

# Load keywords and creditscredits = pd.read_csv('credits.csv')keywords = pd.read_csv('keywords.csv')# Remove rows with bad IDs.metadata = metadata.drop()# Convert IDs to int. Required for mergingkeywords = keywords.astype('int')credits = credits.astype('int')metadata = metadata.astype('int')# Merge keywords and credits into your main metadata dataframemetadata = metadata.merge(credits, on='id')metadata = metadata.merge(keywords, on='id')
# Print the first two movies of your newly merged metadatametadata.head(2)

>

>

>>falar_língua

>

>

>

jealousy toy boy tomhanks timallen donrickles …

boardgame disappearance basedonchildren’sbook …

Os próximos passos são os mesmos que você fez com o seu plot description based recommender. Uma diferença chave é que você usa o CountVectorizer() ao invés de TF-IDF. Isto é porque você não quer diminuir o peso da presença do ator/diretor se ele ou ela atuou ou dirigiu em relativamente mais filmes. Não faz muito sentido intuitivo baixá-los neste contexto.

A maior diferença entre CountVectorizer() e TF-IDF é o componente de frequência inversa de documentos (IDF) que está presente em mais tarde e não no primeiro.

# Import CountVectorizer and create the count matrixfrom sklearn.feature_extraction.text import CountVectorizercount = CountVectorizer(stop_words='english')count_matrix = count.fit_transform(metadata)
count_matrix.shape
(46628, 73881)

Da saída acima, você pode ver que existem 73.881 vocabulários nos metadados que você alimentou.

Próximo, você vai usar o cosine_similarity para medir a distância entre os embeddings.

# Compute the Cosine Similarity matrix based on the count_matrixfrom sklearn.metrics.pairwise import cosine_similaritycosine_sim2 = cosine_similarity(count_matrix, count_matrix)
# Reset index of your main DataFrame and construct reverse mapping as beforemetadata = metadata.reset_index()indices = pd.Series(metadata.index, index=metadata)

Agora você pode reutilizar sua função get_recommendations() passando no novo cosine_sim2 matriz como seu segundo argumento.

get_recommendations('The Dark Knight Rises', cosine_sim2)
12589 The Dark Knight10210 Batman Begins9311 Shiner9874 Amongst Friends7772 Mitchell516 Romeo Is Bleeding11463 The Prestige24090 Quicksand25038 Deadfall41063 SaraName: title, dtype: object
get_recommendations('The Godfather', cosine_sim2)
1934 The Godfather: Part III1199 The Godfather: Part II15609 The Rain People18940 Last Exit34488 Rege35802 Manuscripts Don't Burn35803 Manuscripts Don't Burn8001 The Night of the Following Day18261 The Son of No One28683 In the Name of the LawName: title, dtype: object

Great! Você vê que o seu recomendador foi bem sucedido na captura de mais informações devido a mais metadados e lhe deu melhores recomendações. Existem, é claro, inúmeras maneiras de experimentar este sistema para melhorar as recomendações.

Somas sugestões:

  • Introduzir um filtro de popularidade: este recomendador pegaria os 30 filmes mais similares, calcularia as classificações ponderadas (usando a fórmula IMDB de cima), classificaria os filmes com base nesta classificação, e retornaria os 10 melhores filmes.

  • Outros membros da equipe: outros nomes de membros da equipe, como roteiristas e produtores, também poderiam ser incluídos.

  • O peso crescente do diretor: para dar mais peso ao diretor, ele ou ela poderia ser mencionado várias vezes na sopa para aumentar as notas de similaridade dos filmes com o mesmo diretor.

Filtragem colaborativa com Python

Neste tutorial, você aprendeu como construir seus próprios Sistemas de Recomendação de Filmes Simples e Baseados em Conteúdo. Há também outro tipo de recomendador extremamente popular conhecido como filtros colaborativos.

Filtros colaborativos podem ainda ser classificados em dois tipos:

  • User-based Filtering: estes sistemas recomendam produtos a um usuário que usuários similares tenham gostado. Por exemplo, digamos que Alice e Bob têm um interesse semelhante em livros (ou seja, eles gostam e não gostam muito dos mesmos livros). Agora, digamos que um novo livro foi lançado no mercado, e Alice o leu e adorou. É, portanto, altamente provável que Bob também goste, e por isso, o sistema recomenda este livro a Bob.
  • Item-based Filtering: estes sistemas são extremamente semelhantes ao motor de recomendação de conteúdo que você construiu. Estes sistemas identificam itens semelhantes com base na forma como as pessoas o classificaram no passado. Por exemplo, se Alice, Bob e Eva deram 5 estrelas para O Senhor dos Anéis e O Hobbit, o sistema identifica os itens como semelhantes. Portanto, se alguém compra O Senhor dos Anéis, o sistema também recomenda O Hobbit para ele ou ela.

Um exemplo de filtragem colaborativa baseada num sistema de classificação:

Você não estará construindo esses sistemas neste tutorial, mas já está familiarizado com a maioria das idéias necessárias para fazê-lo. Um bom lugar para começar com filtros colaborativos é examinando o conjunto de dados do MovieLens, que pode ser encontrado aqui.

Conclusion

Congratulações por terminar este tutorial!

Você passou com sucesso pelo nosso tutorial que lhe ensinou tudo sobre sistemas recomendados em Python. Você aprendeu como construir recomendadores simples e baseados em conteúdo.

Um bom exercício para todos vocês seria implementar a filtragem colaborativa em Python usando o subconjunto de dados MovieLens que você usou para construir recomendadores simples e baseados em conteúdo.

Se você está apenas começando em Python e gostaria de aprender mais, faça o curso Introdução à Ciência dos Dados em Python do DataCamp.

adult belongs_to_collection budget genres homepage id imdb_id língua_original título_original visão geral estado tagline título video vote_average vote_count cast crew keywords
0 False {‘id’: 10194, ‘name’: ‘Toy Story Collection’, … 30000000 Largado NaN Toy Story False 7.7 5415.0 para característica em características: metadados = metadados.apply(literal_eval)

Next, você escreve funções que o ajudarão a extrair a informação requerida de cada recurso.

Primeiro, você vai importar o pacote NumPy para ter acesso à sua NaN constante. A seguir, você pode usá-lo para escrever a get_director() function:

# Import Numpyimport numpy as np

Receba o nome do diretor a partir da funcionalidade crew. Se o diretor não estiver listado, retorne NaN

def get_director(x): for i in x: if i == 'Director': return i return np.nan

Next, você escreverá uma função que retornará os 3 elementos superiores ou a lista inteira, o que for mais. Aqui a lista refere-se aos elementos cast, keywords, e genres.

def get_list(x): if isinstance(x, list): names = for i in x] #Check if more than 3 elements exist. If yes, return only first three. If no, return entire list. if len(names) > 3: names = names return names #Return empty list in case of missing/malformed data return 
# Define new director, cast, genres and keywords features that are in a suitable form.metadata = metadata.apply(get_director)features = for feature in features: metadata = metadata.apply(get_list)
# Print the new features of the first 3 filmsmetadata].head(3)
title cast director keywords genres
0 Toy Story John Lasseter
1 Jumanji Joe Johnston
2 Grumpier Old Men Howard Deutch >

O próximo passo seria converter os nomes e as instâncias de palavras-chave em minúsculas e retirar todos os espaços entre elas.

Remover os espaços entre as palavras é um passo importante no pré-processamento. Ele é feito para que seu vetorizador não conte o Johnny de “Johnny Depp” e “Johnny Galecki” como o mesmo. Após este passo de processamento, os actores acima mencionados serão representados como “johnnydepp” e “johnnygalecki” e serão distintos do seu vectorizador.

Outro bom exemplo em que o modelo pode sair a mesma representação vectorial é “bread jam” e “traffic jam”. Assim, é melhor tirar qualquer espaço que esteja presente.

A função abaixo fará exactamente isso por si:

# Function to convert all strings to lower case and strip names of spacesdef clean_data(x): if isinstance(x, list): return else: #Check if director exists. If not, return empty string if isinstance(x, str): return str.lower(x.replace(" ", "")) else: return ''
# Apply clean_data function to your features.features = for feature in features: metadata = metadata.apply(clean_data)

Você está agora em condições de criar a sua “sopa de metadados”, que é uma string que contém todos os metadados que você quer alimentar o seu vectorizador (nomeadamente actores, realizador e palavras-chave).

A função create_soup irá simplesmente juntar todas as colunas necessárias por um espaço. Este é o passo final do pré-processamento, e a saída desta função será alimentada na palavra vector model.

def create_soup(x): return ' '.join(x) + ' ' + ' '.join(x) + ' ' + x + ' ' + ' '.join(x)
# Create a new soup featuremetadata = metadata.apply(create_soup, axis=1)
metadata].head(2)

soup 0 1