TensorFlow Developer Certificate in 2023: Zero to Mastery

Name: TensorFlow Developer Certificate in 2023: Zero to Mastery
Price: 9 USD
Availability: InStock

62h 43m 54s

English

Paid

November 22, 2024

Learn TensorFlow. Pass the TensorFlow Developer Certificate Exam. Get Hired as a TensorFlow developer. This course will take you from a TensorFlow beginner to being part of Google's Certification Network.

Learn to pass Google's official TensorFlow Developer Certificate exam (and add it to your resume)
Complete access to ALL interactive notebooks and ALL course slides as downloadable guides
Understand how to integrate Machine Learning into tools and applications
Build image recognition, object detection, text recognition algorithms with deep neural networks and convolutional neural networks
Applying Deep Learning for Time Series Forecasting
Be recognized as a top candidate for recruiters seeking TensorFlow developers
Build TensorFlow models using Computer Vision, Convolutional Neural Networks and Natural Language Processing
Increase your skills in Machine Learning and Deep Learning
Learn to build all types of Machine Learning Models using the latest TensorFlow 2
Using real-world images in different shapes and sizes to visualize the journey of an image through convolutions to understand how a computer “sees” information, plot loss and accuracy
Gain the skills you need to become a TensorFlow Certified Developer

Watch Online TensorFlow Developer Certificate in 2023: Zero to Mastery

Join premium to watch

Go to premium

#	Title	Duration
1	Course Outline	05:22
2	What is deep learning?	04:39
3	Why use deep learning?	09:39
4	What are neural networks?	10:27
5	What is deep learning already being used for?	08:37
6	What is and why use TensorFlow?	07:57
7	What is a Tensor?	03:38
8	What we're going to cover throughout the course	04:30
9	How to approach this course	05:34
10	Creating your first tensors with TensorFlow and tf.constant()	18:46
11	Creating tensors with TensorFlow and tf.Variable()	07:08
12	Creating random tensors with TensorFlow	09:41
13	Shuffling the order of tensors	09:41
14	Creating tensors from NumPy arrays	11:56
15	Getting information from your tensors (tensor attributes	11:58
16	Indexing and expanding tensors	12:34
17	Manipulating tensors with basic operations	05:35
18	Matrix multiplication with tensors part 1	11:54
19	Matrix multiplication with tensors part 2	13:30
20	Matrix multiplication with tensors part 3	10:04
21	Changing the datatype of tensors	06:56
22	Tensor aggregation (finding the min, max, mean & more)	09:50
23	Tensor troubleshooting example (updating tensor datatypes)	06:14
24	Finding the positional minimum and maximum of a tensor (argmin and argmax) (9:31)	09:32
25	Squeezing a tensor (removing all 1-dimension axes)	03:00
26	One-hot encoding tensors	05:47
27	Trying out more tensor math operations	04:48
28	Exploring TensorFlow and NumPy's compatibility	05:44
29	Making sure our tensor operations run really fast on GPUs	10:20
30	Introduction to Neural Network Regression with TensorFlow	07:34
31	Inputs and outputs of a neural network regression model	09:00
32	Anatomy and architecture of a neural network regression model	07:56
33	Creating sample regression data (so we can model it)	12:47
34	The major steps in modelling with TensorFlow	20:16
35	Steps in improving a model with TensorFlow part 1	06:03
36	Steps in improving a model with TensorFlow part 2	09:26
37	Steps in improving a model with TensorFlow part 3	12:34
38	Evaluating a TensorFlow model part 1 ("visualise, visualise, visualise")	07:25
39	Evaluating a TensorFlow model part 2 (the three datasets)	11:02
40	Evaluating a TensorFlow model part 3 (getting a model summary)	17:19
41	Evaluating a TensorFlow model part 4 (visualising a model's layers)	07:15
42	Evaluating a TensorFlow model part 5 (visualising a model's predictions)	09:17
43	Evaluating a TensorFlow model part 6 (common regression evaluation metrics)	08:06
44	Evaluating a TensorFlow regression model part 7 (mean absolute error)	05:53
45	Evaluating a TensorFlow regression model part 7 (mean square error)	03:19
46	Setting up TensorFlow modelling experiments part 1 (start with a simple model)	13:51
47	Setting up TensorFlow modelling experiments part 2 (increasing complexity)	11:30
48	Comparing and tracking your TensorFlow modelling experiments	10:21
49	How to save a TensorFlow model	08:20
50	How to load and use a saved TensorFlow model	10:16
51	(Optional) How to save and download files from Google Colab	06:19
52	Putting together what we've learned part 1 (preparing a dataset)	13:32
53	Putting together what we've learned part 2 (building a regression model)	13:21
54	Putting together what we've learned part 3 (improving our regression model)	15:48
55	Preprocessing data with feature scaling part 1 (what is feature scaling?)	09:35
56	Preprocessing data with feature scaling part 2 (normalising our data)	10:58
57	Preprocessing data with feature scaling part 3 (fitting a model on scaled data)	07:41
58	Introduction to neural network classification in TensorFlow	08:26
59	Example classification problems (and their inputs and outputs)	06:39
60	Input and output tensors of classification problems	06:22
61	Typical architecture of neural network classification models with TensorFlow	09:37
62	Creating and viewing classification data to model	11:35
63	Checking the input and output shapes of our classification data	04:39
64	Building a not very good classification model with TensorFlow	12:11
65	Trying to improve our not very good classification model	09:14
66	Creating a function to view our model's not so good predictions	15:09
67	Make our poor classification model work for a regression dataset	12:19
68	Non-linearity part 1: Straight lines and non-straight lines	09:39
69	Non-linearity part 2: Building our first neural network with non-linearity	05:48
70	Non-linearity part 3: Upgrading our non-linear model with more layers	10:19
71	Non-linearity part 4: Modelling our non-linear data once and for all	08:38
72	Non-linearity part 5: Replicating non-linear activation functions from scratch	14:27
73	Getting great results in less time by tweaking the learning rate	14:48
74	Using the TensorFlow History object to plot a model's loss curves	06:12
75	Using callbacks to find a model's ideal learning rate	17:33
76	Training and evaluating a model with an ideal learning rate	09:21
77	Introducing more classification evaluation methods	06:05
78	Finding the accuracy of our classification model	04:18
79	Creating our first confusion matrix (to see where our model is getting confused)	08:28
80	Making our confusion matrix prettier	14:01
81	Putting things together with multi-class classification part 1: Getting the data	10:38
82	Multi-class classification part 2: Becoming one with the data	07:08
83	Multi-class classification part 3: Building a multi-class classification model	15:39
84	Multi-class classification part 4: Improving performance with normalisation	12:44
85	Multi-class classification part 5: Comparing normalised and non-normalised data	04:14
86	Multi-class classification part 6: Finding the ideal learning rate	10:39
87	Multi-class classification part 7: Evaluating our model	13:17
88	Multi-class classification part 8: Creating a confusion matrix	04:27
89	Multi-class classification part 9: Visualising random model predictions	10:43
90	What "patterns" is our model learning?	15:34
91	Introduction to Computer Vision with TensorFlow	09:37
92	Introduction to Convolutional Neural Networks (CNNs) with TensorFlow	08:00
93	Downloading an image dataset for our first Food Vision model	08:28
94	Becoming One With Data	05:06
95	Becoming One With Data Part 2	12:27
96	Becoming One With Data Part 3	04:23
97	Building an end to end CNN Model	18:18
98	Using a GPU to run our CNN model 5x faster	09:18
99	Trying a non-CNN model on our image data	08:52
100	Improving our non-CNN model by adding more layers	09:53
101	Breaking our CNN model down part 1: Becoming one with the data	09:04
102	Breaking our CNN model down part 2: Preparing to load our data	11:47
103	Breaking our CNN model down part 3: Loading our data with ImageDataGenerator	09:55
104	Breaking our CNN model down part 4: Building a baseline CNN model	08:03
105	Breaking our CNN model down part 5: Looking inside a Conv2D layer	15:21
106	Breaking our CNN model down part 6: Compiling and fitting our baseline CNN	07:15
107	Breaking our CNN model down part 7: Evaluating our CNN's training curves	11:46
108	Breaking our CNN model down part 8: Reducing overfitting with Max Pooling	13:41
109	Breaking our CNN model down part 9: Reducing overfitting with data augmentation	06:53
110	Breaking our CNN model down part 10: Visualizing our augmented data	15:05
111	Breaking our CNN model down part 11: Training a CNN model on augmented data	08:50
112	Breaking our CNN model down part 12: Discovering the power of shuffling data	10:02
113	Breaking our CNN model down part 13: Exploring options to improve our model	05:22
114	Downloading a custom image to make predictions on	04:55
115	Writing a helper function to load and preprocessing custom images	10:01
116	Making a prediction on a custom image with our trained CNN	10:09
117	Multi-class CNN's part 1: Becoming one with the data	15:00
118	Multi-class CNN's part 2: Preparing our data (turning it into tensors)	06:39
119	Multi-class CNN's part 3: Building a multi-class CNN model	07:25
120	Multi-class CNN's part 4: Fitting a multi-class CNN model to the data	06:03
121	Multi-class CNN's part 5: Evaluating our multi-class CNN model (	04:52
122	Multi-class CNN's part 6: Trying to fix overfitting by removing layers	12:20
123	Multi-class CNN's part 7: Trying to fix overfitting with data augmentation	11:47
124	Multi-class CNN's part 8: Things you could do to improve your CNN model	04:24
125	Multi-class CNN's part 9: Making predictions with our model on custom images	09:23
126	Saving and loading our trained CNN model	06:22
127	What is and why use transfer learning?	10:13
128	Downloading and preparing data for our first transfer learning model	14:40
129	Introducing Callbacks in TensorFlow and making a callback to track our models	10:02
130	Exploring the TensorFlow Hub website for pretrained models	09:52
131	Building and compiling a TensorFlow Hub feature extraction model	14:01
132	Blowing our previous models out of the water with transfer learning	09:14
133	Plotting the loss curves of our ResNet feature extraction model	07:36
134	Building and training a pre-trained EfficientNet model on our data	09:43
135	Different Types of Transfer Learning	11:41
136	Comparing Our Model's Results	15:17
137	Introduction to Transfer Learning in TensorFlow Part 2: Fine-tuning	06:17
138	Importing a script full of helper functions (and saving lots of space)	07:36
139	Downloading and turning our images into a TensorFlow BatchDataset	15:39
140	Discussing the four (actually five) modelling experiments we're running	02:16
141	Comparing the TensorFlow Keras Sequential API versus the Functional API	02:35
142	Creating our first model with the TensorFlow Keras Functional API	11:39
143	Compiling and fitting our first Functional API model	10:54
144	Getting a feature vector from our trained model	13:40
145	Drilling into the concept of a feature vector (a learned representation)	03:44
146	Downloading and preparing the data for Model 1 (1 percent of training data)	09:52
147	Building a data augmentation layer to use inside our model	12:07
148	Visualising what happens when images pass through our data augmentation layer	10:56
149	Building Model 1 (with a data augmentation layer and 1% of training data)	15:56
150	Building Model 2 (with a data augmentation layer and 10% of training data)	16:38
151	Creating a ModelCheckpoint to save our model's weights during training	07:26
152	Fitting and evaluating Model 2 (and saving its weights using ModelCheckpoint)	07:15
153	Loading and comparing saved weights to our existing trained Model 2	07:18
154	Preparing Model 3 (our first fine-tuned model)	20:27
155	Fitting and evaluating Model 3 (our first fine-tuned model)	07:46
156	Comparing our model's results before and after fine-tuning	10:27
157	Downloading and preparing data for our biggest experiment yet (Model 4)	06:25
158	Preparing our final modelling experiment (Model 4)	12:01
159	Fine-tuning Model 4 on 100% of the training data and evaluating its results	10:20
160	Comparing our modelling experiment results in TensorBoard	10:47
161	How to view and delete previous TensorBoard experiments	02:05
162	Introduction to Transfer Learning Part 3: Scaling Up	06:20
163	Getting helper functions ready and downloading data to model	13:35
164	Outlining the model we're going to build and building a ModelCheckpoint callback	05:39
165	Creating a data augmentation layer to use with our model	04:40
166	Creating a headless EfficientNetB0 model with data augmentation built in	08:59
167	Fitting and evaluating our biggest transfer learning model yet	07:57
168	Unfreezing some layers in our base model to prepare for fine-tuning	11:29
169	Fine-tuning our feature extraction model and evaluating its performance	08:24
170	Saving and loading our trained model	06:26
171	Downloading a pretrained model to make and evaluate predictions with	06:35
172	Making predictions with our trained model on 25,250 test samples	12:47
173	Unravelling our test dataset for comparing ground truth labels to predictions	06:06
174	Confirming our model's predictions are in the same order as the test labels	05:18
175	Creating a confusion matrix for our model's 101 different classes	12:08
176	Evaluating every individual class in our dataset	14:17
177	Plotting our model's F1-scores for each separate class	07:37
178	Creating a function to load and prepare images for making predictions	12:09
179	Making predictions on our test images and evaluating them	16:07
180	Discussing the benefits of finding your model's most wrong predictions	06:10
181	Writing code to uncover our model's most wrong predictions	11:17
182	Plotting and visualizing the samples our model got most wrong	10:37
183	Making predictions on and plotting our own custom images	09:50
184	Introduction to Milestone Project 1: Food Vision Big™	05:45
185	Making sure we have access to the right GPU for mixed precision training	10:18
186	Getting helper functions ready	03:07
187	Introduction to TensorFlow Datasets (TFDS)	12:04
188	Exploring and becoming one with the data (Food101 from TensorFlow Datasets)	15:57
189	Creating a preprocessing function to prepare our data for modelling	15:51
190	Batching and preparing our datasets (to make them run fast)	13:48
191	Exploring what happens when we batch and prefetch our data	06:50
192	Creating modelling callbacks for our feature extraction model	07:15
193	Turning on mixed precision training with TensorFlow	10:06
194	Creating a feature extraction model capable of using mixed precision training	12:43
195	Checking to see if our model is using mixed precision training layer by layer	07:57
196	Training and evaluating a feature extraction model (Food Vision Big™)	10:20
197	Introducing your Milestone Project 1 challenge: build a model to beat DeepFood	07:48
198	Introduction to Natural Language Processing (NLP) and Sequence Problems	12:52
199	Example NLP inputs and outputs	07:23
200	The typical architecture of a Recurrent Neural Network (RNN)	09:04
201	Preparing a notebook for our first NLP with TensorFlow project	08:53
202	Becoming one with the data and visualizing a text dataset	16:42
203	Splitting data into training and validation sets	06:27
204	Converting text data to numbers using tokenisation and embeddings (overview)	09:23
205	Setting up a TensorFlow TextVectorization layer to convert text to numbers	17:11
206	Mapping the TextVectorization layer to text data and turning it into numbers	11:03
207	Creating an Embedding layer to turn tokenised text into embedding vectors	12:28
208	Discussing the various modelling experiments we're going to run	08:58
209	Model 0: Building a baseline model to try and improve upon	09:26
210	Creating a function to track and evaluate our model's results	12:15
211	Model 1: Building, fitting and evaluating our first deep model on text data	20:52
212	Visualizing our model's learned word embeddings with TensorFlow's projector tool	20:44
213	High-level overview of Recurrent Neural Networks (RNNs) + where to learn more	09:35
214	Model 2: Building, fitting and evaluating our first TensorFlow RNN model (LSTM)	18:17
215	Model 3: Building, fitting and evaluating a GRU-cell powered RNN	16:57
216	Model 4: Building, fitting and evaluating a bidirectional RNN model	19:35
217	Discussing the intuition behind Conv1D neural networks for text and sequences	19:32
218	Model 5: Building, fitting and evaluating a 1D CNN for text	09:58
219	Using TensorFlow Hub for pretrained word embeddings (transfer learning for NLP)	13:46
220	Model 6: Building, training and evaluating a transfer learning model for NLP	10:46
221	Preparing subsets of data for model 7 (same as model 6 but 10% of data)	10:53
222	Model 7: Building, training and evaluating a transfer learning model on 10% data	10:05
223	Fixing our data leakage issue with model 7 and retraining it	13:43
224	Comparing all our modelling experiments evaluation metrics	13:15
225	Uploading our model's training logs to TensorBoard and comparing them	11:15
226	Saving and loading in a trained NLP model with TensorFlow	10:26
227	Downloading a pretrained model and preparing data to investigate predictions	13:25
228	Visualizing our model's most wrong predictions	08:29
229	Making and visualizing predictions on the test dataset	08:28
230	Understanding the concept of the speed/score tradeoff	15:02
231	Introduction to Milestone Project 2: SkimLit	14:21
232	What we're going to cover in Milestone Project 2 (NLP for medical abstracts)	07:23
233	SkimLit inputs and outputs	11:03
234	Setting up our notebook for Milestone Project 2 (getting the data)	14:59
235	Visualizing examples from the dataset (becoming one with the data)	13:19
236	Writing a preprocessing function to structure our data for modelling	19:51
237	Performing visual data analysis on our preprocessed text	07:56
238	Turning our target labels into numbers (ML models require numbers)	13:16
239	Model 0: Creating, fitting and evaluating a baseline model for SkimLit	09:26
240	Preparing our data for deep sequence models	09:56
241	Creating a text vectoriser to map our tokens (text) to numbers	14:08
242	Creating a custom token embedding layer with TensorFlow	09:15
243	Creating fast loading dataset with the TensorFlow tf.data API	09:50
244	Model 1: Building, fitting and evaluating a Conv1D with token embeddings	17:22
245	Preparing a pretrained embedding layer from TensorFlow Hub for Model 2	10:54
246	Model 2: Building, fitting and evaluating a Conv1D model with token embeddings	11:31
247	Creating a character-level tokeniser with TensorFlow's TextVectorization layer	23:25
248	Creating a character-level embedding layer with tf.keras.layers.Embedding	07:45
249	Model 3: Building, fitting and evaluating a Conv1D model on character embeddings	13:46
250	Discussing how we're going to build Model 4 (character + token embeddings)	06:05
251	Model 4: Building a multi-input model (hybrid token + character embeddings)	15:37
252	Model 4: Plotting and visually exploring different data inputs	07:33
253	Crafting multi-input fast loading tf.data datasets for Model 4	08:42
254	Model 4: Building, fitting and evaluating a hybrid embedding model	13:19
255	Model 5: Adding positional embeddings via feature engineering (overview)	07:19
256	Encoding the line number feature to used with Model 5	12:26
257	Encoding the total lines feature to be used with Model 5	07:57
258	Model 5: Building the foundations of a tribrid embedding model	09:20
259	Model 5: Completing the build of a tribrid embedding model for sequences	14:09
260	Visually inspecting the architecture of our tribrid embedding model	10:26
261	Creating multi-level data input pipelines for Model 5 with the tf.data API	09:01
262	Bringing SkimLit to life!!! (fitting and evaluating Model 5)	10:36
263	Comparing the performance of all of our modelling experiments	09:37
264	Saving, loading & testing our best performing model	07:49
265	Congratulations and your challenge before heading to the next module	12:34
266	Introduction to Milestone Project 3 (BitPredict) & where you can get help	03:54
267	What is a time series problem and example forecasting problems at Uber	07:47
268	Example forecasting problems in daily life	04:53
269	What can be forecast?	07:58
270	What we're going to cover (broadly)	02:36
271	Time series forecasting inputs and outputs	08:56
272	Downloading and inspecting our Bitcoin historical dataset	14:59
273	Different kinds of time series patterns & different amounts of feature variables	07:40
274	Visualizing our Bitcoin historical data with pandas	04:53
275	Reading in our Bitcoin data with Python's CSV module	10:59
276	Creating train and test splits for time series (the wrong way)	08:38
277	Creating train and test splits for time series (the right way)	07:13
278	Creating a plotting function to visualize our time series data	07:58
279	Discussing the various modelling experiments were going to be running	09:12
280	Model 0: Making and visualizing a naive forecast model	12:17
281	Discussing some of the most common time series evaluation metrics	11:12
282	Implementing MASE with TensorFlow	09:39
283	Creating a function to evaluate our model's forecasts with various metrics	10:12
284	Discussing other non-TensorFlow kinds of time series forecasting models	05:07
285	Formatting data Part 2: Creating a function to label our windowed time series	13:02
286	Discussing the use of windows and horizons in time series data	07:51
287	Writing a preprocessing function to turn time series data into windows & labels	23:36
288	Turning our windowed time series data into training and test sets	10:02
289	Creating a modelling checkpoint callback to save our best performing model	07:26
290	Model 1: Building, compiling and fitting a deep learning model on Bitcoin data	16:59
291	Creating a function to make predictions with our trained models	14:04
292	Model 2: Building, fitting and evaluating a deep model with a larger window size-27	17:44
293	Model 3: Building, fitting and evaluating a model with a larger horizon size	13:16
294	Adjusting the evaluation function to work for predictions with larger horizons	08:35
295	Model 3: Visualizing the results	08:45
296	Comparing our modelling experiments so far and discussing autocorrelation	09:45
297	Preparing data for building a Conv1D model	13:22
298	Model 4: Building, fitting and evaluating a Conv1D model on our Bitcoin data	14:52
299	Model 5: Building, fitting and evaluating a LSTM (RNN) model on our Bitcoin data	16:06
300	Investigating how to turn our univariate time series into multivariate	13:53
301	Creating and plotting a multivariate time series with BTC price and block reward	12:13
302	Preparing our multivariate time series for a model	13:38
303	Model 6: Building, fitting and evaluating a multivariate time series model	09:26
304	Model 7: Discussing what we're going to be doing with the N-BEATS algorithm	09:40
305	Model 7: Replicating the N-BEATS basic block with TensorFlow layer subclassing	18:39
306	Model 7: Testing our N-BEATS block implementation with dummy data inputs	15:03
307	Model 7: Setting up hyperparameters for the N-BEATS algorithm	08:51
308	Model 7: Getting ready for residual connections	12:56
309	Model 7: Outlining the steps we're going to take to build the N-BEATS model	10:06
310	Model 7: Putting together the pieces of the puzzle of the N-BEATS model	22:23
311	Model 7: Plotting the N-BEATS algorithm we've created and admiring its beauty	06:47
312	Model 8: Ensemble model overview	04:44
313	Model 8: Building, compiling and fitting an ensemble of models	20:05
314	Model 8: Making and evaluating predictions with our ensemble model	16:10
315	Discussing the importance of prediction intervals in forecasting	12:57
316	Getting the upper and lower bounds of our prediction intervals	07:58
317	Plotting the prediction intervals of our ensemble model predictions	13:03
318	(Optional) Discussing the types of uncertainty in machine learning	13:42
319	Model 9: Preparing data to create a model capable of predicting into the future	08:25
320	Model 9: Building, compiling and fitting a future predictions model	05:02
321	Model 9: Discussing what's required for our model to make future predictions	08:31
322	Model 9: Creating a function to make forecasts into the future	12:09
323	Model 9: Plotting our model's future forecasts	13:10
324	Model 10: Introducing the turkey problem and making data for it	14:16
325	Model 10: Building a model to predict on turkey data (why forecasting is BS)	13:39
326	Comparing the results of all of our models and discussing where to go next	13:00
327	What is the TensorFlow Developer Certification?	05:29
328	Why the TensorFlow Developer Certification?	06:58
329	How to prepare (your brain) for the TensorFlow Developer Certification	08:15
330	How to prepare (your computer) for the TensorFlow Developer Certification	12:44
331	What to do after the TensorFlow Developer Certification exam	02:14
332	What is Machine Learning?	04:52
333	AI/Machine Learning/Data Science	06:53
334	Exercise: Machine Learning Playground	06:17
335	How Did We Get Here?	06:04
336	Exercise: YouTube Recommendation Engine	04:25
337	Types of Machine Learning	04:42
338	What Is Machine Learning? Round 2	04:45
339	Section Review	01:49
340	Section Overview	02:39
341	Introducing Our Framework	03:09
342	6 Step Machine Learning Framework	05:00
343	Types of Machine Learning Problems	10:33
344	Types of Data	04:51
345	Types of Evaluation	03:32
346	Features In Data	05:59
347	Modelling - Splitting Data	05:23
348	Modelling - Picking the Model	04:36
349	Modelling - Tuning	03:18
350	Modelling - Comparison	03:36
351	Experimentation	09:33
352	Tools We Will Use	04:01
353	Section Overview	02:28
354	Pandas Introduction	04:30
355	Series, Data Frames and CSVs	13:22
356	Describing Data with Pandas	09:49
357	Selecting and Viewing Data with Pandas	11:09
358	Selecting and Viewing Data with Pandas Part 2	13:07
359	Manipulating Data	13:57
360	Manipulating Data 2	09:57
361	Manipulating Data 3	10:13
362	How To Download The Course Assignments	02:41
363	Section Overview	07:44
364	NumPy Introduction	05:18
365	NumPy DataTypes and Attributes	14:06
366	Creating NumPy Arrays	09:23
367	NumPy Random Seed	07:18
368	Viewing Arrays and Matrices	09:36
369	Manipulating Arrays	11:32
370	Manipulating Arrays 2	09:45
371	Standard Deviation and Variance	07:11
372	Reshape and Transpose	07:27
373	Dot Product vs Element Wise	11:46
374	Exercise: Nut Butter Store Sales	03:34
375	Comparison Operators	13:05
376	Sorting Arrays	06:20
377	Turn Images Into NumPy Arrays	07:38