This article will explain brief summary of **linear regression** and how to implement it using TensorFlow 2. If you are beginner, I would recommend to read following posts first:

- Setup Deep Learning environment: Tensorflow, Jupyter Notebook and VSCode

- Tensorflow 2: Build Your First Machine Learning Model with tf.keras

### Regression

It is a process where a model learns to predict a continuous value output for a given input data. For example, we are given some data points of x and corresponding y and we need to learn the relationship between them that is called a hypothesis.

In case of Linear regression, the hypothesis is a straight line, i.e, the response value(y) as accurately as possible as a function of the feature or independent variable(x).

```
y = W*x + b
```

Where **W** is a vector called **Weights** and **b** is a scalar called **Bias**. The Weights and Bias are called the parameters of the model.

### Simple Example

Let us consider a dataset where we have a value of response **y** for every feature **x**:

X | Y |
---|---|

0 | 5 |

1 | 8 |

2 | 11 |

3 | 14 |

4 | 17 |

5 | 20 |

6 | 23 |

7 | 26 |

8 | 29 |

9 | 32 |

We have to predict value for **x=10**

Let's build Tensorflow 2 model for this:

```
import tensorflow as tf
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
y = [5, 8, 11, 14, 17, 20, 23, 26, 29, 32]
# Define layer
layer0 = tf.keras.layers.Dense(units=1, input_shape=[1])
model = tf.keras.Sequential([layer0])
# Compile model
model.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(1))
# Train the model
history = model.fit(x, y, epochs=100, verbose=False)
# Prediction
print('Prediction: {}'.format(model.predict([10])))
# Get weight and bias
weights = layer0.get_weights()
print('weight: {} bias: {}'.format(weights[0], weights[1]))
```

In above code, we defined x and y with provided data. then define keras Dense layer with single Neuron and compiled the model with **mean squared error** and **Adam** optimizer. After training, we define to get prediction for x=10 and display to check **weight** and **bias**.

Here is the output

```
Prediction: [[35.]]
weight: [[3.]] bias: [5.]
```

Which is correct. As it is very simple example for understanding purpose.

```
y = W*x + b
y = 3x + 5
```

for x= 0, y=5

x=1, y = 8

...

x=10, y= 3*10+5 = 35

### Another Example

Let's prepare a linear dataset

```
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
x_train = np.linspace(0, 50, 51)
y_train = np.linspace(5, 155, 51)
```

It is similar to previous one ((x,y)(0,5)(1,8)(2,11)...) except total number of data points. Let's add some noise:

```
y_train = y_train + np.random.normal(0,5,51)
```

Let's visualize the training data

```
plt.xlabel('x_train')
plt.ylabel('y_train')
plt.scatter(x_train, y_train)
plt.show()
```

**Build the model:**

```
layer0 = tf.keras.layers.Dense(units=1, input_shape=[1])
model = tf.keras.Sequential([layer0])
model.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(0.1))
history = model.fit(x_train,y_train, epochs=100, verbose=False)
```

The model is similar to previous except Adam arg value.

Check the training loss:

```
plt.xlabel('Epoch Number')
plt.ylabel("Loss Magnitude")
plt.plot(history.history['loss'])
plt.show()
```

As you can see, our model improves very quickly at first, and then has a steady, slow improvement until it is very near "**perfect**" towards the end.

Let's get prediction for **x=100**

```
print('Prediction: {}'.format(model.predict([100])))
```

**Output:**

```
Prediction: [[304.8801]]
```

Which is **~305**. Let's plot the result

```
weights = layer0.get_weights()
weight = weights[0][0]
bias = weights[1]
print('weight: {} bias: {}'.format(weight, bias))
y_learned = x_train * weight + bias
plt.scatter(x_train, y_train, label='Training Data')
plt.plot(x_train, y_learned, color='orangered', label='Fit Line')
plt.legend()
plt.show()
```

### Conclusion

In this article, we saw what is **linear regression** with a very simple example and learned how to build a linear regression model, evaluate it, and use it to predict new data values using TensorFlow 2.0 Keras API.

Enjoy TensorFlow!!