English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 17.5 Hours | 10.0 GB

Master Machine Learning from scratch using Javascript and TensorflowJS with hands-on projects.

If you’re here, you already know the truth: Machine Learning is the future of everything.

In the coming years, there won’t be a single industry in the world untouched by Machine Learning. A transformative force, you can either choose to understand it now, or lose out on a wave of incredible change. You probably already use apps many times each day that rely upon Machine Learning techniques. So why stay in the dark any longer?

There are many courses on Machine Learning already available. I built this course to be the best introduction to the topic. No subject is left untouched, and we never leave any area in the dark. If you take this course, you will be prepared to enter and understand any sub-discipline in the world of Machine Learning.

A common question – Why Javascript? I thought ML was all about Python and R?

The answer is simple – ML with Javascript is just plain easier to learn than with Python. Although it is immensely popular, Python is an ‘expressive’ language, which is a code-word that means ‘a confusing language’. A single line of Python can contain a tremendous amount of functionality; this is great when you understand the language and the subject matter, but not so much when you’re trying to learn a brand new topic.

Besides Javascript making ML easier to understand, it also opens new horizons for apps that you can build. Rather than being limited to deploying Python code on the server for running your ML code, you can build single-page apps, or even browser extensions that run interesting algorithms, which can give you the possibility of developing a completely novel use case!

Does this course focus on algorithms, or math, or Tensorflow, or what?!?!

Let’s be honest – the vast majority of ML courses available online dance around the confusing topics. They encourage you to use pre-build algorithms and functions that do all the heavy lifting for you. Although this can lead you to quick successes, in the end it will hamper your ability to understand ML. You can only understand how to apply ML techniques if you understand the underlying algorithms.

That’s the goal of this course – I want you to understand the exact math and programming techniques that are used in the most common ML algorithms. Once you have this knowledge, you can easily pick up new algorithms on the fly, and build far more interesting projects and applications than other engineers who only understand how to hand data to a magic library.

Don’t have a background in math? That’s OK! I take special care to make sure that no lecture gets too far into ‘mathy’ topics without giving a proper introduction to what is going on.

A short list of what you will learn:

- Advanced memory profiling to enhance the performance of your algorithms
- Build apps powered by the powerful Tensorflow JS library
- Develop programs that work either in the browser or with Node JS
- Write clean, easy to understand ML code, no one-name variables or confusing functions
- Pick up the basics of Linear Algebra so you can dramatically speed up your code with matrix-based operations. (Don’t worry, I’ll make the math easy!)
- Comprehend how to twist common algorithms to fit your unique use cases
- Plot the results of your analysis using a custom-build graphing library
- Learn performance-enhancing strategies that can be applied to any type of Javascript code
- Data loading techniques, both in the browser and Node JS environments

**+ Table of Contents**

**What is Machine Learning **

1 Getting Started – How to Get Help

2 Solving Machine Learning Problems

3 A Complete Walkthrough

4 App Setup

5 Problem Outline

6 Identifying Relevant Data

7 Dataset Structures

8 Recording Observation Data

9 What Type of Problem

**Algorithm Overview**

10 How K-Nearest Neighbor Works

11 Lodash Review

12 Implementing KNN

13 Finishing KNN Implementation

14 Testing the Algorithm

15 Interpreting Bad Results

16 Test and Training Data

17 Randomizing Test Data

18 Generalizing KNN

19 Gauging Accuracy

20 Printing a Report

21 Refactoring Accuracy Reporting

22 Investigating Optimal K Values

23 Updating KNN for Multiple Features

24 Multi-Dimensional KNN

25 N-Dimension Distance

26 Arbitrary Feature Spaces

27 Magnitude Offsets in Features

28 Feature Normalization

29 Normalization with MinMax

30 Applying Normalization

31 Feature Selection with KNN

32 Objective Feature Picking

33 Evaluating Different Feature Values

**Onwards to Tensorflow JS!**

34 Let’s Get Our Bearings

35 A Plan to Move Forward

36 Tensor Shape and Dimension

37 Elementwise Operations

38 Broadcasting Operations

39 Logging Tensor Data

40 Tensor Accessors

41 Creating Slices of Data

42 Tensor Concatenation

43 Summing Values Along an Axis

44 Massaging Dimensions with ExpandDims

**Applications of Tensorflow**

45 KNN with Regression

46 A Change in Data Structure

47 KNN with Tensorflow

48 Maintaining Order Relationships

49 Sorting Tensors

50 Averaging Top Values

51 Moving to the Editor

52 Loading CSV Data

53 Running an Analysis

54 Reporting Error Percentages

55 Normalization or Standardization

56 Numerical Standardization with Tensorflow

57 Applying Standardization

58 Debugging Calculations

59 What Now

**Getting Started with Gradient Descent**

60 Linear Regression

61 Why Linear Regression

62 Understanding Gradient Descent

63 Guessing Coefficients with MSE

64 Observations Around MSE

65 Derivatives!

66 Gradient Descent in Action

67 Quick Breather and Review

68 Why a Learning Rate

69 Answering Common Questions

70 Gradient Descent with Multiple Terms

71 Multiple Terms in Action

**Gradient Descent with Tensorflow**

72 Project Overview

73 Data Loading

74 Default Algorithm Options

75 Formulating the Training Loop

76 Initial Gradient Descent Implementation

77 Calculating MSE Slopes

78 Updating Coefficients

79 Interpreting Results

80 Matrix Multiplication

81 More on Matrix Multiplication

82 Matrix Form of Slope Equations

83 Simplification with Matrix Multiplication

84 How it All Works Together!

**Increasing Performance with Vectorized Solutions**

85 Refactoring the Linear Regression Class

86 Refactoring to One Equation

87 A Few More Changes

88 Same Results Or Not

89 Calculating Model Accuracy

90 Implementing Coefficient of Determination

91 Dealing with Bad Accuracy

92 Reminder on Standardization

93 Data Processing in a Helper Method

94 Reapplying Standardization

95 Fixing Standardization Issues

96 Massaging Learning Rates

97 Moving Towards Multivariate Regression

98 Refactoring for Multivariate Analysis

99 Learning Rate Optimization

100 Recording MSE History

101 Updating Learning Rate

**Plotting Data with Javascript**

102 Observing Changing Learning Rate and MSE

103 Plotting MSE Values

104 Plotting MSE History against B Values

**Gradient Descent Alterations**

105 Batch and Stochastic Gradient Descent

106 Refactoring Towards Batch Gradient Descent

107 Determining Batch Size and Quantity

108 Iterating Over Batches

109 Evaluating Batch Gradient Descent Results

110 Making Predictions with the Model

**Natural Binary Classification**

111 Introducing Logistic Regression

112 Logistic Regression in Action

113 Bad Equation Fits

114 The Sigmoid Equation

115 Decision Boundaries

116 Changes for Logistic Regression

117 Project Setup for Logistic Regression

118 Project Download

119 Importing Vehicle Data

120 Encoding Label Values

121 Updating Linear Regression for Logistic Regression

122 The Sigmoid Equation with Logistic Regression

123 A Touch More Refactoring

124 Gauging Classification Accuracy

125 Implementing a Test Function

126 Variable Decision Boundaries

127 Mean Squared Error vs Cross Entropy

128 Refactoring with Cross Entropy

129 Finishing the Cost Refactor

130 Plotting Changing Cost History

**Multi-Value Classification**

131 Multinominal Logistic Regression

132 A Smart Refactor to Multinominal Analysis

133 A Smarter Refactor!

134 A Single Instance Approach

135 Refactoring to Multi-Column Weights

136 A Problem to Test Multinominal Classification

137 Classifying Continuous Values

138 Training a Multinominal Model

139 Marginal vs Conditional Probability

140 Sigmoid vs Softmax

141 Refactoring Sigmoid to Softmax

142 Implementing Accuracy Gauges

143 Calculating Accuracy

**Image Recognition In Action**

144 Handwriting Recognition

145 Greyscale Values

146 Many Features

147 Flattening Image Data

148 Encoding Label Values

149 Implementing an Accuracy Gauge

150 Unchanging Accuracy

151 Debugging the Calculation Process

152 Dealing with Zero Variances

153 Backfilling Variance

**Performance Optimization**

154 Handing Large Datasets

155 Minimizing Memory Usage

156 Creating Memory Snapshots

157 The Javascript Garbage Collector

158 Shallow vs Retained Memory Usage

159 Measuring Memory Usage

160 Releasing References

161 Measuring Footprint Reduction

162 Optimization Tensorflow Memory Usage

163 Tensorflow’s Eager Memory Usage

164 Cleaning up Tensors with Tidy

165 Implementing TF Tidy

166 Tidying the Training Loop

167 Measuring Reduced Memory Usage

168 One More Optimization

169 Final Memory Report

170 Plotting Cost History

171 NaN in Cost History

172 Fixing Cost History

173 Massaging Learning Parameters

174 Improving Model Accuracy

**Appendix Custom CSV Loader**

175 Loading CSV Files

176 A Test Dataset

177 Reading Files from Disk

178 Splitting into Columns

179 Dropping Trailing Columns

180 Parsing Number Values

181 Custom Value Parsing

182 Extracting Data Columns

183 Shuffling Data via Seed Phrase

184 Splitting Test and Training

**Extras**

185 Bonus!

Resolve the captcha to access the links!