Upload 4 files

build_engine.py

@@ -0,0 +1,98 @@
+import pandas as pd
+import numpy as np
+import pickle
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import ast
+
+DATA_PATH = '../data/' 
+MAX_ITEMS = 12000
+
+def process_movies():
+    print("🎬 Processing TMDB Movies...")
+    movies = pd.read_csv(DATA_PATH + 'tmdb_5000_movies.csv')
+    
+    movies['release_date'] = pd.to_datetime(movies['release_date'], errors='coerce')
+    movies = movies.dropna(subset=['release_date'])
+    
+    movies = movies[
+        (movies['release_date'].dt.year >= 2000) | 
+        ((movies['release_date'].dt.year < 2000) & (movies['vote_count'] > 1500))
+    ].copy()
+    
+    def parse_genres(x):
+        try:
+            return " ".join([i['name'] for i in ast.literal_eval(x)])
+        except:
+            return ""
+
+    movies['genres_str'] = movies['genres'].apply(parse_genres)
+    movies['tags'] = movies['overview'].fillna('') + " " + movies['genres_str']
+    movies['type'] = 'Movie'
+    movies = movies[['id', 'title', 'tags', 'vote_average', 'vote_count', 'type', 'genres_str']]
+    movies.rename(columns={'vote_average': 'rating', 'genres_str': 'genre_list'}, inplace=True)
+    
+    return movies
+
+def process_anime():
+    print("🍙 Processing Anime...")
+    anime = pd.read_csv(DATA_PATH + 'anime.csv')
+    
+    anime = anime[anime['members'] > 40000].copy()
+    anime['name'] = anime['name'].fillna('')
+    anime['genre'] = anime['genre'].fillna('')
+    anime['type'] = anime['type'].fillna('Anime')
+    anime['tags'] = anime['genre'] + " " + anime['type'] + " " + anime['name']
+    anime['genre_list'] = "Anime"
+    anime.rename(columns={'anime_id': 'id', 'name': 'title', 'rating': 'rating', 'members': 'vote_count'}, inplace=True)
+    anime['type'] = 'Anime'
+    
+    anime = anime[['id', 'title', 'tags', 'rating', 'vote_count', 'type', 'genre_list']]
+    
+    return anime
+
+def build_engine():
+    df_movies = process_movies()
+    df_anime = process_anime()
+    
+    combined = pd.concat([df_movies, df_anime], ignore_index=True)
+    combined = combined.sample(frac=1, random_state=42).reset_index(drop=True)
+    if len(combined) > MAX_ITEMS:
+        print(f"⚠️ Trimming dataset from {len(combined)} to {MAX_ITEMS}...")
+        combined = combined.head(MAX_ITEMS)
+
+    print(f"📊 Total Database: {len(combined)} items.")
+    print("🧠 Training NLP Model...")
+    cv = CountVectorizer(max_features=5000, stop_words='english')
+    vectors = cv.fit_transform(combined['tags']).toarray()
+    print("📐 Calculating Cosine Similarity...")
+    similarity = cosine_similarity(vectors)
+    print("📝 Generating Quiz Data...")
+    
+    all_genres = set()
+    for g in combined['genre_list'].dropna():
+        cleaned = g.replace(" ", ",").split(",") 
+        for item in cleaned:
+            if item and len(item) > 2: all_genres.add(item.strip())
+            
+    quiz_data = {}
+    for genre in all_genres:
+        if genre == "Anime":
+            mask = combined['type'] == 'Anime'
+        else:
+            mask = (combined['genre_list'].str.contains(genre, case=False, na=False)) & (combined['type'] == 'Movie')
+            
+        top_items = combined[mask].sort_values(by='rating', ascending=False).head(20)
+        
+        if not top_items.empty:
+            quiz_data[genre] = top_items[['id', 'title', 'type']].to_dict('records')
+
+    print("💾 Saving Artifacts...")
+    pickle.dump(combined, open('movie_list.pkl', 'wb'))
+    pickle.dump(similarity, open('similarity.pkl', 'wb'))
+    pickle.dump(quiz_data, open('quiz_data.pkl', 'wb'))
+    
+    print("🎉 DONE! Backend ready.")
+
+if __name__ == "__main__":
+    build_engine()

etl_pinecone.py

@@ -0,0 +1,102 @@
+import pandas as pd
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from pinecone import Pinecone, ServerlessSpec
+from tqdm import tqdm
+import time
+
+PINECONE_API_KEY = "pcsk_5tHsyD_Ewe6CLcGWckB2mCAsMuy1E2YDosgMWSt1itcBh1q5PxgmpmNymK4jpX7byrBZgd"
+INDEX_NAME = "cine-match"
+DATA_PATH = '../data/'
+MAX_ITEMS = 40000
+
+def prepare_data():
+    print("📂 Loading Datasets...")
+    
+    movies = pd.read_csv(DATA_PATH + 'movies_metadata.csv', low_memory=False)
+    
+    movies = movies[movies['release_date'].notna()]
+    movies = movies[movies['vote_count'].notna()]
+    
+    movies['vote_count'] = pd.to_numeric(movies['vote_count'], errors='coerce')
+    movies['vote_average'] = pd.to_numeric(movies['vote_average'], errors='coerce')
+    movies['popularity'] = pd.to_numeric(movies['popularity'], errors='coerce')
+    
+    movies['release_date'] = pd.to_datetime(movies['release_date'], errors='coerce')
+    movies = movies[
+        (movies['vote_count'] > 50) &
+        (movies['release_date'].dt.year >= 1980)
+    ].copy()
+    
+    movies['overview'] = movies['overview'].fillna('')
+    movies['title'] = movies['title'].fillna('')
+    movies['text_chunk'] = "Movie: " + movies['title'] + ". Plot: " + movies['overview']
+    
+    movies['type'] = 'Movie'
+    movies['image_id'] = movies['imdb_id']
+    movies = movies[['id', 'title', 'text_chunk', 'type', 'vote_count', 'vote_average']]
+    
+    print(f"✅ Movies Processed: {len(movies)}")
+
+    anime = pd.read_csv(DATA_PATH + 'anime.csv')
+    anime = anime[anime['members'] > 10000]
+    anime['type'] = 'Anime'
+    
+    anime['name'] = anime['name'].fillna('')
+    anime['genre'] = anime['genre'].fillna('')
+    anime['text_chunk'] = "Anime: " + anime['name'] + ". Genres: " + anime['genre'] + ". Type: " + anime['type']
+    
+    anime.rename(columns={'anime_id': 'id', 'name': 'title', 'rating': 'vote_average', 'members': 'vote_count'}, inplace=True)
+    anime['image_id'] = anime['id']
+    anime = anime[['id', 'title', 'text_chunk', 'type', 'vote_count', 'vote_average']]
+
+    print(f"✅ Anime Processed: {len(anime)}")
+    
+    combined = pd.concat([movies, anime], ignore_index=True)
+    
+    combined = combined.sort_values(by='vote_count', ascending=False).head(MAX_ITEMS)
+    
+    print(f"🔥 Final Database Size: {len(combined)} items.")
+    return combined
+
+def upload_to_pinecone(df):
+    print("🧠 Loading AI Model (all-MiniLM-L6-v2)...")
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    
+    print("☁️ Connecting to Pinecone...")
+    pc = Pinecone(api_key=PINECONE_API_KEY)
+    index = pc.Index(INDEX_NAME)
+    
+    batch_size = 100
+    total_batches = len(df) // batch_size + 1
+    
+    print("🚀 Starting Upload... (This will take a while!)")
+    
+    for i in tqdm(range(0, len(df), batch_size)):
+        batch = df.iloc[i : i + batch_size]
+        
+        vectors = model.encode(batch['text_chunk'].tolist()).tolist()
+        
+        upsert_data = []
+        for j, row in enumerate(batch.itertuples()):
+            upsert_data.append({
+                "id": f"{row.type}_{row.id}",
+                "values": vectors[j],
+                "metadata": {
+                    "title": str(row.title),
+                    "type": str(row.type),
+                    "original_id": str(row.id),
+                    "rating": float(row.vote_average) if pd.notna(row.vote_average) else 0.0
+                }
+            })
+            
+        try:
+            index.upsert(vectors=upsert_data)
+        except Exception as e:
+            print(f"Error uploading batch: {e}")
+            
+    print("🎉 SUCCESS! All data is now in the Cloud Brain.")
+
+if __name__ == "__main__":
+    df = prepare_data()
+    upload_to_pinecone(df)

main.py

@@ -0,0 +1,195 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from fastapi.middleware.cors import CORSMiddleware
+from pinecone import Pinecone
+from sentence_transformers import SentenceTransformer
+import random
+import os
+
+# ============================
+# 🔑 CONFIGURATION
+# ============================
+PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+INDEX_NAME = "cine-match"
+
+if not PINECONE_API_KEY:
+    env_path = os.path.join(os.path.dirname(__file__), ".env")
+    if os.path.exists(env_path):
+        with open(env_path, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip().startswith("PINECONE_API_KEY"):
+                    parts = line.split("=", 1)
+                    if len(parts) > 1:
+                        PINECONE_API_KEY = parts[1].strip().strip('"').strip("'")
+                        break
+
+if not PINECONE_API_KEY:
+    raise RuntimeError(
+        "PINECONE_API_KEY not set. Add it to environment or ml-engine/.env"
+    )
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+print("⏳ Loading AI Model...")
+model = SentenceTransformer('all-MiniLM-L6-v2')
+pc = Pinecone(api_key=PINECONE_API_KEY)
+index = pc.Index(INDEX_NAME)
+print("✅ Brain Online!")
+
+# ============================
+# 🛠 MODELS
+# ============================
+
+class SearchRequest(BaseModel):
+    query: str
+    filter_type: str = "All"
+
+class QuizRequest(BaseModel):
+    genre: str
+
+class FinalRecommendationRequest(BaseModel):
+    mood: str
+    selected_titles: list[str]
+    genre: str
+
+# ============================
+# 🔍 MODE 1: SIMPLE SEARCH
+# ============================
+
+@app.post("/search")
+def semantic_search(req: SearchRequest):
+    try:
+        query_vector = model.encode(req.query).tolist()
+        filter_dict = {}
+        if req.filter_type != "All":
+            filter_dict = {"type": req.filter_type}
+
+        results = index.query(
+            vector=query_vector,
+            top_k=20,
+            include_metadata=True,
+            filter=filter_dict if filter_dict else None
+        )
+        
+        matches = []
+        for match in results['matches']:
+            meta = match['metadata']
+            matches.append({
+                "id": meta['original_id'],
+                "title": meta['title'],
+                "type": meta['type'],
+                "score": match['score'],
+                "rating": meta.get('rating', 0)
+            })
+        return {"results": matches}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/mood")
+def mood_search(mood: str):
+    # Simple mapping for the "Search Mode" mood buttons
+    mood_map = {
+        "Happy": "Feel good movie, comedy, lighthearted, happy ending",
+        "Dark": "Dark, psychological thriller, disturbing, gritty, noir",
+        "Adrenaline": "High stakes action, fast paced, car chases",
+        "Mind-Bending": "Confusing plot, time travel, philosophy, deep thoughts",
+        "Romantic": "Love story, romance, heartbreak",
+        "Scary": "Horror, ghosts, jump scares"
+    }
+    search_query = mood_map.get(mood, mood)
+    return semantic_search(SearchRequest(query=search_query))
+
+# ============================
+# 🧙‍♂️ MODE 2: WIZARD / HYBRID
+# ============================
+
+@app.post("/get-quiz-items")
+def get_quiz_items(req: QuizRequest):
+    query = f"Popular, famous, high rated {req.genre} movies or anime"
+    vector = model.encode(query).tolist()
+    
+    results = index.query(
+        vector=vector,
+        top_k=20,
+        include_metadata=True,
+        filter={"type": "Anime" if req.genre == "Anime" else "Movie"}
+    )
+    
+    items = []
+    for match in results['matches']:
+        meta = match['metadata']
+        items.append({
+            "id": meta['original_id'],
+            "title": meta['title'],
+            "type": meta['type'],
+            "poster": None
+        })
+    return {"items": items}
+
+@app.post("/hybrid-recommend")
+def hybrid_recommend(req: FinalRecommendationRequest):
+    joined_titles = ", ".join(req.selected_titles)
+    semantic_query = f"{req.mood} {req.genre} similar to {joined_titles}"
+    
+    query_vector = model.encode(semantic_query).tolist()
+    
+    results = index.query(
+        vector=query_vector,
+        top_k=60, 
+        include_metadata=True
+    )
+    
+    recommendations = []
+    for match in results['matches']:
+        meta = match['metadata']
+        if meta['title'] in req.selected_titles: continue
+            
+        reason = f"Because you liked {random.choice(req.selected_titles)} and wanted something {req.mood}."
+        
+        recommendations.append({
+            "id": meta['original_id'],
+            "title": meta['title'],
+            "type": meta['type'],
+            "score": match['score'],
+            "rating": meta.get('rating', 0),
+            "reason": reason 
+        })
+        
+    return {"results": recommendations}
+
+@app.get("/lucky")
+def lucky_pick():
+    """
+    Picks a random high-rated movie from the database.
+    """
+    # Query for generally good movies
+    vector = model.encode("Masterpiece, highly rated, famous, classic, 5 stars").tolist()
+    
+    # Get 50 candidates
+    results = index.query(
+        vector=vector,
+        top_k=50, 
+        include_metadata=True
+    )
+    
+    if not results['matches']:
+        raise HTTPException(status_code=404, detail="No movies found")
+        
+    # Pick one random movie
+    match = random.choice(results['matches'])
+    meta = match['metadata']
+    
+    return {
+        "id": meta['original_id'],
+        "title": meta['title'],
+        "type": meta['type'],
+        "rating": meta.get('rating', 0),
+        "reason": "Serendipity ✨"
+    }

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+pydantic
+pinecone-client
+sentence-transformers
+torch
+numpy