Repository navigation
Expand file tree
/
Copy pathSimilarItems.py
More file actions
149 lines (120 loc) · 4.97 KB
/
Copy pathSimilarItems.py
File metadata and controls
149 lines (120 loc) · 4.97 KB
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
137
138
139
140
141
142
143
144
145
146
147
148
149
import heapq
import numpy as np
from typing import Dict, List, Tuple
from itertools import combinations
from collections import defaultdict
class SimilarItems:
"""Similar items class"""
@staticmethod
def similarity(embeddings: Dict[int, np.ndarray]) -> Dict[Tuple[int, int], float]:
"""Calculate pairwise similarities between each item
in embedding.
Args:
embeddings (Dict[int, np.ndarray]): Items embeddings.
Returns:
Tuple[List[str], Dict[Tuple[int, int], float]]:
List of all items + Pairwise similarities dict
Keys are in form of (i, j) - combinations pairs of item_ids
with i < j.
Round each value to 8 decimal places.
"""
result_dict = {}
keys = list(embeddings)
combs = combinations(keys, 2)
for item1_idx, item2_idx in combs:
embedding_1 = embeddings[item1_idx]
embedding_2 = embeddings[item2_idx]
similarity = np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))
result_dict[(item1_idx, item2_idx)] = round(similarity, 8)
return result_dict
@staticmethod
def knn(
sim: Dict[Tuple[int, int], float], top: int
) -> Dict[int, List[Tuple[int, float]]]:
"""Return closest neighbors for each item.
Args:
sim (Dict[Tuple[int, int], float]): <similarity> method output.
top (int): Number of top neighbors to consider.
Returns:
Dict[int, List[Tuple[int, float]]]: Dict with top closest neighbors
for each item.
"""
knn_dict = defaultdict(list)
for (item_id_1, item_id_2), similarity in sim.items():
heapq.heappush(knn_dict[item_id_1], (item_id_2, similarity)) # Fixed order of item_id and similarity
heapq.heappush(knn_dict[item_id_2], (item_id_1, similarity)) # Fixed order of item_id and similarity
knn_result = {}
for item_id, neighbors in knn_dict.items():
top_neighbors = heapq.nlargest(top, neighbors, key=lambda x: x[1])
knn_result[item_id] = [(neighbor, similarity) for neighbor, similarity in top_neighbors]
return knn_result
@staticmethod
def knn_price(
knn_dict: Dict[int, List[Tuple[int, float]]],
prices: Dict[int, float],
) -> Dict[int, float]:
"""Calculate weighted average prices for each item.
Weights should be positive numbers in [0, 2] interval.
Args:
knn_dict (Dict[int, List[Tuple[int, float]]]): <knn> method output.
prices (Dict[int, float]): Price dict for each item.
Returns:
Dict[int, float]: New prices dict, rounded to 2 decimal places.
"""
knn_price_dict = {}
for item_id, neighbors in knn_dict.items():
total_weight = 0
weighted_price_sum = 0
for neighbor, similarity in neighbors:
weight = similarity + 1 # Calculate weight in [0, 2] interval
total_weight += weight
weighted_price_sum += prices[neighbor] * weight
if total_weight > 0:
knn_price_dict[item_id] = round(weighted_price_sum / total_weight, 2)
else:
knn_price_dict[item_id] = 0
return knn_price_dict
@staticmethod
def transform(
embeddings: Dict[int, np.ndarray],
prices: Dict[int, float],
top: int,
) -> Dict[int, float]:
"""Transforming input embeddings into a dictionary
with weighted average prices for each item.
Args:
embeddings (Dict[int, np.ndarray]): Items embeddings.
prices (Dict[int, float]): Price dict for each item.
top (int): Number of top neighbors to consider.
Returns:
Dict[int, float]: Dict with weighted average prices for each item.
"""
knn_price_dict = {}
# Step 1: Calculate pairwise similarities
sim = SimilarItems.similarity(embeddings)
# Step 2: Find top closest neighbors for each item
knn_dict = SimilarItems.knn(sim, top)
# Step 3: Calculate weighted average prices for each item
knn_price_dict = SimilarItems.knn_price(knn_dict, prices)
return knn_price_dict
# embeddings = {
# 1: np.array([-1, -1, -1, 1]),
# 2: np.array([5, 5, 5, 4]),
# 3: np.array([10, 10, 10, 1]),
# 4: np.array([2, 2, 2, 2])
# }
# prices = {
# 1: 100.5,
# 2: 12.2, #0,49896 = 6,087312
# 3: 60.0,
# 4: 11.1 #0.50103 = 5,561433
# }
# # similarity = SimilarItems.similarity(embeddings=embeddings)
# # print('Similarity: ', similarity)
# # print('*********************')
# # sim = similarity.copy()
# # knn = SimilarItems.knn(sim=sim, top=3)
# # print('*********************')
# # print('KNN\n', knn)
# # print('*********************')
# # print('knn_price: ', SimilarItems.knn_price(knn, prices=prices))