Removed Emojies

app.py

@@ -1,14 +1,11 @@
-import pandas as pd
 import gradio as gr
-import plotly.express as px
+import pandas as pd
+import numpy as np
+import difflib
 import plotly.graph_objects as go
 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
-import os
-import time
 
 # Load dataset with proper error handling
 def load_data(file_path='steam.csv', max_rows=27075):
@@ -26,47 +23,44 @@ data = load_data()
 
 # Only proceed if we have data
 if len(data) > 0:
-    # Handle missing values more carefully
+    # Handle missing values
     for feature in ['genres', 'categories', 'steamspy_tags', 'platforms', 'positive_ratings', 'price']:
         if feature not in data.columns:
             data[feature] = ''
-        elif data[feature].dtype == object:  # Only fill string columns with empty strings
+        elif data[feature].dtype == object:  # String columns
             data[feature] = data[feature].fillna('')
         else:
-            data[feature] = data[feature].fillna(0)  # Fill numeric columns with 0
+            data[feature] = data[feature].fillna(0)  # Numeric columns
     
-    # Combine features - now including price
+    # Combine features
     data['combined_features'] = (
         data['genres'].astype(str) + ' ' + 
         data['categories'].astype(str) + ' ' + 
         data['steamspy_tags'].astype(str) + ' ' + 
-        data['platforms'].astype(str) + ' ' +
-        data['price'].astype(str)  # Add price as a feature
+        data['platforms'].astype(str)
     )
     
-    # Vectorize with error handling
+    # Vectorize
     try:
-        vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2), max_features=8000)
+        vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2), max_features=5000)
         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
+    # Normalize positive ratings
     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
+            data[['positive_ratings']].clip(lower=0)
         )
     else:
         data['positive_ratings_scaled'] = 0
     
-    # Compute similarity matrix (only if we have enough data)
+    # Compute similarity matrix
     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
@@ -84,103 +78,73 @@ if len(data) > 0:
             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 = []
 
-# Cache for storing recommendation results to improve performance
-recommendation_cache = {}
-
-# Platform detection function with improved logic
+# Platform detection function without emojis
 def detect_platforms(platforms_str):
     platforms_str = str(platforms_str).lower()
-    os_icons = []
+    platforms = []
     
-    # More reliable platform detection
     if 'windows' in platforms_str:
-        os_icons.append("🖥️ Windows")
+        platforms.append("Windows")
     if any(mac_term in platforms_str for mac_term in ['mac', 'macos', 'osx']):
-        os_icons.append("🍎 macOS")
+        platforms.append("macOS")
     if 'linux' in platforms_str:
-        os_icons.append("🐧 Linux")
+        platforms.append("Linux")
     
-    return os_icons if os_icons else ["❓ Unknown"]
+    return platforms if platforms else ["Unknown"]
 
-# Generate a radar chart for game comparison
-def generate_game_comparison_chart(game_name):
-    if not game_name or game_name not in list_of_all_titles:
-        return None
+# Create price gauge visualization
+def create_price_gauge(game_price, similar_games_prices):
+    # Add the main game price to the list
+    all_prices = [game_price] + similar_games_prices
     
-    try:
-        # Get the game index
-        game_idx = data.loc[data['name'] == game_name].index[0]
-        
-        # Get top 3 similar games
-        similarity_scores = list(enumerate(game_similarity[game_idx]))
-        sorted_similar = sorted(similarity_scores, key=lambda x: x[1], reverse=True)[1:4]  # Skip the first one (the game itself)
-        
-        similar_games = [data.iloc[idx]['name'] for idx, _ in sorted_similar]
-        
-        # Create feature vectors for radar chart (using genres as features)
-        features = ['Action', 'Adventure', 'RPG', 'Strategy', 'Simulation', 'Sports', 'Racing']
-        chart_data = []
-        
-        # Add main game
-        main_game_data = data.iloc[game_idx]
-        main_genres = str(main_game_data.get('genres', '')).split(';')
-        main_values = [1 if genre in main_genres else 0.2 for genre in features]
-        chart_data.append(go.Scatterpolar(
-            r=main_values,
-            theta=features,
-            fill='toself',
-            name=game_name
-        ))
-        
-        # Add similar games
-        for idx, score in sorted_similar:
-            sim_game = data.iloc[idx]
-            sim_genres = str(sim_game.get('genres', '')).split(';')
-            sim_values = [1 if genre in sim_genres else 0.2 for genre in features]
-            chart_data.append(go.Scatterpolar(
-                r=sim_values,
-                theta=features,
-                fill='toself',
-                name=sim_game['name']
-            ))
-        
-        fig = go.Figure(data=chart_data)
-        fig.update_layout(
-            polar=dict(
-                radialaxis=dict(
-                    visible=True,
-                    range=[0, 1]
-                )
-            ),
-            showlegend=True,
-            title=f"Genre Comparison: {game_name} vs Similar Games"
-        )
-        
-        return fig
-    except Exception as e:
-        print(f"Error generating comparison chart: {e}")
-        return None
+    # Filter out None values and convert to float
+    all_prices = [float(p) if p is not None else 0 for p in all_prices]
+    
+    # Calculate stats
+    max_price = max(all_prices) if all_prices else 60  # Default max if no prices
+    avg_price = sum(all_prices) / len(all_prices) if all_prices else 0
+    
+    # Create gauge for the main game price
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=game_price if game_price is not None else 0,
+        title={'text': "Game Price ($)"},
+        gauge={
+            'axis': {'range': [0, max(max_price, 60)]},  # Ensure reasonable scale
+            'bar': {'color': "#1DB954"},  # Steam-like green
+            'steps': [
+                {'range': [0, avg_price], 'color': "lightgray"},
+                {'range': [avg_price, max_price], 'color': "gray"}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': avg_price
+            }
+        }
+    ))
+    
+    fig.update_layout(
+        height=300,
+        margin=dict(l=20, r=20, t=50, b=20),
+    )
+    
+    return fig
 
-# Enhanced recommendation function with better formatting and emojis
+# Function to get game recommendations
 def recommend_games(user_game_name_input):
-    # Check cache first
-    if user_game_name_input in recommendation_cache:
-        return recommendation_cache[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.", []
+        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()
@@ -194,7 +158,7 @@ def recommend_games(user_game_name_input):
         # 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.", []
+            return f"No match found for '{user_game_name_input}'. Please try another game name.", [], None
         closest_match = find_close_match[0]
     
     try:
@@ -202,7 +166,7 @@ def recommend_games(user_game_name_input):
         
         # Check for valid index
         if index_of_the_game >= len(game_similarity):
-            return f"Found match '{closest_match}' but encountered an indexing error.", []
+            return f"Found match '{closest_match}' but encountered an indexing error.", [], None
         
         similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
         
@@ -221,12 +185,12 @@ def recommend_games(user_game_name_input):
         searched_game_genres = str(searched_game.get('genres', '')).split(';')
         searched_game_genres_display = ", ".join([g for g in searched_game_genres if g])
         searched_game_platforms = detect_platforms(searched_game.get('platforms', ''))
-        searched_game_platform_display = " ".join(searched_game_platforms)
+        searched_game_platform_display = ", ".join(searched_game_platforms)
         searched_game_price = searched_game.get('price', 0)
-        searched_game_price_display = f"${searched_game_price:.2f}" if isinstance(searched_game_price, (int, float)) and searched_game_price > 0 else "Free" if searched_game_price == 0 else "N/A"
+        searched_game_price_display = f"${searched_game_price:.2f}" if isinstance(searched_game_price, (int, float)) else "N/A"
         
-        # Format the searched game with nicer styling
-        recommendations.append(f"## 🎮 You searched for: {closest_match}\n" +
+        # Format the searched game with clean styling
+        recommendations.append(f"## You searched for: {closest_match}\n" +
                               f"**Genres:** {searched_game_genres_display}\n" +
                               f"**Platforms:** {searched_game_platform_display}\n" +
                               f"**Price:** {searched_game_price_display}\n")
@@ -234,339 +198,101 @@ def recommend_games(user_game_name_input):
         game_list.append(closest_match)
         
         # Add a divider
-        recommendations.append("---\n## 🏆 Top Recommendations\n")
+        recommendations.append("---\n## Top Recommendations\n")
         
-        # Generate emoji for each position
-        position_emojis = ["🥇", "🥈", "🥉", "4️⃣", "5️⃣"]
+        # Get prices for similar games (for gauge visualization)
+        similar_games_prices = []
         
         # Process recommendations
-        for i, (index, score) in enumerate(sorted_similar_games[1:11]):  # Only process first 10 to find 5 good ones
-            if score < 0.2:  # Higher threshold for better quality
+        for i, (index, score) in enumerate(sorted_similar_games[1:6]):  # Get top 5 recommendations
+            if score < 0.2:  # Minimum threshold for 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)
+            platform_list = detect_platforms(platforms)
+            platform_display = ", ".join(platform_list)
             
             # Get price info
             price = data.iloc[index].get('price', 0)
-            price_display = f"${price:.2f}" if isinstance(price, (int, float)) and price > 0 else "Free" if price == 0 else "N/A"
+            similar_games_prices.append(price)
+            price_display = f"${price:.2f}" if isinstance(price, (int, float)) else "N/A"
             
-            # Get genre info for additional context
+            # Get genre info
             genres = str(data.iloc[index].get('genres', '')).split(';')
             genres_display = ", ".join([g for g in genres if g])
             
-            # Get positive ratings
-            positive_ratings = data.iloc[index].get('positive_ratings', 0)
-            
-            # Determine emoji based on game type
-            category_emoji = "🔫" if "Action" in genres_display else "🧙" if "RPG" in genres_display else "🏎️" if "Racing" in genres_display else "🧩" if "Puzzle" in genres_display else "🌍" if "Adventure" in genres_display else "⚔️" if "Strategy" in genres_display else "🏡" if "Simulation" in genres_display else "🎲"
-            
             # Calculate match percentage
             match_percentage = int(score * 100)
             
-            # Create match bar
-            match_bar = "█" * (match_percentage // 10) + "░" * (10 - (match_percentage // 10))
-            
-            # Create color indicator based on match percentage
-            color_indicator = "🟢" if match_percentage >= 80 else "🟡" if match_percentage >= 60 else "🟠" if match_percentage >= 40 else "🔴"
-            
-            # Format recommendation with emoji and more details
-            position_emoji = position_emojis[i] if i < len(position_emojis) else f"{i+1}."
-            
+            # Format recommendation with clean styling
+            position = i + 1
             recommendation = (
-                f"### {position_emoji} {category_emoji} {game_name}\n" +
-                f"**Match:** {color_indicator} {match_percentage}% {match_bar}\n" +
+                f"### {position}. {game_name}\n" +
+                f"**Match:** {match_percentage}%\n" +
                 f"**Genres:** {genres_display}\n" +
-                f"**Platforms:** {os_display}\n" +
+                f"**Platforms:** {platform_display}\n" +
                 f"**Price:** {price_display}\n"
             )
             
             recommendations.append(recommendation)
-            
-            # Add to game list
             game_list.append(game_name)
             
             if len(recommendations) >= 7:  # searched game + divider + 5 recommendations
                 break
         
-        result = ("\n".join(recommendations), game_list)
-        recommendation_cache[user_game_name_input] = result  # Cache the result
-        return result
-        
-    except Exception as e:
-        return f"Error while finding recommendations: {str(e)}", []
-
-# Improved precision calculation
-def evaluate_precision(user_game_name_input):
-    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
-        )
+        # Create price gauge visualization
+        price_gauge = create_price_gauge(searched_game_price, similar_games_prices)
         
-        # 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
+        return "\n".join(recommendations), game_list, price_gauge
         
     except Exception as e:
-        print(f"Precision calculation error: {str(e)}")
-        return 0.0
+        return f"Error while finding recommendations: {str(e)}", [], None
 
-# 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", []
-        
-    # Get recommendations
-    recommendations, game_list = recommend_games(user_input)
-    
-    # Calculate precision
-    precision = evaluate_precision(user_input)
-    
-    # Add platform legend and precision info
-    footer = "\n\n---\n"
-    footer += f"📊 **Recommendation Quality:** {precision*100:.0f}% precision" if precision > 0 else "📊 **Recommendation Quality:** Unable to calculate precision"
-    
-    return recommendations + footer, game_list
-
-# Function to generate price distribution chart
-def generate_price_chart():
-    try:
-        # Filter for reasonable prices (exclude outliers)
-        price_data = data[data['price'] < 100].copy()
-        
-        # Create price bins
-        price_bins = [0, 5, 10, 15, 20, 30, 50, 100]
-        price_data['price_category'] = pd.cut(price_data['price'], bins=price_bins, right=False)
-        
-        # Count games in each price bin
-        price_counts = price_data['price_category'].value_counts().sort_index()
-        
-        # Create bar chart
-        fig = px.bar(
-            x=[str(cat) for cat in price_counts.index],
-            y=price_counts.values,
-            labels={'x': 'Price Range ($)', 'y': 'Number of Games'},
-            title='Price Distribution of Steam Games',
-            color_discrete_sequence=['#1DB954']  # Steam-like green
-        )
-        
-        # Update layout
-        fig.update_layout(
-            xaxis_title='Price Range ($)',
-            yaxis_title='Number of Games',
-            template='plotly_white'
-        )
-        
-        return fig
-    except Exception as e:
-        print(f"Error generating price chart: {e}")
-        return None
-
-# Function to create genre distribution chart
-def create_genre_chart():
-    try:
-        # Extract all genres
-        all_genres = []
-        for genres in data['genres'].dropna():
-            all_genres.extend([g.strip() for g in str(genres).split(';') if g.strip()])
-        
-        # Get counts
-        genre_counts = pd.Series(all_genres).value_counts().nlargest(10)
-        
-        # Create bar chart
-        fig = px.bar(
-            x=genre_counts.index,
-            y=genre_counts.values,
-            labels={'x': 'Genre', 'y': 'Number of Games'},
-            title='Top 10 Game Genres on Steam',
-            color_discrete_sequence=['#66c0f4']  # Steam blue
-        )
-        
-        fig.update_layout(
-            xaxis_title='Genre',
-            yaxis_title='Number of Games',
-            template='plotly_white'
-        )
-        
-        return fig
-    except Exception as e:
-        print(f"Error creating genre chart: {e}")
-        return None
-
-# Improved Gradio UI with added features
+# Gradio UI with simplified design
 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!")
+    gr.Markdown("# Steam Game Recommender")
+    gr.Markdown("Enter the name of a game you like and get recommendations based on similarity.")
     
-    with gr.Tab("Find Recommendations"):
-        with gr.Row():
-            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.Row():
-            # Changed to markdown for better formatting
-            output_text = gr.Markdown(
-                label="Recommendations"
+    with gr.Row():
+        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.Tab("Statistics"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("## Game Price Distribution")
-                price_chart = gr.Plot(value=generate_price_chart())
-            
-            with gr.Column():
-                gr.Markdown("## Top Game Genres")
-                genre_chart = gr.Plot(value=create_genre_chart())
-                
-        with gr.Row():
-            refresh_stats_button = gr.Button("Refresh Statistics")
+        with gr.Column(scale=1):
+            run_button = gr.Button("Find Recommendations", variant="primary")
     
-    # Add a tab for help/about
-    with gr.Tab("About"):
-        gr.Markdown("""
-        ## About This Recommender
-        
-        This Steam game recommender uses **TF-IDF vectorization** and **cosine similarity** to find games similar to your favorites. The recommendation engine analyzes:
-        
-        - Game genres
-        - Categories
-        - User-defined tags
-        - Platforms
-        - Price points
-        
-        The system then ranks games by similarity score and refines results using positive user ratings.
-        
-        ### How to Use
-        
-        1. Enter the name of a game you enjoy in the search box
-        2. Click "Find Recommendations" to see similar games
-        3. Explore the Statistics tab to see distributions of game prices and genres
-        
-        ### Dataset
-        
-        This system uses a dataset of Steam games with features like:
-        - Game title
-        - Genres
-        - Categories
-        - User tags
-        - Price
-        - Platform compatibility
-        - User ratings
-        
-        ### Limitations
-        
-        - Recommendations depend on data quality and completeness
-        - The system works best with popular titles that have detailed metadata
-        - Very niche or new games may have fewer accurate recommendations
-        """)
-    
-    # Add a search history tab
-    with gr.Tab("Search History"):
-        search_history = gr.Dataframe(
-            headers=["Time", "Search Query", "Top Recommendation"],
-            datatype=["str", "str", "str"],
-            row_count=10,
-            col_count=(3, "fixed"),
-            value=[]
-        )
-        
-        clear_history_button = gr.Button("Clear History")
+    with gr.Row():
+        with gr.Column(scale=3):
+            # Recommendations output
+            output_text = gr.Markdown(label="Recommendations")
+        with gr.Column(scale=2):
+            # Price gauge visualization
+            price_gauge = gr.Plot(label="Price Comparison")
     
-    # Register events
-    search_history_data = []
-    
-    def update_search_history(user_input):
-        if not user_input or user_input.strip() == "":
-            return search_history_data
-            
-        recommendations, game_list = recommend_games(user_input)
-        
-        # Format timestamp
-        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-        
-        # Get top recommendation (if any)
-        top_rec = game_list[1] if len(game_list) > 1 else "No recommendation found"
-        
-        # Add to history
-        search_history_data.append([timestamp, user_input, top_rec])
-        
-        # Keep only the most recent 10 entries
-        return search_history_data[-10:]
-    
-    def clear_history():
-        search_history_data.clear()
-        return []
-    
-    # Combined function to update recommendations and history
-    def recommend_and_update_history(user_input):
-        rec_text, game_list = recommend_and_visualize(user_input)
-        history = update_search_history(user_input)
-        return rec_text, history
+    # Register event
+    def on_submit(user_input):
+        rec_text, game_list, gauge = recommend_games(user_input)
+        return rec_text, gauge
     
     run_button.click(
-        fn=recommend_and_update_history, 
+        fn=on_submit, 
         inputs=input_box, 
-        outputs=[output_text, search_history],
+        outputs=[output_text, price_gauge],
         show_progress=True
     )
     
     # Also trigger on Enter key
     input_box.submit(
-        fn=recommend_and_update_history, 
+        fn=on_submit, 
         inputs=input_box, 
-        outputs=[output_text, search_history],
+        outputs=[output_text, price_gauge],
         show_progress=True
     )
-    
-    # Clear history button
-    clear_history_button.click(
-        fn=clear_history,
-        inputs=[],
-        outputs=[search_history]
-    )
-    
-    # Refresh statistics
-    refresh_stats_button.click(
-        fn=lambda: (generate_price_chart(), create_genre_chart()),
-        inputs=[],
-        outputs=[price_chart, genre_chart]
-    )
 
 # Launch the Gradio app
 if __name__ == "__main__":