Update the Project

app.py

@@ -1,69 +1,323 @@
+"""
+app.py - Gradio Web Application for Forest Fire Detection
+Provides a web interface for image classification, video analysis, and model info.
+"""
+# `spaces` must be imported before any CUDA-touching library (tensorflow is
+# imported transitively below via `src.inference`) for Hugging Face ZeroGPU.
+import spaces
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+# Fix invalid SSL_CERT_FILE on Windows (points to non-existent path)
+ssl_cert = os.environ.get('SSL_CERT_FILE', '')
+if ssl_cert and not os.path.exists(ssl_cert):
+    del os.environ['SSL_CERT_FILE']
+
+import tempfile
+import time
+from pathlib import Path
+
+import cv2
 import gradio as gr
-from huggingface_hub import InferenceClient
+import numpy as np
+from PIL import Image
 
+from src.inference import FireNetInference
+from src.model import FireNetModel
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+# Default model path (override with MODEL_PATH env var, e.g. as a Space secret)
+DEFAULT_MODEL = os.environ.get('MODEL_PATH', 'models/FirenetCNN1.h5')
 
-    messages = [{"role": "system", "content": system_message}]
+# Class descriptions
+CLASS_INFO = {
+    'fire': {
+        'color': 'Red',
+        'description': 'Active fire detected with high confidence. Immediate attention required.',
+        'icon': '🔥'
+    },
+    'no_fire': {
+        'color': 'Green',
+        'description': 'No fire detected. Scene appears safe.',
+        'icon': '✅'
+    },
+    'smoke': {
+        'color': 'Orange',
+        'description': 'Smoke detected. May indicate early-stage fire or controlled burn.',
+        'icon': '💨'
+    }
+}
 
-    messages.extend(history)
 
-    messages.append({"role": "user", "content": message})
+_engine = None
 
-    response = ""
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
+def get_inference_engine() -> FireNetInference:
+    """Get or create the cached inference engine (loaded once per process)."""
+    global _engine
+    if _engine is None:
+        model_path = DEFAULT_MODEL
+        if not os.path.exists(model_path):
+            # Try alternative paths
+            alternatives = [
+                'models/FirenetCNN.keras',
+                'models/FirenetCNN.h5',
+                'models/firenet_model.h5',
+                'FirenetCNN1.h5',
+                'FirenetCNN.h5',
+            ]
+            for alt in alternatives:
+                if os.path.exists(alt):
+                    model_path = alt
+                    break
+        _engine = FireNetInference(model_path)
+    return _engine
 
-        response += token
-        yield response
 
+@spaces.GPU(duration=30)
+def predict_image(image, apply_gradcam=True):
+    """Predict on a single image with optional Grad-CAM."""
+    if image is None:
+        return None, "Please upload an image.", None, None
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
-
-if __name__ == "__main__":
-    demo.launch()
+    try:
+        engine = get_inference_engine()
+
+        # Convert PIL to temp file for inference
+        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
+            if isinstance(image, np.ndarray):
+                cv2.imwrite(tmp.name, cv2.cvtColor(image, cv2.COLOR_RGB2BGR))
+            else:
+                image.save(tmp.name)
+            tmp_path = tmp.name
+
+        result = engine.predict_image(tmp_path, apply_gradcam=apply_gradcam)
+
+        # Cleanup
+        os.unlink(tmp_path)
+
+        # Prepare outputs
+        label = result['label']
+        confidence = result['confidence']
+        probs = result['probability_array']
+
+        # Create annotated image
+        if result.get('annotated_image') is not None:
+            annotated = cv2.cvtColor(result['annotated_image'], cv2.COLOR_BGR2RGB)
+        elif result.get('heatmap') is not None and result['has_gradcam']:
+            original = cv2.imread(tmp_path) if os.path.exists(tmp_path) else None
+            if original is not None:
+                rgb_orig = cv2.cvtColor(original, cv2.COLOR_BGR2RGB)
+                heatmap = np.array(result['heatmap'])
+                annotated = engine.gradcam.overlay_heatmap(rgb_orig, heatmap, alpha=0.5)
+            else:
+                annotated = np.array(image)
+        else:
+            annotated = np.array(image)
+
+        # Create probability chart
+        prob_dict = {cls: float(probs[i]) for i, cls in enumerate(FireNetModel.CLASS_LABELS)}
+
+        # Format result text
+        info = CLASS_INFO.get(label, {})
+        result_text = f"## {info.get('icon', '')} Prediction: **{label.upper()}**\n"
+        result_text += f"**Confidence:** {confidence*100:.2f}%\n\n"
+        result_text += f"**Details:** {info.get('description', 'N/A')}\n\n"
+        result_text += "### Class Probabilities\n"
+        for cls, prob in prob_dict.items():
+            bar = '█' * int(prob * 20)
+            result_text += f"- **{cls}**: {prob*100:.1f}% {bar}\n"
+
+        return annotated, result_text, prob_dict, None
+
+    except Exception as e:
+        return None, f"Error: {str(e)}", None, None
+
+
+@spaces.GPU(duration=120)
+def predict_video(video_path, skip_frames=5, apply_gradcam=True):
+    """Process a video file frame-by-frame."""
+    if video_path is None:
+        return None, "Please upload a video.", None
+
+    try:
+        engine = get_inference_engine()
+
+        # Create output path
+        output_path = tempfile.mktemp(suffix='.mp4')
+
+        stats = engine.predict_video(
+            video_path,
+            output_path=output_path,
+            skip_frames=skip_frames,
+            apply_gradcam=apply_gradcam
+        )
+
+        # Format stats
+        result_text = f"## Video Analysis Complete\n\n"
+        result_text += f"**Total Frames:** {stats['total_frames']}\n"
+        result_text += f"**Processed Frames:** {stats['processed_frames']}\n"
+        result_text += f"**Processing Time:** {stats['processing_time_seconds']:.2f}s\n"
+        result_text += f"**FPS:** {stats['processed_frames']/max(stats['processing_time_seconds'],0.001):.1f}\n\n"
+
+        # Class distribution
+        labels = [f['label'] for f in stats['frame_by_frame'] if f['processed']]
+        if labels:
+            from collections import Counter
+            counts = Counter(labels)
+            result_text += "### Detection Summary\n"
+            for cls, count in counts.most_common():
+                pct = count / len(labels) * 100
+                result_text += f"- **{cls}**: {count} frames ({pct:.1f}%)\n"
+
+        return output_path, result_text, stats
+
+    except Exception as e:
+        return None, f"Error: {str(e)}", None
+
+
+def get_model_info():
+    """Get model information and statistics."""
+    try:
+        engine = get_inference_engine()
+        config = FireNetModel.get_model_config()
+
+        info_text = f"## Model Information\n\n"
+        info_text += f"**Architecture:** {config['architecture']}\n"
+        info_text += f"**Input Shape:** {config['input_shape']}\n"
+        info_text += f"**Number of Classes:** {config['num_classes']}\n"
+        info_text += f"**Class Labels:** {', '.join(config['class_labels'])}\n"
+        info_text += f"**Learning Rate:** {config['learning_rate']}\n"
+        info_text += f"**Image Size:** {config['image_size']}\n"
+        info_text += f"**Batch Size:** {config['batch_size']}\n"
+        info_text += f"**Grad-CAM Layer:** {config['last_conv_layer']}\n\n"
+
+        info_text += "### Model Files\n"
+        models_dir = Path('models')
+        if models_dir.exists():
+            for f in models_dir.glob('*'):
+                if f.suffix in ('.h5', '.keras'):
+                    size_mb = f.stat().st_size / (1024 * 1024)
+                    info_text += f"- **{f.name}**: {size_mb:.1f} MB\n"
+
+        info_text += "\n### Class Reference\n"
+        for cls, details in CLASS_INFO.items():
+            info_text += f"- {details['icon']} **{cls}**: {details['description']}\n"
+
+        return info_text
+
+    except Exception as e:
+        return f"Error loading model info: {str(e)}"
+
+
+# Build Gradio interface
+with gr.Blocks(title="Forest Fire Detection - FirenetCNN", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🔥 Forest Fire Detection using FirenetCNN and XAI Techniques
+
+        Detect and classify forest fires from images and videos using deep learning with explainable AI (Grad-CAM).
+
+        **Classes:** `fire` | `no_fire` | `smoke`
+        """
+    )
+
+    with gr.Tabs():
+        # Tab 1: Image Classification
+        with gr.Tab("📷 Image Classification"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    image_input = gr.Image(type="pil", label="Upload Image")
+                    gradcam_check = gr.Checkbox(label="Apply Grad-CAM", value=True)
+                    predict_btn = gr.Button("Predict", variant="primary")
+
+                with gr.Column(scale=1):
+                    image_output = gr.Image(label="Annotated Result")
+                    result_text = gr.Markdown(label="Prediction")
+                    prob_chart = gr.Label(label="Probabilities")
+
+            predict_btn.click(
+                fn=predict_image,
+                inputs=[image_input, gradcam_check],
+                outputs=[image_output, result_text, prob_chart, gr.State()]
+            )
+
+        # Tab 2: Video Analysis
+        with gr.Tab("🎥 Video Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    video_input = gr.Video(label="Upload Video")
+                    skip_frames = gr.Slider(
+                        minimum=1, maximum=30, value=5, step=1,
+                        label="Process every Nth frame"
+                    )
+                    video_gradcam = gr.Checkbox(label="Apply Grad-CAM", value=True)
+                    video_btn = gr.Button("Analyze Video", variant="primary")
+
+                with gr.Column(scale=1):
+                    video_output = gr.Video(label="Processed Video")
+                    video_stats = gr.Markdown(label="Statistics")
+
+            video_btn.click(
+                fn=predict_video,
+                inputs=[video_input, skip_frames, video_gradcam],
+                outputs=[video_output, video_stats, gr.State()]
+            )
+
+        # Tab 3: Webcam Inference
+        with gr.Tab("📹 Webcam Inference"):
+            gr.Markdown(
+                """
+                ### Live Webcam Detection
+
+                Click **Start Camera** to begin real-time fire/smoke detection.
+
+                **Note:** Webcam inference runs locally in your browser.
+                """
+            )
+            webcam_input = gr.Image(label="Webcam Feed")
+            webcam_output = gr.Image(label="Detection Result")
+
+            # Webcam processing would need real-time streaming
+            # For now, provide a static image upload alternative
+            gr.Markdown("*For live webcam detection, use the Python API directly:*")
+            gr.Markdown(
+                "```python\n"
+                "from src.inference import FireNetInference\n"
+                "engine = FireNetInference('models/FirenetCNN1.h5')\n"
+                "engine.predict_webcam()\n"
+                "```"
+            )
+
+        # Tab 4: Model Information
+        with gr.Tab("📊 Model Information"):
+            model_info = gr.Markdown(value=get_model_info)
+
+            gr.Markdown(
+                """
+                ### Evaluation Metrics (Test Set)
+
+                | Class | Precision | Recall | F1-Score | Support |
+                |-------|-----------|--------|----------|---------|
+                | fire | 0.92 | 0.81 | 0.86 | 121 |
+                | no_fire | 0.76 | 0.98 | 0.86 | 146 |
+                | smoke | 0.84 | 0.67 | 0.75 | 138 |
+                | **accuracy** | | | **0.82** | **405** |
+                | macro avg | 0.84 | 0.82 | 0.82 | 405 |
+                | weighted avg | 0.83 | 0.82 | 0.82 | 405 |
+                """
+            )
+
+    gr.Markdown(
+        """
+        ---
+        *Built with FirenetCNN (MobileNetV2) + Grad-CAM | [GitHub](https://github.com/OpelSpeedster/Forest-Fire-Detection-Using-FirenetCNN-and-XAI-Techniques)*
+        """
+    )
+
+
+if __name__ == '__main__':
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        share=False,
+    )

config.py

@@ -0,0 +1,127 @@
+"""
+Development configuration and utilities for Forest Fire Detection project
+"""
+import json
+from pathlib import Path
+from typing import Dict, Any
+class Config:
+    """Project configuration management"""
+    
+    def __init__(self):
+        self.project_root = Path.cwd()
+        self.data_dir = self.project_root / "data"
+        self.models_dir = self.project_root / "models"
+        self.assets_dir = self.project_root / "assets"
+        self.notebooks_dir = self.project_root / "notebooks"
+        self.src_dir = self.project_root / "src"
+        
+        # Load or create configuration
+        self.config_path = self.project_root / "config.json"
+        self.load_config()
+    
+    def load_config(self) -> Dict[str, Any]:
+        """Load configuration from file or create default"""
+        if self.config_path.exists():
+            with open(self.config_path, 'r') as f:
+                self.config = json.load(f)
+        else:
+            self.config = self._get_default_config()
+            self.save_config()
+        
+        return self.config
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default project configuration"""
+        return {
+            "project_name": "Forest Fire Detection using FirenetCNN and XAI Techniques",
+            "version": "1.0.0",
+            "description": "Detect and classify forest fires with explainable AI",
+            "model": {
+                "input_size": [224, 224],
+                "num_classes": 3,
+                "class_labels": ["fire", "no_fire", "smoke"],
+                "reverse_class_map": {"fire": 0, "no_fire": 1, "smoke": 2}
+            },
+            "gradcam": {
+                "target_layer": "out_relu",
+                "alpha": 0.5,
+                "colormap": "cv2.COLORMAP_JET"
+            },
+            "app": {
+                "title": "Forest Fire Detection - FirenetCNN",
+                "port": 7860,
+                "share": True
+            },
+            "paths": {
+                "data_dir": "data",
+                "models_dir": "models",
+                "assets_dir": "assets",
+                "notebooks_dir": "notebooks",
+                "src_dir": "src"
+            }
+        }
+    
+    def save_config(self) -> None:
+        """Save configuration to file"""
+        with open(self.config_path, 'w') as f:
+            json.dump(self.config, f, indent=2)
+    
+    def get_model_paths(self) -> Dict[str, str]:
+        """Get all model file paths"""
+        return {
+            "modern": str(self.models_dir / "FirenetCNN.keras"),
+            "legacy": str(self.models_dir / "FirenetCNN1.h5"),
+            "alternative": str(self.models_dir / "firenet_model.h5")
+        }
+    
+    def setup_directories(self) -> None:
+        """Create necessary directories"""
+        directories = [
+            self.models_dir,
+            self.assets_dir,
+            self.notebooks_dir,
+            self.src_dir,
+            self.data_dir
+        ]
+        
+        for directory in directories:
+            directory.mkdir(parents=True, exist_ok=True)
+    
+    def validate_environment(self) -> bool:
+        """Validate that required files and directories exist"""
+        required_items = [
+            self.notebooks_dir / "Fire_PredCopy.ipynb"
+        ]
+        
+        for item in required_items:
+            if not item.exists():
+                print(f"⚠️  Warning: Required item not found: {item}")
+        
+        return all(item.exists() for item in required_items)
+    
+    def print_summary(self) -> None:
+        """Print project structure summary"""
+        print("=" * 60)
+        print(f"🚀 {self.config['project_name']}")
+        print("=" * 60)
+        print(f"📝 Version: {self.config['version']}")
+        print(f"📝 Description: {self.config['description']}")
+        print()
+        print("📂 Project Structure:")
+        print(f"   • Models: {self.models_dir}/")
+        print(f"   • Assets: {self.assets_dir}/")
+        print(f"   • Notebooks: {self.notebooks_dir}/")
+        print(f"   • Source: {self.src_dir}/")
+        print(f"   • Data: {self.data_dir}/")
+        print()
+        print("🔧 Key Features:")
+        print("   • FirenetCNN (MobileNetV2 based)")
+        print("   • Grad-CAM Explainable AI")
+        print("   • Gradio Web Interface")
+        print("   • Image & Video Analysis")
+        print("   • Model Conversion Tools")
+        print("   • Full Documentation")
+        print("=" * 60)
+if __name__ == "__main__":
+    config = Config()
+    config.print_summary()

models/FirenetCNN.h5

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

models/FirenetCNN1.h5

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

models/firenet_model.h5

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

packages.txt

@@ -0,0 +1,3 @@
+ffmpeg
+libgl1
+libglib2.0-0

requirements.txt

@@ -0,0 +1,11 @@
+tensorflow[and-cuda]>=2.15.0,<2.20.0
+opencv-python-headless>=4.8.0
+numpy>=1.24.0
+Pillow>=10.0.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+scikit-learn>=1.3.0
+gradio>=4.44.0
+spaces>=0.30.0
+requests>=2.31.0
+python-dateutil>=2.8.0

src/__init__.py

@@ -0,0 +1,12 @@
+"""
+Forest Fire Detection using FirenetCNN and XAI Techniques
+src/__init__.py
+"""
+
+__version__ = "1.0.0"
+
+from .model import FireNetModel
+from .gradcam import GradCAM
+from .inference import FireNetInference
+
+__all__ = ["FireNetModel", "GradCAM", "FireNetInference"]

src/gradcam.py

@@ -0,0 +1,200 @@
+"""
+src/gradcam.py
+Grad-CAM implementation for visualizing model decisions
+"""
+import cv2
+import numpy as np
+import tensorflow as tf
+from typing import Optional, Tuple, Union
+class GradCAM:
+    """
+    Gradient-weighted Class Activation Mapping (Grad-CAM)
+    
+    Visualizes which regions of an image the model focuses on for its predictions.
+    Based on the original Grad-CAM paper: "Grad-CAM: Visual Explanations from Deep Neural Networks via Gradient-based Localization"
+    """
+    
+    def __init__(self, model, last_conv_layer_name: str = 'out_relu'):
+        """
+        Initialize Grad-CAM with a Keras model.
+        
+        Args:
+            model: Keras model
+            last_conv_layer_name: Name of the last convolutional layer to use
+        """
+        self.model = model
+        self.last_conv_layer_name = last_conv_layer_name
+        
+        # Create the gradient model once
+        self.grad_model = self._create_gradient_model()
+    
+    def _create_gradient_model(self):
+        """
+        Create a model that connects the last conv layer and model output.
+        
+        Returns:
+            Keras Model that outputs both the last conv layer and predictions
+        """
+        return tf.keras.Model(
+            [self.model.inputs],
+            [self.model.get_layer(self.last_conv_layer_name).output, self.model.output]
+        )
+    
+    def generate_heatmap(self, image_array: np.ndarray, class_index: int) -> np.ndarray:
+        """
+        Generate a Grad-CAM heatmap for a given image and class.
+        
+        Args:
+            image_array: Preprocessed image array (with batch dimension)
+            class_index: Index of the class to generate heatmap for
+            
+        Returns:
+            Generated heatmap (numpy array, shape: H x W)
+        """
+        with tf.GradientTape() as tape:
+            last_conv_layer_output, preds = self.grad_model(image_array)
+            class_channel = preds[:, class_index]
+        
+        grads = tape.gradient(class_channel, last_conv_layer_output)
+        
+        # Pool gradients across spatial dimensions
+        pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+        
+        # Get the output of the last conv layer
+        last_conv_layer_output = last_conv_layer_output[0]
+        
+        # Compute the weighted combination of feature maps
+        heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
+        heatmap = tf.squeeze(heatmap)
+        
+        # Apply ReLU to get positive weights
+        heatmap = tf.maximum(heatmap, 0)
+        
+        # Normalize heatmap to [0, 1]
+        max_val = tf.math.reduce_max(heatmap)
+        if max_val > 0:
+            heatmap = heatmap / max_val
+        
+        return heatmap.numpy()
+    
+    def overlay_heatmap(self, original_image: np.ndarray, heatmap: np.ndarray, 
+                       alpha: float = 0.5) -> np.ndarray:
+        """
+        Overlay heatmap on original image using JET colormap.
+        
+        Args:
+            original_image: Original image (numpy array, RGB)
+            heatmap: Grad-CAM heatmap (normalized to [0, 1])
+            alpha: Weight for heatmap in overlay (0-1)
+            
+        Returns:
+            Image with heatmap overlay (numpy array, RGB)
+        """
+        # Resize heatmap to match original image dimensions
+        heatmap = cv2.resize(heatmap, (original_image.shape[1], original_image.shape[0]))
+        
+        # Convert heatmap to 8-bit format and apply JET colormap
+        heatmap = np.uint8(255 * heatmap)
+        heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+        
+        # Convert original image to float for blending
+        original_float = original_image.astype(np.float32)
+        heatmap_float = heatmap.astype(np.float32)
+        
+        # Blend original image with heatmap
+        superimposed_img = heatmap_float * alpha + original_float
+        superimposed_img = np.clip(superimposed_img, 0, 255).astype(np.uint8)
+        
+        return superimposed_img
+    
+    @staticmethod
+    def preprocess_frame(frame: np.ndarray, target_size: Tuple[int, int] = (224, 224)):
+        """
+        Preprocess a video frame for model inference.
+        
+        Args:
+            frame: Input frame (numpy array, BGR format from OpenCV)
+            target_size: Target size for model input
+            
+        Returns:
+            Preprocessed frame (numpy array)
+        """
+        # Resize to model input size
+        resized = cv2.resize(frame, target_size)
+        # Normalize to [0, 1]
+        normalized = resized / 255.0
+        # Add batch dimension
+        batched = np.expand_dims(normalized, axis=0)
+        
+        return batched
+    
+    @staticmethod
+    def get_confidence_and_prediction(predictions: np.ndarray, 
+                                     class_labels: list) -> Tuple[str, float, np.ndarray]:
+        """
+        Get prediction label, confidence, and full probability array.
+        
+        Args:
+            predictions: Model output probabilities (array of shape [1, 3])
+            class_labels: List of class labels
+            
+        Returns:
+            Tuple of (predicted_label, confidence, probability_array)
+        """
+        prob_array = predictions[0]
+        max_idx = np.argmax(prob_array)
+        confidence = prob_array[max_idx]
+        label = class_labels[max_idx]
+        
+        return label, confidence, prob_array
+    
+    @staticmethod
+    def get_text_overlay_params(label: str, color_map: dict):
+        """
+        Get parameters for text overlay on frames.
+        
+        Args:
+            label: Predicted class label
+            color_map: Dictionary mapping labels to colors
+            
+        Returns:
+            Tuple of (text_color, background_color)
+        """
+        text_color = color_map.get(label, (255, 255, 255))  # White default
+        background_color = (0, 0, 0)  # Black background
+        return text_color, background_color
+    
+    @staticmethod
+    def create_text_overlay(frame: np.ndarray, text: str, 
+                           text_color: Tuple[int, int, int], 
+                           bg_color: Tuple[int, int, int] = (0, 0, 0)):
+        """
+        Create a text overlay with background on the frame.
+        
+        Args:
+            frame: Input frame
+            text: Text to display
+            text_color: Color of the text
+            bg_color: Background color
+            
+        Returns:
+            Frame with text overlay
+        """
+        # Get text size
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 0.7
+        thickness = 2
+        (text_width, text_height), baseline = cv2.getTextSize(text, font, font_scale, thickness)
+        
+        # Define text position with padding
+        text_x, text_y = 10, 40
+        rect_x1, rect_y1 = text_x - 5, text_y - text_height - baseline - 5
+        rect_x2, rect_y2 = text_x + text_width + 5, text_y + baseline + 5
+        
+        # Draw background rectangle
+        cv2.rectangle(frame, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
+        
+        # Draw text
+        cv2.putText(frame, text, (text_x, text_y), font, font_scale, text_color, thickness)
+        
+        return frame

src/inference.py

@@ -0,0 +1,539 @@
+"""
+src/inference.py
+Unified inference interface for FirenetCNN
+Supports single-image, video, and webcam inference with Grad-CAM visualization
+"""
+import cv2
+import numpy as np
+import tensorflow as tf
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
+from PIL import Image
+import time
+
+from .model import FireNetModel
+from .gradcam import GradCAM
+class FireNetInference:
+    """
+    Unified inference engine for FirenetCNN
+    
+    Provides interface for:
+    - Single image inference with optional Grad-CAM
+    - Video inference with frame-by-frame processing
+    - Real-time webcam inference
+    - Model evaluation and reporting
+    """
+    
+    def __init__(self, model_path: str = 'models/FirenetCNN.keras'):
+        """
+        Initialize the inference engine.
+        
+        Args:
+            model_path: Path to the trained model file
+        """
+        self.model_path = model_path
+        self.class_labels = FireNetModel.CLASS_LABELS
+        self.reverse_class_map = FireNetModel.REVERSE_CLASS_MAP
+        self.color_map = FireNetModel.TEXT_COLOR
+        
+        # Load model and Grad-CAM components
+        self.model_wrapper = FireNetModel(model_path)
+        self.model = self.model_wrapper.load_pretrained_model()
+        self.gradcam = GradCAM(self.model, self.model_wrapper.last_conv_layer_name)
+        
+        # Create gradient model for Grad-CAM
+        self.grad_model = tf.keras.Model(
+            [self.model.inputs],
+            [self.model.get_layer(self.model_wrapper.last_conv_layer_name).output, self.model.output]
+        )
+    
+    def predict_image(self, image_path: str, 
+                     apply_gradcam: bool = True, 
+                     output_path: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Perform inference on a single image.
+        
+        Args:
+            image_path: Path to input image
+            apply_gradcam: Whether to generate Grad-CAM heatmap
+            output_path: Optional path to save annotated image
+            
+        Returns:
+            Dictionary with prediction results and annotations
+        """
+        # Load image
+        image = cv2.imread(str(image_path))
+        if image is None:
+            raise ValueError(f"Could not load image: {image_path}")
+        
+        # Store original for potential output
+        original_image = image.copy()
+        height, width = image.shape[:2]
+        
+        # Preprocess for model
+        input_frame = GradCAM.preprocess_frame(image)
+        
+        # Get predictions
+        predictions = self.model.predict(input_frame, verbose=0)
+        label, confidence, prob_array = GradCAM.get_confidence_and_prediction(
+            predictions, self.class_labels
+        )
+        
+        # Generate Grad-CAM if requested and prediction is fire or smoke
+        heatmap = None
+        superimposed_img = None
+        
+        if apply_gradcam and label in ['fire', 'smoke']:
+            # Convert BGR to RGB for Grad-CAM processing
+            rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            
+            # Prepare input for Grad-CAM
+            img_array = tf.expand_dims(tf.convert_to_tensor(rgb_image / 255.0), 0)
+            class_index = self.reverse_class_map[label]
+            
+            # Generate heatmap
+            heatmap = self.gradcam.generate_heatmap(img_array, class_index)
+            
+            # Overlay heatmap
+            superimposed_img = self.gradcam.overlay_heatmap(
+                original_image, heatmap, alpha=0.5
+            )
+        
+        # Create text overlay parameters
+        text_color, bg_color = GradCAM.get_text_overlay_params(label, self.color_map)
+        result_text = f"Class: {label} ({confidence*100:.2f}%)"
+        
+        # Add text overlay to image
+        annotated_image = GradCAM.create_text_overlay(
+            superimposed_img if superimposed_img is not None else original_image,
+            result_text, text_color, bg_color
+        )
+        
+        # Save annotated image if output path provided
+        if output_path:
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+            cv2.imwrite(str(output_path), annotated_image)
+        
+        # Return results as dictionary
+        result = {
+            'image_path': image_path,
+            'label': label,
+            'confidence': confidence,
+            'probability_array': prob_array.tolist(),
+            'class_labels': self.class_labels,
+            'has_gradcam': heatmap is not None,
+            'heatmap': heatmap.tolist() if heatmap is not None else None,
+            'annotated_image': annotated_image if output_path is None else None,
+            'processing_time': 0  # Will be measured externally if needed
+        }
+        
+        return result
+    
+    def predict_video(self, video_path: str, 
+                     output_path: Optional[str] = None,
+                     skip_frames: int = 5,
+                     apply_gradcam: bool = True) -> Dict[str, Any]:
+        """
+        Process a video file frame-by-frame.
+        
+        Args:
+            video_path: Path to input video file
+            output_path: Optional path to save processed video
+            skip_frames: Process every Nth frame (for performance)
+            apply_gradcam: Whether to generate Grad-CAM for fire/smoke frames
+            
+        Returns:
+            Dictionary with video processing statistics
+        """
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError(f"Could not open video file: {video_path}")
+        
+        # Get video properties
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        # Setup video writer if output path provided
+        video_writer = None
+        if output_path:
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            video_writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        
+        # Statistics
+        stats = {
+            'total_frames': frame_count,
+            'processed_frames': 0,
+            'predictions': [],
+            'frame_by_frame': [],
+            'final_frame': None,
+            'processing_time_seconds': 0
+        }
+        
+        # State tracking across frames
+        last_label = "Initializing..."
+        last_confidence = 0
+        last_heatmap = None
+        last_color = (255, 255, 255)  # White
+        
+        start_time = time.time()
+        frame_number = 0
+        
+        while cap.isOpened() and frame_number < frame_count:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Process only every Nth frame for performance
+            if frame_number % skip_frames == 0 or frame_number == 0:
+                # Preprocess frame
+                input_frame = GradCAM.preprocess_frame(frame)
+                
+                # Get predictions
+                predictions = self.model.predict(input_frame, verbose=0)
+                label, confidence, prob_array = GradCAM.get_confidence_and_prediction(
+                    predictions, self.class_labels
+                )
+                
+                # Update state
+                last_label = label
+                last_confidence = confidence
+                
+                # Generate Grad-CAM if requested and prediction is fire or smoke
+                if apply_gradcam and label in ['fire', 'smoke']:
+                    rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    img_array = tf.expand_dims(tf.convert_to_tensor(rgb_image / 255.0), 0)
+                    class_index = self.reverse_class_map[label]
+                    
+                    last_heatmap = self.gradcam.generate_heatmap(img_array, class_index)
+                    last_color = self.color_map.get(label, (255, 255, 255))
+                else:
+                    last_heatmap = None
+                    last_color = self.color_map.get(label, (255, 255, 255))
+                
+                # Update statistics
+                stats['processed_frames'] += 1
+            
+            # Apply Grad-CAM if available
+            display_frame = frame.copy()
+            if last_heatmap is not None:
+                display_frame = self.gradcam.overlay_heatmap(frame, last_heatmap, alpha=0.5)
+            
+            # Create text overlay
+            text_color, bg_color = GradCAM.get_text_overlay_params(last_label, self.color_map)
+            result_text = f"Class: {last_label} ({last_confidence*100:.2f}%)"
+            display_frame = GradCAM.create_text_overlay(display_frame, result_text, text_color, bg_color)
+            
+            # Save frame if video writer provided
+            if video_writer:
+                video_writer.write(display_frame)
+            
+            # Store frame info
+            frame_info = {
+                'frame_number': frame_number,
+                'label': last_label,
+                'confidence': last_confidence,
+                'processed': (frame_number % skip_frames == 0 or frame_number == 0),
+                'has_gradcam': last_heatmap is not None,
+                'color_bgr': last_color
+            }
+            stats['frame_by_frame'].append(frame_info)
+            
+            # Store last frame for final output
+            stats['final_frame'] = display_frame.copy()
+            
+            frame_number += 1
+        
+        # Cleanup
+        cap.release()
+        if video_writer:
+            video_writer.release()
+        
+        # Calculate processing time
+        processing_time = time.time() - start_time
+        stats['processing_time_seconds'] = processing_time
+        
+        return stats
+    
+    def predict_webcam(self, window_name: str = "Live Webcam Inference (Slow)",
+                      apply_gradcam: bool = False,
+                      max_frames: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Perform real-time inference using webcam.
+        
+        Args:
+            window_name: Name of the display window
+            apply_gradcam: Whether to generate Grad-CAM (normally False for webcam)
+            max_frames: Maximum number of frames to process (None for infinite)
+            
+        Returns:
+            Dictionary with webcam inference results
+        """
+        cap = cv2.VideoCapture(0)
+        if not cap.isOpened():
+            raise RuntimeError("Could not open webcam.")
+        
+        # Statistics
+        stats = {
+            'frames_processed': 0,
+            'predictions': [],
+            'detected_classes': set(),
+            'processing_times': [],
+            'live_feed_active': True
+        }
+        
+        frame_count = 0
+        
+        print(f"Webcam started. Press 'q' to quit.")
+        
+        try:
+            while cap.isOpened() and (max_frames is None or frame_count < max_frames):
+                ret, frame = cap.read()
+                if not ret:
+                    print("Error: Failed to capture frame.")
+                    break
+                
+                # Start timing
+                start_time = time.time()
+                
+                # Preprocess frame
+                input_frame = GradCAM.preprocess_frame(frame)
+                
+                # Get predictions
+                predictions = self.model.predict(input_frame, verbose=0)
+                label, confidence, prob_array = GradCAM.get_confidence_and_prediction(
+                    predictions, self.class_labels
+                )
+                
+                # End timing
+                processing_time = time.time() - start_time
+                stats['processing_times'].append(processing_time)
+                
+                # Update stats
+                stats['frames_processed'] += 1
+                stats['detected_classes'].add(label)
+                frame_info = {
+                    'frame_number': frame_count,
+                    'label': label,
+                    'confidence': confidence,
+                    'processing_time': processing_time
+                }
+                stats['predictions'].append(frame_info)
+                
+                # Generate Grad-CAM if requested and prediction is fire or smoke
+                heatmap = None
+                if apply_gradcam and label in ['fire', 'smoke']:
+                    rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    img_array = tf.expand_dims(tf.convert_to_tensor(rgb_image / 255.0), 0)
+                    class_index = self.reverse_class_map[label]
+                    
+                    heatmap = self.gradcam.generate_heatmap(img_array, class_index)
+                
+                # Create text overlay
+                text_color, bg_color = GradCAM.get_text_overlay_params(label, self.color_map)
+                result_text = f"Class: {label} ({confidence*100:.2f}%)"
+                display_frame = GradCAM.create_text_overlay(frame, result_text, text_color, bg_color)
+                
+                # Apply Grad-CAM if available
+                if heatmap is not None:
+                    display_frame = self.gradcam.overlay_heatmap(display_frame, heatmap, alpha=0.5)
+                
+                # Display the frame
+                cv2.imshow(window_name, display_frame)
+                
+                # Check for quit
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    break
+                
+                frame_count += 1
+        
+        finally:
+            # Cleanup
+            cap.release()
+            cv2.destroyAllWindows()
+            stats['live_feed_active'] = False
+        
+        return stats
+    
+    def create_gradcam_demo_image(self, image_path: str, class_to_highlight: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Create a demonstration image with Grad-CAM for all classes.
+        
+        Args:
+            image_path: Path to input image
+            class_to_highlight: Optional specific class to highlight (default: auto-select best)
+            
+        Returns:
+            Dictionary with demo images for each class
+        """
+        # Load and preprocess image
+        image = cv2.imread(str(image_path))
+        if image is None:
+            raise ValueError(f"Could not load image: {image_path}")
+        
+        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        img_array = tf.expand_dims(tf.convert_to_tensor(rgb_image / 255.0), 0)
+        
+        # Get predictions
+        predictions = self.model.predict(img_array, verbose=0)
+        prob_array = predictions[0]
+        
+        # Determine which class to highlight (default: class with highest probability)
+        if class_to_highlight is None:
+            max_idx = np.argmax(prob_array)
+            class_to_highlight = self.class_labels[max_idx]
+        
+        # Create demo images for each class
+        demo_images = {}
+        
+        for class_label in self.class_labels:
+            # Get class index
+            class_index = self.reverse_class_map[class_label]
+            
+            # Generate heatmap
+            heatmap = self.gradcam.generate_heatmap(img_array, class_index)
+            
+            # Overlay heatmap
+            if class_label == class_to_highlight:
+                # For highlighted class, show the original heatmap
+                overlaid = self.gradcam.overlay_heatmap(
+                    rgb_image, heatmap, alpha=0.6
+                )
+                overlaid = cv2.cvtColor(overlaid, cv2.COLOR_RGB2BGR)
+            else:
+                # For other classes, show grayscale heatmap
+                heatmap_bgr = cv2.applyColorMap(
+                    np.uint8(255 * heatmap), cv2.COLORMAP_JET
+                )
+                overlaid = heatmap_bgr
+            
+            # Create text overlay
+            text_color, bg_color = GradCAM.get_text_overlay_params(class_label, self.color_map)
+            result_text = f"{class_label} ({prob_array[class_index]*100:.1f}%)"
+            demo_images[class_label] = GradCAM.create_text_overlay(
+                overlaid, result_text, text_color, bg_color
+            )
+        
+        return {
+            'original_image': cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR),
+            'prediction': {
+                'predicted_class': self.class_labels[np.argmax(prob_array)],
+                'confidence': float(np.max(prob_array)),
+                'probabilities': prob_array.tolist()
+            },
+            'demo_images': demo_images,
+            'class_to_highlight': class_to_highlight
+        }
+    
+    @classmethod
+    def convert_model_format(cls, input_path: str, output_path: str) -> None:
+        """
+        Convert model from legacy format to modern Keras format.
+        
+        Args:
+            input_path: Path to input model (HDF5 format)
+            output_path: Path to save converted model
+        """
+        from tensorflow.keras.models import load_model
+        
+        model = load_model(input_path, compile=False)
+        model.save(output_path, save_format='keras')
+        print(f"Model converted and saved to: {output_path}")
+    
+    @classmethod
+    def evaluate_model_on_dataset(cls, model_path: str, 
+                                 test_dir: str,
+                                 output_report: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Evaluate model performance on a dataset.
+        
+        Args:
+            model_path: Path to model file
+            test_dir: Path to test dataset directory (with class subdirectories)
+            output_report: Optional path to save evaluation report
+            
+        Returns:
+            Dictionary with evaluation results
+        """
+        from sklearn.metrics import classification_report, confusion_matrix
+        import matplotlib.pyplot as plt
+        import seaborn as sns
+        
+        # Load model
+        model_wrapper = FireNetModel(model_path)
+        model = model_wrapper.load_pretrained_model()
+        
+        # Create data generators
+        test_datagen = ImageDataGenerator(rescale=1./255.)
+        test_generator = test_datagen.flow_from_directory(
+            test_dir,
+            target_size=FireNetModel.IMAGE_SIZE,
+            batch_size=FireNetModel.BATCH_SIZE,
+            class_mode='categorical',
+            shuffle=False
+        )
+        
+        # Make predictions
+        y_pred = model.predict(test_generator, verbose=0)
+        y_pred_classes = np.argmax(y_pred, axis=1)
+        
+        # Get true labels
+        y_true = test_generator.classes
+        
+        # Generate classification report
+        report = classification_report(
+            y_true, 
+            y_pred_classes, 
+            target_names=FireNetModel.CLASS_LABELS,
+            output_dict=True
+        )
+        
+        # Generate confusion matrix
+        cm = confusion_matrix(y_true, y_pred_classes)
+        
+        # Create and save visualization
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                   xticklabels=FireNetModel.CLASS_LABELS,
+                   yticklabels=FireNetModel.CLASS_LABELS)
+        plt.title('Confusion Matrix')
+        plt.ylabel('True Label')
+        plt.xlabel('Predicted Label')
+        
+        if output_report:
+            plt.savefig(output_report, dpi=150, bbox_inches='tight')
+            plt.close()
+        
+        # Save report as text file if requested
+        if output_report and output_report.endswith('.txt'):
+            with open(output_report, 'w') as f:
+                f.write("Forest Fire Detection Model Evaluation Report\n")
+                f.write("=" * 60 + "\n\n")
+                f.write(f"Total samples: {len(y_true)}\n")
+                f.write(f"Classes: {', '.join(FireNetModel.CLASS_LABELS)}\n\n")
+                f.write("Classification Report:\n")
+                f.write(classification_report(y_true, y_pred_classes, 
+                                             target_names=FireNetModel.CLASS_LABELS) + "\n\n")
+                f.write("Confusion Matrix:\n")
+                f.write(str(cm) + "\n")
+                
+                # Add detailed metrics
+                f.write("\nDetailed Metrics:\n")
+                for i, class_name in enumerate(FireNetModel.CLASS_LABELS):
+                    precision = report[class_name]['precision']
+                    recall = report[class_name]['recall']
+                    f1 = report[class_name]['f1-score']
+                    support = report[class_name]['support']
+                    f.write(f"{class_name:10} - Precision: {precision:.3f}, "
+                           f"Recall: {recall:.3f}, F1-score: {f1:.3f}, "
+                           f"Support: {support}\n")
+        
+        return {
+            'classification_report': report,
+            'confusion_matrix': cm.tolist(),
+            'total_samples': len(y_true),
+            'accuracy': report['accuracy'],
+            'macro_avg_f1': report['macro avg']['f1-score'],
+            'weighted_avg_f1': report['weighted avg']['f1-score']
+        }

src/model.py

@@ -0,0 +1,224 @@
+"""
+src/model.py
+FirenetCNN model definition and utilities
+"""
+import json
+import numpy as np
+from pathlib import Path
+from typing import Dict, Tuple, Optional, List
+import tensorflow as tf
+from tensorflow.keras.applications import MobileNetV2
+from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout
+from tensorflow.keras.models import Model, load_model
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+class FireNetModel:
+    """FirenetCNN model implementation using MobileNetV2 transfer learning"""
+    
+    # Model configuration constants
+    IMAGE_SIZE = (224, 224)
+    BATCH_SIZE = 32
+    LEARNING_RATE = 0.0001
+    EPOCHS = 100
+    CLASS_LABELS = ['fire', 'no_fire', 'smoke']  # Model's actual output order
+    REVERSE_CLASS_MAP = {'fire': 0, 'no_fire': 1, 'smoke': 2}
+    
+    # Text overlay styling (OpenCV BGR format)
+    TEXT_COLOR = {
+        'fire': (0, 0, 255),      # Red
+        'smoke': (0, 255, 255),   # Yellow
+        'no_fire': (0, 255, 0),   # Green
+    }
+    
+    def __init__(self, model_path: str = 'models/FirenetCNN.keras'):
+        """
+        Initialize the FirenetCNN model.
+        
+        Args:
+            model_path: Path to the trained Keras model (.keras or .h5 format)
+        """
+        self.model_path = Path(model_path)
+        self.model = None
+        self.last_conv_layer_name = 'out_relu'
+        
+        # Ensure model directory exists
+        self.model_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    @staticmethod
+    def build_model(input_shape: Tuple[int, int, int] = (224, 224, 3)) -> Model:
+        """
+        Build the FirenetCNN architecture.
+        
+        Args:
+            input_shape: Input shape for the model (default: 224x224x3)
+            
+        Returns:
+            Compiled Keras model
+        """
+        base_model = MobileNetV2(weights='imagenet', include_top=False, 
+                                input_shape=input_shape)
+        
+        # Freeze the base model layers
+        base_model.trainable = False
+        
+        # Classification head
+        x = base_model.output
+        x = GlobalAveragePooling2D()(x)
+        x = Dense(1024, activation='relu')(x)
+        x = Dropout(0.5)(x)
+        predictions = Dense(3, activation='softmax')(x)
+        
+        model = Model(inputs=base_model.input, outputs=predictions)
+        
+        model.compile(optimizer=Adam(learning_rate=0.0001),
+                     loss='categorical_crossentropy',
+                     metrics=['accuracy'])
+        
+        return model
+    
+    @staticmethod
+    def create_data_generators(train_dir: str, val_dir: str):
+        """
+        Create data generators for training and validation.
+        
+        Args:
+            train_dir: Path to training data directory
+            val_dir: Path to validation data directory
+            
+        Returns:
+            Tuple of (train_generator, validation_generator)
+        """
+        # Training data with augmentation
+        train_datagen = ImageDataGenerator(
+            rescale=1./255.,
+            rotation_range=40,
+            width_shift_range=0.2,
+            height_shift_range=0.2,
+            shear_range=0.2,
+            zoom_range=0.2,
+            horizontal_flip=True,
+            fill_mode='nearest'
+        )
+        
+        # Validation data without augmentation
+        val_test_datagen = ImageDataGenerator(rescale=1./255.)
+        
+        train_generator = train_datagen.flow_from_directory(
+            train_dir,
+            target_size=FireNetModel.IMAGE_SIZE,
+            batch_size=FireNetModel.BATCH_SIZE,
+            class_mode='categorical'
+        )
+        
+        validation_generator = val_test_datagen.flow_from_directory(
+            val_dir,
+            target_size=FireNetModel.IMAGE_SIZE,
+            batch_size=FireNetModel.BATCH_SIZE,
+            class_mode='categorical'
+        )
+        
+        return train_generator, validation_generator
+    
+    def load_pretrained_model(self, model_path: Optional[str] = None) -> Model:
+        """
+        Load a pretrained model from file.
+        
+        Args:
+            model_path: Path to model file (optional, uses instance path if None)
+            
+        Returns:
+            Loaded Keras model
+            
+        Raises:
+            FileNotFoundError: If model file does not exist
+        """
+        path = Path(model_path) if model_path else self.model_path
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Model file not found: {path}")
+        
+        try:
+            # Try to load as modern Keras .keras format
+            self.model = load_model(str(path), compile=False)
+            return self.model
+        except Exception:
+            # Fallback to legacy .h5 format
+            if path.suffix == '.h5':
+                self.model = load_model(str(path), compile=False)
+                return self.model
+            raise ValueError(f"Unsupported model format or file not found: {path}")
+    
+    def save_model(self, path: str) -> None:
+        """
+        Save the model to file.
+        
+        Args:
+            path: Path to save the model
+        """
+        if self.model is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        
+        self.model.save(path)
+    
+    @staticmethod
+    def preprocess_image(image_path: str) -> tf.Tensor:
+        """
+        Preprocess a single image for inference.
+        
+        Args:
+            image_path: Path to the image file
+            
+        Returns:
+            Preprocessed image tensor
+        """
+        img = tf.keras.utils.load_img(image_path, target_size=FireNetModel.IMAGE_SIZE)
+        img_array = tf.keras.utils.img_to_array(img)
+        img_array = tf.expand_dims(img_array, 0)  # Add batch dimension
+        img_array = img_array / 255.0
+        return img_array
+    
+    @staticmethod
+    def get_model_config() -> Dict:
+        """
+        Get model configuration metadata.
+        
+        Returns:
+            Dictionary with model configuration
+        """
+        return {
+            'input_shape': (*FireNetModel.IMAGE_SIZE, 3),
+            'num_classes': len(FireNetModel.CLASS_LABELS),
+            'class_labels': FireNetModel.CLASS_LABELS,
+            'reverse_class_map': FireNetModel.REVERSE_CLASS_MAP,
+            'learning_rate': FireNetModel.LEARNING_RATE,
+            'image_size': FireNetModel.IMAGE_SIZE,
+            'batch_size': FireNetModel.BATCH_SIZE,
+            'architecture': 'FirenetCNN (MobileNetV2 + custom classifier head)',
+            'last_conv_layer': 'out_relu'
+        }
+    
+    @classmethod
+    def save_model_config(cls, path: str) -> None:
+        """
+        Save model configuration to JSON.
+        
+        Args:
+            path: Path to save configuration JSON
+        """
+        config = cls.get_model_config()
+        with open(path, 'w') as f:
+            json.dump(config, f, indent=2)
+    
+    @classmethod
+    def load_model_config(cls, path: str) -> Dict:
+        """
+        Load model configuration from JSON.
+        
+        Args:
+            path: Path to configuration JSON
+            
+        Returns:
+            Dictionary with model configuration
+        """
+        with open(path, 'r') as f:
+            return json.load(f)

src/training.py

@@ -0,0 +1,165 @@
+"""
+src/training.py
+Training pipeline for FirenetCNN model
+"""
+import tensorflow as tf
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
+
+from .model import FireNetModel
+
+
+def train(
+    train_dir: str,
+    val_dir: str,
+    model_save_path: str = 'models/FirenetCNN.keras',
+    epochs: int = 100,
+    learning_rate: float = 0.0001,
+    batch_size: int = 32,
+    image_size: Tuple[int, int] = (224, 224),
+    fine_tune: bool = False,
+    fine_tune_epochs: int = 10,
+    fine_tune_lr: float = 1e-5,
+    callback_save_best: bool = True,
+    callback_early_stopping: bool = True,
+    early_stopping_patience: int = 10,
+) -> Dict[str, Any]:
+    """
+    Train the FirenetCNN model.
+
+    Args:
+        train_dir: Path to training data directory
+        val_dir: Path to validation data directory
+        model_save_path: Path to save the trained model
+        epochs: Number of training epochs
+        learning_rate: Learning rate for initial training
+        batch_size: Training batch size
+        image_size: Input image size (height, width)
+        fine_tune: Whether to fine-tune the base model after initial training
+        fine_tune_epochs: Number of fine-tuning epochs
+        fine_tune_lr: Learning rate for fine-tuning
+        callback_save_best: Save model with best validation accuracy
+        callback_early_stopping: Stop training if validation loss stops improving
+        early_stopping_patience: Patience for early stopping
+
+    Returns:
+        Dictionary with training history and results
+    """
+    # Build model
+    model = FireNetModel.build_model(input_shape=(*image_size, 3))
+
+    # Create data generators
+    train_gen, val_gen = FireNetModel.create_data_generators(train_dir, val_dir)
+
+    # Setup callbacks
+    callbacks = []
+
+    save_path = Path(model_save_path)
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if callback_save_best:
+        best_model_path = save_path.with_name(save_path.stem + '_best' + save_path.suffix)
+        callbacks.append(tf.keras.callbacks.ModelCheckpoint(
+            str(best_model_path),
+            monitor='val_accuracy',
+            save_best_only=True,
+            mode='max',
+            verbose=1
+        ))
+
+    if callback_early_stopping:
+        callbacks.append(tf.keras.callbacks.EarlyStopping(
+            monitor='val_loss',
+            patience=early_stopping_patience,
+            restore_best_weights=True,
+            verbose=1
+        ))
+
+    # Initial training (frozen base model)
+    print(f"Phase 1: Training with frozen base for {epochs} epochs...")
+    history = model.fit(
+        train_gen,
+        epochs=epochs,
+        validation_data=val_gen,
+        callbacks=callbacks,
+        verbose=1
+    )
+
+    # Fine-tuning phase
+    if fine_tune:
+        print(f"\nPhase 2: Fine-tuning for {fine_tune_epochs} epochs...")
+
+        # Unfreeze the base model
+        base_model = None
+        for layer in model.layers:
+            if hasattr(layer, 'layers') and len(layer.layers) > 50:
+                base_model = layer
+                break
+
+        if base_model is not None:
+            base_model.trainable = True
+
+            # Recompile with lower learning rate
+            model.compile(
+                optimizer=tf.keras.optimizers.Adam(learning_rate=fine_tune_lr),
+                loss='categorical_crossentropy',
+                metrics=['accuracy']
+            )
+
+            # Continue training
+            history_fine = model.fit(
+                train_gen,
+                epochs=fine_tune_epochs,
+                validation_data=val_gen,
+                callbacks=callbacks,
+                verbose=1
+            )
+
+            # Merge histories
+            for key in history_fine.history:
+                history.history[key].extend(history_fine.history[key])
+
+    # Save final model
+    model.save(str(save_path))
+    print(f"\nModel saved to: {save_path}")
+
+    return {
+        'history': history.history,
+        'epochs_completed': len(history.history['accuracy']),
+        'final_train_acc': history.history['accuracy'][-1],
+        'final_val_acc': history.history['val_accuracy'][-1],
+        'model_path': str(save_path)
+    }
+
+
+if __name__ == '__main__':
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Train FirenetCNN model')
+    parser.add_argument('--train-dir', default='data/forestfire-classifier-dataset/train',
+                        help='Training data directory')
+    parser.add_argument('--val-dir', default='data/forestfire-classifier-dataset/val',
+                        help='Validation data directory')
+    parser.add_argument('--model-path', default='models/FirenetCNN.keras',
+                        help='Path to save trained model')
+    parser.add_argument('--epochs', type=int, default=100,
+                        help='Number of training epochs')
+    parser.add_argument('--fine-tune', action='store_true',
+                        help='Enable fine-tuning phase')
+    parser.add_argument('--fine-tune-epochs', type=int, default=10,
+                        help='Number of fine-tuning epochs')
+
+    args = parser.parse_args()
+
+    results = train(
+        train_dir=args.train_dir,
+        val_dir=args.val_dir,
+        model_save_path=args.model_path,
+        epochs=args.epochs,
+        fine_tune=args.fine_tune,
+        fine_tune_epochs=args.fine_tune_epochs
+    )
+
+    print(f"\nTraining complete!")
+    print(f"Final train accuracy: {results['final_train_acc']:.4f}")
+    print(f"Final val accuracy: {results['final_val_acc']:.4f}")