updated

app.py

@@ -1,3 +1,5 @@
+# app.py
+
 import torch
 import pickle
 import gradio as gr
@@ -14,54 +16,62 @@ with open('item_encoder.pkl', 'rb') as f:
 with open('user_positive_items.pkl', 'rb') as f:
     user_positive_items = pickle.load(f)
 
+# Load the trained model
+class NCFModelWrapper:
+    def __init__(self, model_path, num_users, num_items, embedding_size=50, device='cpu'):
+        self.device = torch.device(device)
+        self.model = NCFModel(num_users, num_items, embedding_size=embedding_size).to(self.device)
+        self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+        self.model.eval()
+
+    def predict(self, user, item):
+        with torch.no_grad():
+            user = torch.tensor([user], dtype=torch.long).to(self.device)
+            item = torch.tensor([item], dtype=torch.long).to(self.device)
+            output = self.model(user, item)
+            score = torch.sigmoid(output).item()
+        return score
+
+# Determine number of users and items from encoders
+num_users = len(user_encoder.classes_)
+num_items = len(item_encoder.classes_)
+
+# Initialize the model
+model = NCFModelWrapper(
+    model_path='best_ncf_model.pth',
+    num_users=num_users,
+    num_items=num_items,
+    embedding_size=50,  # Ensure this matches your trained model
+    device='cpu'  # Change to 'cuda' if GPU is available and desired
+)
 
 def recommend(user_id, num_recommendations=5):
-    """
-    Given a user ID, recommend top N items.
-
-    Args:
-        user_id (str): User ID for recommendation.
-        num_recommendations (int, optional): Number of recommendations to return. Defaults to 5.
-
-    Returns:
-        str: Top N recommendations for the user or an error message if the user ID is invalid.
-    """
-
     try:
         user = user_encoder.transform([user_id])[0]
-    except ValueError:
-        return f"Invalid User ID: '{user_id}'"
+    except:
+        return f"User ID '{user_id}' not found."
 
     # Get items the user has interacted with
     pos_items = user_positive_items.get(user, set())
 
     # Get all possible items
-    all_items = set(range(len(item_encoder.classes_)))
+    all_items = set(range(num_items))
 
     # Candidate items are those not interacted with
     candidate_items = list(all_items - pos_items)
 
-    # Load and use the model
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
-    model = NCFModel(num_users=len(user_encoder.classes_),
-                      num_items=len(item_encoder.classes_),
-                      embedding_size=50).to(device)
-    model.load_state_dict(torch.load('best_ncf_model.pth', map_location=device))
-    model.eval()
-
     # Predict scores for candidate items
     scores = []
-    with torch.no_grad():
-        for item in candidate_items:
-            score = torch.sigmoid(model(torch.tensor([user]).to(device),
-                                       torch.tensor([item]).to(device))).item()
-            scores.append((item, score))
+    for item in candidate_items:
+        score = model.predict(user, item)
+        scores.append((item, score))
 
     # Sort items based on score
     scores.sort(key=lambda x: x[1], reverse=True)
 
     # Get top N recommendations
     top_items = scores[:num_recommendations]
+
     recommendations = []
     for item_id, score in top_items:
         original_item_id = item_encoder.inverse_transform([item_id])[0]
@@ -69,9 +79,22 @@ def recommend(user_id, num_recommendations=5):
 
     return "\n".join(recommendations)
 
-
 # Define Gradio interface
 iface = gr.Interface(
     fn=recommend,
     inputs=[
-        gr.Textbox(lines=1, placeholder="Enter User ID", label="User ID
+        gr.Textbox(lines=1, placeholder="Enter User ID", label="User ID"),
+        gr.Slider(minimum=1, maximum=20, step=1, value=5, label="Number of Recommendations")
+    ],
+    outputs="text",
+    title="Neural Collaborative Filtering Recommendation System",
+    description="Enter a User ID to receive personalized item recommendations.",
+    examples=[
+        ["user_1", 5],
+        ["user_2", 10],
+        ["user_3", 7]
+    ]
+)
+
+if __name__ == "__main__":
+    iface.launch()