sklearn.preprocessing

표준화 (중심 화) scalesklearn.preprocessing. scale (X, axis=0, with_mean=True, with_std=True, copy=True)
X
표준 화 된 데이터 (배열 또는 희소 행렬)
axis
0 은 한 열 에 대해 같은 조작 을 하 는 것 을 나타 내 고, 1 은 한 줄 에 대해 같은 조작 을 하 는 것 을 나타 낸다.
with_mean
평균 값 중심 화 (true)
with_std
분산 규모 화 (true)
표준화 과정 은 두 단계 이다. 평균 값 의 중심 화 (평균 값 이 0 으로 변 함).방 차 의 규모 화.

from sklearn import preprocessing
import numpy as np

#         ，         ，         
x = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

#                 ，  ，            
x_scale = preprocessing.scale(x)

x_scale

>>> array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])

#                  ，    0,1 
x_scale.mean(axis=0)
>>> array([ 0.,  0.,  0.])

x_scale.std(axis=0)
>>> array([ 1.,  1.,  1.])

# axis=1            ，axis=0              
x_scale.mean(axis=1)
>>> array([ 0.03718711,  0.31916121, -0.35634832])

귀 일화
 
표준 화 는 특징 매트릭스 (각 열 은 같은 특징의 서로 다른 수치 로) 의 열 처리 데이터 에 따라 z - score 를 구 하 는 방법 을 통 해 견본 의 모든 특징의 값 을 같은 볼 륨 으로 변환 하 는 것 이다.  귀 일 화 는 특징 매트릭스 (각 줄 은 서로 다른 특징의 수치) 의 줄 처리 데이터 에 따라 샘플 벡터 가 점 승 연산 이나 다른 핵 함수 가 유사 성 을 계산 할 때 통 일 된 기준 을 가 지 는 데 목적 을 둔다. 즉, 모두 '단위 벡터' 로 전환 하 는 것 이다.  sklearn.preprocessing. normalize (X, norm=’l2’, axis=1, copy=True, return_norm=False)
Normalization 각 샘플 을 norm 1 의 정상 분포 로 귀 일 화 했 습 니 다.
함수 normalize 는 배열 과 유사 한 데이터 세트 를 조작 하 는 간단 한 방법 을 제공 합 니 다. l1 또는 l2 패 러 다 임 (norm 매개 변수) 을 사용 합 니 다.

x = np.array([[1., -1.,  2.],
              [2.,  0.,  0.],
              [0.,  1., -1.]])

X_normalized = preprocessing.normalize(x, norm='l2')

print(X_normalized)

>>> [[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]

[0, 1] 로 귀 일화

x = np.array([[1., -1.,  2.],
              [2.,  0.,  0.],
              [0.,  1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(x)

print(X_train_minmax)

>>> [[0.5        0.         1.        ]
 [1.         0.5        0.33333333]
 [0.         1.         0.        ]]


#   scaler   
min_max_scaler.scale_ 
array([ 0.5       ,  0.5       ,  0.33...])

min_max_scaler.min_                               
array([ 0.        ,  0.5       ,  0.33...])

이치 화 - 특징의 이치 화 Binarizer
특징의 이치 화 는 수치 형의 특징 데 이 터 를 불 형식의 값 으로 바 꾸 는 것 을 말한다.실 용적 인 Binarizer 를 사용 할 수 있 습 니 다.기본 값 은 0 에서 2 값 으로 0 보다 큰 것 은 모두 1 로 표시 하고 0 보다 작은 것 은 모두 0 으로 표시 합 니 다.

binarizer = preprocessing.Binarizer().fit(x)

print(binarizer.transform(x))

>>> [[1. 0. 1.]
 [1. 0. 0.]
 [0. 1. 0.]]

분류 특징 인 코딩

OneHotEncoder(categorical_features='all', dtype=<...>,
       handle_unknown='error', n_values='auto', sparse=True)

카 테 고리 형 변 수 를 모델 에 직접 사용 하려 면 one - of - k 인 코딩 이나 one - hot 인 코딩 을 사용 할 수 있 습 니 다.이것들 은 모두 OneHotEncoder (독 열 코드) 를 통 해 이 루어 질 수 있 으 며 n 가지 값 이 있 는 특징 을 n 개의 이원 적 특징 으로 바 꿀 수 있다.기본적으로 n 값 은 데이터 세트 를 통 해 자동 으로 추 정 됩 니 다.예 를 들 어 데이터 에는 2 가지 성별, 3 가지 가능 한 곳, 4 가지 가능 한 브 라 우 저 가 집중 되 어 있다.그리고 인 코딩 할 때 9 열 에 있 는 array 배열 에서 앞의 2 개의 디지털 인 코딩 성별, 다음 3 개의 디지털 인 코딩 부분, 마지막 4 개의 디지털 인 코딩 브 라 우 저.분 산 된 특징 에 대해 서 는 기본적으로 원 - hot (독 열) 인 코딩 에 따라 이 분 산 된 특징 이 수치 가 있 는 만큼 이 특징 을 나타 낸다.분 산 된 특징 을 원 - hot 인 코딩 으로 사용 하면 특징 간 의 거리 계산 이 더욱 합 리 적 입 니 다.분 산 된 특징 이 one - hot 인 코딩 을 한 후에 인 코딩 후의 특징 은 모든 차원 의 특징 이 연속 적 인 특징 으로 볼 수 있다.연속 형 특징 에 대한 획일 화 방법 과 마찬가지 로 모든 1 차원 특징 을 획일 화 할 수 있다.예 를 들 어 귀 일 화 는 [- 1, 1] 또는 귀 일 화 는 평균 값 이 0 이 고 방 차 는 1 이다.        

from sklearn import preprocessing
enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])    # fit     
enc.transform([[0, 1, 3]]).toarray()    #     

>>> [[1. 0. 0. 1. 0. 0. 0. 0. 1.]]



#    ，         ，              ，
#            ，         ，                。
#          OneHotEncoder    n_values，               
enc = preprocessing.OneHotEncoder(n_values=[2,3,4])  #                  2 3 4


#   enc n_values_    ，               
print(enc.n_values_)    #       
[2 3 4]



feature_indices_：            ，   i     ，       feature_indices_[i] feature_indices_[i+1]，sklearn          ，
        n_features+1。    ，feature_indices_  （0，3，8）。
    0     ，         0  3，     1 2；   1     ，
         3  8，     5 7。   0     ，         1-0=1 2-0=2；
   1     ，         5-3=2 7-3=4。         （1，2，2，4）       。

상례 에 따 르 면 데이터 행렬 은 4 * 3, 즉 4 개의 데이터, 3 개의 특징 차원 이다.
0 0 3    첫 번 째 열 은 첫 번 째 특징 차원 으로 두 가지 수치 가 있 는데 각각 0 과 1 이기 때문에 대응 하 는 인 코딩 방식 은 10, 01 이다.
1 1 0    두 번 째 열 은 두 번 째 특징 차원 으로 세 가지 수치 가 있 는데 각각 0, 1 과 2 이기 때문에 대응 하 는 인 코딩 방식 은 100, 010, 001 이다.
0 2 1    세 번 째 열 은 세 번 째 특징 차원 으로 네 가지 수치 가 있 는데 각각 0, 1, 2 와 3 이기 때문에 대응 하 는 인 코딩 방식 은 1000, 0100, 0010, 0001 이다.
1 0 2
인 코딩 할 인자 [0, 1, 3], 0 - > 10, 1 - > 010, 3 - > 0001 이 므 로 100001 입 니 다.

>>> genders = ['female', 'male']
>>> locations = ['from Africa', 'from Asia', 'from Europe', 'from US']
>>> browsers = ['uses Chrome', 'uses Firefox', 'uses IE', 'uses Safari']
>>> enc = preprocessing.OneHotEncoder(categories=[genders, locations, browsers])
>>> # Note that for there are missing categorical values for the 2nd and 3rd
>>> # feature
>>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']]
>>> enc.fit(X) 
OneHotEncoder(categorical_features=None,
       categories=[...],
       dtype=<...>, handle_unknown='error',
       n_values=None, sparse=True)
>>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray()
array([[1., 0., 0., 1., 0., 0., 1., 0., 0., 0.]])

부족 한 데 이 터 를 보충 하 다.
scikit - learn 모델 에 서 는 입력 한 데이터 가 수치 형 이 고 의미 가 있다 고 가정 합 니 다. 데이터 가 부족 한 것 이 NAN 이나 빈 값 으로 표시 되면 식별 하고 계산 할 수 없습니다.부족 한 값 을 보완 하려 면 평균치, 중위 수, 중수 등 을 사용 할 수 있다.Imputer 라 는 종 류 는 실현 할 수 있다.배열 에 nan 이 존재 하 는 지 여 부 는 np. isnan () 을 사용 하여 판단 할 수 있 습 니 다.
strategy = "constant" 일 때 fillvalue 는 상수 로 채 우 는 거 예요.

>>> import numpy as np
>>> from sklearn.impute import SimpleImputer
>>> imp = SimpleImputer(missing_values=np.nan, strategy='mean')
>>> imp.fit([[1, 2], [np.nan, 3], [7, 6]])       
SimpleImputer(copy=True, fill_value=None, missing_values=nan, strategy='mean', verbose=0)
>>> X = [[np.nan, 2], [6, np.nan], [7, 6]]
>>> print(imp.transform(X))           
[[4.          2.        ]
 [6.          3.666...]
 [7.          6.        ]]

#################  
from sklearn.preprocessing import Imputer

imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
imp.fit([[1, 2], [np.nan, 3], [7, 6]])
x = [[np.nan, 2], [6, np.nan], [7, 6]]
print(imp.transform(x))

#  
#imp.fit(x)
#imp.transform(x)

[[4.         2.        ]
 [6.         3.66666667]
 [7.         6.        ]]

빈 칸 데이터

#       
tem='1,2,3, ,3,4,5,6,7,8, ,9'
print tem

#      
tem = tem.replace(' ','nan').split(',')
print tem
#             
x = np.array(tem,dtype = float).reshape((4,3))
print x

1,2,3, ,3,4,5,6,7,8, ,9
['1', '2', '3', 'nan', '3', '4', '5', '6', '7', '8', 'nan', '9']
[[  1.   2.   3.]
 [ nan   3.   4.]
 [  5.   6.   7.]
 [  8.  nan   9.]]

Imputer().fit_transform(x)
array([[ 1.        ,  2.        ,  3.        ],
       [ 4.66666667,  3.        ,  4.        ],
       [ 5.        ,  6.        ,  7.        ],
       [ 8.        ,  3.66666667,  9.        ]])

Imputer () 의 인 자 는 다음 과 같 습 니 다.  1. missing_values: 기본 값 (default = "NaN")  2. strategy: string 문자 형식, optional (default = "mean"), 보통 mean (평균치), median (중위), most빈번 하 다  3. axis: 축방향, 기본 값 은 (열 방향, axis = 0), 줄 은 (axis = 1)  help 명령 을 통 해 Imputer 에 대한 설명 을 표시 할 수 있 습 니 다. help(Imputer())
다항식 특징 생 성 PolynomialFeatures
입력 데이터 의 비 선형 특징 을 고려 하여 모델 의 복잡 도 를 높이 는 것 은 매우 유용 하 다.간단 하고 자주 사용 하 는 방법 은 여러 가지 특징 으로 특징의 고급 과 상호작용 항 을 얻 을 수 있다.
다음 코드 는 (X1, X2) 를 (1, X1, X2, X1 ^ 2, X1X2, X2 ^ 2) 로 바 꿉 니 다.
from (X1,X2,X3) to (1,X1,X2,X3,X1X2,X1X3,X2X3,X1X2X3).  interaction_only = True 자체 제곱 없 음

>>> import numpy as np
>>> from sklearn.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X                                                 
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)                             
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])


>>> X = np.arange(9).reshape(3, 3)
>>> X                                                 
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> poly = PolynomialFeatures(degree=3, interaction_only=True)
>>> poly.fit_transform(X)                             
array([[  1.,   0.,   1.,   2.,   0.,   0.,   2.,   0.],
       [  1.,   3.,   4.,   5.,  12.,  15.,  20.,  60.],
       [  1.,   6.,   7.,   8.,  42.,  48.,  56., 336.]])