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

# Overview of classifier
Let’s review how `classify()` works. During the classification phase, the WSSs return arrays of ten numbers from $0$ to $1$. But when we ask the system to recognize an image, we do not want to see those arrays, we want a human-readable answer such as “$3$.” This means that we must decode the WSSs’ answers before returning them.

So far, the `classify()` function didn't have much to do, apart from calling `forward()` and rounding its output. Now `classify()` has a more complex job. It must convert the output of the WSSs back to human-readable labels, like this:

def classify(X, w):
    y_hat = forward(X, w)
    labels = np.argmax(y_hat, axis=1)
    return labels.reshape(-1, 1)

 The first line of `classify()` calculates a matrix of predictions $\hat{y}$, with one row per label, and one column per class. Each row in $\hat{y}$ contains ten numbers between $0$ and $1$.


The second line uses NumPy’s `argmax()` function to get the index of the maximum value in each row of $\hat{y}$ , or the value closer to $1$. By default, `argmax()` finds the maximum value in the entire matrix, so this code uses the argument `axis=1` to apply it to each row separately. The result is an array of indices, which are also the decoded MNIST labels.  We might practice with   functions like `argmax()` in an interactive Python interpreter before using them. On the other hand, these functions save a lot of time because they make the code efficient.

The last line of `classify()` reshapes the labels array to a single-column matrix of digits. Now we finally see why the `Y_test` matrix is not one-hot encoded like `Y_train`. 



We’ll compare `Y_test` with the classifier’s output, so the two matrices must have a single column of human-readable labels.

We are almost there. We just need one more alteration to our classifier code.

# Need more weights

When we introduced one-hot encoding, we extended the matrix of labels from one to ten columns. Now we need to do the same with the weights.

So far, our matrix of weights has one column and one row per input variable. We initialize it like this:

```python3
w = np.zeros((X.shape[1], 1))
```

Now we need ten columns of weights, one per class:

```python
w = np.zeros((X_train.shape[1], Y_train.shape[1]))
```

The new $w$ has one row per input variable, and one column per class. This code gets the number of input variables and classes from the number of columns in $X$ and $Y$, respectively.

At this point, we could be confused by all those matrix dimensions. A question might arise: does $w$ have as many rows as $X$ has columns, or is it the other way around?”. Let’s take a moment to think about all those rows and columns and answer this question.

# Reviewing matrix dimensions


* $X$ is one row per example, and one column per input variable $(m,n)$. The MNIST training set has 60,000 examples, each composed of 784 pixels. Add the bias column, and $X$ becomes (60000, 785).

* $Y$ is a matrix of one-hot-encoded labels. It has one row per example, and one column per class. If we use $k$ for the number of classes, then $Y$ is $(m, k)$. In our case, that’s (60000, 10).

* The matrix of weights $w$ is $(n, k)$, that is, one row per input variable, and one column per class. In our case, it is $(785, 10)$. 

We’ve learned a lot since our first learning program, where w was a single parameter. Now we’re training over thousands of parameters!

As a double-check, we can verify that the weighted sum `X ⋅ w = Y` has all the right dimensions as shown below:

Understand why we need more weights and dimensions.

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

Decode the Classifier’s Answers

Overview of classifier