How to Calculate Canberra Distance in Python

Spread the love

The Canberra distance is a numerical measure of the distance between pairs of points in a vector space, particularly applicable for data scattered around the origin. This metric has unique characteristics that make it useful in specific domains, especially in signal processing, computer vision, and machine learning.

This article will discuss the concept of Canberra distance, provide a step-by-step guide to calculating it in Python, and demonstrate how it can be employed in real-world scenarios. We’ll also show how to leverage Python libraries like numpy and scikit-learn to simplify computations and enhance performance.


Before proceeding, you should have a basic understanding of Python, including data types, loops, and functions. You should also be familiar with the numpy and scikit-learn libraries. If you haven’t installed these libraries yet, you can do so using pip:

pip install numpy
pip install scikit-learn

Defining Canberra Distance

The Canberra distance is a variation of Manhattan distance and is based on a different scale. It is defined as the sum of the absolute differences between the two data points, divided by the sum of the absolute values of the two data points, summed over all dimensions.

If A and B are two points in n-dimensional space, the Canberra distance d is computed as:

d(A, B) = Σ (|A_i – B_i| / (|A_i| + |B_i|))

where A_i and B_i are the ith elements of points A and B respectively.

The Canberra distance has a useful property of putting less weight on dimensions where both points have high magnitude, and more weight on dimensions where one point has a low magnitude and the other has a high magnitude. This property makes the Canberra distance particularly useful when dealing with data scattered around the origin.

Calculating Canberra Distance in Python

Canberra Distance in Python from Scratch

Let’s start by defining a function that computes the Canberra distance between two points in an n-dimensional space:

def canberra_distance(point1, point2):
    return sum(abs(a - b) / (abs(a) + abs(b)) for a, b in zip(point1, point2))

point1 = [2, 3, 1]
point2 = [5, 7, 3]

print(canberra_distance(point1, point2))  

Here, we use the zip function to create pairs of corresponding elements from the two points. We then calculate the absolute difference divided by the absolute sum for each pair and sum up these values.

Canberra Distance with Numpy

If you’re working with large amounts of data, it’s a good idea to use numpy for computations. Here’s how you can calculate the Canberra distance with numpy:

import numpy as np

def canberra_distance_numpy(point1, point2):
    return np.sum(np.abs(np.array(point1) - np.array(point2)) / (np.abs(np.array(point1)) + np.abs(np.array(point2))))

point1 = [2, 3, 1]
point2 = [5, 7, 3]

print(canberra_distance_numpy(point1, point2)) 

Numpy’s operations are vectorized, which means they operate on arrays element-wise. This makes numpy’s computations much more efficient for large datasets compared to standard Python.

Canberra Distance with Scikit-learn

The scikit-learn library provides a function to compute the Canberra distance directly. This can be particularly useful when you’re dealing with machine learning applications:

from scipy.spatial import distance

point1 = [2, 3, 1]
point2 = [5, 7, 3]

print(distance.canberra(point1, point2))  

The distance.canberra function takes two 1-D arrays representing the vectors and returns the Canberra distance between them.

Applications of Canberra Distance

The Canberra distance can be a useful tool in various domains. For instance, it’s used in signal processing for spectral distance measurements, which can be useful for comparing signals or sounds. In image processing, it can be used for texture comparison.

In machine learning, Canberra distance can be used in clustering and classification algorithms such as K-Nearest Neighbors (KNN) and K-Means. The choice of distance measure can significantly influence the performance of these algorithms, and the Canberra distance is a good option when your data is centered around the origin.


In this article, we have introduced the Canberra distance, a fundamental concept in geometry and machine learning, and demonstrated how to calculate it in Python, both using plain Python and with the help of numpy and scipy.

Understanding and implementing various distance measures is essential in the field of data science and machine learning, as many algorithms rely heavily on distance computations. While we have focused on Canberra distance here, there are many other distance measures (e.g., Euclidean, Manhattan, cosine) that may be more suitable depending on the problem at hand, so it’s beneficial to understand the differences and know how to implement each.

Leave a Reply