NewRecommenderDataset

app.py

@@ -1,597 +1,149 @@
-import gradio as gr
 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 gradio as gr
+import numpy as np
 
-# Load dataset with proper error handling
-def load_data(file_path='games_march2025_cleaned.csv', max_rows=88899):
+# Load the data - when deploying, adjust the path to where your dataset will be stored
+def load_data():
     try:
-        data = pd.read_csv(file_path, quotechar='"', on_bad_lines='skip', nrows=max_rows, engine='python')
-        print(f"Successfully loaded {len(data)} games from {file_path}")
+        # For Hugging Face Spaces deployment, you might need to adjust this path
+        data = pd.read_csv('games_march2025_cleaned.csv', nrows=20000, on_bad_lines='skip', engine='python')
         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', 'tags', 'platforms', 'positive_ratings', 'price'])
-
-# Load and preprocess data
-data = load_data()
-
-# Only proceed if we have data
-if len(data) > 0:
-    # Handle missing values
-    for feature in ['genres', 'categories', 'tags', 'platforms', 'positive_ratings', 'negative_ratings', 'price']:
-        if feature not in data.columns:
-            data[feature] = ''
-        elif data[feature].dtype == object:  # String columns
-            data[feature] = data[feature].fillna('')
-        else:
-            data[feature] = data[feature].fillna(0)  # Numeric columns
-    
-    # Add derived features for better recommendations
-    if 'positive_ratings' in data.columns and 'negative_ratings' in data.columns:
-        data['positive_ratings'] = pd.to_numeric(data['positive_ratings'], errors='coerce')
-        data['negative_ratings'] = pd.to_numeric(data['negative_ratings'], errors='coerce')
-        data.dropna(subset=['positive_ratings', 'negative_ratings'], inplace=True)
-
-        data['rating_ratio'] = data['positive_ratings'] / (data['positive_ratings'] + data['negative_ratings'] + 1)
+        return None
 
-    else:
-        data['rating_ratio'] = 0.5  # Default neutral rating
-    
-    # Add playtime features if available - FIX: Added proper checks for empty data
-    if 'average_playtime_forever' in data.columns:
-        # Log transform to handle skewed distribution
-        data['log_playtime'] = np.log1p(data['average_playtime_forever'])
-        
-        # FIX: Check if we have valid data before scaling
-        if len(data) > 0 and not data['log_playtime'].isna().all():
-            try:
-                scaler = MinMaxScaler()
-                # FIX: Only scale non-NA values
-                valid_playtime_mask = ~data['log_playtime'].isna()
-                if valid_playtime_mask.any():  # Only if we have any valid values
-                    data.loc[valid_playtime_mask, 'playtime_scaled'] = scaler.fit_transform(
-                        data.loc[valid_playtime_mask, ['log_playtime']]
-                    )
-                else:
-                    data['playtime_scaled'] = 0.5
-            except Exception as e:
-                print(f"Error in playtime scaling: {e}")
-                data['playtime_scaled'] = 0.5
-        else:
-            data['playtime_scaled'] = 0.5
-    else:
-        data['playtime_scaled'] = 0.5
-    
-    # Add user score features if available - FIX: Added proper checks
-    if 'user_score' in data.columns:
-        # FIX: Handle potential non-numeric values
-        data['user_score'] = pd.to_numeric(data['user_score'], errors='coerce')
-        # FIX: Check for NaN values before scaling
-        data['user_score_scaled'] = data['user_score'].fillna(50) / 100.0  # Assuming user_score is out of 100
-    else:
-        data['user_score_scaled'] = 0.5
-    
-    # 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) + ' '
+# Prepare the feature vectors for similarity calculation
+def prepare_features(data):
+    selected_features = ['genres', 'price', 'average_playtime_2weeks', 'tags', 'average_playtime_forever']
+    
+    for feature in selected_features:
+        data[feature] = data[feature].fillna('')
+    
+    combined_features = (
+        data['genres'] + ' ' +
+        data['price'].astype(str) + ' ' +
+        data['average_playtime_2weeks'].astype(str) + ' ' +
+        data['tags'].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) + ' '
+    vectorizer = TfidfVectorizer()
+    feature_vectors = vectorizer.fit_transform(combined_features)
     
-    # Add other features
-    for feature in ['categories', 'tags', 'platforms']:
-        if feature in data.columns:
-            data['combined_features'] += data[feature].astype(str) + ' '
+    return feature_vectors
+
+# Function to get game recommendations
+def get_recommendations(game_name, data, feature_vectors):
+    list_of_all_titles = data['name'].tolist()
+    find_close_match = difflib.get_close_matches(game_name, list_of_all_titles)
     
-    # Add developers and publishers if available
-    for feature in ['developers', 'publishers']:
-        if feature in data.columns:
-            data['combined_features'] += data[feature].astype(str) + ' '
+    if not find_close_match:
+        return "No match found for the game name. Please try another title."
     
-    # Clean the combined features
-    data['combined_features'] = data['combined_features'].str.replace(';', ' ').str.replace("'", '').str.replace('[', '').str.replace(']', '').str.replace('{', '').str.replace('}', '').str.lower()
+    closest_match = find_close_match[0]
+    index_of_the_game = data.loc[data['name'] == closest_match].index[0]
     
-    # Vectorize with improved parameters
-    try:
-        # FIX: Check if we have enough data for vectorization
-        if len(data) > 1:
-            # 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}")
-        else:
-            print("Not enough data for vectorization")
-            feature_vectors = np.zeros((len(data), 1))
-    except Exception as e:
-        print(f"Vectorization error: {e}")
-        feature_vectors = np.zeros((len(data), 1))
+    game_similarity = cosine_similarity(feature_vectors)
+    similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
+    sorted_similar_games = sorted(similarity_scores, key=lambda x: x[1], reverse=True)
     
-    # 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'])
+    results = []
+    for i, game in enumerate(sorted_similar_games[1:10], 1):  # Skip the first one as it's the game itself
+        index = game[0]
+        name = data.loc[index, 'name']
         
-        # FIX: Check for valid data before scaling
-        if not data['log_ratings'].isna().all():
-            try:
-                scaler = MinMaxScaler()
-                valid_ratings_mask = ~data['log_ratings'].isna()
-                if valid_ratings_mask.any():
-                    data.loc[valid_ratings_mask, 'positive_ratings_scaled'] = scaler.fit_transform(
-                        data.loc[valid_ratings_mask, ['log_ratings']]
-                    )
-                else:
-                    data['positive_ratings_scaled'] = 0
-            except Exception as e:
-                print(f"Error in ratings scaling: {e}")
-                data['positive_ratings_scaled'] = 0
-        else:
-            data['positive_ratings_scaled'] = 0
-    else:
-        data['positive_ratings_scaled'] = 0
-    
-    # Compute similarity matrix with optimizations
-    if feature_vectors.shape[0] > 1:
-        try:
-            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}")
-            game_similarity = np.eye(len(data))
-    else:
-        game_similarity = np.eye(len(data))
-    
-    list_of_all_titles = data['name'].tolist()
-else:
-    feature_vectors = np.zeros((0, 0))
-    game_similarity = np.zeros((0, 0))
-    list_of_all_titles = []
-
-# Improved platform detection function
-def detect_platforms(platforms_str):
-    platforms = []
-    
-    if isinstance(platforms_str, str):
-        platforms_str = platforms_str.lower()
+        # Get additional information
+        about = data.loc[index, 'about_the_game'] if 'about_the_game' in data.columns else "No description available"
+        image_url = data.loc[index, 'header_image'] if 'header_image' in data.columns else None
         
-        if 'windows' in platforms_str or 'true' in platforms_str:
+        # Get platform information
+        platforms = []
+        if 'windows' in data.columns and data.loc[index, 'windows'] == 1:
             platforms.append("Windows")
-        if any(mac_term in platforms_str for mac_term in ['mac', 'macos', 'osx']):
-            platforms.append("macOS")
-        if 'linux' in platforms_str:
+        if 'mac' in data.columns and data.loc[index, 'mac'] == 1:
+            platforms.append("Mac")
+        if 'linux' in data.columns and data.loc[index, 'linux'] == 1:
             platforms.append("Linux")
-        if any(mobile_term in platforms_str for mobile_term in ['android', 'ios', 'mobile']):
-            platforms.append("Mobile")
-    elif isinstance(platforms_str, bool) and platforms_str:
-        # Handle boolean True values
-        platforms.append("Windows")  # Assuming Windows by default if boolean True
-    
-    return platforms if platforms else ["Unknown"]
-
-# Extract platform information from dataset columns
-def get_platforms(row):
-    platforms = []
-    
-    # Check for platform columns from the screenshots (windows, mac, linux)
-    if 'windows' in row and row['windows']:
-        platforms.append("Windows")
-    if 'mac' in row and row['mac']:
-        platforms.append("macOS")
-    if 'linux' in row and row['linux']:
-        platforms.append("Linux")
-    
-    # If no platforms detected but there's a platforms field, try that
-    if not platforms and 'platforms' in row:
-        platforms = detect_platforms(row['platforms'])
-    
-    return platforms if platforms else ["Unknown"]
-
-# Extract genre information
-def extract_genres(genres_str):
-    if not genres_str or pd.isna(genres_str):
-        return []
-    
-    # Handle different formats that might be in the data
-    if isinstance(genres_str, str):
-        # Remove common formatting characters
-        clean_str = genres_str.replace("'", "").replace("[", "").replace("]", "").replace("{", "").replace("}", "")
+        platforms_str = ", ".join(platforms) if platforms else "Unknown"
         
-        # Try different delimiters
-        if ',' in clean_str:
-            return [g.strip() for g in clean_str.split(',') if g.strip()]
-        elif ';' in clean_str:
-            return [g.strip() for g in clean_str.split(';') if g.strip()]
+        # Format the result
+        result = f"**{i}. {name}**\n\n"
+        result += f"**Platforms:** {platforms_str}\n\n"
+        
+        # Truncate the about text to keep output clean
+        if about and about != "":
+            about_truncated = about[:300] + "..." if len(about) > 300 else about
+            result += f"**About the Game:** {about_truncated}\n\n"
         else:
-            return [clean_str]
-    
-    return []
-
-# 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
-    
-    # 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
-
-# Create user ratings visualization
-def create_ratings_chart(game_data):
-    if not isinstance(game_data, dict):
-        return None
-    
-    # Extract ratings data
-    game_name = game_data.get('name', 'Unknown')
-    positive = game_data.get('positive', 0)
-    negative = game_data.get('negative', 0)
-    
-    # Calculate percentages
-    total = positive + negative
-    if total == 0:
-        positive_pct = 0
-        negative_pct = 0
-    else:
-        positive_pct = (positive / total) * 100
-        negative_pct = (negative / total) * 100
-    
-    # Create bar chart
-    fig = go.Figure()
-    
-    fig.add_trace(go.Bar(
-        x=['Positive', 'Negative'],
-        y=[positive, negative],
-        text=[f"{positive:,} ({positive_pct:.1f}%)", f"{negative:,} ({negative_pct:.1f}%)"],
-        textposition='auto',
-        marker_color=['#66c0f4', '#ff7b7b']  # Steam-like colors
-    ))
-    
-    fig.update_layout(
-        title=f"User Ratings for {game_name}",
-        xaxis_title="Rating Type",
-        yaxis_title="Number of Ratings",
-        height=300,
-        margin=dict(l=20, r=20, t=50, b=20),
-    )
+            result += "**About the Game:** No description available\n\n"
+        
+        result += "---\n\n"
+        
+        results.append((result, image_url))
     
-    return fig
+    return results
 
-# 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, None
-    
-    # Normalize input for better matching
-    user_input_cleaned = user_game_name_input.strip().lower()
-    
-    # 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 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]
+# Gradio interface function
+def recommend_games(game_name):
+    data = load_data()
+    if data is None:
+        return "Failed to load data. Please check the data file."
+    
+    feature_vectors = prepare_features(data)
+    recommendations = get_recommendations(game_name, data, feature_vectors)
+    
+    if isinstance(recommendations, str):
+        return recommendations
+    
+    # Format the output for Gradio
+    result_texts = []
+    result_images = []
+    
+    for result, image_url in recommendations:
+        result_texts.append(result)
+        if image_url and str(image_url) != 'nan':
+            result_images.append(image_url)
         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, None
-            
-            # Take the closest match
-            closest_match = find_close_match[0]
+            # Use a placeholder image if no image URL is available
+            result_images.append(None)
     
-    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, None
-        
-        similarity_scores = list(enumerate(game_similarity[index_of_the_game]))
-        
-        # 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 = extract_genres(data.iloc[index_of_the_game].get('genres', ''))
-            current_game_genres = extract_genres(data.iloc[idx].get('genres', ''))
-            
-            # Count matching genres
-            matching_genres = len(set(searched_game_genres) & set(current_game_genres))
-            genre_factor = matching_genres / max(len(searched_game_genres), 1) if searched_game_genres else 0
-            
-            # Add playtime score if available
-            playtime_factor = data.iloc[idx].get('playtime_scaled', 0)
-            
-            # Create hybrid score with weights
-            hybrid_score = (
-                0.60 * sim_score +       # Base similarity from TF-IDF vectors
-                0.15 * rating_factor +   # Rating popularity 
-                0.15 * genre_factor +    # Genre match
-                0.10 * playtime_factor   # Playtime popularity
-            )
-            
-            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 = []
-        
-        # Get searched game details
-        searched_game = data.iloc[index_of_the_game]
-        
-        # Extract genres
-        searched_game_genres = extract_genres(searched_game.get('genres', ''))
-        searched_game_genres_display = ", ".join([g for g in searched_game_genres if g])
-        
-        # Extract platforms
-        searched_game_platforms = get_platforms(searched_game)
-        searched_game_platform_display = ", ".join(searched_game_platforms)
-        
-        # Get price
-        searched_game_price = searched_game.get('price', 0)
-        searched_game_price_display = f"${searched_game_price:.2f}" if isinstance(searched_game_price, (int, float)) else "N/A"
-        
-        # Get ratings
-        searched_game_positive = searched_game.get('positive_ratings', searched_game.get('positive', 0))
-        searched_game_negative = searched_game.get('negative_ratings', searched_game.get('negative', 0))
-        
-        # Get metacritic score if available
-        metacritic_score = searched_game.get('metacritic_score', 'N/A')
-        metacritic_display = f"{metacritic_score}/100" if metacritic_score != 'N/A' else "N/A"
-        
-        # Get user score if available
-        user_score = searched_game.get('user_score', 'N/A') 
-        user_score_display = f"{user_score}/100" if user_score != 'N/A' else "N/A"
-        
-        # Get playtime if available
-        avg_playtime = searched_game.get('average_playtime_forever', 0)
-        playtime_display = f"{avg_playtime} minutes" if avg_playtime > 0 else "N/A"
-        
-        # 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" +
-                              f"**Metacritic Score:** {metacritic_display}\n" +
-                              f"**User Score:** {user_score_display}\n" +
-                              f"**Average Playtime:** {playtime_display}\n")
-        
-        game_list.append(closest_match)
-        
-        # Add a divider
-        recommendations.append("---\n## Top Recommendations\n")
-        
-        # Get prices and ratings for similar games (for gauge visualization)
-        similar_games_prices = []
-        
-        # Create ratings data for visualization
-        ratings_data = {
-            'name': closest_match,
-            'positive': searched_game_positive,
-            'negative': searched_game_negative
-        }
-        
-        # Process recommendations with diversity enforcement
-        seen_publishers = set()
-        if 'publishers' in data.columns:
-            searched_game_publisher = str(searched_game.get('publishers', '')).lower()
-            seen_publishers.add(searched_game_publisher)
-        
-        recommended_count = 0
-        
-        # Process recommendations
-        for i, (index, score) in enumerate(sorted_similar_games):
-            if score < 0.10:  # Minimum threshold for quality
-                continue
-            
-            # Enforce diversity by limiting games from same publisher
-            if 'publishers' in data.columns:
-                current_publisher = str(data.iloc[index].get('publishers', '')).lower()
-                if current_publisher in seen_publishers and len(seen_publishers) > 2:
-                    continue
-                seen_publishers.add(current_publisher)
-                
-            game_name = data.iloc[index]['name']
-            
-            # Get platform info
-            platform_list = get_platforms(data.iloc[index])
-            platform_display = ", ".join(platform_list)
-            
-            # Get price info
-            price = data.iloc[index].get('price', 0)
-            similar_games_prices.append(price)
-            price_display = f"${price:.2f}" if isinstance(price, (int, float)) else "N/A"
-            
-            # Get genre info
-            genres = extract_genres(data.iloc[index].get('genres', ''))
-            genres_display = ", ".join([g for g in genres if g])
-            
-            # Get metacritic score if available
-            rec_metacritic_score = data.iloc[index].get('metacritic_score', 'N/A')
-            rec_metacritic_display = f"{rec_metacritic_score}/100" if rec_metacritic_score != 'N/A' else "N/A"
-            
-            # Get user score if available
-            rec_user_score = data.iloc[index].get('user_score', 'N/A')
-            rec_user_score_display = f"{rec_user_score}/100" if rec_user_score != 'N/A' else "N/A"
-            
-            # Calculate match percentage
-            match_percentage = min(int(score * 100), 100)  # Cap at 100%
-            
-            # Format recommendation with clean styling
-            position = recommended_count + 1
-            recommendation = (
-                f"### {position}. {game_name}\n" +
-                f"**Match:** {match_percentage}%\n" +
-                f"**Genres:** {genres_display}\n" +
-                f"**Platforms:** {platform_display}\n" +
-                f"**Price:** {price_display}\n" +
-                f"**Metacritic Score:** {rec_metacritic_display}\n" +
-                f"**User Score:** {rec_user_score_display}\n"
-            )
-            
-            recommendations.append(recommendation)
-            game_list.append(game_name)
-            recommended_count += 1
-            
-            if recommended_count >= 5:  # Stop after 5 recommendations
-                break
-        
-        # Create price gauge visualization
-        price_gauge = create_price_gauge(searched_game_price, similar_games_prices)
-        
-        # Create ratings chart
-        ratings_chart = create_ratings_chart(ratings_data)
-        
-        return "\n".join(recommendations), game_list, price_gauge, ratings_chart
-        
-    except Exception as e:
-        return f"Error while finding recommendations: {str(e)}", [], None, None
+    # Create a gallery of results
+    results_html = ""
+    for i, (text, img) in enumerate(zip(result_texts, result_images)):
+        results_html += text
+    
+    return results_html, result_images
 
-# Gradio UI with improved design
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+# Create the Gradio interface
+with gr.Blocks(title="Steam Game Recommender") as demo:
     gr.Markdown("# Steam Game Recommender")
-    gr.Markdown("Enter the name of a game you like and get recommendations based on similarity analysis of our Steam games dataset.")
+    gr.Markdown("Enter your favorite game to get recommendations for similar games.")
     
     with gr.Row():
-        with gr.Column(scale=4):
-            input_box = gr.Textbox(
-                label="Your Favorite Game", 
-                placeholder="e.g., Counter-Strike, PUBG, Dota 2, Grand Theft Auto V",
-                info="Type a game name that exists in the Steam dataset"
-            )
-        with gr.Column(scale=1):
-            run_button = gr.Button("Find Recommendations", variant="primary")
+        input_text = gr.Textbox(label="Enter your favorite game:")
+        submit_btn = gr.Button("Get Recommendations")
     
-    with gr.Tabs():
-        with gr.TabItem("Recommendations"):
-            with gr.Row():
-                with gr.Column(scale=3):
-                    # Recommendations output
-                    output_text = gr.Markdown(label="Recommendations")
-                with gr.Column(scale=2):
-                    with gr.Row():
-                        # Price gauge visualization
-                        price_gauge = gr.Plot(label="Price Comparison")
-                    with gr.Row():
-                        # Ratings chart
-                        ratings_chart = gr.Plot(label="User Ratings")
-        
-        with gr.TabItem("About"):
-            gr.Markdown("""
-            ## About This Recommender
-            
-            This Steam game recommender system uses machine learning to find games similar to your favorites. It analyzes:
-            
-            - Game genres and categories
-            - User ratings and reviews
-            - Platform availability
-            - Tags and game descriptions
-            - Price points
-            - Player statistics
-            
-            The recommendations are based on a hybrid scoring system that combines content similarity, user ratings, and gameplay metrics.
-            
-            For best results, enter the exact name of a game that exists in the Steam database.
-            """)
-    
-    # Register event
-    def on_submit(user_input):
-        rec_text, game_list, gauge, ratings = recommend_games(user_input)
-        return rec_text, gauge, ratings
-    
-    run_button.click(
-        fn=on_submit, 
-        inputs=input_box, 
-        outputs=[output_text, price_gauge, ratings_chart],
-        show_progress=True
-    )
+    with gr.Row():
+        output_text = gr.Markdown(label="Recommendations")
     
-    # Also trigger on Enter key
-    input_box.submit(
-        fn=on_submit, 
-        inputs=input_box, 
-        outputs=[output_text, price_gauge, ratings_chart],
-        show_progress=True
+    with gr.Row():
+        output_gallery = gr.Gallery(
+            label="Game Images", 
+            show_label=True, 
+            elem_id="gallery",
+            columns=[3], 
+            rows=[3], 
+            height="auto"
+        )
+    
+    submit_btn.click(
+        fn=recommend_games,
+        inputs=input_text,
+        outputs=[output_text, output_gallery]
     )
 
-# Launch the Gradio app
+# Launch the app
 if __name__ == "__main__":
     demo.launch()