Adventures in Machine Learning

Measuring Machine Learning Accuracy with MAPE: A NumPy and Scikit-Learn Guide

Accuracy is an essential aspect of any machine learning algorithm. Evaluating the effectiveness of a model or a prediction system based on its accuracy is one of the most critical steps in machine learning.

A popular method for measuring accuracy is Mean Absolute Percentage Error (MAPE). In this article, we will introduce the concept of MAPE, its definition, importance, interpretation, and implementation using NumPy module.

By the end of this article, you will have a good understanding of what MAPE is, why it is important, and how to implement it using NumPy module.

Definition and Importance of MAPE

MAPE is an error metric used to measure the accuracy of forecasting and prediction methods. It is a measure of the absolute percentage error between the actual values and the predicted or estimated values.

MAPE is an essential tool used to evaluate machine learning algorithms’ effectiveness and accuracy. It assists in identifying algorithms that produce the most reliable predictions and forecasts, ensuring that the predictions are not too far off from the actual values.

Having an accurate indication of how well a machine learning algorithm performs can help in several ways, such as improving the algorithm’s accuracy to solve specific problems and reducing costs or errors associated with making wrong predictions.

Interpretation of MAPE

The formula for calculating MAPE is relatively simple. It involves taking the mean of the absolute percentage error of all the predictions over a specific period.

The formula is as follows:

MAPE = 1/n * (|Actual Value – Estimated Value|/ Actual Value)*100%

Here, n represents the total number of predictions. The mean function gives the average percentage of the absolute error, expressed as a percentage, while the absolute function is used to ensure the difference between the actual and estimated values is always positive.

MAPE expresses the accuracy of a prediction in terms of a percentage, making it easy to understand and interpret. For instance, if a MAPE score is 10%, it means the model’s prediction error, on average, amounts to 10% of the actual value.

Importing and Splitting Dataset

To implement MAPE using NumPy, we need to start by importing the necessary libraries and preparing the dataset we will be working with. We will begin by importing the required libraries, which include NumPy and scikit-learn.

Then, we will load the dataset and divide it into training and testing sets. We will use the train_test_split() function from scikit-learn to perform this task.

Defining MAPE Function and Applying Linear Regression

Once the dataset is ready, we can start implementing MAPE using NumPy. The first step is to define a function that will calculate the MAPE score. We will use this function to evaluate the accuracy of the predictions outputted by our machine learning algorithm.

The next step involves applying a machine learning algorithm to the training dataset. In this example, we will use Linear Regression.

Once the algorithm has been trained on the data, we will use the predict() function to predict the values for the test dataset. Finally, we will use the MAPE function defined earlier to calculate the accuracy of the Linear Regression algorithm’s predictions.

The lower the MAPE score, the better the accuracy of the algorithm.


MAPE is a great tool to use when evaluating the accuracy of machine learning algorithms. It offers a percentage-based outlook on the error in prediction, emphasizing the need for a higher precision in forecasting models.

With the help of NumPy library, we can easily calculate MAPE score by writing a simple code snippet. By understanding the fundamentals of MAPE, we can make informed decisions about machine learning algorithms and make forecasts with greater accuracy.

Introducing scikit learn library

Scikit-learn is a powerful Python library used widely for machine learning tasks such as data preprocessing, model selection, and evaluation. It is built on top of NumPy, Pandas, and Matplotlib, and provides a convenient interface for implementing machine learning algorithms.

Scikit-learn makes it easy to develop and implement machine learning algorithms, partly due to the library’s user-friendly design. It offers several modules and functions that can be used for various machine learning tasks.

In this case, we will be using the mean_absolute_error() function to implement MAPE.

Example implementation of MAPE

To implement MAPE using scikit-learn, we must first load the necessary libraries. We will need pandas, numpy, and scikit-learn.

Then we will load the dataset we want to use to measure the accuracy of our model. After loading the dataset and the necessary libraries, we will perform data cleaning operations.

This step involves converting categorical data into numerical data and filling in missing data. The cleaned data is then divided into a training and testing set using the train_test_split() function.

The next step is to train the model using the training set. We will use the Linear Regression algorithm in this example.

Once we have trained our model, we will make predictions on the testing set using the predict() function. With the actual and predicted values, we can now calculate the MAPE score using the mean_absolute_error() function from scikit-learn.

The formula used by this function is similar to the one used for the MAPE score formula shown earlier. It calculates the mean absolute error between the actual and predicted values.

The code snippet for calculating MAPE using scikit-learn can be written as follows:

“` python

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_absolute_error

# Load the dataset

df = pd.read_csv(‘data.csv’)

# Clean the data

# … # Split dataset into train and test sets

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)

# Train the model using Linear Regression

model = LinearRegression(), Y_train)

# Make predictions on the test set

Y_Predicted = model.predict(X_test)

# Calculate the MAPE score

MAPE = mean_absolute_error(Y_test, Y_Predicted)

print(“MAPE Score: “, MAPE)


The output of this code will be the MAPE score for our prediction system.

The lower the score, the more accurate the predictions are. The advantage of using scikit-learn to implement MAPE is that the calculations are automatic, and we do not have to write long formulas to calculate the error.


Mean Absolute Percentage Error (MAPE) is a crucial metric for measuring the accuracy of machine learning models. By implementing it using Scikit-learn, we can automate the processes of performing data cleaning, splitting into train and test datasets, and calculating the error.

With the help of scikit-learn, we can design prediction models and evaluate their accuracy with minimal effort. Scikit-learn is an excellent learning resource for beginners and experienced data scientists who want to implement state-of-the-art machine learning algorithms.

It provides a wide range of tools and functions that can be used to implement numerous machine learning tasks. In conclusion, anyone working with machine learning algorithms should be familiar with MAPE and how to implement it using scikit-learn.

In this article, we introduced Mean Absolute Percentage Error (MAPE) as a method for measuring the accuracy of machine learning models. We discussed the importance of MAPE as an error metric and how it can be used to improve model predictions by evaluating its percentage of absolute error.

We explored two methods for implementing MAPE using NumPy and scikit-learn libraries, including cleaning the data, training and testing the model, and calculating the error. By understanding MAPE and its implementation techniques, we can make more informed decisions when selecting machine learning algorithms and make accurate predictions with greater precision.