DEV Community: Darya Petrashka

[Part 2] Your first steps in Computer Vision on AWS: training a custom CNN model

Darya Petrashka — Fri, 30 Oct 2026 18:03:21 +0000

This is the second part of the series "Your first steps in Computer Vision on AWS". If you are just starting, this tutorial will guide you step by step from the initial dataset to a deployed app.

You can read the first part on ASL dataset + preprocessing.

Why training on CPU would take ages

While we used a simple CPU SageMaker notebook instance to work with the data, for training we would need a GPU-powered instance.
A CPU is designed for complex sequential tasks. Training a CNN requires performing millions of simple matrix multiplications and convolutions simultaneously.
A GPU contains thousands of smaller, simpler cores designed to execute thousands of calculations at the exact same time, offering massive parallelism.

As an analogy, you can picture a CPU as a powerful supercomputer which can perform most complex calculations (and it will answer '42' 😂). A GPU in this case would be a fleet of calculators, each performing simple parallel operations.

As you can see on the screenshot, one epoch can take 1.5 hours (while we would need 20-25 epochs):

📖 An epoch in machine learning is one complete pass of the entire training dataset through a model.

Let's create a GPU-powered SageMaker notebook instance

Let's create a SageMaker notebook instance.

The AWS ml.g5.xlarge SageMaker instance (and the corresponding EC2 g5.xlarge instance) has 1 NVIDIA A10G Tensor Core GPU with 24 GiB of VRAM (video memory).

Pricing: ml.g5.xlarge is not as cheap as ml.t3.medium. The exact price can vary depending on the region (e.g., for Frankfurt it is $1.258 per hour); see this page for on-demand pricing reference.

⚠️ Don't forget to stop and terminate your instance once the data is processed and uploaded to S3.

Why CNN model?

Before we get into model training, let's stop for a moment to discuss what a CNN model is and why we selected it.

📖 A Convolutional Neural Network (CNN) is designed specifically to process and understand visual data. In simple terms, it uses filters/kernels to look at small pieces of the image, detecting simple shapes like edges or lines. Then, it uses pooling to reduce the image size while retaining the most useful information. Simple shapes are combined into more complex features like wheels, eyes, etc. Finally, the model decides what the picture is ("car", "person", etc.).

Using a CNN for image classification is a good starting point: the model is lightweight (compared to fully connected neural networks), but still quite performant.

We use different types of layers, stacked together, to build the CNN architecture. As the input, each image has a resolution of 200×200 pixels: raw and filtered RGB images will have 3 channels (200, 200, 3), edge images will have 1 channel (200, 200, 1).

Convolutional Layer: applies small, learnable filter matrices (kernels) across input data to extract local visual patterns.
Pooling: each 2×2 pooling layer reduces the image size, e.g. 200 → 100.
Global Average Pooling: converts the final 25×25×128 feature maps into 128 values.
Dense layer: 128 neurons combine the extracted features to make the final decision.
Dropout: randomly turns off 50% of the dense-layer neurons to prevent overfitting.

Finally, the output, where 29 neurons will represent the 29 classes. Softmax converts their outputs into probabilities, and the class with the highest probability is the prediction.

Let's show the model architecture:

In our model, the first convolutional layer learns simple features (e.g., edges); the second learns combinations of those features (e.g., finger shapes), while the third learns more complex hand/sign patterns. The number of filters increases (32 → 64 → 128), so the network can learn more types of features.

You can also see that the model will have 113,501 parameters, whose values will change during training.

📖 A parameter in a CNN is an internal, learnable variable (specifically, weights and biases) that the model automatically adjusts and optimizes during training through backpropagation.

Copy the image data to the instance

Once the SageMaker notebook instance is ready, you can Open Jupyter / Open JupyterLab.

Upload the Raw_images_training.ipynb Jupyter notebook from the GitHub repo.

Run cell by cell.

A useful command to use before any training starts: !nvidia-smi. It would show attached GPUs, temperatures, memory usage, power, and active processes. For example:

⚠️ Don't forget to replace the placeholder and put your S3 bucket name:

BUCKET = "YOUR_BUCKET"

This cell copies the preprocessed data from S3 to the instance. You only need to run it once and then check that the data has been copied successfully.

!aws s3 sync s3://YOUR-BUCKET/raw/asl_alphabet_train/ /home/ec2-user/SageMaker/asl_alphabet_train/ --quiet
!aws s3 sync s3://YOUR-BUCKET/processed/ /home/ec2-user/SageMaker/asl_preprocessed/  --quiet

Let's train 3 CNN models

⚠️ Remember we had 3 versions of data: raw, Gaussian-filtered and Canny edge? Well, you can use this Gaussian_filtered_training.ipynb notebook to train the CNN with Gaussian-filtered images; and this Canny_edges_training.ipynb notebook to train the CNN with Canny edge images.
They don't differ much. I created three separate notebooks mainly to keep the cell output histories separate. If for you it is more comfortable to use a single notebook, feel free to do it. The only thing you would need to change is the REPRESENTATION variable. Set it to raw, filtered, or edges depending on the image version.

In a nutshell, training the CNN model follows this process:
image → prediction → compare with correct answer → calculate error → adjust weights → repeat.

What each notebook does (high-level):

Creates train/validation/test dataframes
Designs and compiles the CNN
Trains the CNN from scratch
Evaluates on the held-out test set
Saves the model and uploads it to S3

Train/validation/test dataframes

⚠️ Note: In some sources, the final held-out dataset is called 'validation'.
Here, we use the validation set to evaluate model performance after each epoch.
The final held-out dataset is called 'test' (we will do the final metric evaluation against it).

We created and recorded the dataset split in the previous part. We saved it in a CSV file, which we now use to retrieve the corresponding image paths.

Compile the network

We compile the designed CNN model using this code snippet:

model.compile(
    optimizer=tf.keras.optimizers.Adam(
        learning_rate=0.001
    ),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=[
        tf.keras.metrics.SparseCategoricalAccuracy(
            name="accuracy"
        )
    ]
)

Adam optimizer is a popular optimization algorithm used to train deep learning models. SparseCategoricalCrossentropy is a loss function used for multi-class classification problems where the true labels are provided as integers. Finally, for the metric, we are using SparseCategoricalAccuracy, an evaluation metric used in multi-class classification models to measure how often model predictions match integer-encoded target labels.

📖 A loss function in deep learning is a mathematical formula that measures the difference between what a neural network predicts and the actual ground truth label.

Model training

We train the model for 25 EPOCHS. It would take only several minutes to fully train the CNN:

history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=EPOCHS,
    callbacks=callbacks,
    verbose=1
)

We will save both best model and final model.

❓ Why isn't the final model always the best model?
The final model represents the state of your model's weights after the last training epoch has finished. The best model is the state of your model weights from the epoch that achieved the optimal score (lowest validation loss or highest validation accuracy) during training. For saving the best model, we are using ModelCheckpoint with save_best_only=True.

Once training is finished, it is useful to plot how was the accuracy changes across training epochs. It was increasing, which is a good sign.

The same goes for the loss. It was decreasing, which indicates that the model's predictions were becoming more accurate according to the loss function.

Model evaluation

We are evaluating the best model on the held-out test dataset with:

test_loss, test_accuracy = model.evaluate(
    test_ds,
    verbose=1
)

The evaluation results on the test dataset are very good, with an accuracy of 99.34%:

Upload models to S3

We are saving the final model, best model, and training history to S3.
After running all the cells in all three notebooks (one for each dataset version), your bucket should contain a new models/ directory with the following structure:

s3://YOUR-BUCKET-NAME/

models/
├── asl_cnn_raw_best.keras
├── asl_cnn_raw_final.keras
├── training_history_raw.csv
├── asl_cnn_filtered_best.keras
├── asl_cnn_filtered_final.keras
├── training_history_filtered.csv
├── asl_cnn_edges_best.keras
├── asl_cnn_edges_final.keras
└── training_history_edges.csv

Which model is the best?

After running the notebook for 3 dataset versions (raw, Gaussian-filtered and Canny edge), it is interesting to find out which data resulted in the best model performance.

Dataset Representation	Loss	Accuracy
Raw RGB	0.0324	99.34%
Canny Edges	0.1291	95.51%
Gaussian Filtered	0.2972	90.11%

It turns out that the optimal performance (highest accuracy, lowest loss) was achieved using raw RGB images. One possible reason is that raw RGB images retain rich color information, gradients, and skin texture. Gaussian filtering may blur high-frequency finger boundaries, while Canny edge detection may discard useful internal hand details.

Conclusion

In this part, we used three dataset versions to train CNN models from scratch. The best performance was achieved using raw RGB images.

We will keep three best models (asl_cnn_raw_best.keras, asl_cnn_filtered_best.keras, asl_cnn_edges_best.keras) in S3 for now. In the next part, we will deploy these models to use in an ASL prediction app. Stay tuned!

[Part 1] Your first steps in Computer Vision on AWS: ASL dataset + preprocessing

Darya Petrashka — Fri, 23 Oct 2026 11:37:58 +0000

This is the first part of the series "Your first steps in Computer Vision on AWS". If you are just starting, this tutorial will guide you step by step from the initial dataset to a deployed app.

Problem

Computer vision (CV) can help us to solve many problems. Sign Language Recognition (SLR) addresses the communication barrier between Deaf and Hard of Hearing (DHH) individuals and hearing non-signers. Our system should provide an automated character transcription without requiring human interpreters.

Fact: Currently, more than 1.5 billion people (nearly 20% of the global population) live with hearing loss; 430 million of them have disabling hearing loss. [Source: World Health Organization]

The core purpose of CV in this domain is to transform high-dimensional, unstructured visual data (RGB images) into structured categories.

Photo by Assad Tanoli on Unsplash

Dataset

The ASL Alphabet dataset (Kaggle) comprises 87,000 training images and 29 test images. Images are 200x200 pixels and in 3-channel RGB format. The dataset has 29 classes: 26 English letters (A-Z) and 3 control signs (SPACE, DELETE, NOTHING). As you can see, it is perfectly balanced: 3,000 images per class in the training set.

One possible limitation is that images were captured under controlled, repeatable environments. They have static, isolated hand postures. We will see in later parts how we can address and potentially overcome such limitations.

Which computer vision task type to select?

Nice overview of CV task types is provided by IBM. Potentially, we can consider the following task types:

Image Classification: Categorizes an entire input image into a pre-defined class.
Object Detection: Localizes target objects with spatial bounding boxes while simultaneously predicting class labels.
Semantic/Instance Segmentation: Assigns class labels to individual pixels, creating fine-grained boundary masks.

For our given dataset, the most sense would be to do image classification: the task requires distinguishing among 29 discrete hand shape classes from pre-cropped images.

❓ Why not object detection?
Hand regions are already centered within the frame, making bounding box detection redundant.

❓ Why not semantic/ instance segmentation?
It has high annotation cost and computational latency, the images are not annotated for this task.

Uploading to S3

After downloading the zipped archive from Kaggle, you will need to upload it to S3.

One way is to use the management console. But with such amount of files, it could take more than a day!

Much better option would be to use AWS CLI. (How to install/update AWS CLI?)

Then run the commands to configure the appropriate concurrency (considering you have the default profile):

aws configure set default.s3.max_concurrent_requests 50

(Maximum number of parallel requests allowed at once)

aws configure set default.s3.max_queue_size 10000

(Maximum number of tasks allowed in the transfer queue)

aws configure set default.s3.multipart_threshold 64MB

(File size threshold before switching to a multipart transfer)

Unzip the downloaded archive. To copy the files:

cd archive/asl_alphabet_train
aws s3 sync ./asl_alphabet_train s3://your-bucket/raw/asl_alphabet_train/

plaintext

So your data in the bucket is organized in the following way:

s3://YOUR-BUCKET-NAME/

raw/
└── asl_alphabet_train/
    ├── A/
    ├── B/
    └── ...

markdown

⚠️ Note: if any file failed to be uploaded, use this command to find which one:

aws s3 sync ./asl_alphabet_train s3://your-bucket/raw/asl_alphabet_train/ --dryrun

Because aws s3 sync compares your source and destination, the --dryrun output will print a list of only the files that have not been copied yet.

Create SageMaker notebook instance

Next, we need some compute to preprocess our data. One of the ways to do it on AWS is to create a SageMaker notebook instance.

Since we are not training any model yet (only processing 200x200 images one at a time), a bare CPU instance with additional disk space would be enough.

The ml.t3.medium general-purpose instance provides 2 vCPUs and 4 GiB of internal RAM. Because we are going to store the original dataset and its 2 preprocessed copies on the disk, we will need to add a 30-40 GB EBS volume.

I created an ml.t3.medium instance with a 50 GB EBS volume:

Pricing: t3.medium is one of the cheapest options. The exact price can vary depending on the region; see this page for on-demand pricing reference.

⚠️ Don't forget to stop and terminate your instance once the data is processed and uploaded to S3.

Let's preprocess our data

Once the notebook instance is ready, you can Open Jupyter / Open JupyterLab.

Upload the data_preprocessing.ipynb Jupyter notebook from the GitHub repo.

Run cell by cell. You might need to restart the Kernel after running pip install of libraries. (first cell)

⚠️ Don't forget to replace the placeholder and put your S3 bucket name:

BUCKET = "YOUR-BUCKET-NAME"

What it does (high-level):

Downloads the data from S3
Creates the train/validation/test split
Separately applies Gaussian filtering and Canny edge detection to each image
Uploads the preprocessed images to S3

Why do we need to preprocess data?

Gaussian filtering subtly softens the image, preserving color while smoothing high-frequency noise.
In our code, it is achieved using a simple function from the OpenCV package:

    filtered = cv2.GaussianBlur(
        image,
        GAUSSIAN_KERNEL,
        sigmaX=GAUSSIAN_SIGMA
    )

We are using (5, 5) as GAUSSIAN_KERNEL and 1.0 as GAUSSIAN_SIGMA. Adjust these values to regulate the amount of smoothing.

Learn more about Gaussian blurring.

Canny edge detection isolates the high-contrast skeletal boundaries of hand postures and finger configurations while discarding background textures and skin illumination gradients.
In our code, it is achieved in 2 steps. First, we convert the image to grayscale:

    gray = cv2.cvtColor(
        image,
        cv2.COLOR_BGR2GRAY
    )

Then, we use a simple function from the OpenCV package:

    edges = cv2.Canny(
        gray,
        threshold1=CANNY_LOW,
        threshold2=CANNY_HIGH
    )

We specified 100 and 200 as CANNY_LOW and CANNY_HIGH thresholds. These values help to decide which faint edges are real and which are just random noise, ensuring that true object boundaries stay connected without breaking up.

Learn more about Canny Edge Detection.

Here is an example of what a letter ' B ' would look like in a raw image, Gaussian-filtered image, and Canny edge image:

Preprocessed data and upload:

The split ratio is 70% for train, 15% for validation, and 15% for held-out test.

Our split sizes:

train 60,900 images
validation 13,050 images
test 13,050 images

⚠️ Note: In some sources, the final held-out dataset is called 'validation'.
Here, we are using validation set for the model training/adjusting during multiple epochs.
The final held-out dataset is called 'test' (we will do the final metric evaluation against it).

Instead of physically moving raw data to separate folders during split, we use the CSV file to track which file corresponds to which split set.
This file maps every image to its three representations.

The file contains several columns: 'split', 'label', 'original_path', 'filtered_path', 'edge_path'.
Our code in the following part will read file paths from the CSV and take the corresponding file from the required split.

Here is what this CSV file looks like (truncated):

After running all the notebook cells, the data is uploaded to S3. Your bucket should have a new processed/ directory:

s3://YOUR-BUCKET-NAME/

processed/
├── filtered/
│   ├── train/
│   ├── validation/
│   └── test/
│
├── edges/
│   ├── train/
│   ├── validation/
│   └── test/
│
└── manifest.csv

Again, the full code in Jupyter notebook is available in the GitHub repo.

Conclusion

In this part, we uploaded the ASL dataset to S3 and created a SageMaker notebook instance. By running the Jupyter notebook, we applied Gaussian filtering and Canny edge detection processing to raw images. Finally, we uploaded processed images to S3.

We will keep all 3 image versions to compare which image representation would give the best model performance. In the next part, we will train a CNN from scratch. Stay tuned!

Community Builders – Christmas Edition

Darya Petrashka — Tue, 20 Dec 2022 07:07:00 +0000

What surprises you most about the community builders program?

It is a world-wide global program! I meet here a lot of people from different cultures, countries, backgrounds. But what unites us is the passion to AWS, tech. And we always can find a common language!

What’s your background and your experience with AWS?

I started my exiting AWS journey last April, first I got hands-on with Lambda, S3, SageMaker (since I am a Data Scientist). Then when I was preparing to Machine Learning certification, I discovered services like Athena, Glue, Kinesis, etc. Thanks to the program, I got Data Analytics certified. Now I am building the project based on Lex, Polly, Lambda, S3.
And this is a non-stop learning, very fascinating!

What’s the biggest benefit you see from the program?

I would say that these are the possibilities that the program provides. The program's benefits and content are made wisely, so you have a cool infrastructure to grow technically. With credits you can build whatever you want, with sessions and cloud academy courses you have resources to learn, if you are stuck, you have a community of people willing to help. Finally, you can share your knowledge with other people!

What’s the next swag item that you would like to get?

A backpack or a T-shirt.

What are you eating for dinner today? Share the recipe!

My dinner is stupid simple: I just blender an apple, a banana, a tangerine, a carrot and some parsley (or spinach) into a smoothie.

Is there anything else you would like to say about the community builders program in 2022?

It's hard to express in words how happy I am to be a part of this awesome program! Thanks a lot! I am really looking forward to the next year!