Machine Learning with TensorFlow on Google Cloud

Learn linear regression, modeling the relationship between a dependent variable and independent variables with a regression line, predicting house price from size using mean squared error and gradient descent.

Learn how logistic regression uses the sigmoid function to model binary class probabilities, connect them to the log odds, and estimate parameters via maximum likelihood.

Explore how neural networks learn to recognize patterns, comparing brain computation with computers, and train models on datasets like fashion mnist to classify grayscale images into ten categories.

Explore the perceptron, the first artificial neuron with binary inputs and outputs, driven by weighted sums and a threshold that yields 0 or 1, paving the way for sigmoid neurons.

Explore how a simple perceptron uses three binary features: blue color, sleeve length, and cotton fabric; weights and a threshold decide purchases, illustrating learning versus programming.

Extend the perceptron from binary to real-valued inputs, keeping weights, threshold, and bias, and explore the simple step activation function that outputs zero or one at zero.

Learn how the sigmoid activation function, also known as the logistic function, replaces the step function to yield a smooth sigmoid neuron output between 0 and 1 for real-valued inputs.

Apply linear regression to forecast store revenue using five features: location type, city type, marketing investment, nearby population, and household income, based on data from about 1000 stores.

Learn to build a linear regression model using TensorFlow and Keras, including data import, encoding categorical features, normalization, training, evaluation, and prediction.

Predict telecom churn with a logistic regression model using a 6000+ customer dataset, including tenure, monthly charges, total charges, and features like phone service, contract, paperless billing, and payment method.

Build a logistic regression model in TensorFlow with a single sigmoid neuron, using Google Colab, getdummies preprocessing, standard scaler, and a train-test split, then evaluate churn at 0.5.

Stack perceptrons in parallel to produce multiple outputs from the same inputs, such as locating x and y coordinates in an image, and use sequential stacking for non linear classifications.

Discover neural networks, their layer architecture (input, hidden, output), and the forward feed process that enables deep learning to model input–output relationships.

Learn how neural networks learn with sigmoid neurons, weights, and biases to compute Z and apply the sigmoid activation, propagating through hidden and output layers to fit target values.

Use gradient descent to minimize error by iteratively updating random weights and bias through forward and backward propagation, until no further improvement is possible, enabling fast training with many features.

Explore how gradient descent iteratively finds a function’s minimum by moving along the slope from a random start, selecting the steepest descent until no further decrease.

Explore how gradient descent minimizes cross-entropy loss in neural networks for classification by updating weights and biases through backpropagation, with learning rate controlling step size.

Learn why activation functions bound outputs and introduced non-linearity in neural networks. Explore common types—step, sigmoid, tanh, and relu—and how they apply to hidden vs output layers.

Understand multiclass classification and why it needs more than two classes. Keep one output neuron per class (shirts, trousers, ties, socks) and apply softmax to produce sum-to-one probabilities.

compare gradient descent, stochastic gradient descent, and mini-batch gradient descent, and learn how update frequency and convergence differ based on full, single, or batch training data.

An epoch is a pass through training data; iterations count processes within a set. Use epochs to recheck performance feeding data one by one, in mini-batches, or all at once.

Define and train deep learning models with Keras, understand its model-level focus, and learn how TensorFlow serves as the backend for low-level differentiation and matrix operations on CPU or GPU.

Build an image classifier with fashion mnist, loading 60k training and 10k test 28-by-28 grayscale images across ten categories. Use Keras to access data and map labels to class names.

Normalize image pixels by dividing by 255 to scale 0 to 1, and split data into 55,000 training, 5,000 validation, 10,000 test sets for gradient descent training.

Explore two primary ways to build and train neural networks in Keras: the sequential API for simple layer-by-layer models and the functional API for complex architectures.

Build a neural network from 28 by 28 inputs, flatten to 784, add two relu dense layers (300 and 100), and a softmax output for ten classes using Keras sequential.

Compile the multi-level perceptron with sparse categorical cross entropy loss, SGD optimizer, and accuracy metric; fit on train and validation data, monitor epochs, history, and convergence.

Evaluate the model on the test set to obtain loss and accuracy, then predict probabilities and final labels for unseen data with predict and argmax.

Build and train a regression model with Keras on California housing dataset, using eight features, standardization, two dense layers of 30 neurons, and mean squared error to predict house prices.

Explore constructing complex neural networks with the Keras functional API, combining inputs, dense layers, and a wide and deep architecture via concatenate to learn both deep and simple patterns.

Learn how to save and load Keras models with checkpoints in Google Colab and Drive, using callbacks like save best only and early stopping to optimize training.

Explore the building blocks of convolutional neural networks and how grouping pixels into features helps CNNs outperform traditional networks in image and speech recognition.

Demonstrate how a convolutional layer processes an input image with a receptive field window, a five cross five window, to extract lower-level features and build higher-level representations.

Learn stride in CNNs, shifting the convolution window to shape receptive field overlap, with stride 2 and 4 illustrating how stride affects overlap and the upper layer size.

Explore how stride and padding affect coverage in CNNs, comparing valid padding that ignores border pixels with same padding that adds blank pixels to preserve the receptive field.

Explore how a 5x5 filter in a convolutional layer converts 25 pixels into a single value by weighted sums, with the network learning the filter weights during training.

Demonstrates how convolutional filters extract features into feature maps, highlighting vertical and horizontal filters and the progression to multi-map convolutional layers and channels.

Explore how convolutional neural networks process images with channels, distinguishing grayscale single-channel inputs from color images with red, green, and blue channels, each pixel valued 0–255.

Demonstrate how a colored image is built from three rgb channels by packing r, g, b values into Excel cells as pixels; observe how combining channels forms colors and images.

Learn how pooling layers in CNNs reduce computation, memory usage, and parameters by aggregating inputs with max or average pooling, with no weights to train.

Build a cnn model for fashion mnist with ten categories by preprocessing: reshape 28x28 grayscale images to 4d, normalize by 255, and split 55k train 5k validation before training.

Build a cnn for 28 by 28 grayscale images with 3x3 convolutions, pooling, and dense layers, producing a 10-class softmax output trained by sparse categorical cross-entropy with sgd.

Train a CNN model on the training data with 30 epochs and 64 batch size, monitor training and validation loss and accuracy, and evaluate on test data.

Pooling reduces trainable parameters and training time in the cnn: about 1.6 million parameters with pooling vs 6.4 million without, and similar accuracy.

Build an end-to-end binary classifier for cats and dogs using a kaggle subset of 4000 images, training a four-layer CNN with data augmentation to reach over 80% accuracy.

Create a cnn model for a cats and dogs dataset, preprocessing jpeg images by resizing to 150 by 150 and normalizing to 0–1 with keras image data generator.

Build and train a four-layer cnn on 150x150 rgb images with max pooling, a 512-neuron dense layer, and sigmoid output for two classes, using a training generator.

Observe the model's overfitting: training accuracy at 87–88% outpaces validation around 72–74%, prompting data augmentation with zoom, shear, and rotation before retraining and saving the CNN model.

Address overfitting by applying image pre-processing and a dropout layer, then expand training data with data augmentation (rotation, shifts, zoom, horizontal flip) via Keras flow from directory.

Design a sequential cnn with four conv layers and max pooling, using relu activations and 50% dropout to curb overfitting, enhanced by rotation, width/height shift, and horizontal flip data augmentation.

You have reached final milestone and completed course, placing you among the top 5%. Download your certificate from your registered email id or site once all lectures show a tick.