what is simple linear regression?

simple linear regression is a statistical and supervised learning method in which a single independent variable (also known as a predictor variable) is used to predict the dependent variable. in other words, it models the linear relationship between the dependent variable and a single independent variable.

simple linear regression in machine learning is a type of linear regression. when the linear regression algorithm deals with a single independent variable, it is known as simple linear regression. when there is more than one independent variable (feature variables), it is known as multiple linear regression.

independent variable

the feature inputs in the dataset are termed as the independent variables. there is only a single independent variable in simple linear regression. an independent variable is also known as a predictor variable as it is used to predict the target value. it is plotted on a horizontal axis.

dependent variable

the target value in the dataset is termed as the dependent variable. it is also known as a response variable or predicted variable. it is plotted on a vertical axis.

line of regression

in simple linear regression, a line of regression is a straight line that best fits the data points and is used to show the relationship between a dependent variable and an independent variable.

graphical representation

the following graph depicts the simple linear regression model −

in the above image, the straight line represents the simple linear regression line where &ycirc; is the predicted value, and y is dependent variable (target) and x is independent variable (input).

simple linear regression model

a simple linear regression model in machine learning can be represented as the following mathematical equation −

$$\mathrm{ y = w_0 + w_1 x + \epsilon }$$

where

y is the dependent variable (target).
x is the independent variable (feature).
w₀ is the y-intercept of the line.
w₁ is the slope of the line, representing the effect of x on y.
îµ is the error term, capturing the variability in y not explained by x.

how simple linear regression works?

the main of simple linear regression is to find the best fit line (a straight line) through the data points that minimizes the difference between the actual values and predicted values.

defining hypothesis function

in simple linear regression, the hypothesis is that there is a linear relation between the dependent variable (output/ target) and the independent variable (input). this linear relation can be represented using a linear equation −

$$\mathrm{\hat{y} = w_0 + w_1 x}$$

with different values of parameters w₀ and w₁ there are multiple linear equations (straight lines). the set of all such linear equations (all straight lines) is termed hypothesis space.

now, the main aim of the simple linear regression model is to find the best-fit line in hypothesis space (set of all straight lines).

finding the best fit line

now the task is to find the best fit line (line of regression). to do this, we define a cost function or loss function that measure the the difference between the actual values and predicted values.

to find the best fit line, the simple linear regression model initializes (with default values) the parameters of the regression line. this regression line (with initialized parameters) is used to find the predicted values for the given input values.

loss function for simple linear regression

now using the input and predicted values, we compute the loss function. the loss function is used to find the optimal values of the parameters.

the loss function finds the difference between the input value and predicted value. there are different loss functions such as mean squared error (mse), mean absolute error (mea), r-squared, etc. used in simple linear regression. the most commonly used loss function is mean squared error.

the loss function for simple linear regression in terms of mean squared error is as follows −

$$\mathrm{j(w_0, w_1) = \frac{1}{2n} \sum_{i=1}^{n} \left( y_i - \hat{y}_i \right)^2}$$

optimization

the optimal values of parameters are those values that minimize the cost function. finding the optimal values is an iterative process in which the parameters are updated iteratively.

there are many optimization techniques applied in simple linear regression. gradient descent is a simple and most common optimization technique used in simple linear regression.

a linear equation with optimal parameter values is the best fit line(regression line) and it is the final solution for a simple linear regression problem. this line is used to predict new and unseen data.

assumptions of simple linear regression

there are some assumptions about the dataset that are made by the simple linear regression model. the following are some assumptions −

linearity − this assumption assumes that the relationship between the dependent and independent variables is linear. that means the dependent variable changes linearly as the independent variable changes. a scatter plot will show the linearity in the dataset.
homoskedasticity − for all observations, the variance of the residuals is the same. this assumption relates to the squared residuals.
independence − the examples (observations or x and y pairs) are independent. there is no collinearity in data so the residuals will not be correlated. to check this, we example the scatter plot of residuals vs. fits.
normality − model residuals are normally distributed. residuals are the differences between the actual and predicted values. to check for the normality, we examine the histogram of residuals. the histogram should be approximately normally distributed.

implementation of simple linear regression algorithm using python

to implement the simple linear regression algorithm, we are taking a dataset with two variables: yearsexperience (independent variable) and salary (dependent variable).

here, we are using the following dataset. the dataset contains 30 examples of data points. you can create a csv file and store these data points in it.

salary_data.csv

years of experience	salary
1.1	39343
1.3	46205
1.5	37731
2	43525
2.2	39891
2.9	56642
3	60150
3.2	54445
3.2	64445
3.7	57189
3.9	63218
4	55794
4	56957
4.1	57081
4.5	61111
4.9	67938
5.1	66029
5.3	83088
5.9	81363
6	93940
6.8	91738
7.1	98273
7.9	101302
8.2	113812
8.7	109431
9	105582
9.5	116969
9.6	112635
10.3	122391
10.5	121872

what is the purpose of this implementation?

the purpose of building this simple linear regression model is to determine which line best represents the relationship between the two variables.

the following are the steps to implement the simple linear regression model in python −

step 1: data preparation

data preparation or pre-processing is the initial step. we have our dataset as a csv file named "salary_data.csv," as discussed above.

we need to import python libraries prior to importing the dataset and building the simple linear regression model.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

load the dataset

dataset = pd.read_csv('salary_data.csv')

the dependent variable (x) and independent variable (y) must then be extracted from the provided dataset. years of experience (yearsexperience) is the independent variable, and salary is the dependent variable.

x = dataset.iloc[:, :-1].values
y = dataset.iloc[:, -1].values

let's check the first five examples of the dataset.

print(dataset.head())

output

0	1.1	39343.0
1	1.3	46205.0
2	1.5	37731.0
3	2.0	43525.0
4	2.2	39891.0

lets check if the dataset is linear or not

plt.scatter(x, y, color="green")
plt.title("salary vs experience")
plt.xlabel("years of experience")
plt.ylabel("salary (inr)")
plt.show()

output

linear relation between dependent and independent variables

the above graph shows that the dependent and independent variables are linearly dependent. so we can apply the simple linear regression on the dataset to find the best relation between these variables.

split the dataset into training and testing sets

the training set and test set will then be divided into two groups. we will use 80% observations for the training set and 20% observations for the test set out of the total 30 observations we have. so there will be 24 observation in training set and 6 observation in test set. we divide our dataset into training and test sets so that we can use one set to train and the other to test our model.

# split the dataset into training and testing sets
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.2)

here, x_train represents the input feature of the training data and y_train represents the output variable (target variable).

step 2: model training (fitting the simple linear regression to training set)

the next step is fitting our model with the training dataset. we will use scikit-learn's linearregression class to train a simple linear regression model on the training data. the code for this is as follows −

from sklearn.linear_model import linearregression

# create a linear regression object
regressor= linearregression()
regressor.fit(x_train, y_train)

the fit() method is used to fit the linear regression object (regressor) to the training data. the model learns the relation between the predictor variable (x_train), and the target variable (y_train).

step 3: model testing

once the model is trained, we can use it to make predictions on the test data. the code for this is as follows −

y_pred = regressor.predict(x_test)
df = pd.dataframe({'actual values':y_test, 'predicted values':y_pred})
print(df)

output

   actual values  predicted values
0        60150.0      54093.648425
1        93940.0      82416.119864
2        57081.0      64478.554619
3       116969.0     115459.003211
4        56957.0      63534.472238
5       121872.0     124899.827024

the above output shows actual values and predicted values of salary in the test set.

here, x_test represents the input feature of the test data and y_pred represents the predicted output variable (target variable).

similarly, you can test the model with training data.

y_pred = regressor.predict(x_train)
df = pd.dataframe({'real values':y_test, 'predicted values':y_pred})
print(df)

output

    real values  predicted values
0       57189.0      60702.225094
1       64445.0      55981.813188
2       63218.0      62590.389857
3      122391.0     123011.662261
4       91738.0      89968.778915
5       43525.0      44652.824612
6       61111.0      68254.884145
7       56642.0      53149.566044
8       66029.0      73919.378433
9       83088.0      75807.543195
10      46205.0      38044.247943
11     109431.0     107906.344160
12      98273.0      92801.026059
13      37731.0      39932.412705
14      54445.0      55981.813188
15      39891.0      46540.989374
16     101302.0     100353.685109
17      55794.0      63534.472238
18      81363.0      81472.037483
19      39343.0      36156.083180
20     113812.0     103185.932253
21      67938.0      72031.213670
22     112635.0     116403.085592
23     105582.0     110738.591304

step 4: model evaluation

we need to evaluate the performance of the model to determine its accuracy. we will use the mean squared error (mse), root mse (rmse), mean average error (mae), and the coefficient of determination (r^2) as evaluation metrics. the code for this is as follows −

from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import r2_score

# get the predicted values for test dat
y_pred = regressor.predict(x_test)
mse = mean_squared_error(y_test, y_pred)
print("mse", mse)
rmse = mean_squared_error(y_test, y_pred, squared=false)
print("rsme", rmse)
mae = mean_absolute_error(y_test, y_pred)
print("mae", mae)
r2 = r2_score(y_test, y_pred)
print("r2", r2)

output

mse:  46485664.99327367
rsme:  6818.0396737826095
mae:  6015.513730219523
r2:  0.9399326805390613

here, y_test represents the actual output variable of the test data.

step 5: visualize training set results (with regression line)

now, let's visualize the results on the training set and the regression line.

we use the scatter plot to plot the actual values (input and target values) in the training set. we also plot a straight line (regression line) for actual values (input) and predicted values of the training set.

y_pred = regressor.predict(x_train)
plt.scatter(x_train, y_train, color="green", label="training data points (actual)")
plt.scatter(x_train, y_pred, color="blue",label="training data points (predicted)")
plt.plot(x_train, y_pred, color="red")
plt.title("salary vs experience (training dataset)")
plt.xlabel("years of experience")
plt.ylabel("salary(in rupees)")
plt.legend()
plt.show()

output

the above graph shows the line of regression (straight line in red color), actual values (in green color), and predicted values (in blue color) for the training set.

step 6: visualize the test set results (with regression line)

now, let's visualize the results on the test set and the regression line.

we use the scatter plot to plot the actual values (input and target values) in the test set. we also plot a straight line (regression line) for actual values (input) and predicted values of the test set.

y_pred = regressor.predict(x_test)
plt.scatter(x_test, y_test, color="green", label="test data points (actual)")
plt.scatter(x_test, y_pred, color="blue",label="test data points (predicted)")
plt.plot(x_test, y_pred, color="red")
plt.title("salary vs experience (test dataset)")
plt.xlabel("years of experience")
plt.ylabel("salary(in rupees)")
plt.legend()
plt.show()

output

the above graph shows the line of regression (straight line in red color), actual values (in green color), and predicted values (in blue color) for the test set.

Save or share this article