Explore machine learning's essentials for software engineers, delve into supervised learning, neural networks, and deep learning, and gain skills to tackle real-world data challenges effectively.

pml_final.tar.gz

just_run

chapter06

SPA_07

SPA_gdb_frontEnd

J12-1

J12-2

SPA-server_image

Handson-10

Machine learning is the future for the next generation of software professionals.

This course serves as a guide to machine learning for software engineers. You’ll be introduced to three of the most relevant components of the AI/ML discipline; supervised learning, neural networks, and deep learning. You’ll grasp the differences between traditional programming and machine learning by hands-on development in supervised learning before building out complex distributed applications with neural networks. You’ll go even further by layering networks to create deep learning systems. You’ll work with complex real-world datasets to explore machine behavior from scratch at each phase.

By the end of this course, you’ll have a working knowledge of modern machine learning techniques. Using software engineering, you’ll be prepared to build complex neural networks and wrangle real-world data challenges.

Fundamentals of Machine Learning for Software Engineers

We built a neural network and prepared its input data, but that was only the
beginning. The same algorithm running on the same data can yield wildly
different results, depending on hyperparameters such as the _learning rate_
and _the number of hidden nodes._

ML development is mostly about finding good values for those hyperparameters. Compared to software development, _there is no hard-and-fast rule that tells us how to set those hyperparameters_. 

We should not change multiple _hyperparameters_ at the same time. Otherwise, we
would not know which changes affected the network’s _accuracy_. Instead, let’s tune
those hyperparameters one at a time, starting with the easy one.

## Picking the number of epochs

The easiest hyperparameter to tune is `epochs` arguably. We already know that
_the longer we train a system, the more accurate it becomes—up to a point_.
After a certain number of epochs, the accuracy gets as high as it can, and
training for longer becomes a waste of time. Overtraining a system might even
become counterproductive and decrease its accuracy.

Long story short: we should train a network long enough to reach its maximum
accuracy, but not any longer. So, here’s the common approach to picking the number of epochs: start with a very high number, and take note of the number of epochs where the accuracy seems to level off. That’s the
“right” number of epochs.

## Tune the number of hidden nodes

Another crucial hyperparameter is `h`, **the number of hidden nodes**. Here is an experiment that proves how important this hyperparameter is. After training a network on a simple two-dimensional dataset(the same one that we used in  [Bending the Boundary](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/bend-the-boundary). Below is the plot of network’s decision boundaries for 1, 2, 10, and 20 hidden nodes. 

# Picking the number of epochs

The easiest hyperparameter to tune is `epochs` arguably. We already know that
_the longer we train a system, the more accurate it becomes—up to a point_.
After a certain number of epochs, the accuracy gets as high as it can, and
training for longer becomes a waste of time. Overtraining a system might even
become counterproductive and decrease its accuracy.

Long story short: we should train a network long enough to reach its maximum
accuracy, but not any longer. So, here’s the common approach to picking the number of epochs: start with a very high number, and take note of the number of epochs where the accuracy seems to level off. That’s the
“right” number of epochs.

# Tune the number of hidden nodes

Another crucial hyperparameter is `h`, **the number of hidden nodes**. Here is an experiment that proves how important this hyperparameter is. After training a network on a simple two-dimensional dataset(the same one that we used in  [Bending the Boundary](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/bend-the-boundary). Below is the plot of network’s decision boundaries for 1, 2, 10, and 20 hidden nodes. 

Explore tuning of hyperparameters - picking up the right number of epochs and hidden nodes.

How Machine Learning Works

Our First Learning Program

Walking the Gradient

Hyperspace

A Discern Machine

Get Real

The Final Challenge

The Perceptron

Designing the Network

Building the Network

Training the Network

How Classifiers Work

Batchin’ Up

The Zen of Testing

Let’s Do Development

A Deeper Kind of Network

Diabetes Prediction Using Keras

Defeating Overfitting

Taming Deep Networks

Beyond Vanilla Networks

Into the Deep

Recognize Handwritten Digits Using a Deep Neural Network

Tune Hyperparameters

Picking the number of epochs