changed to user id

app.py

@@ -18,7 +18,6 @@ load_dotenv()
 
 app = FastAPI()
 
-# Enable CORS for all origins (adjust as needed)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -34,17 +33,15 @@ torch.manual_seed(SEED)
 if torch.cuda.is_available():
     torch.cuda.manual_seed_all(SEED)
 
-# Global variables for our GNN-based post recommender
 global G, features, user_nodes, post_nodes, node2idx, pyg_data, trained_model
-G = None             # Bipartite graph (users and posts)
-features = None      # Node features (we use identity)
-user_nodes = None    # Sorted list of user node IDs
-post_nodes = None    # Sorted list of post node IDs
-node2idx = None      # Mapping from node ID to index (for features)
-pyg_data = None      # PyTorch Geometric data object
-trained_model = None # Trained GNN model
-
-SUPABASE_ID = os.getenv('supabaseID')
+G = None
+features = None
+user_nodes = None
+post_nodes = None
+node2idx = None
+pyg_data = None
+trained_model = None
+
 SUPABASE_URL = os.getenv('supabaseUrl')
 SUPABASE_KEY = os.getenv('supabaseAnonKey')
 
@@ -52,73 +49,50 @@ def get_supabase_client():
     return create_client(SUPABASE_URL, SUPABASE_KEY)
 
 def load_and_preprocess_data_for_posts():
-    """
-    Build a bipartite directed graph from Supabase data:
-      - Users: derived from profiles (via posts and likes)
-      - Posts: from the posts table.
-    Edges:
-      - From user to post if the user created the post.
-      - From user to post if the user liked the post.
-    """
     supabase = get_supabase_client()
-    
-    # Load profiles (users)
-    profiles_response = supabase.table('profiles').select('id, username').execute()
+
+    profiles_response = supabase.table('profiles').select('id').execute()
     df_profiles = pd.DataFrame(profiles_response.data)
-    # Create mapping from user id to username
-    uuid_to_username = dict(zip(df_profiles['id'], df_profiles['username']))
-    
-    # Load posts (each with an author)
+
     posts_response = supabase.table('posts').select('id, author').execute()
     df_posts = pd.DataFrame(posts_response.data)
-    # Map post authors to usernames
-    df_posts['username'] = df_posts['author'].map(uuid_to_username)
-    
-    # Load likes: records of (user_id, post_id)
+
     likes_response = supabase.table('likes').select('user_id, post_id').execute()
     df_likes = pd.DataFrame(likes_response.data)
-    df_likes['username'] = df_likes['user_id'].map(uuid_to_username)
-    
-    # Build bipartite graph (directed: from user to post)
+
     bipartite = nx.DiGraph()
-    
-    # Determine set of users (only those who appear in posts or likes)
-    user_set = set(df_posts['username'].dropna().tolist()) | set(df_likes['username'].dropna().tolist())
-    # Determine set of posts (by id)
+
+    user_set = set(df_posts['author'].dropna().tolist()) | set(df_likes['user_id'].dropna().tolist())
     post_set = set(df_posts['id'].tolist())
-    
-    # Add user nodes with attribute type 'user'
+
     for user in user_set:
-        if user:  # ensure non-empty
+        if user:
             bipartite.add_node(user, type='user')
-    # Add post nodes with attribute type 'post'
+
     for post in post_set:
         bipartite.add_node(post, type='post')
-    
-    # Add edges from post creation: user -> post
+
     for _, row in df_posts.iterrows():
-        user = row['username']
+        user = row['author']
         post = row['id']
         if user and post:
             bipartite.add_edge(user, post)
-    
-    # Add edges from likes: user -> post
+
     for _, row in df_likes.iterrows():
-        user = row['username']
+        user = row['user_id']
         post = row['post_id']
         if user and post:
             bipartite.add_edge(user, post)
-    
+
     return bipartite
 
-# GNN Model using GraphSAGE
 class GraphRecommender(nn.Module):
     def __init__(self, input_dim, hidden_dim=128, output_dim=64):
         super().__init__()
         self.conv1 = SAGEConv(input_dim, hidden_dim)
         self.conv2 = SAGEConv(hidden_dim, output_dim)
         self.dropout = nn.Dropout(0.3)
-    
+
     def forward(self, x, edge_index):
         x = F.relu(self.conv1(x, edge_index))
         x = self.dropout(x)
@@ -126,25 +100,16 @@ class GraphRecommender(nn.Module):
         return x
 
 def prepare_training_data(G, node2idx, user_nodes, post_nodes):
-    """
-    Create positive edges for training.
-    Only consider edges from a user node to a post node.
-    """
-    pos_edges = []
-    for u, v in G.edges():
-        # Only include if u is a user and v is a post
-        if G.nodes[u].get('type') == 'user' and G.nodes[v].get('type') == 'post':
-            pos_edges.append((node2idx[u], node2idx[v]))
-    pos_edge_index = torch.tensor(pos_edges).T  # shape: [2, num_pos_edges]
-    
-    # For negative sampling, form all possible user->post pairs and subtract positive edges.
+    pos_edges = [(node2idx[u], node2idx[v]) for u, v in G.edges() if G.nodes[u]['type'] == 'user' and G.nodes[v]['type'] == 'post']
+    pos_edge_index = torch.tensor(pos_edges).T
+
     all_possible = [(node2idx[u], node2idx[p]) for u in user_nodes for p in post_nodes]
     pos_set = set(pos_edges)
     neg_candidates = [pair for pair in all_possible if pair not in pos_set]
-    # Sample as many negatives as positives (if available)
     neg_sample_size = min(len(pos_edges), len(neg_candidates))
     neg_edges = random.sample(neg_candidates, neg_sample_size)
     neg_edge_index = torch.tensor(neg_edges).T
+
     return pos_edge_index, neg_edge_index
 
 def train_model(model, data, pos_edges, neg_edges, epochs=200):
@@ -158,7 +123,6 @@ def train_model(model, data, pos_edges, neg_edges, epochs=200):
 
         embeddings = model(data.x, data.edge_index)
 
-        # Compute scores for positive and negative edges via dot product
         pos_scores = (embeddings[pos_edges[0]] * embeddings[pos_edges[1]]).sum(1)
         neg_scores = (embeddings[neg_edges[0]] * embeddings[neg_edges[1]]).sum(1)
 
@@ -182,77 +146,38 @@ def train_model(model, data, pos_edges, neg_edges, epochs=200):
     return model
 
 def rebuild_model():
-    """
-    Loads the bipartite user-post graph, computes node features,
-    prepares training data, trains the GNN model, and updates globals.
-    """
     global G, features, user_nodes, post_nodes, node2idx, pyg_data, trained_model
     G = load_and_preprocess_data_for_posts()
-    
-    # Get sorted lists of user and post nodes
-    user_nodes = sorted([n for n, attr in G.nodes(data=True) if attr.get('type') == 'user'])
-    post_nodes = sorted([n for n, attr in G.nodes(data=True) if attr.get('type') == 'post'])
+
     user_nodes = sorted(n for n, attr in G.nodes(data=True) if attr.get('type') == 'user')
     post_nodes = sorted(n for n, attr in G.nodes(data=True) if attr.get('type') == 'post')
     all_nodes = user_nodes + post_nodes
     node2idx = {node: i for i, node in enumerate(all_nodes)}
-    
-    # Use identity features (one-hot) for all nodes
+
     features = torch.eye(len(all_nodes))
     pyg_data = from_networkx(G)
     pyg_data.x = features
-    
+
     pos_edge_index, neg_edge_index = prepare_training_data(G, node2idx, user_nodes, post_nodes)
-    
+
     input_dim = features.shape[1]
-    model = GraphRecommender(input_dim=input_dim, hidden_dim=128, output_dim=64)
+    model = GraphRecommender(input_dim=input_dim)
     trained_model = train_model(model, pyg_data, pos_edge_index, neg_edge_index)
 
-def get_recommendations(username, model, data, G, user_nodes, post_nodes, node2idx, top_k=10):
-    """
-    For a given username, compute the user's embedding and rank candidate posts (that the user hasn't interacted with).
-    """
-    if username not in user_nodes:
-        return []
-    user_idx = node2idx[username]
-    
-    # Find posts the user already interacted with (edges from username)
-    user_interacted = set()
-    for _, v in G.out_edges(username):
-        if G.nodes[v].get('type') == 'post':
-            user_interacted.add(v)
-    
-    with torch.no_grad():
-        embeddings = model(data.x, data.edge_index)
-    user_embed = embeddings[user_idx]
-    
-    candidate_scores = []
-    for post in post_nodes:
-        if post in user_interacted:
-            continue
-        post_idx = node2idx[post]
-        score = torch.dot(user_embed, embeddings[post_idx]).item()
-        candidate_scores.append((post, score))
-    candidate_scores = sorted(candidate_scores, key=lambda x: x[1], reverse=True)
-    top_posts = [post for post, score in candidate_scores[:top_k]]
-    return top_posts
-
-# Endpoints
 @app.post("/rebuild")
 async def rebuild_handler():
     rebuild_model()
     return {"status": "success", "message": "Model and data rebuilt successfully"}
 
 @app.get("/recommend/feed")
-async def get_recommendations_handler(username: str = Query(...)):
+async def get_recommendations_handler(user_id: str = Query(...)):
     if trained_model is None:
         raise HTTPException(status_code=500, detail="Model not initialized, please rebuild first.")
-    recs = get_recommendations(username, trained_model, pyg_data, G, user_nodes, post_nodes, node2idx)
+    recs = get_recommendations(user_id, trained_model, pyg_data, G, user_nodes, post_nodes, node2idx)
     return {"status": "success", "recommendations": recs}
 
 @app.get("/")
 async def health_check():
     return {"status": "success", "message": "Recommendation service operational"}
 
-# Optionally, rebuild the model on startup
 rebuild_model()