協調フィルタリング（Collaborative filtering）レコメンドエンジン

import numpy as np

import pandas as pd

import collections

from mpl_toolkits.mplot3d import Axes3D

from IPython import display

from matplotlib import pyplot as plt

import sklearn

import sklearn.manifold

import tensorflow.compat.v1 as tf

tf.disable_v2_behavior()

tf.logging.set_verbosity(tf.logging.ERROR)

# PandasDataFrameにいくつかの便利な関数を追加します。pd.options.display.max_rows = 10

pd.options.display.float_format = ‘{:.3f}’.format

def mask(df, key, function):

“””Returns a filtered dataframe, by applying function to key”””

return df[function(df[key])]

def flatten_cols(df):

df.columns = [‘ ‘.join(col).strip() for col in df.columns.values]

return df

pd.DataFrame.mask = mask

pd.DataFrame.flatten_cols = flatten_cols

# Altairをインストールし、そのcolabレンダラーをアクティブにします。

print(“Installing Altair…”)

!pip install git+git://github.com/altair-viz/altair.git

import altair as alt

alt.data_transformers.enable(‘default’, max_rows=None)

alt.renderers.enable(‘colab’)

print(“Done installing Altair.”)

# スプレッドシートをインストールし、認証モジュールをインポートします。

USER_RATINGS = False

!pip install –upgrade -q gspread

from google.colab import auth

import gspread

from oauth2client.client import GoogleCredentials

from urllib.request import urlretrieve

import zipfile

urlretrieve(“http://files.grouplens.org/datasets/movielens/ml-100k.zip”, “movielens.zip”)

zip_ref = zipfile.ZipFile(‘movielens.zip’, “r”)

zip_ref.extractall()

print(“Done. Dataset contains:”)

print(zip_ref.read(‘ml-100k/u.info’))

# users データフレーム

users_cols = [‘user_id’, ‘age’, ‘sex’, ‘occupation’, ‘zip_code’]

users = pd.read_csv(

‘ml-100k/u.user’, sep=’|’, names=users_cols, encoding=’latin-1′)

#  ratingsデータフレーム作成

ratings_cols = [‘user_id’, ‘movie_id’, ‘rating’, ‘unix_timestamp’]

ratings = pd.read_csv(

‘ml-100k/u.data’, sep=’\t’, names=ratings_cols, encoding=’latin-1′)

#  movies データフレーム作成

genre_cols = [

“genre_unknown”, “Action”, “Adventure”, “Animation”, “Children”, “Comedy”,

“Crime”, “Documentary”, “Drama”, “Fantasy”, “Film-Noir”, “Horror”,

“Musical”, “Mystery”, “Romance”, “Sci-Fi”, “Thriller”, “War”, “Western”

]

movies_cols = [

‘movie_id’, ‘title’, ‘release_date’, “video_release_date”, “imdb_url”

] + genre_cols

movies = pd.read_csv(

‘ml-100k/u.item’, sep=’|’, names=movies_cols, encoding=’latin-1′)

users[“user_id”] = users[“user_id”].apply(lambda x: str(x-1))

movies[“movie_id”] = movies[“movie_id”].apply(lambda x: str(x-1))

movies[“year”] = movies[‘release_date’].apply(lambda x: str(x).split(‘-‘)[-1])

ratings[“movie_id”] = ratings[“movie_id”].apply(lambda x: str(x-1))

ratings[“user_id”] = ratings[“user_id”].apply(lambda x: str(x-1))

ratings[“rating”] = ratings[“rating”].apply(lambda x: float(x))

# ジャンルの件数

genre_occurences = movies[genre_cols].sum().to_dict()

# all_genresとgenreのカラムを作成

def mark_genres(movies, genres):

def get_random_genre(gs):

active = [genre for genre, g in zip(genres, gs) if g==1]

if len(active) == 0:

return ‘Other’

return np.random.choice(active)

def get_all_genres(gs):

active = [genre for genre, g in zip(genres, gs) if g==1]

if len(active) == 0:

return ‘Other’

return ‘-‘.join(active)

movies[‘genre’] = [

get_random_genre(gs) for gs in zip(*[movies[genre] for genre in genres])]

movies[‘all_genres’] = [

get_all_genres(gs) for gs in zip(*[movies[genre] for genre in genres])]

mark_genres(movies, genre_cols)

# movielensのデータフレーム

movielens = ratings.merge(movies, on=’movie_id’).merge(users, on=’user_id’)

test = df.sample(frac=holdout_fraction, replace=False)

train = df[~df.index.isin(test.index)]

return train, test

indices = ratings_df[[‘user_id’, ‘movie_id’]].values

values = ratings_df[‘rating’].values

return tf.SparseTensor(

indices=indices,

values=values,

dense_shape=[users.shape[0], movies.shape[0]])

predictions = tf.gather_nd(

tf.matmul(user_embeddings, movie_embeddings, transpose_b=True),

sparse_ratings.indices)

loss = tf.losses.mean_squared_error(sparse_ratings.values, predictions)

return loss

class CFModel(object):

self._embedding_vars = embedding_vars

self._loss = loss

self._metrics = metrics

self._embeddings = {k: None for k in embedding_vars}

self._session = None

@property

def embeddings(self):

“””The embeddings dictionary.”””

return self._embeddings

def train(self, num_iterations=100, learning_rate=1.0, plot_results=True,

optimizer=tf.train.GradientDescentOptimizer):

with self._loss.graph.as_default():

opt = optimizer(learning_rate)

train_op = opt.minimize(self._loss)

local_init_op = tf.group(

tf.variables_initializer(opt.variables()),

tf.local_variables_initializer())

if self._session is None:

self._session = tf.Session()

with self._session.as_default():

self._session.run(tf.global_variables_initializer())

self._session.run(tf.tables_initializer())

tf.train.start_queue_runners()

with self._session.as_default():

local_init_op.run()

iterations = []

metrics = self._metrics or ({},)

metrics_vals = [collections.defaultdict(list) for _ in self._metrics]

# Train and append results.

for i in range(num_iterations + 1):

_, results = self._session.run((train_op, metrics))

if (i % 10 == 0) or i == num_iterations:

print(“\r iteration %d: ” % i + “, “.join(

[“%s=%f” % (k, v) for r in results for k, v in r.items()]),

end=”)

iterations.append(i)

for metric_val, result in zip(metrics_vals, results):

for k, v in result.items():

metric_val[k].append(v)

for k, v in self._embedding_vars.items():

self._embeddings[k] = v.eval()

if plot_results:

# Plot the metrics.

num_subplots = len(metrics)+1

fig = plt.figure()

fig.set_size_inches(num_subplots*10, 8)

for i, metric_vals in enumerate(metrics_vals):

ax = fig.add_subplot(1, num_subplots, i+1)

for k, v in metric_vals.items():

ax.plot(iterations, v, label=k)

ax.set_xlim([1, num_iterations])

ax.legend()

return results

def build_model(ratings, embedding_dim=3, init_stddev=1.):

# Split the ratings DataFrame into train and test.

train_ratings, test_ratings = split_dataframe(ratings)

# SparseTensor representation of the train and test datasets.

A_train = build_rating_sparse_tensor(train_ratings)

A_test = build_rating_sparse_tensor(test_ratings)

# Initialize the embeddings using a normal distribution.

U = tf.Variable(tf.random_normal(

[A_train.dense_shape[0], embedding_dim], stddev=init_stddev))

V = tf.Variable(tf.random_normal(

[A_train.dense_shape[1], embedding_dim], stddev=init_stddev))

train_loss = sparse_mean_square_error(A_train, U, V)

test_loss = sparse_mean_square_error(A_test, U, V)

metrics = {

‘train_error’: train_loss,

‘test_error’: test_loss

}

embeddings = {

“user_id”: U,

“movie_id”: V

}

return CFModel(embeddings, train_loss, [metrics])

model = build_model(ratings, embedding_dim=30, init_stddev=0.5)

model.train(num_iterations=1000, learning_rate=10.)

# 実行してスプレッドシートを作成し、それを使用して評価を入力します。

if USER_RATINGS:

auth.authenticate_user()

gc = gspread.authorize(GoogleCredentials.get_application_default())

# Create the spreadsheet and print a link to it.

try:

sh = gc.open(‘MovieLens-test’)

except(gspread.SpreadsheetNotFound):

sh = gc.create(‘MovieLens-test’)

worksheet = sh.sheet1

titles = movies[‘title’].values

cell_list = worksheet.range(1, 1, len(titles), 1)

for cell, title in zip(cell_list, titles):

cell.value = title

worksheet.update_cells(cell_list)

print(“Link to the spreadsheet: ”

“https://docs.google.com/spreadsheets/d/{}/edit”.format(sh.id))

if USER_RATINGS:

my_ratings = pd.DataFrame.from_records(worksheet.get_all_values()).reset_index()

my_ratings = my_ratings[my_ratings[1] != ”]

my_ratings = pd.DataFrame({

‘user_id’: “943”,

‘movie_id’: list(map(str, my_ratings[‘index’])),

‘rating’: list(map(float, my_ratings[1])),

})

# Remove previous ratings.

ratings = ratings[ratings.user_id != “943”]

# Add new ratings.

ratings = ratings.append(my_ratings, ignore_index=True)

# Add new user to the users DataFrame.

if users.shape[0] == 943:

users = users.append(users.iloc[942], ignore_index=True)

users[“user_id”][943] = “943”

print(“Added your %d ratings; you have great taste!” % len(my_ratings))

ratings[ratings.user_id==”943″].merge(movies[[‘movie_id’, ‘title’]])

DOT = ‘dot’

COSINE = ‘cosine’

def compute_scores(query_embedding, item_embeddings, measure=DOT):

u = query_embedding

V = item_embeddings

if measure == COSINE:

V = V / np.linalg.norm(V, axis=1, keepdims=True)

u = u / np.linalg.norm(u)

scores = u.dot(V.T)

return scores

if USER_RATINGS:

scores = compute_scores(

model.embeddings[“user_id”][943], model.embeddings[“movie_id”], measure)

score_key = measure + ‘ score’

df = pd.DataFrame({

score_key: list(scores),

‘movie_id’: movies[‘movie_id’],

‘titles’: movies[‘title’],

‘genres’: movies[‘all_genres’],

})

if exclude_rated:

# remove movies that are already rated

rated_movies = ratings[ratings.user_id == “943”][“movie_id”].values

df = df[df.movie_id.apply(lambda movie_id: movie_id not in rated_movies)]

display.display(df.sort_values([score_key], ascending=False).head(k))

def movie_neighbors(model, title_substring, measure=DOT, k=6):

# Search for movie ids that match the given substring.

ids =  movies[movies[‘title’].str.contains(title_substring)].index.values

titles = movies.iloc[ids][‘title’].values

if len(titles) == 0:

raise ValueError(“Found no movies with title %s” % title_substring)

print(“Nearest neighbors of : %s.” % titles[0])

if len(titles) > 1:

print(“[Found more than one matching movie. Other candidates: {}]”.format(

“, “.join(titles[1:])))

movie_id = ids[0]

scores = compute_scores(

model.embeddings[“movie_id”][movie_id], model.embeddings[“movie_id”],

measure)

score_key = measure + ‘ score’

df = pd.DataFrame({

score_key: list(scores),

‘titles’: movies[‘title’],

‘genres’: movies[‘all_genres’]

})

display.display(df.sort_values([score_key], ascending=False).head(k))

def visualize_movie_embeddings(data, x, y):

nearest = alt.selection(

type=’single’, encodings=[‘x’, ‘y’], on=’mouseover’, nearest=True,

empty=’none’)

base = alt.Chart().mark_circle().encode(

x=x,

y=y,

color=alt.condition(genre_filter, “genre”, alt.value(“whitesmoke”)),

).properties(

width=600,

height=600,

selection=nearest)

text = alt.Chart().mark_text(align=’left’, dx=5, dy=-5).encode(

x=x,

y=y,

text=alt.condition(nearest, ‘title’, alt.value(”)))

return alt.hconcat(alt.layer(base, text), genre_chart, data=data)

def tsne_movie_embeddings(model):

“””Visualizes the movie embeddings, projected using t-SNE with Cosine measure.

Args:

model: A MFModel object.

“””

tsne = sklearn.manifold.TSNE(

n_components=2, perplexity=40, metric=’cosine’, early_exaggeration=10.0,

init=’pca’, verbose=True, n_iter=400)

print(‘Running t-SNE…’)

V_proj = tsne.fit_transform(model.embeddings[“movie_id”])

movies.loc[:,’x’] = V_proj[:, 0]

movies.loc[:,’y’] = V_proj[:, 1]

return visualize_movie_embeddings(movies, ‘x’, ‘y’)