Ready to learn the fundamentals of TensorFlow and deep learning with Python? Well, you’ve come to the right place.

After this two-part code-first introduction, you’ll have written 100s of lines of TensorFlow code and have hands-on experience with two important problems in machine learning: regression (predicting a number) and classification (predicting if something is one thing or another).

Open a Google Colab (if you’re not sure what this is, you’ll find out soon) window and get ready to code along.

Get all of the code/materials on GitHub - https://www.github.com/mrdbourke/tens…

TensorFlow Python documentation - https://www.tensorflow.org/api_docs/p…

## 1: Learn the fundamentals of TensorFlow and Deep Learning with Python (code-first introduction) Part 1

Timestamps:
0:00​ - Intro/hello/how to approach this video
1:50​ - MODULE 0 START (TensorFlow/deep learning fundamentals)
1:53​ - [Keynote] 1. What is deep learning?
6:31​ - [Keynote] 2. Why use deep learning?
16:10​ - [Keynote] 3. What are neural networks?
26:33​ - [Keynote] 4. What is deep learning actually used for?
35:10​ - [Keynote] 5. What is and why use TensorFlow?
43:05​ - [Keynote] 6. What is a tensor?
46:40​ - [Keynote] 7. What we’re going to cover
51:12​ - [Keynote] 8. How to approach this course
56:45​ - 9. Creating our first tensors with TensorFlow
1:15:32​ - 10. Creating tensors with tf Variable
1:22:40​ - 11. Creating random tensors
1:32:20​ - 12. Shuffling the order of tensors
1:42:00​ - 13. Creating tensors from NumPy arrays
1:53:57​ - 14. Getting information from our tensors
2:05:52​ - 15. Indexing and expanding tensors
2:18:27​ - 16. Manipulating tensors with basic operations
2:24:00​ - 17. Matrix multiplication part 1
2:35:55​ - 18. Matrix multiplication part 2
2:49:25​ - 19. Matrix multiplication part 3
2:59:27​ - 20. Changing the datatype of tensors
3:06:24​ - 21. Aggregating tensors
3:16:14​ - 22. Tensor troubleshooting
3:22:27​ - 23. Find the positional min and max of a tensor
3:31:56​ - 24. Squeezing a tensor
3:34:57​ - 25. One-hot encoding tensors
3:40:44​ - 26. Trying out more tensor math operations
3:45:31​ - 27. Using TensorFlow with NumPy
3:51:14​ - MODULE 1 START (neural network regression)
3:51:25​ - [Keynote] 28. Intro to neural network regression with TensorFlow
3:58:57​ - [Keynote] 29. Inputs and outputs of a regression model
4:07:55​ - [Keynote] 30. Architecture of a neural network regression model
4:15:51​ - 31. Creating sample regression data
4:28:39​ - 32. Steps in modelling with TensorFlow
4:48:53​ - 33. Steps in improving a model part 1
4:54:56​ - 34. Steps in improving a model part 2
5:04:22​ - 35. Steps in improving a model part 3
5:16:55​ - 36. Evaluating a model part 1 (“visualize, visualize, visualize”)
5:24:20​ - 37. Evaluating a model part 2 (the 3 datasets)
5:35:22​ - 38. Evaluating a model part 3 (model summary)
5:52:39​ - 39. Evaluating a model part 4 (visualizing layers)
5:59:56​ - 40. Evaluating a model part 5 (visualizing predictions)
6:09:11​ - 41. Evaluating a model part 6 (regression evaluation metrics)
6:17:19​ - 42. Evaluating a regression model part 7 (MAE)
6:23:10​ - 43. Evaluating a regression model part 8 (MSE)
6:26:29​ - 44. Modelling experiments part 1 (start with a simple model)
6:40:19​ - 45. Modelling experiments part 2 (increasing complexity)
6:51:49​ - 46. Comparing and tracking experiments
7:02:08​ - 47. Saving a model
7:28:07​ - 50. Putting together what we’ve learned 1 (preparing a dataset)
7:41:38​ - 51. Putting together what we’ve learned 2 (building a regression model)
7:55:01​ - 52. Putting together what we’ve learned 3 (improving our regression model)
8:10:45​ - [Code] 53. Preprocessing data 1 (concepts)
8:20:21​ - [Code] 54. Preprocessing data 2 (normalizing data)
8:31:17​ - [Code] 55. Preprocessing data 3 (fitting a model on normalized data)
8:38:57​ - MODULE 2 START (neural network classification)
8:39:07​ - [Keynote] 56. Introduction to neural network classification with TensorFlow
8:47:31​ - [Keynote] 57. Classification inputs and outputs
8:54:08​ - [Keynote] 58. Classification input and output tensor shapes
9:00:31​ - [Keynote] 59. Typical architecture of a classification model
9:10:08​ - 60. Creating and viewing classification data to model
9:21:39​ - 61. Checking the input and output shapes of our classification data
9:26:17​ - 62. Building a not very good classification model
9:38:28​ - 63. Trying to improve our not very good classification model
9:47:42​ - 64. Creating a function to visualize our model’s not so good predictions
10:02:50​ - 65. Making our poor classification model work for a regression dataset

## 2: Learn the fundamentals of TensorFlow and Deep Learning with Python (code-first introduction) Part 2

This part continues right where part one left off so get that Google Colab window open and get ready to write plenty more TensorFlow code.

Timestamps:
0:00​ - Intro/hello/have you watched part 1? If not, you should
0:55​ - 66. Non-linearity part 1 (straight lines and non-straight lines)
10:33​ - 67. Non-linearity part 2 (building our first neural network with a non-linear activation function)
16:21​ - 68. Non-linearity part 3 (upgrading our non-linear model with more layers)
26:40​ - 69. Non-linearity part 4 (modelling our non-linear data)
35:18​ - 70. Non-linearity part 5 (reproducing our non-linear functions from scratch)
49:45​ - 71. Getting great results in less time by tweaking the learning rate
1:04:32​ - 72. Using the history object to plot a model’s loss curves
1:10:43​ - 73. Using callbacks to find a model’s ideal learning rate
1:28:16​ - 74. Training and evaluating a model with an ideal learning rate
1:37:37​ - [Keynote] 75. Introducing more classification methods
1:43:41​ - 76. Finding the accuracy of our model
1:47:59​ - 77. Creating our first confusion matrix
1:56:27​ - 78. Making our confusion matrix prettier
2:10:28​ - 79. Multi-class classification part 1 (preparing data)
2:21:04​ - 80. Multi-class classification part 2 (becoming one with the data)
2:28:13​ - 81. Multi-class classification part 3 (building a multi-class model)
2:43:52​ - 82. Multi-class classification part 4 (improving our multi-class model)
2:56:35​ - 83. Multi-class classification part 5 (normalised vs non-normalised)
3:00:48​ - 84. Multi-class classification part 6 (finding the ideal learning rate)
3:11:27​ - 85. Multi-class classification part 7 (evaluating our model)
3:25:34​ - 86. Multi-class classification part 8 (creating a confusion matrix)
3:30:00​ - 87. Multi-class classification part 9 (visualising random samples)
3:40:42​ - 88. What patterns is our model learning?

#tensorflow #python

31.80 GEEK