Update app.py

app.py

@@ -32,33 +32,57 @@ if len(data) > 0:
         else:
             data[feature] = data[feature].fillna(0)  # Numeric columns
     
-    # Combine features
-    data['combined_features'] = (
-        data['genres'].astype(str) + ' ' + 
-        data['categories'].astype(str) + ' ' + 
-        data['steamspy_tags'].astype(str) + ' ' + 
-        data['platforms'].astype(str)
-    )
+    # Add derived features for better recommendations
+    if 'positive_ratings' in data.columns and 'negative_ratings' in data.columns:
+        data['rating_ratio'] = data['positive_ratings'] / (data['positive_ratings'] + data['negative_ratings'] + 1)
+    else:
+        data['rating_ratio'] = 0.5  # Default neutral rating
+    
+    # Create a more comprehensive combined feature set with weighted components
+    data['combined_features'] = ''
+    
+    # Add name with higher weight for better keyword matching
+    if 'name' in data.columns:
+        data['combined_features'] += data['name'].astype(str) + ' ' + data['name'].astype(str) + ' '
+    
+    # Add genres with higher weight (repeat to increase importance)
+    if 'genres' in data.columns:
+        data['combined_features'] += data['genres'].astype(str) + ' ' + data['genres'].astype(str) + ' '
+    
+    # Add other features
+    for feature in ['categories', 'steamspy_tags', 'platforms']:
+        if feature in data.columns:
+            data['combined_features'] += data[feature].astype(str) + ' '
+    
+    # Clean the combined features
+    data['combined_features'] = data['combined_features'].str.replace(';', ' ').str.lower()
     
-    # Vectorize
+    # Vectorize with improved parameters
     try:
-        vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2), max_features=5000)
+        # Use more n-grams and increased max_features for better semantic understanding
+        vectorizer = TfidfVectorizer(
+            stop_words='english', 
+            ngram_range=(1, 3),  # Capture phrases up to 3 words
+            max_features=10000,   # Increase features for more nuanced relationships
+            min_df=2,             # Ignore very rare terms
+            max_df=0.9            # Ignore very common terms
+        )
         feature_vectors = vectorizer.fit_transform(data['combined_features'])
         print(f"Vectorization complete. Shape: {feature_vectors.shape}")
     except Exception as e:
         print(f"Vectorization error: {e}")
         feature_vectors = np.zeros((len(data), 1))
     
-    # Normalize positive ratings
+    # Normalize ratings with sigmoid-like scaling for better differentiation
     if 'positive_ratings' in data.columns and len(data) > 0:
+        # Log transform to handle skewed distribution of ratings
+        data['log_ratings'] = np.log1p(data['positive_ratings'])
         scaler = MinMaxScaler()
-        data['positive_ratings_scaled'] = scaler.fit_transform(
-            data[['positive_ratings']].clip(lower=0)
-        )
+        data['positive_ratings_scaled'] = scaler.fit_transform(data[['log_ratings']])
     else:
         data['positive_ratings_scaled'] = 0
     
-    # Compute similarity matrix
+    # Compute similarity matrix with optimizations
     if feature_vectors.shape[0] > 1:
         try:
             if len(data) > 5000:
@@ -88,7 +112,7 @@ else:
     game_similarity = np.zeros((0, 0))
     list_of_all_titles = []
 
-# Platform detection function without emojis
+# Improved platform detection function
 def detect_platforms(platforms_str):
     platforms_str = str(platforms_str).lower()
     platforms = []
@@ -99,6 +123,8 @@ def detect_platforms(platforms_str):
         platforms.append("macOS")
     if 'linux' in platforms_str:
         platforms.append("Linux")
+    if any(mobile_term in platforms_str for mobile_term in ['android', 'ios', 'mobile']):
+        platforms.append("Mobile")
     
     return platforms if platforms else ["Unknown"]
 
@@ -141,7 +167,7 @@ def create_price_gauge(game_price, similar_games_prices):
     
     return fig
 
-# Function to get game recommendations
+# Enhanced game recommendation function
 def recommend_games(user_game_name_input):
     if not user_game_name_input or not list_of_all_titles:
         return "Please enter a game name and ensure the dataset is loaded.", [], None
@@ -149,17 +175,32 @@ def recommend_games(user_game_name_input):
     # Normalize input for better matching
     user_input_cleaned = user_game_name_input.strip().lower()
     
-    # First try exact match
+    # First try exact match (case insensitive)
     exact_matches = [title for title in list_of_all_titles if title.lower() == user_input_cleaned]
     
     if exact_matches:
         closest_match = exact_matches[0]
     else:
-        # Try fuzzy matching if no exact match
-        find_close_match = difflib.get_close_matches(user_game_name_input, list_of_all_titles, n=1, cutoff=0.6)
-        if not find_close_match:
-            return f"No match found for '{user_game_name_input}'. Please try another game name.", [], None
-        closest_match = find_close_match[0]
+        # Try partial match before fuzzy matching
+        partial_matches = [title for title in list_of_all_titles if user_input_cleaned in title.lower()]
+        
+        if partial_matches:
+            # Sort by length to prefer shorter (more exact) matches
+            closest_match = sorted(partial_matches, key=len)[0]
+        else:
+            # Try fuzzy matching with improved parameters
+            find_close_match = difflib.get_close_matches(
+                user_game_name_input, 
+                list_of_all_titles, 
+                n=5,  # Get more candidates
+                cutoff=0.5  # Lower threshold for more possibilities
+            )
+            
+            if not find_close_match:
+                return f"No match found for '{user_game_name_input}'. Please try another game name.", [], None
+            
+            # Take the closest match
+            closest_match = find_close_match[0]
     
     try:
         index_of_the_game = data.loc[data['name'] == closest_match].index[0]
@@ -170,12 +211,34 @@ def recommend_games(user_game_name_input):
         
         similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
         
-        # Sort by similarity and then by ratings as a tiebreaker
-        sorted_similar_games = sorted(
-            similarity_scores, 
-            key=lambda x: (x[1], data.iloc[x[0]]['positive_ratings_scaled']), 
-            reverse=True
-        )
+        # Enhanced ranking with hybrid scoring
+        game_rankings = []
+        for idx, sim_score in similarity_scores:
+            if idx == index_of_the_game:  # Skip the game itself
+                continue
+            
+            # Get additional factors for hybrid scoring
+            rating_factor = data.iloc[idx]['positive_ratings_scaled'] 
+            
+            # Calculate genre similarity separately
+            searched_game_genres = str(data.iloc[index_of_the_game].get('genres', '')).lower().split(';')
+            current_game_genres = str(data.iloc[idx].get('genres', '')).lower().split(';')
+            
+            # Count matching genres
+            matching_genres = len(set(searched_game_genres) & set(current_game_genres))
+            genre_factor = matching_genres / max(len(searched_game_genres), 1)
+            
+            # Create hybrid score with weights
+            hybrid_score = (
+                0.65 * sim_score +      # Base similarity from TF-IDF vectors
+                0.20 * rating_factor +   # Rating popularity 
+                0.15 * genre_factor      # Genre match
+            )
+            
+            game_rankings.append((idx, hybrid_score))
+        
+        # Sort by the hybrid score
+        sorted_similar_games = sorted(game_rankings, key=lambda x: x[1], reverse=True)
         
         recommendations = []
         game_list = []
@@ -203,10 +266,25 @@ def recommend_games(user_game_name_input):
         # Get prices for similar games (for gauge visualization)
         similar_games_prices = []
         
+        # Process recommendations with diversity enforcement
+        seen_publishers = set()
+        if 'publisher' in data.columns:
+            searched_game_publisher = str(searched_game.get('publisher', '')).lower()
+            seen_publishers.add(searched_game_publisher)
+        
+        recommended_count = 0
+        
         # Process recommendations
-        for i, (index, score) in enumerate(sorted_similar_games[1:6]):  # Get top 5 recommendations
-            if score < 0.2:  # Minimum threshold for quality
+        for i, (index, score) in enumerate(sorted_similar_games):
+            if score < 0.15:  # Minimum threshold for quality
                 continue
+            
+            # Enforce diversity by limiting games from same publisher
+            if 'publisher' in data.columns:
+                current_publisher = str(data.iloc[index].get('publisher', '')).lower()
+                if current_publisher in seen_publishers and len(seen_publishers) > 2:
+                    continue
+                seen_publishers.add(current_publisher)
                 
             game_name = data.iloc[index]['name']
             
@@ -225,10 +303,10 @@ def recommend_games(user_game_name_input):
             genres_display = ", ".join([g for g in genres if g])
             
             # Calculate match percentage
-            match_percentage = int(score * 100)
+            match_percentage = min(int(score * 100), 100)  # Cap at 100%
             
             # Format recommendation with clean styling
-            position = i + 1
+            position = recommended_count + 1
             recommendation = (
                 f"### {position}. {game_name}\n" +
                 f"**Match:** {match_percentage}%\n" +
@@ -239,8 +317,9 @@ def recommend_games(user_game_name_input):
             
             recommendations.append(recommendation)
             game_list.append(game_name)
+            recommended_count += 1
             
-            if len(recommendations) >= 7:  # searched game + divider + 5 recommendations
+            if recommended_count >= 5:  # Stop after 5 recommendations
                 break
         
         # Create price gauge visualization