Delete pages

pages/Automatic_Machine_Learning_project-1.py

@@ -1,168 +0,0 @@
-import streamlit as st
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-import optuna
-import joblib
-from sklearn.model_selection import train_test_split
-from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_curve, auc
-from sklearn.preprocessing import LabelEncoder, StandardScaler
-
-# App Title
-st.title("Wine Quality Analysis & Classification using Optuna")
-
-# Step 1: File Upload
-uploaded_file = st.file_uploader("Upload your dataset (CSV format)", type=["csv"])
-
-if uploaded_file is not None:
-    # Step 2: Load Data
-    data = pd.read_csv(uploaded_file, encoding="utf-8")
-    
-    # Step 3: Display Dataset
-    st.write("Dataset Preview")
-    st.dataframe(data.head())
-
-    # Step 4: Dataset Information
-    st.write("Dataset Info")
-    st.write(data.dtypes)  
-
-    # Step 5: Summary Statistics
-    st.write("Summary Statistics")
-    st.write(data.describe())
-
-    # Step 6: Missing Values Check
-    st.write("Missing Values")
-    st.write(data.isnull().sum())
-
-    # Step 7: Duplicate Check
-    st.write(f"Duplicate Rows: {data.duplicated().sum()}")
-
-    # Step 8: Outlier Detection
-    st.write("Outliers Detection using IQR")
-    numerical_columns = data.select_dtypes(include=["float64", "int64"]).columns.tolist()
-    
-    outlier_counts = {}
-    for column in numerical_columns:
-        Q1 = data[column].quantile(0.25)
-        Q3 = data[column].quantile(0.75)
-        IQR = Q3 - Q1
-        lower_bound = Q1 - 1.5 * IQR
-        upper_bound = Q3 + 1.5 * IQR
-        outlier_counts[column] = ((data[column] < lower_bound) | (data[column] > upper_bound)).sum()
-    
-    st.write(pd.DataFrame(outlier_counts.items(), columns=["Column", "Outliers Count"]))
-
-    # Step 9: Data Visualization
-    st.write("Data Distribution")
-    selected_column = st.selectbox("Select a numerical column", numerical_columns)
-    fig, ax = plt.subplots()
-    sns.histplot(data[selected_column], kde=True, ax=ax)
-    st.pyplot(fig)
-
-    # Step 10: Correlation Heatmap
-    st.write("Correlation Heatmap")
-    fig, ax = plt.subplots(figsize=(10, 6))
-    sns.heatmap(data.corr(), annot=True, cmap="coolwarm", fmt=".2f", ax=ax)
-    st.pyplot(fig)
-
-    # Step 11: Train-Test Split
-    st.write("Train-Test Split & Hyperparameter Optimization using Optuna")
-    target_column = st.selectbox(" Select the target column", data.columns)
-    feature_columns = [col for col in data.columns if col != target_column]
-
-    X = data[feature_columns]
-    y = data[target_column]
-
-    # Label encoding for categorical target variables
-    if y.dtype == 'object':
-        le = LabelEncoder()
-        y = le.fit_transform(y)
-
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
-    # Step 12: Hyperparameter Tuning with Optuna
-    n_trials = st.slider(" Select number of Optuna trials", 10, 100, 20)
-
-    def objective(trial):
-        n_estimators = trial.suggest_int("n_estimators", 50, 300, step=50)
-        max_depth = trial.suggest_int("max_depth", 5, 20, step=5)
-        min_samples_split = trial.suggest_int("min_samples_split", 2, 10)
-        min_samples_leaf = trial.suggest_int("min_samples_leaf", 1, 5)
-
-        model = RandomForestClassifier(
-            n_estimators=n_estimators,
-            max_depth=max_depth,
-            min_samples_split=min_samples_split,
-            min_samples_leaf=min_samples_leaf,
-            random_state=42
-        )
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return accuracy_score(y_test, y_pred)
-
-    with st.spinner("Optimizing hyperparameters..."):
-        study = optuna.create_study(direction="maximize")
-        study.optimize(objective, n_trials=n_trials)
-
-    best_params = study.best_params
-    st.write(f"Best Hyperparameters: {best_params}")
-
-    # Step 13: Train the Best Model
-    best_model = RandomForestClassifier(**best_params, random_state=42)
-    best_model.fit(X_train, y_train)
-    y_pred = best_model.predict(X_test)
-
-    # Step 14: Model Evaluation
-    st.write("Model Evaluation")
-    st.write(f"Optimized Accuracy: {accuracy_score(y_test, y_pred):.2f}")
-    st.write(" Classification Report:")
-    st.text(classification_report(y_test, y_pred))
-
-    # Confusion Matrix
-    st.write("Confusion Matrix")
-    cm = confusion_matrix(y_test, y_pred)
-    fig, ax = plt.subplots()
-    sns.heatmap(cm, annot=True, cmap="Blues", fmt="d", ax=ax)
-    st.pyplot(fig)
-
-    # Feature Importance
-    st.write("Feature Importance")
-    feature_importance = pd.Series(best_model.feature_importances_, index=feature_columns).sort_values(ascending=False)
-    fig, ax = plt.subplots()
-    feature_importance.plot(kind="bar", ax=ax)
-    st.pyplot(fig)
-
-    # Model Comparison
-    st.write("Model Comparison")
-    models = {
-        "RandomForest": RandomForestClassifier(**best_params, random_state=42),
-        "GradientBoosting": GradientBoostingClassifier(),
-        "LogisticRegression": LogisticRegression()
-    }
-    model_accuracies = {}
-    for model_name, model in models.items():
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        model_accuracies[model_name] = accuracy_score(y_test, y_pred)
-
-    st.write(pd.DataFrame(model_accuracies.items(), columns=["Model", "Accuracy"]))
-
-    # Step 15: Save & Download Model
-    joblib.dump(best_model, "best_wine_model.pkl")
-    with open("best_wine_model.pkl", "rb") as file:
-        st.download_button(" Download Best Model", file, file_name="best_wine_model.pkl")
-
-    # Step 16: Make Predictions on User Input
-    st.write("Make Predictions with the Best Model")
-    user_input = {}
-    for feature in feature_columns:
-        user_input[feature] = st.number_input(f"Enter value for {feature}", float(data[feature].min()), float(data[feature].max()), float(data[feature].mean()))
-    
-    user_df = pd.DataFrame([user_input])
-    if st.button("Predict"):
-        prediction = best_model.predict(user_df)
-        predicted_label = le.inverse_transform([prediction[0]]) if 'le' in locals() else prediction[0]
-        st.success(f" Predicted Wine Quality: {predicted_label}")

pages/Automatic_machine_leaning_project-2.py

@@ -1,85 +0,0 @@
-import streamlit as st
-import pandas as pd
-import numpy as np
-import seaborn as sns
-import matplotlib.pyplot as plt
-import optuna
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler, OneHotEncoder
-from sklearn.tree import DecisionTreeRegressor
-from sklearn.neighbors import KNeighborsRegressor
-from sklearn.metrics import mean_squared_error, r2_score
-import warnings
-warnings.filterwarnings("ignore")
-
-# Title of the Streamlit App
-st.title("📊 Possum Dataset Analysis & Model Optimization with Optuna")
-
-# Upload Dataset
-st.sidebar.header("Upload your CSV file")
-uploaded_file = st.sidebar.file_uploader("Choose a file", type=["csv"])
-
-def load_data(file):
-    return pd.read_csv(file)
-
-if uploaded_file is not None:
-    data = load_data(uploaded_file)
-    st.write("### Dataset Preview")
-    st.dataframe(data.head())
-    
-    # Data Summary
-    st.write("### Data Summary")
-    st.write(data.describe())
-    
-    # Data Preprocessing
-    st.write("### Data Preprocessing")
-    target_column = st.selectbox("Select Target Column", data.columns)
-    X = data.drop(columns=[target_column])
-    y = data[target_column]
-    
-    # Splitting Data
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-    st.write(f"Training Samples: {X_train.shape[0]}, Test Samples: {X_test.shape[0]}")
-    
-    # Data Visualization
-    st.write("### Pairplot Visualization")
-    fig = sns.pairplot(data)
-    st.pyplot(fig)
-    
-    # Model Selection
-    model_choice = st.sidebar.radio("Choose a Model", ["Decision Tree", "K-Nearest Neighbors"])
-    
-    def objective(trial):
-        if model_choice == "Decision Tree":
-            max_depth = trial.suggest_int("max_depth", 1, 20)
-            model = DecisionTreeRegressor(max_depth=max_depth)
-        else:
-            n_neighbors = trial.suggest_int("n_neighbors", 1, 20)
-            model = KNeighborsRegressor(n_neighbors=n_neighbors)
-        
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return mean_squared_error(y_test, y_pred)
-    
-    if st.sidebar.button("Optimize Model with Optuna"):
-        study = optuna.create_study(direction="minimize")
-        study.optimize(objective, n_trials=20)
-        st.write("### Best Hyperparameters")
-        st.write(study.best_params)
-        
-        # Train Model with Best Parameters
-        if model_choice == "Decision Tree":
-            model = DecisionTreeRegressor(max_depth=study.best_params["max_depth"])
-        else:
-            model = KNeighborsRegressor(n_neighbors=study.best_params["n_neighbors"])
-        
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        
-        # Performance Metrics
-        st.write("### Model Performance")
-        st.write(f"Mean Squared Error: {mean_squared_error(y_test, y_pred):.4f}")
-        st.write(f"R-Squared Score: {r2_score(y_test, y_pred):.4f}")
-    
-else:
-    st.write("Upload a dataset to get started!")