Visual inspection of industrial environments is a common requirement across heavy industries, such as transportation, construction, and shipbuilding, and typically requires qualified experts to perform the inspection. Inspection locations can often be remote or in adverse environments that put humans at risk, such as bridges, skyscrapers, and offshore oil rigs.
Many of these industries deal with huge metal surfaces and harsh environments. A common problem across these industries is metal corrosion and rust. Although corrosion and rust are used interchangeably across different industries (we also use the terms interchangeably in this post), these two phenomena are different. For more details about the differences between corrosion and rust as well as different degrees of such damages, see Difference Between Rust and Corrosion and Stages of Rust.
Different levels and grades of rust can also result in different colors for the damaged areas. If you have enough images of different classes of rust, you can use the techniques described in this post to detect different classes of rust and corrosion.
Rust is a serious risk for operational safety. The costs associated with inadequate protection against corrosion can be catastrophic. Conventionally, corrosion detection is done using visual inspection of structures and facilities by subject matter experts. Inspection can involve on-site direct interpretation or the collection of pictures and the offline interpretation of them to evaluate damages. Advances in the fields of computer vision and machine learning (ML) makes it possible to automate corrosion detection to reduce the costs and risks involved in performing such inspections.
In this post, we describe how to build a serverless pipeline to create ML models for corrosion detection using Amazon SageMaker and other AWS services. The result is a fully functioning app to help you detect metal corrosion.
We will use the following AWS services:
- Amazon API Gateway is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale.
- AWS Lambda is a compute service that lets you run code without provisioning or managing servers. Lambda runs your code only when triggered and scales automatically, from a few requests per day to thousands per second.
- Amazon SageMaker is a fully managed service that provides developers and data scientists the tools to build, train, and deploy different types of ML models.
- AWS Step Functions allows you to coordinate several AWS services into a serverless workflow. You can design and run workflows where the output of one step acts as the input to the next step while embedding error handling into the workflow.
Solution overview
The corrosion detection solution comprises a React-based web application that lets you pick one or more images of metal corrosion to perform detection. The application lets you train the ML model and deploys the model to SageMaker hosting services to perform inference.
The following diagram shows the solution architecture.
The solution supports the following use cases:
- Performing on-demand corrosion detection
- Performing batch corrosion detection
- Training ML models using Step Functions workflows
The following are the steps for each workflow:
- On-demand corrosion detection – An image picked by the application user is uploaded to an Amazon Simple Storage Service (Amazon S3) bucket. The image S3 object key is sent to an API deployed on API Gateway. The API’s Lambda function invokes a SageMaker endpoint to detect corrosion in the image uploaded, and generates and stores a new image in an S3 bucket, which is further rendered in the front end for analysis.
- Batch corrosion detection – The user uploads a .zip file containing images to an S3 bucket. A Lambda function configured as an Amazon S3 trigger is invoked. The function performs batch corrosion detection by performing an inference using the SageMaker endpoint. Resulting new images are stored back in Amazon S3. These images can be viewed in the front end.
- Training the ML model – The web application allows you to train a new ML model using Step Functions and SageMaker. The following diagram shows the model training and endpoint hosting orchestration. The Step Functions workflow is started by invoking the
StartTrainingJobAPI supported by the Amazon States Language. After a model has been created, theCreateEndpointAPI of SageMaker is invoked, which creates a new SageMaker endpoint and hosts the new ML model. A checkpoint step ensures that the endpoint is completely provisioned before ending the workflow.
Machine learning algorithm options
Corrosion detection is conventionally done by trained professionals using visual inspection. In challenging environments such as offshore rigs, visual inspection can be very risky. Automating the inspection process using computer vision models mounted on drones is a helpful alternative. You can use different ML approaches for corrosion detection. Depending on the available data and application objectives, you could use deep learning (including object detection or semantic segmentation) or color classification, using algorithms such as Extreme Gradient Boosting (XGBoost). We discuss both approaches in this post, with an emphasis on XGBoost method, and cover advantages and limitations of both approaches. Other methods such as unsupervised clustering might also be applicable, but aren’t discussed in this post.
Deep learning approach
In recent years, deep learning has been used for automatic corrosion detection. Depending on the data availability and the type of labeling used, you can use object detection or semantic segmentation to detect corroded areas in metal structures. Although deep learning techniques are very effective for numerous use cases, the complex nature of corrosion detection (the lack of specific shapes) sometimes make deep learning methods less effective for detecting corroded areas.
We explain in more detail some of the challenges involved in using deep learning for this problem and propose an alternative way using a simpler ML method that doesn’t require the laborious labeling required for deep learning methods. If you have a dataset annotated using rectangular bounding boxes, you can use an object detection algorithm.
The most challenging aspect of this problem when using deep learning is that corroded parts of structures don’t have predictable shapes, which makes it difficult to train a comprehensive deep learning model using object detection or semantic segmentation. However, if you have enough annotated images, you can detect these random-looking patterns with reasonable accuracy. For instance, you can detect the corroded area in the following image (shown inside the red rectangle) using an object detection or semantic segmentation model with proper training and data.
The more challenging problem for performing corrosion detection using deep learning is the fact that the entire metal structure can often be corroded (as in the following image), and deep learning models confuse these corroded structures with the non-corroded ones because the edges and shapes of entirely corroded structures are similar to a regular healthy structure with no corrosion. This can be the case for any structure and not just limited to pipes.
Color classification approach (using the XGBoost algorithm)
Another way of looking at the corrosion detection problem is to treat it as a pixel-level color classification, which has shown promise over deep learning methods, even with small training datasets. We use a simple XGBoost method, but you can use any other classification algorithm (such as Random Forest).
The downside of this approach is that darker pixel colors in images can be mistakenly interpreted as corrosion. Lighting conditions and shadows might also affect the outcome of this approach. However, this method produced better-quality results compared to deep learning approaches because this method isn’t affected by the shape of structures or the extent of corrosion. Accuracy can be improved by using more comprehensive data.
If you require pixel-level interpretation of images, the other alternative is to use semantic segmentation, which requires significant labeling. Our proposed method offers a solution to avoid this tedious labeling.
The rest of this post focuses on using the color classification (using XGBoost) approach. We explain the steps required to prepare data for this approach and how to train such a model on SageMaker using the accompanying web application.
Create training and validation datasets
When using XGBoost, you have the option of creating training datasets from both annotated or manually cropped and non-annotated images. The color classification (XGBoost) algorithm requires that you extract the RGB values of each pixel in the image that has been labeled as clean or corroded.
We created Jupyter notebooks to help you create training and validation datasets depending on whether you’re using annotated or non-annotated images.
Create training and validation datasets for annotated images
When you have annotated images of corrosion, you can programmatically crop them to create smaller images so you have just the clean or corroded parts of the image. You reshape the small cropped images into a 2D array and stack them together to build your dataset. To ensure better-quality data, the following code further crops the small images to pick only the central portion of the image.
To help you get started quickly, we created a sample training dataset (5 MB) that you can use to create training and validation datasets. You can then use these datasets to train and deploy a new ML model. We created the sample training dataset from a few public images from pexels.com.
Let’s understand the process of creating a training dataset from annotated images. We created a notebook to help you with the data creation. The following are the steps involved in creating the training and validation data.
Crop annotated images
The first step is to crop the annotated images.
- We read all annotated images and the XML files containing the annotation information (such as bounding boxes and class name). See the following code:
xml_paths = get_file_path_list(xml_path) images_names = list(set(get_filename_list(images_path)))
- Because the input images are annotated, we extract the class names and bounding boxes for each annotated image:
for idx, x in enumerate(xml_paths): single_imgfile_path = images_path + '\'+ x.split('\')[-1].split('.')[0] +'.JPG' image = Image.open(single_imgfile_path) tree = ET.parse(x) root = tree.getroot() for idx2, rt in enumerate(root.findall('object')): name = rt.find('name').text if name in classes_to_use: xmin = int(rt.find('bndbox').find('xmin').text) ymin = int(rt.find('bndbox').find('ymin').text) xmax = int(rt.find('bndbox').find('xmax').text) ymax = int(rt.find('bndbox').find('ymax').text)
- For each bounding box in an image, we zoom in to the bounding box, crop the center portion, and save that in a separate file. We cut the bounding box by 1/3 of its size from each side, therefore taking 1/9 of the area inside the bounding box (its center). See the following code:
a = (xmax-xmin)/3.0 b = (ymax-ymin)/3.0 box = [int(xmin+a),int(ymin+b),int(xmax-a),int(ymax-b)] image1 = image.crop(box) - Finally, we save the cropped image:
image1.save('cropped_images_small/'+name+"-"+str(count)+".png", "PNG", quality=80, optimize=True, progressive=True)
It’s recommended to do a quick visual inspection of the cropped images to make sure they only contain either clean or corroded parts.
The following code shows the implementation for cropping the images (also available in section 2 of the notebook):
def crop_images(xml_path, images_path, classes_to_use):
# Crop objects of type given in "classes_to_use" from xml files with several
# objects in each file and several classes in each file
if os.path.isdir("cropped_images_small"):
shutil.rmtree('cropped_images_small')
os.mkdir('cropped_images_small')
print("Storing cropped images in cropped_images_small folder" )
else:
os.mkdir('cropped_images_small')
print("Storing cropped images in cropped_images_small folder" )
xml_paths = get_file_path_list(xml_path)
images_names = list(set(get_filename_list(images_path)))
count = 0
for idx, x in enumerate(xml_paths):
if '.DS_Store' not in x:
single_imgfile_path = images_path + '\'+ x.split('\')[-1].split('.')[0] +'.JPG'
image = Image.open(single_imgfile_path)
tree = ET.parse(x)
root = tree.getroot()
for idx2, rt in enumerate(root.findall('object')):
name = rt.find('name').text
if name in classes_to_use:
xmin = int(rt.find('bndbox').find('xmin').text)
ymin = int(rt.find('bndbox').find('ymin').text)
xmax = int(rt.find('bndbox').find('xmax').text)
ymax = int(rt.find('bndbox').find('ymax').text)
a = (xmax-xmin)/3.0
b = (ymax-ymin)/3.0
box = [int(xmin+a),int(ymin+b),int(xmax-a),int(ymax-b)]
image1 = image.crop(box)
image1.save('cropped_images_small/'+name+"-"+str(count)+".png", "PNG", quality=80, optimize=True, progressive=True)
count+=1
Create the RGB DataFrame
After cropping and saving the annotated parts, we have many small images, and each image contains only pixels belonging to one class (Clean or Corroded). The next step in preparing the data is to turn the small images into a DataFrame.
- We first define the column names for the DataFrame that contains the class (Clean or Corroded) and the RGB values for each pixel.
- We define the classes to be used (in case we want to ignore other possible classes that might be present).
- For each cropped image, we reshape the image and extract RGB information into a new DataFrame.
- Finally, we save the final data frame into a .csv file.
See the following code:
37 crop_path = 'Path to your cropped images'
38 files = get_file_path_list(crop_path)
39
40 cols = ['class','R','G','B']
41 df = pd.DataFrame()
42
43 classes_to_use = ['Corroded','Clean']
44 dict1 = {'Clean': 0, 'Corroded': 1}
45 for file in files:
46 lbls = Image.open(file)
47 imagenp = np.asarray(lbls)
48 imagenp=imagenp.reshape(imagenp.shape[1]*imagenp.shape[0],3)
49 name = file.split('\')[-1].split('.')[0].split('-')[0]
50 classname = dict1[name]
51 dftemp = pd.DataFrame(imagenp)
52 dftemp.columns =['R','G','B']
53 dftemp['class'] = classname
54 columnsTitles=['class','R','G','B']
55 dftemp=dftemp.reindex(columns=columnsTitles)
56 df = pd.concat([df,dftemp], axis=0)
57
58 df.columns = cols
59 df.to_csv('data.csv', index=False)
In the end, we have a table containing labels and RGB values.
Create training and validation sets and upload to Amazon S3
After you prepare the data, you can use the code listed under section 4 of our notebook to generate the training and validation datasets. Before running the code in this section, make sure you enter the name of a S3 bucket in the bucket variable, for storing the training and validation data.
The following lines of code in the notebook define variables for the input data file name (FILE_DATA), the training/validation ratio (for this post, we use 20% of the data for validation, which leaves 80% for training) and the name of the generated training and validation data .csv files. You can choose to use the sample training dataset as the input data file or use the data file you generated by following the previous step and assigning it to the FILE_DATA variable.
FILE_DATA = 'data.csv'
TARGET_VAR = 'class'
FILE_TRAIN = 'train.csv'
FILE_VALIDATION = 'validation.csv'
PERCENT_VALIDATION = 20
Finally, you upload the training and validation data to the S3 bucket:
s3_train_loc = upload_to_s3(bucket = bucket, channel = 'train', filename = FILE_TRAIN)
s3_valid_loc = upload_to_s3(bucket = bucket, channel = 'validation', filename = FILE_VALIDATION)
Create a training dataset for manually cropped images
For creating the training and validation dataset when using manually cropping images, you should name your cropped images with the prefixes Corroded and Clean to be consistent with the implementation in the provided Jupyter notebook. For example, for the Corroded class, you should name your image files Corroded-1.png, Corroded-2.png, and so on.
Set the path of your images and XML files into the variables img_path and xml_path. Also set the bucket name to the bucket variable. Run the code in all the sections defined in the notebook. This creates the training and validation datasets and uploads them to the S3 bucket.
Deploy the solution
Now that we have the training and validation datasets in Amazon S3, it’s time to train an XGBoost classifier using SageMaker. To do so, you can use the corrosion detection web application’s model training functionality. To help you with the web application deployment, we created AWS CloudFormation templates. Clone the source code from the GitHub repository and follow the deployment steps outlined to complete the application deployment. After you successfully deploy the application, you can explore the features it provides, such as on-demand corrosion detection, training and deploying a model, and batch features.
Training an XGBoost classifier on SageMaker
To train an XGBoost classifier, sign in to the corrosion detection web application, and on the menu, choose Model Training. Here you can train a new SageMaker model.
You need to configure parameters before starting a new training job in SageMaker. The application provides a JSON formatted parameter payload that contains information about the SageMaker training job name, Amazon Elastic Compute Cloud (Amazon EC2) instance type, the number of EC2 instances to use, the Amazon S3 location of the training and validation datasets, and XGBoost hyperparameters.
The parameter payload also lets you configure the EC2 instance type, which you can use for hosting the trained ML model using SageMaker hosting services. You can change the values of the hyperparameters, although the default values provided work. For more information about training job parameters, see CreateTrainingJob. For more information about hyperparameters, see XGBoost Hyperparameters.
See the following JSON code:
{
"TrainingJobName":"Corrosion-Detection-7",
"MaxRuntimeInSeconds":20000,
"InstanceCount":1,
"InstanceType":"ml.c5.2xlarge",
"S3OutputPath":"s3://bucket/csv/output",
"InputTrainingS3Uri":"s3://bucket/csv/train/train.csv",
"InputValidationS3Uri":"s3://bucket/csv/validation/validation.csv",
"HyperParameters":{
"max_depth":"3",
"learning_rate":"0.12",
"eta":"0.2",
"colsample_bytree":"0.9",
"gamma":"0.8",
"n_estimators":"150",
"min_child_weight":"10",
"num_class":"2",
"subsample":"0.8",
"num_round":"100",
"objective":"multi:softmax"
},
"EndpointInstanceType":"ml.m5.xlarge",
"EndpointInitialInstanceCount":1
}
The following screenshot shows the model training page. To start the SageMaker training job, you need to submit the JSON payload by choosing Submit Training Job.
The application shows you the status of the training job. When the job is complete, a SageMaker endpoint is provisioned. This should take a few minutes, and a new SageMaker endpoint should appear on the SageMaker Endpoints tab of the app.
Promote the SageMaker endpoint
For the application to use the newly created SageMaker endpoint, you need to configure the endpoint with the web app. You do so by entering the newly created endpoint name in the New Endpoint field. The application allows you to promote newly created SageMaker endpoints for inference.
Detect corrosion
Now you’re all set to perform corrosion detection. On the Batch Analysis page, you can upload a .zip file containing your images. This processes all the images by detecting corrosion and indicating the percentage of corrosion found in each image.
Summary
In this post, we introduced you to different ML algorithms and used the color classification XGBoost algorithm to detect corrosion. We also showed you how to train and host ML models using Step Functions and SageMaker. We discussed the pros and cons of different ML and deep learning methods and why a color classification method might be more effective. Finally, we showed how you can integrate ML into a web application that allows you to train and deploy a model and perform inference on images. Learn more about Amazon SageMaker and try these solutions out yourself! If you have any comments or questions, let us know in the comments below!
About the Authors
Aravind Kodandaramaiah is a Solution Builder with the AWS Global verticals solutions prototyping team, helping global customers realize the “art of the possibility” using AWS to solve challenging business problems. He is an avid Machine learning enthusiast and focusses on building end-to-end solutions on AWS.
Mehdi E. Far is a Sr Machine Learning Specialist SA at Manufacturing and Industrial Global and Strategic Accounts organization. He helps customers build Machine Learning and Cloud solutions for their challenging problems.