Update app.py

app.py

@@ -5,163 +5,367 @@ from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.preprocessing import MinMaxScaler
 import difflib
+import numpy as np
 
-# Load dataset
-data = pd.read_csv('steam.csv', quotechar='"', on_bad_lines='skip', nrows=10000)
-data.fillna('', inplace=True)
+# Load dataset with proper error handling
+def load_data(file_path='steam.csv', max_rows=10000):
+    try:
+        data = pd.read_csv(file_path, quotechar='"', on_bad_lines='skip', nrows=max_rows)
+        print(f"Successfully loaded {len(data)} games from {file_path}")
+        return data
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        # Return empty DataFrame with expected columns to avoid crashing
+        return pd.DataFrame(columns=['name', 'genres', 'categories', 'steamspy_tags', 'platforms', 'positive_ratings'])
 
-# Combine features
-selected_features = ['genres', 'categories', 'steamspy_tags', 'platforms']
-for feature in selected_features:
-    if feature not in data.columns:
-        data[feature] = ''
-data['combined_features'] = data['genres'] + ' ' + data['categories'] + ' ' + data['steamspy_tags'] + ' ' + data['platforms']
+# Load and preprocess data
+data = load_data()
 
-# Vectorize
-vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2), max_features=8000)
-feature_vectors = vectorizer.fit_transform(data['combined_features'])
-
-# Normalize positive ratings
-scaler = MinMaxScaler()
-data['positive_ratings_scaled'] = scaler.fit_transform(data[['positive_ratings']])
-
-# Similarity matrix
-game_similarity = cosine_similarity(feature_vectors)
-list_of_all_titles = data['name'].tolist()
-
-# Recommend function
-def recommend_games(user_game_name_input):
-    find_close_match = difflib.get_close_matches(user_game_name_input, list_of_all_titles, n=1)
-    if not find_close_match:
-        return "No close match found. Please try another game name.", None, [], {}
-
-    closest_match = find_close_match[0]
-    index_of_the_game = data.loc[data['name'] == closest_match].index[0]
-
-    similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
-    sorted_similar_games = sorted(
-        similarity_scores, 
-        key=lambda x: (x[1], data.iloc[x[0]]['positive_ratings_scaled']), 
-        reverse=True
+# Only proceed if we have data
+if len(data) > 0:
+    # Handle missing values more carefully
+    for feature in ['genres', 'categories', 'steamspy_tags', 'platforms', 'positive_ratings']:
+        if feature not in data.columns:
+            data[feature] = ''
+        elif data[feature].dtype == object:  # Only fill string columns with empty strings
+            data[feature] = data[feature].fillna('')
+        else:
+            data[feature] = data[feature].fillna(0)  # Fill numeric columns with 0
+    
+    # Combine features
+    data['combined_features'] = (
+        data['genres'].astype(str) + ' ' + 
+        data['categories'].astype(str) + ' ' + 
+        data['steamspy_tags'].astype(str) + ' ' + 
+        data['platforms'].astype(str)
     )
+    
+    # Vectorize with error handling
+    try:
+        vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2), max_features=8000)
+        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}")
+        # Create empty feature vectors to avoid crashing
+        feature_vectors = np.zeros((len(data), 1))
+    
+    # Normalize positive ratings safely
+    if 'positive_ratings' in data.columns and len(data) > 0:
+        scaler = MinMaxScaler()
+        data['positive_ratings_scaled'] = scaler.fit_transform(
+            data[['positive_ratings']].clip(lower=0)  # Ensure no negative ratings
+        )
+    else:
+        data['positive_ratings_scaled'] = 0
+    
+    # Compute similarity matrix (only if we have enough data)
+    if feature_vectors.shape[0] > 1:
+        try:
+            # Use batched processing for large datasets to reduce memory usage
+            if len(data) > 5000:
+                print("Large dataset detected. Using batched similarity calculation.")
+                batch_size = 1000
+                similarity_matrix = np.zeros((len(data), len(data)))
+                
+                for i in range(0, len(data), batch_size):
+                    end = min(i + batch_size, len(data))
+                    batch = feature_vectors[i:end]
+                    similarity_matrix[i:end] = cosine_similarity(batch, feature_vectors)
+                
+                game_similarity = similarity_matrix
+            else:
+                game_similarity = cosine_similarity(feature_vectors)
+            
+            print(f"Similarity matrix created. Shape: {game_similarity.shape}")
+        except Exception as e:
+            print(f"Similarity calculation error: {e}")
+            # Create identity matrix as fallback
+            game_similarity = np.eye(len(data))
+    else:
+        game_similarity = np.eye(len(data))
+    
+    list_of_all_titles = data['name'].tolist()
+else:
+    # Fallbacks for empty data
+    feature_vectors = np.zeros((0, 0))
+    game_similarity = np.zeros((0, 0))
+    list_of_all_titles = []
 
-    recommendations = []
-    chart_data = []
-    radar_data = {}
-    for i, (index, score) in enumerate(sorted_similar_games[1:21]):
-        if score < 0.3:
-            continue
-        game_name = data.iloc[index]['name']
-        
-        # Get OS support info
-        platforms = data.iloc[index].get('platforms', '').lower()
-        os_icons = []
-        if 'windows' in platforms:
-            os_icons.append("🪟")
-        if 'mac' in platforms or 'macos' in platforms:
-            os_icons.append("🍎")
-        if 'linux' in platforms or 'steam' in platforms:
-            os_icons.append("🐧")
-        
-        os_display = ' '.join(os_icons) if os_icons else "❓"
-        
-        recommendations.append(f"{i+1}. {game_name} {os_display} (Similarity: {score*100:.1f}%)")
-        chart_data.append({'Game': game_name, 'Similarity': score * 100})
-        radar_data[game_name] = {
-            "genres": data.iloc[index]['genres'],
-            "categories": data.iloc[index]['categories']
-        }
-        
-        if len(recommendations) >= 10:
-            break
+# Platform detection function with improved logic
+def detect_platforms(platforms_str):
+    platforms_str = str(platforms_str).lower()
+    os_icons = []
+    
+    # More reliable platform detection
+    if 'windows' in platforms_str:
+        os_icons.append("🖥️ Windows")
+    if any(mac_term in platforms_str for mac_term in ['mac', 'macos', 'osx']):
+        os_icons.append("🍎 macOS")
+    if 'linux' in platforms_str:
+        os_icons.append("🐧 Linux")
+    
+    return os_icons if os_icons else ["❓ Unknown"]
 
-    chart_df = pd.DataFrame(chart_data)
-    return "\n".join(recommendations), chart_df, list(radar_data.keys()), radar_data
+# Recommend function with improved error handling and consistent return structure
+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, [], {}
+    
+    # Normalize input for better matching
+    user_input_cleaned = user_game_name_input.strip().lower()
+    
+    # First try exact match
+    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:
+        index_of_the_game = data.loc[data['name'] == closest_match].index[0]
+        
+        # Check for valid index
+        if index_of_the_game >= len(game_similarity):
+            return f"Found match '{closest_match}' but encountered an indexing error.", None, [], {}
+        
+        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
+        )
+        
+        recommendations = []
+        chart_data = []
+        radar_data = {}
+        
+        # Add the searched game as the first entry
+        recommendations.append(f"✓ You searched for: {closest_match}")
+        
+        # Process recommendations
+        for i, (index, score) in enumerate(sorted_similar_games[1:21]):
+            if score < 0.2:  # Higher threshold for better quality
+                continue
+                
+            game_name = data.iloc[index]['name']
+            
+            # Get platform info
+            platforms = data.iloc[index].get('platforms', '')
+            os_list = detect_platforms(platforms)
+            os_display = " | ".join(os_list)
+            
+            # Format recommendation with emoji
+            recommendations.append(f"{i+1}. {game_name} ({os_display}) - {score*100:.1f}% similar")
+            
+            # Store data for charts
+            chart_data.append({'Game': game_name, 'Similarity': score * 100})
+            
+            # Store data for radar chart
+            genres = data.iloc[index].get('genres', '')
+            categories = data.iloc[index].get('categories', '')
+            radar_data[game_name] = {
+                "genres": genres,
+                "categories": categories
+            }
+            
+            if len(recommendations) >= 11:  # 10 recommendations + original search
+                break
+        
+        chart_df = pd.DataFrame(chart_data) if chart_data else None
+        return "\n".join(recommendations), chart_df, list(radar_data.keys()), radar_data
+        
+    except Exception as e:
+        return f"Error while finding recommendations: {str(e)}", None, [], {}
 
-# Precision@5
+# Improved precision calculation
 def evaluate_precision(user_game_name_input):
-    find_close_match = difflib.get_close_matches(user_game_name_input, list_of_all_titles, n=1)
-    if not find_close_match:
+    if not user_game_name_input or not list_of_all_titles:
+        return 0.0
+    
+    try:
+        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 0.0
+            
+        closest_match = find_close_match[0]
+        index_of_the_game = data.loc[data['name'] == closest_match].index[0]
+        
+        if index_of_the_game >= len(game_similarity):
+            return 0.0
+            
+        similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
+        sorted_similar_games = sorted(
+            similarity_scores, 
+            key=lambda x: (x[1], data.iloc[x[0]]['positive_ratings_scaled']), 
+            reverse=True
+        )
+        
+        # Calculate precision based on genre overlap rather than exact match
+        top_5_indices = [idx for idx, _ in sorted_similar_games[1:6]]
+        original_genres = set(data.iloc[index_of_the_game]['genres'].split(';'))
+        
+        hits = 0
+        for idx in top_5_indices:
+            rec_genres = set(data.iloc[idx]['genres'].split(';'))
+            # Count as a hit if there's any genre overlap
+            if original_genres.intersection(rec_genres):
+                hits += 1
+                
+        return round(hits / 5, 2) if top_5_indices else 0.0
+        
+    except Exception as e:
+        print(f"Precision calculation error: {str(e)}")
         return 0.0
-    closest_match = find_close_match[0]
-    index_of_the_game = data.loc[data['name'] == closest_match].index[0]
-    similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
-    sorted_similar_games = sorted(
-        similarity_scores, 
-        key=lambda x: (x[1], data.iloc[x[0]]['positive_ratings_scaled']), 
-        reverse=True
-    )
-    top_5 = [data.iloc[idx]['genres'] for idx, _ in sorted_similar_games[1:6]]
-    original_genre = data.iloc[index_of_the_game]['genres']
-    hits = sum(1 for genre in top_5 if genre == original_genre)
-    return round(hits / 5, 2)
 
-# Radar plot function
+# Improved radar plot function
 def plot_game_features(game_name, radar_data):
-    if game_name not in radar_data:
+    if not game_name or game_name not in radar_data:
         return None
 
-    genres = radar_data[game_name]["genres"].split(';')
-    categories = radar_data[game_name]["categories"].split(';')
-    features = list(set([g.strip() for g in genres + categories if g.strip()]))
-
-    if not features:
-        return None
+    try:
+        # Extract features
+        genres = str(radar_data[game_name]["genres"]).split(';') if radar_data[game_name]["genres"] else []
+        categories = str(radar_data[game_name]["categories"]).split(';') if radar_data[game_name]["categories"] else []
+        
+        # Clean and deduplicate features
+        features = list(set([g.strip() for g in genres + categories if g.strip()]))
+        
+        # Limit to top features for readability
+        if len(features) > 10:
+            features = features[:10]
+            
+        if not features:
+            return None
 
-    values = [1] * len(features)
-    radar_df = pd.DataFrame(dict(
-        Feature=features,
-        Presence=values
-    ))
+        values = [1] * len(features)
+        radar_df = pd.DataFrame({
+            'Feature': features,
+            'Presence': values
+        })
 
-    fig = px.line_polar(radar_df, r='Presence', theta='Feature', line_close=True,
-                        title=f"Feature Radar: {game_name}", range_r=[0, 1])
-    fig.update_traces(fill='toself')
-    return fig
+        fig = px.line_polar(radar_df, r='Presence', theta='Feature', line_close=True,
+                            title=f"Feature Radar: {game_name}", range_r=[0, 1])
+        fig.update_traces(fill='toself')
+        return fig
+        
+    except Exception as e:
+        print(f"Radar chart error: {str(e)}")
+        return None
 
-# Combined Gradio function
+# Combined function with progress updates
 def recommend_and_visualize(user_input):
+    if not user_input or user_input.strip() == "":
+        return "Please enter a game name", None, [], {}
+        
+    # Get recommendations
     recommendations, chart_df, game_names, radar_data = recommend_games(user_input)
+    
+    # Calculate precision
     precision = evaluate_precision(user_input)
+    
+    # Create chart if data is available
     chart = None
-
     if chart_df is not None and not chart_df.empty:
-        chart = px.bar(chart_df, x="Game", y="Similarity", title="Top Game Recommendations", 
-                       labels={"Similarity": "Similarity (%)"}, height=400)
+        try:
+            chart = px.bar(chart_df, x="Game", y="Similarity", 
+                         title="Top Game Recommendations", 
+                         labels={"Similarity": "Similarity (%)"}, 
+                         height=400)
+            # Improve readability of labels
+            chart.update_layout(xaxis_tickangle=-45)
+        except Exception as e:
+            print(f"Chart creation error: {str(e)}")
+    
+    # Add platform legend and precision info
+    footer = "\n\n📊 **Recommendation Quality**: "
+    footer += f"Precision@5: {precision*100:.0f}%" if precision > 0 else "Unable to calculate precision"
+    
+    footer += "\n\n**Platform Legend**:\n"
+    footer += "🖥️ Windows | 🍎 macOS | 🐧 Linux | ❓ Unknown"
     
-    legend = "\n\n📌 **Platform Legend**\n🪟 = Windows\n🍎 = macOS\n🐧 = Linux\n❓ = Unknown"
-    return recommendations + f"\n\nPrecision@5 (approx): {precision}" + legend, chart, game_names, radar_data
+    return recommendations + footer, chart, game_names, radar_data
 
-# Trigger radar chart
+# Trigger radar chart display
 def show_selected_game_radar(game_name, radar_data):
+    if not game_name:
+        return None
     return plot_game_features(game_name, radar_data)
 
-# Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("## 🎮 Steam Game Recommender")
+# Improved Gradio UI
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎮 Steam Game Recommender")
     gr.Markdown("Enter the name of a game you like and get recommendations based on similarity!")
-
-    with gr.Row():
-        input_box = gr.Textbox(label="Your Favorite Game", placeholder="e.g., Portal 2")
-
-    with gr.Row():
-        output_text = gr.Textbox(label="Recommendations", lines=12, interactive=False)
-        output_chart = gr.Plot(label="Recommendation Chart")
-
-    run_button = gr.Button("Recommend")
-
+    
     with gr.Row():
-        dropdown = gr.Dropdown(label="Inspect a Recommended Game", choices=[], interactive=True)
-        radar_chart = gr.Plot(label="Genre/Category Radar")
-
+        with gr.Column(scale=4):
+            input_box = gr.Textbox(
+                label="Your Favorite Game", 
+                placeholder="e.g., Portal 2, Half-Life 2, Skyrim",
+                info="Type a game name that exists in the Steam dataset"
+            )
+        with gr.Column(scale=1):
+            run_button = gr.Button("Find Recommendations", variant="primary")
+    
+    with gr.Accordion("Status", open=False):
+        status_text = gr.Markdown(f"Dataset loaded: {len(data)} games")
+    
+    with gr.Tabs():
+        with gr.TabItem("Recommendations"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    output_text = gr.Textbox(
+                        label="Recommendations", 
+                        lines=15, 
+                        interactive=False
+                    )
+                with gr.Column(scale=3):
+                    output_chart = gr.Plot(label="Similarity Chart")
+                    
+        with gr.TabItem("Game Features"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    dropdown = gr.Dropdown(
+                        label="Select a Recommended Game to Analyze", 
+                        choices=[], 
+                        interactive=True,
+                        info="Choose a game to see its features"
+                    )
+                with gr.Column(scale=3):
+                    radar_chart = gr.Plot(label="Genre & Category Radar")
+    
+    # Store radar data between function calls
     radar_data_state = gr.State()
+    
+    # Register events
+    run_button.click(
+        fn=recommend_and_visualize, 
+        inputs=input_box, 
+        outputs=[output_text, output_chart, dropdown, radar_data_state],
+        show_progress=True
+    )
+    
+    # Also trigger on Enter key
+    input_box.submit(
+        fn=recommend_and_visualize, 
+        inputs=input_box, 
+        outputs=[output_text, output_chart, dropdown, radar_data_state],
+        show_progress=True
+    )
+    
+    dropdown.change(
+        fn=show_selected_game_radar, 
+        inputs=[dropdown, radar_data_state], 
+        outputs=radar_chart
+    )
 
-    run_button.click(fn=recommend_and_visualize, 
-                     inputs=input_box, 
-                     outputs=[output_text, output_chart, dropdown, radar_data_state])
-
-    dropdown.change(fn=show_selected_game_radar, 
-                    inputs=[dropdown, radar_data_state], 
-                    outputs=radar_chart)
-
-demo.launch()
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()