RecSys_Collaborative_Filtering/UserItemMatrix.py at main · apovalov/RecSys_Collaborative_Filtering · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import pandas as pd
from typing import Dict

from scipy.sparse import csr_matrix
# from collections import defaultdict

class UserItemMatrix:
    def __init__(self, sales_data: pd.DataFrame):
        """Class initialization. You can make necessary
        calculations here.

        Args:
            sales_data (pd.DataFrame): Sales dataset.

        Example:
            sales_data (pd.DataFrame):

                user_id  item_id  qty   price
            0        1      118    1   626.66
            1        1      285    1  1016.57
            2        2     1229    3   518.99
            3        4     1688    2   940.84
            4        5     2068    1   571.36
            ...

        """
        self._sales_data = sales_data.copy()

        # # Calculate user and item counts
        # self._user_count = len(self._sales_data['user_id'].unique())
        # self._item_count = len(self._sales_data['item_id'].unique())

        unique_users = list(sorted(self._sales_data['user_id'].unique())) #list of unique users
        unique_items = list(sorted(self._sales_data['item_id'].unique()))

        # unique_users = self._sales_data['user_id'].unique() #list of unique users
        # unique_items = self._sales_data['item_id'].unique()

        # Calculate user and item counts
        self._user_count = len(unique_users)
        self._item_count = len(unique_items)

        # Create user and item maps
        self._user_map = {user_id: idx for idx, user_id in enumerate(unique_users)}
        self._item_map = {item_id: idx for idx, item_id in enumerate(unique_items)}

        # Create sparse matrix
        rows = [self._user_map[user_id] for user_id in self._sales_data['user_id']]
        cols = [self._item_map[item_id] for item_id in self._sales_data['item_id']]
        self._matrix = csr_matrix((self._sales_data['qty'], (rows, cols)), shape=(self._user_count, self._item_count))

    @property
    def user_count(self) -> int:
        """
        Returns:
            int: the number of users in sales_data.
        """
        return self._user_count

    @property
    def item_count(self) -> int:
        """
        Returns:
            int: the number of items in sales_data.
        """
        return self._item_count

    @property
    def user_map(self) -> Dict[int, int]:
        """Creates a mapping from user_id to matrix rows indexes.

        Example:
            sales_data (pd.DataFrame):

                user_id  item_id  qty   price
            0        1      118    1   626.66
            1        1      285    1  1016.57
            2        2     1229    3   518.99
            3        4     1688    2   940.84
            4        5     2068    1   571.36

            user_map (Dict[int, int]):
                {1: 0, 2: 1, 4: 2, 5: 3}

        Returns:
            Dict[int, int]: User map
        """
        return dict(sorted(self._user_map.items()))

    @property
    def item_map(self) -> Dict[int, int]:
        """Creates a mapping from item_id to matrix rows indexes.

        Example:
            sales_data (pd.DataFrame):

                user_id  item_id  qty   price
            0        1      118    1   626.66
            1        1      285    1  1016.57
            2        2     1229    3   518.99
            3        4     1688    2   940.84
            4        5     2068    1   571.36

            item_map (Dict[int, int]):
                {118: 0, 285: 1, 1229: 2, 1688: 3, 2068: 4}

        Returns:
            Dict[int, int]: Item map
        """
        return dict(sorted(self._item_map.items()))

    @property
    def csr_matrix(self) -> csr_matrix:
        """User items matrix in form of CSR matrix.

        User row_ind, col_ind as
        rows and cols indecies(mapped from user/item map).

        Returns:
            csr_matrix: CSR matrix
        """
        return self._matrix


# sales = pd.read_excel('3_8_SKU_EMB_2023_08_15.xlsx')
# sales_df = pd.DataFrame(sales)
# # # print(sales_df.head())

# # unique_users = sales_df['user_id'].unique()
# # item_map = {item_id: idx for idx, item_id in enumerate(unique_users)}

# # print(dict(sorted(item_map.items())))


# itemMatrix = UserItemMatrix(sales_df)
# print(itemMatrix.item_map.keys())