Create app.py

app.py

@@ -0,0 +1,265 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+
+# Page configuration
+st.set_page_config(page_title="Data Analysis Platform", layout="wide")
+
+# Initialize session state
+if 'data' not in st.session_state:
+    # Create sample data
+    np.random.seed(42)
+    dates = pd.date_range('2023-01-01', periods=100, freq='D')
+    st.session_state.data = pd.DataFrame({
+        'date': dates,
+        'sales': np.random.normal(1000, 200, 100),
+        'visitors': np.random.normal(500, 100, 100),
+        'conversion_rate': np.random.uniform(0.01, 0.05, 100),
+        'customer_satisfaction': np.random.normal(4.2, 0.5, 100),
+        'region': np.random.choice(['North', 'South', 'East', 'West'], 100)
+    })
+
+# Sidebar for navigation
+st.sidebar.title("Data Analytics Platform")
+page = st.sidebar.radio("Navigation", ["Home", "Data Explorer", "Visualization", "Predictions"])
+
+# Home page
+if page == "Home":
+    st.title("Data Analysis Platform")
+    st.markdown("""
+    Welcome to the Data Analysis Platform. Explore your data with powerful 
+    visualizations and machine learning insights.
+    """)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Upload Your Dataset")
+        uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
+        if uploaded_file is not None:
+            try:
+                st.session_state.data = pd.read_csv(uploaded_file)
+                st.success("Data uploaded successfully!")
+            except Exception as e:
+                st.error(f"Error uploading file: {e}")
+    
+    with col2:
+        st.subheader("Dataset Overview")
+        st.write(st.session_state.data.describe())
+
+# Data Explorer page
+elif page == "Data Explorer":
+    st.title("Data Explorer")
+    
+    # Data summary
+    st.subheader("Dataset Summary")
+    st.write(f"Shape: {st.session_state.data.shape[0]} rows, {st.session_state.data.shape[1]} columns")
+    
+    # Show first few rows
+    st.subheader("Data Preview")
+    st.dataframe(st.session_state.data.head())
+    
+    # Column analysis
+    st.subheader("Column Analysis")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        column = st.selectbox("Select column to analyze:", st.session_state.data.columns)
+    
+    with col2:
+        if pd.api.types.is_numeric_dtype(st.session_state.data[column]):
+            analysis_type = st.selectbox(
+                "Analysis type:", 
+                ["Distribution", "Time Series"] if "date" in column.lower() else ["Distribution"]
+            )
+        else:
+            analysis_type = st.selectbox("Analysis type:", ["Value Counts"])
+    
+    # Display analysis
+    if pd.api.types.is_numeric_dtype(st.session_state.data[column]):
+        st.write(f"**Min:** {st.session_state.data[column].min():.2f}")
+        st.write(f"**Max:** {st.session_state.data[column].max():.2f}")
+        st.write(f"**Mean:** {st.session_state.data[column].mean():.2f}")
+        st.write(f"**Median:** {st.session_state.data[column].median():.2f}")
+        st.write(f"**Std Dev:** {st.session_state.data[column].std():.2f}")
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        sns.histplot(st.session_state.data[column], ax=ax, kde=True)
+        ax.set_title(f"Distribution of {column}")
+        st.pyplot(fig)
+    else:
+        value_counts = st.session_state.data[column].value_counts()
+        st.write(f"**Unique Values:** {len(value_counts)}")
+        st.write(f"**Most Common:** {value_counts.index[0]} ({value_counts.iloc[0]} occurrences)")
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        value_counts.plot(kind='bar', ax=ax)
+        ax.set_title(f"Value counts for {column}")
+        st.pyplot(fig)
+
+# Visualization page
+elif page == "Visualization":
+    st.title("Data Visualization")
+    
+    chart_type = st.selectbox(
+        "Select chart type:",
+        ["Bar Chart", "Line Chart", "Scatter Plot", "Heatmap"]
+    )
+    
+    if chart_type in ["Bar Chart", "Line Chart"]:
+        col1, col2 = st.columns(2)
+        with col1:
+            x_column = st.selectbox("X-axis:", st.session_state.data.columns)
+        with col2:
+            y_column = st.selectbox("Y-axis:", 
+                                  [col for col in st.session_state.data.columns 
+                                   if pd.api.types.is_numeric_dtype(st.session_state.data[col])])
+        
+        # Aggregation for categorical x-axis
+        if not pd.api.types.is_numeric_dtype(st.session_state.data[x_column]):
+            agg_data = st.session_state.data.groupby(x_column)[y_column].mean().reset_index()
+            
+            fig, ax = plt.subplots(figsize=(10, 6))
+            if chart_type == "Bar Chart":
+                sns.barplot(x=x_column, y=y_column, data=agg_data, ax=ax)
+            else:  # Line chart
+                sns.lineplot(x=x_column, y=y_column, data=agg_data, ax=ax, marker='o')
+            ax.set_title(f"{y_column} by {x_column}")
+            st.pyplot(fig)
+        else:
+            fig, ax = plt.subplots(figsize=(10, 6))
+            if chart_type == "Bar Chart":
+                sns.barplot(x=x_column, y=y_column, data=st.session_state.data, ax=ax)
+            else:  # Line chart
+                sns.lineplot(x=x_column, y=y_column, data=st.session_state.data, ax=ax)
+            ax.set_title(f"{y_column} vs {x_column}")
+            st.pyplot(fig)
+    
+    elif chart_type == "Scatter Plot":
+        col1, col2 = st.columns(2)
+        with col1:
+            x_column = st.selectbox("X-axis:", 
+                                  [col for col in st.session_state.data.columns 
+                                   if pd.api.types.is_numeric_dtype(st.session_state.data[col])])
+        with col2:
+            y_column = st.selectbox("Y-axis:", 
+                                  [col for col in st.session_state.data.columns 
+                                   if pd.api.types.is_numeric_dtype(st.session_state.data[col]) and col != x_column])
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        sns.scatterplot(x=x_column, y=y_column, data=st.session_state.data, ax=ax)
+        ax.set_title(f"{y_column} vs {x_column}")
+        st.pyplot(fig)
+    
+    elif chart_type == "Heatmap":
+        numeric_cols = st.session_state.data.select_dtypes(include=['number']).columns.tolist()
+        correlation = st.session_state.data[numeric_cols].corr()
+        
+        fig, ax = plt.subplots(figsize=(10, 8))
+        sns.heatmap(correlation, annot=True, cmap='coolwarm', ax=ax)
+        ax.set_title("Correlation Heatmap")
+        st.pyplot(fig)
+
+# Predictions page
+elif page == "Predictions":
+    st.title("ML Predictions")
+    
+    numeric_cols = st.session_state.data.select_dtypes(include=['number']).columns.tolist()
+    
+    st.subheader("Train a Model")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        target_column = st.selectbox("Target variable:", numeric_cols)
+    
+    with col2:
+        model_type = st.selectbox("Model type:", ["Linear Regression", "Random Forest"])
+    
+    # Select features
+    feature_cols = [col for col in numeric_cols if col != target_column]
+    selected_features = st.multiselect("Select features:", feature_cols, default=feature_cols)
+    
+    if st.button("Train Model"):
+        if len(selected_features) > 0:
+            # Prepare data
+            X = st.session_state.data[selected_features]
+            y = st.session_state.data[target_column]
+            
+            # Split data
+            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+            
+            # Scale features
+            scaler = StandardScaler()
+            X_train_scaled = scaler.fit_transform(X_train)
+            X_test_scaled = scaler.transform(X_test)
+            
+            # Train model
+            if model_type == "Linear Regression":
+                model = LinearRegression()
+            else:
+                model = RandomForestRegressor(n_estimators=100, random_state=42)
+                
+            model.fit(X_train_scaled, y_train)
+            
+            # Evaluate
+            train_score = model.score(X_train_scaled, y_train)
+            test_score = model.score(X_test_scaled, y_test)
+            
+            st.session_state.model = model
+            st.session_state.scaler = scaler
+            st.session_state.features = selected_features
+            
+            st.success("Model trained successfully!")
+            st.write(f"Training R² score: {train_score:.4f}")
+            st.write(f"Testing R² score: {test_score:.4f}")
+            
+            # Feature importance for Random Forest
+            if model_type == "Random Forest":
+                importance = pd.DataFrame({
+                    'Feature': selected_features,
+                    'Importance': model.feature_importances_
+                }).sort_values('Importance', ascending=False)
+                
+                fig, ax = plt.subplots(figsize=(10, 6))
+                sns.barplot(x='Importance', y='Feature', data=importance, ax=ax)
+                ax.set_title("Feature Importance")
+                st.pyplot(fig)
+        else:
+            st.error("Please select at least one feature")
+    
+    # Make predictions section
+    st.subheader("Make Predictions")
+    if 'model' in st.session_state:
+        input_data = {}
+        
+        # Create input fields for each feature
+        for feature in st.session_state.features:
+            min_val = float(st.session_state.data[feature].min())
+            max_val = float(st.session_state.data[feature].max())
+            mean_val = float(st.session_state.data[feature].mean())
+            
+            input_data[feature] = st.slider(
+                f"Input {feature}:",
+                min_value=min_val,
+                max_value=max_val,
+                value=mean_val
+            )
+        
+        if st.button("Predict"):
+            # Prepare input for prediction
+            input_df = pd.DataFrame([input_data])
+            input_scaled = st.session_state.scaler.transform(input_df)
+            
+            # Make prediction
+            prediction = st.session_state.model.predict(input_scaled)[0]
+            
+            st.success(f"Predicted {target_column}: {prediction:.2f}")
+    else:
+        st.info("Train a model first to make predictions")