File saved

app.py

@@ -1,3 +1,268 @@
+# from groq import Groq
+# import gradio as gr
+# from gtts import gTTS
+# import uuid
+# import base64
+# from io import BytesIO
+# import os
+# import logging
+# import spacy
+# from transformers import pipeline
+
+# # Set up logger
+# logger = logging.getLogger(__name__)
+# logger.setLevel(logging.DEBUG)
+# console_handler = logging.StreamHandler()
+# file_handler = logging.FileHandler('chatbot_log.log')
+# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+# console_handler.setFormatter(formatter)
+# file_handler.setFormatter(formatter)
+# logger.addHandler(console_handler)
+# logger.addHandler(file_handler)
+
+# # Initialize Groq Client
+# #client = Groq(api_key=os.getenv("GROQ_API_KEY_2"))
+
+# client = Groq(
+#     api_key="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",
+#  )
+
+# # Initialize spaCy NLP model for named entity recognition (NER)
+# nlp = spacy.load("en_core_web_sm")  
+
+# # Initialize sentiment analysis model using Hugging Face
+# sentiment_analyzer = pipeline("sentiment-analysis")
+
+# # Function to preprocess user input for better NLP understanding
+# def preprocess_input(user_input):
+#     # Clean up text (remove unnecessary characters, standardize)
+#     user_input = user_input.strip().lower()
+#     return user_input
+
+# # Function for sentiment analysis (optional)
+# def analyze_sentiment(user_input):
+#     result = sentiment_analyzer(user_input)
+#     return result[0]['label']  # Positive, Negative, or Neutral
+
+# # Function to extract medical entities from input using NER
+
+# symptoms = [
+#     "fever", "cough", "headache", "nausea", "pain", "fatigue", "dizziness",
+#     "shortness of breath", "sore throat", "runny nose", "congestion", "diarrhea",
+#     "vomiting", "chills", "sweating", "loss of appetite", "insomnia", 
+#     "itching", "rash", "swelling", "bleeding", "burning sensation",
+#     "weakness", "tingling", "numbness", "muscle cramps", "joint pain",
+#     "blurred vision", "double vision", "dry eyes", "sensitivity to light",
+#     "difficulty breathing", "palpitations", "chest pain", "back pain",
+#     "stomach ache", "abdominal pain", "weight loss", "weight gain",
+#     "frequent urination", "difficulty urinating", "anxiety", "depression",
+#     "irritability", "confusion", "memory loss", "bruising"
+# ]
+# diseases = [
+#     "diabetes", "cancer", "asthma", "flu", "pneumonia", "hypertension",
+#     "arthritis", "bronchitis", "migraine", "stroke", "heart attack",
+#     "coronary artery disease", "tuberculosis", "malaria", "dengue",
+#     "hepatitis", "anemia", "thyroid disease", "eczema", "psoriasis",
+#     "osteoporosis", "parkinson's", "alzheimer's", "depression",
+#     "anxiety disorder", "schizophrenia", "epilepsy", "bipolar disorder",
+#     "chronic kidney disease", "liver cirrhosis", "HIV", "AIDS",
+#     "covid-19", "cholera", "smallpox", "measles", "mumps", 
+#     "rubella", "whooping cough", "obesity", "GERD", "IBS", 
+#     "celiac disease", "ulcerative colitis", "Crohn's disease", 
+#     "sleep apnea", "hypothyroidism", "hyperthyroidism"
+# ]
+
+
+# # Function to extract medical entities
+# def extract_medical_entities(user_input):
+#     user_input = preprocess_input(user_input)
+#     medical_entities = []
+#     for word in user_input.split():
+#         if word in symptoms or word in diseases:
+#             medical_entities.append(word)
+#     return medical_entities
+# # def extract_medical_entities(user_input):
+# #     doc = nlp(user_input)
+# #     medical_entities = [ent.text for ent in doc.ents if ent.label_ == "SYMPTOM" or ent.label_ == "DISEASE"]
+# #     print(medical_entities)
+# #     print("This is doc",doc)
+# #     return medical_entities
+
+# # Function to encode the image
+# def encode_image(uploaded_image):
+#     try:
+#         logger.debug("Encoding image...")
+#         buffered = BytesIO()
+#         uploaded_image.save(buffered, format="PNG")
+#         logger.debug("Image encoding complete.")
+#         return base64.b64encode(buffered.getvalue()).decode("utf-8")
+#     except Exception as e:
+#         logger.error(f"Error encoding image: {e}")
+#         raise
+
+# # Initialize messages
+# def initialize_messages():
+#      return [{"role": "system",
+#              "content": '''You are Dr. HealthBuddy, a professional, empathetic,
+#               and knowledgeable virtual doctor chatbot. Your purpose is to provide health information,
+#               symptom guidance, and lifestyle tips using the uploaded dataset as a reference for common
+#                symptoms and associated conditions.
+
+#  Utilize the dataset to provide information about symptoms and possible conditions for educational purposes.
+#  If a symptom matches data in the dataset, offer users relevant insights, and suggest general management strategies.
+#  Clearly communicate that you are not a substitute for professional medical advice.
+#  Encourage users to consult a licensed healthcare provider for any severe or persistent health issues.
+#  Maintain a friendly and understanding tone in all responses.
+#  Examples:
+
+#  User: "I have skin rash and itching. What could it be?"
+#  Response: "According to the data, skin rash and itching are common symptoms of conditions like fungal infections.
+#  You can try keeping the affected area dry and clean, and using over-the-counter antifungal creams.
+# If the rash persists or worsens, please consult a dermatologist."
+
+#  User: "What might cause nodal skin eruptions?"
+#  Response: "Nodal skin eruptions could be linked to conditions such as fungal infections.
+# It's best to monitor the symptoms and avoid scratching.
+#  For a proper diagnosis, consider visiting a healthcare provider.'''}]
+
+
+# messages = initialize_messages()
+
+# def customLLMBot(user_input, uploaded_image, chat_history):
+#     try:
+#         global messages
+#         logger.info("Processing input...")
+
+#         # Preprocess the user input
+#         user_input = preprocess_input(user_input)
+        
+#         # Analyze sentiment (Optional)
+#         sentiment = analyze_sentiment(user_input)
+#         logger.info(f"Sentiment detected: {sentiment}")
+
+#         # Extract medical entities (Optional)
+#         medical_entities = extract_medical_entities(user_input)
+#         logger.info(f"Extracted medical entities: {medical_entities}")
+
+#         # Append user input to the chat history
+#         chat_history.append(("user", user_input))
+
+#         if uploaded_image is not None:
+#             # Encode the image to base64
+#             base64_image = encode_image(uploaded_image)
+
+#             logger.debug(f"Image received, size: {len(base64_image)} bytes")
+
+#             # Create a message for the image prompt
+#             messages_image = [
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {"type": "text", "text": "What's in this image?"},
+#                         {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
+#                     ]
+#                 }
+#             ]
+
+#             logger.info("Sending image to Groq API for processing...")
+#             response = client.chat.completions.create(
+#                 model="llama-3.2-11b-vision-preview",
+#                 messages=messages_image,
+#             )
+#             logger.info("Image processed successfully.")
+#         else:
+#             # Process text input
+#             logger.info("Processing text input...")
+#             messages.append({
+#                 "role": "user",
+#                 "content": user_input
+#             })
+#             response = client.chat.completions.create(
+#                 model="llama-3.2-11b-vision-preview",
+#                 messages=messages,
+#             )
+#             logger.info("Text processed successfully.")
+
+#         # Extract the reply
+#         LLM_reply = response.choices[0].message.content
+#         logger.debug(f"LLM reply: {LLM_reply}")
+
+#         # Append the bot's response to the chat history
+#         chat_history.append(("bot", LLM_reply))
+#         messages.append({"role": "assistant", "content": LLM_reply})
+
+#         # Generate audio for response
+#         audio_file = f"response_{uuid.uuid4().hex}.mp3"
+#         tts = gTTS(LLM_reply, lang='en')
+#         tts.save(audio_file)
+#         logger.info(f"Audio response saved as {audio_file}")
+
+#         # Return chat history and audio file
+#         return chat_history, audio_file
+
+#     except Exception as e:
+#         logger.error(f"Error in customLLMBot function: {e}")
+#         return [("user", user_input or "Image uploaded"), ("bot", f"An error occurred: {e}")], None
+
+# # Gradio Interface
+# def chatbot_ui():
+#     with gr.Blocks() as demo:
+#         gr.Markdown("# Healthcare Chatbot Doctor")
+
+#         # State for user chat history
+#         chat_history = gr.State([])
+
+#         # Layout for chatbot and input box alignment
+#         with gr.Row():
+#             with gr.Column(scale=3):  # Main column for chatbot
+#                 chatbot = gr.Chatbot(label="Responses", elem_id="chatbot")
+#                 user_input = gr.Textbox(
+#                     label="Ask a health-related question",
+#                     placeholder="Describe your symptoms...",
+#                     elem_id="user-input",
+#                     lines=1,
+#                 )
+#             with gr.Column(scale=1):  # Side column for image and buttons
+#                 uploaded_image = gr.Image(label="Upload an Image", type="pil")
+#                 submit_btn = gr.Button("Submit")
+#                 clear_btn = gr.Button("Clear")
+#                 audio_output = gr.Audio(label="Audio Response")
+
+#         # Define actions
+#         def handle_submit(user_query, image, history):
+#             logger.info("User submitted a query.")
+#             response, audio = customLLMBot(user_query, image, history)
+#             return response, audio, None, "", history  # Clear the image after submission
+
+#         # Submit on pressing Enter key
+#         user_input.submit(
+#             handle_submit,
+#             inputs=[user_input, uploaded_image, chat_history],
+#             outputs=[chatbot, audio_output, uploaded_image, user_input, chat_history],
+#         )
+
+#         # Submit on button click
+#         submit_btn.click(
+#             handle_submit,
+#             inputs=[user_input, uploaded_image, chat_history],
+#             outputs=[chatbot, audio_output, uploaded_image, user_input, chat_history],
+#         )
+
+#         # Action for clearing all fields
+#         clear_btn.click(
+#             lambda: ([], "", None, []),
+#             inputs=[],
+#             outputs=[chatbot, user_input, uploaded_image, chat_history],
+#         )
+
+#     return demo
+
+# # Launch the interface
+# #chatbot_ui().launch(server_name="0.0.0.0", server_port=7860)
+
+# chatbot_ui().launch(server_name="localhost", server_port=7860)
+
+
 from groq import Groq
 import gradio as gr
 from gtts import gTTS
@@ -6,6 +271,18 @@ import base64
 from io import BytesIO
 import os
 import logging
+import spacy
+from transformers import pipeline
+import torch
+from PIL import Image
+from torchvision import transforms
+import pathlib
+import cv2  # Import OpenCV
+import numpy as np
+
+# Pathlib adjustment for Windows compatibility
+temp = pathlib.PosixPath
+pathlib.PosixPath = pathlib.WindowsPath
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -18,57 +295,175 @@ file_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 logger.addHandler(file_handler)
 
-# Initialize Groq Client
+#Initialize Groq Client
 client = Groq(api_key=os.getenv("GROQ_API_KEY_2"))
 
-# client = Groq(
-#     api_key="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",
-#  )
+# # Initialize Groq Client
+# client = Groq(api_key="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")
+
+# Initialize spaCy NLP model for named entity recognition (NER)
+nlp = spacy.load("en_core_web_sm")
+
+# Initialize sentiment analysis model using Hugging Face
+sentiment_analyzer = pipeline("sentiment-analysis")
+
+# Load pre-trained YOLOv5 model
+def load_yolov5_model():
+    model = torch.hub.load(
+        r'C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\yolov5',
+        'custom',
+        path=r"C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\models\best.pt",
+        source="local"
+    )
+    model.eval()
+    return model
+
+model = load_yolov5_model()
+
+# Function to preprocess user input for better NLP understanding
+def preprocess_input(user_input):
+    user_input = user_input.strip().lower()
+    return user_input
+
+# Function for sentiment analysis (optional)
+def analyze_sentiment(user_input):
+    result = sentiment_analyzer(user_input)
+    return result[0]['label']
+
+# Function to extract medical entities from input using NER
+symptoms = [
+    "fever", "cough", "headache", "nausea", "pain", "fatigue", "dizziness",
+    "shortness of breath", "sore throat", "runny nose", "congestion", "diarrhea",
+    "vomiting", "chills", "sweating", "loss of appetite", "insomnia", 
+    "itching", "rash", "swelling", "bleeding", "burning sensation",
+    "weakness", "tingling", "numbness", "muscle cramps", "joint pain",
+    "blurred vision", "double vision", "dry eyes", "sensitivity to light",
+    "difficulty breathing", "palpitations", "chest pain", "back pain",
+    "stomach ache", "abdominal pain", "weight loss", "weight gain",
+    "frequent urination", "difficulty urinating", "anxiety", "depression",
+    "irritability", "confusion", "memory loss", "bruising"
+]
+diseases = [
+    "diabetes", "cancer", "asthma", "flu", "pneumonia", "hypertension",
+    "arthritis", "bronchitis", "migraine", "stroke", "heart attack",
+    "coronary artery disease", "tuberculosis", "malaria", "dengue",
+    "hepatitis", "anemia", "thyroid disease", "eczema", "psoriasis",
+    "osteoporosis", "parkinson's", "alzheimer's", "depression",
+    "anxiety disorder", "schizophrenia", "epilepsy", "bipolar disorder",
+    "chronic kidney disease", "liver cirrhosis", "HIV", "AIDS",
+    "covid-19", "cholera", "smallpox", "measles", "mumps", 
+    "rubella", "whooping cough", "obesity", "GERD", "IBS", 
+    "celiac disease", "ulcerative colitis", "Crohn's disease", 
+    "sleep apnea", "hypothyroidism", "hyperthyroidism"
+]
+
+def extract_medical_entities(user_input):
+    user_input = preprocess_input(user_input)
+    medical_entities = []
+    for word in user_input.split():
+        if word in symptoms or word in diseases:
+            medical_entities.append(word)
+    return medical_entities
 
 # Function to encode the image
 def encode_image(uploaded_image):
     try:
         logger.debug("Encoding image...")
         buffered = BytesIO()
-        uploaded_image.save(buffered, format="PNG")  # Ensure the correct format
+        uploaded_image.save(buffered, format="PNG")
         logger.debug("Image encoding complete.")
         return base64.b64encode(buffered.getvalue()).decode("utf-8")
     except Exception as e:
         logger.error(f"Error encoding image: {e}")
         raise
-def initialize_messages():
-    return [{"role": "system",
-             "content": '''You are Dr. HealthBuddy, a highly experienced and professional virtual doctor chatbot with over 40 years of expertise across all medical fields. You provide health-related information, symptom guidance, lifestyle tips, and actionable solutions using a dataset to reference common symptoms and conditions. Your goal is to offer concise, empathetic, and knowledgeable responses tailored to each patient’s needs.
-
-You only respond to health-related inquiries and strive to provide the best possible guidance. Your responses should include clear explanations, actionable steps, and when necessary, advise patients to seek in-person care from a healthcare provider for a proper diagnosis or treatment. Maintain a friendly, professional, and empathetic tone in all your interactions.
-
-Prompt Template:
-- Input: Patient’s health concerns, including symptoms, questions, or specific issues they mention.
-- Response: Start with a polite acknowledgment of the patient’s concern. Provide a clear, concise explanation and suggest practical, actionable steps based on the dataset. If needed, advise on when to consult a healthcare provider.
-
-Examples:
 
-- User: "I have skin rash and itching. What could it be?"
-  Response: "According to the data, skin rash and itching are common symptoms of conditions like fungal infections. You can try keeping the affected area dry and clean, and using over-the-counter antifungal creams. If the rash persists or worsens, please consult a dermatologist."
+# Initialize messages
+def initialize_messages():
+    return [{"role": "system", "content": '''You are Dr. HealthBuddy, a professional, empathetic, and knowledgeable virtual doctor chatbot.'''}]
 
-- User: "What might cause nodal skin eruptions?"
-  Response: "Nodal skin eruptions could be linked to conditions such as fungal infections. It's best to monitor the symptoms and avoid scratching. For a proper diagnosis, consider visiting a healthcare provider."
+messages = initialize_messages()
 
-- User: "I am a 22-year-old female diagnosed with hypothyroidism. I've gained 10 kg recently. What should I do?"
-  Response: "Hi. You have done well managing your hypothyroidism. For effective weight loss, focus on a balanced diet rich in vegetables, lean proteins, and whole grains. Pair this with regular exercise like brisk walking or yoga. Also, consult your endocrinologist to ensure your thyroid levels are well-controlled. Let me know if you have more questions."
+# Function for image prediction using YOLOv5
+def predict_image(image):
+    try:
+        # Debug: Check if the image is None
+        if image is None:
+            return "Error: No image uploaded.", "No description available."
+
+        # Convert PIL image to NumPy array (OpenCV format)
+        image_np = np.array(image)  # Convert PIL image to NumPy array
+
+        # Convert RGB to BGR (OpenCV uses BGR by default)
+        image_np = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+
+        # Resize the image to match the model's expected input size
+        image_resized = cv2.resize(image_np, (224, 224))
+
+        # Transform the image for the model
+        transform = transforms.Compose([
+            transforms.ToTensor(),  # Convert image to tensor
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # Normalize
+        ])
+        im = transform(image_resized).unsqueeze(0)  # Add batch dimension (BCHW)
+
+        # Get predictions
+        with torch.no_grad():
+            output = model(im)  # Raw model output (logits)
+
+        # Apply softmax to get confidence scores
+        softmax = torch.nn.Softmax(dim=1)
+        probs = softmax(output)
+
+        # Get the predicted class and its confidence score
+        predicted_class_id = torch.argmax(probs, dim=1).item()
+        confidence_score = probs[0, predicted_class_id].item()
+
+        # Get predicted class name if available
+        if hasattr(model, 'names'):
+            class_name = model.names[predicted_class_id]
+            prediction_result = f"Predicted Class: {class_name}\nConfidence: {confidence_score:.4f}"
+            description = get_description(class_name)  # Function to get description
+        else:
+            prediction_result = f"Predicted Class ID: {predicted_class_id}\nConfidence: {confidence_score:.4f}"
+            description = "No description available."
 
-- User: "I’ve been feeling discomfort between my shoulder blades after sitting for long periods. What could this be?"
-  Response: "Hello. The discomfort between your shoulder blades could be related to posture or strain. Try adjusting your sitting position and consider ergonomic changes to your workspace. Over-the-counter pain relievers or hot compresses may help. If the pain persists, consult an orthopedic specialist for further evaluation."
+        # Display the image with OpenCV (optional)
+        cv2.imshow("Processed Image", image_resized)
+        cv2.waitKey(1)  # Wait for 1 ms to display the image
 
-Always ensure the tone remains compassionate, and offer educational insights while stressing that you are not a substitute for professional medical advice. Encourage users to consult a healthcare provider for any serious or persistent health concerns.'''
-    }]
-messages=initialize_messages()
+        return prediction_result, description
 
+    except Exception as e:
+        logger.error(f"Error in image prediction: {e}")
+        return f"An error occurred during image prediction: {e}", "No description available."
+
+# Function to get description based on predicted class
+def get_description(class_name):
+    descriptions = {
+        "bcc": "Basal cell carcinoma (BCC) is a type of skin cancer that begins in the basal cells. It often appears as a slightly transparent bump on the skin, though it can take other forms. BCC grows slowly and is unlikely to spread to other parts of the body, but early treatment is important to prevent damage to surrounding tissues.",
+        "atopic": "Atopic dermatitis is a chronic skin condition characterized by itchy, inflamed skin. It is common in individuals with a family history of allergies or asthma.",
+        "acne": "Acne is a skin condition that occurs when hair follicles become clogged with oil and dead skin cells. It often causes pimples, blackheads, and whiteheads, and is most common among teenagers.",
+        # Add more descriptions as needed
+    }
+    return descriptions.get(class_name.lower(), "No description available.")
+
+# Custom LLM Bot Function
 def customLLMBot(user_input, uploaded_image, chat_history):
     try:
         global messages
         logger.info("Processing input...")
 
+        # Preprocess the user input
+        user_input = preprocess_input(user_input)
+        
+        # Analyze sentiment (Optional)
+        sentiment = analyze_sentiment(user_input)
+        logger.info(f"Sentiment detected: {sentiment}")
+
+        # Extract medical entities (Optional)
+        medical_entities = extract_medical_entities(user_input)
+        logger.info(f"Extracted medical entities: {medical_entities}")
+
         # Append user input to the chat history
         chat_history.append(("user", user_input))
 
@@ -76,12 +471,10 @@ def customLLMBot(user_input, uploaded_image, chat_history):
             # Encode the image to base64
             base64_image = encode_image(uploaded_image)
 
-            # Log the image size and type
             logger.debug(f"Image received, size: {len(base64_image)} bytes")
 
             # Create a message for the image prompt
-            # Create a message specifically for image prompts
-            messages_image=[
+            messages_image = [
                 {
                     "role": "user",
                     "content": [
@@ -116,7 +509,7 @@ def customLLMBot(user_input, uploaded_image, chat_history):
 
         # Append the bot's response to the chat history
         chat_history.append(("bot", LLM_reply))
-        messages.append({"role":"assistant","content":LLM_reply})
+        messages.append({"role": "assistant", "content": LLM_reply})
 
         # Generate audio for response
         audio_file = f"response_{uuid.uuid4().hex}.mp3"
@@ -128,10 +521,8 @@ def customLLMBot(user_input, uploaded_image, chat_history):
         return chat_history, audio_file
 
     except Exception as e:
-        # Handle errors gracefully
         logger.error(f"Error in customLLMBot function: {e}")
-        return [(("user", user_input or "Image uploaded"), ("bot", f"An error occurred: {e}"))], None
-
+        return [("user", user_input or "Image uploaded"), ("bot", f"An error occurred: {e}")], None
 
 # Gradio Interface
 def chatbot_ui():
@@ -157,24 +548,48 @@ def chatbot_ui():
                 clear_btn = gr.Button("Clear")
                 audio_output = gr.Audio(label="Audio Response")
 
+        # New section for image prediction (left and right layout)
+        with gr.Row():
+            # Left side: Upload image
+            with gr.Column():
+                gr.Markdown("### Upload Image for Prediction")
+                prediction_image = gr.Image(label="Upload Image", type="pil")
+                predict_btn = gr.Button("Predict")
+
+            # Right side: Prediction result and description
+            with gr.Column():
+                gr.Markdown("### Prediction Result")
+                prediction_output = gr.Textbox(label="Result", interactive=False)
+
+                # Description column
+                gr.Markdown("### Description")
+                description_output = gr.Textbox(label="Description", interactive=False)
+
+                # Clear button for prediction result (below description box)
+                clear_prediction_btn = gr.Button("Clear Prediction")
+
         # Define actions
         def handle_submit(user_query, image, history):
             logger.info("User submitted a query.")
             response, audio = customLLMBot(user_query, image, history)
-            return response, audio, None,"",history  # Clear the image after submission
+            return response, audio, None, "", history
+
+        # Clear prediction result and image
+        def clear_prediction(prediction_image, prediction_output, description_output):
+            return None, "", ""
 
         # Submit on pressing Enter key
         user_input.submit(
             handle_submit,
             inputs=[user_input, uploaded_image, chat_history],
-            outputs=[chatbot, audio_output, uploaded_image,user_input, chat_history],
+            outputs=[chatbot, audio_output, uploaded_image, user_input, chat_history],
         )
 
         # Submit on button click
         submit_btn.click(
             handle_submit,
             inputs=[user_input, uploaded_image, chat_history],
-            outputs=[chatbot, audio_output, uploaded_image,user_input, chat_history],
+            outputs=[chatbot, audio_output, uploaded_image, user_input, chat_history],
         )
 
         # Action for clearing all fields
@@ -184,9 +599,24 @@ def chatbot_ui():
             outputs=[chatbot, user_input, uploaded_image, chat_history],
         )
 
+        # Action for image prediction
+        predict_btn.click(
+            predict_image,
+            inputs=[prediction_image],
+            outputs=[prediction_output, description_output],  # Update both outputs
+        )
+
+        # Action for clearing prediction result and image
+        clear_prediction_btn.click(
+            clear_prediction,
+            inputs=[prediction_image, prediction_output, description_output],
+            outputs=[prediction_image, prediction_output, description_output],
+        )
+
     return demo
 
 # Launch the interface
-chatbot_ui().launch(server_name="0.0.0.0", server_port=7860)
+# chatbot_ui().launch(server_name="localhost", server_port=7860)
 
-#chatbot_ui().launch(server_name="localhost", server_port=7860)
+# Launch the interface
+chatbot_ui().launch(server_name="0.0.0.0", server_port=7860)

pred.py

@@ -0,0 +1,108 @@
+
+import torch
+from PIL import Image
+from torchvision import transforms
+import pathlib   
+temp = pathlib.PosixPath   
+pathlib.PosixPath = pathlib.WindowsPath
+
+
+model = torch.hub.load(r'C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\yolov5', 'custom', path=r"C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\models\best.pt", source="local")
+
+
+img_path = r"C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\ACNE.jpg"
+image = Image.open(img_path)
+
+
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),  # Resize to model's expected input size
+    transforms.ToTensor(),         # Convert image to tensor
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # Normalize
+])
+im = transform(image).unsqueeze(0)  # Add batch dimension (BCHW)
+
+
+output = model(im)
+
+
+# Get predictions
+with torch.no_grad():
+    output = model(im)  # Raw model output (logits)
+
+# Apply softmax to get confidence scores
+softmax = torch.nn.Softmax(dim=1)
+probs = softmax(output)
+
+# Get the predicted class and its confidence score
+predicted_class_id = torch.argmax(probs, dim=1).item()
+confidence_score = probs[0, predicted_class_id].item()
+
+# Print predicted class and confidence score
+print(f"Predicted Class ID: {predicted_class_id}")
+print(f"Confidence Score: {confidence_score:.4f}")
+
+# Print predicted class name if available
+if hasattr(model, 'names'):
+    class_name = model.names[predicted_class_id]
+    print(f"Predicted Class Name: {class_name}")
+
+# import torch
+# import cv2  # Import OpenCV
+# from torchvision import transforms
+# import pathlib
+
+# # Pathlib adjustment for Windows compatibility
+# temp = pathlib.PosixPath
+# pathlib.PosixPath = pathlib.WindowsPath
+
+# # Load pre-trained YOLOv5 model
+# model = torch.hub.load(
+#     r'C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\yolov5',
+#     'custom',
+#     path=r"C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\models\best.pt",
+#     source="local"
+# )
+
+# # Set model to evaluation mode
+# model.eval()
+
+# # Define image transformations (for PyTorch)
+# transform = transforms.Compose([
+#     transforms.ToTensor(),  # Convert image to tensor
+#     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # Normalize
+# ])
+
+# # Load and preprocess the image using OpenCV
+# img_path = r"C:\Users\RESHMA R B\OneDrive\Documents\Desktop\project_without_malayalam\chatbot2\ACNE.jpg"
+# image = cv2.imread(img_path)  # Load image in BGR format
+# image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB
+# image_resized = cv2.resize(image, (224, 224))  # Resize to match model's expected input size
+
+# # Transform the image for the model
+# im = transform(image_resized).unsqueeze(0)  # Add batch dimension (BCHW)
+
+# # Get predictions
+# with torch.no_grad():
+#     output = model(im)  # Raw model output (logits)
+
+# # Apply softmax to get confidence scores
+# softmax = torch.nn.Softmax(dim=1)
+# probs = softmax(output)
+
+# # Get the predicted class and its confidence score
+# predicted_class_id = torch.argmax(probs, dim=1).item()
+# confidence_score = probs[0, predicted_class_id].item()
+
+# # Print predicted class and confidence score
+# print(f"Predicted Class ID: {predicted_class_id}")
+# print(f"Confidence Score: {confidence_score:.4f}")
+
+# # Print predicted class name if available
+# if hasattr(model, 'names'):
+#     class_name = model.names[predicted_class_id]
+#     print(f"Predicted Class Name: {class_name}")
+
+
+# cv2.imshow("Input Image", image)  
+# cv2.waitKey(0)  
+# cv2.destroyAllWindows()  

requirements.txt

@@ -1,8 +1,29 @@
-gtts
-gradio
-groq
-loguru
-# torch
-# transformers
-# torchvision
-# pillow
+# Core Libraries
+numpy==1.24.3
+pandas==2.0.2
+scipy==1.10.1
+
+# Machine Learning & Deep Learning
+torch==2.0.1
+torchvision==0.15.2
+transformers==4.30.2
+scikit-learn==1.2.2
+ultralytics==8.0.124
+
+# Image Processing
+pillow==9.5.0
+opencv-python==4.7.0.72
+
+# NLP
+spacy==3.5.3
+
+# Visualization
+matplotlib==3.7.1
+
+# Gradio & Audio
+gradio==3.32.0
+gtts==2.3.2
+
+# API Integration
+groq==0.1.0
+requests==2.28.2