¿Cómo normalizar una matriz en NumPy?

Me gustaría tener la norma de una matriz NumPy. Más específicamente, estoy buscando una versión equivalente de esta función

def normalize(v):
    norm = np.linalg.norm(v)
    if norm == 0: 
       return v
    return v / norm

¿Hay algo así en skearno numpy?

Esta función funciona en una situación donde ves el vector 0.

Si usa scikit-learn, puede usar sklearn.preprocessing.normalize:

import numpy as np
from sklearn.preprocessing import normalize

x = np.random.rand(1000)*10
norm1 = x / np.linalg.norm(x)
norm2 = normalize(x[:,np.newaxis], axis=0).ravel()
print np.all(norm1 == norm2)
# True

Estoy de acuerdo en que sería bueno que tal función fuera parte de las baterías incluidas. Pero no lo es, que yo sepa. Aquí hay una versión para ejes arbitrarios y que ofrece un rendimiento óptimo.

import numpy as np

def normalized(a, axis=-1, order=2):
    l2 = np.atleast_1d(np.linalg.norm(a, order, axis))
    l2[l2==0] = 1
    return a / np.expand_dims(l2, axis)

A = np.random.randn(3,3,3)
print(normalized(A,0))
print(normalized(A,1))
print(normalized(A,2))

print(normalized(np.arange(3)[:,None]))
print(normalized(np.arange(3)))

Puede especificar ord para obtener la norma L1. Para evitar la división cero, uso eps, pero tal vez eso no sea genial.

def normalize(v):
    norm=np.linalg.norm(v, ord=1)
    if norm==0:
        norm=np.finfo(v.dtype).eps
    return v/norm

Esto también podría funcionar para ti

import numpy as np
normalized_v = v / np.sqrt(np.sum(v**2))

pero falla cuando vtiene longitud 0.

Si tiene datos multidimensionales y desea que cada eje se normalice a su máximo o su suma:

def normalize(_d, to_sum=True, copy=True):
    # d is a (n x dimension) np array
    d = _d if not copy else np.copy(_d)
    d -= np.min(d, axis=0)
    d /= (np.sum(d, axis=0) if to_sum else np.ptp(d, axis=0))
    return d

Utiliza la función numpys pico a pico .

a = np.random.random((5, 3))

b = normalize(a, copy=False)
b.sum(axis=0) # array([1., 1., 1.]), the rows sum to 1

c = normalize(a, to_sum=False, copy=False)
c.max(axis=0) # array([1., 1., 1.]), the max of each row is 1

También existe la función unit_vector()de normalizar vectores en el popular módulo de transformaciones de Christoph Gohlke:

import transformations as trafo
import numpy as np

data = np.array([[1.0, 1.0, 0.0],
                 [1.0, 1.0, 1.0],
                 [1.0, 2.0, 3.0]])

print(trafo.unit_vector(data, axis=1))

Usted mencionó el aprendizaje de sci-kit, así que quiero compartir otra solución.

kit de ciencia aprender MinMaxScaler

En sci-kit learn, hay una API llamada MinMaxScaler que puede personalizar el rango de valores a su gusto.

También se ocupa de los problemas de NaN para nosotros.

Los NaN se tratan como valores perdidos: no se tienen en cuenta y se mantienen en la transformación. ... ver referencia [1]

Muestra de código

El código es simple, solo escribe

# Let's say X_train is your input dataframe
from sklearn.preprocessing import MinMaxScaler
# call MinMaxScaler object
min_max_scaler = MinMaxScaler()
# feed in a numpy array
X_train_norm = min_max_scaler.fit_transform(X_train.values)
# wrap it up if you need a dataframe
df = pd.DataFrame(X_train_norm)

• [1] sklearn.preprocessing.MinMaxScaler

Sin sklearny usando solo numpy. Simplemente defina una función :.

Suponiendo que las filas son las variables y las columnas las muestras ( axis= 1):

import numpy as np

# Example array
X = np.array([[1,2,3],[4,5,6]])

def stdmtx(X):
    means = X.mean(axis =1)
    stds = X.std(axis= 1, ddof=1)
    X= X - means[:, np.newaxis]
    X= X / stds[:, np.newaxis]
    return np.nan_to_num(X)

salida:

X
array([[1, 2, 3],
       [4, 5, 6]])

stdmtx(X)
array([[-1.,  0.,  1.],
       [-1.,  0.,  1.]])

Si desea normalizar n vectores de características dimensionales almacenados en un tensor 3D, también puede usar PyTorch:

import numpy as np
from torch import FloatTensor
from torch.nn.functional import normalize

vecs = np.random.rand(3, 16, 16, 16)
norm_vecs = normalize(FloatTensor(vecs), dim=0, eps=1e-16).numpy()

Si está trabajando con vectores 3D, puede hacerlo de manera concisa usando el toolbelt vg . Es una capa ligera encima de numpy y admite valores individuales y vectores apilados.

import numpy as np
import vg

x = np.random.rand(1000)*10
norm1 = x / np.linalg.norm(x)
norm2 = vg.normalize(x)
print np.all(norm1 == norm2)
# True

Creé la biblioteca en mi último inicio, donde estaba motivada por usos como este: ideas simples que son demasiado detalladas en NumPy.

Si no necesita la máxima precisión, su función se puede reducir a:

v_norm = v / (np.linalg.norm(v) + 1e-16)

Si trabaja con una matriz multidimensional, es posible una solución rápida.

Digamos que tenemos una matriz 2D, que queremos normalizar por el último eje, mientras que algunas filas tienen la norma cero.

import numpy as np
arr = np.array([
    [1, 2, 3], 
    [0, 0, 0],
    [5, 6, 7]
], dtype=np.float)

lengths = np.linalg.norm(arr, axis=-1)
print(lengths)  # [ 3.74165739  0.         10.48808848]
arr[lengths > 0] = arr[lengths > 0] / lengths[lengths > 0][:, np.newaxis]
print(arr)
# [[0.26726124 0.53452248 0.80178373]
# [0.         0.         0.        ]
# [0.47673129 0.57207755 0.66742381]]