Update app.py

app.py

@@ -1,60 +1,93 @@
 import streamlit as st
 import numpy as np
 import pandas as pd
-from langchain.tools import tool
-from langchain.agents import initialize_agent, AgentType
-from langchain.chat_models import ChatOpenAI
-from typing import Union, List, Dict, Optional
 import matplotlib.pyplot as plt
 import seaborn as sns
 import os
 import base64
 import io
+from groq import Groq
+from langchain.tools import tool
+from langchain.agents import AgentType, initialize_agent
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from typing import Optional, Dict, List
+
+# Initialize Groq Client
+client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
 
-# Set up LangChain with OpenAI (or any other LLM)
-os.environ["OPENAI_API_KEY"] = "your-openai-api-key"  # Replace with your OpenAI API key
-llm = ChatOpenAI(model="gpt-4", temperature=0.7)
+class GroqAnalyst:
+    """Advanced AI Researcher & Data Analyst using Groq"""
+    def __init__(self, model_name="mixtral-8x7b-32768"):
+        self.model_name = model_name
+        self.system_prompt = """
+        You are an expert AI research assistant and data scientist. 
+        Provide detailed, technical analysis with professional visualizations.
+        """
+
+    def analyze(self, prompt: str, data: pd.DataFrame) -> str:
+        """Execute complex data analysis using Groq"""
+        try:
+            dataset_info = f"""
+            Dataset Shape: {data.shape}
+            Columns: {', '.join(data.columns)}
+            Data Types: {data.dtypes.to_dict()}
+            Sample Data: {data.head(3).to_dict()}
+            """
+            
+            completion = client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": self.system_prompt},
+                    {"role": "user", "content": f"{dataset_info}\n\nTask: {prompt}"}
+                ],
+                model=self.model_name,
+                temperature=0.3,
+                max_tokens=4096,
+                stream=False
+            )
+            
+            return completion.choices[0].message.content
+        
+        except Exception as e:
+            return f"Analysis Error: {str(e)}"
 
 @tool
-def analyze_basic_stats(data: pd.DataFrame) -> str:
-    """Calculate basic statistical measures for numerical columns in the dataset.
+def advanced_eda(data: pd.DataFrame) -> Dict:
+    """Perform comprehensive exploratory data analysis.
     
     Args:
-        data (pd.DataFrame): The dataset to analyze. It should contain at least one numerical column.
-    
+        data (pd.DataFrame): Input dataset for analysis
+        
     Returns:
-        str: A string containing formatted basic statistics for each numerical column,
-            including mean, median, standard deviation, skewness, and missing value counts.
+        Dict: Contains statistical summary, missing values, and data quality report
     """
-    stats = {}
-    numeric_cols = data.select_dtypes(include=[np.number]).columns
-    
-    for col in numeric_cols:
-        stats[col] = {
-            'mean': float(data[col].mean()),
-            'median': float(data[col].median()),
-            'std': float(data[col].std()),
-            'skew': float(data[col].skew()),
-            'missing': int(data[col].isnull().sum())
+    analysis = {
+        "statistical_summary": data.describe().to_dict(),
+        "missing_values": data.isnull().sum().to_dict(),
+        "data_quality": {
+            "duplicates": data.duplicated().sum(),
+            "zero_values": (data == 0).sum().to_dict()
         }
-    
-    return str(stats)
+    }
+    return analysis
 
 @tool
-def generate_correlation_matrix(data: pd.DataFrame) -> str:
-    """Generate a visual correlation matrix for numerical columns in the dataset.
+def visualize_distributions(data: pd.DataFrame, columns: List[str]) -> str:
+    """Generate distribution plots for specified numerical columns.
     
     Args:
-        data (pd.DataFrame): The dataset to analyze. It should contain at least two numerical columns.
-    
+        data (pd.DataFrame): Input dataset
+        columns (List[str]): List of numerical columns to visualize
+        
     Returns:
-        str: A base64 encoded string representing the correlation matrix plot image.
+        str: Base64 encoded image of the visualization
     """
-    numeric_data = data.select_dtypes(include=[np.number])
-    
-    plt.figure(figsize=(10, 8))
-    sns.heatmap(numeric_data.corr(), annot=True, cmap='coolwarm')
-    plt.title('Correlation Matrix')
+    plt.figure(figsize=(12, 6))
+    for i, col in enumerate(columns, 1):
+        plt.subplot(1, len(columns), i)
+        sns.histplot(data[col], kde=True)
+        plt.title(f'Distribution of {col}')
+    plt.tight_layout()
     
     buf = io.BytesIO()
     plt.savefig(buf, format='png')
@@ -62,136 +95,122 @@ def generate_correlation_matrix(data: pd.DataFrame) -> str:
     return base64.b64encode(buf.getvalue()).decode()
 
 @tool
-def analyze_categorical_columns(data: pd.DataFrame) -> str:
-    """Analyze categorical columns in the dataset for distribution and frequencies.
+def temporal_analysis(data: pd.DataFrame, time_col: str, value_col: str) -> str:
+    """Analyze time series data and generate trend visualization.
     
     Args:
-        data (pd.DataFrame): The dataset to analyze. It should contain at least one categorical column.
-    
+        data (pd.DataFrame): Dataset containing time series
+        time_col (str): Name of timestamp column
+        value_col (str): Name of value column to analyze
+        
     Returns:
-        str: A string containing formatted analysis results for each categorical column,
-            including unique value counts, top categories, and missing value counts.
+        str: Base64 encoded image of time series plot
     """
-    categorical_cols = data.select_dtypes(include=['object', 'category']).columns
-    analysis = {}
-    
-    for col in categorical_cols:
-        analysis[col] = {
-            'unique_values': int(data[col].nunique()),
-            'top_categories': data[col].value_counts().head(5).to_dict(),
-            'missing': int(data[col].isnull().sum())
-        }
+    plt.figure(figsize=(12, 6))
+    data[time_col] = pd.to_datetime(data[time_col])
+    data.set_index(time_col)[value_col].plot()
+    plt.title(f'Temporal Trend of {value_col}')
+    plt.xlabel('Date')
+    plt.ylabel('Value')
     
-    return str(analysis)
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    plt.close()
+    return base64.b64encode(buf.getvalue()).decode()
 
 @tool
-def suggest_features(data: pd.DataFrame) -> str:
-    """Suggest potential feature engineering steps based on data characteristics.
+def hypothesis_testing(data: pd.DataFrame, group_col: str, value_col: str) -> Dict:
+    """Perform statistical hypothesis testing between groups.
     
     Args:
-        data (pd.DataFrame): The dataset to analyze. It can contain both numerical and categorical columns.
-    
+        data (pd.DataFrame): Input dataset
+        group_col (str): Categorical column defining groups
+        value_col (str): Numerical column to compare
+        
     Returns:
-        str: A string containing suggestions for feature engineering based on
-            the characteristics of the input data.
+        Dict: Contains test results, p-value, and conclusion
     """
-    suggestions = []
-    numeric_cols = data.select_dtypes(include=[np.number]).columns
-    categorical_cols = data.select_dtypes(include=['object', 'category']).columns
+    from scipy.stats import ttest_ind
     
-    if len(numeric_cols) >= 2:
-        suggestions.append("Consider creating interaction terms between numerical features")
+    groups = data[group_col].unique()
+    if len(groups) != 2:
+        return {"error": "Hypothesis testing requires exactly two groups"}
     
-    if len(categorical_cols) > 0:
-        suggestions.append("Consider one-hot encoding for categorical variables")
-        
-    for col in numeric_cols:
-        if data[col].skew() > 1 or data[col].skew() < -1:
-            suggestions.append(f"Consider log transformation for {col} due to skewness")
+    group1 = data[data[group_col] == groups[0]][value_col]
+    group2 = data[data[group_col] == groups[1]][value_col]
+    
+    t_stat, p_value = ttest_ind(group1, group2)
     
-    return '\n'.join(suggestions)
+    return {
+        "t_statistic": t_stat,
+        "p_value": p_value,
+        "conclusion": "Significant difference" if p_value < 0.05 else "No significant difference"
+    }
 
 def main():
-    st.title("Data Analysis Assistant")
-    st.write("Upload your dataset and get automated analysis with natural language interaction.")
+    st.title("🔬 AI Research Assistant with Groq")
+    st.markdown("Advanced data analysis powered by Groq's accelerated computing")
     
     # Initialize session state
     if 'data' not in st.session_state:
-        st.session_state['data'] = None
-    if 'agent' not in st.session_state:
-        st.session_state['agent'] = None
-    
-    # Drag-and-drop file upload
-    uploaded_file = st.file_uploader("Drag and drop a CSV file here", type="csv")
-    
-    try:
-        if uploaded_file is not None:
-            with st.spinner('Loading and processing your data...'):
-                # Load the dataset
-                data = pd.read_csv(uploaded_file)
-                st.session_state['data'] = data
-                
-                # Initialize the LangChain agent with the tools
-                tools = [analyze_basic_stats, generate_correlation_matrix, 
-                         analyze_categorical_columns, suggest_features]
-                st.session_state['agent'] = initialize_agent(
-                    tools=tools,
-                    llm=llm,
-                    agent=AgentType.OPENAI_FUNCTIONS,
-                    verbose=True
-                )
+        st.session_state.data = None
+    if 'analyst' not in st.session_state:
+        st.session_state.analyst = GroqAnalyst()
+    
+    # File upload section
+    with st.sidebar:
+        st.header("Data Upload")
+        uploaded_file = st.file_uploader("Upload dataset (CSV)", type="csv")
+        if uploaded_file:
+            with st.spinner("Analyzing dataset..."):
+                st.session_state.data = pd.read_csv(uploaded_file)
+                st.success(f"Loaded {len(st.session_state.data)} records")
+    
+    # Main analysis interface
+    if st.session_state.data is not None:
+        st.subheader("Dataset Overview")
+        st.dataframe(st.session_state.data.head(), use_container_width=True)
+        
+        analysis_type = st.selectbox("Select Analysis Type", [
+            "Exploratory Data Analysis",
+            "Temporal Analysis",
+            "Statistical Testing",
+            "Custom Research Query"
+        ])
+        
+        if analysis_type == "Exploratory Data Analysis":
+            with st.expander("Advanced EDA"):
+                eda_result = advanced_eda(st.session_state.data)
+                st.json(eda_result)
                 
-                st.success(f'Successfully loaded dataset with {data.shape[0]} rows and {data.shape[1]} columns')
-                st.subheader("Data Preview")
-                st.dataframe(data.head())
+                num_cols = st.session_state.data.select_dtypes(include=np.number).columns.tolist()
+                if num_cols:
+                    selected_cols = st.multiselect("Select columns for distribution analysis", num_cols)
+                    if selected_cols:
+                        img_data = visualize_distributions(st.session_state.data, selected_cols)
+                        st.image(f"data:image/png;base64,{img_data}")
         
-        if st.session_state['data'] is not None:
-            analysis_type = st.selectbox(
-                "Choose analysis type",
-                ["Basic Statistics", "Correlation Analysis", "Categorical Analysis", 
-                 "Feature Engineering", "Custom Question"]
-            )
-            
-            if analysis_type == "Basic Statistics":
-                with st.spinner('Analyzing basic statistics...'):
-                    result = st.session_state['agent'].run(
-                        f"Analyze the dataset and provide basic statistics: {st.session_state['data']}"
-                    )
-                    st.write(result)
-                    
-            elif analysis_type == "Correlation Analysis":
-                with st.spinner('Generating correlation matrix...'):
-                    result = st.session_state['agent'].run(
-                        f"Generate a correlation matrix for the dataset: {st.session_state['data']}"
-                    )
-                    if isinstance(result, str) and result.startswith('data:image') or ',' in result:
-                        st.image(f"data:image/png;base64,{result.split(',')[-1]}")
-                    else:
-                        st.write(result)
-                    
-            elif analysis_type == "Categorical Analysis":
-                with st.spinner('Analyzing categorical columns...'):
-                    result = st.session_state['agent'].run(
-                        f"Analyze categorical columns in the dataset: {st.session_state['data']}"
-                    )
-                    st.write(result)
-                    
-            elif analysis_type == "Feature Engineering":
-                with st.spinner('Generating feature suggestions...'):
-                    result = st.session_state['agent'].run(
-                        f"Suggest feature engineering steps for the dataset: {st.session_state['data']}"
-                    )
-                    st.write(result)
-                    
-            elif analysis_type == "Custom Question":
-                question = st.text_input("What would you like to know about your data?")
-                if question:
-                    with st.spinner('Analyzing...'):
-                        result = st.session_state['agent'].run(question)
-                        st.write(result)
-                        
-    except Exception as e:
-        st.error(f"An error occurred: {str(e)}")
+        elif analysis_type == "Temporal Analysis":
+            time_col = st.selectbox("Select time column", st.session_state.data.columns)
+            value_col = st.selectbox("Select value column", st.session_state.data.select_dtypes(include=np.number).columns)
+            if time_col and value_col:
+                img_data = temporal_analysis(st.session_state.data, time_col, value_col)
+                st.image(f"data:image/png;base64,{img_data}")
+        
+        elif analysis_type == "Statistical Testing":
+            group_col = st.selectbox("Select group column", st.session_state.data.select_dtypes(include='object').columns)
+            value_col = st.selectbox("Select metric to compare", st.session_state.data.select_dtypes(include=np.number).columns)
+            if group_col and value_col:
+                test_result = hypothesis_testing(st.session_state.data, group_col, value_col)
+                st.json(test_result)
+        
+        elif analysis_type == "Custom Research Query":
+            research_query = st.text_area("Enter your research question:")
+            if research_query:
+                with st.spinner("Conducting advanced analysis..."):
+                    result = st.session_state.analyst.analyze(research_query, st.session_state.data)
+                    st.markdown("### Research Findings")
+                    st.markdown(result)
 
 if __name__ == "__main__":
     main()