Fixed suggestions

app.py

@@ -2,7 +2,6 @@ import os
 import random
 import itertools
 import numpy as np
-import pandas as pd
 import networkx as nx
 import torch
 import torch.nn as nn
@@ -45,20 +44,26 @@ if torch.cuda.is_available():
     torch.cuda.manual_seed_all(SEED)
 
 # Global variables
-global G, features, user_ids, pyg_data, trained_model
-G = features = user_ids = pyg_data = trained_model = None
+G = None
+features = None
+user_ids = None
+pyg_data = None
+trained_model = None
 
 SUPABASE_URL = os.getenv('supabaseUrl')
 SUPABASE_KEY = os.getenv('supabaseAnonKey')
 
 def get_supabase_client():
+    """Initialize and return a Supabase client."""
     return create_client(SUPABASE_URL, SUPABASE_KEY)
 
 def load_and_preprocess_data():
+    """Load and preprocess follower data from Supabase."""
     supabase = get_supabase_client()
     logger.info("Loading data from Supabase")
 
     def fetch_table(table, columns, chunk_size=1000):
+        """Fetch data from a Supabase table in chunks."""
         offset = 0
         all_data = []
         while True:
@@ -73,29 +78,47 @@ def load_and_preprocess_data():
     followers = fetch_table('followers', 'id, following')
     users = fetch_table('profiles', 'id')
 
-    follower_dict = {f['id']: f['following'] for f in followers}
-    user_set = {u['id'] for u in users}
+    # Build follower_dict: id (followed) -> list of following (followers)
+    follower_dict = {}
+    for f in followers:
+        followed_id = f['id']  # The user being followed
+        follower_id = f['following']  # The user following the id
+        if not follower_id or not followed_id:  # Skip invalid entries
+            logger.warning(f"Skipping invalid entry: follower_id={follower_id}, followed_id={followed_id}")
+            continue
+        if followed_id in follower_dict:
+            follower_dict[followed_id].append(follower_id)
+        else:
+            follower_dict[followed_id] = [follower_id]
+
+    user_set = set(u['id'] for u in users if u['id'])  # Valid user IDs
+    # Create edge list: follower (following) -> followed (id)
     merged = [
-        {'follower_id': follower_dict[fid], 'followed_id': fid}
-        for fid in follower_dict if fid in user_set and follower_dict[fid] != '' and fid != ''
+        {'follower_id': follower, 'followed_id': fid}
+        for fid in follower_dict
+        for follower in follower_dict[fid]
+        if fid in user_set and follower in user_set
     ]
     logger.info(f"Loaded {len(merged)} follower relationships")
     return merged
 
 def create_graph_dataframe(merged_data):
+    """Create a directed graph and feature matrix from merged data."""
+    global G, features, user_ids
     G = nx.DiGraph()
     edges = [(d['follower_id'], d['followed_id']) for d in merged_data]
     G.add_edges_from(edges)
     user_ids = sorted(G.nodes())
     
-    # Use dense identity matrix for features (sparse not supported by SAGEConv)
+    # Use identity matrix as node features
     features = torch.eye(len(user_ids))
     logger.info(f"Created graph with {len(user_ids)} nodes")
     return G, features, user_ids
 
 def prepare_training_data(G, user_ids):
+    """Prepare positive and negative edge indices for training."""
     pos_edges = [(user_ids.index(u), user_ids.index(v)) for u, v in G.edges()]
-    pos_edge_index = torch.tensor(pos_edges, dtype=torch.long).T
+    pos_edge_index = torch.tensor(pos_edges, dtype=torch.long).t()
 
     num_nodes = len(user_ids)
     all_possible_edges = set(itertools.permutations(range(num_nodes), 2))
@@ -104,9 +127,10 @@ def prepare_training_data(G, user_ids):
     negative_edges = random.sample(list(all_possible_edges - existing_edges), neg_sample_size)
 
     logger.info(f"Prepared {len(pos_edges)} positive and {len(negative_edges)} negative edges")
-    return pos_edge_index, torch.tensor(negative_edges, dtype=torch.long).T
+    return pos_edge_index, torch.tensor(negative_edges, dtype=torch.long).t()
 
 class GraphRecommender(nn.Module):
+    """GraphSAGE-based recommendation model."""
     def __init__(self, input_dim, hidden_dim=128, output_dim=64):
         super().__init__()
         self.conv1 = SAGEConv(input_dim, hidden_dim)
@@ -120,6 +144,7 @@ class GraphRecommender(nn.Module):
         return x
 
 def train_model(model, data, pos_edges, neg_edges, epochs=200, patience=20):
+    """Train the GraphRecommender model."""
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     model = model.to(device)
     data = data.to(device)
@@ -137,8 +162,8 @@ def train_model(model, data, pos_edges, neg_edges, epochs=200, patience=20):
 
         embeddings = model(data.x, data.edge_index)
 
-        pos_scores = (embeddings[pos_edges[0]] * embeddings[pos_edges[1]]).sum(1)
-        neg_scores = (embeddings[neg_edges[0]] * embeddings[neg_edges[1]]).sum(1)
+        pos_scores = (embeddings[pos_edges[0]] * embeddings[pos_edges[1]]).sum(dim=1)
+        neg_scores = (embeddings[neg_edges[0]] * embeddings[neg_edges[1]]).sum(dim=1)
 
         pos_loss = F.binary_cross_entropy_with_logits(pos_scores, torch.ones_like(pos_scores))
         neg_loss = F.binary_cross_entropy_with_logits(neg_scores, torch.zeros_like(neg_scores))
@@ -162,13 +187,19 @@ def train_model(model, data, pos_edges, neg_edges, epochs=200, patience=20):
     return model.to('cpu')
 
 def get_recommendations(user_id, model, data, G, user_ids, top_k=10):
+    """Generate top-k user recommendations excluding current follows."""
     if user_id not in user_ids:
+        logger.warning(f"User {user_id} not found in graph")
         return []
 
     user_idx = user_ids.index(user_id)
-    current_follows = set(G.successors(user_id))
+    current_follows = set(G.successors(user_id))  # Users this user follows
     candidate_indices = [i for i, u in enumerate(user_ids) if u != user_id and u not in current_follows]
 
+    if not candidate_indices:
+        logger.info(f"No new recommendations available for user {user_id}")
+        return []
+
     with torch.no_grad():
         embeddings = model(data.x, data.edge_index)
         user_embed = embeddings[user_idx].unsqueeze(0)
@@ -181,6 +212,7 @@ def get_recommendations(user_id, model, data, G, user_ids, top_k=10):
     return recommendations
 
 def rebuild_model():
+    """Rebuild the graph and retrain the model."""
     global G, features, user_ids, pyg_data, trained_model
     logger.info("Starting model rebuild at 3:30 AM Pacific Time")
     try:
@@ -199,13 +231,17 @@ def rebuild_model():
 
 @app.post("/rebuild")
 async def rebuild_handler():
+    """API endpoint to manually trigger model rebuild."""
     rebuild_model()
     return {"status": "success", "message": "Model and data rebuilt successfully"}
 
 @app.get("/recommend/network")
 async def get_recommendations_handler(user_id: str = Query(...)):
+    """API endpoint to get recommendations for a user."""
     if not trained_model:
         raise HTTPException(status_code=500, detail="Model not initialized, please rebuild first.")
+    if not user_id.strip():
+        raise HTTPException(status_code=400, detail="Invalid user_id")
 
     recommendations = get_recommendations(user_id, trained_model, pyg_data, G, user_ids)
     
@@ -221,25 +257,28 @@ async def get_recommendations_handler(user_id: str = Query(...)):
 
 @app.get("/")
 async def health_check():
+    """API endpoint for health check."""
     return {"status": "success", "message": "Recommendation service operational"}
 
 # Scheduler setup with Pacific Time Zone
 scheduler = BackgroundScheduler(timezone="America/Los_Angeles")
 scheduler.add_job(
     rebuild_model,
-    trigger=CronTrigger(hour=3, minute=30),  # Run at 3:30 AM Pacific Time every day
+    trigger=CronTrigger(hour=3, minute=30),  # Run at 3:30 AM Pacific Time daily
     id='daily_model_rebuild',
     replace_existing=True
 )
 
 @app.on_event("startup")
 async def startup_event():
-    rebuild_model()  # Initial build on startup
+    """Startup event to initialize model and scheduler."""
+    rebuild_model()
     scheduler.start()
     logger.info("Scheduler started, model will rebuild daily at 3:30 AM Pacific Time")
 
 @app.on_event("shutdown")
 async def shutdown_event():
+    """Shutdown event to stop scheduler."""
     scheduler.shutdown()
     logger.info("Scheduler shut down")