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

## Accuracy Evaluation in Machine Learning

### 1. Introduction

Accuracy is crucial in any machine learning algorithm. Evaluating a model’s effectiveness based on its accuracy is a critical step. One popular method for measuring accuracy is Mean Absolute Percentage Error (MAPE).

This article will explore the concept of MAPE, its definition, importance, interpretation, and implementation using the NumPy module. By the end, you’ll understand what MAPE is, why it’s important, and how to implement it using NumPy.

### 2. Definition and Importance of MAPE

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

MAPE is essential for evaluating machine learning algorithms’ effectiveness and accuracy. It helps identify algorithms producing the most reliable predictions and forecasts, ensuring that 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.

### 3. Interpretation of MAPE

#### 3.1 Formula

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.

#### 3.2 Example

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.

### 4. Implementing MAPE with NumPy

#### 4.1 Importing and Splitting Dataset

To implement MAPE using NumPy, we need to import the necessary libraries and prepare 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.

#### 4.2 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.

### 5. Conclusion

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 the NumPy library, we can easily calculate the 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:

``````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

# 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()
model.fit(X_train, 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.

## Conclusion

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.

This article 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.