TensorFlow and the Google Cloud ML Engine for Deep Learning

Install TensorFlow in a virtual environment to isolate Python packages, choose a Python version (2.7 or 3.x), and follow the platform-specific installation instructions on the course site.

Install and use a browser-based Python notebook to execute code line by line, add markdown comments, and host notebooks in a virtual environment for easy sharing.

Set up your Google Cloud Platform account, claim the $300 free trial, create a top-level project to organize resources, and learn to launch a VM instance in Compute Engine.

Master using Google Cloud Shell as a browser-based command line to access resources with gcloud, manage projects and billing, and run scripts without local software installation.

Explore how google cloud datalab notebooks run in a vm container, enabling interactive jupyter coding and data access, with service accounts and connections via gcloud, cloud shell, or local docker.

Connect to a datalab VM on Google Cloud, enable the Compute Engine API, and use Cloud Shell to launch Jupiter notebooks for TensorFlow-based deep learning workflows.

Understand how machine learning learns from data to change its behavior, enabling classification, regression, clustering, and rule extraction in deep learning with TensorFlow on Google Cloud ML Engine.

Explore representation learning and deep learning, showing how neural networks automatically learn feature representations from images and videos, reducing reliance on hand-crafted rules and human experts.

Explore neural networks as powerful deep learning models for representation learning, where multiple layers and neurons automatically learn relevant features, with CNNs for image processing.

Explore the open source TensorFlow framework, a dataflow-graph based library for neural networks that enables distributed training and production deployment with Python APIs and visualization tools.

Build a simple TensorFlow computation graph using constants and operations such as add, subtract, and square. Execute the graph with a session and visualize the results in tensorboard.

This lecture explains computation graphs as the abstraction for deep learning, where edges are data items and nodes are computations in a directed acyclic graph enabling parallel and lazy evaluation.

Explore tensors by defining their rank, shape, and data type, and learn how building versus running a computation graph enables lazy, distributed evaluation.

Explore tensors in a TensorFlow lab by defining vector constants, building a computation graph, and executing it with a session to compute sums, products, and averages.

Explore linear regression as the simplest machine learning problem, fitting a line y = a + b x with least squares to model the relationship between x and y.

Discover how placeholders provide inputs and how variables hold trainable parameters in a linear regression model, updated by gradient descent to minimize mean squared error.

Learn how placeholders use a feed dictionary to feed input data and drive computations in a TensorFlow graph through a running session.

Explore how to initialize and update variables in a machine learning workflow, running in a session to compute Y = W X + B, with global and selective variable initializers.

Learn linear regression with made-up data using TensorFlow, define w and b, use placeholders, minimize mean squared error with gradient descent, and train a simple model to fit four points.

Discover how convolutional neural networks power image processing and recognition, using pixels as features, and compare with recurrent neural networks for sequence data.

Represent images as tensors by choosing grayscale or color formats such as RGB or CMYK, determining the needed channels, and shaping four-dimensional tensors with height, width, and channels.

Learn how a coordinator and a queue-based input enable multi-threaded image reading and resizing for deep learning, preparing images as a four-dimensional tensor for batch processing in TensorFlow.

Explore image preprocessing with resizing to uniform dimensions, a 50 percent central crop, and an upside-down flip, then combine images with a stack into a single tensor for deep learning.

Introduce the MNIST handwritten digit dataset, featuring 60,000 labeled training images, each 28x28 grayscale, used for supervised digit recognition.

Explore supervised versus unsupervised learning, and how the k-nearest neighbors algorithm uses labeled training data and distance measures to identify handwritten digits and find the closest data point.

Explore one-hot notation and Manhattan distance alongside Euclidean distance, and apply them in a k-nearest neighbors digit recognition workflow using a pixel-based dataset.

Demonstrates steps in the k-nearest neighbors implementation for 28x28 grayscale images, flattening to a 784-element vector, computing L1 distances to 5,000 training digits to identify the nearest neighbor.

Explore a lab on k-nearest neighbors using a 28 by 28 handwritten digit dataset, converting images to 784-pixel vectors, applying l1 distance, one-hot labels, and a computation graph.

Define learning as reverse engineering input-output functions through neural networks, from single neurons to deep layered structures. Explain how training tunes weights and biases to improve classification and regression.

Neural networks build complex behavior from simple neurons and their interconnections. Each neuron performs an affine transformation followed by an activation function, with weights and biases learned through backpropagation.

Explore how a single neuron uses an affine transformation to learn linear regression, minimizing residuals and fitting a regression line by adjusting weights and a bias.

Explain how xor cannot be learned with a single neuron, requiring a three-neuron, two-layer boullier feedforward neural network with nonlinear activation like rectified linear unit to learn the xor function.

Explore how a neural network learns to reproduce the xor function by adjusting weights and biases through training with an optimizer, cost function, training data, and activation functions.

Learn to access and prepare Yahoo Finance historical data for regression models, sourcing S&P 500, Nasdaq, and oil fund data with monthly frequency.

Explore building linear regression models from a baseline Python implementation to a flow-based setup, using mean squared error and gradient descent to train with three features.

Set up a baseline linear regression in Python to model how changes in the S&P 500 index affect Google's stock price, using data from Yahoo Finance and scikit-learn.

Learn to build end-to-end linear regression with a computation graph, placeholders, and a gradient descent optimizer, minimizing mean squared error to fit W and B.

Implement a multiple regression model in TensorFlow by combining Nasdaq and oil returns, setting up X variables, placeholders, and bias, and tuning batch size and optimizer.

Explore logistic regression as an alternative to linear regression for binary outcomes, using activation function and cross-entropy loss to model how actions influence probabilities, including handling categorical and continuous variables.

Learn how logistic regression implements linear classification by fitting constants to data and producing label probabilities, using the highest probability for binary or multi-class outputs.

Develop a logistic regression baseline in Python to predict Google stock movement (up or down) from monthly returns by converting data to binary labels, including intercept handling, and evaluating accuracy.

Explore how logistic regression relates to linear regression by modeling probabilities with log-odds and an s-curve, and why residuals are not normally distributed.

Explore how softmax activation enables logistic regression for binary and multiclass classification, including cross-entropy loss, probability vectors, and neural network representations.

Learn how logistic regression switches from mean square error to cross entropy, harnessing softmax outputs and one-hot encoding, and apply argmax to predict true labels.

Implement logistic regression in a TensorFlow lab, using softmax activation with cross-entropy loss and gradient descent to predict stock direction from S&P 500 returns, achieving 72.8% accuracy.

Estimates provide a high level API for linear and logistic regression by outsourcing computation. They use composition over inheritance to manage input functions and feature vectors in neural networks.

Explore linear regression with estimators, using a single feature from the S&P 500, an input function, and a chosen optimizer to train with batch size and steps.

Use estimators to perform logistic regression, applying linear regression features and two-dimensional inputs, while the estimator handles one-hot labels, training via input functions and batch size, and evaluating accuracy.

Explore traditional machine learning and how input features shape model predictions, then compare to neural networks, training versus prediction phases, and feature-driven classifications.

Contrast traditional machine learning with deep learning, showing how representation-based models automate feature selection using neural networks. Examine deep neural networks, layers, and neurons that extract features for classification.

Examine how a single neuron functions as a mathematical unit, taking inputs with weights and a bias, applying an activation function to produce outputs for the next layer.

Explore how activation functions, including soft max and Velu, pair with affine transformations to enable nonlinear learning and probabilistic binary and multi-class classification.

Explore how neural networks train using gradient descent and back propagation, minimizing mean square error by forward pass to compute outputs and loss, then backward to adjust weights and biases.

Explore a deep neural network for regression of automobile prices, using features like make, fuel type, and doors, with dataset cleaning, training, validation, and production splits, and price scaling.

Learn to build a TensorFlow DNN regression model for car price prediction, designing numeric and categorical feature columns, embeddings, and input functions, and tune hyperparameters to reduce RMSE.

Discover how hyperparameters govern neural network training—from batch size and epochs to optimizers and activation functions—and how to tune them for best validation performance.

Learn why deep networks suffer vanishing and exploding gradients during backpropagation and how to mitigate them with proper initialization (Xavier), gradient clipping, batch normalization, and non-saturating activation functions like elu.

Examine the bias-variance trade-off in regression and neural networks, recognizing how high bias or high variance leads to underfitting or overfitting and affects training and test performance.

Train a deep neural network classifier on the iris dataset using sepal and petal measurements to distinguish three iris types, achieving about 93–97% accuracy on test data.