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 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
Let’s take the MNIST network we built in Part II of this course and rewrite it from the beginning using Keras.

Keras already comes with a few common datasets, MNIST included, so we don’t have to use our `mnist.py` library. Instead, we can load MNIST and one-hot encode its labels with this piece of code:
```python
from keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
(X_train_raw, Y_train_raw), (X_test_raw, Y_test_raw) = mnist.load_data()
X_train = X_train_raw.reshape(X_train_raw.shape[0], -1) / 255
X_test = X_test_raw.reshape(X_test_raw.shape[0], -1) / 255
Y_train = to_categorical(Y_train_raw)
Y_test = to_categorical(Y_test_raw)
```
The first time we run this code, Keras downloads MNIST all by itself.


Note that MNIST does not have a validation set out of the box. We can either bend the rules and use the test set to validate the network or split the test set into a validation set and a smaller test set, as we did before.

Also, this code does not standardize the inputs as accurately as we did in our earlier implementations: it just divides all the input pixels by 255 so they range from 0 to 1. Feel free to use the more sophisticated standardization method we used in 
 ["Standardization in Practice"](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/preparing-data#Standardization-in-practice) but this method does not make huge differences.

Writing the network is up to us. When it comes time to call `model.compile()`, we can decide which algorithm to use, either `SGD` (that is, standard gradient descent) or the more advanced `RMSProp` that we used earlier in this chapter. We may try both and compare the training speed and final accuracy on the training and the test set.

We should not expect that the Keras MNIST network will work well with the same hyperparameters we found in ["Let’s Do Development"](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/preparing-data). Here we have a different implementation, so we’ll probably need to find new values for those hyperparameters. Aim for 99% accuracy or better.

Use Keras to build your own neural network model for testing 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 (Keras)

Revision

Hands on