Como normalizar uma matriz NumPy para dentro de um determinado intervalo?

Depois de fazer algum processamento em uma matriz de áudio ou imagem, ele precisa ser normalizado dentro de um intervalo antes de poder ser gravado novamente em um arquivo. Isso pode ser feito da seguinte maneira:

# Normalize audio channels to between -1.0 and +1.0
audio[:,0] = audio[:,0]/abs(audio[:,0]).max()
audio[:,1] = audio[:,1]/abs(audio[:,1]).max()

# Normalize image to between 0 and 255
image = image/(image.max()/255.0)

Existe uma maneira menos detalhada de função de conveniência para fazer isso? matplotlib.colors.Normalize()não parece estar relacionado.

audio /= np.max(np.abs(audio),axis=0)
image *= (255.0/image.max())

Usando /=e *=permite eliminar uma matriz temporária intermediária, economizando um pouco de memória. A multiplicação é mais barata que a divisão, então

image *= 255.0/image.max()    # Uses 1 division and image.size multiplications

é marginalmente mais rápido que

image /= image.max()/255.0    # Uses 1+image.size divisions

Como estamos usando métodos numpy básicos aqui, acho que essa é a solução mais eficiente possível.

As operações no local não alteram o tipo de matriz do contêiner. Como os valores normalizados desejados são flutuantes, as matrizes audioe imageprecisam ter o tipo de ponto de ponto flutuante antes que as operações no local sejam executadas. Se eles ainda não são do tipo de ponto flutuante, será necessário convertê-los usando astype. Por exemplo,

image = image.astype('float64')

Se a matriz contiver dados positivos e negativos, eu usaria:

import numpy as np

a = np.random.rand(3,2)

# Normalised [0,1]
b = (a - np.min(a))/np.ptp(a)

# Normalised [0,255] as integer: don't forget the parenthesis before astype(int)
c = (255*(a - np.min(a))/np.ptp(a)).astype(int)        

# Normalised [-1,1]
d = 2.*(a - np.min(a))/np.ptp(a)-1

Se a matriz contiver nan, uma solução pode ser removê-las apenas como:

def nan_ptp(a):
    return np.ptp(a[np.isfinite(a)])

b = (a - np.nanmin(a))/nan_ptp(a)

No entanto, dependendo do contexto, você pode querer tratar de maneira nandiferente. Por exemplo, interpole o valor, substituindo por, por exemplo, 0 ou gere um erro.

Por fim, vale a pena mencionar, mesmo que não seja uma pergunta do OP, a padronização :

e = (a - np.mean(a)) / np.std(a)

Você também pode redimensionar usando sklearn. As vantagens são que você pode ajustar a normalização do desvio padrão, além de centralizar os dados na média, e fazer isso no eixo, pelos recursos ou pelos registros.

from sklearn.preprocessing import scale
X = scale( X, axis=0, with_mean=True, with_std=True, copy=True )

Os argumentos de palavra-chave axis, with_mean, with_stdsão auto-explicativas, e são mostrados em seu estado padrão. O argumento copyexecuta a operação no local, se estiver definido como False. Documentação aqui .

Você pode usar a versão "i" (como em idiv, imul ..) e ela não parece nem um pouco ruim:

image /= (image.max()/255.0)

No outro caso, você pode escrever uma função para normalizar uma matriz n-dimensional por colunas:

def normalize_columns(arr):
    rows, cols = arr.shape
    for col in xrange(cols):
        arr[:,col] /= abs(arr[:,col]).max()

Você está tentando escalar min-max os valores audioentre -1 e +1 e imageentre 0 e 255.

Usando sklearn.preprocessing.minmax_scale, deve resolver facilmente o seu problema.

por exemplo:

audio_scaled = minmax_scale(audio, feature_range=(-1,1))

e

shape = image.shape
image_scaled = minmax_scale(image.ravel(), feature_range=(0,255)).reshape(shape)

Nota : Não deve ser confundida com a operação que dimensiona a norma (comprimento) de um vetor para um determinado valor (geralmente 1), que também é comumente referido como normalização.

Uma solução simples é usar os dimensionadores oferecidos pela biblioteca sklearn.preprocessing.

scaler = sk.MinMaxScaler(feature_range=(0, 250))
scaler = scaler.fit(X)
X_scaled = scaler.transform(X)
# Checking reconstruction
X_rec = scaler.inverse_transform(X_scaled)

O erro X_rec-X será zero. Você pode ajustar o intervalo_funcionalidade para suas necessidades ou até mesmo usar um scaler padrão sk.StandardScaler ()

Eu tentei seguir isso , e recebi o erro

TypeError: ufunc 'true_divide' output (typecode 'd') could not be coerced to provided output parameter (typecode 'l') according to the casting rule ''same_kind''

A numpymatriz que eu estava tentando normalizar era uma integermatriz. Parece que eles preteriram a conversão de tipos nas versões> 1.10, e você precisa usar isso numpy.true_divide()para resolver isso.

arr = np.array(img)
arr = np.true_divide(arr,[255.0],out=None)

imgfoi um PIL.Imageobjeto.