update space

.env

@@ -13,3 +13,8 @@ FROM_EMAIL="your_from_email_address"
 # TensorFlow Settings
 TF_ENABLE_ONEDNN_OPTS=0
 TF_FORCE_GPU_ALLOW_GROWTH=true
+
+
+# MODELS
+DISEASE_MODEL_PATH=models/Final_Chicken_disease_model.h5
+LLAMA_MODEL_NAME=meta-llama/Llama-3.2-1B

app.py

@@ -19,12 +19,6 @@ from huggingface_hub import login
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Load Hugging Face Token
-HF_TOKEN = os.environ.get('HF_Token')
-if HF_TOKEN:
-    login(token=HF_TOKEN, add_to_git_credential=True)
-else:
-    logger.warning("Hugging Face token not found in environment variables.")
 
 # Check GPU availability for TensorFlow
 gpu_devices = tf.config.list_physical_devices('GPU')
@@ -46,9 +40,7 @@ else:
     logger.error("Static directory not found.")
     raise HTTPException(status_code=500, detail="Static directory not found.")
 
-# Load models at startup
-disease_model = load_disease_model()
-llama_model, llama_tokenizer = load_llama_model()
+
 
 # Include routers for authentication, disease detection, and health dashboard
 app.include_router(auth_router, prefix="/auth", tags=["Authentication"])

services/disease_detection_service.py

@@ -9,25 +9,44 @@ import numpy as np
 from huggingface_hub import login
 from pymongo import MongoClient
 from transformers import TFAutoModelForCausalLM, AutoTokenizer
+import configparser
 
 # Logging setup
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Load Hugging Face Token
+HF_TOKEN = os.environ.get('HF_Token')
+if HF_TOKEN:
+    login(token=HF_TOKEN, add_to_git_credential=True)
+else:
+    logger.warning("Hugging Face token not found in environment variables.")
+
+
 # Load environment variables
 MONGO_URI = os.getenv("MONGO_URI")
 db_client = MongoClient(MONGO_URI)
 db = db_client.poultry_farm  # MongoDB for record-keeping
 
+# Load configuration file
+config = configparser.ConfigParser()
+config.read('config.ini')
+
 # Mixed precision and GPU configuration
 gpu_devices = tf.config.list_physical_devices('GPU')
 if gpu_devices:
     for gpu in gpu_devices:
-        tf.config.experimental.set_memory_growth(gpu, True)
+        # Enable memory growth for each GPU to avoid allocating all memory at once
+        tf.config.set_memory_growth(gpu, True)
     from tensorflow.keras import mixed_precision
-    policy = mixed_precision.Policy('mixed_float16')
-    mixed_precision.set_global_policy(policy)
-    logger.info("Using mixed precision with GPU.")
+    # Check if GPU supports mixed precision (compute capability >= 7)
+    gpu_details = tf.config.experimental.get_device_details(gpu_devices[0])
+    if gpu_details.get('compute_capability', (0, 0))[0] >= 7:
+        policy = mixed_precision.Policy('mixed_float16')
+        mixed_precision.set_global_policy(policy)
+        logger.info("Using mixed precision with GPU.")
+    else:
+        logger.info("GPU detected but does not support mixed precision.")
 else:
     logger.info("Using CPU without mixed precision.")
 
@@ -35,23 +54,29 @@ else:
 def load_disease_model():
     """Load the disease detection model."""
     try:
-        model_path = "models/Final_Chicken_disease_model.h5"
+        # Load the model path from the configuration file or use the default path
+        model_path = config.get('MODELS', 'DISEASE_MODEL_PATH', fallback="models/Final_Chicken_disease_model.h5")
+        # Use GPU if available, otherwise use CPU
         device = '/GPU:0' if gpu_devices else '/CPU:0'
         with tf.device(device):
             model = load_model(model_path, compile=True)
         logger.info(f"Disease detection model loaded successfully on {device}.")
         return model
     except Exception as e:
-        logger.error(f"Error loading disease model: {e}")
-        raise RuntimeError("Failed to load disease detection model")
+        # Log the error and raise an exception to indicate failure
+        logger.error(f"Error loading disease model: {e}", exc_info=True)
+        raise RuntimeError("Failed to load disease detection model") from e
 
 def load_llama_model():
     """Load the Llama 3.2 model for text generation using TensorFlow."""
     try:
-        model_name = "meta-llama/Llama-3.2-1B"
+        # Load the model name from environment variable or use the default model
+        model_name = os.getenv("LLAMA_MODEL_NAME", "meta-llama/Llama-3.2-1B")
+        # Load the tokenizer and model from the Hugging Face hub
         tokenizer = AutoTokenizer.from_pretrained(model_name)
         model = TFAutoModelForCausalLM.from_pretrained(model_name)
 
+        # Add padding token if not already present
         if tokenizer.pad_token is None:
             tokenizer.add_special_tokens({'pad_token': '[PAD]'})
             model.resize_token_embeddings(len(tokenizer))
@@ -59,11 +84,16 @@ def load_llama_model():
         logger.info("Llama 3.2 model loaded successfully with TensorFlow.")
         return model, tokenizer
     except Exception as e:
-        logger.error(f"Error loading Llama model: {e}")
-        raise RuntimeError("Failed to load Llama model")
+        # Log the error and raise an exception to indicate failure
+        logger.error(f"Error loading Llama model: {e}", exc_info=True)
+        raise RuntimeError("Failed to load Llama model") from e
 
+# Load models at startup
+disease_model = load_disease_model()
+llama_model, llama_tokenizer = load_llama_model()
 
 # Disease mapping and treatment guidelines
+# Maps predicted class indices to disease names, status, and treatment recommendations
 name_disease = {0: 'Coccidiosis', 1: 'Healthy', 2: 'New Castle Disease', 3: 'Salmonella'}
 status_map = {0: 'Critical', 1: 'No issue', 2: 'Critical', 3: 'Critical'}
 recommendations = {
@@ -75,66 +105,85 @@ recommendations = {
 
 class PoultryFarmBot:
     def __init__(self, db):
+        # Initialize the bot with a reference to the MongoDB database
         self.db = db
 
-    def preprocess_image(self, image):
+    def preprocess_image(self, image: np.ndarray) -> np.ndarray:
         """Preprocess image for model input."""
         try:
+            # Check if the image is valid
+            if image is None or image.size == 0:
+                raise ValueError("Empty or invalid image provided.")
+            # Resize the image to the input size required by the model (224x224)
             image = cv2.resize(image, (224, 224))
-            image = np.expand_dims(image, axis=0) / 255.0  # Normalize and add batch dimension
+            # Normalize the image (scaling pixel values to range [0, 1]) and add a batch dimension
+            image = np.expand_dims(image, axis=0) / 255.0
             logger.info("Image preprocessed successfully.")
             return image
         except Exception as e:
-            logger.error(f"Error in image preprocessing: {e}")
-            return None
+            # Log the error and raise an exception to indicate failure
+            logger.error(f"Error in image preprocessing: {e}", exc_info=True)
+            raise
 
-    def predict_disease(self, image):
+    def predict_disease(self, image: np.ndarray):
         """Predict the disease from a preprocessed image and return detailed information."""
-        preprocessed_image = self.preprocess_image(image)
-        if preprocessed_image is None:
-            return "Image preprocessing failed.", None, None, None
-
         try:
+            # Preprocess the input image for prediction
+            preprocessed_image = self.preprocess_image(image)
+            # Make a prediction using the disease detection model
             prediction = disease_model.predict(preprocessed_image)
+            # Get the predicted class index (the class with the highest probability)
             predicted_class = np.argmax(prediction, axis=1).item()
+            # Map the predicted class to the disease name, status, and recommendation
             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")
+            # Calculate the confidence of the prediction (as a percentage)
             confidence = prediction[0][predicted_class] * 100
             logger.info(f"Predicted: {disease_name} with {confidence:.2f}% confidence.")
 
-            # Generate detailed response using Llama 3.2
+            # Generate a detailed response using Llama 3.2 for additional insights
             detailed_response = self.generate_detailed_response(disease_name, disease_status, recommendation)
             return detailed_response, disease_name, disease_status, recommendation, confidence
         except Exception as e:
-            logger.error(f"Prediction error: {e}")
+            # Log the error and return failure information
+            logger.error(f"Prediction error: {e}", exc_info=True)
             return "Prediction failed.", None, None, None, None
 
-    def generate_detailed_response(self, disease_name, status, recommendation):
+    def generate_detailed_response(self, disease_name: str, status: str, recommendation: str) -> str:
         """Generate a detailed response using Llama 3.2 model for additional disease insights."""
+        # Construct a prompt for the Llama model with detailed information about the disease
         prompt = (
             f"The disease detected is {disease_name}, classified as {status}. "
             f"Recommended action: {recommendation}. "
             f"Here is more information about {disease_name}, including its causes, symptoms, and treatments "
             "for effective management on a poultry farm."
         )
+        # Generate a response using the Llama model based on the constructed prompt
         response = self.llama_response(prompt)
+        # Remove the prompt text from the response (if included) and return it
         return response.replace(prompt, "").strip()
 
-    def llama_response(self, prompt):
+    def llama_response(self, prompt: str) -> str:
         """Generate a response from the Llama 3.2 model based on a given prompt."""
         try:
-            inputs = llama_tokenizer(prompt, return_tensors="tf", max_length=150, truncation=True, padding=True)
-            outputs = llama_model.generate(inputs["input_ids"], max_length=150, do_sample=True, temperature=0.7)
+            # Tokenize the prompt and prepare it for the Llama model
+            inputs = llama_tokenizer(prompt, return_tensors="tf", max_length=200, truncation=True, padding=True)
+            # Generate a response using the Llama model with sampling options for variety
+            outputs = llama_model.generate(inputs["input_ids"], max_length=200, do_sample=True, temperature=0.7, top_p=0.9)
+            # Decode the generated output to obtain the response text
             return llama_tokenizer.decode(outputs[0], skip_special_tokens=True)
         except Exception as e:
-            logger.error(f"Llama model response error: {e}")
+            # Log the error and return an error message indicating failure
+            logger.error(f"Llama model response error: {e}", exc_info=True)
             return "Error generating detailed response."
 
-    def diagnose_and_respond(self, image):
+    def diagnose_and_respond(self, image: np.ndarray):
         """Diagnose the disease and respond with detailed information and recommendations."""
+        # Check if the provided image is valid (not None and has a non-zero size)
         if image is None or image.size == 0:
             return "Please provide a valid poultry fecal image.", None, None, None, None
+        # Predict the disease using the disease detection model and return the response
         return self.predict_disease(image)
 
 # Initialize the bot instance