# -*- coding: utf-8 -*-

import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity


def load_datasets(data_dir: str) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    rate_df = pd.read_csv(f"{data_dir}/ratings.csv")
    movies_df = pd.read_csv(f"{data_dir}/movies.csv")
    tags_df = pd.read_csv(f"{data_dir}/tags.csv")

    return rate_df, movies_df, tags_df


def genre_pivot_table(movies_df: pd.DataFrame) -> pd.DataFrame:
    # ジャンルをリストに分割し、各ジャンルを1行とする
    movies_df["genre_list"] = movies_df["genres"].str.split("|")
    movies_df = movies_df.explode("genre_list")

    # ジャンル情報であることを示すフラグを追加
    movies_df["is_genre"] = 1

    # ピボットテーブルを作成
    movies_df_pivot = movies_df.pivot_table(
        index=["movieId", "title"],
        columns="genre_list",
        values="is_genre",
        fill_value=0
    )

    # インデックスをリセットし、不要な列を削除
    movies_df_pivot = movies_df_pivot.reset_index()
    movies_df_pivot.columns.name = None

    # 列の順序を変更し、不要なカラムを削除
    columns = movies_df_pivot.columns.tolist()
    columns[:2] = ["movieId", "title"]
    movies_df_pivot = movies_df_pivot[columns]
    movies_df_pivot = movies_df_pivot.drop("(no genres listed)", axis=1)

    return movies_df_pivot


def create_recommendations(rate_df: pd.DataFrame, movies_df: pd.DataFrame, target_user_id: int, n_target_items: int = 5) -> pd.DataFrame:
    # 映画情報からジャンル情報を抽出しやすいようにデータフレームを整形
    movies_df_pivot = genre_pivot_table(movies_df)

    # 各映画情報からジャンル情報をOne-Hotエンコーディングしたベクトルを準備
    x = movies_df_pivot.drop(["movieId", "title"], axis=1).to_numpy()

    # レコメンデーション対象のユーザーが高評価した映画情報を抽出
    high_review_movie_df = rate_df.query(f"userId == {target_user_id} and rating == 5").sort_values(by="timestamp", ascending=False)

    # 高評価した映画情報のタイトルと紐づくようにデータフレームを作成する
    high_review_movie_df = pd.merge(high_review_movie_df[:n_target_items], movies_df_pivot, how="left", on="movieId")

    # ユーザーが好む映画と、すべての映画の類似度を計算
    avg_high_review_movie_df_x = high_review_movie_df.loc[:, "Action":"Western"].mean().to_numpy()
    similarities = cosine_similarity(avg_high_review_movie_df_x.reshape(1, -1), x)
    movies_df_pivot["similarity"] = similarities[0]

    return movies_df_pivot


if __name__ == "__main__":
    # データセット (MovieLens) の読み込み
    rate_df, movies_df, _ = load_datasets("./ml-latest-small")

    # 指定したユーザーに対する推薦情報を作成
    # 戻り値のデータフレームにあるカラムの「similarity」が大きいものほど推薦対象となる
    target_user_id = 1      # 推薦対象のユーザーIDを指定
    recommendation = create_recommendations(
        rate_df,
        movies_df,
        target_user_id=target_user_id,
    )

    # 結果の保存
    recommendation.to_csv(f"recommendation-for-user{target_user_id}.csv")

# -*- coding: utf-8 -*-

import gensim
import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity


def load_datasets(data_dir: str) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    rate_df = pd.read_csv(f"{data_dir}/ratings.csv")
    movies_df = pd.read_csv(f"{data_dir}/movies.csv")
    tags_df = pd.read_csv(f"{data_dir}/tags.csv")

    return rate_df, movies_df, tags_df


def extract_genres_and_tags(movies_df: pd.DataFrame, tags_df: pd.DataFrame) -> pd.DataFrame:
    # タグ情報を抽出してリスト化
    tags_df["tag"] = tags_df["tag"].str.lower()
    user_tags_df = tags_df.groupby("movieId")["tag"].apply(list).reset_index()

    # ジャンルとタグ情報を一つのデータフレームにまとめる
    genres_tags_df = pd.merge(movies_df, user_tags_df, how="left", on="movieId")

    # ジャンル情報をリストに変換
    genres_tags_df["genre_list"] = genres_tags_df["genres"].map(lambda x: x.split("|")).to_list()

    # タグとジャンルを一つのリストにまとめる
    genres_tags_df["tag"] = genres_tags_df["tag"].fillna("").apply(list)
    genres_tags_df["tag_genre"] = genres_tags_df["tag"] + genres_tags_df["genre_list"]

    return genres_tags_df


def create_word2vec(words: list[str]) -> gensim.models.Word2Vec:
    return gensim.models.word2vec.Word2Vec(
        words,
        vector_size=100,    # 埋め込みベクトルの次元
        window=100,         # 上下文の最大距離
        sg=1,               # 0=CBoW, 1=Skip-Gram
        hs=0,               # 0=NS, 1=HS
        epochs=30           # 学習回数
    )


def embedding_movie_info(word2vec: gensim.models.word2vec.Word2Vec, tags_and_genres: list[str]) -> list:
    movie_vec = []

    tag_genre_in_model = set(word2vec.wv.key_to_index.keys())

    for tag_genre in tags_and_genres:
        input_tag_genre = set(tag_genre) & tag_genre_in_model

        if len(input_tag_genre) == 0:
            vec = np.random.randn(word2vec.vector_size)
        else:
            vec = word2vec.wv[input_tag_genre].mean(axis=0)

        movie_vec.append(vec)

    return movie_vec


def create_recommendations(rate_df: pd.DataFrame, genres_tags_df: pd.DataFrame, movie_vec: list, target_user_id: int, top_n: int = 10) -> pd.DataFrame:
    # ユーザーの高評価映画を取得
    high_review_movie_df = rate_df.query(f"userId == {target_user_id} and rating == 5").sort_values(by="timestamp", ascending=False)[:top_n]
    high_review_movie_df_list = high_review_movie_df["movieId"].tolist()

    # 高評価映画の平均ベクトルを計算
    movie_vec_arr = np.array(movie_vec)
    high_review_movie_vec_arr = movie_vec_arr[high_review_movie_df_list]
    avg_high_review_movie_vec_arr = high_review_movie_vec_arr.mean(axis=0)

    # すべての映画との類似度を計算
    similarities = cosine_similarity(avg_high_review_movie_vec_arr.reshape(1, -1), movie_vec_arr)
    genres_tags_df["similarity"] = similarities[0]

    return genres_tags_df


if __name__ == "__main__":
    # データセット (MovieLens) の読み込み
    rate_df, movies_df, tags_df = load_datasets("./ml-latest-small")

    # タグとジャンルの組み合わせを抽出
    genres_tags_df = extract_genres_and_tags(movies_df, tags_df)

    # Word2Vec モデルの作成
    tags_and_genres = genres_tags_df["tag_genre"].tolist()
    word2vec = create_word2vec(tags_and_genres)

    # 動画情報の埋め込み
    movie_vec = embedding_movie_info(word2vec, tags_and_genres)

    # 推奨映画の作成
    # 戻り値のデータフレームにあるカラムの「similarity」が大きいものほど推薦対象となる
    target_user_id = 11     # 推薦対象のユーザーIDを指定
    recommendation = create_recommendations(rate_df, genres_tags_df, movie_vec, target_user_id)

    # 結果の保存
    recommendation.to_csv(f"recommendation-for-user{target_user_id}-with-word2vec.csv")

# -*- coding: utf-8 -*-

import pandas as pd
from surprise import Dataset, KNNWithMeans, Reader, accuracy
from surprise.model_selection import train_test_split
from surprise.trainset import Trainset


def load_datasets(data_dir: str) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    rate_df = pd.read_csv(f"{data_dir}/ratings.csv")
    movies_df = pd.read_csv(f"{data_dir}/movies.csv")
    tags_df = pd.read_csv(f"{data_dir}/tags.csv")

    return rate_df, movies_df, tags_df


def to_train_test_data(rate_df: pd.DataFrame) -> tuple[Trainset, list]:
    reader = Reader(rating_scale=(0.5, 5.0))
    data_rate = Dataset.load_from_df(rate_df[["userId", "movieId", "rating"]], reader)

    return train_test_split(data_rate, test_size=0.2)


def train_recommender(train_set: Trainset, test_set: list) -> KNNWithMeans:
    # モデルの学習
    sim_options = {"name": "pearson", "user_based": True}
    knn = KNNWithMeans(k=20, sim_options=sim_options)
    knn.fit(train_set)

    # テストデータの評価
    test_pred = knn.test(test_set)
    print(f"RMSE: {accuracy.rmse(test_pred)}")
    print(f"MAE: {accuracy.mae(test_pred)}")

    return knn


def create_recommendations(recommender: KNNWithMeans, movies_df: pd.DataFrame, train_set: Trainset, top_n: int = 10) -> pd.DataFrame:
    # 予測結果の作成
    data_test = train_set.build_anti_testset()
    predictions = recommender.test(data_test)

    # 予測結果の上位 N 個を取得
    result_df = pd.DataFrame([[uid, iid, est] for uid, iid, _, est, _ in predictions], columns=["userId", "movieId", "pred"])
    result_top_n = result_df.sort_values("pred", ascending=False).groupby("userId").head(top_n).sort_index()
    result_top_n_merge = pd.merge(result_top_n, movies_df[["movieId", "title"]], how="left", on="movieId")

    return result_top_n_merge


if __name__ == "__main__":
    # データセット (MovieLens) の読み込み
    rate_df, movies_df, _ = load_datasets("./ml-latest-small")

    # 訓練データとテストデータに分割
    train_set, test_set = to_train_test_data(rate_df)

    # モデルの学習と評価
    recommender = train_recommender(train_set, test_set)

    # 推薦結果の作成
    recommendation = create_recommendations(recommender, movies_df, train_set)

    # 結果の保存
    recommendation.to_csv("recommendation_with_user_similarity.csv")

# -*- coding: utf-8 -*-

import pandas as pd
from surprise import SVD  # Matrix Factorization
from surprise import Dataset, Reader, accuracy
from surprise.model_selection import train_test_split
from surprise.trainset import Trainset


def load_datasets(data_dir: str) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    rate_df = pd.read_csv(f"{data_dir}/ratings.csv")
    movies_df = pd.read_csv(f"{data_dir}/movies.csv")
    tags_df = pd.read_csv(f"{data_dir}/tags.csv")

    return rate_df, movies_df, tags_df


def to_train_test_data(rate_df: pd.DataFrame) -> tuple[Trainset, list]:
    reader = Reader(rating_scale=(0.5, 5.0))
    data_rate = Dataset.load_from_df(rate_df[["userId", "movieId", "rating"]], reader)

    return train_test_split(data_rate, test_size=0.2)


def train_recommender(train_set: Trainset, test_set: list) -> SVD:
    # モデルの学習
    mf = SVD(
        n_factors=10,
        n_epochs=50,
        lr_all=0.01,
        biased=False
    )
    mf.fit(train_set)

    # テストデータの評価
    test_pred = mf.test(test_set)
    print(f"RMSE: {accuracy.rmse(test_pred)}")
    print(f"MAE: {accuracy.mae(test_pred)}")

    return mf


def create_recommendations(recommender: SVD, movies_df: pd.DataFrame, train_set: Trainset, top_n: int = 10) -> pd.DataFrame:
    # 予測結果の作成
    data_test = train_set.build_anti_testset()
    predictions = recommender.test(data_test)

    # 予測結果の上位 N 個を取得
    result_df = pd.DataFrame([[uid, iid, est] for uid, iid, _, est, _ in predictions], columns=["userId", "movieId", "pred"])
    result_top_n = result_df.sort_values("pred", ascending=False).groupby("userId").head(top_n).sort_index()
    result_top_n_merge = pd.merge(result_top_n, movies_df[["movieId", "title"]], how="left", on="movieId")

    return result_top_n_merge


if __name__ == "__main__":
    # データセット (MovieLens) の読み込み
    rate_df, movies_df, _ = load_datasets("./ml-latest-small")

    # 訓練データとテストデータに分割
    train_set, test_set = to_train_test_data(rate_df)

    # モデルの学習と評価
    recommender = train_recommender(train_set, test_set)

    # 推薦結果の作成
    recommendation = create_recommendations(recommender, movies_df, train_set)

    # 結果の保存
    recommendation.to_csv("recommendation_with_matrix_factorization.csv")