Shipwrecks detection using bathymetric data
- 🔬 Data Science
- 🥠 Deep Learning and Instance Segmentation
In this notebook, we will use bathymetry data provided by NOAA to detect shipwrecks from the Shell Bank Basin area located near New York City in United States. A Bathymetric Attributed Grid (BAG) is a two-band imagery where one of the bands is elevation and the other is uncertainty (define uncertainty of elevation value). We have applied deep learning methods after pre-processing the data (which is explained in Preprocess bathymetric data) for the detection.
One important step in pre-processing is applying shaded relief function provided in ArcGIS which is also used by NOAA in one of their BAG visualizations here. Shaded Relief is a 3D representation of the terrain which differentiate the shipwrecks distinctly from the background and reveals them. This is created by merging the Elevation-coded images and
Hillshade method where a 3-band imagery is returned which is easy to interpret as compared to the raw bathymetry image. Subsequently, the images are exported as "RCNN Masks" to train a
MaskRCNN model provided by ArcGIS API for Python for detecting the shipwrecks.
The notebook presents the use of deep learning methods to automate the identification of submerged shipwrecks which could be useful for hydrographic offices, archaeologists, historians who otherwise would spend a lot of time doing it manually.
import os from pathlib import Path from datetime import datetime as dt from arcgis.gis import GIS from arcgis.raster.functions import RFT from arcgis.learn import prepare_data, MaskRCNN
gis = GIS('https://pythonapi.playground.esri.com/portal', 'arcgis_python', 'amazing_arcgis_123')
bathymetry_img = gis.content.get('442df8b8b26d41c598e4e8953e9257ca') bathymetry_img
training_data_wrecks = gis.content.get('d9c02b5835b540e09e378c779ec3c17d') training_data_wrecks
We are applying some preprocessing to the bathymetry data so that we can export the data for training a deep learning model. The preprocessing steps include mapping 'No Data' pixels value to '-1' and applying Shaded Relief function to the output raster. The resultant raster after applying Shaded Relief function will be a 3-band imagery that we can use to export data using
Export Training Data for Deep Learning tool in ArcGIS Pro 2.5, for training our deep learning model.
All the preprocessing steps are recorded in the form of a Raster function template which you can use in ArcGIS Pro to generate the processed raster.
shaded_relief_rft = gis.content.get('b9b7c724601c4bd1946c8e2bfe4d640d') shaded_relief_rft
shaded_relief_ob = RFT(shaded_relief_rft)
# ! conda install -c anaconda graphviz -y
We need to add this custom raster function to ArcGIS Pro using Import functions option in the 'Custom' tab of 'Raster Functions'
Once we apply the Raster function template on the bathymetry data, we will get the output image below. We will use this image to export training data for our deep learning model.
shaded_relief = gis.content.get('1205289b53a24eda903d98760f81d352') shaded_relief
Export training data using 'Export Training data for deep learning' tool, click here for detailed documentation:
- Set 'shaded_relief' as
- Set a location where you want to export the training data in
Output Folderparameter, it can be an existing folder or the tool will create that for you.
- Set the 'training_data_wrecks' as input to the
Input Feature Class Or Classified Rasterparameter.
Class Field Valueas 'ecode'.
Image Formatas 'TIFF format'
Tile Size X&
Tile Size Ycan be set to 256.
Stride Ycan be set to 50.
- Select 'RCNN Masks' as the
Meta Data Formatbecause we are training a 'MaskRCNN Model'.
- In 'Environments' tab set an optimum
Cell Size. For this example, as we have performing the analysis on the bathymetry data with 50 cm resolution, so, we used '0.5' as the cell size.
arcpy.ia.ExportTrainingDataForDeepLearning(in_raster="shaded_Relief_CopyRaster", out_folder=r"\256X256_multiple_cellsize_stride50", in_class_data="training_data_wrecks", image_chip_format="TIFF", tile_size_x=256, tile_size_y=256, stride_x=50, stride_y=50, output_nofeature_tiles="ONLY_TILES_WITH_FEATURES", metadata_format="RCNN_Masks", start_index=0, class_value_field="ecode", buffer_radius=0, in_mask_polygons=None, rotation_angle=0, reference_system="MAP_SPACE", processing_mode="PROCESS_AS_MOSAICKED_IMAGE", blacken_around_feature="NO_BLACKEN", crop_mode="FIXED_SIZE")
As we have already exported our training data, we will now train our model using ArcGIS API for Python. We will be using
arcgis.learn module which contains tools and deep learning capabilities. Documentation is available here to install and setup environment.
We can always apply multiple transformations to our training data when training a model that can help generalize the model better. Though, we do some standard data augmentations, we can enhance them further based on the data at hand, to increase data size, and avoid occurring.
Let us have look, how we can do it using Fastai's image transformation library.
from fastai.vision.transform import crop, rotate, brightness, contrast, rand_zoom
train_tfms = [rotate(degrees=30, # defining a transform using rotate with degrees fixed to p=0.5), # a value, but by passing an argument p. crop(size=224, # crop of the image to return image of size 224. The position p=1., # is given by (col_pct, row_pct), with col_pct and row_pct row_pct=(0, 1), # being normalized between 0 and 1. col_pct=(0, 1)), brightness(change=(0.4, 0.6)), # Applying change in brightness of image. contrast(scale=(1.0, 1.5)), # Applying scale to contrast of image. rand_zoom(scale=(1.,1.2))] # Randomized version of zoom. val_tfms = [crop(size=224, # cropping the image to same size for validation datasets p=1.0, # as in training datasets. row_pct=0.5, col_pct=0.5)] transforms = (train_tfms, val_tfms) # tuple containing transformations for data augmentation # of training and validation datasets respectively.
We would specify the path to our training data and a few hyper parameters.
path: path of folder containing training data.
batch_size: No of images your model will train on each step inside an epoch, it directly depends on the memory of your graphic card.
transforms: tuple containing Fast.ai transforms for data augmentation of training and validation datasets respectively.
This function will return a fast.ai databunch, we will use this in the next step to train a model.
gis = GIS('home')
training_data = gis.content.get('91178e9303af49b0b9ae09c0d32ec164') training_data
filepath = training_data.download(file_name=training_data.name)
import zipfile with zipfile.ZipFile(filepath, 'r') as zip_ref: zip_ref.extractall(Path(filepath).parent)
data_path = Path(os.path.join(os.path.splitext(filepath)))
data = prepare_data(path=data_path, batch_size=8, transforms=transforms)
To make sense of training data we will use the
show_batch() method in
arcgis.learn. This method randomly picks few samples from the training data and visualizes them.
rows: number of rows we want to see the results for.
arcgis.learn provides the
MaskRCNN model for instance segmentation tasks, which is based on a pretrained convnet, like ResNet that acts as the 'backbone'. More details about
MaskRCNN can be found here.
model = MaskRCNN(data)
Learning rate is one of the most important hyperparameters in model training. Here, we explore a range of learning rate to guide us to choose the best one. We will use the
lr_find() method to find an optimum learning rate at which we can train a robust model.
lr = model.lr_find()
To train the model, we use the
fit() method. To start, we will train our model for 80 epochs. Epoch defines how many times model is exposed to entire training set. We have passes three parameters to
epochs: Number of cycles of training on the data.
lr: Learning rate to be used for training the model.
wd: Weight decay to be used.
model.fit(epochs=80, lr=lr, wd=0.1)
As you can see, both the losses (valid_loss and train_loss) started from a higher value and ended up to a lower value, that tells our model has learnt well. Let us do an accuracy assessment to validate our observation.
We can compute the average precision score for the model we just trained in order to do the accuracy assessment. Average precision computes average precision on the validation set for each class. We can compute the Average Precision Score by calling
model.average_precision_score. It takes the following parameters:
detect_thresh: The probability above which a detection will be considered for computing average precision.
iou_thresh: The intersection over union threshold with the ground truth labels, above which a predicted bounding box will be considered a true positive.
mean: If False, returns class-wise average precision otherwise returns mean average precision.
model.average_precision_score(detect_thresh=0.3, iou_thresh=0.3, mean=False)
The model has an average precision score of 0.94 which proves that the model has learnt well. Let us now see it's results on validation set.
The code below will pick a few random samples and show us ground truth and respective model predictions side by side. This allows us to validate the results of your model in the notebook itself. Once satisfied we can save the model and use it further in our workflow. The
model.show_results() method can be used to display the detected ship wrecks. Each detection is visualized as a mask by default.
We would now save the model which we just trained as a 'Deep Learning Package' or '.dlpk' format. Deep Learning package is the standard format used to deploy deep learning models on the ArcGIS platform.
We will use the
save() method to save the model and by default it will be saved to a folder 'models' inside our training data folder itself.
arcpy.ia.DetectObjectsUsingDeepLearning(in_raster="shaded_Relief_CopyRaster", out_detected_objects=r"\\ShipwrecksDetectObjects_80e", in_model_definition=r"\\models\Shipwrecks_80e\Shipwrecks_80e.emd", model_arguments ="padding 56;batch_size 4;threshold 0.3;return_bboxes False", run_nms="NMS", confidence_score_field="Confidence", class_value_field="Class", max_overlap_ratio=0, processing_mode="PROCESS_AS_MOSAICKED_IMAGE")
The output of the model is a layer of detected shipwrecks which is shown below:
This notebook showcased how instance segmentation models like
MaskRCNN can be used to automatically detect shipwrecks using bathymetry data. This notebook also showcased how custom transformations, irrespective of already present standard transformations, based on the data, can be added while preparing data in order to achieve better performance.