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

## Revision
Before we move on, let’s practice with the code for a little while. That’s optional, but it’s a good way to revise these concepts.

Go through all the codes which we have covered in this chapter by launching the below app:

## Hands on Challenge
In the beginning of the second part, we set a target for ourselves: 99% accuracy on MNIST. We just got so close, reaching 98.6%. That last 0.4%  is up to us.

Configuring a network can be more art than science, and this is proof of that. Here’s my suggestion: To find better hyperparameters than the ones we have now, drop compare.py. Instead, use neural_network_quieter.py, an alternative version of the network that logs accuracy after 1 complete epoch—it’s much faster. Here are a few things that we can try:
* The standardized version of MNIST generally works better. There’s no reason not to use it.
* Sometimes, it pays off to be patient and wait for more `epochs` before giving up. However, if 20 or 30 `epochs` go by without increasing accuracy, then it may be time to try another configuration.
* More hidden nodes slow down the training, but they make the network smarter when dealing with unorganized data. Do not be afraid to push that number higher.
* The smaller the learning rate, the slower the training, but those small
steps help the network reach closer to the minimum `loss`. Try a slightly
smaller value of `lr` than the one we settled on.
* We talked a lot about the pros and cons of small batches in the past. All
that being said, in this specific case, we had more luck with very large batch
sizes.

Hitting that 99% with our neural network is entirely possible. 

We can expect to get different results each time we run this program because it uses random values for its `weights`. Tweak the hyperparameters with the aim to raise the accuracy.


# Revision
Before we move on, let’s practice with the code for a little while. That’s optional, but it’s a good way to revise these concepts.

Go through all the codes which we have covered in this chapter by launching the below app:

# Hands on Challenge
In the beginning of the second part, we set a target for ourselves: 99% accuracy on MNIST. We just got so close, reaching 98.6%. That last 0.4%  is up to us.

Configuring a network can be more art than science, and this is proof of that. Here’s my suggestion: To find better hyperparameters than the ones we have now, drop compare.py. Instead, use neural_network_quieter.py, an alternative version of the network that logs accuracy after 1 complete epoch—it’s much faster. Here are a few things that we can try:
* The standardized version of MNIST generally works better. There’s no reason not to use it.
* Sometimes, it pays off to be patient and wait for more `epochs` before giving up. However, if 20 or 30 `epochs` go by without increasing accuracy, then it may be time to try another configuration.
* More hidden nodes slow down the training, but they make the network smarter when dealing with unorganized data. Do not be afraid to push that number higher.
* The smaller the learning rate, the slower the training, but those small
steps help the network reach closer to the minimum `loss`. Try a slightly
smaller value of `lr` than the one we settled on.
* We talked a lot about the pros and cons of small batches in the past. All
that being said, in this specific case, we had more luck with very large batch
sizes.

Hitting that 99% with our neural network is entirely possible. 

We can expect to get different results each time we run this program because it uses random values for its `weights`. Tweak the hyperparameters with the aim to raise the accuracy.


Test what we have learned so far about neural networks and their hyperparameters to achieve 99% accuracy for MNIST.

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

Playground (Achieving 99%-MNIST)

Revision

Hands on Challenge