Show Sidebar Hide Sidebar

Norm

How to compute the norm of a NumPy array. These are scalar quantities which represent the size of the array.

New to Plotly?

Plotly's Python library is free and open source! Get started by downloading the client and reading the primer.
You can set up Plotly to work in online or offline mode, or in jupyter notebooks.
We also have a quick-reference cheatsheet (new!) to help you get started!

Imports

This tutorial imports Numpy.

In [1]:
import plotly.plotly as py
import plotly.graph_objs as go

from plotly.tools import FigureFactory as FF

import numpy as np

2-Norm of Array

np.linalg.norm() computes the norm of a NumPy array according to an order, ord, which specifies the metric by which the norm takes. For example, if we are given an array

$$ \begin{align*} [x_1, ..., x_n] \end{align*} $$

with numbers $x_i$ then we can compute the Frobenius Norm or more commonly called the 2-norm by doing:

$$ \begin{align*} \sqrt{\sum_{i=1}^{n}{x_i^{2}}} \end{align*} $$

In NumPy you can also use np.linalg.norm() to compute the norm of a matrix, or a matrix's columns or rows, treating each as their own array.

In [2]:
import plotly.plotly as py
import plotly.graph_objs as go

size = 40
array_normal = np.random.randn(size)
array_random = np.random.random(size)

trace_1 = go.Scatter(
    x=[i for i in range(size)],
    y=array_normal,
    mode='markers',
    name='Normal Dist',
    marker=dict(
        color='#F23557',
        size=2*int(np.linalg.norm(array_normal))
    )
)

trace_2 = go.Scatter(
    x=[i for i in range(size)],
    y=array_random,
    mode='markers',
    name='From [0, 1)',
    marker=dict(
        color='#1E64F0',
        size=2*int(np.linalg.norm(array_random))
    )
)

data = [trace_1, trace_2]
py.iplot(data, filename='numpy-normalize-2-norm')
Out[2]:

2-Norm by Matrix Row

By setting axis to 1 to return an array of the respective row's norm value. In the example below we can visualize the norm values of each row by looking at their color: the darker the shade of BLUE, the greater the value of the norm.

In [3]:
import plotly.plotly as py
from plotly.tools import FigureFactory as FF

z_norms = [[.1, .3, .5, .7],  
           [1, .8, .6, .4],
           [.6, .4, .2, .0],  
           [.9, .7, .5, .3]]

z_text = [[.1, .3, .5, .7],  
          [1, .8, .6, .4],
          [.6, .4, .2, .0],  
          [.9, .7, .5, .3]]

colorscale =  [[0, 'rgb(220,220,220)'],
               [0.35, 'rgb(106,137,247)'],
               [0.5, 'rgb(90,120,245)'],
               [0.6, 'rgb(70,100,245)'],
               [0.7, 'rgb(40,60,190)'],
               [1, 'rgb(5,10,172)']]

row_norms = np.linalg.norm(z_text, axis=1)
for index in range(len(z_norms)):
    z_norms[index] = [row_norms[index] for j in range(len(z_norms))]
    
fig = FF.create_annotated_heatmap(z_norms, annotation_text=z_text, colorscale=colorscale)
py.iplot(fig, filename='numpy-normalize-matrix-rows-2-norm')
Out[3]:
In [4]:
help(np.linalg.norm)
Help on function norm in module numpy.linalg.linalg:

norm(x, ord=None, axis=None, keepdims=False)
    Matrix or vector norm.
    
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.
    
    Parameters
    ----------
    x : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D.
    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.
    
        .. versionadded:: 1.10.0
    
    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    
    Notes
    -----
    For values of ``ord <= 0``, the result is, strictly speaking, not a
    mathematical 'norm', but it may still be useful for various numerical
    purposes.
    
    The following norms can be calculated:
    
    =====  ============================  ==========================
    ord    norm for matrices             norm for vectors
    =====  ============================  ==========================
    None   Frobenius norm                2-norm
    'fro'  Frobenius norm                --
    'nuc'  nuclear norm                  --
    inf    max(sum(abs(x), axis=1))      max(abs(x))
    -inf   min(sum(abs(x), axis=1))      min(abs(x))
    0      --                            sum(x != 0)
    1      max(sum(abs(x), axis=0))      as below
    -1     min(sum(abs(x), axis=0))      as below
    2      2-norm (largest sing. value)  as below
    -2     smallest singular value       as below
    other  --                            sum(abs(x)**ord)**(1./ord)
    =====  ============================  ==========================
    
    The Frobenius norm is given by [1]_:
    
        :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
    
    The nuclear norm is the sum of the singular values.
    
    References
    ----------
    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
    
    Examples
    --------
    >>> from numpy import linalg as LA
    >>> a = np.arange(9) - 4
    >>> a
    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
    >>> b = a.reshape((3, 3))
    >>> b
    array([[-4, -3, -2],
           [-1,  0,  1],
           [ 2,  3,  4]])
    
    >>> LA.norm(a)
    7.745966692414834
    >>> LA.norm(b)
    7.745966692414834
    >>> LA.norm(b, 'fro')
    7.745966692414834
    >>> LA.norm(a, np.inf)
    4.0
    >>> LA.norm(b, np.inf)
    9.0
    >>> LA.norm(a, -np.inf)
    0.0
    >>> LA.norm(b, -np.inf)
    2.0
    
    >>> LA.norm(a, 1)
    20.0
    >>> LA.norm(b, 1)
    7.0
    >>> LA.norm(a, -1)
    -4.6566128774142013e-010
    >>> LA.norm(b, -1)
    6.0
    >>> LA.norm(a, 2)
    7.745966692414834
    >>> LA.norm(b, 2)
    7.3484692283495345
    
    >>> LA.norm(a, -2)
    nan
    >>> LA.norm(b, -2)
    1.8570331885190563e-016
    >>> LA.norm(a, 3)
    5.8480354764257312
    >>> LA.norm(a, -3)
    nan
    
    Using the `axis` argument to compute vector norms:
    
    >>> c = np.array([[ 1, 2, 3],
    ...               [-1, 1, 4]])
    >>> LA.norm(c, axis=0)
    array([ 1.41421356,  2.23606798,  5.        ])
    >>> LA.norm(c, axis=1)
    array([ 3.74165739,  4.24264069])
    >>> LA.norm(c, ord=1, axis=1)
    array([ 6.,  6.])
    
    Using the `axis` argument to compute matrix norms:
    
    >>> m = np.arange(8).reshape(2,2,2)
    >>> LA.norm(m, axis=(1,2))
    array([  3.74165739,  11.22497216])
    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
    (3.7416573867739413, 11.224972160321824)

Still need help?
Contact Us

For guaranteed 24 hour response turnarounds, upgrade to a Developer Support Plan.