recnexteval 0.1.0__py3-none-any.whl

recnexteval/algorithms/baseline/random.py

@@ -0,0 +1,39 @@
+from typing import Self
+
+import numpy as np
+import pandas as pd
+from scipy.sparse import csr_matrix
+
+from ...matrix import PredictionMatrix
+from ..base import TopKAlgorithm
+from ..utils import get_top_K_values
+
+
+class Random(TopKAlgorithm):
+    """Random recommendation for users.
+
+    The Random algorithm recommends K random items to all users in the predict frame.
+    """
+    IS_BASE: bool = False
+
+    def _fit(self, X: csr_matrix) -> Self:  # noqa: ARG002
+        self.fit_complete_ = True
+        return self
+
+    def _predict(self, X: PredictionMatrix) -> csr_matrix:
+        predict_ui_df = X.get_prediction_data()._df  # noqa: SLF001
+
+        known_item_id = X.max_known_item_id
+        intended_shape = (X.max_global_user_id, known_item_id)
+
+        to_predict = pd.Series(predict_ui_df.uid.unique())
+        to_predict = to_predict.sort_values(ignore_index=True)
+        row = to_predict.values.repeat(self.K)
+        total_items_to_predict = len(row)
+        col = self.rand_gen.integers(0, known_item_id, total_items_to_predict)
+        scores = csr_matrix((np.ones(total_items_to_predict), (row, col)), shape=intended_shape)
+
+        # Get top K of allowed items per user
+        X_pred = get_top_K_values(scores, K=self.K)
+        X_pred = X_pred[predict_ui_df["uid"].values]
+        return X_pred

recnexteval/algorithms/baseline/recent_popularity.py

@@ -0,0 +1,34 @@
+
+import logging
+from typing import Self
+
+import numpy as np
+from scipy.sparse import csr_matrix
+
+from ...matrix import PredictionMatrix
+from ..base import PopularityPaddingMixin, TopKAlgorithm
+
+
+logger = logging.getLogger(__name__)
+
+
+class RecentPopularity(TopKAlgorithm, PopularityPaddingMixin):
+    """A popularity-based algorithm which only considers popularity of the latest train data."""
+
+    IS_BASE: bool = False
+
+    def _fit(self, X: csr_matrix) -> Self:
+        self.sorted_scores_ = self.get_popularity_scores(X)
+        return self
+
+    def _predict(self, X: PredictionMatrix) -> csr_matrix:
+        """
+        Predict the K most popular item for each user using only data from the latest window.
+        """
+        intended_shape = (X.get_prediction_data().num_interactions, X.user_item_shape[1])
+
+        # Vectorized: repeat the sorted scores for each prediction row
+        data = np.tile(self.sorted_scores_, (intended_shape[0], 1))
+        X_pred = csr_matrix(data)
+
+        return X_pred

recnexteval/algorithms/itemknn/__init__.py

@@ -0,0 +1,14 @@
+from .itemknn import ItemKNN
+from .itemknn_incremental import ItemKNNIncremental
+from .itemknn_incremental_movielens import ItemKNNIncrementalMovieLens100K
+from .itemknn_rolling import ItemKNNRolling
+from .itemknn_static import ItemKNNStatic
+
+
+__all__ = [
+    "ItemKNN",
+    "ItemKNNIncremental",
+    "ItemKNNIncrementalMovieLens100K",
+    "ItemKNNRolling",
+    "ItemKNNStatic",
+]

recnexteval/algorithms/itemknn/itemknn.py

@@ -0,0 +1,119 @@
+import logging
+from typing import Self
+
+from scipy.sparse import csr_matrix
+from sklearn.metrics.pairwise import cosine_similarity
+
+from recnexteval.matrix import ItemUserBasedEnum, PredictionMatrix
+from ..base import PopularityPaddingMixin, TopKItemSimilarityMatrixAlgorithm
+from ..utils import get_top_K_values
+
+
+logger = logging.getLogger(__name__)
+
+
+def compute_cosine_similarity(X: csr_matrix) -> csr_matrix:
+    """Compute the cosine similarity between the items in the matrix.
+
+    Self similarity is removed.
+
+    :param X: user x item matrix with scores per user, item pair.
+    :type X: csr_matrix
+    :return: similarity matrix
+    :rtype: csr_matrix
+    """
+    # X.T otherwise we are doing a user KNN
+    item_cosine_similarities = cosine_similarity(X.T, dense_output=False)
+    if not isinstance(item_cosine_similarities, csr_matrix):
+        item_cosine_similarities = csr_matrix(item_cosine_similarities)
+    # Set diagonal to 0, because we don't want to support self similarity
+    item_cosine_similarities.setdiag(0)
+
+    return item_cosine_similarities
+
+
+class ItemKNN(TopKItemSimilarityMatrixAlgorithm, PopularityPaddingMixin):
+    """Item K Nearest Neighbours model.
+
+    First described in 'Item-based top-n recommendation algorithms.' :cite:`10.1145/963770.963776`
+
+    This code is adapted from RecPack :cite:`recpack`
+
+    For each item the K most similar items are computed during fit.
+    Similarity parameter decides how to compute the similarity between two items.
+
+    Cosine similarity between item i and j is computed as
+
+    .. math::
+        sim(i,j) = \\frac{X_i X_j}{||X_i||_2 ||X_j||_2}
+
+    :param K: How many neigbours to use per item,
+        make sure to pick a value below the number of columns of the matrix to fit on.
+        Defaults to 200
+    :type K: int, optional
+    """
+
+    ITEM_USER_BASED = ItemUserBasedEnum.ITEM
+
+    def _fit(self, X: csr_matrix) -> Self:
+        """Fit a cosine similarity matrix from item to item
+        We assume that X is a binary matrix of shape (n_users, n_items)
+        """
+        item_similarities = compute_cosine_similarity(X)
+        item_similarities = get_top_K_values(item_similarities, K=self.K)
+
+        self.similarity_matrix_ = item_similarities
+        self.X_ = X.copy()
+        return self
+
+    def _predict(self, X: PredictionMatrix) -> csr_matrix:
+        predict_ui_df = X.get_prediction_data()._df  # noqa: SLF001
+
+        # create a boolean series that is true for index in predict_ui_df.uid
+        uid_to_predict = predict_ui_df[predict_ui_df.uid < self.X_.shape[0]].uid.unique()
+        uid_to_predict = sorted(uid_to_predict.tolist())
+
+        # features: csr_matrix = self.X_[uid_to_predict]
+        # we try without any filtering on the feature matrix
+        features: csr_matrix = self.X_
+        scores = features @ self.similarity_matrix_
+
+        if not isinstance(scores, csr_matrix):
+            scores = csr_matrix(scores)
+
+        intended_shape = (X.max_global_user_id, X.max_global_item_id)
+
+        if scores.shape == intended_shape:
+            return scores
+
+        # there are 2 cases where the shape is different:
+        # 1. The algorithm did not predict unknown user, causing shortage in rows
+        # 2. The algorithm not aware of unknown items, causing shortage in columns
+
+        # handle case 1
+        if scores.shape[1] < intended_shape[1]:
+            scores = self._pad_unknown_iid_with_none_strategy(
+                y_pred=scores,
+                current_shape=scores.shape,
+                intended_shape=intended_shape,
+            )
+
+        # handle case 2
+        if self.pad_with_popularity:
+            scores = self._pad_uknown_uid_with_popularity_strategy(
+                X_pred=scores,
+                intended_shape=intended_shape,
+                predict_ui_df=predict_ui_df,
+            )
+        else:
+            # current_shape = (X.max_known_user_id, X.max_known_item_id)
+            scores = self._pad_unknown_uid_with_random_strategy(
+                X_pred=scores,
+                current_shape=scores.shape,
+                # current_shape=current_shape,
+                intended_shape=intended_shape,
+                predict_ui_df=predict_ui_df,
+            )
+
+        pred = scores[predict_ui_df["uid"].values]
+        return pred

recnexteval/algorithms/itemknn/itemknn_incremental.py

@@ -0,0 +1,65 @@
+import logging
+from typing import Self
+
+from scipy.sparse import csr_matrix, hstack, vstack
+
+from ..base import PopularityPaddingMixin, TopKItemSimilarityMatrixAlgorithm
+from .itemknn import ItemKNN
+
+
+logger = logging.getLogger(__name__)
+
+
+class ItemKNNIncremental(ItemKNN):
+    """Incremental version of ItemKNN algorithm.
+
+    This class extends the ItemKNN algorithm to allow for incremental updates
+    to the model. The incremental updates are done by updating the historical
+    data with the new data by appending the new data to the historical data.
+    """
+
+    IS_BASE: bool = False
+
+    def __init__(self, K: int = 10, pad_with_popularity: bool = True) -> None:
+        PopularityPaddingMixin.__init__(self, pad_with_popularity=pad_with_popularity)
+        TopKItemSimilarityMatrixAlgorithm.__init__(self, K=K)
+        self.X_: None | csr_matrix = None
+
+    def _append_training_data(self, X: csr_matrix) -> None:
+        """Append a new interaction matrix to the historical data.
+
+        Args:
+            X (csr_matrix): Interaction matrix to append
+        """
+        if self.X_ is None:
+            raise ValueError("No existing training data to append to.")
+        X_prev: csr_matrix = self.X_.copy()
+        new_num_rows = max(X_prev.shape[0], X.shape[0])
+        new_num_cols = max(X_prev.shape[1], X.shape[1])
+        # Pad the previous matrix
+        if X_prev.shape[0] < new_num_rows:  # Pad rows
+            row_padding = csr_matrix((new_num_rows - X_prev.shape[0], X_prev.shape[1]))
+            X_prev = vstack([X_prev, row_padding])
+        if X_prev.shape[1] < new_num_cols:  # Pad columns
+            col_padding = csr_matrix((X_prev.shape[0], new_num_cols - X_prev.shape[1]))
+            X_prev = hstack([X_prev, col_padding])
+
+        # Pad the current matrix
+        if X.shape[0] < new_num_rows:  # Pad rows
+            row_padding = csr_matrix((new_num_rows - X.shape[0], X.shape[1]))
+            X = vstack([X, row_padding])
+        if X.shape[1] < new_num_cols:  # Pad columns
+            col_padding = csr_matrix((X.shape[0], new_num_cols - X.shape[1]))
+            X = hstack([X, col_padding])
+
+        # Merge data
+        self.X_ = X_prev + X
+
+    def _fit(self, X: csr_matrix) -> Self:
+        """Fit a cosine similarity matrix from item to item."""
+        if self.X_ is not None:
+            self._append_training_data(X)
+            super()._fit(self.X_)
+        else:
+            super()._fit(X)
+        return self

recnexteval/algorithms/itemknn/itemknn_incremental_movielens.py

@@ -0,0 +1,95 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from scipy.sparse import csr_matrix
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import OneHotEncoder
+
+from ...matrix import InteractionMatrix
+from ...utils import add_rows_to_csr_matrix
+from .itemknn_incremental import ItemKNNIncremental
+
+
+logger = logging.getLogger(__name__)
+
+
+class ItemKNNIncrementalMovieLens100K(ItemKNNIncremental):
+    """Incremental version of ItemKNN algorithm with MovieLens100k Metadata.
+
+    This class extends the ItemKNN algorithm to allow for incremental updates
+    to the model. The incremental updates are done by updating the historical
+    data with the new data by appending the new data to the historical data.
+    """
+    IS_BASE: bool = False
+
+    def __init__(self, metadata: pd.DataFrame, K:int=10) -> None:
+        super().__init__(K)
+        if metadata is None:
+            raise ValueError("Metadata is required for ItemKNNIncrementalMovieLens100K")
+        self.metadata = metadata.copy()
+
+    def _predict(self, X: csr_matrix, predict_im: InteractionMatrix) -> csr_matrix:
+        """Predict the K most similar items for each item using the latest data."""
+        X_pred = super()._predict(self.X_)
+        # ID indexing starts at 0, so max_id + 1 is the number of unique IDs
+        max_user_id = predict_im.max_user_id + 1
+        max_item_id = predict_im.max_item_id + 1
+        intended_shape = (
+            max(max_user_id, X.shape[0]),
+            max(max_item_id, X.shape[1]),
+        )
+
+        predict_frame = predict_im._df
+
+        if X_pred.shape == intended_shape:
+            return X_pred
+
+        known_user_id, known_item_id = X_pred.shape
+        X_pred = add_rows_to_csr_matrix(X_pred, intended_shape[0] - known_user_id)
+        logger.debug(f"Padding user ID in range({known_user_id}, {intended_shape[0]}) with items")
+        to_predict = predict_frame.value_counts("uid")
+
+        # pad users with items from most similar user
+        user_similarity_matrix = self.get_user_similarity_matrix()
+        for user_id in to_predict.index:
+            if user_id >= known_user_id:
+                most_similar_user_idx = np.argmax(user_similarity_matrix[user_id][:known_user_id])
+                X_pred[user_id, :] = X_pred[most_similar_user_idx, :]
+
+        logger.debug(f"Padding by {self.name} completed")
+        return X_pred
+
+    def get_user_similarity_matrix(self):
+        user_metadata = self.metadata.copy()
+
+        # set userId as index
+        user_metadata.set_index("userId", inplace=True)
+        user_metadata.index.name = None
+
+        # reorder the indices
+        user_metadata.reset_index(drop=True)
+        user_metadata.sort_index(inplace=True)
+
+        # zipcode is a column that does not provide any useful information so we drop it
+        user_metadata = user_metadata.drop(columns=["zipcode"])
+
+        # obtain categorical columns
+        categorical_columns = user_metadata.select_dtypes(include=["object"]).columns.tolist()
+
+        # Use one-hot encoding to encode the categorical columns
+        encoder = OneHotEncoder(sparse_output=False)
+        one_hot_encoded = encoder.fit_transform(user_metadata[categorical_columns])
+
+        # obtain the column names for the encoded data
+        one_hot_df = pd.DataFrame(one_hot_encoded, columns=encoder.get_feature_names_out(categorical_columns))
+
+        # Concatenate the one-hot encoded dataframe with the original dataframe and drop the original categorical columns
+        df_encoded = pd.concat([user_metadata, one_hot_df], axis=1)
+        df_encoded = df_encoded.drop(categorical_columns, axis=1)
+
+        # compute cosine similarity but exclude self-similarity
+        user_similarity_matrix = cosine_similarity(df_encoded)
+        np.fill_diagonal(user_similarity_matrix, 0)
+
+        return user_similarity_matrix

recnexteval/algorithms/itemknn/itemknn_rolling.py

@@ -0,0 +1,17 @@
+import logging
+
+from .itemknn import ItemKNN
+
+
+logger = logging.getLogger(__name__)
+
+
+class ItemKNNRolling(ItemKNN):
+    """Rolling version of ItemKNN algorithm.
+
+    This class extends the ItemKNN algorithm to update the memory of the model
+    to only keep the last window of interactions. The model is simply discarding
+    all interactions that are older than the window size.
+    """
+
+    IS_BASE: bool = False

recnexteval/algorithms/itemknn/itemknn_static.py

@@ -0,0 +1,31 @@
+import logging
+from typing import Self
+
+from recnexteval.matrix import InteractionMatrix
+from .itemknn import ItemKNN
+
+
+logger = logging.getLogger(__name__)
+
+
+class ItemKNNStatic(ItemKNN):
+    """Static version of ItemKNN algorithm.
+
+    This class extends the ItemKNN algorithm to only fit the model once. `fit` will only
+    fit the model once and will not update the model with new data. The purpose
+    is to make the training data static and not update the model with new data.
+    """
+
+    IS_BASE: bool = False
+
+    def __init__(self, K: int = 10) -> None:
+        self._is_fitted = False
+        super().__init__(K)
+
+    def fit(self, X: InteractionMatrix) -> Self:
+        if self._is_fitted:
+            return self
+
+        super().fit(X)
+        self._is_fitted = True
+        return self

recnexteval/algorithms/time_aware_item_knn/__init__.py

@@ -0,0 +1,11 @@
+# RecPack, An Experimentation Toolkit for Top-N Recommendation
+# Copyright (C) 2020  Froomle N.V.
+# License: GNU AGPLv3 - https://gitlab.com/recpack-maintainers/recpack/-/blob/master/LICENSE
+# Author:
+#   Lien Michiels
+#   Robin Verachtert
+
+from recnexteval.algorithms.time_aware_item_knn.base import TARSItemKNN
+from recnexteval.algorithms.time_aware_item_knn.ding_2005 import TARSItemKNNDing
+from recnexteval.algorithms.time_aware_item_knn.liu_2010 import TARSItemKNNLiu
+from recnexteval.algorithms.time_aware_item_knn.vaz_2013 import TARSItemKNNVaz

recnexteval/algorithms/time_aware_item_knn/base.py

@@ -0,0 +1,248 @@
+# RecPack, An Experimentation Toolkit for Top-N Recommendation
+# Copyright (C) 2020  Froomle N.V.
+# License: GNU AGPLv3 - https://gitlab.com/recpack-maintainers/recpack/-/blob/master/LICENSE
+# Author:
+#   Lien Michiels
+#   Robin Verachtert
+
+import logging
+
+import numpy as np
+from scipy.sparse import csr_matrix
+
+from recnexteval.algorithms.base import TopKItemSimilarityMatrixAlgorithm, PopularityPaddingMixin
+from recnexteval.matrix import InteractionMatrix
+from recnexteval.utils.util import add_rows_to_csr_matrix
+from .decay_functions import (
+    ConcaveDecay,
+    ConvexDecay,
+    ExponentialDecay,
+    InverseDecay,
+    LinearDecay,
+    LogDecay,
+    NoDecay,
+)
+from .similarity_functions import (
+    compute_conditional_probability,
+    compute_cosine_similarity,
+    compute_pearson_similarity,
+)
+from .top_k import get_top_K_values
+
+
+EPSILON = 1e-13
+
+logger = logging.getLogger(__name__)
+
+
+class TARSItemKNN(TopKItemSimilarityMatrixAlgorithm, PopularityPaddingMixin):
+    """Framework for time aware variants of the ItemKNN algorithm.
+
+    This class was inspired by works from Liu, Nathan N., et al. (2010), Ding et al. (2005) and Lee et al. (2007).
+
+    The framework for these approaches can be summarised as:
+
+    - When training the user interaction matrix is weighted to take into account temporal information.
+    - Similarities are computed on this weighted matrix, using various similarity measures.
+    - When predicting the interactions are similarly weighted, giving more weight to more recent interactions.
+    - Recommendation scores are obtained by multiplying the weighted interaction matrix with
+      the previously computed similarity matrix.
+
+    The similarity between items is based on their decayed interaction vectors:
+
+    .. math::
+
+        \\text{sim}(i,j) = s(\\Gamma(A_i), \\Gamma(A_j))
+
+    Where :math:`s` is a similarity function (like ``cosine``),
+    :math:`\\Gamma` a decay function (like ``exponential_decay``) and
+    :math:`A_i` contains the distances to now from when the users interacted with item `i`,
+    if they interacted with the item at all (else the value is 0).
+
+    During computation, 'now' is considered as the maximal timestamp in the matrix + 1.
+    As such the age is always a positive non-zero value.
+
+    :param K: How many neigbours to use per item,
+        make sure to pick a value below the number of columns of the matrix to fit on.
+        Defaults to 200
+    :type K: int, Optional
+    :param pad_with_popularity: Whether to pad the similarity matrix with RecentPop Algorithm.
+        Defaults to True.
+    :type pad_with_popularity: bool, optional
+    :param fit_decay: Defines the decay scaling used for decay during model fitting.
+        Defaults to `` 1 / (24 * 3600)`` (one day).
+    :type fit_decay: float, optional
+    :param predict_decay: Defines the decay scaling used for decay during prediction.
+        Defaults to ``1 / (24 * 3600)`` (one day).
+    :type predict_decay: float, optional
+    :param decay_interval: Size of a single time unit in seconds.
+        Allows more finegrained parameters for large scale datasets where events are collected over months of data.
+        Defaults to 1 (second).
+    :type decay_interval: int, optional
+    :param similarity: Which similarity measure to use. Defaults to ``"cosine"``.
+        ``["cosine", "conditional_probability", "pearson"]`` are supported.
+    :type similarity: str, Optional
+    :param decay_function: The decay function to use, defaults to ``"exponential"``.
+        Supported values are ``["exponential", "log", "linear", "concave", "convex", "inverse"]``
+
+    This code is adapted from RecPack :cite:`recpack`
+    """
+
+    SUPPORTED_SIMILARITIES = ["cosine", "conditional_probability", "pearson"]
+    DECAY_FUNCTIONS = {
+        "exponential": ExponentialDecay,
+        "log": LogDecay,
+        "linear": LinearDecay,
+        "concave": ConcaveDecay,
+        "convex": ConvexDecay,
+        "inverse": InverseDecay,
+    }
+
+    def __init__(
+        self,
+        K: int = 200,
+        pad_with_popularity: bool = True,
+        fit_decay: float = 1 / (24 * 3600),
+        predict_decay: float = 1 / (24 * 3600),
+        decay_interval: int = 1,
+        similarity: str = "cosine",
+        decay_function: str = "exponential",
+    ):
+        # Uses other default parameters for ItemKNN
+        super().__init__(K=K)
+        self.training_data: InteractionMatrix = None
+        self.pad_with_popularity = pad_with_popularity
+
+        if decay_interval <= 0 or type(decay_interval) == float:
+            raise ValueError("Parameter decay_interval needs to be a positive integer.")
+
+        self.decay_interval = decay_interval
+
+        if similarity not in self.SUPPORTED_SIMILARITIES:
+            raise ValueError(f"Similarity {similarity} is not supported.")
+        self.similarity = similarity
+
+        if decay_function not in self.DECAY_FUNCTIONS:
+            raise ValueError(f"Decay function {decay_function} is not supported.")
+
+        self.decay_function = decay_function
+
+        # Verify decay parameters
+        if self.decay_function in ["exponential", "log", "linear", "concave", "convex"]:
+            if fit_decay != 0:
+                self.DECAY_FUNCTIONS[decay_function].validate_decay(fit_decay)
+
+            if predict_decay != 0:
+                self.DECAY_FUNCTIONS[decay_function].validate_decay(predict_decay)
+
+        self.fit_decay = fit_decay
+        self.predict_decay = predict_decay
+        self.decay_function = decay_function
+
+    def _get_decay_func(self, decay, max_value):
+        if decay == 0:
+            return NoDecay()
+
+        elif self.decay_function == "inverse":
+            return self.DECAY_FUNCTIONS[self.decay_function]()
+        elif self.decay_function in ["exponential", "convex"]:
+            return self.DECAY_FUNCTIONS[self.decay_function](decay)
+        elif self.decay_function in ["log", "linear", "concave"]:
+            return self.DECAY_FUNCTIONS[self.decay_function](decay, max_value)
+
+    def _predict(self, X: csr_matrix, predict_im: InteractionMatrix) -> csr_matrix:
+        """Predict scores for nonzero users in X.
+
+        Scores are computed by matrix multiplication of weighted X
+        with the stored similarity matrix.
+
+        :param X: csr_matrix with interactions
+        :type X: csr_matrix
+        :return: csr_matrix with scores
+        :rtype: csr_matrix
+        """
+        X_decay = self._add_decay_to_predict_matrix(self.training_data)
+        X_pred = super()._predict(X_decay)
+
+        # ID indexing starts at 0, so max_id + 1 is the number of unique IDs
+        max_user_id = predict_im.max_user_id + 1
+        max_item_id = predict_im.max_item_id + 1
+        intended_shape = (
+            max(max_user_id, X.shape[0]),
+            max(max_item_id, X.shape[1]),
+        )
+
+        predict_frame = predict_im._df
+
+        if X_pred.shape == intended_shape:
+            return X_pred
+
+        known_user_id, known_item_id = X_pred.shape
+        X_pred = add_rows_to_csr_matrix(X_pred, intended_shape[0] - known_user_id)
+        logger.debug(f"Padding user ID in range({known_user_id}, {intended_shape[0]}) with items")
+        to_predict = predict_frame.value_counts("uid")
+
+        if self.pad_with_popularity:
+            popular_items = self.get_popularity_scores(super()._transform_fit_input(X))
+            for user_id in to_predict.index:
+                if user_id >= known_user_id:
+                    X_pred[user_id, :] = popular_items
+        else:
+            row = []
+            col = []
+            for user_id in to_predict.index:
+                if user_id >= known_user_id:
+                    row += [user_id] * to_predict[user_id]
+                    col += self.rand_gen.integers(0, known_item_id, to_predict[user_id]).tolist()
+            pad = csr_matrix((np.ones(len(row)), (row, col)), shape=intended_shape)
+            X_pred += pad
+
+        logger.debug(f"Padding by {self.name} completed")
+        return X_pred
+
+    def _fit(self, X: csr_matrix) -> "TARSItemKNN":
+        """Fit a cosine similarity matrix from item to item."""
+
+        if self.training_data is None:
+            self.training_data = X.copy()
+        else:
+            self.training_data = self.training_data.union(X)
+        X = self.training_data.copy()
+
+        X = self._add_decay_to_fit_matrix(X)
+        if self.similarity == "cosine":
+            item_similarities = compute_cosine_similarity(X)
+        elif self.similarity == "conditional_probability":
+            item_similarities = compute_conditional_probability(X)
+        elif self.similarity == "pearson":
+            item_similarities = compute_pearson_similarity(X)
+
+        item_similarities = get_top_K_values(item_similarities, K=self.K)
+
+        self.similarity_matrix_ = item_similarities
+
+        return self
+
+    def _add_decay_to_interaction_matrix(self, X: InteractionMatrix, decay: float) -> csr_matrix:
+        """Weigh the interaction matrix based on age of the events.
+
+        If decay is 0, it is assumed to be disabled, and so we just return binary matrix.
+        :param X: Interaction matrix.
+        :type X: InteractionMatrix
+        :return: Weighted csr matrix.
+        :rtype: csr_matrix
+        """
+        timestamp_mat = X.latest_interaction_timestamps_matrix
+
+        # To get 'now', we add 1 to the maximal timestamp. This makes sure there are no vanishing zeroes.
+        now = timestamp_mat.data.max() + 1
+        ages = (now - timestamp_mat.data) / self.decay_interval
+        timestamp_mat.data = self._get_decay_func(decay, ages.max())(ages)
+
+        return csr_matrix(timestamp_mat)
+
+    def _add_decay_to_fit_matrix(self, X: InteractionMatrix) -> csr_matrix:
+        return self._add_decay_to_interaction_matrix(X, self.fit_decay)
+
+    def _add_decay_to_predict_matrix(self, X: InteractionMatrix) -> csr_matrix:
+        return self._add_decay_to_interaction_matrix(X, self.predict_decay)