Create app.py

app.py

@@ -0,0 +1,169 @@
+import pandas as pd
+import difflib
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import gradio as gr
+import numpy as np
+
+# Load the data - when deploying, adjust the path to where your dataset will be stored
+def load_data():
+    try:
+        # For Hugging Face Spaces deployment, you might need to adjust this path
+        data = pd.read_csv('games_march2025_cleaned.csv', nrows=88899, on_bad_lines='skip', engine='python')
+        return data
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        return None
+
+# Prepare the feature vectors for similarity calculation
+def prepare_features(data):
+    selected_features = ['genres', 'price', 'average_playtime_2weeks', 'tags']
+    
+    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)
+    )
+    
+    vectorizer = TfidfVectorizer()
+    feature_vectors = vectorizer.fit_transform(combined_features)
+    
+    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)
+    
+    if not find_close_match:
+        return "No match found for the game name. Please try another title."
+    
+    closest_match = find_close_match[0]
+    index_of_the_game = data.loc[data['name'] == closest_match].index[0]
+    
+    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)
+
+    result_html = ""
+
+    for i, (index, score) in enumerate(sorted_similar_games[1:10], 1):
+        name = data.loc[index, 'name']
+        about = data.loc[index, 'short_description'] or "No description available"
+        image_url = data.loc[index, 'header_image'] or ""
+
+        platforms = []
+        if data.loc[index, 'windows'] == 1:
+            platforms.append("Windows")
+        if data.loc[index, 'mac'] == 1:
+            platforms.append("Mac")
+        if data.loc[index, 'linux'] == 1:
+            platforms.append("Linux")
+        platforms_str = ", ".join(platforms) or "Unknown"
+
+        price = data.loc[index, 'price']
+        pos = data.loc[index, 'positive']
+        neg = data.loc[index, 'negative']
+        total_reviews = pos + neg
+        pos_ratio = f"{(pos / total_reviews * 100):.1f}%" if total_reviews > 0 else "N/A"
+
+        result_html += f"""
+        <div style="display:flex; align-items:flex-start; margin-bottom:20px;">
+            <img src="{image_url}" style="width:150px; height:auto; margin-right:15px; border-radius:8px;">
+            <div>
+                <h3>{i}. {name} <small>(Similarity: {score:.2f})</small></h3>
+                <p><b>Platforms:</b> {platforms_str}</p>
+                <p><b>Price:</b> ${price}</p>
+                <p><b>Positive Reviews:</b> {pos_ratio}</p>
+                <p>{about}</p>
+            </div>
+        </div>
+        <hr>
+        """
+
+    return result_html
+
+# Gradio interface function
+def recommend_games(game_name, max_age, max_price, min_pos_neg_ratio):
+    data = load_data()
+    if data is None:
+        return "Failed to load data. Please check the data file."
+
+    # Fill NA values to avoid division errors
+    data['positive'] = data['positive'].fillna(0)
+    data['negative'] = data['negative'].fillna(0)
+
+    # Calculate the positive-to-negative ratio (avoid division by zero)
+    data['pos_neg_ratio'] = data.apply(
+        lambda row: (row['positive'] / row['negative']) if row['negative'] > 0 else row['positive'],
+        axis=1
+    )
+
+    # Apply filters
+    data = data[
+        (data['required_age'] <= max_age) &
+        (data['price'] <= max_price) &
+        (data['pos_neg_ratio'] >= min_pos_neg_ratio)
+    ].reset_index(drop=True)
+
+    if data.empty:
+        return "No games found matching your filter criteria."
+
+    feature_vectors = prepare_features(data)
+    recommendations_html = get_recommendations(game_name, data, feature_vectors)
+    
+    return recommendations_html
+
+
+    
+    # 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:
+            # Use a placeholder image if no image URL is available
+            result_images.append(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
+
+# Create the Gradio interface
+with gr.Blocks(title="Steam Game Recommender") as demo:
+    gr.Markdown("# 🎮 Steam Game Recommender")
+    gr.Markdown("Enter a game you like and adjust filters to get the best matches.")
+
+    with gr.Row():
+        input_text = gr.Textbox(label="🎯 Favorite Game")
+    
+    with gr.Row():
+        max_age_slider = gr.Slider(0, 21, value=17, label="Max Age Rating (Avoid Adult Games)")
+        max_price_slider = gr.Slider(0.0, 100.0, value=60.0, step=0.5, label="Maximum Price ($)")
+        min_pos_neg_slider = gr.Slider(0.0, 10.0, value=2.0, step=0.1, label="Min Positive:Negative Ratio")
+
+    with gr.Row():
+        submit_btn = gr.Button("🔍 Get Recommendations")
+
+    with gr.Row():
+        output_text = gr.Markdown(label="🧠 Recommendations")
+
+    submit_btn.click(
+        fn=recommend_games,
+        inputs=[input_text, max_age_slider, max_price_slider, min_pos_neg_slider],
+        outputs=output_text
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()