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?¶

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.

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?