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

# Deep learning
* Deep learning is a set of complex technologies, but they all spring from a simple idea: neural networks become more powerful if they have many layers. Those **“deep”** networks pose more challenges than the **“shallow”** three-layered networks we’ve built so far. In the next few chapters, we’ll describe and overcome those challenges.

* Adding layers is just the beginning. In the last few years, the original concept of deep learning branched out into many innovative and sometimes wonderful ideas. We’ll take a look at some of those.

* In Parts I and II, we used MNIST as our benchmark. MNIST will also be our starting point in the first chapters of Part III,  but eventually, we’ll outgrow it and tackle more complex datasets.

* The third part of this course is all about deep learning, the major breakthrough in modern artificial intelligence. **Deep learning** means a few different things, but first and foremost as mentioned previously, it stands for neural networks with many layers. Deeper networks have more sophisticated models than shallow networks, so they can generate more complicated functions to approximate data.

Later on, we’ll see that there is more to **deep learning** than adding layers. Deep learning is actually a set of interconnected techniques with names such as _convolutions, recurrent neural networks, and generational adversarial networks_. By the end of this course, we’ll have a better idea of those techniques, and will be well equipped to explore them on our own.

To begin, we’ll start from that basic concept: adding _layers to a neural network_. In this chapter, we’ll create two networks: 
1. **A shallow one** with three layers
2. **A slightly deeper one** with four 

We’ll run both networks on the same dataset and compare their results.

In the first two parts of this course, we wrote our code from scratch, line by line. However, as we move into deep learning, this approach takes up more and more time. It also becomes less compelling because we already have a solid grasp of the fundamentals, and do not need to linger on every little detail. From this chapter onward, we’ll write our neural networks with **Keras**, a popular ML library. We’ll focus on the big picture and Keras will take care of the details.

Let’s recap what we can expect from this chapter:
* We’ll see how to build a neural network with Keras.
* We‘ll write a three-layered network and run it on a simple dataset.
* We’ll add a layer to the network and see how its performance changes.


# Prepare Echidna dataset
Before we get into building networks, let’s prepare a dataset to run them on. Let’s recall the concept of 
[Tracing a Boundary](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/trace-a-boundary). Soon enough, we’ll see how a neural network’s decision boundary changes as we add a fourth layer. For that purpose, there is a dataset that’s twisty, but also easy to visualize. Here it is:


Get familiar with deep learning and learn about the attributes of the Echidna dataset.

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

The Echidna Dataset

Deep learning