PyTorch for Deep Learning and Computer Vision

Discover the deep learning projects for this course on GitHub. Clone the repositories in the project folder to follow along with PyTorch for deep learning and computer vision.

Explore PyTorch deep learning and computer vision through hands-on projects, from linear regression to ten-class image classification using convolutional networks, transfer learning, and style transfer.

Explore tensors in PyTorch, learn their data structure and GPU-accelerated computation, and recognize their role as a fundamental prerequisite before neural network implementation.

Learn to create and manipulate one dimensional tensors in PyTorch, including indexing, slicing, reshaping, and converting between numpy arrays and tensors for deep learning and computer vision.

Explore basic vector operations on tensors in PyTorch, including elementwise addition, multiplication, dot product, linspace, and plotting with Matplotlib, recognizing tensors as fundamental data structures for neural networks.

Explore two dimensional tensors as matrices representing grayscale images with 0 to 255 intensities, create tensors with arange, reshape using view into 3x3 and 3x3x2 forms, and indexing and slicing.

Master three-dimensional tensor indexing in PyTorch, locating element ten and slicing blocks, rows, and columns with exclusive stop indices.

Master matrix multiplication in PyTorch for deep learning and computer vision by multiplying matrices A and B, exploring dimensions, conditions, and practical tensor operations with torch matmul.

Explore derivatives and gradients in PyTorch by computing a polynomial's derivative at a point, using backward on a tensor with requires_grad, and extend to partial derivatives for multivariable functions.

Finish the intro to tensor section and train a linear model by adjusting its parameters until they fit a set of data points in PyTorch.

Explore linear model training with loss functions and gradient descent, and learn how learning rates guide fitting data points, with future use in visual imagery and sophisticated style transfer techniques.

Discover supervised learning with a linear model in PyTorch, train using gradient descent to fit data, and make predictions for new inputs using the forward function.

Learn how to initialize and use PyTorch's linear class to build a simple one-input one-output model, set a seed for reproducible weights and bias, and train via gradient descent.

Build a custom LR class in PyTorch by inheriting from nn.Module and implementing a forward method for a simple linear model. Initialize parameters, print them, and prepare for training.

Create a noisy 2d dataset with torch.rand, plot X and Y coordinates, and prepare a linear model in PyTorch for training via gradient descent.

Explore how a loss function guides fitting a line to data by adjusting the weight of a zero-bias model to minimize prediction error.

Learn gradient descent to train linear models by updating weights in the negative gradient direction with a learning rate, minimizing the mean squared error.

Explore mean squared error in linear regression with bias and errors between actual and predicted values. Update weight and bias by gradient descent, with PyTorch handling the math.

Train a PyTorch model by using the built-in mean squared loss and stochastic gradient descent with a 0.01 learning rate across 100 epochs to minimize the loss.

Build and train a linear model to fit data, then prepare to classify two discrete classes, as you progress toward more complex neural networks in this PyTorch course.

Explore the perceptron as the simplest neural network. Learn how back propagation, weights, and gradient descent enable neural networks to detect complex patterns.

Explore how PyTorch enables building and training neural networks, from the perceptron to a multilayer perceptron, and learn how deep learning models extract patterns from observational data.

Create a linearly separable dataset with Sklearn make_blobs, visualize it with matplotlib, and convert to PyTorch tensors to train a perceptron using gradient descent.

Explore how a perceptron uses labeled data to classify two classes based on age and glucose levels, minimizing cross-entropy with gradient descent and converting outputs via sigmoid activation.

Implement a simple perceptron model in PyTorch by defining an nn.Module subclass, initializing with input and output sizes, applying a sigmoid, and plotting initial parameters with data.

train a two-input neural model on binary data using binary cross entropy loss and stochastic gradient descent in PyTorch, updating weights through forward predictions, backpropagation, and 1000 epochs.

Train a neural model on labeled data to predict class probabilities for inputs with features x1 and x2, then classify them as class one or zero using a 0.5 threshold.

Build on perceptrons and a small-error linear model trained from labeled data to make predictions on new inputs, then transition to training much deeper neural networks in the next section.

Explore how deep neural networks overcome linear model limitations for complex data by using perceptron basics and non-linear decision boundaries.

Explore how combining two perceptrons with weights and bias creates a nonlinear boundary via a sigmoid activation, illustrating how linear models form complex neural networks.

Explore how neural networks combine linear models into nonlinear predictions using perceptrons and sigmoid activations. Learn how deep architectures stack hidden layers and weights to classify complex data.

execute a feedforward pass through an input layer, hidden layers, and an output layer, computing weighted sums and sigmoid activations to produce predictions while gradient descent tunes weights and biases.

Train deep neural networks by performing feedforward predictions, computing cross-entropy error, and backpropagating the loss to update weights with gradient descent across all layers.

Apply backpropagation to train neural networks by minimizing cross-entropy with gradient descent, updating weights through a hidden layer using sigmoid activation to form non-linear boundaries for classification.

Train a deep neural network in PyTorch using a two-circle dataset with 500 points, a hidden layer of 4 nodes, and the Adam optimizer, learning rate 0.1, for binary classification.

Learn to visualize a trained neural network’s decision boundary by building a 50 by 50 grid, computing predictions with the model, and plotting a contour against the data.

Explore extending binary image classification to multi-class with PyTorch, building on deep neural networks to classify images into more than two classes.

Explore the Mnist dataset and build deep neural networks to fit image data, validate performance on new data with holdout sets, and deploy a trained model to predict web images.

Explore the MNIST dataset of handwritten digits and build a deep neural network with 784 input nodes and 10 output classes, using softmax for multi-class classification.

Train a neural network to classify handwritten digits using a training dataset and a test set. Explore generalization, underfitting, overfitting, and regularization alongside validation sets to improve real world performance.

Learn to load and transform Mnist images in PyTorch using Torchvision, applying compose transforms to convert to tensors and normalize, and set up a training data loader.

Implement a two hidden-layer neural network in PyTorch for MNIST, using relu and cross-entropy loss, trained with Adam, monitoring loss and accuracy and tuning learning rate.

Train and validate a neural network on the MNIST dataset using a validation loader to track validation loss and accuracy across epochs to observe generalization.

Compare image classification using deep neural networks and the high capacity they require with the computing power they demand, and present convolutional neural networks as a more efficient alternative.

Learn how convolutional neural networks leverage the grid-like structure of grayscale mnist images, using pooling to reduce parameters and combat overfitting while enabling scalable image classification.

Explore the convolutional layer as the core building block of convolutional networks, learning features with small kernels, a stride, and feature maps, and apply relu activation to promote translational invariance.

Explore how convolutional neural networks detect image features with learnable kernels that form feature maps for patterns like X, forward slash, and backslash, then apply relu and prepare for pooling.

Pooling reduces the dimensionality of convolutional feature maps with a 2x2 max-pooling kernel and stride of two, lowering computations and overfitting while preserving key features and scale invariance.

Learn how convolutional layers extract features and pooling reduces them, then a fully connected network classifies grayscale breast lesion images as malignant or benign using backpropagation and gradient descent.

Implement a PyTorch convolutional neural network to classify MNIST images using the Lynette model with two conv layers, pooling, and two fully connected layers.

Train a convolutional neural network in PyTorch on MNIST data using GPUs in Google Colab, monitor loss and accuracy, and apply dropout to reduce overfitting.

Explore the cifar-10 dataset, a color 32×32 image set with three channels across ten classes, featuring 50,000 training and 10,000 validation images and varied poses compared to mnist.

Apply LeNet to the CIFAR-10 dataset in PyTorch, loading 32 by 32 color images and mapping class labels. Note overfitting and accuracy, with plans for hyperparameter tuning and data transformations.

Explore hyperparameter tuning for image classification: adjust learning rate with the atom optimizer, deepen the network with extra convolutional layers, and use padding and smaller kernels to reduce overfitting.

Use data augmentation with random horizontal flip, rotation, affine transforms, and color jitter to augment training data, reduce overfitting, and improve validation accuracy on the Cifar ten dataset in PyTorch.

Utilize transfer learning with pre-trained models like Alexnet and Vgg 16, freezing feature extractors while retraining the classifier on a small bees and ants dataset for efficient accuracy.

Apply transfer learning with PyTorch by using pre-trained AlexNet and VGG16, freezing feature extractors, and adapting the final layer for ants and bees dataset.