"Updated README.md with project description, structure, setup instructions, usage, core functionality, and other details."

.gitignore

@@ -0,0 +1,6 @@
+.env
+/venv
+.gradio
+**/__pycache__/
+app/__pycache__/llm.cpython-310.pyc
+logs/application.log

README.md

@@ -1,13 +1,166 @@
+# Lumpy Skin Disease Prediction System
+
+This project is an AI-based diagnostic system for detecting Lumpy Skin Disease in animals using Machine Learning (ML), Convolutional Neural Networks (CNN), and Large Language Model (LLM) integration. The system allows users to upload images and provide various input features, after which the model analyzes the data and provides a detailed report.
+
+---
+
+## Project Screenshot
+
+![Project Screenshot](screenshots/Screenshot(69).png)
+
+---
+
+## Project Structure (Inside 'app' Directory)
+
+- **app.py** - Main Gradio app script for the user interface.
+- **predict.py** - Contains the prediction logic and interacts with both ML and CNN models.
+- **llm.py** - Utilizes the LLM to generate detailed diagnostic reports.
+- **config.py** - Configuration file with paths and environment variables.
+- **utils.py** - Contains other utility functions and properties.
+- **exception.py** - Custom exception handling for various error scenarios.
+- **logger.py** - Configures logging across the application.
+
+---
+
+## Setup Instructions
+
+### Prerequisites
+- Python 3.10
+- Virtual environment (recommended)
+- `pip` package manager
+
+### Install Dependencies
+
+1. **Clone the Repository**:
+    ```bash
+    git clone https://github.com/Sukanth07/lumpy-skin-disease-prediction.git
+    cd lumpy-skin-disease-prediction
+    ```
+
+2. **Set Up Virtual Environment**:
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # For Linux
+    .\venv\Scripts\activate  # For Windows
+    ```
+
+3. **Install Required Packages**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+4. **Protobuf Builder File Config**:
+    Since there is dependency issue with protobuf, we will manually copy and paste the latest builder file in library path.
+    If you are using Linux based OS, this can be handled programmatically at the start of the app.py
+    ```bash
+    cp "./builder.py" "./venv/Lib/site-packages/google/protobuf/internel/"  # For Linux
+    copy ".\\builder.py" ".\\venv\Lib\\site-packages\\google\\protobuf\\internal\\"    # For Windows
+    ```
+
+5. **Environment Variables**:
+    Create a `.env` file with your API keys and other sensitive data:
+    ```
+    GEMINI_API_KEY=your-gemini-api-key
+    ```
+    You can get the free Gemini API key with this link: https://aistudio.google.com/app/apikey
+
+---
+
+## Usage
+
+### Running the Gradio App
+Start the Gradio app by running the following command:
+```bash
+python app.py
+```
+
+To continuosly run and update the app, use the following command:
+```bash
+gradio app.py
+```
+
+The app will launch in your default browser. You can upload images and provide additional input data to get a comprehensive diagnostic report.
+
+---
+
+## Core Functionality
+- **Machine Learning Prediction** - Predicts the presence of Lumpy Skin Disease based on structured input data.
+- **CNN Image Analysis** - Analyzes images to classify them as 'Lumpy' or 'Not Lumpy'.
+- **LLM Diagnostic Report** - Uses a language model to generate a detailed report based on model predictions and input data.
+
 ---
-title: Lumpy Skin Disease Pred
-emoji: 📈
-colorFrom: red
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.5.0
-app_file: app.py
-pinned: false
-license: mit
+
+## Project Components
+
+1. **app.py**
+   - Main entry point for the Gradio UI.
+   - Displays input fields, image upload options, and prediction results.
+
+2. **predict.py**
+   - Implements the `DataPreprocessor`, `ML_Model_Predictor`, and `CNN_Model_Predictor` classes.
+   - Orchestrates data preprocessing, model prediction, and combines outputs for the LLM report generation.
+
+3. **llm.py**
+   - Responsible for configuring and generating predictions using the LLM.
+   - Formats the results in a user-friendly diagnostic report.
+
+4. **logger.py**
+   - Sets up logging configurations for the project.
+   - Ensures that logs are stored in `logs/app.log` with error level and timestamps.
+
+5. **exception.py**
+   - Contains custom exceptions for model loading, preprocessing, and inference.
+   - Includes a utility function `log_exception` to standardize error logging.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Exception Handling and Logging
+
+- **Logging**: All logs are recorded in `logs/app.log` with timestamps and log levels.
+
+- **Custom Exceptions**: The project uses `exception.py` to handle specific errors, such as:
+    - `ModelLoadingError`: Raised when a model fails to load.
+    - `PreprocessingError`: Raised during data preprocessing issues.
+    - `PredictionError`: Raised for issues in the ML or CNN prediction processes.
+    - `APIError`: Raised when the LLM API encounters an error.
+
+---
+
+## Commands
+
+- **Run App**:
+    ```bash
+    python app.py
+    ```
+
+- **Install Packages**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+- **Deactivate Virtual Environment**:
+    ```bash
+    deactivate
+    ```
+
+---
+
+## Future Improvements
+
+- **Model Optimization**: Further enhance ML and CNN models for faster predictions.
+
+- **LLM Fine-tuning**: Use domain-specific data to improve the LLM's understanding of Lumpy Skin Disease.
+
+- **Expanded Input**: Integrate more diverse data inputs for robust analysis.
+
+---
+
+## License
+
+This project is licensed under the MIT License. See `LICENSE` for more details.
+
+---
+
+## Contributors
+
+- **Sukanth K** - [github.com/Sukanth07](https://github.com/Sukanth07)

app.py

@@ -0,0 +1,76 @@
+import gradio as gr
+import warnings
+import src.utils as utils
+from src.predict import prediction
+from src.logger import get_logger
+
+logger = get_logger(__name__)
+warnings.filterwarnings("ignore")
+
+utils.copy_builder()
+
+def show_processing_text():
+    return gr.update(visible=True), gr.update(visible=False)
+
+def prediction_with_loading(image, longitude, latitude, cloud_cover, evapotranspiration, precipitation, min_temp, mean_temp, max_temp, vapour_pressure, wet_day_freq):
+    try:
+        logger.info("Starting prediction process...")
+        response = prediction(
+            image, longitude, latitude, cloud_cover, evapotranspiration,
+            precipitation, min_temp, mean_temp, max_temp, vapour_pressure, wet_day_freq
+        )
+        logger.info("Prediction completed successfully.")
+        return gr.update(value=response, visible=True), gr.update(visible=False)
+    except Exception as e:
+        logger.error(f"Error in prediction: {str(e)}")
+        return "An error occurred during prediction. Please try again.", gr.update(visible=False)
+
+with gr.Blocks(css=utils.css, theme=gr.themes.Ocean(primary_hue=gr.themes.colors.red, secondary_hue=gr.themes.colors.pink)) as demo:
+    gr.Markdown("<div class='title'>LUMPY SKIN DISEASE PREDICTION</div>")
+    
+    with gr.Row():
+        with gr.Column(scale=5):
+            # Image upload
+            image_input = gr.Image(type="pil", label="Upload Image", height=177)
+        
+        with gr.Column(scale=5):
+            longitude = gr.Number(label="Longitude")
+            latitude = gr.Number(label="Latitude")
+
+    with gr.Row():
+        with gr.Column(scale=5):
+            cloud_cover = gr.Number(label="Monthly Cloud Cover")
+            evapotranspiration = gr.Number(label="Potential EvapoTranspiration")
+        
+        with gr.Column(scale=5):
+            precipitation = gr.Number(label="Precipitation")
+            min_temp = gr.Number(label="Minimum Temperature")
+
+        with gr.Column(scale=5):
+            mean_temp = gr.Number(label="Mean Temperature")
+            max_temp = gr.Number(label="Maximum Temperature")
+        
+        with gr.Column(scale=5):
+            vapour_pressure = gr.Number(label="Vapour Pressure")
+            wet_day_freq = gr.Number(label="Wet Day Frequency")
+
+    with gr.Row():
+        predict_button = gr.Button("Predict", variant="primary")
+    
+    processing_text = gr.Markdown("", visible=False, height=100)
+    output_text = gr.Markdown(label="LLM Generated Diagnostic Report", container=True, show_copy_button=True, visible=False)
+
+    predict_button.click(
+        fn=show_processing_text,
+        inputs=[],
+        outputs=[processing_text, output_text],
+        queue=False
+    )
+    predict_button.click(
+        fn=prediction_with_loading,
+        inputs=[image_input, longitude, latitude, cloud_cover, evapotranspiration, precipitation, min_temp, mean_temp, max_temp, vapour_pressure, wet_day_freq],
+        outputs=[output_text, processing_text],
+        queue=True
+    )
+
+demo.launch(share=True)

builder.py

@@ -0,0 +1,268 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Builds descriptors, message classes and services for generated _pb2.py.
+
+This file is only called in python generated _pb2.py files. It builds
+descriptors, message classes and services that users can directly use
+in generated code.
+"""
+
+"""Dynamic Protobuf class creator."""
+
+__author__ = '[email protected] (Jie Luo)'
+
+
+from collections import OrderedDict
+import hashlib
+import os
+
+from google.protobuf import descriptor_pb2
+from google.protobuf import descriptor
+from google.protobuf import message_factory
+
+
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+
+_sym_db = _symbol_database.Default()
+
+
+def BuildMessageAndEnumDescriptors(file_des, module):
+  """Builds message and enum descriptors.
+
+  Args:
+    file_des: FileDescriptor of the .proto file
+    module: Generated _pb2 module
+  """
+
+  def BuildNestedDescriptors(msg_des, prefix):
+    for (name, nested_msg) in msg_des.nested_types_by_name.items():
+      module_name = prefix + name.upper()
+      module[module_name] = nested_msg
+      BuildNestedDescriptors(nested_msg, module_name + '_')
+    for enum_des in msg_des.enum_types:
+      module[prefix + enum_des.name.upper()] = enum_des
+
+  for (name, msg_des) in file_des.message_types_by_name.items():
+    module_name = '_' + name.upper()
+    module[module_name] = msg_des
+    BuildNestedDescriptors(msg_des, module_name + '_')
+
+
+def BuildTopDescriptorsAndMessages(file_des, module_name, module):
+  """Builds top level descriptors and message classes.
+
+  Args:
+    file_des: FileDescriptor of the .proto file
+    module_name: str, the name of generated _pb2 module
+    module: Generated _pb2 module
+  """
+
+  def BuildMessage(msg_des):
+    create_dict = {}
+    for (name, nested_msg) in msg_des.nested_types_by_name.items():
+      create_dict[name] = BuildMessage(nested_msg)
+    create_dict['DESCRIPTOR'] = msg_des
+    create_dict['__module__'] = module_name
+    message_class = _reflection.GeneratedProtocolMessageType(
+        msg_des.name, (_message.Message,), create_dict)
+    _sym_db.RegisterMessage(message_class)
+    return message_class
+
+  # top level enums
+  for (name, enum_des) in file_des.enum_types_by_name.items():
+    module['_' + name.upper()] = enum_des
+    module[name] = enum_type_wrapper.EnumTypeWrapper(enum_des)
+    for enum_value in enum_des.values:
+      module[enum_value.name] = enum_value.number
+
+  # top level extensions
+  for (name, extension_des) in file_des.extensions_by_name.items():
+    module[name.upper() + '_FIELD_NUMBER'] = extension_des.number
+    module[name] = extension_des
+
+  # services
+  for (name, service) in file_des.services_by_name.items():
+    module['_' + name.upper()] = service
+
+  # Build messages.
+  for (name, msg_des) in file_des.message_types_by_name.items():
+    module[name] = BuildMessage(msg_des)
+
+
+def BuildServices(file_des, module_name, module):
+  """Builds services classes and services stub class.
+
+  Args:
+    file_des: FileDescriptor of the .proto file
+    module_name: str, the name of generated _pb2 module
+    module: Generated _pb2 module
+  """
+  # pylint: disable=g-import-not-at-top
+  from google.protobuf import service as _service
+  from google.protobuf import service_reflection
+  # pylint: enable=g-import-not-at-top
+  for (name, service) in file_des.services_by_name.items():
+    module[name] = service_reflection.GeneratedServiceType(
+        name, (_service.Service,),
+        dict(DESCRIPTOR=service, __module__=module_name))
+    stub_name = name + '_Stub'
+    module[stub_name] = service_reflection.GeneratedServiceStubType(
+        stub_name, (module[name],),
+        dict(DESCRIPTOR=service, __module__=module_name))
+
+
+def _GetMessageFromFactory(factory, full_name):
+  """Get a proto class from the MessageFactory by name.
+
+  Args:
+    factory: a MessageFactory instance.
+    full_name: str, the fully qualified name of the proto type.
+  Returns:
+    A class, for the type identified by full_name.
+  Raises:
+    KeyError, if the proto is not found in the factory's descriptor pool.
+  """
+  proto_descriptor = factory.pool.FindMessageTypeByName(full_name)
+  proto_cls = factory.GetPrototype(proto_descriptor)
+  return proto_cls
+
+
+def MakeSimpleProtoClass(fields, full_name=None, pool=None):
+  """Create a Protobuf class whose fields are basic types.
+
+  Note: this doesn't validate field names!
+
+  Args:
+    fields: dict of {name: field_type} mappings for each field in the proto. If
+        this is an OrderedDict the order will be maintained, otherwise the
+        fields will be sorted by name.
+    full_name: optional str, the fully-qualified name of the proto type.
+    pool: optional DescriptorPool instance.
+  Returns:
+    a class, the new protobuf class with a FileDescriptor.
+  """
+  factory = message_factory.MessageFactory(pool=pool)
+
+  if full_name is not None:
+    try:
+      proto_cls = _GetMessageFromFactory(factory, full_name)
+      return proto_cls
+    except KeyError:
+      # The factory's DescriptorPool doesn't know about this class yet.
+      pass
+
+  # Get a list of (name, field_type) tuples from the fields dict. If fields was
+  # an OrderedDict we keep the order, but otherwise we sort the field to ensure
+  # consistent ordering.
+  field_items = fields.items()
+  if not isinstance(fields, OrderedDict):
+    field_items = sorted(field_items)
+
+  # Use a consistent file name that is unlikely to conflict with any imported
+  # proto files.
+  fields_hash = hashlib.sha1()
+  for f_name, f_type in field_items:
+    fields_hash.update(f_name.encode('utf-8'))
+    fields_hash.update(str(f_type).encode('utf-8'))
+  proto_file_name = fields_hash.hexdigest() + '.proto'
+
+  # If the proto is anonymous, use the same hash to name it.
+  if full_name is None:
+    full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' +
+                 fields_hash.hexdigest())
+    try:
+      proto_cls = _GetMessageFromFactory(factory, full_name)
+      return proto_cls
+    except KeyError:
+      # The factory's DescriptorPool doesn't know about this class yet.
+      pass
+
+  # This is the first time we see this proto: add a new descriptor to the pool.
+  factory.pool.Add(
+      _MakeFileDescriptorProto(proto_file_name, full_name, field_items))
+  return _GetMessageFromFactory(factory, full_name)
+
+
+def _MakeFileDescriptorProto(proto_file_name, full_name, field_items):
+  """Populate FileDescriptorProto for MessageFactory's DescriptorPool."""
+  package, name = full_name.rsplit('.', 1)
+  file_proto = descriptor_pb2.FileDescriptorProto()
+  file_proto.name = os.path.join(package.replace('.', '/'), proto_file_name)
+  file_proto.package = package
+  desc_proto = file_proto.message_type.add()
+  desc_proto.name = name
+  for f_number, (f_name, f_type) in enumerate(field_items, 1):
+    field_proto = desc_proto.field.add()
+    field_proto.name = f_name
+    # # If the number falls in the reserved range, reassign it to the correct
+    # # number after the range.
+    if f_number >= descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER:
+      f_number += (
+          descriptor.FieldDescriptor.LAST_RESERVED_FIELD_NUMBER -
+          descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER + 1)
+    field_proto.number = f_number
+    field_proto.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL
+    field_proto.type = f_type
+  return file_proto

final_models/mobilenet_lumpy_skin_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be6e05f78a51401277f181f787deb16c9eeff9834342f71b090fc368c6782385
+size 14868376

final_models/randomforest_best_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf85c7fc7d48a6a2362baaef7b118a3f56555dbaa7a2bae48f1afca942cef855
+size 9915513

final_models/scaler_object.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e7b94e6c71cb971a521dc7e44c4c9ba64a5307c35a4588da5a9515ad6c1c48e
+size 1383

requirements.txt

@@ -0,0 +1,15 @@
+fastapi
+google-generativeai
+gradio
+huggingface_hub[cli]
+matplotlib
+numpy==1.26.4
+pandas
+python-dotenv
+protobuf==3.19.6
+scikit-learn==1.5.2
+scipy
+seaborn
+subprocess.run
+tensorflow==2.10.0
+uvicorn

src/config.py

@@ -0,0 +1,13 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BASE_DIR = os.path.abspath(os.path.join(os.getcwd(), '.'))
+print(BASE_DIR)
+
+MODELS_DIR = os.path.join(BASE_DIR, 'final_models')
+
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+
+GEMINI_MODEL_NAME = 'gemini-1.5-flash-latest'

src/exception.py

@@ -0,0 +1,30 @@
+import traceback
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+# Define custom exceptions for different parts of the application
+class ModelLoadingError(Exception):
+    """Raised when a model fails to load properly."""
+
+class PreprocessingError(Exception):
+    """Raised when an error occurs during data preprocessing."""
+
+class PredictionError(Exception):
+    """Raised when there is an issue with generating predictions from the models."""
+
+class APIError(Exception):
+    """Raised when there is an issue with the API call to the LLM or any external service."""
+
+
+def log_exception(e: Exception, custom_message: str = ""):
+    """
+    Logs detailed information about an exception, including traceback.
+
+    Args:
+        e (Exception): The exception to log.
+        custom_message (str): Optional custom message to provide additional context in the log.
+    """
+    exc_type, exc_value, exc_traceback = e.__class__, e, e.__traceback__
+    trace_details = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+    logger.error(f"{custom_message}\nException type: {exc_type}\nTraceback:\n{trace_details}")

src/llm.py

@@ -0,0 +1,62 @@
+import google.generativeai as genai
+from .exception import log_exception, APIError
+from .config import *
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+class LLM:
+    def __init__(self):
+        try:
+            # Configure and initialize the Generative AI model
+            genai.configure(api_key=GEMINI_API_KEY)
+            self.model = genai.GenerativeModel(GEMINI_MODEL_NAME)
+            logger.info("LLM model initialized successfully.")
+        except Exception as e:
+            log_exception(e, "Failed to initialize the LLM model in LLM class.")
+            raise APIError("Error initializing LLM model. Check API key and model name.") from e
+
+    def prompt_template(self, result):
+        # Generates a structured prompt for the LLM based on the provided data
+        prompt = f"""You are a medical assistant with expertise in diagnosing and explaining Lumpy Skin Disease in animals. Based on provided data, generate a detailed report covering the following sections:
+
+- Prediction Output: State if the case is classified as 'Lumpy' or 'Not Lumpy'.
+- Key Observations: Summarize important symptoms and indicators.
+- Cause Analysis: Explain the main reasons contributing to the prediction.
+- Precautions & Solutions: Suggest any preventive measures and potential treatments for the condition.
+
+Instructions: Carefully analyze the provided image, input data, and ML model predictions to generate a clear and comprehensive report.
+
+Input Data:
+{result}
+
+Output Report:
+- Prediction Output: Provide the final classification as **Lumpy** or **Not Lumpy** based on your analysis.
+  
+- Key Observations: List the notable symptoms from the image and input data that influenced the classification.
+
+- Cause Analysis: Explain the likely cause(s) contributing to this prediction, highlighting specific symptoms or environmental factors.
+
+- Precautions & Solutions: Outline preventive measures to avoid the spread of Lumpy Skin Disease, and suggest any possible treatments or care strategies to manage the condition.
+
+"""
+        return prompt
+
+    def inference(self, image, result):
+        try:
+            # Prepare and send the request to the LLM model
+            refined_prompt = self.prompt_template(result)
+            prompt = [{'role': 'user', 'parts': [image, refined_prompt]}]
+            
+            response = self.model.generate_content(prompt)
+
+            if response.text:
+                logger.info("LLM inference successful.")
+                return response.text
+            else:
+                logger.warning("LLM did not return any text.")
+                raise APIError("LLM response is empty. Please check input format and prompt.")
+
+        except Exception as e:
+            log_exception(e, "Error during LLM inference in LLM class.")
+            raise APIError("Error during LLM inference. Check input data and model configuration.") from e

src/logger.py

@@ -0,0 +1,20 @@
+import os
+import logging
+from logging.handlers import RotatingFileHandler
+
+# Create logs directory if it doesn't exist
+os.makedirs("logs", exist_ok=True)
+
+# Configure the logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        RotatingFileHandler("logs/application.log", maxBytes=5*1024*1024, backupCount=3),  # Log rotation
+        logging.StreamHandler()  # Log to console as well
+    ]
+)
+
+# Function to get the logger
+def get_logger(name):
+    return logging.getLogger(name)

src/predict.py

@@ -0,0 +1,114 @@
+import joblib
+import numpy as np
+import tensorflow as tf
+from .llm import LLM
+from .config import *
+from .exception import log_exception, ModelLoadingError, PreprocessingError, PredictionError
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+class DataPreprocessor:
+    def __init__(self):
+        try:
+            self.scaler = joblib.load(f"{MODELS_DIR}/scaler_object.joblib")
+            logger.info("DataPreprocessor initialized with scaler.")
+        except Exception as e:
+            log_exception(e, "Error loading scaler in DataPreprocessor.")
+            raise ModelLoadingError("Could not load the scaler for data preprocessing.") from e
+
+    def preprocess(self, input_data):
+        try:
+            scaled_data = self.scaler.transform(np.array(input_data).reshape(1, -1))
+            logger.info("Data preprocessing completed successfully.")
+            return scaled_data
+        except Exception as e:
+            log_exception(e, "Error in preprocessing data in DataPreprocessor.")
+            raise PreprocessingError("Preprocessing failed. Ensure input data format is correct.") from e
+
+
+class ML_Model_Predictor:
+    def __init__(self):
+        try:
+            self.model = joblib.load(f"{MODELS_DIR}/randomforest_best_model.pkl")
+            logger.info("ML model loaded successfully.")
+        except Exception as e:
+            log_exception(e, "Failed to load ML model in ML_Model_Predictor.")
+            raise ModelLoadingError("Could not load ML model. Please check model path and format.") from e
+
+    def predict(self, preprocessed_data):
+        try:
+            prediction = self.model.predict(preprocessed_data)
+            logger.info("ML model prediction completed successfully.")
+            return prediction[0]
+        except Exception as e:
+            log_exception(e, "Error during ML model prediction in ML_Model_Predictor.")
+            raise PredictionError("Prediction failed. Ensure input data format is correct.") from e
+
+
+class CNN_Model_Predictor:
+    def __init__(self):
+        try:
+            self.model = tf.keras.models.load_model(f"{MODELS_DIR}/mobilenet_lumpy_skin_model.h5")
+            logger.info("CNN model loaded successfully.")
+        except Exception as e:
+            log_exception(e, "Failed to load CNN model in CNN_Model_Predictor.")
+            raise ModelLoadingError("Could not load CNN model. Please check model path and format.") from e
+
+    def predict(self, image):
+        try:
+            image = image.resize((224, 224))
+            image_array = np.array(image) / 255.0
+            image_array = np.expand_dims(image_array, axis=0)
+            image_array = tf.keras.applications.mobilenet_v2.preprocess_input(image_array)
+            prediction = self.model.predict(image_array)
+            logger.info("CNN model prediction completed successfully.")
+            return np.argmax(prediction, axis=1)[0]
+        except Exception as e:
+            log_exception(e, "Error during CNN model prediction in CNN_Model_Predictor.")
+            raise PredictionError("CNN prediction failed. Check image input format.") from e
+
+
+def prediction(image, longitude, latitude, cloud_cover, evapotranspiration, precipitation, min_temp, mean_temp, max_temp, vapour_pressure, wet_day_freq):
+    try:
+        # Initialize classes
+        preprocessor = DataPreprocessor()
+        ml_predictor = ML_Model_Predictor()
+        cnn_predictor = CNN_Model_Predictor()
+        llm = LLM()
+        
+        # Prepare structured data input for ML model
+        structured_data = [longitude, latitude, cloud_cover, evapotranspiration, precipitation, min_temp, mean_temp, max_temp, vapour_pressure, wet_day_freq]
+        preprocessed_data = preprocessor.preprocess(structured_data)
+        
+        # Get predictions from ML and CNN models
+        ml_prediction = ml_predictor.predict(preprocessed_data)
+        cnn_prediction = cnn_predictor.predict(image)
+    
+        result = f"""
+        Lumpy Skin Disease Diagnostic Report:
+        
+        **ML Model Prediction:** {'Lumpy' if ml_prediction == 1 else 'Not Lumpy'}
+        **CNN Model Prediction:** {'Lumpy' if cnn_prediction == 1 else 'Not Lumpy'}
+        
+        **Input Data:**
+        - Longitude: {longitude}
+        - Latitude: {latitude}
+        - Monthly Cloud Cover: {cloud_cover}
+        - Potential EvapoTranspiration: {evapotranspiration}
+        - Precipitation: {precipitation}
+        - Minimum Temperature: {min_temp}
+        - Mean Temperature: {mean_temp}
+        - Maximum Temperature: {max_temp}
+        - Vapour Pressure: {vapour_pressure}
+        - Wet Day Frequency: {wet_day_freq}
+        """
+
+        # Generate LLM report
+        report = llm.inference(image=image, result=result)
+        logger.info("LLM report generated successfully.")
+        return report
+    
+    except Exception as e:
+        log_exception(e, "Error in prediction function.")
+        raise PredictionError("Prediction function encountered an error. Check inputs and model paths.") from e

src/utils.py

@@ -0,0 +1,39 @@
+import site
+import subprocess
+from .config import *
+
+def copy_builder():
+    try:
+        site_packages_path = site.getsitepackages()[0]
+        destination_path = os.path.join(site_packages_path, 'google/protobuf/internal/')
+        subprocess.run(["cp", "./builder.py", destination_path], shell=True, check=True)
+    except Exception as e:
+        raise Exception(f"Failed to copy builder.py to site-packages: {e}")
+
+css="""
+.container { 
+    max-width: 90%; 
+}
+
+.title {
+    font-family: 'Trebuchet MS';
+    text-align: center;
+    font-size: 2em;
+    font-weight: bold;
+    padding: 10px 0;
+    background-color: #1f2121;
+}
+
+input, textarea{
+    background-color: #18191a;
+}
+
+#output-container {
+    max-height: 400px;
+    overflow-y: auto;
+    padding: 10px;
+    border: 1px solid #ccc;
+    border-radius: 5px;
+}
+
+"""