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

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 this challenge,  think about what could go wrong as we split a dataset.

Imagine that you receive a large dataset of handwritten characters, like MNIST, only for letters from A to Z. You want to build a classifier for this dataset, so you need _training_, _validation_, and _test sets_. Let’s say that the entire dataset is made up of 1,000,000 characters, and you plan to reserve 50,000 characters for the validation set and 50,000 more for the test set. Here’s the code that does that:
```python
data_train, data_validation, data_test = np.split(data_all, [900_000, 950_000])
```
This line splits `data_all` at the two given indexes. The result is that `data_train` contains 900,000 characters, `data_validation` contains 50,000, and the rest are left for `data_test`.

The code here seems innocuous enough, but it contains a sneaky problem that might easily trip you up, or not, depending on the specific dataset. The question for you to ponder is that _can you imagine what that problem is, and what’s the specific thing that makes this splitting strategy potentially wrong? How would you counter the problem if it happens?_

Implement what we have learned about splitting the data into three sets: training, testing, and validation.

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 (Thinking About Testing)

Hands on challenge