first push

src/streamlit_app.py

@@ -1,6 +1,5 @@
 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
@@ -9,18 +8,23 @@ from sklearn.neighbors import KNeighborsClassifier
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.metrics import accuracy_score, r2_score
 
-# ========================
-# Directory Setup
-# ========================
-BASE_DIR = "/tmp"  # Writable directory in hosted environments
-UPLOAD_DIR = os.path.join(BASE_DIR, "uploads")
-PROCESSED_DIR = os.path.join(BASE_DIR, "processed")
-PKL_DIR = os.path.join(BASE_DIR, "pkl")
-ENCODERS_DIR = os.path.join(BASE_DIR, "encoders")
-
-# Create directories if they don't exist
-for folder in [UPLOAD_DIR, PROCESSED_DIR, PKL_DIR, ENCODERS_DIR]:
-    os.makedirs(folder, exist_ok=True)
+# Initialize session state variables
+if "uploaded_file_name" not in st.session_state:
+    st.session_state.uploaded_file_name = None
+if "df" not in st.session_state:
+    st.session_state.df = None
+if "processed_df" not in st.session_state:
+    st.session_state.processed_df = None
+if "encoders" not in st.session_state:
+    st.session_state.encoders = {}
+if "models" not in st.session_state:
+    st.session_state.models = {}
+if "final_model" not in st.session_state:
+    st.session_state.final_model = None
+if "problem_type" not in st.session_state:
+    st.session_state.problem_type = None
+if "target_encoder" not in st.session_state:
+    st.session_state.target_encoder = None
 
 st.sidebar.title("Navigation")
 page = st.sidebar.selectbox("Go to", ["Upload File", "Preprocess Data", "Train & Select Model", "Create App"])
@@ -33,34 +37,21 @@ if page == "Upload 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(UPLOAD_DIR, uploaded_file.name)
-        with open(save_path, "wb") as f:
-            f.write(uploaded_file.getbuffer())
-        st.success(f"File saved to {save_path}")
-
+        st.session_state.uploaded_file_name = uploaded_file.name
         if uploaded_file.name.endswith(".csv"):
-            df = pd.read_csv(save_path)
-            st.dataframe(df)
+            st.session_state.df = pd.read_csv(uploaded_file)
+            st.dataframe(st.session_state.df)
         elif uploaded_file.name.endswith(".sql"):
-            with open(save_path, "r", encoding="utf-8") as f:
-                sql_content = f.read()
+            sql_content = uploaded_file.read().decode("utf-8")
             st.text_area("SQL Content", sql_content, height=300)
+        st.success("File loaded into memory!")
 
 # ========================
 # Preprocess Data Page
 # ========================
 elif page == "Preprocess Data":
     st.title("Preprocess Uploaded CSV")
-    files = [f for f in os.listdir(UPLOAD_DIR) if f.endswith(".csv")]
-
-    if files:
-        selected_file = st.selectbox("Select a CSV file to preprocess", files)
-        file_path = os.path.join(UPLOAD_DIR, 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
-
+    if st.session_state.df is not None:
         st.write("Current Data:")
         st.dataframe(st.session_state.df)
 
@@ -73,11 +64,7 @@ elif page == "Preprocess Data":
         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)
+            st.success("Missing values dropped!")
 
         col_to_drop = st.multiselect("Select columns to drop", st.session_state.df.columns)
         if st.button("Drop Selected Columns"):
@@ -85,25 +72,18 @@ elif page == "Preprocess Data":
             st.success(f"Dropped columns: {col_to_drop}")
 
         if st.button("Label Encode Object Columns"):
-            label_encoders = {}
+            st.session_state.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
-
-            for col, le in label_encoders.items():
-                with open(f"{ENCODERS_DIR}/{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)
+                st.session_state.encoders[col] = le
+            st.success("Object columns label-encoded!")
 
-        if st.button("Save Preprocessed File"):
-            processed_path = os.path.join(PROCESSED_DIR, selected_file)
-            st.session_state.df.to_csv(processed_path, index=False)
-            st.success(f"Preprocessed file saved to: {processed_path}")
+        if st.button("Save Preprocessed Data"):
+            st.session_state.processed_df = st.session_state.df.copy()
+            st.success("Preprocessed data saved in memory!")
     else:
-        st.warning("No CSV files available. Please upload a CSV first.")
+        st.warning("Please upload a CSV first.")
 
 # ========================
 # Train & Select Model Page
@@ -111,35 +91,26 @@ elif page == "Preprocess Data":
 elif page == "Train & Select Model":
     st.title("Train Models and Select the Best One")
 
-    processed_files = [f for f in os.listdir(PROCESSED_DIR) if f.endswith(".csv")]
-
-    if processed_files:
-        selected_file = st.selectbox("Select a processed CSV", processed_files)
-        file_path = os.path.join(PROCESSED_DIR, selected_file)
-
-        df = pd.read_csv(file_path)
-        st.dataframe(df.head())
-
+    if st.session_state.processed_df is not None:
+        df = st.session_state.processed_df
         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"
+                st.session_state.problem_type = "classification"
             else:
-                problem_type = "regression"
+                st.session_state.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
-            )
+            test_size = st.slider("Test size (%)", 20, 50, 30, step=5)
+            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size/100, random_state=42)
 
             results = {}
+            st.session_state.models = {}
 
-            if problem_type == "classification":
+            if st.session_state.problem_type == "classification":
                 models = {
                     "Logistic Regression": LogisticRegression(max_iter=500),
                     "KNN": KNeighborsClassifier(),
@@ -150,6 +121,7 @@ elif page == "Train & Select Model":
                     preds = model.predict(X_test)
                     acc = accuracy_score(y_test, preds)
                     results[name] = acc
+                    st.session_state.models[name] = model
             else:
                 models = {
                     "Linear Regression": LinearRegression(),
@@ -160,20 +132,18 @@ elif page == "Train & Select Model":
                     preds = model.predict(X_test)
                     score = r2_score(y_test, preds)
                     results[name] = score
+                    st.session_state.models[name] = model
 
-            st.subheader("Model Accuracy / Score")
-            for model_name, score in results.items():
-                st.write(f"{model_name}: *{score:.4f}*")
+            st.subheader("Model Scores")
+            for name, score in results.items():
+                st.write(f"{name}: {score:.4f}")
 
-            selected_model_name = st.selectbox("Select model to save", list(results.keys()))
+            selected_model = 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_DIR, 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}")
+                st.session_state.final_model = st.session_state.models[selected_model]
+                st.success("Model saved in memory!")
     else:
-        st.warning("No processed files found. Please preprocess a file first.")
+        st.warning("Please preprocess a file first.")
 
 # ========================
 # Create App Page
@@ -181,61 +151,25 @@ elif page == "Train & Select Model":
 elif page == "Create App":
     st.title("Use Model for Prediction")
 
-    processed_files = [f for f in os.listdir(PROCESSED_DIR) 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_DIR, selected_csv))
+    if st.session_state.final_model is not None and st.session_state.processed_df is not None:
+        df = st.session_state.processed_df
         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)
+        X = df.drop(columns=[target_col])
+
+        user_input = {}
+        for col in X.columns:
+            if col in st.session_state.encoders:
+                options = st.session_state.encoders[col].classes_.tolist()
+                val = st.selectbox(f"Select {col}", options)
+                user_input[col] = st.session_state.encoders[col].transform([val])[0]
             else:
-                problem_type = "regression"
-                model = LinearRegression()
-
-            model.fit(X, y)
-
-            encoders = {}
-            for col in X.columns:
-                encoder_path = f"{ENCODERS_DIR}/{selected_csv}_{col}_encoder.pkl"
-                if os.path.exists(encoder_path):
-                    with open(encoder_path, "rb") as f:
-                        encoders[col] = pickle.load(f)
-
-            target_encoder = None
-            target_encoder_path = f"{ENCODERS_DIR}/{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)
-
-                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])
+                val = st.number_input(f"Enter {col}", value=float(X[col].mean()))
+                user_input[col] = val
+
+        if st.button("Predict"):
+            input_df = pd.DataFrame([user_input])
+            prediction = st.session_state.final_model.predict(input_df)
+            st.subheader("Prediction")
+            st.write(prediction[0])
     else:
-        st.warning("No processed CSV files found. Please preprocess a file first.")
+        st.warning("Please train and save a model first.")