return ease result and the score to be multiplied by cbf

.gitignore

@@ -0,0 +1 @@
+__pycache__

app.py

@@ -33,7 +33,9 @@ def games_recomm(preferences_id):
 
         res = ease_model(pred_df=pred_df, k=10)
         # res = cbf_model(pred_df=pred_df, k=10)
-        
+    
+    # st.write(res[['predicted_items', 'predicted_score']])
+    st.write(res)
     if type(res) == ValueError:
         st.error("Recommendation failed. Please select with at least 3 games title.")
         st.session_state

contentBased_model.py

@@ -57,7 +57,11 @@ class KnnCBF:
 
         return classifier.kneighbors(test)
     
-    def predict_active(self, pred_df, k=10, remove_owned=True):
+    def predict_active(self, pred_df, 
+                    k=10,
+                    weight_hybrid=.3,
+                    hybrid_model=True):
+        
         act_df = pred_df.merge(self.item_lookup, on=[self.item_col], sort=False)
         # active_user = pred_df['user_id'].unique()
         pred_df = pred_df[[self.user_col]].drop_duplicates()
@@ -88,19 +92,23 @@ class KnnCBF:
 
         top_tensor = torch.from_numpy(result).topk(k)
         indices = top_tensor.indices.tolist()
-        score = top_tensor.values.tolist()
+        score = top_tensor.values
 
         _output_preds.append( [self.item_map[_id] for _id in indices] )
-        _score_preds.append( score )
+        if hybrid_model:
+            score = score * weight_hybrid
+
+        _score_preds.append( score.tolist() )
 
         pred_df['predicted_items'] = _output_preds
-        pred_df['relevance_score'] = _score_preds
+        pred_df['predicted_score'] = _score_preds
 
-        escaped = [
-            ele for i_list in pred_df['predicted_items'].values for ele in i_list
-        ]
+        # escaped = [
+        #     ele for i_list in pred_df['predicted_items'].values for ele in i_list
+        # ]
         
-        return escaped
+        return pred_df
+        # return escaped
     
 def cbf_model(pred_df, k=10):
     items = pd.read_csv("data/games_attributes.csv")

easeBased_model.py

@@ -39,7 +39,12 @@ class EASE:
         
         return dist_labels
         
-    def predict_active(self, pred_df, weight_mx, k=10, remove_owned=True):
+    def predict_active(self, pred_df, 
+                    weight_mx,
+                    k=10, 
+                    weight_lambda=0.7,
+                    hybrid_model=True,
+                    remove_owned=True):
         """
             Args:
                 pred_df: (DataFrame) data of user interactions
@@ -69,22 +74,32 @@ class EASE:
         if remove_owned:
             _preds_act_tensor += -1. * user_act_tensor
 
+        if hybrid_model:
+            _preds_act_tensor = _preds_act_tensor * weight_lambda
+
         output_preds = []
         score_preds = []
         for _preds in _preds_act_tensor:
             top_items = _preds.topk(k)
 
-            output_preds.append([self.item_map[id] for id in top_items.indices.tolist()])
+            output_preds.append([self.item_map[id] for id in top_items.indices.tolist()])            
             score_preds.append( top_items.values.tolist() )
-
+        
+        print("'\nOutput preds:", output_preds)
+        print("Score preds:", score_preds)
         pred_df['predicted_items'] = output_preds
         pred_df['predicted_score'] = score_preds
         
-        escaped = [
-            ele for i_list in pred_df['predicted_items'].values for ele in i_list
-        ]
+        escaped_id = [ele for i_list in pred_df['predicted_items'].values for ele in i_list]
+        escaped_score = [score for s_list in pred_df['predicted_score'].values for score in s_list]
+
+        pred_result = pd.DataFrame({
+            'app_id' : escaped_id,
+            'predicted_score' : escaped_score
+        })
+        # print(pred_result)
 
-        return escaped
+        return pred_result
     
 def ease_model(pred_df, k=10):
     ease_B = torch.load("data/ease_B.pt")