update space

.idea/workspace.xml

@@ -5,10 +5,8 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="27c9ae1a-a6fa-4472-8bcd-a7087620894b" name="Changes" comment="update space">
-      <change afterPath="$PROJECT_DIR$/models/auth.h5" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/models/Final_Chicken_disease_model.h5" beforeDir="false" afterPath="$PROJECT_DIR$/models/diseases.h5" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/services/convert_model.py" beforeDir="false" afterPath="$PROJECT_DIR$/services/convert_model.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/services/convert_model.py" beforeDir="false" />
       <change beforePath="$PROJECT_DIR$/services/disease_detection_service.py" beforeDir="false" afterPath="$PROJECT_DIR$/services/disease_detection_service.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
@@ -131,14 +129,6 @@
       <workItem from="1730397485849" duration="22781000" />
       <workItem from="1730454506390" duration="12672000" />
     </task>
-    <task id="LOCAL-00076" summary="update space">
-      <option name="closed" value="true" />
-      <created>1730402280098</created>
-      <option name="number" value="00076" />
-      <option name="presentableId" value="LOCAL-00076" />
-      <option name="project" value="LOCAL" />
-      <updated>1730402280098</updated>
-    </task>
     <task id="LOCAL-00077" summary="update space">
       <option name="closed" value="true" />
       <created>1730402500058</created>
@@ -523,7 +513,15 @@
       <option name="project" value="LOCAL" />
       <updated>1730490013545</updated>
     </task>
-    <option name="localTasksCounter" value="125" />
+    <task id="LOCAL-00125" summary="update space">
+      <option name="closed" value="true" />
+      <created>1730491745530</created>
+      <option name="number" value="00125" />
+      <option name="presentableId" value="LOCAL-00125" />
+      <option name="project" value="LOCAL" />
+      <updated>1730491745530</updated>
+    </task>
+    <option name="localTasksCounter" value="126" />
     <servers />
   </component>
   <component name="TypeScriptGeneratedFilesManager">

services/convert_model.py

@@ -1,12 +0,0 @@
-# convert_model.py
-
-import tensorflow as tf
-
-MODEL_PATH = "models/diseases.h5"
-NEW_MODEL_PATH = "models/Final_Chicken_disease_model"
-
-# Load the .h5 model
-model = tf.keras.models.load_model(MODEL_PATH)
-
-# Save it in the SavedModel format
-model.save(NEW_MODEL_PATH)

services/disease_detection_service.py

@@ -4,6 +4,7 @@ import os
 import logging
 import threading
 import tensorflow as tf
+import torch
 import cv2
 import numpy as np
 from keras.models import load_model
@@ -19,6 +20,7 @@ logger = logging.getLogger(__name__)
 # Load Hugging Face API token for secure model access
 HF_TOKEN = os.environ.get('HF_Token')
 if HF_TOKEN:
+    # Login to Hugging Face using the token from environment variables
     login(token=HF_TOKEN, add_to_git_credential=True)
     logger.info("Hugging Face login successful.")
 else:
@@ -32,8 +34,12 @@ logger.info("Configuration loaded from config.ini.")
 # Configure TensorFlow for GPU and mixed precision if supported
 gpu_devices = tf.config.list_physical_devices('GPU')
 if gpu_devices:
+    logger.info(f"Number of GPUs found: {len(gpu_devices)}")
     for gpu in gpu_devices:
+        # Enable memory growth to prevent TensorFlow from allocating all GPU memory at once
         tf.config.experimental.set_memory_growth(gpu, True)
+        logger.info(f"Enabled memory growth for GPU: {gpu.name}")
+    # Enable mixed precision if GPU has sufficient compute capability
     if tf.config.experimental.get_device_details(gpu_devices[0]).get('compute_capability', (0, 0))[0] >= 7:
         from tensorflow.keras import mixed_precision
         policy = mixed_precision.Policy('mixed_float16')
@@ -42,36 +48,38 @@ if gpu_devices:
 else:
     logger.info("No GPU detected, using CPU without mixed precision.")
 
+# Check if GPU is available for PyTorch
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device for PyTorch: {device}")
+
 # Global model variables and threading event for synchronization
 disease_model, auth_model = None, None
 llama_model, llama_tokenizer = None, None
 model_loading_event = threading.Event()
 
-# Function to load the disease detection model
-def load_disease_model():
-    """Load the disease detection model."""
+# Utility function to load models
+def load_model_util(model_path, model_name):
+    """Load and compile a Keras model from the provided path."""
     try:
-        model_path = config.get('MODELS', 'DISEASE_MODEL_PATH', fallback="models/diseases.h5")
-        device = tf.config.list_logical_devices('GPU')[0] if gpu_devices else tf.config.list_logical_devices('CPU')[0]
-        with tf.device(device.name):
-            model = load_model(model_path, compile=True)
-        logger.info(f"Disease detection model loaded successfully on {device.name}.")
+        logger.info(f"Loading {model_name} from path: {model_path}")
+        model = load_model(model_path, compile=True)
+        logger.info(f"{model_name} loaded successfully.")
         return model
     except Exception as e:
-        logger.error("Error loading disease detection model", exc_info=True)
-        raise RuntimeError("Failed to load disease detection model") from e
+        logger.error(f"Error loading {model_name}", exc_info=True)
+        raise RuntimeError(f"Failed to load {model_name}") from e
+
+# Function to load the disease detection model
+def load_disease_model():
+    # Load the disease detection model from the configured path
+    model_path = config.get('MODELS', 'DISEASE_MODEL_PATH', fallback="models/diseases.h5")
+    return load_model_util(model_path, "Disease detection model")
 
 # Function to load the authentication model
 def load_auth_model():
-    """Load the authentication model to verify poultry images."""
-    try:
-        auth_model_path = config.get('MODELS', 'AUTH_MODEL_PATH', fallback="models/auth.h5")
-        auth_model = load_model(auth_model_path, compile=True)
-        logger.info("Authentication model loaded successfully.")
-        return auth_model
-    except Exception as e:
-        logger.error("Error loading authentication model", exc_info=True)
-        raise RuntimeError("Failed to load authentication model") from e
+    # Load the authentication model from the configured path
+    auth_model_path = config.get('MODELS', 'AUTH_MODEL_PATH', fallback="models/auth.h5")
+    return load_model_util(auth_model_path, "Authentication model")
 
 # Function to load the Llama 3.2 model for language generation
 def load_llama_model():
@@ -81,8 +89,11 @@ def load_llama_model():
         logger.info("Loading Llama 3.2 model and tokenizer using PyTorch-compatible model.")
         model_name = "meta-llama/Llama-3.2-1B"
 
+        # Load the tokenizer and model from Hugging Face
         llama_tokenizer = AutoTokenizer.from_pretrained(model_name)
-        llama_model = AutoModelForCausalLM.from_pretrained(model_name)
+        logger.info("Tokenizer loaded successfully.")
+        llama_model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
+        logger.info("Model loaded successfully.")
 
         # Add a padding token if it's missing
         if llama_tokenizer.pad_token is None:
@@ -91,11 +102,11 @@ def load_llama_model():
             llama_model.resize_token_embeddings(len(llama_tokenizer))
 
         logger.info("Llama model and tokenizer loaded successfully.")
-        model_loading_event.set()
+        model_loading_event.set()  # Signal that the model has been loaded
         return llama_model, llama_tokenizer
     except Exception as e:
         logger.error("Failed to load Llama model", exc_info=True)
-        model_loading_event.set()
+        model_loading_event.set()  # Signal that model loading failed
         raise RuntimeError("Failed to load the Llama 3.2 model. Verify compatibility.")
 
 # Disease mappings and recommended treatments
@@ -108,79 +119,133 @@ recommendations = {
     3: 'Administer antibiotics as prescribed by a veterinarian and ensure biosecurity.'
 }
 
-
 class PoultryFarmBot:
     def __init__(self, disease_model, auth_model):
         self.disease_model = disease_model
         self.auth_model = auth_model
-        logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
+        self.logger.info("PoultryFarmBot initialized with provided models.")
 
     def preprocess_image(self, image: np.ndarray) -> np.ndarray:
         """Preprocess the input image for model prediction."""
         try:
+            self.logger.info(f"Original image shape: {image.shape}")
+            # Resize the image to the required input size for the model
             image = cv2.resize(image, (224, 224))
-            return image / 255.0  # Normalize
+            self.logger.info(f"Image resized to: {image.shape}")
+            # Normalize pixel values to be between 0 and 1
+            image = image / 255.0
+            self.logger.info("Image normalized for model input.")
+            return image
         except Exception as e:
             self.logger.error("Error in image preprocessing", exc_info=True)
             raise ValueError("Invalid image format or empty image provided.")
 
     def generate_detailed_response(self, disease_name: str, status: str, recommendation: str) -> str:
         """Generate detailed response using Llama model based on prediction."""
+        # Create a prompt with detailed information about the disease
         prompt = (
             f"The detected disease is {disease_name}, classified as {status}. "
             f"Suggested action: {recommendation}. "
             f"Here is additional information on {disease_name}: causes, symptoms, and effective management."
         )
+        self.logger.info(f"Generated prompt for Llama model: {prompt}")
+        # Use the Llama model to generate a more detailed response
         response = self.llama_response(prompt)
+        self.logger.info("Generated detailed response from Llama model.")
+        # Remove the original prompt from the response and return only the generated text
         return response.replace(prompt, "").strip()
 
     def predict_disease(self, image: np.ndarray):
         """Predict disease from preprocessed image and provide detailed results."""
         try:
+            # Preprocess the image for prediction
+            self.logger.info("Starting image preprocessing for disease prediction.")
             preprocessed_image = self.preprocess_image(image)
 
             # Use auth_model to verify the image is poultry-related
+            self.logger.info("Verifying if the image is poultry-related.")
             is_poultry = self.auth_model.predict(preprocessed_image.reshape(1, 224, 224, 3)).argmax()
+            self.logger.info(f"Auth model prediction result: {is_poultry}")
             if is_poultry != 0:
                 self.logger.info("Image not recognized as poultry.")
-                return "Unknown Image", "N/A", "N/A", "Image not recognized as poultry.", None
-
-            # Predict disease if image is verified
+                return {
+                    "message": "Image not recognized as poultry.",
+                    "disease_name": "N/A",
+                    "status": "N/A",
+                    "recommendation": "N/A",
+                    "confidence": None
+                }
+
+            # Predict disease if image is verified as poultry
+            self.logger.info("Predicting disease from the image.")
             prediction = self.disease_model.predict(preprocessed_image.reshape(1, 224, 224, 3))
             predicted_class = prediction.argmax()
+            self.logger.info(f"Disease model prediction result: {predicted_class}")
             disease_name = name_disease.get(predicted_class, "Unknown disease")
             disease_status = status_map.get(predicted_class, "Unknown status")
             recommendation = recommendations.get(predicted_class, "No recommendation available")
-            confidence = prediction[0][predicted_class] * 100
+            confidence = float(prediction[0][predicted_class] * 100)
             self.logger.info(f"Disease Prediction: {disease_name} with {confidence:.2f}% confidence.")
 
             # Generate a detailed response using Llama model
             detailed_response = self.generate_detailed_response(disease_name, disease_status, recommendation)
-            return detailed_response, disease_name, disease_status, recommendation, confidence
+            self.logger.info("Generated detailed response for disease prediction.")
+            return {
+                "message": detailed_response,
+                "disease_name": disease_name,
+                "status": disease_status,
+                "recommendation": recommendation,
+                "confidence": confidence
+            }
         except Exception as e:
             self.logger.error("Error in disease prediction", exc_info=True)
-            return "Prediction failed.", None, None, None, None
+            return {
+                "message": "Prediction failed.",
+                "disease_name": None,
+                "status": None,
+                "recommendation": None,
+                "confidence": None
+            }
 
     def llama_response(self, prompt: str) -> str:
         """Generate a response from the Llama model based on a prompt."""
         try:
+            # Limit the maximum length of the generated response
             max_length = min(len(prompt) + 50, 512)
-            inputs = llama_tokenizer(prompt, return_tensors="tf", max_length=max_length, truncation=True, padding=True)
+            self.logger.info(f"Generating response with max length: {max_length}")
+            # Tokenize the input prompt
+            inputs = llama_tokenizer(prompt, return_tensors="pt", max_length=max_length, truncation=True, padding=True).to(device)
+            self.logger.info("Input prompt tokenized successfully.")
+            # Generate a response using the Llama model
             outputs = llama_model.generate(inputs["input_ids"], max_length=max_length, do_sample=True, temperature=0.7, top_p=0.9)
-            return llama_tokenizer.decode(outputs[0], skip_special_tokens=True)
+            self.logger.info("Response generated by Llama model.")
+            # Decode the generated response into a readable string
+            response = llama_tokenizer.decode(outputs[0], skip_special_tokens=True)
+            self.logger.info("Response decoded successfully.")
+            return response
         except Exception as e:
             logger.error("Error generating response from Llama model", exc_info=True)
             return "Error generating detailed response."
 
     def diagnose_and_respond(self, image: np.ndarray):
         """Diagnose disease and provide comprehensive response."""
+        # Check if the provided image is valid
+        self.logger.info("Starting diagnosis process.")
         if image is None or image.size == 0:
-            return "Provide a valid poultry fecal image.", None, None, None, None
+            self.logger.warning("Invalid image provided for diagnosis.")
+            return {
+                "message": "Provide a valid poultry fecal image.",
+                "disease_name": None,
+                "status": None,
+                "recommendation": None,
+                "confidence": None
+            }
+        # Predict disease from the provided image
         return self.predict_disease(image)
 
-
 # Load models upon service startup
+logger.info("Loading models for disease detection service.")
 disease_model = load_disease_model()
 auth_model = load_auth_model()
 llama_model, llama_tokenizer = load_llama_model()