Update app.py

app.py

@@ -1,223 +1,100 @@
 import streamlit as st
 import pandas as pd
-import numpy as np
 import matplotlib.pyplot as plt
-from sentence_transformers import SentenceTransformer
-from transformers import pipeline
+import seaborn as sns
 from sklearn.ensemble import IsolationForest
-from io import BytesIO
-
-# App Config
-st.set_page_config(
-    page_title="FactoryGPT 5.0 – Maintenance Dashboard",
-    page_icon="🧠",
-    layout="wide"
-)
-
-# Load NLP + Anomaly Models
-EMBED_MODEL = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
-GEN_MODEL = pipeline('text2text-generation', model='google/flan-t5-base')
-
-# Optional: Units per parameter
-unit_map = {
-    "temperature": "°C",
-    "vibration": "mm/s",
-    "pressure": "bar",
-    "current": "A",
-    "voltage": "V",
-    "speed": "RPM"
-}
-
-# Style
-st.markdown("""
-    <style>
-    html, body, [class*="css"] {
-        font-family: 'Segoe UI', sans-serif;
-        background-color: #0f1117;
-        color: #f0f0f0;
-    }
-    .card {
-        background-color: #1a1c23;
-        padding: 1rem;
-        border-radius: 10px;
-        margin-bottom: 1rem;
-        box-shadow: 0 0 8px rgba(88,166,255,0.2);
-    }
-    </style>
-""", unsafe_allow_html=True)
-
-# Header
-st.markdown("""
-    <div style='text-align: center;'>
-        <h1 style='color: #58a6ff;'>🏭 FactoryGPT 5.0 – Technical Maintenance Dashboard</h1>
-        <p style='color: #bbb;'>Anomaly Monitoring • Parameter Trends • Role-Based Intelligence</p>
-        <hr style='border-top: 2px solid #888;'>
-    </div>
-""", unsafe_allow_html=True)
+from sklearn.preprocessing import StandardScaler
+import openai
+import os
+
+# Set your OpenAI key here or use Hugging Face Secrets Manager
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+st.set_page_config(page_title="Smart Factory RAG Assistant", layout="wide")
+
+st.title("🏭 Industry 5.0 | Smart Factory RAG Assistant")
 
 # File Upload
-uploaded_file = st.sidebar.file_uploader("📂 Upload sensor log (CSV)", type=["csv"])
+uploaded_file = st.file_uploader("📤 Upload your factory CSV data", type=["csv"])
 
 if uploaded_file:
     df = pd.read_csv(uploaded_file)
-    numeric_cols = df.select_dtypes(include=np.number).columns.tolist()
+    st.success("✅ File uploaded and loaded!")
+
+    # Basic Preview
+    st.subheader("📄 Data Preview")
+    st.dataframe(df.head())
+
+    # Descriptive Stats
+    st.subheader("📊 Descriptive Statistics")
+    st.dataframe(df.describe().T)
+
+    # Correlation Analysis
+    st.subheader("🔗 Parameter Correlation Heatmap")
+    fig, ax = plt.subplots(figsize=(10, 6))
+    corr = df.corr(numeric_only=True)
+    sns.heatmap(corr, annot=True, cmap="coolwarm", fmt=".2f", ax=ax)
+    st.pyplot(fig)
 
     # Anomaly Detection
-    iso = IsolationForest(contamination=0.02, random_state=42)
-    labels = iso.fit_predict(df[numeric_cols])
-    df['status'] = ['❌ Fault Detected' if x == -1 else '✅ Healthy' for x in labels]
-    df['maintenance_flag'] = ['🔧 Inspect Required' if x == -1 else '🟢 Stable' for x in labels]
-
-    # NLP Embeddings
-    if 'chunks' not in st.session_state or 'embeddings' not in st.session_state:
-        chunks = [
-            f"[Entry {i}] " + ", ".join([f"{col}: {row[col]:.2f}" for col in numeric_cols])
-            for i, row in df.iterrows()
-        ]
-        embeddings = EMBED_MODEL.encode(chunks)
-        st.session_state.chunks = chunks
-        st.session_state.embeddings = embeddings
-
-    # Health Summary
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown("### 🧠 Machine Health Summary")
-        status_counts = df['status'].value_counts()
-        fig1, ax1 = plt.subplots(figsize=(5, 4))
-        bars = ax1.bar(status_counts.index, status_counts.values, color=["red", "green"])
-        ax1.set_title("Detected Machine Health Conditions", fontsize=14)
-        ax1.set_ylabel("Record Count")
-        ax1.set_xlabel("Status")
-        ax1.set_facecolor("#0f1117")
-        ax1.tick_params(colors='white')
-        ax1.title.set_color('white')
-        ax1.xaxis.label.set_color('white')
-        ax1.yaxis.label.set_color('white')
-        for spine in ax1.spines.values():
-            spine.set_edgecolor('white')
-        for bar in bars:
-            height = bar.get_height()
-            ax1.annotate(f'{height:,}', xy=(bar.get_x() + bar.get_width()/2, height),
-                         xytext=(0, 6), textcoords="offset points", ha='center', color='white')
-        st.pyplot(fig1)
-
-    with col2:
-        st.markdown("### 🧪 Parameters Monitored")
-        st.markdown(f"""
-            <div class="card">
-                {' • '.join(numeric_cols)}
-            </div>
-        """, unsafe_allow_html=True)
-
-    # Trend Plot
-    st.markdown("### 📉 Sensor Trend (with Fault Overlay)")
-    col3, col4 = st.columns(2)
-    time_col = col3.selectbox("🕒 Time Column", ["None"] + list(df.columns))
-    trend_param = col4.selectbox("📌 Select Parameter", numeric_cols)
-
-    if time_col != "None":
-        df = df.sort_values(by=time_col)
-
-    x_vals = df[time_col] if time_col != "None" else df.index
-    y_vals = df[trend_param]
-    y_label = f"{trend_param} ({unit_map.get(trend_param.lower(), '')})"
-
-    fig2, ax2 = plt.subplots(figsize=(8, 4.5))
-    ax2.plot(x_vals, y_vals, label=trend_param, color="skyblue", linewidth=1.5)
-    ax2.scatter(
-        x_vals[df['status'] == '❌ Fault Detected'],
-        y_vals[df['status'] == '❌ Fault Detected'],
-        color='red', label='Fault Detected', zorder=5
-    )
-    ax2.set_title(f"{trend_param} Sensor Trend")
-    ax2.set_xlabel("Time" if time_col != "None" else "Index")
-    ax2.set_ylabel(y_label)
-    ax2.legend()
-    ax2.set_facecolor("#0f1117")
-    ax2.tick_params(colors='white')
-    ax2.title.set_color('white')
-    ax2.xaxis.label.set_color('white')
-    ax2.yaxis.label.set_color('white')
-    for spine in ax2.spines.values():
-        spine.set_edgecolor('white')
-    st.pyplot(fig2)
-
-    img_buffer = BytesIO()
-    fig2.savefig(img_buffer, format='png', bbox_inches="tight")
-    st.download_button("📷 Download Trend Chart (PNG)", img_buffer.getvalue(), file_name="sensor_trend.png")
-
-    # Fault Rate Over Time
-    if time_col != "None":
-        st.markdown("### 📈 Fault Rate Over Time")
-        df[time_col] = pd.to_datetime(df[time_col], errors='coerce')
-        df['fault_flag'] = df['status'].apply(lambda x: 1 if x == '❌ Fault Detected' else 0)
-        freq = 'H' if (df[time_col].max() - df[time_col].min()).days <= 3 else 'D'
-        grouped = df.set_index(time_col)['fault_flag'].resample(freq).mean() * 100
-
-        fig3, ax3 = plt.subplots(figsize=(8, 4))
-        ax3.plot(grouped.index, grouped, color='orange', linewidth=2)
-        ax3.set_title("Fault Rate Over Time")
-        ax3.set_ylabel("Fault Rate (%)")
-        ax3.set_xlabel("Time")
-        ax3.set_facecolor("#0f1117")
-        ax3.tick_params(colors='white')
-        ax3.title.set_color('white')
-        ax3.yaxis.label.set_color('white')
-        ax3.xaxis.label.set_color('white')
-        for spine in ax3.spines.values():
-            spine.set_edgecolor('white')
-        st.pyplot(fig3)
-
-    # Export Faults
-    st.markdown("### 📤 Export Anomalies")
-    fault_df = df[df['status'] == '❌ Fault Detected']
-    buf = BytesIO()
-    fault_df.to_csv(buf, index=False)
-    st.download_button("⬇️ Download Fault Log", data=buf.getvalue(), file_name="faults.csv", mime="text/csv")
-
-    # Metadata correlation
-    st.markdown("### 🏷️ Fault Distribution by Machine/Component")
-    meta_cols = [c for c in df.columns if 'machine' in c.lower() or 'component' in c.lower()]
-    for col in meta_cols:
-        st.markdown(f"**{col} – Fault Frequency**")
-        st.bar_chart(df[df['status'] == '❌ Fault Detected'][col].value_counts())
-
-    # Role Assistant
-    st.markdown("### 💬 Technical Assistant by Role")
-    roles = {
-        "Operator": {
-            "description": "Focus on equipment behavior. Spot abnormal patterns and guide simple actions.",
-            "style": "Explain simply. Emphasize safety and when to alert maintenance."
-        },
-        "Maintenance": {
-            "description": "Diagnose machine issues. Recommend parts to inspect or replace.",
-            "style": "Use technical language. Mention symptoms and sensor causes."
-        },
-        "Engineer": {
-            "description": "Analyze system behavior. Identify root causes or instability.",
-            "style": "Use RCA format. Discuss fault thresholds, control issues, and next steps."
-        }
-    }
-
-    role = st.selectbox("👤 Select your role", roles.keys())
-    question = st.text_input("🧠 Ask a question")
+    st.subheader("⚠️ Anomaly Detection using Isolation Forest")
+    num_df = df.select_dtypes(include='number').dropna()
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(num_df)
+
+    iso = IsolationForest(contamination=0.05)
+    df['Anomaly'] = iso.fit_predict(X_scaled)
+    anomalies = df[df['Anomaly'] == -1]
+    st.write(f"Detected {len(anomalies)} anomalies")
+    st.dataframe(anomalies.head(10))
+
+    # Prepare context for GPT
+    st.subheader("🧠 Role-Based Decision Assistant")
+    role = st.selectbox("Select your role", ["Engineer", "Operator"])
+    question = st.text_input("Ask a question based on the data analysis")
 
     if question:
-        qvec = EMBED_MODEL.encode([question])[0]
-        sims = np.dot(st.session_state.embeddings, qvec)
-        idxs = np.argsort(sims)[-5:][::-1]
-        context = "\n".join([st.session_state.chunks[i] for i in idxs])
-
-        prompt = (
-            f"ROLE: {role}\n"
-            f"RESPONSIBILITIES: {roles[role]['description']}\n"
-            f"COMMUNICATION STYLE: {roles[role]['style']}\n\n"
-            f"DATA CONTEXT:\n{context}\n\n"
-            f"QUESTION:\n{question}\n\n"
-            f"ANSWER:\n"
-        )
-        result = GEN_MODEL(prompt, max_length=400)[0]['generated_text']
-        st.markdown(f"**🤖 Response:**\n\n{result}")
+        with st.spinner("Thinking..."):
+            summary = df.describe().to_string()
+            corr_text = corr.to_string()
+            anomaly_count = len(anomalies)
+
+            context = f"""
+You are a highly skilled {role} working in a smart manufacturing facility.
+
+Here is a summary of the uploaded data:
+
+STATISTICAL SUMMARY:
+{summary}
+
+PARAMETER CORRELATIONS:
+{corr_text}
+
+ANOMALY DETECTION:
+{anomaly_count} anomalies detected using Isolation Forest method.
+
+Based on this context, answer the following question in a clear, technically accurate manner and suggest best decisions from the point of view of a {role}.
+"""
+
+            final_prompt = f"""{context}
+QUESTION: {question}
+ANSWER:"""
+
+            try:
+                response = openai.ChatCompletion.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": f"You are an expert {role} in a smart factory."},
+                        {"role": "user", "content": final_prompt}
+                    ],
+                    temperature=0.5,
+                    max_tokens=500
+                )
+                answer = response['choices'][0]['message']['content']
+                st.success("✅ Recommendation:")
+                st.markdown(f"**{answer}**")
+            except Exception as e:
+                st.error(f"⚠️ Error calling GPT API: {str(e)}")
 
 else:
-    st.info("👈 Upload a sensor CSV file to generate your technical dashboard.")
+    st.info("📂 Please upload a factory CSV data file to begin analysis.")