added scheduler, logging and optimization updates

app.py

@@ -18,11 +18,10 @@ import json
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 import logging
-import uvicorn
 import pytz
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 load_dotenv()
@@ -56,6 +55,7 @@ def get_supabase_client():
 
 def load_and_preprocess_data():
     supabase = get_supabase_client()
+    logger.info("Loading data from Supabase")
 
     def fetch_table(table, columns, chunk_size=1000):
         offset = 0
@@ -84,6 +84,7 @@ def load_and_preprocess_data():
     bipartite.add_edges_from((p['author'], p['id']) for p in posts)
     bipartite.add_edges_from((l['user_id'], l['post_id']) for l in likes)
 
+    logger.info(f"Loaded graph with {len(user_set)} users and {len(post_set)} posts")
     return bipartite
 
 class GraphRecommender(nn.Module):
@@ -109,11 +110,19 @@ def prepare_training_data(G, node2idx, user_nodes, post_nodes):
     neg_sample_size = min(len(pos_edges), len(neg_candidates))
     neg_edges = random.sample(neg_candidates, neg_sample_size)
 
-    return torch.tensor(pos_edges).T, torch.tensor(neg_edges).T
+    logger.info(f"Prepared {len(pos_edges)} positive and {len(neg_edges)} negative edges")
+    return torch.tensor(pos_edges, dtype=torch.long).T, torch.tensor(neg_edges, dtype=torch.long).T
 
 def train_model(model, data, pos_edges, neg_edges, epochs=200):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = model.to(device)
+    data = data.to(device)
+    pos_edges = pos_edges.to(device)
+    neg_edges = neg_edges.to(device)
+
     optimizer = optim.Adam(model.parameters(), lr=0.005, weight_decay=1e-4)
 
+    logger.info("Starting model training")
     for epoch in range(epochs):
         model.train()
         optimizer.zero_grad()
@@ -131,11 +140,12 @@ def train_model(model, data, pos_edges, neg_edges, epochs=200):
         total_loss.backward()
         optimizer.step()
 
-    return model
+    logger.info("Model training completed")
+    return model.to('cpu')
 
 def rebuild_model():
     global G, features, user_nodes, post_nodes, node2idx, pyg_data, trained_model
-    logger.info("Starting model rebuild at 3:30 AM")
+    logger.info("Starting model rebuild at 3:30 AM Pacific Time")
     try:
         G = load_and_preprocess_data()
         user_nodes = sorted(n for n, attr in G.nodes(data=True) if attr['type'] == 'user')
@@ -144,11 +154,8 @@ def rebuild_model():
         all_nodes = user_nodes + post_nodes
         node2idx = {node: i for i, node in enumerate(all_nodes)}
 
-        features = torch.sparse_coo_tensor(
-            torch.arange(len(all_nodes)).repeat(2, 1),
-            torch.ones(len(all_nodes)),
-            (len(all_nodes), len(all_nodes))
-        )
+        # Use dense features instead of sparse (SAGEConv requires dense input)
+        features = torch.eye(len(all_nodes))
         pyg_data = from_networkx(G)
         pyg_data.x = features
 
@@ -156,14 +163,7 @@ def rebuild_model():
 
         input_dim = features.shape[1]
         model = GraphRecommender(input_dim)
-        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        model = model.to(device)
-        pyg_data = pyg_data.to(device)
-        pos_edges = pos_edges.to(device)
-        neg_edges = neg_edges.to(device)
-
         trained_model = train_model(model, pyg_data, pos_edges, neg_edges)
-        trained_model = trained_model.to('cpu')
         logger.info("Model rebuild completed successfully")
     except Exception as e:
         logger.error(f"Error during model rebuild: {str(e)}")
@@ -187,6 +187,7 @@ def get_recommendations(user_id, model, data, G, user_nodes, post_nodes, node2id
     post_scores = [(post_nodes[i], score.item()) for i, score in zip(post_indices, scores)]
     post_scores = sorted(post_scores, key=lambda x: x[1], reverse=True)
 
+    logger.info(f"Generated {len(post_scores)} recommendations for user {user_id}")
     return [{"post_id": post, "score": score} for post, score in post_scores]
 
 def fetch_full_post_records(post_ids, batch_size=1000):
@@ -231,6 +232,7 @@ async def get_recommendations_handler(user_id: str = Query(...)):
             post_record["score"] = post["score"]
             ordered_recommendations.append(post_record)
 
+    # Stream the response
     def generate():
         yield '{"status": "success", "recommendations": ['
         for i, rec in enumerate(ordered_recommendations):
@@ -257,7 +259,7 @@ scheduler.add_job(
 async def startup_event():
     rebuild_model()
     scheduler.start()
-    logger.info("Scheduler started, model will rebuild daily at 3:30 AM")
+    logger.info("Scheduler started, model will rebuild daily at 3:30 AM Pacific Time")
 
 @app.on_event("shutdown")
 async def shutdown_event():
@@ -265,4 +267,5 @@ async def shutdown_event():
     logger.info("Scheduler shut down")
 
 if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)