Update app.py

app.py

@@ -1,103 +1,147 @@
-import gradio as gr
-from transformers import pipeline, RagTokenizer, RagRetriever, RagSequenceForGeneration
-import paho.mqtt.client as mqtt
-from gtts import gTTS
+import streamlit as st
+import torch
+from transformers import ViTForImageClassification, ViTImageProcessor, pipeline
+from PIL import Image
+import pandas as pd
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.llms import HuggingFaceHub
+from langchain_community.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.docstore.document import Document
+from langchain.prompts import PromptTemplate
+from langchain.chains import RetrievalQA
 import os
-import sqlite3
-from sklearn.ensemble import IsolationForest
-import speech_recognition as sr
 
-# Initialize Database
-conn = sqlite3.connect('preferences.db')
-cursor = conn.cursor()
-cursor.execute('''CREATE TABLE IF NOT EXISTS preferences (id INTEGER PRIMARY KEY, setting TEXT, value TEXT)''')
-cursor.execute('''CREATE TABLE IF NOT EXISTS history (id INTEGER PRIMARY KEY, command TEXT, response TEXT)''')
-conn.commit()
-
-# Anomaly Detection Model
-anomaly_model = IsolationForest(contamination=0.1)
-data = []
-
-# Initialize Models
-retriever = RagRetriever.from_pretrained("facebook/rag-sequence-base")
-tokenizer = RagTokenizer.from_pretrained("facebook/rag-sequence-base")
-model = RagSequenceForGeneration.from_pretrained("facebook/rag-sequence-base")
-nlp = pipeline("conversational")
-
-# IoT Device Control
-def control_device(command):
-    client = mqtt.Client()
-    client.connect("broker.hivemq.com", 1883, 60)
-    if "light" in command and "on" in command:
-        client.publish("home/light", "ON")
-        return "Light turned on."
-    elif "light" in command and "off" in command:
-        client.publish("home/light", "OFF")
-        return "Light turned off."
-    else:
-        return "Command not recognized."
-
-# Process Command
-def process_command(command):
-    if "light" in command:
-        return control_device(command)
-    else:
-        inputs = tokenizer(command, return_tensors="pt")
-        retrieved_docs = retriever(command, return_tensors="pt")
-        outputs = model.generate(input_ids=inputs['input_ids'], context_input_ids=retrieved_docs['context_input_ids'])
-        return tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-# Log History
-def log_history(command, response):
-    cursor.execute("INSERT INTO history (command, response) VALUES (?, ?)", (command, response))
-    conn.commit()
-
-# Anomaly Detection
-def detect_anomalies(command):
-    global data
-    data.append(len(command))
-    if len(data) > 10:
-        anomaly_model.fit([[x] for x in data])
-        if anomaly_model.predict([[len(command)]])[0] == -1:
-            return True
-    return False
+# Page config
+st.set_page_config(
+    page_title="Building Damage Analysis",
+    page_icon="🏗️",
+    layout="wide"
+)
 
-# Gradio Interface for Audio and Text Input
-def assistant(input_audio=None, input_text=""):
-    if input_audio:
-        # Process audio input
-        recognizer = sr.Recognizer()
-        with sr.AudioFile(input_audio) as source:
-            audio = recognizer.record(source)
-            try:
-                command = recognizer.recognize_google(audio)
-            except sr.UnknownValueError:
-                return "Sorry, I could not understand the audio.", ""
-    else:
-        # Process text input
-        command = input_text
+# Initialize models
+@st.cache_resource
+def load_models():
+    # Vision model
+    damage_model = ViTForImageClassification.from_pretrained("microsoft/vit-base-patch16-224")
+    processor = ViTImageProcessor.from_pretrained("microsoft/vit-base-patch16-224")
+    
+    # Text model
+    llm = HuggingFaceHub(
+        repo_id="google/flan-t5-large",
+        model_kwargs={"temperature": 0.7, "max_length": 512}
+    )
+    
+    embeddings = HuggingFaceEmbeddings(
+        model_name='sentence-transformers/all-MiniLM-L6-v2'
+    )
+    
+    return damage_model, processor, embeddings, llm
 
-    # Check anomalies
-    if detect_anomalies(command):
-        return "Warning: Anomalous behavior detected!", ""
+# Sample data - in production, you'd load this from a proper dataset
+SAMPLE_DATA = [
+    {
+        "repair_description": "Major wall crack requiring structural repair. Steel plate reinforcement needed.",
+        "repair_cost": 5000,
+        "damage_type": "Wall Crack"
+    },
+    {
+        "repair_description": "Concrete beam damage with exposed rebar. Requires immediate attention.",
+        "repair_cost": 7500,
+        "damage_type": "Beam Damage"
+    },
+    {
+        "repair_description": "Foundation settling causing structural issues. Need underpinning.",
+        "repair_cost": 15000,
+        "damage_type": "Foundation Issue"
+    }
+]
 
-    # Process command
-    response = process_command(command)
-    log_history(command, response)
+def setup_rag(embeddings, llm):
+    # Create documents from sample data
+    documents = [
+        Document(
+            page_content=f"{item['repair_description']} Cost: ${item['repair_cost']}",
+            metadata={'cost': item['repair_cost'], 'damage_type': item['damage_type']}
+        )
+        for item in SAMPLE_DATA
+    ]
+    
+    # Create vector store
+    vectorstore = FAISS.from_documents(documents, embeddings)
+    
+    # Create prompt template
+    template = """
+    Analyze building damage and provide repair recommendations based on this context:
+    {context}
+    
+    For damage type: {question}
+    
+    Provide:
+    1. Damage assessment
+    2. Repair steps
+    3. Safety considerations
+    4. Estimated cost range
+    """
+    
+    prompt = PromptTemplate(template=template, input_variables=["context", "question"])
+    
+    # Create QA chain
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=vectorstore.as_retriever(search_kwargs={'k': 2}),
+        chain_type_kwargs={"prompt": prompt}
+    )
+    
+    return qa_chain
 
-    # Text-to-Speech Output
-    tts = gTTS(text=response, lang='en')
-    tts.save("response.mp3")
-    return response, "response.mp3"
+def process_image(image, model, processor):
+    inputs = processor(images=image, return_tensors="pt")
+    outputs = model(**inputs)
+    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    return predictions[0].tolist()
 
-# Gradio Interface with Audio and Text Input Options
-demo = gr.Interface(
-    fn=assistant,
-    inputs=[
-        gr.Audio(source="microphone", type="filepath", optional=True),  # Audio input
-        gr.Textbox(label="Text Command", placeholder="Type a command...")  # Text input
-    ],
-    outputs=["text", "audio"]
-)
+def main():
+    st.title("🏗️ Building Damage Detection & Analysis")
+    st.markdown("""
+    Upload a photo of building damage for AI analysis and repair recommendations.
+    """)
+    
+    # Load models on first run
+    if 'models_loaded' not in st.session_state:
+        with st.spinner('Loading AI models...'):
+            damage_model, processor, embeddings, llm = load_models()
+            qa_chain = setup_rag(embeddings, llm)
+            st.session_state['models_loaded'] = True
+            st.session_state['models'] = (damage_model, processor, qa_chain)
+    
+    damage_model, processor, qa_chain = st.session_state['models']
+    
+    # File upload
+    uploaded_file = st.file_uploader("Upload building damage photo", type=["jpg", "jpeg", "png"])
+    
+    if uploaded_file:
+        # Display image
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Uploaded Image", use_column_width=True)
+        
+        with st.spinner('Analyzing damage...'):
+            # Process image
+            predictions = process_image(image, damage_model, processor)
+            damage_types = ["Wall Crack", "Beam Damage", "Foundation Issue", 
+                          "Roof Damage", "Structural Damage"]
+            
+            # Show results
+            st.subheader("Detected Damage Types")
+            for damage_type, prob in zip(damage_types, predictions):
+                if prob > 0.2:
+                    st.metric(damage_type, f"{prob:.1%}")
+                    
+                    with st.spinner(f'Generating analysis for {damage_type}...'):
+                        analysis = qa_chain.invoke(damage_type)
+                        st.markdown(f"### Analysis for {damage_type}")
+                        st.markdown(analysis['result'])
 
-demo.launch()
+if __name__ == "__main__":
+    main()