normal-movielens.ipynb

{"cells":[{"cell_type":"markdown","metadata":{},"source":["##GNN and Traditional algorithms for Movielens\n","\n"]},{"cell_type":"code","execution_count":1,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:18:30.368289Z","iopub.status.busy":"2023-10-06T17:18:30.367911Z","iopub.status.idle":"2023-10-06T17:18:30.373867Z","shell.execute_reply":"2023-10-06T17:18:30.372640Z","shell.execute_reply.started":"2023-10-06T17:18:30.368261Z"},"trusted":true},"outputs":[],"source":["import pandas as pd\n","import networkx as nx\n","import matplotlib.pyplot as plt\n","import numpy as np\n","from networkx.algorithms import bipartite\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F"]},{"cell_type":"code","execution_count":2,"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","execution":{"iopub.execute_input":"2023-10-06T17:18:30.382613Z","iopub.status.busy":"2023-10-06T17:18:30.381695Z","iopub.status.idle":"2023-10-06T17:18:49.095842Z","shell.execute_reply":"2023-10-06T17:18:49.094784Z","shell.execute_reply.started":"2023-10-06T17:18:30.382577Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["20000263\n"]}],"source":["\n","data = pd.read_csv('movielens-20m/rating.csv')\n","movies_df = pd.read_csv(\"movielens-20m/movie.csv\")\n","tags_df = pd.read_csv(\"movielens-20m/tag.csv\")\n","genome_scores_raw = pd.read_csv(\"movielens-20m/genome_scores.csv\")\n","print(len(data))\n","def load_data(data, size):\n","    data = data.iloc[:size]\n","    genome_scores = genome_scores_raw[genome_scores_raw['movieId'].isin(data['movieId'].unique())]\n","    train_data = data.copy()\n","    test_data = pd.DataFrame()\n","\n","    movie_num_user_rated_counts = train_data['movieId'].value_counts()\n","    popular_movies = movie_num_user_rated_counts[movie_num_user_rated_counts >= 10].index.tolist()\n","    train_data = train_data[train_data['movieId'].isin(popular_movies)]\n","\n","    test_indices = []\n","    for user_id in train_data['userId'].unique():\n","        user_ratings_indices = train_data[train_data['userId'] == user_id].index\n","        if len(user_ratings_indices) > 1:\n","            test_indices.append(np.random.choice(user_ratings_indices))\n","\n","    test_data = train_data.loc[test_indices]\n","    train_data = train_data.drop(test_indices)\n","\n","    return train_data, test_data, genome_scores"]},{"cell_type":"markdown","metadata":{},"source":["##Visual"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:18:49.856441Z","iopub.status.busy":"2023-10-06T17:18:49.856104Z","iopub.status.idle":"2023-10-06T17:19:22.028871Z","shell.execute_reply":"2023-10-06T17:19:22.027765Z","shell.execute_reply.started":"2023-10-06T17:18:49.856414Z"},"trusted":true},"outputs":[],"source":["import networkx as nx\n","from networkx.algorithms import bipartite\n","\n","# 1. Create a new graph\n","def makegraph(train_data):\n","    ratings_df = train_data\n","\n","    G = nx.Graph()\n","\n","    # 2. Bulk add user nodes\n","    unique_users = ratings_df['userId'].unique()\n","    G.add_nodes_from(unique_users, bipartite=0)\n","\n","    # 3. Bulk add movie nodes\n","    movie_nodes = [('m_' + str(row['movieId']), {'bipartite': 1, 'title': row['title'], 'genres': row['genres'].split('|')}) for _, row in movies_df.iterrows()]\n","    G.add_nodes_from(movie_nodes)\n","\n","    # 4. Bulk add edges\n","    edges = [(row['userId'], 'm_' + str(row['movieId']), {'rating': row['rating'], 'timestamp': row['timestamp']}) for _, row in ratings_df.iterrows()]\n","    G.add_edges_from(edges)\n","\n","    # 5. Group tags by movie and add them to the graph\n","    grouped_tags = tags_df.groupby('movieId')\n","    for movieId, group in grouped_tags:\n","        movie_node = 'm_' + str(movieId)\n","        G.nodes[movie_node]['tags'] = group[['tag', 'timestamp', 'userId']].to_dict('records')\n","\n","    # 6. Ensure the graph is bipartite\n","    assert bipartite.is_bipartite(G)\n","    return G\n"]},{"cell_type":"code","execution_count":4,"metadata":{},"outputs":[],"source":["def prepare_data(train_data, genome_scores_data):\n","    # Loading the data\n","    ratings = train_data\n","    genome_scores = genome_scores_data\n","    \n","    # Adjust relevance values in genome_scores such that the median becomes 0\n","    relevance_median = genome_scores['relevance'].median()\n","    genome_scores['relevance'] -= relevance_median\n","\n","    # Scaling the values of relevance\n","    max_zero_centered_relevance = genome_scores['relevance'].max()\n","    min_zero_centered_relevance = genome_scores['relevance'].min()\n","    scaler_positive_values = 0.5 / max_zero_centered_relevance\n","    scaler_negative_values = -0.5 / min_zero_centered_relevance\n","\n","    genome_scores['relevance'] = np.where(\n","        genome_scores['relevance'] > 0,\n","        genome_scores['relevance'] * scaler_positive_values,\n","        genome_scores['relevance'] * scaler_negative_values\n","    ) + 0.5\n","\n","    # Make relevance and label values be mapped to closest element in bins_values\n","    bins_values = np.array([0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1])\n","    genome_scores['relevance'] = genome_scores['relevance'].apply(lambda x: bins_values[np.abs(bins_values - x).argmin()])\n","\n","    # Converting ratings to be from 0 to 1 and mapping them to closest element in bins_values\n","    ratings['rating'] = (ratings['rating'] - 1) / 4\n","    ratings['rating'] = ratings['rating'].apply(lambda x: bins_values[np.abs(bins_values - x).argmin()])\n","    \n","    return ratings, genome_scores, bins_values\n","\n","def predict_rating_for_movie(user_id, movie_id, ratings, genome_scores, bins_values):\n","    user_ratings = ratings[ratings['userId'] == user_id]\n","    movies_rated_by_user = user_ratings['movieId'].tolist()\n","    genome_scores_movies_rated_by_user = genome_scores[genome_scores['movieId'].isin(movies_rated_by_user)]\n","    \n","    \n","    # Getting the probabilities for all labels\n","    probability_label = {}\n","    for label_value in bins_values:\n","        probability_label[label_value] = compute_movie_output(movie_id, user_id, user_ratings, genome_scores_movies_rated_by_user, genome_scores, label_value)\n","    \n","    most_probable_label = max(probability_label, key=probability_label.get)\n","    return (most_probable_label * 4) + 1\n","def get_probability(user_ratings, genome_scores_user, tag_id, relevance, label):\n","    \"\"\"Function to calculate the probability for a tagId based on user ratings.\"\"\"\n","   \n","    # Filtered genome_scores_user with same relevance for the given tagId\n","    relevant_movies_rated_by_user = genome_scores_user[(genome_scores_user['tagId'] == tag_id) & (genome_scores_user['relevance'] == relevance)]\n","       \n","    if relevant_movies_rated_by_user.empty:\n","        return 1  # If the user hasn't rated any movies with that relevance and tagId, we'll consider a default probability of 1.\n","   \n","    # Count the number of those movies (in relevant_movies_rated_by_user) rated with a value of label\n","    num_rated_label = user_ratings[user_ratings['movieId'].isin(relevant_movies_rated_by_user['movieId']) & (user_ratings['rating'] == label)].shape[0]\n","   \n","    return (num_rated_label / relevant_movies_rated_by_user.shape[0]) + 1\n","\n","def compute_movie_output(movie_id, user_id, user_ratings, genome_scores_user, genome_scores, label):\n","    \"\"\"Function to compute output for a movie based on user's ratings.\"\"\"\n","   \n","    # Get the tag relevance scores for the movie\n","    movie_relevance_scores = genome_scores[genome_scores['movieId'] == movie_id]\n","   \n","    # Calculate the probability for each tagId. It iterates through every row in movie_relevance_scores, passing as parameters the tagId (row['tagId']) and relevance (row['relevance'])\n","    probabilities = [get_probability(user_ratings, genome_scores_user, row['tagId'], row['relevance'], label) for _, row in movie_relevance_scores.iterrows()]\n","   \n","    # Calculate output by multiplying all the probabilities\n","    output = 1\n","    for prob in probabilities:\n","        output *= prob\n","   \n","    return output"]},{"cell_type":"code","execution_count":5,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:22.032781Z","iopub.status.busy":"2023-10-06T17:19:22.031952Z","iopub.status.idle":"2023-10-06T17:19:23.296415Z","shell.execute_reply":"2023-10-06T17:19:23.295342Z","shell.execute_reply.started":"2023-10-06T17:19:22.032739Z"},"trusted":true},"outputs":[],"source":["def cosine_similarity_matrix(tr_data):\n","    \n","    # Create a user-movie matrix with NaN for unrated movies\n","    df_user_movie = tr_data.pivot(index='userId', columns='movieId', values='rating')\n","\n","    # Put 0 instead of NaNs\n","    df_user_movie = df_user_movie.fillna(0)\n","    \n","    num_users = len(df_user_movie)\n","\n","    # Create an empty DataFrame with user IDs as row and column indices - cosine similatity matrix\n","    user_ids = range(1, num_users + 1)\n","    user_similarity_df = pd.DataFrame(index=user_ids, columns=user_ids)\n","    \n","    # Fill incosine similarity matrix\n","    for i in range(num_users):\n","        for j in range(num_users):\n","            user_similarity_df.at[i + 1, j + 1] = cosine_similarity1(df_user_movie.iloc[i], df_user_movie.iloc[j])\n","            \n","    # Set the user similarity to themself to 0\n","    # Set values to 0 where i == j\n","\n","    for i in range(user_similarity_df.shape[0]):\n","        user_similarity_df.iat[i, i] = 0\n","        \n","    return user_similarity_df\n","            \n","def cosine_similarity1(vector1, vector2):\n","    dot_product = np.dot(vector1, vector2)\n","    norm_vector1 = np.linalg.norm(vector1)\n","    norm_vector2 = np.linalg.norm(vector2)\n","    similarity = dot_product / (norm_vector1 * norm_vector2)\n","    return similarity\n","\n","def cosine_based_prediction(cosine_similarity_df, user_to_predict, movie_to_rate, train_data):\n","    \n","    row_user_to_predict = cosine_similarity_df.index.get_loc(user_to_predict)\n","    \n","    # Steps:\n","    # 1. Make user_similarity_df from a train set \n","    # 2. For a user find the closet users who have rated the movie\n","    # 3. Take the average of the rating and return it \n","    # 2. For a user find the closet users who have rated the movie\n","    sorted_similarities = cosine_similarity_df.iloc[row_user_to_predict].sort_values(ascending=False)\n","    # Loop through the sorted users to find a user who has rated the movie\n","    for user_id, similarity in sorted_similarities.items():\n","        # Filter the DataFrame to get ratings by the current user\n","        filtered_df = train_data[train_data['userId'] == user_id]\n","        \n","        # Check if this user has rated the movie\n","        if movie_to_rate in filtered_df['movieId'].values:\n","            return filtered_df[filtered_df['movieId'] == movie_to_rate]['rating'].mean()\n","    \n","    return 3.53 #Mean"]},{"cell_type":"code","execution_count":6,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:23.298243Z","iopub.status.busy":"2023-10-06T17:19:23.297811Z","iopub.status.idle":"2023-10-06T17:19:23.305358Z","shell.execute_reply":"2023-10-06T17:19:23.304248Z","shell.execute_reply.started":"2023-10-06T17:19:23.298205Z"},"trusted":true},"outputs":[],"source":["def predict_rating(G, user, movie):\n","    neighbors = list(G.neighbors(movie))\n","    if not neighbors:\n","        return np.mean([attr['rating'] for _, _, attr in G.edges(data=True) if 'rating' in attr])\n","\n","    sim_weights = []\n","    user_ratings = []\n","    for neighbor in neighbors:\n","        # Jaccard similarity as an example, but can be changed\n","        common_movies = list(nx.common_neighbors(G, user, neighbor))\n","        sim = len(common_movies) / (G.degree(user) + G.degree(neighbor) - len(common_movies))\n","        rating = G[neighbor][movie]['rating']\n","        \n","        sim_weights.append(sim)\n","        user_ratings.append(rating)\n","    \n","    return np.dot(user_ratings, sim_weights) / sum(sim_weights)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:23.307480Z","iopub.status.busy":"2023-10-06T17:19:23.306723Z","iopub.status.idle":"2023-10-06T17:19:23.322662Z","shell.execute_reply":"2023-10-06T17:19:23.321444Z","shell.execute_reply.started":"2023-10-06T17:19:23.307440Z"},"trusted":true},"outputs":[],"source":["def personalized_pagerank_recommendations(G, user, alpha=0.85):\n","    \"\"\"Generate recommendations for a user using Personalized PageRank.\"\"\"\n","    personalization = {node: 0 for node in G.nodes()}\n","    for neighbor in G.neighbors(user):\n","        personalization[neighbor] = G[user][neighbor]['rating']\n","    \n","    ppr = nx.pagerank(G, alpha=alpha, personalization=personalization)\n","    \n","    movies = [node for node in ppr.keys() if G.nodes[node]['bipartite'] == 1]\n","    sorted_movies = sorted(movies, key=lambda x: ppr[x], reverse=True)\n","    \n","    return sorted_movies\n"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:23.324872Z","iopub.status.busy":"2023-10-06T17:19:23.324058Z","iopub.status.idle":"2023-10-06T17:19:23.631740Z","shell.execute_reply":"2023-10-06T17:19:23.630677Z","shell.execute_reply.started":"2023-10-06T17:19:23.324817Z"},"trusted":true},"outputs":[],"source":["import seaborn as sns\n","\n","# Compute KDE of train ratings\n","\n","\n","def predict_rating_ppr_kde(G, user, movie,rating_kde,train_data):\n","    sorted_movies = personalized_pagerank_recommendations(G, user)\n","    \n","    if not sorted_movies:\n","        return train_data['rating'].mean()\n","    \n","    if movie in sorted_movies:\n","        rank = sorted_movies.index(movie)\n","    else:\n","        rank = len(sorted_movies)\n","    \n","    # Calculate rank percentile\n","    rank_percentile = rank / len(sorted_movies)\n","    \n","    # Map rank percentile to KDE\n","    y = np.interp(rank_percentile, rating_kde[1], rating_kde[0])\n","    return y\n","\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:23.633973Z","iopub.status.busy":"2023-10-06T17:19:23.633360Z","iopub.status.idle":"2023-10-06T17:19:23.639711Z","shell.execute_reply":"2023-10-06T17:19:23.638134Z","shell.execute_reply.started":"2023-10-06T17:19:23.633925Z"},"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["/home/raaf/Pythonprojects/Recommender_systems/venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n","  from .autonotebook import tqdm as notebook_tqdm\n"]}],"source":["from node2vec import Node2Vec\n","from sklearn.metrics.pairwise import cosine_similarity\n","def load_node2vec(G):\n","    node2vec = Node2Vec(G, dimensions=64, walk_length=30, num_walks=200, workers=52)  \n","    model = node2vec.fit(window=10, min_count=1)\n","    return model\n","\n","\n","def predict_rating_node2vec(model, user, movie):\n","    user_vector = model.wv[str(user)]\n","    movie_vector = model.wv[str(movie)]\n","\n","    similarity = cosine_similarity([user_vector], [movie_vector])[0][0]\n","\n","    predicted_rating = (4 * ((similarity+1)/2)) + 1\n","    return predicted_rating\n"]},{"cell_type":"code","execution_count":7,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:23.643369Z","iopub.status.busy":"2023-10-06T17:19:23.642772Z","iopub.status.idle":"2023-10-06T17:19:23.686387Z","shell.execute_reply":"2023-10-06T17:19:23.685268Z","shell.execute_reply.started":"2023-10-06T17:19:23.643339Z"},"trusted":true},"outputs":[],"source":["\n","from scipy.sparse import csr_matrix\n","from sklearn.neighbors import NearestNeighbors\n","def create_pivot_table(data,defaultval):\n","    #data = pd.merge(movies_df,ratings_df)\n","    return data.pivot_table(index=[\"movieId\"], columns=[\"userId\"], values=\"rating\").fillna(defaultval)\n","\n","def create_knn(pivot_table):\n","    new_knn = NearestNeighbors(metric = 'cosine', algorithm = 'brute')\n","    pivot_matrix = csr_matrix(pivot_table.values) #Required for knn\n","    new_knn.fit(pivot_matrix)\n","    return new_knn\n","\n","#Takes\n","def predict_user_rating_rafael(userId, movieId, pivot_table, k, knn_model):\n","    #Get movie's nearest neighbors\n","    movieId_index = pivot_table.index.get_loc(movieId)\n","    \n","    #print(movieId_index)\n","    #print(pivot_table.iloc[movieId_index,:])\n","    p_distances, p_indices  = knn_model.kneighbors(pivot_table.iloc[movieId_index,:].values.reshape(1,-1), n_neighbors = k+1)\n","    p_indices = p_indices[0][1:]\n","    \n","    \n","    #Get users ratings for those movies\n","    ratings = []\n","    \n","    for index in p_indices:\n","        #print(pivot_table.iloc[index, userId])\n","        userId_index = pivot_table.columns.get_loc(userId)\n","        ratings.append(pivot_table.iloc[index, userId_index])\n","        \n","        \n","    #Average their ratings to find their predicted rating for the target movie\n","    average = sum(ratings)/len(ratings)\n","    return average\n","\n","def predict_user_rating_rafael2(userId, movieId, pivot_table, k, knn_model):\n","    movieId_index = pivot_table.index.get_loc(movieId)\n","    p_distances, p_indices = knn_model.kneighbors(pivot_table.iloc[movieId_index, :].values.reshape(1, -1), n_neighbors=k + 1)\n","    p_indices = p_indices[0][1:]\n","\n","    ratings = []\n","    for index in p_indices:\n","        userId_index = pivot_table.columns.get_loc(userId)\n","        rating = pivot_table.iloc[index, userId_index]\n","        if rating != -1:  # Only consider movies that the user has rated\n","            ratings.append(rating)\n","\n","    if len(ratings) == 0:  # If the user hasn't rated any of the neighbors\n","        return 3.53  # or return a default value or handle it in some other way\n","\n","    average = sum(ratings) / len(ratings)\n","    return average\n","#Steps:\n","#Initialize pivot_table -> Initialize Knn -> Use prediction Method\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:22:11.693042Z","iopub.status.busy":"2023-10-06T17:22:11.692597Z","iopub.status.idle":"2023-10-06T17:22:12.498030Z","shell.execute_reply":"2023-10-06T17:22:12.497178Z","shell.execute_reply.started":"2023-10-06T17:22:11.693005Z"},"trusted":true},"outputs":[],"source":["test_predictions = []\n","actual_ratings = []\n","test_predictions_knn = []\n","test_predictions_knn2 = []\n","#test_predictions_node2vec = []\n","test_predictions_Sonya = []\n","test_predictions_GNN = []\n","\n","import concurrent.futures\n","def calculate_rmse_for_data_size(data_size, k):\n","    train_data, test_data = load_data(data, data_size)\n","    print(\"Finished loading Data\")\n","    cosine_matrix = cosine_similarity_matrix(train_data)\n","    print(\"Finished cosine matrix\")\n","    #rating_kde = sns.kdeplot(train_data['rating'], cumulative=True, bw_adjust=0.5).get_lines()[0].get_data()\n","    G = makegraph(train_data)\n","    pivot = create_pivot_table(train_data.drop('timestamp', axis=1),3.53)\n","    print(\"Finished pivot table\")\n","    pivot2 = create_pivot_table(train_data.drop('timestamp', axis=1),-1)\n","    print(\"Finished pivot table2\")\n","    knn = create_knn(pivot)\n","    print(\"Finished knn\")\n","    knn2 = create_knn(pivot2)\n","    print(\"Finished knn1\")\n","\n","    def process_row(row):\n","        movie = 'm_' + str(row['movieId'])\n","        results = {}\n","        if G.has_node(movie):\n","            results['actual_ratings'] = row['rating']\n","            results['test_predictions'] = predict_rating(G, row['userId'], movie)\n","            results['test_predictions_knn'] = predict_user_rating_rafael(row['userId'],row['movieId'],pivot,k,knn)\n","            results['test_predictions_knn2'] = predict_user_rating_rafael2(row['userId'],row['movieId'],pivot2,k,knn2)\n","            #results['test_predictions_node2vec'] = predict_rating_node2vec(G_train, row['userId'], row['movieId'])\n","            results['test_predictions_Sonya'] = cosine_based_prediction(cosine_matrix,row['userId'],row['movieId'],train_data)\n","        return results\n","\n","    actual_ratings = []\n","    test_predictions = []\n","    test_predictions_knn = []\n","    test_predictions_knn2 = []\n","    #test_predictions_node2vec = []\n","    test_predictions_Sonya = []\n","\n","    with concurrent.futures.ThreadPoolExecutor() as executor:\n","        futures = [executor.submit(process_row, row) for _, row in test_data.iterrows()]\n","        for future in concurrent.futures.as_completed(futures):\n","            results = future.result()\n","            if results:\n","                actual_ratings.append(results['actual_ratings'])\n","                test_predictions.append(results['test_predictions'])\n","                test_predictions_knn.append(results['test_predictions_knn'])\n","                test_predictions_knn2.append(results['test_predictions_knn2'])\n","                #test_predictions_node2vec.append(results['test_predictions_node2vec'])\n","                test_predictions_Sonya.append(results['test_predictions_Sonya'])\n","\n","\n","    # Calculate RMSE for PPR\n","    rmse_knn = np.sqrt(np.mean((np.array(test_predictions_knn) - np.array(actual_ratings)) ** 2)) \n","    rmse_knn2 = np.sqrt(np.mean((np.array(test_predictions_knn2) - np.array(actual_ratings)) ** 2)) \n","    # Calculate RMSE\n","    default = np.sqrt(np.mean((3.53 - np.array(actual_ratings)) ** 2))\n","    #rmse = np.sqrt(np.mean((np.array(test_predictions) - np.array(actual_ratings)) ** 2)) \n","    #rmse_node2vec = np.sqrt(np.mean((np.array(test_predictions_node2vec) - np.array(actual_ratings)) ** 2))\n","    rmse_sonya = np.sqrt(np.mean((np.array(test_predictions_Sonya) - np.array(actual_ratings)) ** 2))\n","\n","    return {\n","        \"K\": k,\n","        \"default_rmse\": default,\n","        #\"jaccard_rmse\": rmse,\n","        \"knn_rmse\": rmse_knn,\n","        \"knn2_rmse\": rmse_knn2,\n","        \"sonya_rmse\": rmse_sonya\n","    }\n"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Finished loading Data\n","Finished cosine matrix\n","Finished graph\n","Finished pivot table\n","Finished pivot table2\n","Finished knn\n","Finished knn1\n"]},{"name":"stderr","output_type":"stream","text":["/tmp/ipykernel_4635/1956417043.py:8: SettingWithCopyWarning: \n","A value is trying to be set on a copy of a slice from a DataFrame.\n","Try using .loc[row_indexer,col_indexer] = value instead\n","\n","See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n","  genome_scores['relevance'] -= relevance_median\n","/tmp/ipykernel_4635/1956417043.py:16: SettingWithCopyWarning: \n","A value is trying to be set on a copy of a slice from a DataFrame.\n","Try using .loc[row_indexer,col_indexer] = value instead\n","\n","See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n","  genome_scores['relevance'] = np.where(\n","/tmp/ipykernel_4635/1956417043.py:24: SettingWithCopyWarning: \n","A value is trying to be set on a copy of a slice from a DataFrame.\n","Try using .loc[row_indexer,col_indexer] = value instead\n","\n","See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n","  genome_scores['relevance'] = genome_scores['relevance'].apply(lambda x: bins_values[np.abs(bins_values - x).argmin()])\n"]},{"name":"stdout","output_type":"stream","text":["Finished genome\n"]}],"source":["test_predictions = []\n","actual_ratings = []\n","test_predictions_knn = []\n","test_predictions_knn2 = []\n","#test_predictions_node2vec = []\n","test_predictions_Sonya = []\n","test_predictions_GNN = []\n","\n","train_data, test_data, genome_scores = load_data(data, 10**6)\n","print(\"Finished loading Data\")\n","cosine_matrix = cosine_similarity_matrix(train_data)\n","print(\"Finished cosine matrix\")\n","#rating_kde = sns.kdeplot(train_data['rating'], cumulative=True, bw_adjust=0.5).get_lines()[0].get_data()\n","G = makegraph(train_data)\n","print(\"Finished graph\")\n","#nodemodel = load_node2vec(G)\n","#print(\"Finished node2vec\")\n","pivot = create_pivot_table(train_data.drop('timestamp', axis=1),3.53)\n","print(\"Finished pivot table\")\n","pivot2 = create_pivot_table(train_data.drop('timestamp', axis=1),-1)\n","print(\"Finished pivot table2\")\n","knn = create_knn(pivot)\n","print(\"Finished knn\")\n","knn2 = create_knn(pivot2)\n","print(\"Finished knn1\")\n","ratings, genome_scores, bins_values = prepare_data(train_data, genome_scores)\n","print(\"Finished genome\")\n","\n","\n","\n"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[],"source":["import concurrent.futures\n","import dill\n","from functools import partial\n","concurrent.futures.process._dill = dill\n","def process_row(row, G, pivot, k, knn, pivot2, knn2, cosine_matrix, train_data, ratings, genome_scores, bins_values):\n","    movie = 'm_' + str(row['movieId'])\n","    results = {}\n","    try:\n","        if G.has_node(movie):\n","            results['actual_ratings'] = row['rating']\n","            results['test_predictions'] = predict_rating(G, row['userId'], movie)\n","            results['test_predictions_knn'] = predict_user_rating_rafael(row['userId'],row['movieId'],pivot,k,knn)\n","            results['test_predictions_knn2'] = predict_user_rating_rafael2(row['userId'],row['movieId'],pivot2,k,knn2)\n","            #results['test_predictions_node2vec'] = predict_rating_node2vec(nodemodel, row['userId'], movie)\n","            results['test_predictions_Sonya'] = cosine_based_prediction(cosine_matrix,row['userId'],row['movieId'],train_data)\n","            results['test_predictions_bayes'] = predict_rating_for_movie(row['userId'], row['movieId'], ratings, genome_scores, bins_values)\n","    except KeyError:\n","        print(\"missing movie\")\n","    return results\n","\n","def calculate_rmse_for_data_size(data_size, k, knn, knn2):\n","    # Convert DataFrame to list of dictionaries for faster iteration\n","    test_data_list = test_data.to_dict('records')\n","\n","    # Use a partial function to pass additional arguments to process_row\n","    process_func = partial(process_row, G=G, pivot=pivot, k=k, knn=knn, pivot2=pivot2, knn2=knn2, cosine_matrix=cosine_matrix, train_data=train_data, ratings=ratings, genome_scores=genome_scores, bins_values=bins_values)\n","\n","    with concurrent.futures.ProcessPoolExecutor() as executor:\n","        results_list = list(executor.map(process_func, test_data_list))\n","\n","    # Extract results\n","    actual_ratings = [res['actual_ratings'] for res in results_list]\n","    test_predictions = [res['test_predictions'] for res in results_list]\n","    test_predictions_knn = [res['test_predictions_knn'] for res in results_list]\n","    test_predictions_knn2 = [res['test_predictions_knn2'] for res in results_list]\n","    #test_predictions_node2vec = [res['test_predictions_node2vec'] for res in results_list]\n","    test_predictions_Sonya = [res['test_predictions_Sonya'] for res in results_list]\n","    test_predictions_bayes = [res['test_predictions_bayes'] for res in results_list]\n","\n","   \n","    knn = np.array(test_predictions_knn) - np.array(actual_ratings)\n","    knn2 = np.array(test_predictions_knn2) - np.array(actual_ratings)\n","    \n","    default = 3.53 - np.array(actual_ratings)\n","    jaccards = np.array(test_predictions) - np.array(actual_ratings)\n","    #node2vec = np.array(test_predictions_node2vec) - np.array(actual_ratings)\n","    cosine_similarity = np.array(test_predictions_Sonya) - np.array(actual_ratings)\n","    bayes = np.array(test_predictions_bayes) - np.array(actual_ratings)\n","    \n","    rmse_knn = np.sqrt(np.mean(knn**2))\n","    rmse_knn2 = np.sqrt(np.mean(knn2**2))\n","    rmse_default = np.sqrt(np.mean(default**2))\n","    rmse_jaccards = np.sqrt(np.mean(jaccards**2))\n","    #rmse_node2vec = np.sqrt(np.mean(node2vec**2))\n","    rmse_cosine_similarity = np.sqrt(np.mean(cosine_similarity**2))\n","    rmse_bayes = np.sqrt(np.mean(bayes**2))\n","\n","    # Collect RMSE values and method names\n","    methods = ['KNN', 'KNN2', 'Default', 'Jaccards', 'Node2Vec', 'Cosine Similarity', 'Bayes']\n","    rmse_values = [rmse_knn, rmse_knn2, rmse_default, rmse_jaccards, rmse_cosine_similarity, rmse_bayes]\n","\n","    # Plotting\n","    import matplotlib.pyplot as plt\n","\n","    # Assuming you want standard deviation as error bars\n","    std_devs = [np.std(knn), np.std(knn2), np.std(default), np.std(jaccards), np.std(cosine_similarity), np.std(bayes)]\n","\n","    plt.bar(methods, rmse_values, yerr=std_devs, capsize=10)\n","    plt.ylabel('RMSE')\n","    plt.title('RMSE of Different Methods with Error Bars')\n","    plt.xticks(rotation=45)\n","    plt.tight_layout()\n","    plt.show()\n","    df = pd.DataFrame({\n","        'actual_ratings': actual_ratings,\n","        'knn_diff': knn,\n","        'knn2_diff': knn2,\n","        'default_diff': default,\n","        'jaccards_diff': jaccards,\n","        'cosine_similarity_diff': cosine_similarity,\n","        'bayes_diff': bayes\n","    })\n","\n","    # Save the DataFrame to a CSV file\n","    df.to_csv('raw_data_differences2.csv', index=False)"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-10-06T17:19:54.207731Z","iopub.status.busy":"2023-10-06T17:19:54.207327Z","iopub.status.idle":"2023-10-06T17:19:54.213533Z","shell.execute_reply":"2023-10-06T17:19:54.212698Z","shell.execute_reply.started":"2023-10-06T17:19:54.207697Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n","Processing data size: 1000000\n"]}],"source":["log_points = np.logspace(np.log10(1), np.log10(500), 15)\n","ks = [int(point) for point in log_points] # Adjust the step size as needed\n","data_size = 10**6\n","results = []\n","for k in ks:\n","    print(f\"Processing data size: {data_size}\")\n","    result = calculate_rmse_for_data_size(data_size,k)\n","    results.append(result)\n","\n","# Convert results to DataFrame and save to CSV\n","df = pd.DataFrame(results)\n","df.to_csv(\"rmse_results.csv\", index=False)"]},{"cell_type":"code","execution_count":10,"metadata":{},"outputs":[],"source":["calculate_rmse_for_data_size(10**5,50,knn,knn2)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1000x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import pandas as pd\n","import matplotlib.pyplot as plt\n","\n","data = [\n","    {'data_size': 100000, 'default_rmse': 1.0409231876661615, 'jaccard_rmse': 0.958323759459673, 'knn_rmse': 1.028443732732137, 'knn2_rmse': 1.0211321621439473, 'sonya_rmse': 1.2602853202029642},\n","    {'data_size': 146002, 'default_rmse': 1.115569587976464, 'jaccard_rmse': 0.9957294301603007, 'knn_rmse': 1.1086767026049011, 'knn2_rmse': 1.0635798314991034, 'sonya_rmse': 1.2923124628092757},\n","    {'data_size': 213166, 'default_rmse': 1.042443473721447, 'jaccard_rmse': 0.9539865756218018, 'knn_rmse': 1.0377975763877625, 'knn2_rmse': 1.001007958384412, 'sonya_rmse': 1.2707660746110012},\n","    {'data_size': 311228, 'default_rmse': 1.0841523572116154, 'jaccard_rmse': 1.0009174751550534, 'knn_rmse': 1.0798435855159854, 'knn2_rmse': 1.0406309697008735, 'sonya_rmse': 1.3011450043471011},\n","    {'data_size': 454400, 'default_rmse': 1.0516670066541332, 'jaccard_rmse': 0.9705116692397364, 'knn_rmse': 1.0484517308571042, 'knn2_rmse': 1.0254368746495934, 'sonya_rmse': 1.2836354320368133},\n","    {'data_size': 663435, 'default_rmse': 1.0803028256055511, 'jaccard_rmse': 0.9798151849148711, 'knn_rmse': 1.0764215613679324, 'knn2_rmse': 1.0217775563066682, 'sonya_rmse': 1.3009677193546045},\n","    {'data_size': 968630, 'default_rmse': 1.0664912581647152, 'jaccard_rmse': 0.9728303848262069, 'knn_rmse': 1.0619990551671377, 'knn2_rmse': 0.9989001672801774, 'sonya_rmse': 1.2939853548055162},\n","    {'data_size': 1414222, 'default_rmse': 1.0713509216498267, 'jaccard_rmse': 0.9667747863700861, 'knn_rmse': 1.0679252474148946, 'knn2_rmse': 1.0086180267260354, 'sonya_rmse': 1.2652338056322132},\n","    {'data_size': 2064797, 'default_rmse': 1.074405815450433, 'jaccard_rmse': 0.9722796103833918, 'knn_rmse': 1.0712785602161756, 'knn2_rmse': 1.0099330842270393, 'sonya_rmse': 1.2676073644153178}\n","]\n","\n","# Convert the data to a DataFrame\n","df = pd.DataFrame(data)\n","\n","# Plot the data\n","plt.figure(figsize=(10, 6))\n","for column in df.columns:\n","    if column != \"data_size\":\n","        plt.plot(df[\"data_size\"], df[column], label=column)\n","\n","plt.xlabel('Data Size')\n","plt.ylabel('RMSE')\n","plt.title('RMSE vs Data Size')\n","plt.legend()\n","plt.grid(True)\n","\n","# Save the plot as an image\n","plt.savefig(\"data.png\")\n","plt.show()\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1000x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import matplotlib.pyplot as plt\n","\n","# Assuming you've already run your previous code and have the df DataFrame\n","# If you're running this separately, you can load the DataFrame from the CSV:\n","df = pd.read_csv(\"rmse_results.csv\")\n","\n","# Plot the data\n","plt.figure(figsize=(10, 6))\n","\n","# Plotting each RMSE against K\n","for column in df.columns:\n","    if column != \"K\":\n","        plt.plot(df[\"K\"], df[column], label=column)\n","\n","plt.xscale(\"log\")  # Since you used a logspace for K values\n","plt.xlabel('K')\n","plt.ylabel('RMSE')\n","plt.title('RMSE vs K with a datasize of 10^5')\n","plt.legend()\n","plt.grid(True)\n","\n","# Show the plot\n","plt.show()"]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.12"}},"nbformat":4,"nbformat_minor":4}