## Coefficient of Determination (R-Squared) in Data Science

Data Science has become an integral part of modern-day businesses, and it relies heavily on advanced statistical analysis. One of the commonly used metrics in Data Science is the Coefficient of Determination.

It is a measure that quantifies the performance of a model that predicts the response variable based on the independent variables. This article will provide an in-depth understanding of the Coefficient of Determination, commonly referred to as R squared value in regression models, and its implementation in Python.

### What is the Coefficient of Determination?

The Coefficient of Determination (R-squared value) is an error metric used in regression models to evaluate the performance of a model.

It measures the proportion of the variance in the target variable that is explained by the independent variables in the model. In simpler terms, R squared indicates how well the regression line – the line of best fit – represents the data points.

The R squared value ranges between 0 and 1, with 0 indicating that the model does not explain any of the data variation, and 1 implying that the model explains all of the variation in the data.

## Understanding R Squared value

The R squared value is a regression error metric that provides information on the accuracy of the model. A higher R squared value, close to 1, indicates that the model accurately predicts the response variables values and better captures the relationship between the independent variables and the response variable.

## Formula and Interpretation of R Squared Value

The formula for calculating R squared value is the ratio of explained variance to total variance. This can be expressed mathematically as follows:

R squared = 1 – (RSS/TSS)

Where RSS stands for the residual sum of squares and TSS represents the total sum of squares.

The residual sum of squares measures the difference between the predicted and actual values, while the total sum of squares measures the variation in the response variable. Interpretation of R squared value:

- R squared value near 1 indicates that the model captures most of the variance in the response variable and can be considered a good fit.
- R squared value near 0 indicates that the model fails to capture enough variance in the response variable and is considered a poor fit. R squared value less than 0 indicates that the model is worse than merely using the mean value of the response variable to make predictions.

## Calculating R Squared Value using NumPy Library in Python

NumPy is a fast and efficient library in Python used for scientific computing. It is easy to use and simplifies numerous complicated computations traditionally done using loops.

### Here are the steps to calculate R squared value using NumPy:

#### Step 1: Importing NumPy Library

The first step to calculate R squared value using Numpy is by importing it in Python. The code for importing the numpy library is :

`import numpy as np`

#### Step 2: Loading the data

After importing NumPy, the next step is to load your data into Python. NumPys array enables easy and fast data manipulations.

We can load our data with NumPy like this:

`data= np.loadtxt(filename)`

#### Step 3: Creating the correlation matrix

The correlation matrix helps us to understand the relationship between the independent and the dependent variables. We can use the corrcoef() function from NumPy to calculate the correlation matrix.

`corr_matrix = np.corrcoef(x, y) # x and y are the independent and the dependent variables respectively.`

#### Step 4: Residual Errors

The residual errors represent the difference between actual and predicted dependent variables.

To calculate the residual error, you need to perform the following calculation:

```
y_pred = np.array([predict(x, a) for x in x]) #where, a represents the slope and y-intercept values.
rss = np.sum((y_pred - y) ** 2) # y is the dependent variable.
```

#### Step 5: Calculation of total sum of errors

The total sum of errors is the sum of squares of differences between actual and mean of the dependent variable. The calculation is as follows:

`tss = np.sum((y - np.mean(y)) ** 2)`

#### Step 6: Calculation of R squared value

Finally, we divide the RSS by TSS to obtain the R squared value as shown below:

`r_squared = 1 - (rss / tss)`

### Python Code Example

Here’s the Python code for calculating R squared value using NumPy:

```
import numpy as np
def predict(x, a):
return a[0] + a[1] * x
data = np.loadtxt("dataset.txt")
x = data[:, 0]
y = data[:, 1]
corr_matrix = np.corrcoef(x, y)
slope, intercept = np.polyfit(x, y, 1)
y_pred = np.array([predict(x, (intercept, slope)) for x in x])
rss = np.sum((y_pred - y) ** 2)
tss = np.sum((y - np.mean(y)) ** 2)
r_squared = 1 - (rss / tss)
print("R Squared value is:", r_squared)
```

## 3) R square with Python Sklearn Library

In the previous section, we looked at how to calculate R squared value using NumPy. In addition to NumPy, Python has several libraries that can perform this calculation. One such library is the Scikit-learn (sklearn) library.

Scikit-learn is a popular machine learning library that houses hundreds of algorithms for various machine learning tasks. Sklearn also provides a function to calculate R squared value called r2_score().

In this section, we will learn how to calculate R squared value using the sklearn library.

### Calculation of R squared using Sklearn Library

Sklearn’s r2_score() function is a simple and fast way to calculate R squared value. It takes two arguments: y_true and y_pred, where y_true represents the ground truth (actual) values of the dependent variable, and y_pred represents the predicted values of the dependent variable.

The formula for calculating R squared is as follows:

r_squared = 1 – (sum((y_true – y_pred) ** 2) / sum((y_true – mean(y_true)) ** 2))

The function is simple to use. Here’s how to calculate R squared using the sklearn library in Python:

#### Step 1: Importing Libraries

The first step is to import the required libraries.

Here, we will need numpy and sklearn.

```
import numpy as np
from sklearn.metrics import r2_score
```

#### Step 2: Loading the Data

We will load our dataset into Python using numpy. data = np.loadtxt(‘dataset.txt’)

```
x = data[:, 0].reshape(-1, 1)
y = data[:, 1].reshape(-1, 1)
```

#### Step 3: Fitting the Model

We will fit our data using the linear regression model available in sklearn.

First, we will import the LinearRegression class from sklearn and then create an instance of the class. Finally, we will fit the data.

```
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(x, y)
```

#### Step 4: Predicting the Values of the Dependent Variable

Using our model, we can predict the values of the dependent variable. We will use our model to predict the dependent variable using the independent variable.

`y_pred = model.predict(x)`

#### Step 5: Calculating R Squared Value

With the predicted values, we can now calculate R squared value using the r2_score() function available in sklearn. r_squared = r2_score(y, y_pred)

The r2_score() function automatically calculates the R squared value based on the actual and predicted values of the dependent variable.

### Python Code Example

Here’s the complete Python code for calculating R squared value using the sklearn library.

```
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
# Load data
data = np.loadtxt("dataset.txt")
x = data[:, 0].reshape(-1, 1)
y = data[:, 1].reshape(-1, 1)
# Fit the model
model = LinearRegression()
model.fit(x, y)
# Predict the values of the dependent variable
y_pred = model.predict(x)
# Calculate R squared value
r_squared = r2_score(y, y_pred)
print("R Squared value is: ", r_squared)
```

## Conclusion

In conclusion, we have learned how to calculate R squared value using two popular Python libraries: NumPy and sklearn. NumPy is a fast and efficient library that simplifies numerous computational processes in Python, including regression tasks.

On the other hand, Sklearn is a robust machine learning library that houses various algorithms for machine learning tasks and is user-friendly. The calculations with NumPy and Sklearn were done with the same dataset, and we got the same R squared value, indicating that we can trust both methods to give a reliable R squared value.

In conclusion, the best method to use depends on the context and the analysis you are performing. However, we can confidently use either method to calculate R squared value.

In this article, we have learned about the Coefficient of Determination (R squared value) in Data Science. R squared is an error metric used in regression models to evaluate the performance of a model.

We also looked at how to calculate R squared value in Python, using two popular libraries: NumPy and Sklearn. Both methods gave reliable R squared values.

R squared value is an essential metric in machine learning and is used to measure the accuracy of the model. This article highlighted the importance of R squared in data analysis and demonstrated how to calculate it.

Through this article, we hope that you have gained a better understanding of R squared value and its significance in data analysis.