각 열의 값 범위가 다른 팬더에 데이터 프레임이 있습니다. 예를 들면 :

df :

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

각 값이 0과 1 사이 인이 데이터 프레임의 열을 어떻게 정규화 할 수 있는지 아십니까?

내 원하는 출력은 다음과 같습니다.

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

sklearn 패키지 및 관련 전처리 유틸리티를 사용하여 데이터를 정규화 할 수 있습니다.

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)

자세한 내용은 데이터 전처리 : 기능을 범위로 확장 하는 방법에 대한 scikit-learn 문서 를 참조하세요 .

Pandas 를 사용하는 쉬운 방법 : (여기서는 평균 정규화를 사용하고 싶습니다)

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

최소-최대 정규화를 사용하려면 :

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

편집 : 일부 문제를 해결하려면 Pandas가 위 코드에서 자동으로 colomn-wise 함수를 적용한다고 말할 필요가 있습니다.

이 게시물을 기반으로 : /stats/70801/how-to-normalize-data-to-0-1-range

다음을 수행 할 수 있습니다.

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

당신의 가치가 부정적인지 긍정적인지에 대해 걱정할 필요가 없습니다. 그리고 값은 0과 1 사이에 잘 ​​분산되어야합니다.

문제는 실제로 열에 작용하는 간단한 변환입니다.

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

frame.apply(f, axis=0)

또는 더 간결하게 :

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

sklearn 패키지 사용을 좋아한다면 다음과 같이 pandas를 사용하여 열 및 인덱스 이름을 유지할 수 있습니다 loc.

from sklearn.preprocessing import MinMaxScaler

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

단순함은 아름답습니다 :

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

정규화하려는 열 목록을 만들 수 있습니다.

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

Pandas Dataframe은 이제 원하는 열에서만 정규화됩니다.

그러나 반대로 원하는 경우 정규화 하지 않으려 는 열 목록을 선택하고 모든 열 목록을 만들고 원하지 않는 열을 제거하면됩니다.

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 ]

파이썬에서 다른 표준화의 예.

참고로이 위키피디아 기사 : 표준 편차의 편향되지 않은 추정

예제 데이터

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

팬더를 사용한 정규화 (편향되지 않은 추정값 제공)

정규화 할 때 단순히 평균을 빼고 표준 편차로 나눕니다.

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

sklearn을 사용한 정규화 (Pandas와는 다른 편향된 추정값 제공)

동일한 작업을 수행하면 sklearn다른 출력을 얻을 수 있습니다!

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

sklearn의 편향된 추정이 기계 학습을 덜 강력하게 만들까요?

아니.

sklearn.preprocessing.scale 의 공식 문서에는 편향 추정기를 사용하는 것이 기계 학습 알고리즘의 성능에 영향을 미칠 가능성 이 없으며 안전하게 사용할 수 있다고 명시되어 있습니다.

공식 문서에서 :

표준 편차에 대해 편향된 추정량을 사용합니다 numpy.std(x, ddof=0). 의 선택은 ddof모델 성능에 영향을주지 않습니다.

MinMax Scaling은 어떻습니까?

MinMax 스케일링에는 표준 편차 계산이 없습니다. 따라서 결과는 pandas와 scikit-learn에서 동일합니다.

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

판다에서 더 좋은 방법은

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

편집 데이터 프레임에 음수가 있으면 대신 사용해야합니다.

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

Sandman과 Praveen이 제공 한 솔루션은 매우 훌륭합니다. 데이터 프레임의 다른 열에 범주 형 변수가있는 경우이 방법은 약간의 조정이 필요합니다.

이 유형의 문제에 대한 나의 해결책은 다음과 같습니다.

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

일부 열은 정규화되고 다른 열은 데이터 레이블 또는 범주 열이 변경되지 않은 일부 회귀 작업처럼 변경되지 않을 수 있으므로이 비단뱀적인 방법을 제안합니다 (@shg 및 @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()))

단순한 수학 일뿐입니다. 대답은 아래와 같이 간단해야합니다.

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

다음은 목록 이해를 사용하여 열 방식으로 수행하는 방법입니다.

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

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

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

Pandas의 문서에서 DataFrame 구조는 작업 (함수)을 자체에 적용 할 수 있습니다.

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

DataFrame의 입력 축을 따라 기능을 적용합니다. 함수에 전달 된 객체는 DataFrame의 인덱스 (axis = 0) 또는 열 (axis = 1) 중 하나에 인덱스가있는 Series 객체입니다. 반환 유형은 전달 된 함수 집계 여부 또는 DataFrame이 비어있는 경우 reduce 인수에 따라 다릅니다.

사용자 정의 함수를 적용하여 DataFrame을 작동 할 수 있습니다.

다음 함수는 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

다음과 같이 간단하게 pandas.DataFrame.transform 1 함수를 사용할 수 있습니다 .

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

한 줄로 할 수 있습니다.

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

각 열에 대한 평균을 취한 다음 모든 행에서 (평균)을 빼고 (특정 열의 평균은 해당 행에서만 빼기) 평균으로 만 나눕니다. 마지막으로, 우리가 얻는 것은 정규화 된 데이터 세트입니다.

Pandas는 기본적으로 열 단위 정규화를 수행합니다. 아래 코드를 시도하십시오.

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

출력 값의 범위는 0과 1입니다.

데이터가 양으로 치우친 경우 정규화하는 가장 좋은 방법은 로그 변환을 사용하는 것입니다.

df = np.log10(df)