Gain insights into image classification with PyTorch. Learn about data preprocessing, model training, fine-tuning, and deploying models using ONNX for real-world applications.

Introduction to PyTorch image classification-01.png

wfngenv.tar.gz

wfngenv

terminalenv

PyTorch is a machine learning framework used in a wide array of popular applications, including Tesla’s Autopilot and Pyro, Uber’s probabilistic modeling engine.

This course is an introduction to image classification using PyTorch’s computer vision models for training and tuning your own model. You’ll start with the fundamental concepts of applying machine learning and its applications to image classification before exploring the process of training your AI model. You’ll prepare data for intake by the computer vision model with image pre-processing, set up pipelines for training your model, and fine-tune the variables to improve predictive performance. You’ll finish by deploying the image classification model by converting to ONNX format and serving it via REST API.

By the end of this course, you’ll be able to build and deploy your own image classification models from scratch.

Getting Started with Image Classification with PyTorch

# Introduction to image preprocessing
Image processing is an important part of a computer vision project. This lesson will cover two important tools that help load and preprocess images.

First, we’ll review loading images with the **Python Imaging Library (PIL)**. Second, we’ll review image transformations with the **torchvision** framework.


# Python Imaging Library (PIL)
The Python Imaging Library (PIL)  is a useful library for image processing because it comes with the following features:
* It has extensive file format support.
* It has efficient internal representation. 
* It has powerful image-processing functions.

It’s widely considered to be a must-have image-processing tool for Python developers.


## Load an image
We can easily load an image via PIL using the `open` function:



from PIL import Image

img = Image.open("test.png")

It returns an `Image` object, and each instance has the following attributes:
* `filename`(`str`): This is the filename or path of the source file. If the input for `open` is a file-like object, it will return an empty string.
* `format`(`str`): This is the file format of the source file.
* `mode`(`str`): This is the pixel format used by the image. The most commonly used modes are `1`, `L`, `RGB`, or `CMYK`.
* `size`(`Tuple`): This is the size of the image represented as a 2-tuple (width, height).
* `width`(`int`): This is the width of an image in pixels.
* `height`(`int`): This is the height of an image in pixels.
* `palette` (`PIL.ImagePalette.ImagePalette`): This is the color palette table for the image.
* `info`(`dict`): This is the data associated with the image. The data has no effect when saving the image.
* `is_animated`(`bool`): This is an attribute that checks if the loaded image has more than one frame.
* `n_frames`(`int`): This is the number of frames for the loaded image. It’s only applicable to animated images.

Once we call the `open` function, we can check the underlying attributes by entering the following:


Learn to load images using the PIL package and perform transformations on images with torchvision. 

Introduction

Basic Concepts

Augmentation

Loss

Training

Model Conversion

Deployment

Appendix

Conclusion

Load and Preprocess Images

Introduction to image preprocessing

Python Imaging Library (PIL)

Load an image