High-level overview of how Jupyter notebooks, Pandas, Numpy, Matplotlib, Seaborn, and scikit-learn play a role in exploratory data analysis and preparing your training data for machine learning.

We'll walk through a Jupyter notebook that explores, cleans, and normalizes training data to build a real machine learning model to predict if mammogram results are benign or malignant.

We'll cover the differences between numerical, categorical, and ordinal data.

Topics covered include normal distributions, Poisson distributions, binomial distributions, Bernoulli distributions, and the difference between probability density functions and probability mass functions.

We'll talk about how time series data consists of separate signals from trends, seasonality, and noise.

A quick overview of Amazon Athena, and how it can be used to query your unstructured, structured, or semi-structured data in S3 in a serverless setting.

High-level features of QuickSight, Amazon's data visualization product, including its new machine learning capabilities.

There are lots of visualization choices; bar and line graphs, heat maps, tree maps, pivot tables, and much more - all of which are offered by QuickSight. Let's talk about how to decide which kind of graph is most appropriate for illustrating different aspects of your data.

How Amazon EMR works, including how a Hadoop cluster's architecture works. What is HDFS and EMRFS? What are different usage modes for EMR? How does it scale? What can it do?

How Apache Spark has supplanted MapReduce; the architecture of Spark, and its capabilities, including Spark Streaming, MLLib, GraphX, and Spark SQL. How Spark integrates with AWS and Kinesis.

Zeppelin notebooks run on your EMR cluster to control Spark, but EMR notebooks can run outside of your cluster and control the provisioning of the cluster itself, too. We'll also discuss the security features available with EMR, and how to choose an instance type for the master, core, and task nodes of your cluster.

We'll introduce what the world of feature engineering is all about, and why it is so important to getting good results from your machine learning models. And, we'll dive into the "curse of dimensionality," and why more features usually isn't better.

A big part of feature engineering is dealing with missing data. We'll discuss various approaches, including mean imputation, dropping, and using machine learning for imputation including KNN, deep learning, and regression methods such as MICE.

Training models with highly unbalanced data sets - such as in fraud detection, where very few observations are actual fraud, is a big problem. We'll talk about ways to address this from a feature engineering standpoint, including oversampling, undersampling, and SMOTE.

We'll introduce how to compute variance and standard deviation, and how to identify outliers as a function of standard deviation and in box-and-whisker plots. We'll also give a shout-out to Amazon's Random Cut Forest algorithm.

We'll round out our tour of feature engineering with a discussion of binning numerical data, transforming data to create new features to discover sub-linear and super-linear patterns, one-hot encoding, scaling and normalization, and the importance of shuffling your training data.

Humans can be the most important tool for creating missing data, especially labels. We'll talk about how Amazon SageMaker Ground Truth manages human labeling tasks and optimizes them, as well as using unsupervised techniques such as Rekognition and Comprehend to fabricate features and labels from existing data.

As TF-IDF (Term Frequency - Inverse Document Frequency) may be new to you, we'll start by reviewing how TF-IDF works and how it fits into a search engine solution.

We'll walk through the process of creating an JupyterLab PySpark Notebook within an EMR Workspace, backed by an EMR EC2 cluster, within a EMR Studio environment. We'll use this notebook to pre-process real Wikipedia data, build a TF/IDF model around it, and use it for actual search.

We'll cover the biological inspiration of deep learning, and how this translates to artificial neural networks.

We'll dive deep into activation functions, including linear, step, logistic / sigmoid, hyperbolic tangent, ReLU, Leaky ReLu, PReLu, Swish, and more - and how to choose between them.

Convolutional Neural Networks, or CNN's, are inspired by the human visual cortex and are useful for object recognition and other tasks. We'll cover how they work, some popular CNN architectures such as ResNet, and how CNN's are built in Keras and Tensorflow.

Recurrent Neural Networks, or RNN's, are well suited for problems involving sequences of data, such as predicting markets or machine translation. We'll cover how RNN's work, some popular variants included LSTM and GRU, and different applications of them.

Hyperparameter tuning of deep neural networks is a complex subject. We'll talk about how deep neural nets are trained with gradient descent, and how your choice of learning rate and batch size affects your training. Sometimes it's counter-intuitive!

Deep neural networks are prone to overfitting. We'll cover some simple regularization techniques to combat this, including dropout, early stopping, and simply using a smaller network.

A brief discussion of EMR's built-in support for deep learning with Apache MXNet, deep learning AMI's for EC2, and EC2 instance types appropriate for deep learning.

What is L1 and L2 regularization, how do they differ, and how do you choose between them?

What is the vanishing gradient problem, and what can be done to combat it? Also, what's gradient checking?

How to read and interpret various kinds of confusion matrices, allowing you to distinguish true and false positives and negatives from an overall accuracy metric.

We'll cover various ways to measure classifiers, including precision, recall, ROC curves, F1, RMSE, and AUC. We'll discuss how to interpret these metrics, and how to decide which one is relevant to the problem you're trying to solve.

Two ensemble methods are bagging and boosting, and they solve very different problems.

The heart of AWS's machine learning offering is SageMaker. We'll cover what it does and its architecture at a high level, and how it's used together with ECR and S3.

The Linear Learner algorithm in SageMaker is a robust means of regression or classification in systems that can be described in a linear manner.

The XGBoost algorithm is winning a lot of Kaggle competitions lately; if you care about accuracy, it's a great choice. SageMaker includes the open source XGBoost algorithm; we'll cover what it does, how to use it, and how to tune it.

The Seq2Seq algorithm is commonly used for machine translation tasks. It is implemented as an RNN or CNN with attention under the hood.

DeepAR is a powerful RNN-based model for extrapolating time series, and sets of related time series, into the future.

BlazingText can operate in supervised mode to assign labels to sentences, or in Word2Vec mode to build an embedding layer of related words.

Object2Vec is a general mechanism for building embeddings of objects based on arbitrary pairs of data.

The Object Detection algorithm identifies objects in images, together with their bounding boxes.

Image Classification is used to identify what objects are in an image, but without data on where those objects are within the image.

Semantic Segmentation identifies objects within images at a per-pixel level, using segmentation masks.

Random Cut Forest is Amazon's algorithm for anomaly detection in a series of data.

Neural Topic Modeling is a neural network-based technique for clustering documents into a specific number of topics, in an unsupervised manner.

LDA is another topic modeling technique in SageMaker that does not rely on neural networks, but just looks at commonalities in the terms contained by documents.

KNN is a simple method for classification or regression by just analyzing the K observations most similar to a new observation.

Factorization Machines are generally used for classification or regression of sparse data, for example in recommender systems.

IP Insights uses deep learning to identify anomalous behavior from IP addresses in your web log data.

We'll review how reinforcement learning (specifically Q-Learning and Markov Decision Processes) works with an example of an AI-driven video game, and cover how reinforcement learning works within SageMaker.

SageMaker has the ability to spin up multiple training jobs to automatically explore different hyperparameter settings, and settle on the best values to use for your deployed model. There are some important best practices to follow that we'll cover.

SageMaker integrates with Apache Spark, so you can use Spark to pre-process massive data sets, and hand off your data to SageMaker for training and deployment.

We'll cover what's new in SageMaker for 2020 - mainly SageMaker Studio, a new ML IDE on top of SageMaker Notebooks, Experiments, Debugger, Autopilot, and Model Monitor.

Amazon Comprehend is a high-level NLP (natural language processing) service, capable of identifying objects, key phrases, languages, sentiments, and syntax in arbitrary text.

Translate is AWS's high-level service for machine translation.

Transcribe is AWS's high-level service for speech-to-text.

Polly is the AWS service for text-to-speech. There are many ways to control it that we'll talk about.

Rekognition is the AWS service for computer vision. It's capable of object detection, facial recognition and analysis, celebrity detection, text extraction, and more.

Forecast is an AWS service for time-series analysis. It can select from multiple time series prediction models to find the best one for your particular data sets.

Lex is billed as the heart of Alexa; it's really a chatbot-building service.

We'll briefly mention Amazon Textract, DeepRacer, Lookout, and Monitron.

We'll cover the newest high-level ML services for 2020: AWS DeepComposer, Amazon Fraud Detector, Amazon CodeGuru, Contact Lens for Amazon Connect, Amazon Kendra, and Amazon Augmented AI (A2I)

Some examples of assembling AWS's high-level machine learning services into complete applications.

We'll set up a deep learning AMI on EC2, and connect to Jupyter Notebook from our desktop, and import our deep learning CNN model to experiment with.

We'll walk through preparing the input data for our CNN and building our initial model for it in Tensorflow and Keras.

Next, we'll improve our model by applying dropout layers to avoid overfitting, and we'll explore the effect changing the batch size and learning rate has on our results, and why.

We'll go in depth on how SageMaker containers work and their expected format, and how production variants can be used to divide traffic between different versions of a model.

SageMaker Neo can compile some SageMaker inference images into code that may be run on embedded devices, when latency matters a lot. IoT Greengrass is what gets the code where it needs to be.

We'll review some general AWS security best practices, and the specifics of how SageMaker encrypts your data at rest and in transit using KMS.

There are some special cases when using VPC's to keep your SageMaker environment secure. We'll also cover the IAM policies relevant to SageMaker, and how to log and monitor SageMaker with CloudTrail and CloudWatch.

Some general guidelines on choosing an instance type for SageMaker training and inference, and how to use Spot instances to reduce your training costs.

Elastic Inference can accelerate deep learning inference deployments at a lower cost than deploying dedicated GPU instances. Automatic scaling can automatically add and remove inference nodes in response to load, as measured by CloudWatch. We'll also talk about ensuring your SageMaker resources are spread across multiple availability zones.

Inference Pipelines allow you to chain together multiple containers for inference.

In part one, we'll spin up a SageMaker notebook and import our CNN model developed with Keras and Tensorflow.

In part 2, we'll test our model locally on the notebook instance, and kick off a training job using SageMaker on a P3 instance.

Finally, we'll deploy our model and use it to make inferences. And, we'll use SageMaker's automatic model tuning to explore the space of hyperparameters to find the best values for our model, and deploy a new, tuned model.

Understand how the Transformer architecture evolved from earlier work with Recurrent Neural Networks, and how self-attention and attention-based neural networks allowed massive parallel training of large language models (LLMs)

Understand exactly how self-attention, masked self-attention, and multi-headed self-attention neural networks are trained and used to establish the meaning of words within their context. Also, how self-attention is a part of Transformers (such as GPT) and large language models.

Understand how the Transformer architecture for deep learning can be used for chat, Q&A, classification, named entity recognition, summarization, translation, code generation, and text generation.

Learn how GPT (GPT-2, GPT-3.5, GPT-4) works under the hood, including tokenization, token embedding, positional encoding, and stacks of Decoders consisting of masked self-attention and feed-forward neural networks (FFNN's).

In the conclusion of how GPT works, we'll focus on the output processing that happens after the final Decoder block. How this produces a new token embedding and logits that can be used to predict the next token (word) in a sequence.

Learn how fine-tuning can be applied to transformers (such as GPT) to adapt them to specific tasks, through transfer learning.

Launch a SageMaker Notebook integrated with Huggingface to explore tokenization and positional encoding components of the Transformer architecture.

See and visualize multi-headed self-attention using a SageMaker Notebook and Huggingface.

We'll illustrate importing the GPT-2 transfomer from HuggingFace into a SageMaker Notebook, and using it to generate text.

Learn how AWS is starting to incorporate generative AI with AWS Foundation Models (Jurassic-2, Claude, Stable Diffusion, Amazon Titan), and how to quickly deploy and use them with SageMaker JumpStart.

We'll load a GPT-2 Foundation Model using SageMaker JumpStart, use it, and discuss how to fine-tune it within a SageMaker Notebook.

Learn the features and pricing of Amazon Q Developer, a coding assistant powered by generative AI and AWS.