Update app.py

app.py

@@ -1,182 +1,149 @@
 import gradio as gr
-import pandas as pd
-import pickle
-import os
-import base64
-from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate
-from llama_index.llms.huggingface import HuggingFaceInferenceAPI
+from llama_index import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI  # Use the new import as per the warning
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 from dotenv import load_dotenv
+import os
+import base64
 
 # Load environment variables
 load_dotenv()
 
-# Configure the Llama index settings
-Settings.llm = HuggingFaceInferenceAPI(
-    model_name="google/gemma-1.1-7b-it",
+# Configure HuggingFaceInferenceAPI and embedding model
+huggingface_inference_api = HuggingFaceInferenceAPI(
+    model_name="google/gemma-1.1-7b-it", 
     tokenizer_name="google/gemma-1.1-7b-it",
     context_window=3000,
     token=os.getenv("HF_TOKEN"),
     max_new_tokens=512,
-    generate_kwargs={"temperature": 0.1},
-)
-Settings.embed_model = HuggingFaceEmbedding(
-    model_name="BAAI/bge-small-en-v1.5"
+    generate_kwargs={"temperature": 0.1}
 )
+huggingface_embedding = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")
 
-# Define the directory for persistent storage and data
+# Define directories
 PERSIST_DIR = "./db"
 DATA_DIR = "data"
 
-# Ensure data directory exists
+# Ensure directories exist
 os.makedirs(DATA_DIR, exist_ok=True)
 os.makedirs(PERSIST_DIR, exist_ok=True)
 
-# Load the saved model and feature columns for the machine health predictor
-with open('logistic_regression_model.pkl', 'rb') as model_file:
-    model = pickle.load(model_file)
-
-with open('feature_columns.pkl', 'rb') as col_file:
-    feature_columns = pickle.load(col_file)
-
-def predict_status(air_temp, proc_temp, speed, torque, tool_wear):
-    # Prepare the input data
-    sample_input = {
-        "Air temperature [K]": air_temp,
-        "Process temperature [K]": proc_temp,
-        "Rotational speed [rpm]": speed,
-        "Torque [Nm]": torque,
-        "Tool wear [min]": tool_wear
-    }
-    
-    # Convert the sample input to a DataFrame
-    sample_df = pd.DataFrame([sample_input])
-    
-    # Ensure all columns from training data are present in the sample DataFrame
-    for col in feature_columns:
-        if col not in sample_df.columns:
-            sample_df[col] = 0  # Add missing columns and fill with 0
-    
-    # Reorder columns to match the order in the training data
-    sample_df = sample_df[feature_columns]
-
-    # Make a prediction
-    prediction = model.predict(sample_df)[0]
-
-    # Initialize the reason list
-    reasons = []
-
-    # Define acceptable ranges for each feature with user-friendly feedback
-    acceptable_ranges = {
-        "Air temperature [K]": (150, 500),
-        "Process temperature [K]": (150, 500),
-        "Rotational speed [rpm]": (500, 1500),
-        "Torque [Nm]": (100, 800),
-        "Tool wear [min]": (50, 300)
-    }
-
-    # User-friendly reasons for each feature
-    if air_temp < 150:
-        reasons.append("• The air temperature is too low, which might be causing the machine to underperform.")
-    elif air_temp > 500:
-        reasons.append("• The air temperature is too high, which could be causing the machine to overheat.")
-
-    if proc_temp < 150:
-        reasons.append("• The process temperature is below the normal range, possibly affecting machine efficiency.")
-    elif proc_temp > 500:
-        reasons.append("• The process temperature is too high, which might lead to overheating.")
-
-    if speed < 500:
-        reasons.append("• The rotational speed is too low, causing the machine to operate inefficiently.")
-    elif speed > 1500:
-        reasons.append("• The rotational speed is too high, which might be causing excessive strain on the machine.")
-
-    if torque < 100:
-        reasons.append("• The torque is too low, which may indicate that the machine is not operating at its full capacity.")
-    elif torque > 800:
-        reasons.append("• The torque is too high, possibly putting excessive stress on the machine's components.")
-
-    if tool_wear < 50:
-        reasons.append("• The tool wear is minimal, but routine checks are still recommended to prevent future issues.")
-    elif tool_wear > 300:
-        reasons.append("• The tool wear is high, and the tool may need to be replaced soon to maintain optimal performance.")
-
-    # Generate the final result message
-    if prediction == 0:
-        result_message = "🔴 Machine is NOT working.\n"  # First line for machine status
-        if reasons:
-            result_message += "\n".join(reasons)  # Second row onward for reasons with bullet points
-        else:
-            result_message += "No specific reason identified."  # In case no issues found
-    else:
-        result_message = "🟢 Machine is working fine."
-
-    return result_message
-
-def displayPDF():
-    # Load and display the PDF content from the data folder
-    filepath = os.path.join(DATA_DIR, "saved_pdf.pdf")
-    with open(filepath, "rb") as f:
+def display_pdf(file):
+    with open(file, "rb") as f:
         base64_pdf = base64.b64encode(f.read()).decode('utf-8')
-    pdf_display = f'<iframe src="data:application/pdf;base64,{base64_pdf}" width="100%" height="600" type="application/pdf"></iframe>'
-    return pdf_display
+    return f'<iframe src="data:application/pdf;base64,{base64_pdf}" width="100%" height="600" type="application/pdf"></iframe>'
 
 def data_ingestion():
-    documents = SimpleDirectoryReader(DATA_DIR).load_data()
-    storage_context = StorageContext.from_defaults()
-    index = VectorStoreIndex.from_documents(documents)
-    index.storage_context.persist(persist_dir=PERSIST_DIR)
+    try:
+        documents = SimpleDirectoryReader(DATA_DIR).load_data()
+        storage_context = StorageContext.from_defaults()
+        index = VectorStoreIndex.from_documents(documents)
+        index.storage_context.persist(persist_dir=PERSIST_DIR)
+    except Exception as e:
+        print(f"Error during data ingestion: {str(e)}")
 
 def handle_query(query):
-    storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
-    index = load_index_from_storage(storage_context)
-    chat_text_qa_msgs = [
-        (
-            "user",
-            """You are a Q&A assistant named AskAI, created by Vatsa. You have a specific response programmed for when users specifically ask about your creator, Suriya. The response is: "I was created by Suriya, an enthusiast in Artificial Intelligence. He is dedicated to solving complex problems and delivering innovative solutions. With a strong focus on machine learning, deep learning, Python, generative AI, NLP, and computer vision, Suriya is passionate about pushing the boundaries of AI to explore new possibilities." For all other inquiries, your main goal is to provide answers as accurately as possible, based on the instructions and context you have been given. If a question does not match the provided context or is outside the scope of the document, kindly advise the user to ask questions within the context of the document.
-            Context:
-            {context_str}
-            Question:
-            {query_str}
-            """
-        )
-    ]
-    text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
+    try:
+        storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
+        index = load_index_from_storage(storage_context)
+        
+        chat_text_qa_msgs = [
+            (
+                "user",
+                """You are a Q&A assistant named AskAI, created by Vatsa. You have a specific response programmed for when users specifically ask about your creator, Suriya. The response is: "I was created by Suriya, an enthusiast in Artificial Intelligence. He is dedicated to solving complex problems and delivering innovative solutions. With a strong focus on machine learning, deep learning, Python, generative AI, NLP, and computer vision, Suriya is passionate about pushing the boundaries of AI to explore new possibilities." For all other inquiries, your main goal is to provide answers as accurately as possible, based on the instructions and context you have been given. If a question does not match the provided context or is outside the scope of the document, kindly advise the user to ask questions within the context of the document.
+                Context:
+                {context_str}
+                Question:
+                {query_str}
+                """
+            )
+        ]
+        text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
+        
+        query_engine = index.as_query_engine(text_qa_template=text_qa_template)
+        answer = query_engine.query(query)
+
+        if hasattr(answer, 'response'):
+            return answer.response
+        elif isinstance(answer, dict) and 'response' in answer:
+            return answer['response']
+        else:
+            return "Sorry, I couldn't find an answer."
+    except Exception as e:
+        print(f"Error during query handling: {str(e)}")
+        return "An error occurred while processing your query."
+
+def process_file(uploaded_file):
+    if not uploaded_file.name.endswith('.pdf'):
+        return "Please upload a valid PDF file."
     
-    query_engine = index.as_query_engine(text_qa_template=text_qa_template)
-    answer = query_engine.query(query)
+    try:
+        # Save the uploaded file
+        filepath = os.path.join(DATA_DIR, "saved_pdf.pdf")
+        with open(filepath, "wb") as f:
+            f.write(uploaded_file.read())  # Read directly from uploaded_file
+
+        data_ingestion()  # Process PDF every time a new file is uploaded
+        return "PDF processed successfully."
+    except Exception as e:
+        return f"Error processing PDF: {str(e)}"
+
+def chat(user_input):
+    return handle_query(user_input)
+
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("<h1 style='text-align: center;'>PDF Chatbot By Vatsa Solution Pvt Ltd</h1>")
+    gr.Markdown("<h3 style='text-align: center;'>Retrieval-Augmented Generation</h3>")
+    gr.Markdown("<h4 style='text-align: center;'>Start chat ...🚀</h4>")
     
-    if hasattr(answer, 'response'):
-        return answer.response
-    elif isinstance(answer, dict) and 'response' in answer:
-        return answer['response']
-    else:
-        return "Sorry, I couldn't find an answer."
-
-# Define the Gradio interface
-iface = gr.Interface(
-    fn=lambda air_temp, proc_temp, speed, torque, tool_wear, user_query: (
-        predict_status(air_temp, proc_temp, speed, torque, tool_wear),
-        displayPDF(),
-        handle_query(user_query)
-    ),
-    inputs=[
-        gr.Slider(label="Air Temperature (K)", minimum=0, maximum=1000, step=0.01, value=300),
-        gr.Slider(label="Process Temperature (K)", minimum=0, maximum=1000, step=0.01, value=300),
-        gr.Slider(label="Rotational Speed (rpm)", minimum=0, maximum=2000, step=1, value=1000),
-        gr.Slider(label="Torque (Nm)", minimum=0, maximum=1000, step=0.1, value=500),
-        gr.Slider(label="Tool Wear (min)", minimum=0, maximum=1000, step=1, value=100),
-        gr.Textbox(label="Ask me anything about the PDF:", placeholder="Type your question here...")
-    ],
-    outputs=[
-        "text",  # For machine health prediction
-        "html",  # For PDF display
-        "text"   # For query response
-    ],
-    title="Integrated Machine Health and PDF Query Predictor",
-    description="Provide machine parameters to predict whether the machine is working or not, and ask questions about the PDF content.",
-)
-
-# Launch the Gradio app
-if __name__ == "__main__":
-    iface.launch()
+    with gr.Row():
+        with gr.Column():
+            pdf_input = gr.File(label="Upload your PDF File", type="binary")  # Corrected type to 'binary'
+            process_btn = gr.Button("Submit & Process")
+            output_status = gr.Textbox(label="Status", interactive=False)
+        
+        chat_box = gr.Textbox(label="Ask me anything about the content of the PDF:", placeholder="Type your question here...", lines=3)
+        submit_btn = gr.Button("Send")
+        response_box = gr.Markdown()
+
+    # Button actions
+    process_btn.click(fn=process_file, inputs=pdf_input, outputs=output_status)
+    submit_btn.click(fn=chat, inputs=chat_box, outputs=response_box)
+
+    # Styling
+    gr.Markdown(
+        """
+        <style>
+            .gradio-container {
+                background-color: #f9f9f9;
+                border-radius: 10px;
+                padding: 20px;
+                box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+            }
+            h1, h3, h4 {
+                font-family: Arial, sans-serif;
+                color: #333;
+            }
+            .gr-button {
+                background-color: #007bff;
+                color: white;
+                border-radius: 5px;
+                padding: 10px;
+                margin-top: 10px;
+            }
+            .gr-button:hover {
+                background-color: #0056b3;
+            }
+            .gr-textbox {
+                border: 1px solid #ccc;
+                border-radius: 5px;
+                padding: 10px;
+            }
+        </style>
+        """,
+        elem_id="custom-css"
+    )
+
+# Launch the app
+demo.launch()