first push

requirements.txt

@@ -1,3 +1,4 @@
 altair
 pandas
-streamlit
+streamlit
+scikit-learn

src/streamlit_app.py

@@ -1,40 +1,223 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import os
+import pickle
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score, r2_score
+
+st.sidebar.title("Navigation")
+page = st.sidebar.selectbox("Go to", ["Upload File", "Preprocess Data", "Train & Select Model", "Create App"])
+
+os.makedirs("uploads", exist_ok=True)
+os.makedirs("processed", exist_ok=True)
+os.makedirs("pkl", exist_ok=True)
+os.makedirs("encoders", exist_ok=True)  # Folder to save encoders
+
+if page == "Upload File":
+    st.title("Upload CSV or SQL File")
+    uploaded_file = st.file_uploader("Upload a CSV or SQL file", type=["csv", "sql"])
+
+    if uploaded_file is not None:
+        save_path = os.path.join("uploads", uploaded_file.name)
+        with open(save_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        st.success(f"File saved to {save_path}")
+
+        if uploaded_file.name.endswith(".csv"):
+            df = pd.read_csv(save_path)
+            st.dataframe(df)
+        elif uploaded_file.name.endswith(".sql"):
+            with open(save_path, "r", encoding="utf-8") as f:
+                sql_content = f.read()
+            st.text_area("SQL Content", sql_content, height=300)
+
+elif page == "Preprocess Data":
+    st.title("Preprocess Uploaded CSV")
+    files = [f for f in os.listdir("uploads") if f.endswith(".csv")]
+
+    if files:
+        selected_file = st.selectbox("Select a CSV file to preprocess", files)
+        file_path = os.path.join("uploads", selected_file)
+
+        if "df" not in st.session_state or st.session_state.file_path != file_path:
+            st.session_state.df = pd.read_csv(file_path)
+            st.session_state.file_path = file_path
+
+        st.write("Current Data:")
+        st.dataframe(st.session_state.df)
+
+        missing_placeholders = [
+            "?", "NA", "N/A", "na", "null", "NULL", "none", "None",
+            "missing", "Missing", "not available", "Not Available",
+            "--", "---", "-", "_", ""
+        ]
+
+        if st.button("Drop Missing / Placeholder Values"):
+            st.session_state.df = st.session_state.df.replace(missing_placeholders, pd.NA)
+            st.session_state.df = st.session_state.df.dropna()
+            st.success("All placeholder and missing values dropped!")
+            missing_after = st.session_state.df.isnull().sum()
+            st.write("Missing values per column AFTER drop:")
+            st.dataframe(missing_after.rename("Missing Count"))
+            st.dataframe(st.session_state.df)
+
+        col_to_drop = st.multiselect("Select columns to drop", st.session_state.df.columns)
+        if st.button("Drop Selected Columns"):
+            st.session_state.df = st.session_state.df.drop(columns=col_to_drop)
+            st.success(f"Dropped columns: {col_to_drop}")
+
+        if st.button("Label Encode Object Columns"):
+            label_encoders = {}
+            for col in st.session_state.df.select_dtypes(include=['object']).columns:
+                le = LabelEncoder()
+                st.session_state.df[col] = le.fit_transform(st.session_state.df[col].astype(str))
+                label_encoders[col] = le
+
+            # Save each encoder as pickle
+            for col, le in label_encoders.items():
+                with open(f"encoders/{selected_file}_{col}_encoder.pkl", "wb") as f:
+                    pickle.dump(le, f)
+
+            st.success("All object columns label-encoded and encoders saved!")
+            st.dataframe(st.session_state.df)
+
+        if st.button("Save Preprocessed File"):
+            processed_path = os.path.join("processed", selected_file)
+            st.session_state.df.to_csv(processed_path, index=False)
+            st.success(f"Preprocessed file saved to: {processed_path}")
+    else:
+        st.warning("No CSV files available. Please upload a CSV first.")
+
+elif page == "Train & Select Model":
+    st.title("Train Models and Select the Best One")
+
+    processed_files = [f for f in os.listdir("processed") if f.endswith(".csv")]
+
+    if processed_files:
+        selected_file = st.selectbox("Select a processed CSV", processed_files)
+        file_path = os.path.join("processed", selected_file)
+
+        df = pd.read_csv(file_path)
+        st.dataframe(df.head())
+
+        target_col = st.selectbox("Select target column", df.columns)
+        st.dataframe(df[target_col].value_counts())
+
+        if target_col:
+            X = df.drop(columns=[target_col])
+            y = df[target_col]
+
+            if y.dtype == "object" or len(y.unique()) <= 20:
+                problem_type = "classification"
+            else:
+                problem_type = "regression"
+
+            test_size = st.slider("Test size (%)", min_value=20, max_value=50, step=5, value=30)
+            X_train, X_test, y_train, y_test = train_test_split(
+                X, y, test_size=test_size/100, random_state=42
+            )
+
+            results = {}
+
+            if problem_type == "classification":
+                models = {
+                    "Logistic Regression": LogisticRegression(max_iter=500),
+                    "KNN": KNeighborsClassifier(),
+                    "Decision Tree": DecisionTreeClassifier()
+                }
+                for name, model in models.items():
+                    model.fit(X_train, y_train)
+                    preds = model.predict(X_test)
+                    acc = accuracy_score(y_test, preds)
+                    results[name] = acc
+            else:
+                models = {
+                    "Linear Regression": LinearRegression(),
+                    "Decision Tree": DecisionTreeClassifier()
+                }
+                for name, model in models.items():
+                    model.fit(X_train, y_train)
+                    preds = model.predict(X_test)
+                    score = r2_score(y_test, preds)
+                    results[name] = score
+
+            st.subheader("Model Accuracy / Score")
+            for model_name, score in results.items():
+                st.write(f"{model_name}: **{score:.4f}**")
+
+            selected_model_name = st.selectbox("Select model to save", list(results.keys()))
+            if st.button("Save Selected Model"):
+                final_model = models[selected_model_name]
+                pkl_path = os.path.join("pkl", f"{selected_model_name}.pkl")
+                with open(pkl_path, "wb") as f:
+                    pickle.dump(final_model, f)
+                st.success(f"Model saved as {pkl_path}")
+    else:
+        st.warning("No processed files found. Please preprocess a file first.")
+
+elif page == "Create App":
+    st.title("Use Model for Prediction")
+
+    processed_files = [f for f in os.listdir("processed") if f.endswith(".csv")]
+    if processed_files:
+        selected_csv = st.selectbox("Select a processed CSV file", processed_files)
+        df = pd.read_csv(os.path.join("processed", selected_csv))
+        target_col = st.selectbox("Select target column", df.columns)
+
+        if target_col:
+            X = df.drop(columns=[target_col])
+            y = df[target_col]
+
+            if y.dtype == "object" or len(y.unique()) <= 20:
+                problem_type = "classification"
+                model = LogisticRegression(max_iter=500)
+            else:
+                problem_type = "regression"
+                model = LinearRegression()
+
+            model.fit(X, y)
+
+            # Load encoders for features if available
+            encoders = {}
+            for col in X.columns:
+                encoder_path = f"encoders/{selected_csv}_{col}_encoder.pkl"
+                if os.path.exists(encoder_path):
+                    with open(encoder_path, "rb") as f:
+                        encoders[col] = pickle.load(f)
+
+            # Load encoder for target if available (for inverse transform of prediction)
+            target_encoder = None
+            target_encoder_path = f"encoders/{selected_csv}_{target_col}_encoder.pkl"
+            if os.path.exists(target_encoder_path):
+                with open(target_encoder_path, "rb") as f:
+                    target_encoder = pickle.load(f)
+
+            user_input = {}
+            for col in X.columns:
+                if col in encoders:
+                    options = encoders[col].classes_.tolist()
+                    val = st.selectbox(f"Select {col}", options)
+                    user_input[col] = encoders[col].transform([val])[0]
+                else:
+                    if X[col].dtype in ["int64", "float64"]:
+                        val = st.number_input(f"Enter {col}", value=float(X[col].mean()))
+                        user_input[col] = val
+                    else:
+                        val = st.text_input(f"Enter {col}")
+                        user_input[col] = val
+
+            if st.button("Predict"):
+                input_df = pd.DataFrame([user_input])
+                prediction = model.predict(input_df)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+                st.subheader("Prediction")
+                if problem_type == "classification" and target_encoder is not None:
+                    st.text(target_encoder.inverse_transform(prediction)[0])
+                else:
+                    st.text(prediction[0])
+    else:
+        st.warning("No processed CSV files found. Please preprocess a file first.")