Saya memiliki dataframe dalam panda di mana setiap kolom memiliki rentang nilai yang berbeda. Sebagai contoh:

df:

A     B   C
1000  10  0.5
765   5   0.35
800   7   0.09

Adakah yang tahu bagaimana saya bisa menormalkan kolom-bingkai dataframe ini di mana setiap nilai antara 0 dan 1?

Output yang saya inginkan adalah:

A     B    C
1     1    1
0.765 0.5  0.7
0.8   0.7  0.18(which is 0.09/0.5)

Anda dapat menggunakan sklearn paket dan utilitas preprocessing terkait untuk menormalkan data.

import pandas as pd
from sklearn import preprocessing

x = df.values #returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled = min_max_scaler.fit_transform(x)
df = pd.DataFrame(x_scaled)

Untuk informasi lebih lanjut, lihat dokumentasi scikit-learn pada data preprocessing: penskalaan fitur ke kisaran.

satu cara mudah dengan menggunakan Panda : (di sini saya ingin menggunakan normalisasi rata-rata)

normalized_df=(df-df.mean())/df.std()

untuk menggunakan normalisasi min-max:

normalized_df=(df-df.min())/(df.max()-df.min())

Sunting: Untuk mengatasi beberapa masalah, perlu dikatakan bahwa Panda secara otomatis menerapkan fungsi colomn-wise dalam kode di atas.

Berdasarkan pos ini: /stats/70801/how-to-normalize-data-to-0-1-range

Anda dapat melakukan hal berikut:

def normalize(df):
    result = df.copy()
    for feature_name in df.columns:
        max_value = df[feature_name].max()
        min_value = df[feature_name].min()
        result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)
    return result

Anda tidak perlu khawatir tentang apakah nilai Anda negatif atau positif. Dan nilainya harus tersebar dengan baik antara 0 dan 1.

Masalah Anda sebenarnya adalah transformasi sederhana yang bekerja pada kolom:

def f(s):
    return s/s.max()

frame.apply(f, axis=0)

Atau bahkan lebih singkat:

   frame.apply(lambda x: x/x.max(), axis=0)

Jika Anda suka menggunakan paket sklearn, Anda dapat menyimpan kolom dan nama indeks dengan menggunakan panda locseperti:

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler() 
scaled_values = scaler.fit_transform(df) 
df.loc[:,:] = scaled_values

Sederhana itu indah:

df["A"] = df["A"] / df["A"].max()
df["B"] = df["B"] / df["B"].max()
df["C"] = df["C"] / df["C"].max()

Anda dapat membuat daftar kolom yang ingin dinormalisasi

column_names_to_normalize = ['A', 'E', 'G', 'sadasdsd', 'lol']
x = df[column_names_to_normalize].values
x_scaled = min_max_scaler.fit_transform(x)
df_temp = pd.DataFrame(x_scaled, columns=column_names_to_normalize, index = df.index)
df[column_names_to_normalize] = df_temp

Bingkai Data Pandas Anda sekarang dinormalisasi hanya pada kolom yang Anda inginkan

Namun , jika Anda menginginkan yang sebaliknya , pilih daftar kolom yang TIDAK ingin Anda normalkan, Anda bisa membuat daftar semua kolom dan menghapus yang tidak diinginkan

column_names_to_not_normalize = ['B', 'J', 'K']
column_names_to_normalize = [x for x in list(df) if x not in column_names_to_not_normalize ]

Saya pikir cara yang lebih baik untuk melakukannya dalam panda adalah adil

df = df/df.max().astype(np.float64)

Sunting Jika dalam bingkai data Anda ada angka negatif yang harus Anda gunakan sebagai gantinya

df = df/df.loc[df.abs().idxmax()].astype(np.float64)

Solusi yang diberikan oleh Sandman dan Praveen sangat baik. Satu-satunya masalah dengan itu jika Anda memiliki variabel kategori di kolom lain dari bingkai data Anda metode ini akan membutuhkan beberapa penyesuaian.

Solusi saya untuk jenis masalah ini adalah sebagai berikut:

 from sklearn import preprocesing
 x = pd.concat([df.Numerical1, df.Numerical2,df.Numerical3])
 min_max_scaler = preprocessing.MinMaxScaler()
 x_scaled = min_max_scaler.fit_transform(x)
 x_new = pd.DataFrame(x_scaled)
 df = pd.concat([df.Categoricals,x_new])

Contoh standardisasi berbeda dalam python.

Untuk referensi lihat artikel wikipedia ini: https://en.wikipedia.org/wiki/Unprice_estimation_of_standard_deviation

Contoh Data

import pandas as pd
df = pd.DataFrame({
               'A':[1,2,3],
               'B':[100,300,500],
               'C':list('abc')
             })
print(df)
   A    B  C
0  1  100  a
1  2  300  b
2  3  500  c

Normalisasi menggunakan panda (Memberikan perkiraan tidak bias)

Ketika menormalkan kita cukup mengurangi mean dan membaginya dengan standar deviasi.

df.iloc[:,0:-1] = df.iloc[:,0:-1].apply(lambda x: (x-x.mean())/ x.std(), axis=0)
print(df)
     A    B  C
0 -1.0 -1.0  a
1  0.0  0.0  b
2  1.0  1.0  c

Normalisasi menggunakan sklearn (Memberikan perkiraan bias, berbeda dari panda)

Jika Anda melakukan hal yang sama dengan sklearnAnda akan mendapatkan hasil yang BERBEDA!

import pandas as pd

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()


df = pd.DataFrame({
               'A':[1,2,3],
               'B':[100,300,500],
               'C':list('abc')
             })
df.iloc[:,0:-1] = scaler.fit_transform(df.iloc[:,0:-1].to_numpy())
print(df)
          A         B  C
0 -1.224745 -1.224745  a
1  0.000000  0.000000  b
2  1.224745  1.224745  c

Apakah perkiraan bias sklearn membuat Pembelajaran Mesin Kurang Kuat?

TIDAK.

Dokumentasi resmi sklearn.preprocessing.scale menyatakan bahwa menggunakan estimator yang bias TIDAK UNIK untuk mempengaruhi kinerja algoritma pembelajaran mesin dan kita dapat menggunakannya dengan aman.

From official documentation:
We use a biased estimator for the standard deviation,
equivalent to numpy.std(x, ddof=0). 
Note that the choice of ddof is unlikely to affect model performance.

Bagaimana dengan Scaling MinMax?

Tidak ada perhitungan Standar Deviasi dalam penskalaan MinMax. Jadi hasilnya sama di kedua panda dan scikit-belajar.

import pandas as pd
df = pd.DataFrame({
               'A':[1,2,3],
               'B':[100,300,500],
             })
(df - df.min()) / (df.max() - df.min())
     A    B
0  0.0  0.0
1  0.5  0.5
2  1.0  1.0


# Using sklearn
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler() 
arr_scaled = scaler.fit_transform(df) 

print(arr_scaled)
[[0.  0. ]
 [0.5 0.5]
 [1.  1. ]]

df_scaled = pd.DataFrame(arr_scaled, columns=df.columns,index=df.index)
print(df_scaled)
     A    B
0  0.0  0.0
1  0.5  0.5
2  1.0  1.0

Anda mungkin ingin memiliki beberapa kolom yang dinormalisasi dan yang lainnya tidak berubah seperti beberapa tugas regresi yang label data atau kolom kategorinya tidak berubah. Jadi saya sarankan Anda cara pythonic ini (Ini kombinasi dari jawaban @shg dan @Cina):

features_to_normalize = ['A', 'B', 'C']
# could be ['A','B'] 

df[features_to_normalize] = df[features_to_normalize].apply(lambda x:(x-x.min()) / (x.max()-x.min()))

Ini hanya matematika sederhana. Jawabannya harus sesederhana seperti di bawah ini.

normed_df = (df - df.min()) / (df.max() - df.min())

def normalize(x):
    try:
        x = x/np.linalg.norm(x,ord=1)
        return x
    except :
        raise
data = pd.DataFrame.apply(data,normalize)

Dari dokumen panda, struktur DataFrame dapat menerapkan operasi (fungsi) untuk dirinya sendiri.

DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)

Menerapkan fungsi di sepanjang sumbu input DataFrame. Objek yang diteruskan ke fungsi adalah objek Seri yang memiliki indeks, baik indeks DataFrame (sumbu = 0) atau kolom (sumbu = 1). Jenis pengembalian tergantung pada apakah fungsi yang disahkan agregat, atau argumen pengurangan jika DataFrame kosong.

Anda dapat menerapkan fungsi khusus untuk mengoperasikan DataFrame.

Fungsi berikut menghitung skor Z:

def standardization(dataset):
  """ Standardization of numeric fields, where all values will have mean of zero 
  and standard deviation of one. (z-score)

  Args:
    dataset: A `Pandas.Dataframe` 
  """
  dtypes = list(zip(dataset.dtypes.index, map(str, dataset.dtypes)))
  # Normalize numeric columns.
  for column, dtype in dtypes:
      if dtype == 'float32':
          dataset[column] -= dataset[column].mean()
          dataset[column] /= dataset[column].std()
  return dataset

Ini adalah bagaimana Anda melakukannya dengan bijaksana menggunakan pemahaman daftar:

[df[col].update((df[col] - df[col].min()) / (df[col].max() - df[col].min())) for col in df.columns]

Anda cukup menggunakan fungsi pandas.DataFrame.transform 1 dengan cara ini:

df.transform(lambda x: x/x.max())

df_normalized = df / df.max(axis=0)

Anda dapat melakukan ini dalam satu baris

DF_test = DF_test.sub(DF_test.mean(axis=0), axis=1)/DF_test.mean(axis=0)

dibutuhkan rata-rata untuk setiap kolom dan kemudian kurangi (rata-rata) dari setiap baris (rata-rata kolom tertentu hanya mengurangi dari barisnya saja) dan bagi dengan rata-rata saja. Akhirnya, yang kami dapatkan adalah kumpulan data yang dinormalisasi.

Panda melakukan normalisasi bijaksana kolom secara default. Coba kode di bawah ini.

X= pd.read_csv('.\\data.csv')
X = (X-X.min())/(X.max()-X.min())

Nilai output akan berada dalam kisaran 0 dan 1.