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 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 [Fearful Symmetry](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/initialize-the-weights#Fearful-symmetry), we learned that we should not initialize all the neural network’s `weights` to the same value. We may easily notice what happens if we ignore that advice. We can use NumPy’s `zeros()` function to initialize all the `weights` to $0$. For example, we get a matrix of $zeros$ with two _rows_ and three _columns_ by:


```python
➾ np.zeros((2, 3))
❮ array([[ 0., 0., 0.],
[ 0., 0., 0.]])
```
The parameter to `zeros()` has its own parentheses because it’s a 
#key# tuple: an immutable collection of values #key#. In this case, the tuple has two values: the rows and columns of the matrix, respectively.

After we initialize the `weights` to $0$, run the network for a few `iterations`, and see what happens. Compare its results to the results of the randomly
initialized network. How does it fare? Also try to modify the zero-initialized network to give it fewer hidden nodes. And notice, is there any significant difference in accuracy?

Finally, peek into the zero-initialized network as it trains. For example, we can print ten rows from around the middle of $w_1$ and $w_2$ as follows:

```python
print(w1[120:130])
print(w2[120:130])
```
What do we see?

# Revision
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 [Fearful Symmetry](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/initialize-the-weights#Fearful-symmetry), we learned that we should not initialize all the neural network’s `weights` to the same value. We may easily notice what happens if we ignore that advice. We can use NumPy’s `zeros()` function to initialize all the `weights` to $0$. For example, we get a matrix of $zeros$ with two _rows_ and three _columns_ by:


```python
➾ np.zeros((2, 3))
❮ array([[ 0., 0., 0.],
[ 0., 0., 0.]])
```
The parameter to `zeros()` has its own parentheses because it’s a 
#key# tuple: an immutable collection of values #key#. In this case, the tuple has two values: the rows and columns of the matrix, respectively.

After we initialize the `weights` to $0$, run the network for a few `iterations`, and see what happens. Compare its results to the results of the randomly
initialized network. How does it fare? Also try to modify the zero-initialized network to give it fewer hidden nodes. And notice, is there any significant difference in accuracy?

Finally, peek into the zero-initialized network as it trains. For example, we can print ten rows from around the middle of $w_1$ and $w_2$ as follows:

```python
print(w1[120:130])
print(w2[120:130])
```
What do we see?

 Compare randomly initialized weights with fixed weights by interacting with the hands-on exercise.

Playground

Compare randomly initialized weights with fixed weights by interacting with the hands-on exercise.

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

Revision

Hands-on challenge