Automated Inspection with Computer Vision.png

AICV_jupyterOpenCV.tar.gz

load_image

annotation

color_spaces

thresholding

smoothing

masking

jup_smooth

morphology

blob_detection

jup_fiducials

edge_detection

jupyter_masking_edge_detection

corner_detection

jupyter_corner_detection

homographies

jup_homographies

topography

jup_topography

tensor_manipulation

neural_network_building_blocks

training_neural_network

jup_train_nn

cnn_building_blocks

cnn_for_classification

pretrained_classification_cnn

jup_train_classification_cnn

transfer_learning

jup_finetune_classification_CNN

cnn_for_object_detection

jup_pretrained_object_detection

cnn_for_semantic_segmentation

jup_pretrained_semantic_segmentation

annotation_formats

spa_train_mlp

prj_jup_create_train_mlp_classification

Computer vision is essential for developers who wish to learn practical skills, e.g., in industrial manufacturing, automated inspection of products is crucial for quality assurance.

In this course, you’ll apply computer vision and machine learning to analyze images for automated inspection. You’ll start by learning image I/O operations, thresholding, smoothing, and masking. You’ll learn feature detection using template matching and morphology. You’ll use the Sobel and Canny Edge Detectors, Harris Corner Detector, and Hough transform. You’ll learn about 2D transformations, including perspective and affine transformation, and 3D-to-2D projections. You’ll perform topography with a laser line to inspect the 3D shape of an object. Lastly, you’ll train convolutional neural networks for object detection and image segmentation and annotate datasets using CVAT.

By the end of this course, you will have the skills to build inspection systems for industrial applications using computer vision and machine learning.

Automated Inspection with Computer Vision

```Python
conv = torch.nn.Conv2d(in_channels=32, out_channels=3, kernel_size=(3, 3))
```

```Python
conv = torch.nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(5, 5))
```

```Python
conv = torch.nn.Conv2d(in_channels=3, out_channels=64, kernel_size=(3, 3))
```

```Python
conv = torch.nn.Conv2d(in_channels=1, out_channels=3, kernel_size=(5, 5))
```

**(Select all that apply.)** The shape of the input tensor to a convolution layer is `(N, 3, 32, 32)`. Which construction call would be suitable for this convolution layer?

(Select all that apply.) The shape of the input tensor to a convolution layer is <code>(N, 3, 32, 32)</code>. Which construction call would be suitable for this convolution layer?

**(True or False)** A convolution layer outputs an image that can be interpreted as the map of some feature's presence in the input image.

(True or False) A convolution layer outputs an image that can be interpreted as the map of some feature’s presence in the input image.

Half of the pixels in the height and width plane will be zeroed, and the other half will be boosted by a factor of two.

Half of the observations in the mini-batch will be zeroed, and the other half will be boosted by a factor of two.

Half of the input tensor channels will be replaced with random numbers in the $[0, 1]$ range.

Half of the input tensor channels will be zeroed, and the other half will be boosted by a factor of two.

Which statement describes the behavior of a ```torch.nn.Dropout2d``` layer in training mode, with the parameter ```p=0.5```?

Which statement describes the behavior of a <code>torch.nn.Dropout2d</code> layer in training mode, with the parameter <code>p=0.5</code>?

Consider a ```torch.nn.MaxPool2d``` layer with ```kernel_size=(2, 2)``` (all other parameters set to default values). If the shape of its input tensor is `(16, 32, 28, 28)`, what is the shape of its output tensor?

Consider a <code>torch.nn.MaxPool2d</code> layer with <code>kernel_size=(2, 2)</code> (all other parameters set to default values). If the shape of its input tensor is <code>(16, 32, 28, 28)</code>, what is the shape of its output tensor?

What is the shape of the input tensor to a classification CNN for a mini-batch of 16 monochrome images with ```height=32, width=32```?

What is the shape of the input tensor to a classification CNN for a mini-batch of 16 monochrome images with <code>height=32, width=32</code>?

Consider a CNN that classifies images among 10 classes. What is the shape of the output tensor, for a mini-batch of 64 color images whose dimensions are `(32, 32)`? 

Consider a CNN that classifies images among 10 classes. What is the shape of the output tensor, for a mini-batch of 64 color images whose dimensions are <code>(32, 32)</code>?

The predicted class index is the index of the vector entry having the highest value.

The predicted class index is the index of the only non-zero entry in the vector.

The predicted class index is the weighted average of the vector indices, weighted by the vector values.

The predicted class index is the index of the median value in the vector.

A classification CNN outputs a vector of 12 numbers for each image in a mini-batch. How can we get the predicted class of a given image?

A classification CNN outputs a vector of 12 numbers for each image in a mini-batch. How can we get the predicted class of a given image?

The index corresponding to the highest value in the vector will be returned.

The maximum value in the vector will be returned.

The vector will be converted to a probability distribution, i.e., all values will be positive, with a sum of 1.0.

The vector will be converted to a one-hot vector, i.e., a single entry in the vector will be non-zero.

A classification CNN outputs a vector of real numbers (positive and negative) for each image in the mini-batch. What is the effect of passing the output tensor into a ```torch.softmax()``` function?

A classification CNN outputs a vector of real numbers (positive and negative) for each image in the mini-batch. What is the effect of passing the output tensor into a <code>torch.softmax()</code> function?

CNN Building Blocks and CNN for Classification

CNN Building Blocks and CNN for Classification

Test your knowledge of CNN building blocks, and how to use CNN for a classification task.

Introduction

Getting Started with Images

Image I/O and Annotations

Color Spaces and Thresholding

Convert Color Spaces, Threshold

Smoothing and Masking

Detection of Features

Image Registration

3D Vision

Getting Started with Neural Networks

Convolutional Neural Networks

Project: Create and Train a CNN for Classification

Object Detection and Semantic Segmentation

Dataset Annotation

Final Remarks

Quiz: CNN Building Blocks and CNN for Classification