Petrel

PyTorch has a very reliable implementation of EfficientDet but like all deep learning frameworks it requires a fair amount of work to prepare the data for use in the model. Petrel streamlines this process by providing a standard format for loading training and validation data as well as a single class manage the whole training pipeline. The major components are described below.

Input Data Format.

Petrel's Dataset classes take two dataframes as inputs, one consisting of one row per image, the other consisting of one row per bounding box.

The first table, metadata, is only required to contain one column:

• file This should be the absolute path name to the image file. Images can be stored in any manner the user wishes.

It is strongly recommended that metadata rows contain a height and a width column for each image as well. Although not strictly necessary, it is very likely the preprocessing pipeline will require this information. Any other image level metadata should be included in this table, but is not used by this package.

Ensure that the indices for metadata range from 0 to numrows - 1.

A sample table with the minimum recommended columns is below. This data comes from NABirds; the file name consists of the species level directory number (encoded elsewhere) and the random hex string identifying the image file.

The second table, boxes, contains the information about the bounding boxes for each image. Bounding box coordinates are stored in PASCAL VOC format with each coordinate a separate column. These are converted into a single tensor by the Petrel module. Six columns are required.

• file The name of the file containing the bounding box.
• labels A numeric label for the class of the object contained in the bounding box. Numbers should range from 1 to num_clases. Zero is reserved for the empty class.
• xmin Upper left horizontal coordinate of the bounding box.
• ymin Upper left vertical coordinate of the boundingbox.
• xmax Lower right horizontal coordinate of the bounding box.
• ymax Lower right vertical coordinate of the bounding box.

A seventh column containing class names, to go with the label column, is useful, but not required. Other columns can be added as the user requires.

A sample table, this time from the Sweden Larch Casebearer dataset is below. In this table damage is the class name corresponding to the label.

Preparing Training and Validation Data

The classes TrainDataset and ValDataset extend the base PetrelDataset class by adding functionality for separate training and validation preprocessing. Preprocessing is done by a chained series of transformations operating on both the image and the bounding boxes.

Preprocessing for training usually involves iterating through a series of transformations, some of which are random (i.e. random cropping). There is usually a requirement that at least one bounding box in the image be preserved be contained in the final output, otherwise the preprocessing steps are run again. If this fails after a certain number of attempts another set of transformations (which may or may not be the same) is done once in its place. TrainDataset is designed to be used with Albumentations chained together by Compose, but could work with another package with a similar API.

Since validation requires the same images for each epoch ValDataset` only performs one transformation operation.

Users are expected to provide their own transformation functions as this is the part of model training that is most dependent on the dataset in use. A sample transformation that only reshapes images to a fixed size is provided in dataset/___init__.py

A sample TrainDataset and ValDataset is construction is shown below.

from petrel.dataset import TrainDataset, ValDataset
train_dataset = TrainDataset(
    meta_data=TRAINING_METADATA,
    boxes=TRAINING_BOXES,
    image_root=f"{TRAIN_IMG_ROOT_DIR}",
    transform=TRAIN_TRANSFORM
)

val_dataset = ValDataset(
    meta_data=VAL_METADATA,
    boxes=VAL_BOXES,
    image_root=f"{VAL_IMG_ROOT_DIR}",
    transform=VAL_TRANSFORM,
    train_pipe=True #Set to false if not used for training.
)

Setting up and training a model is even simpler.

from petrel.model import load_edet, load_optimizer, load_scheduler, ModelTrainer
model = load_edet(
    "tf_efficientdet_d0",
    image_size=512,
    num_classes=4
)
optimizer = load_optimizer(
    "adamw",
    model,
    learning_rate=2.56e-3
)
scheduler = load_scheduler(
    "exponential",
    optimizer=optimizer,
    gamma=0.94**0.25
)
model_trainer = ModelTrainer(
    model,
    optimizer,
    scheduler,
    base_dir=f"{BASE_MODEL_DIR}"
)

Prediction and Evaluation

The predict module contains code for conputing predictions for single batches, which can be size 1, or whole datasets. The predict function takes an image and an optional dictionary of bounding boxes and labels and returns a dictionary of bounding box predictions. When a full batch job is required, predict_df or val_predict_df can be used depending on whether ground truth data is available.

The eval module computes evaluation metrics. For a range of IOU match thresholds, defaulting to the COCO standard 0.50:0.05:0.95, eval computes the PASCAL-VOC mAP for each class and an unweighted average mAP over all classes. These can then be averaged over the IOU thresholds to approximate the COCO mAP (COCO mAP averages over regular recall values 0.01:0.01:0.99 while PASCAL-VOC mAP is a continous integral over recall values; the difference will be slight.)

Below is an example of evaluating a model on a dataset.

from petrel.model import load_edet
from petrel.predict import model_eval, val_prediction_df
model = load_edet(
    "tf_efficientdet_d0",
    image_size=512,
    num_classes=4,
    checkpoint_path=f"{BASE_MODEL_DIR}",
    train=False)

pred_df = val_prediction_df(model, val_loader, verbose=20)
eval_df = model_eval(pred_df, categories=categories)

The output of model_eval for a simple EfficientDet0 on the Larch Casebearer Dataset is shown below.

Averaged over the IOU Thresholds the (approximate) COCO mAP results are