How to Calculate Root Mean Square Error (RMSE) in Python

Spread the love


When it comes to evaluating the performance of regression models, the Root Mean Square Error (RMSE) is one of the most frequently used metrics. RMSE quantifies how much the predicted values deviate from the actual values. Understanding and calculating RMSE is crucial for optimizing model performance. This article provides a comprehensive guide to understanding RMSE and illustrates how to calculate it using Python effectively.

Understanding RMSE

RMSE is a measure of the differences between the values predicted by a model and the values actually observed. It represents the sample standard deviation of the differences between predicted and observed values. The formula for RMSE is:

RMSE = sqrt((1/n) * Σ(actual – predicted)^2)


  • sqrt denotes the square root
  • n is the number of observations
  • Σ represents the summation of the squares of the differences between actual and predicted values
  • actual represents the actual values
  • predicted represents the predicted values

Data Preparation

You need a dataset with actual and predicted values to compute RMSE. This could be your dataset or synthetic data. Here, we will create synthetic data using pandas:

import pandas as pd

# Create a DataFrame with actual and predicted values
data = {'Actual': [2.5, 3.6, 4.7, 5.9, 6.8], 'Predicted': [2.7, 3.4, 4.5, 6.0, 6.6]}
df = pd.DataFrame(data)

Implementing RMSE Calculation

Now, let’s create a function to calculate RMSE using the formula discussed.

import math

def calculate_rmse(actual, predicted):
    Calculate the Root Mean Square Error (RMSE)
    :param actual: list of actual values
    :param predicted: list of predicted values
    :return: RMSE
    # Ensure actual and predicted lists have the same length
    if len(actual) != len(predicted):
        raise ValueError("Input lists must have the same length")
    # Calculate RMSE
    n = len(actual)
    sum_squared_errors = sum([(a - p) ** 2 for a, p in zip(actual, predicted)])
    rmse = math.sqrt(sum_squared_errors / n)
    return rmse

Using the function.

actual = df['Actual'].tolist()
predicted = df['Predicted'].tolist()

rmse = calculate_rmse(actual, predicted)
print(f'RMSE: {rmse}')

Leveraging Scikit-learn

Python’s scikit-learn library provides a convenient function to calculate RMSE. Let’s see how to use it.

from sklearn.metrics import mean_squared_error
from math import sqrt

rmse = sqrt(mean_squared_error(df['Actual'], df['Predicted']))
print(f'RMSE (using scikit-learn): {rmse}')

Optimizing with NumPy

NumPy can be used to optimize calculations. Here’s how to calculate RMSE using NumPy.

import numpy as np

def calculate_rmse_numpy(actual, predicted):
    Calculate the Root Mean Square Error (RMSE) using numpy
    :param actual: numpy array of actual values
    :param predicted: numpy array of predicted values
    :return: RMSE
    # Ensure actual and predicted arrays have the same shape
    if actual.shape != predicted.shape:
        raise ValueError("Input arrays must have the same shape")
    # Calculate RMSE using numpy
    rmse = np.sqrt(np.mean((actual - predicted) ** 2))
    return rmse

Using the NumPy function.

actual_np = np.array(actual)
predicted_np = np.array(predicted)

rmse = calculate_rmse_numpy(actual_np, predicted_np)
print(f'RMSE (using numpy): {rmse}')


In this extensive guide, we delved into the Root Mean Square Error (RMSE), its significance in regression analysis, and various methods for calculating it in Python. We explored custom implementations, optimization with NumPy, and leveraging scikit-learn for calculating RMSE. Being an essential metric, RMSE helps in understanding the performance of regression models, enabling data scientists and analysts to refine and optimize models for better accuracy.

Leave a Reply