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

Perceptrons are simple, and they can be assembled into larger structures like machine learning construction bricks. However, that simplicity comes with a distressing limitation that perceptrons work well on some datasets and fail badly on others. More specifically, perceptrons are a good fit for **linearly separable data**. Let’s see what linearly separable means, and why it matters.

# Linearly separable data

Let's look at this two-dimensional dataset:

The two classes in the data are green triangles and blue squares. They are neatly arranged into distinct clusters. We can even separate them with a line:


Datasets that can be partitioned with a straight line, like the one we get here, are called **linearly separable** datasets. By contrast, if a dataset can only be partitioned with a curved line, or cannot be partitioned at all, is called **non-linearly separable** data.

Now imagine, we apply a classifier to these green and blue points. The classifier learns how the points are distributed, and then assign arbitrary new points to either the green class or the blue class. The key information is that our perceptron-based classifier would work very well on linearly separable data like these. Later in this course, in [How Classifiers Work](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/trace-a-boundary), we’ll see exactly why that’s the case. For now, we can take it as: train a perceptron on a linearly separable dataset, like the one shown here, and we’ll get accurate classifications.


We just saw an example with two-dimensional data. However, the same reasoning applies for data with three or more dimensions. Instead of a line, we’ll separate the classes with a higher-dimensional hyperplane. With three dimensions, we’ll trace a plane. With $785$ dimensions, as in the case of MNIST, we would have to trace a $784$ dimensional linear shape. In all of these cases, the intuition stays the same: if we can separate the classes with a “_**straight**_” shape, then those data are good for a perceptron.

## Multi-class linearly separable data

In linearly separable data, we used a binary classifier to show the meaning of linearly separable. But what if a dataset has more than two classes, as in the following case?


Distinguish between linearly separable data and non-linearly separable data.

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

Where Perceptrons Fail

Linearly separable data