Camera-Based Wildfire Detection: A Frugal Approach for Early Warning Systems

Context

Wildfires have become a pressing issue, especially as we’ve seen this year in California, where thousands of acres have been engulfed in flames. Facing this growing threat, AI appears to be a promising solution for the early detection of fires. However, artificial intelligence models are often noted for their high energy use, which can have an indirect impact on global warming. Therefore, it has become essential to design frugal models, combining performance and energy sobriety.

On the occasion of the AI Action Summit, a challenge of a special kind was organized: the Frugal AI Challenge, a hackathon, initiated by the Ministry of Ecological Transition, Hugging Face and Data for Good. The challenge aimed at demonstrating the possibility to design more sober AI models, while maintaining efficiency.

The Frugal AI Challenge offered participants the opportunity to address several tasks to fight against the climate crisis, including the detection of forest fires based on images captured by cameras mounted on watchtowers in the forest.

To evaluate the participants, two metrics were observed: energy consumption in Wh and accuracy, i.e. the model’s ability to predict the correct classification.

Figure 1: Energy Consumption (Wh) vs Accuracy (%) of different approaches

At Sia, Consulting for Good is a core initiative that aims to integrate social, environmental and ethical considerations into our[LB2] consulting missions. We have recently created a new division called Low Carbon Solutions. Its objective is to support companies,[LB3] across all sectors transition to low-carbon models and in their ambition to reduce their environmental impact.

In this dynamic, we were eager to participate in the frugal AI challenge, to help Pyronear and the French Fire and Rescue Services in their task while demonstrating our ability to respond to this kind of problem.

Among Sia R&D activities, the Computer Vision and Climate LABs quickly formed a team to participate in the challenge on the task of detecting wildfires, a subject that had already been studied, but rather on the analysis of the evolution of this risk according to global warming projections.

What is Pyronear?

Pyronear is a non-profit NGO whose objective is to democratize open and low-tech solutions for fighting wildfires, a major issue in the fight against global warming and the preservation of ecosystems. The goal of the hackathon was clear: design an efficient model for this task while minimizing its energy footprint.

The Dataset provided: Pyro-SDIS pyronear/pyro-sdis · Datasets at Hugging Face

Pyro-SDIS is a dataset designed for the detection of fire smoke using AI models. It was developed in collaboration with the Departmental Fire and Rescue Services (SDIS) in France and the volunteers of the Pyronear NGO.

The images in this dataset come from Pyronear cameras, installed with the support of its SDIS partners. These images have been carefully annotated by committed volunteers, we acknowledge their valuable work.

Dataset Contents

The Pyro-SDIS subset contains images and annotations for the detection of fire smoke. Its structure includes the following metadata for each image:

• Image Path: The path to the image file.
• Annotations: Annotations in YOLO format for smoke detection:
  - class_id: Class label (e.g. smoke).
  - x_center, y_center: Normalized coordinates of the center of the bounding box.
  - width, height: The normalized width and height of the bounding box.
• Metadata:
  - partner: Partner organization responsible for the camera (e.g. SDIS 07, Force 06).
  - camera: Camera ID.
  - Date: The date the image was captured (format YYYY-MM-DDTHH-MM-SS).
  - image_name: Original name of the image file.
• Format: JPEG — Mode: RGB — Size: (1280, 720)
• Volume:
  - Training set: 29,537 images
  - Validation set: 4,099 images.
• Examples of dataset images:

Figure 2: Random sample of the Pyro-SDIS dataset, bbox in red indicates smoke.

Using this data, the challenge was to design a high-performance, eco-friendly AI model to quickly detect forest fires and thus improve the responsiveness of emergency services.

Our Approaches:

Data Exploration and Augmentation

First, to improve the robustness of our model, we applied different data augmentation techniques, creating varied training examples from the limited Pyronear dataset, this will help our models to learn robust, generalizable patterns rather than memorizing specific instances. Moreover, this performance improvement will not increase model size and consumption during inference, which is an important aspect for the frugal part of this challenge. We chose to have a particular focus on zoom, contrast and noise addition:

• Zoom: Simulates different capture distances.
• Contrast: Enhance smoke recognition in different lighting conditions.
• Added noise: Improves robustness against natural disturbances.
• Specifically, we used:
  - GaussNoise: Adds Gaussian noise to the image with a standard deviation ranging from 0 to 0.1.
  - GaussianBlur: Applies Gaussian blur to the image to simulate a natural blur effect or focus problem.
  - HorizontalFlip: Flips the image horizontally to generate a new perspective and increase the diversity of the data.
  - CLAHE (Contrast Limited Adaptive Histogram Equalization): Applies adaptive histogram equalization to improve the local contrast of images, useful for low-contrast images.
  - RandomGamma: Adjusts gamma correction non-linearly, darkening or brightening images to improve robustness to lighting variations.

Models training

We explored different approaches based on the ranking of the best models available at that moment, from Hugging Face and Roboflow leaderboards:

• https://huggingface.co/spaces/hf-vision/object_detection_leaderboard
• https://leaderboard.roboflow.com/

We finally focused on two kinds of object detection models, namely RTDETR and YOLO for their accuracy and inference speed. [AO4]

Table I: Model Comparison YOLOv8 vs RTDETRv2 for Object Detection

RT DETR: the best model in terms of raw performance.

Real-Time Detection TransformerRT-DETR, developed by Baidu, is a state-of-the-art, end-to-end object detector that delivers real-time performance while maintaining high accuracy.

Figure 3: Baidu RT-DETR Overview

The RT-DETR model delivered satisfactory performance but was too resource-intensive, making it a strong candidate for post-training inference optimization (see section 4.). Through optimization by using pruning, quantization and building a dedicated inference engine, we successfully reduced its energy consumption by 50% with only a minor accuracy trade-off. However, despite these improvements, its inference efficiency still fell short of matching the performance of the YOLO models.

YOLO: The best tradeoff models between speed and accuracy.

Then we were interested in the YOLO model family, the YOLO (You Only Look Once) models are a family of convolutional neural network (CNN) architectures designed for real-time object detection. Originally developed by Joseph Redmon, YOLO stands out for its speed and efficiency, making it a popular solution for applications such as surveillance, autonomous driving, and object recognition in video. The latest version, YOLO11, provides access to different model sizes via Ultralytics.

Figure 4: Comparison of YOLO models

Initially, we trained a YOLO11s model, which appeared to offer the best balance between size and precision. However, we later explored a multi-camera YOLO11n hybrid architecture. We observed that the camera IDs provided valuable information, as they indicated both location and a relatively constant field of view, given that the cameras were fixed on watchtowers.

Figure 5: YOLOv11 paper, figure 1

In the dataset we identified 6 cameras with over 1500 images each, enough to consider finetuning from the master model.

Figure 6: Images by Cameras available in the dataset

The hybrid architecture consisted of two bricks:

• A YOLO11n master model, the lightest in the family, trained on the entire dataset.
• Six additional YOLO11n models, refined from the master model with camera-specific images. This methodology allows for capturing the particularities of each area.

Figure 7: Hybrid architecture with finetuned models

When inferring, if the image comes from one of the six identified cameras , we choose the dedicated finetuned model, otherwise the default master model would be used.

We identified several areas for improvement that we were not able to finalize in the time allotted for this challenge. Among these, the integration of additional metadata already available in the dataset such as date or location or addition of external data such as weather conditions would have enriched the model’s inputs and potentially improved its performance.

While these improvements could not be implemented in the current project, they are promising avenues for future iterations.

Focus on model optimization

The optimization of artificial intelligence models, especially computer vision models, is crucial for their deployment on devices with limited resources, which is also very interesting in the context of the Frugal AI Challenge.

Two major techniques can reduce size and speed up inference: pruning and quantization.

Pruning consists of removing the least significant weights or neurons from a neural network. This technique reduces the size of the model and speeds up execution without significantly degrading accuracy if properly calibrated. We opted for a 10% pruning to limit the loss of accuracy of the model.

As for quantization, it decreases the accuracy of weights and activations, often from 32 bits to 8, which reduces memory usage and improves execution speed. FP8 and FP16 are floating-point numerical formats, carefully designed to balance computational efficiency and numerical accuracy in AI workflows. FP8 uses 8 bits to represent numbers with reduced precision, allowing faster computation while saving memory bandwidth. FP16 provides higher precision with 16 bits, ideal for tasks requiring greater numerical accuracy without a significant overhead in hardware resources. To limit loss of accuracy we were not able to optimize dynamic quantization and preferred to us half precision with FP16 format.

As seen, these optimizations come with trade-offs. Pruning too aggressively can cause a significant loss of accuracy, making the model less reliable in critical scenarios. Similarly, quantization can introduce representation errors, especially for tasks requiring a great deal of finesse of analysis.

Thus, the optimization of our models by pruning and quantization is a balancing act between efficiency and precision. A good approach is to adjust these techniques based on the hardware constraints and requirements of the target application. By combining these methods wisely, we were able to achieve a faster and lighter model, without sacrificing performance.

Finally, we decided to use TensorRT to optimize inference. It is a high-performance deep learning inference library developed by NVIDIA to speed up processing.

• Multi-framework support: Compatible with TensorFlow, PyTorch, and ONNX.
• Optimized inference engine: Fast and efficient execution on NVIDIA GPUs, supporting batch processing.
• Flexibility: Deploy to a wide range of devices.

Thanks to these optimizations, we have managed to maximize the efficiency of the model while maintaining high performance, thus making our approach more adapted to the ecological and material constraints of the Frugal AI Challenge.

Conclusion

The evaluation of our model according to the criteria of frugality and accuracy was carried out thanks to the CodeCarbon package. We achieved an accuracy of over 80% in classifying images (presence or absence of smoke). The chosen approach, based on a unique optimized YOLO11s model trained on 100 epochs with precise adjustment of the hyperparameters, has made it possible to obtain an excellent compromise between performance and lightness.

The assessment also considered energy consumption:

• Carbon footprint: 1.3 gCO2
• Power consumption: 3.5 Wh
• Infrastructure used: NVIDIA Tesla T4 GPU for inference over 4,099 frames.

These results highlight the effectiveness of the single model approach, which has proven to be the most effective in this challenge.

Finally, the concrete application of this solution could benefit firefighters and emergency services, by offering them a fast and energy-efficient fire detection tool. The opening of this technology towards embedded devices or real-time monitoring solutions represents a promising avenue for future innovations in environmental risk management.

This hackathon highlighted a crucial issue: making artificial intelligence more sustainable. In a context where models are becoming more and more energy-consuming, it is imperative to promote more responsible practices. Frugal AI is not limited to a technical constraint; It paves the way for sustainable, accessible and climate-friendly innovations.

In conclusion, the Frugal AI Challenge was a great opportunity to rethink the way we think about AI. This type of initiative must be encouraged to bring out technological solutions aligned with the environmental challenges of our time.

If you are interested in this subject, do not hesitate to share your thoughts in comments or to join the communities committed to responsible AI!

Link to the AI Action Summit: Artificial Intelligence Action Summit
Link to the Frugal AI challenge: Frugal AI Challenge | 2025 Frugal AI Challenge
Link to Sia : Sia AI: Our AI Solutions Ecosystem

Hashley Ramanankatsoina Daniel Levy Kinza Kasmi Thomas Guillebot de Nerville Ariel Eddie Guidi

References

Code Carbon — Python package
A python package estimating the hardware energy consumption (CPU + GPU + RAM) of your program.

Power Hungry Processing: Watts Driving the Cost of AI Deployment? — Luccioni et al., 2023
A broad study of AI models’ power consumption at inference stage. Experiments are run with Code Carbon and applied to both Natural Language Processing and Computer Vision tasks.

The Price of Prompting: Profiling Energy Use in Large Language Models Inference — Huson et al., 2024
A study focusing on LLM inference energy needs. Provides an open-source tool for energy monitoring and additional insights into energy profiles during LLM inference.

Trends in AI inference energy consumption: Beyond the performance-vs-parameter laws of deep learning — Desislavov et al., 2023
The authors gather data on hardware performance and models computing needs during inference. They focus on both vision and NLP tasks, concluding on how energy consumption varies with performance increase.
A wider perspective on the (negative) environmental impacts of AI

The great challenges of generative AI (French only) — Data For Good, 2023.
Pages 80 to 107 are dedicated to the environmental impacts of generative AI.

Awesome Green AI — Samuel Rincé
A curated collection of Green AI resources including tools, scientific papers and reports. It covers training, inference and model deployment.

Efficient Deep Learning: A Survey on Making Deep Learning Models Smaller, Faster, and Better — Gaurav Menghani, 2023
A broad technical survey on making deep learning models more efficient at inference stage. It includes compression (pruning, quantization, clustering…) and training methods, efficient architectures and frameworks as well as automation processes designed to increase energy efficiency.

Towards Greener LLMs: Bringing Energy-Efficiency to the Forefront of LLM Inference — Stojkovic et al., 2024
The authors estimate the influence of three optimization methods for LLM inference, namely workload type, batching and model parallelism. They conclude on their influence with respect to throughput, power and energy consumption.

Quantization and other optimization modules
Model optimization in Tensorflow
Quantization in Pytorch
vLLM