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…

Subscribe: https://www.youtube.com/channel/UCr8O8l5cCX85Oem1d18EezQ/featured

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:11:32 - 48. Loading a saved model

7:21:49 - 49. Saving and downloading files from Google Colab

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

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