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 sigmoids
 Even though linear regression is not a natural fit for binary classification, that does not mean that we have to scrap our linear regression code and start from scratch. Instead, we can adapt our existing algorithm to this new problem using a technique that statisticians call **logistic regression**.

Let’s start by looking back at $\hat{y}$, the weighted sum of the inputs that we introduced in the lesson: [Adding More Dimensions](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/add-more-dimensions).

$$
\hat{y} = x_1 * w_1 + x_2 * w_2 + x_3 * w_3 + ...
$$
In linear regression, $\hat{y}$ could take any value. Binary classification, however, imposes a tight constraint that $\hat{y}$ must not drop below $0$ nor raise above $1$. Here’s an idea: maybe we can find a function that wraps around the weighted sum and constrains it to the range from $0$ to $1$:

$$
\hat{y} = wrapper\_function (x_1 * w_1 + x_2 * w_2 + x_3 * w_3 + ...)
$$

Let’s revise what the `wrapper_function()` does. It takes any number out of the weighted sum, and squashes it into the range from $0$ to $1$.

The other requirement is that the function that we  look for should work well with gradient descent. Think about the following:
* We use this function to calculate $\hat{y}$.
* Then we use $\hat{y}$  to calculate the loss.
* Finally, we descend the loss with gradient descent.

For gradient descent, the wrapper function should be smooth, without flat areas (where the gradient drops to zero) or gaps (where the gradient is not even defined).




For the sake of gradient descent, the wrapper function should be smooth, without flat areas (where the gradient drops to zero) or gaps (where the gradient is not even defined).

>Note: To wrap it up, we want a function that smoothly changes across the range from $0$ to $1$ without ever jumping or flatlining. Something like this:


# Overview of sigmoids
 Even though linear regression is not a natural fit for binary classification, that does not mean that we have to scrap our linear regression code and start from scratch. Instead, we can adapt our existing algorithm to this new problem using a technique that statisticians call **logistic regression**.

Let’s start by looking back at $\hat{y}$, the weighted sum of the inputs that we introduced in the lesson: [Adding More Dimensions](https://www.educative.io/courses/fundamentals-of-machine-learning-for-software-engineers/add-more-dimensions).

$$
\hat{y} = x_1 * w_1 + x_2 * w_2 + x_3 * w_3 + ...
$$
In linear regression, $\hat{y}$ could take any value. Binary classification, however, imposes a tight constraint that $\hat{y}$ must not drop below $0$ nor raise above $1$. Here’s an idea: maybe we can find a function that wraps around the weighted sum and constrains it to the range from $0$ to $1$:

$$
\hat{y} = wrapper\_function (x_1 * w_1 + x_2 * w_2 + x_3 * w_3 + ...)
$$

Let’s revise what the `wrapper_function()` does. It takes any number out of the weighted sum, and squashes it into the range from $0$ to $1$.

The other requirement is that the function that we  look for should work well with gradient descent. Think about the following:
* We use this function to calculate $\hat{y}$.
* Then we use $\hat{y}$  to calculate the loss.
* Finally, we descend the loss with gradient descent.

For gradient descent, the wrapper function should be smooth, without flat areas (where the gradient drops to zero) or gaps (where the gradient is not even defined).




For the sake of gradient descent, the wrapper function should be smooth, without flat areas (where the gradient drops to zero) or gaps (where the gradient is not even defined).

>Note: To wrap it up, we want a function that smoothly changes across the range from $0$ to $1$ without ever jumping or flatlining. Something like this:


Learn and explore how sigmoids help when linear regression fails.

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

Invasion of the Sigmoids

Overview of sigmoids