Jika anda're menggunakan scikit-belajar anda dapat menggunakan 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

Aku akan setuju bahwa itu lebih baik jika fungsi tersebut adalah bagian dari baterai yang disertakan. Tapi itu bukan't, sejauh yang saya tahu. Di sini adalah versi untuk sewenang-wenang kapak, dan memberikan kinerja yang optimal.

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)))

Anda dapat menentukan ord untuk mendapatkan L1 norma. Untuk menghindari nol divisi I menggunakan eps, tapi yang's mungkin tidak besar.

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

Jika anda memiliki data multidimensi dan ingin masing-masing sumbu normal untuk max atau sum:

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

Menggunakan numpys puncak ke puncak fungsi.

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

Ini juga mungkin bekerja untuk anda

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

tapi gagal ketika v memiliki panjang 0.

Ada juga fungsi unit_vector() untuk menormalkan vektor di tempat transformasi modul oleh 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))

Jika anda ingin menormalkan n dimensi vektor fitur yang tersimpan di sebuah tensor 3D, anda juga bisa menggunakan 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()

Jika anda're bekerja dengan 3D vektor, anda dapat melakukan ini dengan singkat menggunakan toolbelt vg. It's lapisan cahaya di atas numpy dan mendukung nilai-nilai tunggal dan ditumpuk vektor.

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

Saya membuat perpustakaan di startup terakhir saya, di mana ia termotivasi dengan menggunakan seperti ini: ide-ide sederhana yang terlalu verbose di NumPy.

Yang anda sebutkan sci-kit belajar, jadi saya ingin berbagi solusi lain.

sci-kit belajar MinMaxScaler

Dalam sci-kit belajar, ada API yang disebut MinMaxScaler yang dapat menyesuaikan jangkauan nilai yang anda inginkan.

Hal ini juga menangani NaN masalah bagi kita.

NaNs diperlakukan sebagai nilai yang hilang: diabaikan dalam fit, dan dipelihara di transform. ... lihat referensi [1]

Contoh kode

Kode ini sederhana, cukup ketik

# 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)

Referensi

• [1] sklearn.preprocessing.MinMaxScaler

Jika anda don't perlu presisi maksimal, fungsi anda dapat dikurangi dengan:

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

Tanpa sklearn dan menggunakan numpy. Hanya mendefinisikan fungsi:.

Dengan asumsi bahwa baris ini adalah variabel dan kolom sampel (sumbu= 1):

`` impor numpy sebagai np

Contoh array

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

def stdmtx(X): berarti = X. berarti(axis =1) pms = X. std(axis= 1, high aa=1) X= X - means[:, np.newaxis] X= X / pms[:, np.newaxis] kembali np.nan_to_num(X)

``

output:

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

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

``

Jika anda bekerja dengan array multidimensi berikut solusi cepat adalah mungkin.

Mengatakan kami telah 2D array, yang kita inginkan untuk menormalkan terakhir oleh axis, sementara beberapa baris yang memiliki nol norma.

``python impor numpy sebagai np arr = np.array([ [1, 2, 3], [0, 0, 0], [5, 6, 7] ], dtype=np.float)

panjang = np.linalg.norma(arr, axis=-1) cetak(panjang) # [ 3.74165739 0. 10.48808848] arr[panjang > 0] = arr[panjang > 0] / panjang[panjang > 0][:, np.newaxis] cetak(arr)

[[0.26726124 0.53452248 0.80178373]

[0. 0. 0. ]

[0.47673129 0.57207755 0.66742381]]

``