Upload 5 files

README.md

@@ -1,10 +0,0 @@
----
-title: DataAnalysisApp
-emoji: 👁
-colorFrom: pink
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,140 @@
+import streamlit as st
+import pandas as pd
+import time
+
+# --- Import Utilities ---
+# IMPORTANT: Both utils.py and app.py MUST be in the same directory for this import to work.
+try:
+    from utils import initialize_hf_agent, steps_eda, function_agent, handle_start_button_click
+except ImportError:
+    st.error("ERROR: Could not import 'utils.py'. Please ensure 'utils.py' is in the same folder as 'app.py'.")
+    st.stop()
+
+
+# --- Configuration Constants ---
+# Available LLM Models for selection (Now only the selected HuggingFace model)
+HUGGINGFACE_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
+
+
+# --- Streamlit UI Setup ---
+st.set_page_config(layout="wide", page_title="AI Data Science Assistant")
+st.title("AI Assistant for Data Science 🤖")
+st.write("Hello, 👋 I am your AI assistant and I am here to help you with your data science projects.")
+
+# --- Sidebar: Model Selection and Explanation ---
+with st.sidebar:
+    st.write("Your Data Science Adventure Begins with an CSV File. ")
+    st.caption("You may already know that every exciting data science journey starts with a CSV file. Upload your CSV file to get started!")
+
+    st.divider()
+
+    # Model Information Expander
+    with st.expander("LLM Engine Details"):
+        st.info("Using **Hugging Face Hub** as the LLM Engine.")
+        st.write(f"**Model:** `{HUGGINGFACE_MODEL}`")
+        st.caption("This requires the **HUGGINGFACEHUB_API_TOKEN** to be set in your Streamlit secrets or environment variables.")
+    
+    # Store the single model in session state for consistency with the original structure
+    st.session_state.selected_model = HUGGINGFACE_MODEL
+
+    st.divider()
+    st.caption("Developed by [Your Name]")
+
+
+# --- Session State Initialization ---
+
+# Initialize the key in session state for the start button
+if "clicked" not in st.session_state:
+    st.session_state.clicked = {1: False}
+if 'df' not in st.session_state:
+    st.session_state.df = None
+if 'pandas_agent' not in st.session_state:
+    st.session_state.pandas_agent = None
+if 'llm' not in st.session_state:
+    st.session_state.llm = None
+if 'selected_model' not in st.session_state:
+    st.session_state.selected_model = HUGGINGFACE_MODEL
+
+
+# The button calls the imported utility function
+st.button("Let's Get Started!", on_click=handle_start_button_click, args=[1])
+
+
+# --- Main Application Logic ---
+if st.session_state.clicked[1]:
+    user_csv = st.file_uploader("Upload your CSV file", type="csv")
+
+    if user_csv is not None:
+        
+        # 1. Load Data
+        user_csv.seek(0)
+        df = pd.read_csv(user_csv, low_memory=False)
+        st.session_state.df = df
+        
+        # 2. Initialize Agent (uses imported utility function)
+        # Note: The function name is changed to initialize_hf_agent
+        st.session_state.llm, st.session_state.pandas_agent = initialize_hf_agent(df, st.session_state.selected_model)
+        
+        # Check if agent is successfully initialized
+        if st.session_state.pandas_agent is None:
+            # The error message is already shown in utils.py on failure
+            st.stop()
+        
+        # --- Main Execution Flow ---
+        
+        st.header("Exploratory Data Analysis (EDA)")
+        
+        # Display EDA Steps in Expander (uses imported utility function)
+        with st.sidebar:
+            with st.expander("What are the steps of EDA?"):
+                # Note: The llm object is passed to steps_eda
+                steps_text = steps_eda(st.session_state.llm) 
+                st.markdown(steps_text)
+
+        # Run the initial, automated EDA sequence (uses imported utility function)
+        function_agent(st.session_state.pandas_agent, st.session_state.df)
+
+        
+        st.divider()
+        st.subheader("Variable of Study")
+        user_question_variable = st.text_input("What variable would you like to analyze (e.g., 'price') and what question do you have about it? (e.g., 'What is the distribution of age?')")
+        
+        if user_question_variable:
+            st.info(f"Analyzing variable: **{user_question_variable}**")
+            
+            # Efficient combined prompt for analysis
+            variable_analysis_prompt = (
+                f"Analyze the variable {user_question_variable}. "
+                f"Specifically, provide summary statistics (mean, median, mode, quartiles), "
+                f"identify any outliers, and check for missing values. "
+                f"Also, use your plotting tool to create a histogram or a box plot for this variable. "
+                f"Output the plot code separately."
+            )
+            
+            with st.spinner("Running deep variable analysis..."):
+                start_time = time.time()
+                response = st.session_state.pandas_agent.run(variable_analysis_prompt)
+                end_time = time.time()
+                
+            st.write(response)
+            
+            st.info(f"Analysis Time: **{end_time - start_time:.2f} seconds**")
+            st.warning("The agent will output Python code for plots. You would need to manually execute this code to visualize it.")
+
+            
+            st.divider()
+            st.subheader("Further Study")
+            
+            user_question_dataframe = st.text_input("Do you have any other final questions about the dataset or need a complex visualization? (e.g., 'What is the correlation between age and salary?')")
+            
+            if user_question_dataframe:
+                st.info(f"Final question: **{user_question_dataframe}**")
+                
+                with st.spinner("Running final analysis..."):
+                    final_response = st.session_state.pandas_agent.run(user_question_dataframe)
+                
+                st.write(final_response)
+                
+            st.divider()
+            st.header("Data Science Problem")
+            st.write("Now that we have a solid grasp of the data at hand and a clear understanding of the variables we intend to investigate, it's time to define the specific data science problem we aim to solve. This step is crucial as it sets the direction for our analysis and helps us determine the appropriate methodologies and techniques to employ.")

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+pandas
+langchain-community
+langchain-experimental
+langchain-core

utils.py

@@ -0,0 +1,101 @@
+import streamlit as st
+import pandas as pd
+from langchain_community.llms import HuggingFaceHub # New Import for HuggingFace
+from langchain_experimental.agents import create_pandas_dataframe_agent
+from langchain.agents.agent_types import AgentType 
+from typing import Tuple, Optional
+import os # New Import for environment variables/secrets
+
+
+# --- Utility Functions ---
+
+def handle_start_button_click(button_id: int):
+    """Function to update the clicked value in session state."""
+    st.session_state.clicked[button_id] = True
+
+
+@st.cache_resource(show_spinner="Initializing LLM Agent...")
+def initialize_hf_agent(df: pd.DataFrame, model_name: str) -> Tuple[Optional[HuggingFaceHub], Optional[create_pandas_dataframe_agent]]:
+    """
+    Initializes the HuggingFaceHub-based LangChain Pandas Agent.
+    This function is cached to prevent repeated, slow LLM initialization.
+    """
+    
+    # Check for Hugging Face API Token
+    # Checks st.secrets first, then environment variables
+    hf_token = st.secrets.get("HUGGINGFACEHUB_API_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+
+    if not hf_token:
+        st.error("ERROR: **HUGGINGFACEHUB_API_TOKEN** is not found. Please set it in your environment variables or in your Streamlit secrets (`.streamlit/secrets.toml`).")
+        return None, None
+    
+    # 1. Initialize HuggingFaceHub LLM
+    try:
+        # Uses the specified model which should be mistralai/Mistral-7B-Instruct-v0.2
+        llm = HuggingFaceHub(
+            repo_id=model_name,
+            huggingfacehub_api_token=hf_token,
+            # Adjust model parameters as needed, e.g., to match instruction-tuned requirements
+            model_kwargs={"temperature": 0.1, "max_length": 512} 
+        )
+        
+        # Simple test run to confirm connection
+        llm_test_response = llm("Say 'OK' and nothing else.") 
+        
+        if not llm_test_response or len(llm_test_response.strip()) < 2:
+            st.error(f"HuggingFace model responded with an empty or too short response during test: '{llm_test_response.strip()}'")
+            return None, None
+            
+        st.sidebar.success(f"Hugging Face model **{model_name}** connected.")
+    except Exception as e:
+        st.error(f"Failed to initialize HuggingFace model '{model_name}'. Error: {e}")
+        return None, None 
+
+    # 2. Create Pandas Agent
+    pandas_agent = create_pandas_dataframe_agent(
+        llm,
+        df,
+        verbose=True,
+        # Using ZERO_SHOT_REACT_DESCRIPTION which is generally well-supported
+        agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION, 
+        allow_dangerous_code=True
+    )
+    return llm, pandas_agent
+
+
+@st.cache_data(show_spinner=False)
+def steps_eda(_llm) -> str:
+    """Queries the LLM for the key steps of EDA."""
+    st.info("Querying LLM for EDA steps...")
+    response = _llm("What are the key steps of Exploratory Data Analysis (EDA)? Provide a bulleted list.")
+    return response
+
+
+@st.cache_data(show_spinner="Running initial EDA queries...")
+def function_agent(_agent, _df) -> bool:
+    """Runs the initial automated EDA sequence."""
+    st.write("**Data Overview**")
+    st.write("The first rows of the dataset are:")
+    st.dataframe(_df.head(), use_container_width=True)
+    
+    st.subheader("Data Cleaning")
+    
+    columns_df = _agent.run("What are the columns in the dataset?")
+    st.write(f"The columns in the dataset are: {columns_df}")
+    
+    missing_values = _agent.run("Are there any missing values in the dataset? List the columns and counts.")
+    st.write(f"Missing values in the dataset: {missing_values}")
+    
+    duplicates = _agent.run("Are there any duplicate rows in the dataset? How many?")
+    st.write(f"Duplicate rows in the dataset: {duplicates}")
+    
+    st.subheader("Statistical Summary")
+    st.dataframe(_df.describe(include='all'), use_container_width=True)
+    
+    correlation_analysis = _agent.run("Calculate the correlation matrix between all numerical features and summarize the top 3 strongest correlations.")
+    st.write(correlation_analysis)
+    
+    outliers_and_new_features = _agent.run("Identify any extreme outliers in the numerical features (use IQR method for top 3 columns). Also, are there any obvious new features that could be created from existing columns? Combine these answers.")
+    st.write(outliers_and_new_features)
+
+    return True