final

app.py

@@ -0,0 +1,103 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.cluster import KMeans
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.metrics import accuracy_score, classification_report
+
+# Streamlit App Title
+st.title("Book Recommendation System")
+
+# Load dataset
+file_path = "books.csv"
+df = pd.read_csv(file_path, on_bad_lines="skip", engine="python")
+
+# Select only existing relevant columns
+expected_columns = ['bookID', 'title', 'authors', 'average_rating', 'isbn', 'isbn13', 'language_code', 'num_pages', 'ratings_count', 'text_reviews_count', 'publication_date', 'publisher']
+available_columns = [col for col in expected_columns if col in df.columns]
+df = df[available_columns]
+df = df.dropna()
+
+# Ensure numeric columns are properly converted
+numeric_columns = ['average_rating', 'ratings_count', 'text_reviews_count', 'num_pages']
+for col in numeric_columns:
+    if col in df.columns:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+df = df.dropna()
+
+# Handle categorical columns
+label_encoders = {}
+categorical_columns = ['title', 'authors', 'publisher']
+for col in categorical_columns:
+    if col in df.columns:
+        df[col] = df[col].astype(str)  # Ensure all values are strings
+
+# Create tabs
+tab1, tab2, tab3 = st.tabs(["Dataset Overview", "Visualization Matrix", "Book Prediction Based on Input"])
+
+with tab1:
+    st.write("### Data Preview")
+    st.write(df.head())
+    st.write("### Summary Statistics")
+    st.write(df.describe())
+
+with tab2:
+    st.write("### Clustering Visualization using K-Means")
+    features = st.multiselect("Select Features for Clustering", df.columns)
+    k = st.slider("Select Number of Clusters (K)", min_value=2, max_value=10, value=3)
+    if st.button("Run K-Means Clustering"):
+        if len(features) == 2:
+            X = df[features]
+            scaler = StandardScaler()
+            X_scaled = scaler.fit_transform(X)
+            
+            kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
+            df['Cluster'] = kmeans.fit_predict(X_scaled)
+            
+            plt.figure(figsize=(8, 6))
+            sns.scatterplot(x=df[features[0]], y=df[features[1]], hue=df['Cluster'], palette='viridis')
+            plt.title("Book Clustering Visualization")
+            st.pyplot(plt)
+        else:
+            st.write("Please select exactly two features for visualization.")
+
+with tab3:
+    st.write("### Predict Books Based on User Input")
+    
+    avg_rating = st.number_input("Enter desired Average Rating", min_value=float(df['average_rating'].min()), max_value=float(df['average_rating'].max()), value=float(df['average_rating'].median()))
+    ratings_count = st.number_input("Enter desired Ratings Count", min_value=float(df['ratings_count'].min()), max_value=float(df['ratings_count'].max()), value=float(df['ratings_count'].median()))
+    text_reviews_count = st.number_input("Enter desired Text Reviews Count", min_value=float(df['text_reviews_count'].min()), max_value=float(df['text_reviews_count'].max()), value=float(df['text_reviews_count'].median()))
+    
+    if st.button("Find Matching Books"):
+        filtered_books = df.copy()
+        
+        lower_bound_avg = avg_rating * 0.8
+        upper_bound_avg = avg_rating * 1.2
+        filtered_books = filtered_books[(filtered_books['average_rating'] >= lower_bound_avg) & (filtered_books['average_rating'] <= upper_bound_avg)]
+        
+        lower_bound_ratings = ratings_count * 0.8
+        upper_bound_ratings = ratings_count * 1.2
+        filtered_books = filtered_books[(filtered_books['ratings_count'] >= lower_bound_ratings) & (filtered_books['ratings_count'] <= upper_bound_ratings)]
+        
+        lower_bound_reviews = text_reviews_count * 0.8
+        upper_bound_reviews = text_reviews_count * 1.2
+        filtered_books = filtered_books[(filtered_books['text_reviews_count'] >= lower_bound_reviews) & (filtered_books['text_reviews_count'] <= upper_bound_reviews)]
+        
+        output_columns = ['title', 'authors'] + [col for col in ['bookID', 'average_rating', 'isbn', 'isbn13', 'language_code', 'num_pages', 'ratings_count', 'text_reviews_count', 'publication_date', 'publisher'] if col in df.columns]
+        
+        if not filtered_books.empty:
+            st.write("### Books Matching Your Preferences")
+            st.write(filtered_books[output_columns].head(10))
+        else:
+            st.write("No exact matches found. Showing closest books instead.")
+            df['distance'] = (
+                abs(df['average_rating'] - avg_rating) +
+                abs(df['ratings_count'] - ratings_count) +
+                abs(df['text_reviews_count'] - text_reviews_count)
+            )
+            sorted_books = df.nsmallest(10, 'distance')
+            st.write(sorted_books[output_columns].head(10))

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+pandas
+numpy
+matplotlib
+seaborn
+scikit-learn