Introduction

Ecologists and environmental scientists often struggle with the labor-intensive process of manually identifying individual organisms in high-resolution aerial imagery. With the rise of uncrewed aerial vehicles (UAVs) and high-resolution aircraft sensors, the volume of data acquisition now far outpaces the human capacity to analyze it. DeepForest provides a scalable, automated solution to this bottleneck, offering a specialized Python package for detecting ecological objects like tree crowns and birds in airborne RGB imagery. By leveraging deep learning, DeepForest allows researchers to convert vast amounts of imagery into actionable ecological data with a fraction of the manual effort.

What Is DeepForest?

DeepForest is a Python package for training and predicting ecological objects in airborne imagery for biodiversity applications. It is designed to simplify the process of object detection in high-resolution RGB imagery, specifically targeting tree crown delineation and wildlife observation. Built on the PyTorch and PyTorch Lightning frameworks, DeepForest provides a streamlined interface for ecologists who may not have extensive machine learning expertise.

The project is maintained by the Weecology Lab at the University of Florida and is released under the MIT license. It provides prebuilt models trained on extensive datasets, such as those from the National Ecological Observatory Network (NEON), allowing users to start making predictions immediately without needing to collect and label their own data from scratch.

Why DeepForest Matters

Traditional forest monitoring has long relied on manual field surveys or low-resolution satellite imagery, both of which have significant tradeoffs. Field surveys are slow and labor-intensive, while satellite data often lacks the precision required to identify individual tree crowns. DeepForest fills this gap by enabling the use of high-resolution airborne RGB imagery—captured by drones or piloted aircraft—to automate the identification of individual organisms at scale.

The ability to automate tree crown detection is critical for calculating forest biomass, monitoring carbon sequestration, and understanding species distribution. By reducing the technical barriers to entry for computer vision in ecology, DeepForest empowers researchers to focus on the ecological analysis rather than the complexities of neural network architecture. The project’s open-source nature and use of standardized annotation formats ensure that the community can collaboratively improve the models’ accuracy across diverse forest types and geographic regions.

Key Features

• Prebuilt Detection Models: DeepForest includes ready-to-use models for tree crown and bird detection, trained on large-scale datasets like NEON, providing immediate utility for most users.
• Custom Model Training: Users can extend the prebuilt models by annotating their own imagery and fine-tuning the weights to better suit specific ecosystems or species.
• Tile-Based Prediction: To handle massive geospatial images that would otherwise exceed GPU memory, DeepForest offers a predict_tile function that processes images in overlapping patches.
• Standardized Annotation Format: The package uses a simple CSV-based format (image_path, xmin, ymin, xmax, ymax, label) following the Pascal VOC convention, making it easy to import and export data.
• PyTorch Lightning Integration: By using PyTorch Lightning, the package automatically handles data distribution across available GPUs, simplifying the hardware acceleration process.
• Species Classification: While the initial models are single-class, they can be extended to perform species-level classification based on new labeled data.
• R Wrapper Availability: For researchers who prefer R over Python, a wrapper package (deepforestr) is available to provide access to DeepForest’s capabilities.
• Evaluation Tools: Built-in methods for calculating precision, recall, and intersection-over-union (IoU) allow users to quantitatively assess the accuracy of their predictions.

How DeepForest Compares

DeepForest is positioned as a specialized tool for ecological monitoring, whereas many other computer vision tools are designed for general-purpose object detection. When compared to general-purpose platforms like Roboflow or broader remote sensing libraries like Torchgeo, DeepForest offers a more curated experience tailored to the specific needs of ecologists.

The primary differentiator for DeepForest is its “out-of-the-box” utility. While Torchgeo provides the building blocks for remote sensing ML, DeepForest provides the actual models trained on ecological data. Roboflow is an excellent platform for dataset management and annotation, but it lacks the specialized, pre-trained ecological weights that DeepForest provides. For a researcher who needs to detect trees in a specific forest type, DeepForest is the most direct path to results.

Getting Started: Installation

DeepForest is available as a Python package and can be installed via several methods. It is highly recommended to use a virtual environment to avoid dependency conflicts, especially since it relies on PyTorch and Torchvision.

pip Installation

The simplest way to install DeepForest is via pip:

pip install deepforest

Conda Installation

For users who prefer Conda, it is recommended to first install PyTorch and Torchvision from the official PyTorch channel to ensure compatibility:

conda create -n deepforest python=3 pytorch torchvision -c pytorch
conda activate deepforest
conda install deepforest -c conda-forge

Source Installation

If you wish to contribute to the project or modify the source code, you can install it directly from the GitHub repository:

git clone https://github.com/weecology/DeepForest.git
cd DeepForest
pip install .

Prerequisites: DeepForest requires Python 3.8 or higher. GPU support is provided via PyTorch, and if you have an NVIDIA GPU, ensure you have the correct CUDA toolkit installed to accelerate predictions and training.

How to Use DeepForest

Using DeepForest starts with initializing the model and loading the pre-trained weights. The most common workflow involves loading a release model and using it to predict tree crowns in a single image or a large geospatial tile.

Once the model is initialized, you can use the predict_image method for smaller images or predict_tile for large-scale aerial imagery. The output is a pandas DataFrame containing the bounding box coordinates for every detected object, which can then be exported to CSV or used for further geospatial analysis in GIS software.

Code Examples

The following examples demonstrate the basic usage of DeepForest. These snippets are based on the official documentation and repository examples.

Basic Prediction

This example shows how to load the pre-trained tree detection model and make a prediction on a single image.

from deepforest import main

# Initialize the DeepForest model
model = main.deepforest()

# Load the pretrained release model weights
model.use_release()

# Predict tree crowns in the image
predictions = model.predict_image(path="path/to/your/image.jpg")
print(predictions)

The predict_image function returns a DataFrame with the coordinates of the detected tree crowns.

Tile-Based Prediction for Large Images

For large aerial images, predict_tile is used to avoid memory errors. It splits the image into patches and processes them sequentially.

from deepforest import main

model = main.deepforest()
model.use_release()

# Predict on a large geospatial tile
predictions = model.predict_tile(raster_path="path/to/large_tile.tif", 
                                 patch_size=300, 
                                 patch_overlap=0.5)
print(predictions)

The patch_size and patch_overlap parameters allow you to tune the accuracy and avoid edge effects at the patch boundaries.

Advanced Configuration

DeepForest includes a default configuration file (deepforest_config.yml) that allows users to control critical hyperparameters and data paths. This configuration can be modified directly in the YAML file or programmatically via the model object’s config dictionary.

from deepforest import main

model = main.deepforest()
# Change the batch size for training or evaluation
model.config["batch_size"] = 10
# Update the location of training data
model.config["train_data_path"] = "/path/to/custom_data"

Common customization scenarios include adjusting the batch size to match your GPU memory (VRAM) or updating the paths to your custom annotation files for fine-tuning the model on a specific forest type.

Real-World Use Cases

DeepForest is particularly effective in scenarios where high-resolution imagery is available but manual annotation is impossible due to the scale of the data.

• Forest Inventory and Biomass Estimation: A forestry manager can use DeepForest to automatically count individual trees across thousands of acres, providing a more accurate estimate of forest density and biomass than traditional sampling methods.
• Wildlife Observation: An ecologist studying bird populations can use the bird detection model to identify individuals in high-resolution aerial imagery, allowing for the map of nesting sites and distribution patterns.
• Carbon Sequestration Monitoring: Environmental agencies can use the tool to monitor the change in tree cover over time by comparing predictions from imagery captured at different time intervals, quantifying the loss or gain of tree crowns.
• Species-Specific Mapping: By fine-tuning the model on a specific species (e.g., identifying only Monarch birch), researchers can map the distribution of invasive species or the distribution of rare plants within a landscape.

Contributing to DeepForest

The Weecology Lab encourages community contributions to improve the model’s performance across diverse ecosystems. Since the project is open-source, users can contribute by reporting bugs, suggesting new features, or submitting pull requests. New contributors should look for “good first issues” on GitHub to get oriented with the code.

The project follows a standard GitHub flow: users should open an issue to discuss a feature or use the GitHub Discussions board for questions. Bug reports should be detailed, including the same image and annotation file used to trigger the error.

Community and Support

DeepForest is supported by a vibrant community of ecologists and developers. Official support channels include the laGitHub Discussions board, where users can get suggestions on how to improve model predictions for their specific imagery. The official documentation site on ReadTheDocs is the primary source for tutorials and API references.

The project is active and maintained, with frequent updates to the PyTorch backend to ensure compatibility with the latest deep learning libraries.

Conclusion

DeepForest is the right choice for researchers and environmental scientists who need to automate the object detection of trees and birds in high-resolution aerial imagery. It is particularly powerful when using pre-trained weights that allow for immediate results without the need for extensive data labeling. For those who need extreme precision in a specific ecosystem, the package’s ability to be fine-tuned on custom data makes it a la

robust and flexible tool.

While the tool is not designed for satellite imagery (which is generally too low-resolution for individual crown detection), it is the gold standard for UAV and aircraft-based ecological monitoring. We recommend that you star the repo, try the quickstart guide, and join the community to help improve the ecological computer vision landscape.

Resources

• DeepForest GitHub Repository
• Official DeepForest Documentation
• DeepForest Demo Repository