Convolutional Neural Networks with TensorFlow in Python

Explore how image kernels act as filters in image processing, covering blur, sharpen, and edge detection. See how they bridge simple neural networks to convolutional neural networks.

discover how image transformations such as blur, sharpen, and edge detection are constructed from kernels that average and compare neighboring pixels to emphasize high-contrast edges.

Explore how kernels, represented as matrices, encode image transformations like blur, sharpening, and edge detection, and see why convolutional neural networks rely on these kernels to preserve structure.

Learn how sliding a kernel over an image produces a new image via convolution, clarify flipped versus non-flipped kernels, cross-correlation terminology, and edge handling challenges.

Learn how to handle image edges when applying kernels in convolutional neural networks, including zero padding, mirror padding, and omitting border pixels, with notes on information loss and pooling.

Explore why convolutional neural networks rely on learnable kernels and filters to transform images, preserve spatial structure, and reduce parameters, then build a CNN on MNIST to boost image recognition.

Explore how convolutional layers use kernels to detect features like arcs and acute angles, producing feature maps that summarize images, with many kernels creating hundreds of maps, including color depth.

Explore pooling in convolutional neural networks, focusing on 2x2 max pooling with stride 2 to reduce dimensionality, speed training, and reduce overfitting by preserving key features.

Trace how input dimensions shape cnn training as a 32×32×3 image becomes 28×28×10 after the first convolution and 14×14×10 after pooling, then 12×12×6 with a 3×3 kernel.

Learn how to fight overfitting in convolutional neural networks by using early stopping, monitoring validation loss and accuracy, and splitting data into training and validation sets.

Explore how optimizers minimize the loss in neural networks, covering gradient descent, learning rate, momentum, Adagrad, RMSprop, and Adam, and preview convolutional neural networks on the Mnist dataset.

Set up the Python-based environment for deep learning by installing Anaconda, Python 3, Jupyter Notebook, and the necessary packages, and learn the coding environment used in this course.

Explore why Python and Jupyter power data science, highlighting open source, cross-platform, high-level language benefits, IPython notebooks and kernels that run in a browser.

Install and set up the Anaconda distribution to include Python, Jupyter Notebook, and data science packages, choosing Python 3 and 64-bit on Windows, Mac, or Linux.

Explore the Jupiter dashboard to rename, move, and delete folders, manage files with checkboxes, upload notebooks, and create new IPython notebooks (.ipynb).

Explore how to use Jupyter dashboards by editing code and markdown cells, running with Ctrl-Enter or Shift-Enter, and switching between input and output fields.

Anaconda bundles numpy, pandas, matplotlib, itertools, and sklearn, plus TensorFlow 2 and TensorFlow datasets. Install via the Anaconda prompt with pip commands to set up the course.

Build and train a convolutional neural network on the MNIST dataset to classify handwritten digits using TensorFlow 2 in Python, Jupyter notebook, including data preprocessing and validation for early stopping.

Outline a simple convolutional neural network architecture for Mnist, with two convolutional and two max-pool layers, a flatten step, and a dense softmax classifier for ten digits.

Preprocess the mnist data by downloading with tfds, scaling pixels to 0–1, shuffling and splitting into train and validation sets, and batching for efficient neural network training.

Define and compile a cnn in TensorFlow 2 using a sequential architecture of conv, max pool, flatten, and dense layers, then train with early stopping to reach high validation accuracy.

Test the trained convolutional neural network on the mnist test set to report loss and accuracy, and analyze predictions with probability bars.

Explore TensorBoard with the MNIST CNN by logging training metrics, visualizing scalars and graphs, and enabling hyperparameter tuning and deeper insights through distributions and histograms.

Explore how to use the confusion matrix to evaluate classification models, visualize results with TensorBoard, and interpret per-class performance to improve TensorFlow image classifiers.

Tune CNN hyperparameters with Tensorboard by testing kernel sizes and optimizers on MNIST, logging results, and visualizing accuracy across combinations using hparams, parallel coordinates, and scatter plots.

Explore how convolutional layers form CNNs and implement a practical MNIST example, then learn to tackle real-world datasets by optimizing CNNs with regularization, dropout, and data augmentation.

Explore how regularization fights overfitting by reducing model capacity, adding a regularization term to the loss, and encouraging sparse or near-zero weights.

L2 regularization adds the L2 norm to the loss to shrink non-essential weights, linking weight decay, and outlining differences with SGD and adaptive optimizers.

Dropout randomly drops neurons during training to reduce overfitting and encourage independent features. TensorFlow scales outputs and applies dropout mainly to fully connected layers with rates 0.1 to 0.5.

Explore data augmentation to expand a model's capabilities by transforming training data, including mirroring, rotating, translating, color adjustments, noise, and more, beyond the original dataset.

Explore practical challenges in image classification with CNNs, building an automatic labeling system for fashion items to streamline product tagging and search.

Train a cnn to recognize and label fashion items using a dataset of 16,000 images, categorized into glasses, trousers, and shoes with multiple sublabels, and return labels for each image.

Convert images to numpy arrays for TensorFlow by resizing from 300 by 400 to 90 by 120 with Pillow, then convert to a numpy array for model input.

Train multiple models with hyperparameters and log results using TensorBoard. Visualize accuracy and confusion matrices, and automate parameter sweeps with a callback for the primary classification network.

Label fashion images into glasses and sunglasses, trousers and jeans, or shoes with the primary classification network, scaling images to 0-1 using NumPy datasets and TensorFlow.

Develop a compact two-convolutional layer CNN with a three-class output (glasses, sunglasses, trousers/jeans, shoes) and tune the first filter size and count via grid search.

Complete the primary classification by training a convolutional neural network with two convolutional layers, two max pool layers, and a dense output. Tune filter sizes, log results with tensorboard today.

Explore two approaches to label trousers or jeans by gender and type: separate mini-task models or a single four-class model, with hierarchical options and tradeoffs; lecture continues with combining labels.

Combine labels into four classes—male trousers, female trousers, male jeans, female jeans—and train a convolutional neural network in TensorFlow to assign one label per image.

Develop hierarchical convolutional neural networks to classify trousers and jeans by gender, then by type, and compare stacking versus separate gender-specific networks with performance around 80–90%.

Compare convolutional neural networks with TensorFlow for trousers and jeans, scoring gender and type predictions on a test set using a combined versus hierarchical labeling approach.

Apply L2 regularization and dropout to the network, analyze hyperparameter effects and random noise on accuracy, and introduce data augmentation as the next topic.

Augment the shoes dataset by mirroring images with numpy flip to capture left-to-right and right-to-left orientations, preserving labels while expanding from 5,000 to 10,000 images.

Explore why neural networks resemble a black box, examine failures from biased training data and adversarial inputs, and underscore the importance of understanding model behavior to improve reliability.