샘플 프레임의 입력과 출력이있는 의사 코드 예제가 유용 할 것입니다.

@ chrish42 , 예가 좋을 것입니다.

참고로 scikit-learn에는 파이프 라인에 맞는 OneHotEncoder 클래스가 있습니다.

이와 같은 것이 작동해야합니까?

import pandas as pd
from sklearn.pipeline import TransformerMixin

class DummyEncoder(TransformerMixin):

    def __init__(self, columns=None):

        self.columns = columns

    def transform(self, X, y=None, **kwargs):

        return pd.get_dummies(X, columns=self.columns)

    def fit(self, X, y=None, **kwargs):

        return self

기부

In [15]: df
Out[15]: 
   A  B  C
0  1  a  a
1  2  b  a

In [16]: DummyEncoder().transform(df)
Out[16]: 
   A  B_a  B_b  C_a
0  1    1    0    1
1  2    0    1    1

컬럼 순서에주의하십시오.

@TomAugspurger , 실제로 sklearn 처리 파이프 라인 자체와의 호환성은 저에게 관심이있는 부분이 아닙니다. 내가 원하는 것은 get_dummes ()에 의해 수행 된 변환을 데이터 세트에 저장 한 다음 두 번째 데이터 세트에 첫 번째 데이터 세트의 값의 하위 집합이 있더라도 해당 변환을있는 그대로 적용 (정확히 동일한 열 생성)하는 기능입니다. 이것은 실제로 "훈련 / 테스트 프레임 워크에서 사용 가능"을 의미합니다. 이 설명이 더 명확합니까? (누군가가 여전히 필요하다고 생각하는 예를 추가 할 수 있습니다.)

sklearn의 OneHotEncoder 클래스를 알고 있지만 다른 제한 사항이 있습니다.

나는 @ chrish42 와 같은 문제를 우연히 발견했고 get_dummies가 나에게 두통을주는 것을 발견했습니다.

현재 get dummies의 한계의 예

다음 df_train DataFrame의 데이터로 작업한다고 가정하겠습니다.

```.python
df_train = pandas.DataFrame ({ "car": [ "seat", "bmw"], "color": [ "red", "green"]})
pandas.get_dummies (df_train)

car_bmw car_seat color_green color_red
0 0 1 0 1
1 1 0 1 0

Then we are provided with

``` .python
df_test = pandas.DataFrame({"car":["seat","mercedes"], "color":["red","green"]})
pandas.get_dummies(df_test )

         car_mercedes  car_seat  color_green  color_red
0             0         1            0          1
1             1         0            1          0

df_train에서 변수 "car"에 대한 "mercedes"값을 본 적이 없기 때문에 다음과 같은 핫 인코딩을 얻을 수 있기를 바랍니다.

```.python
car_bmw car_seat color_green color_red
0 0 1 0 1
1 0 0 1 0

Where the column car_mercedes actually never appears.

This could be solved by allowing get_dummies to receive an input dictionary stating the accepted values that we allow for each column.  

Returning to the previous example, we could give as input to get_dummies the following dict of sets

``` .python
accepted_values_per_column = {'car': {'bmw', 'seat'}, 'color': {'green', 'red'}}

get_dummies가

```.python
get_dummies (df_test, Accepted_values_per_column = Accepted_values_per_column)

       car_bmw  car_seat  color_green  color_red

0 0 1 0 1
1 0 0 1 0
```

get_dummies (df_test)가 이미 반환 된 것을 반환 할 것으로 예상합니다.

관찰되지 않은 변수를 _ 가능하게 _ 지정하려면 변수를 Categorical 로 지정하면됩니다. 이 작업은 생성시 또는 이후에 수행 할 수 있습니다. 문서를 참조하십시오.

In [5]: df_train = pd.DataFrame({"car":Series(["seat","bmw"]).astype('category',categories=['seat','bmw','mercedes']),"color":["red","green"]})

In [6]: df_train
Out[6]: 
    car  color
0  seat    red
1   bmw  green

In [7]: pd.get_dummies(df_train )
Out[7]: 
   car_seat  car_bmw  car_mercedes  color_green  color_red
0         1        0             0            0          1
1         0        1             0            1          0

원래 질문은 잘 지정되어 있지 않으므로 닫습니다.

그리고 다른 방법으로 인코딩에서 다시 Categorical로 이동할 때는 Categorical.from_codes를 사용합니다.

원치 않는 조언이 하나 더 있습니다. 범주 형에 대한 계수의 정확한 추정에 관심이 있다면 인코딩 된 열 중 하나를 삭제하지 않으면 절편과 함께 다중 공선 성을 갖게됩니다 (있는 경우).

2015 년 10 월 5 일 05:34에 Jeff Reback [email protected] 은 다음과 같이 썼습니다.

관측되지 않을 수있는 변수를 지정하려면 변수를 범주 형으로 만들기 만하면됩니다. 이 작업은 생성시 또는 이후에 수행 할 수 있습니다. 문서를 참조하십시오.

[5]에서 : df_train = pd.DataFrame ({ "car": Series ([ "seat", "bmw"]). astype ( 'category', categories = [ 'seat', 'bmw', 'mercedes'] ), "color": [ "red", "green"]})

[6] : df_train
출력 [6] :
자동차 색상
0 좌석 빨간색
1 BMW 그린

[7] : pd.get_dummies (df_train)
출력 [7] :
car_seat car_bmw car_mercedes color_green color_red
0 1 0 0 0 1
101010
원래 질문은 잘 지정되어 있지 않으므로 닫습니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.

@TomAugspurger @jreback 최근에 같은 문제가 발생했다고 생각하며 예를 들어보고 싶습니다.

train_a = pd.DataFrame ({ "IsBadBuy": [0,1,0], "제조업체": [ 'Toyota', 'Mazda', 'BMW']})

IsBadBuy Make_BMW Make_Mazda Make_Toyota
0 0 0 0 1
1 1 0 1 0
2 0 1 0 0

test_a = pd.DataFrame ({ "Make": [ 'Toyota', 'BMW']})
print pd.get_dummies (test_a, columns = [ 'Make'])

Make_BMW Make_Toyota
0 0 1
1 1 0

여기서 이상적으로는 ML 알고리즘이 동일한 수의 기능을 예상하고 테스트에서 얻은 값이 학습에서 얻은 값의 하위 집합이 될 것이기 때문에 Make_Mazda 열을 보존해야합니다.

범주 형을 사용하십시오. 올바른 수의 열로 확장됩니다. 당신이 관심이 있다면 이것에 대해 이야기했습니다 https://m.youtube.com/watch?v=KLPtEBokqQ0

    _____________________________

보낸 사람 : Ajay Saxena [email protected]
보낸 날짜 : 2017 년 1 월 12 일 목요일 18:31
제목 : Re : [pandas-dev / pandas] 위시리스트 : get_dummies ()를 학습 / 테스트 프레임 워크에 사용할 수 있도록 설정 (# 8918)
받는 사람 : pandas-dev / pandas [email protected]
참조 : Tom Augspurger [email protected] , Mention [email protected]

@jreback 최근에 같은 문제가 발생했다고 생각

train_a = pd.DataFrame ({ "IsBadBuy": [0,1,0], "제조업체": [ 'Toyota', 'Mazda', 'BMW']})

IsBadBuy Make_BMW Make_Mazda Make_Toyota
0 0 0 0 1
1 1 0 1 0
2 0 1 0 0

test_a = pd.DataFrame ({ "Make": [ 'Toyota', 'BMW']})
print pd.get_dummies (test_a, columns = [ 'Make'])

Make_BMW Make_Toyota
0 0 1
1 1 0

여기서 이상적으로는 ML 알고리즘이 동일한 수의 기능을 예상하고 테스트에서 얻은 값이 학습에서 얻은 값의 하위 집합이 될 것이기 때문에 Make_Mazda 열을 보존해야합니다.

—
당신이 언급 되었기 때문에 이것을 받고 있습니다.
이 이메일에 직접 답장하거나 GitHub에서 보거나 스레드를 음소거하십시오.

감사합니다 @TomAugspurger

@TomAugspurger 가 제공 한 PyData Chicago 2016 강연은 정말 훌륭했습니다. 그는이 문제 / 요청을 종결해서는 안되는 모든 이유를 설명하는 환상적인 작업을 수행했습니다. IMHO 그의 클래스 DummyEncoder 또는 적절한 동등한 일부가 Pandas에 포함되어야합니다. 예, 그의 github로 이동하여 그의 클래스를 복사 / 에뮬레이션 할 수 있지만 라이브러리 내에서 지원하는 것이 훨씬 더 좋을 것입니다.

데이터 모델링 초기에 라이브러리가 필요하다고 생각합니다.
pandas 및 scikit-learn과 잘 작동합니다.
그러나 pandas는 scikit-learn에 의존하지 않으며 그 반대의 경우도 마찬가지입니다. 나는 생각한다
둘 다 위에 지어진 또 다른 도서관을위한 공간.

2017 년 5 월 10 일 수요일 오후 6:13, Brian Wylie [email protected]
썼다 :

@TomAugspurger가 제공 한 PyData Chicago 2016 강연
https://github.com/TomAugspurger 는 정말 잘했습니다. 그는
이 문제 / 요청이 필요한 모든 이유를 설명하는 환상적인 작업
닫히지 마십시오. IMHO 그의 클래스 DummyEncoder 또는 합리적인
이에 상응하는 내용이 Pandas에 포함되어야합니다. 네 github에 갈 수 있습니다
그의 수업을 복사 / 에뮬레이션하지만 그것을 갖는 것이 훨씬 더 좋을 것입니다.
라이브러리 내에서 지원됩니다.

BTW 내 생각 @TomAugspurger https://github.com/TomAugspurger
새로운 좋아하는 PyData 전문가. 나는 그가있는 모든 것을 사냥 할거야
완료 / 작업하고 그것을 흡수하려고 .. 소름 끼치는 / 스토킹 방식으로 .. 당신
전혀 소름 끼치 지 않는 정상적인 방식으로 알고 있습니다. :)

—
당신이 언급 되었기 때문에 이것을 받고 있습니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/pandas-dev/pandas/issues/8918#issuecomment-300638388 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABQHIpTqgHSE7iFVF9Pp4_YoKB9DPLcEks5r4kSrgaJpZM4DB6Hb
.

여기에 도움이 될만한 우리 중 일부가 작업 한 작은 해결책이 있습니다. 적합 / 변환 기능이있는 더미 변수.

https://github.com/joeddav/get_smarties

피드백과 기여가 도움이 될 것입니다!

# 14017과 관련된 것으로 보입니다.

이 문제에 정확히 도움이 될 수있는 솔루션을 만들었습니다. 열차 테스트 프레임 워크에서 핫 인코딩 범주 형 변수 하나. 데이터 세트가 너무 커서 머신 메모리에 맞지 않는 경우도 처리 할 수 ​​있습니다.

https://github.com/yashu-seth/dummyPy

여기 에서 이에 대한 작은 자습서를 찾을 수도

이것을 구독하는 사람들은 dask-ml의 구현에 관심이있을 것입니다.

• http://dask-ml.readthedocs.io/en/latest/preprocessing.html#additional -tranformers
• http://dask-ml.readthedocs.io/en/latest/modules/generated/dask_ml.preprocessing.Categorizer.html#dask_ml.preprocessing.Categorizer
• http://dask-ml.readthedocs.io/en/latest/modules/generated/dask_ml.preprocessing.DummyEncoder.html#dask_ml.preprocessing.DummyEncoder

@TomAugspurger 이 코드는 작동하지 않습니다. 프로덕션 단일 레코드 데이터를 변환하려면 현재 존재하는 단일 값에 대해 핫 인코딩 된 열 하나만 제공합니다.
내가 무엇을 놓치고 있습니까?

수입 pyodbc
수입 피클
sklearn.linear_model에서 가져 오기 LogisticRegression
sklearn.linear_model에서 가져 오기 LinearRegression

numpy를 np로 가져 오기
팬더를 pd로 가져 오기
sklearn.pipeline import TransformerMixin에서
sklearn.pipeline에서 가져 오기 make_pipeline

클래스 DummyEncoder (TransformerMixin) :
def fit (self, X, y = None) :
self.index_ = X.index
self.columns_ = X.columns
self.cat_columns_ = X.select_dtypes (include = [ 'category']). columns
self.non_cat_columns_ = X.columns.drop (self.cat_columns_)

    self.cat_map_ = {col: X[col].cat for col in self.cat_columns_}

    left = len(self.non_cat_columns_)
    self.cat_blocks_ = {}
    for col in self.cat_columns_:
        right = left + len(X[col].cat.categories)
        self.cat_blocks_[col], left = slice(left, right), right
    return self

def transform(self, X, y=None):
    return np.asarray(pd.get_dummies(X))

def inverse_transform(self, X):
    non_cat = pd.DataFrame(X[:, :len(self.non_Cat_columns_)],
                             columns=self.non_cat_columns_)
    cats = []
    for col, cat in self.cat_map_.items():
        slice_ = self.cat_blocks_[col]
        codes = X[:, slice_].argmax(1)
        series = pd.Series(pd.Categorical.from_codes(
                codes, cat.categories, ordered=cat.ordered
        ), name=col)
        cats.append(series)
    df = pd.concat([non_cat] + cats, axis=1)[self.columns_]
    return df

SQL에서 Pandas Dataframe으로 데이터 가져 오기

cnxn = pyodbc.connect ( 'DRIVER = {SQL Server}; SERVER = {XXXXX}; DATABASE = {ML_Learn_Taxi}; UID = {XXXX}; PWD = {XXXX}')
SQL = "" "
SELECT top 1 CONVERT (int, [order_key]) order_key
, CONVERT (int, [service_date_key]) service_date_key
, [order_source_desc]
, 1 as 'return_flag'
FROM [ML_Return_Customer]. [dbo]. [return_customers_test_set]
WHERE [order_source_desc] = '온라인'
노동 조합
SELECT 상위 2 CONVERT (int, [order_key])
, CONVERT (int, [service_date_key])
, [order_source_desc]
, 2
FROM [ML_Return_Customer]. [dbo]. [return_customers_test_set]
WHERE [order_source_desc] = '수신 전화'
노동 조합
SELECT top 1 CONVERT (int, [order_key])
, CONVERT (int, [service_date_key])
, [order_source_desc]
,1
FROM [ML_Return_Customer]. [dbo]. [return_customers_test_set]
WHERE [order_source_desc] = '발신 전화'
"" "

prod_sql = "" "
SELECT top 1 CONVERT (int, [order_key]) order_key
, CONVERT (int, [service_date_key]) service_date_key
, [order_source_desc]
, 1 as 'return_flag'
FROM [ML_Return_Customer]. [dbo]. [return_customers_test_set]
WHERE [order_source_desc] = '온라인'
"" "

InputDataSet = pd.read_sql (sql, cnxn)
ProdDataSet = pd.read_sql (prod_sql, cnxn)

print ( " * * * * 데이터 * * * * * ")
인쇄 (InputDataSet)

print ( " * 범주 열 정보 * * ")
열 = [ 'order_source_desc']
InputDataSet [columns] = InputDataSet [columns] .apply (lambda x : x.astype ( 'category'))

InputDataSet.info ()

print ( " * 선형 회귀 * * ")

X = InputDataSet.drop ( 'return_flag', 축 = 1)
y = InputDataSet [ 'return_flag']

A = ProdDataSet.drop ( 'return_flag', 축 = 1)
B = ProdDataSet [ 'return_flag']

enc = DummyEncoder ()
enc.fit (X)

비 = enc.transform (X)

Prod = enc.transform (A)

인쇄 (Prod)

출력 : * * * * 데이터 * * * *
order_key service_date_key order_source_desc return_flag
0 10087937 20151214 온라인 1
1 10088174 20151201 인바운드 통화 2
2 10088553 20151217 수신 전화 2
3663478 20160806 아웃 바운드 통화 1
* 카테고리 열 정보 * *

RangeIndex : 4 개 항목, 0 ~ 3
데이터 열 (총 4 개 열) :
order_key 4 null이 아닌 int64
service_date_key 4 null이 아닌 int64
order_source_desc 4 널이 아닌 범주
return_flag 4 null이 아닌 int64
dtypes : category (1), int64 (3)
메모리 사용량 : 284.0 바이트
* 선형 회귀 * * *
[[10087937 20151214 1]]

그래서 저는이 스레드가 약간 지저분하다고 생각하므로 여기에 간단한 해결책과 이것이 어떻게 이미 가능한지 요약하려고 노력할 것입니다. 한 열에 대해 설명하지만 여러 열로 일반화 할 수 있습니다.

따라서 "fit"호출에서 다음을 수행하십시오.

categories = sorted(training_data.iloc[:, column_index].value_counts(dropna=True).index)

피팅하는 동안 배우는 상태에 categories 을 저장합니다.

그리고 "변환"에서 다음을 수행합니다.

from pandas.api import types as pandas_types

categorical_data = testing_data.iloc[:, [column_index]].astype(
    pandas_types.CategoricalDtype(categories=categories),
)
one_hot_encoded = pandas.get_dummies(categorical_data)

그리고 값에 대해 항상 동일한 매핑에서 원-핫 인코딩을 수행합니다. 학습 중에 일부 범주 값이 없으면 테스트 중에 NaN으로 표시됩니다. 테스트 중에 일부 값이 표시되지 않으면 해당 열이 설정되지 않습니다.

아주 좋습니다. 나는 이것을하고 싶은 모든 사람들이 그것을 새롭게 발견 할 필요가 없었기를 바랍니다. ;-)

@mitar 가 제안한 접근 방식은 좋은 짧은 예입니다. 이 문제에 대한 더 긴 탐구를 위해 유용하고 도움이 될 수있는 노트북이 있습니다 : https://nbviewer.jupyter.org/github/SuperCowPowers/scp-labs/blob/master/notebooks/Categorical_Encoding_Dangers.ipynb

Kaggle XGBoost 튜토리얼의 연습에서 아래 코드를 보았습니다. 이것은 트릭입니다.

X_train = pd.get_dummies(X_train)
X_valid = pd.get_dummies(X_valid)
X_test = pd.get_dummies(X_test)
X_train, X_valid = X_train.align(X_valid, join='left', axis=1)
X_train, X_test = X_train.align(X_test, join='left', axis=1)

나는 또한 같은 문제에 여러 번 직면했습니다. 나는 나를 위해 일을 더 쉽게 만들어주는 수업 (이 토론에서 아이디어를 얻음)을 작성했습니다.

import pandas
from sklearn.preprocessing import LabelEncoder

class CategoryEncoder:
    '''
    labelEncoding : boolean -> True If the categorical columns are to be label encoded
    oneHotEncoding : boolean -> True If the categorical columns are to be one hot encoded (using pandas.get_dummies method)
    dropFirst : boolean -> True if first column is to be dropped (usually to avoid multi-collinearity) post one hot encoding
                           Doesn't matter if oneHotEncoding = False

    df : pandas.DataFrame() -> dataframe object that needs to be encoded
    catCols : list -> list of the categorical columns that need to be encoded
    '''
    def __init__(self,labelEncoding=True,oneHotEncoding=False,dropFirst=False):
        self.labelEncoding = labelEncoding
        self.oneHotEncoding = oneHotEncoding
        self.dropFirst = dropFirst
        self.labelEncoder = {}
        self.oneHotEncoder = {}

    def fit(self,df,catCols=[]):
        df1 = df.copy()
        if self.labelEncoding:
            for col in catCols:
                labelEncoder = LabelEncoder()
                labelEncoder.fit(df1.loc[:,col].astype(str))
                df1.loc[:,col] = labelEncoder.transform(df1.loc[:,col])
                self.labelEncoder[col] = labelEncoder.classes_

        if self.oneHotEncoding:
            for col in catCols:
                cats = sorted(df1.loc[:,col].value_counts(dropna=True).index)
                self.oneHotEncoder[col] = cats

    def transform(self,df,catCols=[]):
        df1 = df.copy()
        if self.labelEncoding:
            for col in catCols:
                labelEncoder = self.labelEncoder[col]
                labelEncoder = {v:i for i,v in enumerate(labelEncoder.tolist())}
                print(labelEncoder)
                df1.loc[:,col] = df1.loc[:,col].map(labelEncoder)

        if self.oneHotEncoding:
            for col in catCols:
                oneHotEncoder = self.oneHotEncoder[col]
                df1.loc[:,col] = df1.loc[:,col].astype(pandas.CategoricalDtype(categories=oneHotEncoder))
            df1 = pandas.get_dummies(df1,columns=catCols,drop_first=self.dropFirst)

        return df1

인코더의 인스턴스를 시작하고 사용하기 쉽습니다.

enc1 = CategoryEncoder(True,False)     # Will label encode but not one-hot encode
enc2 = CategoryEncoder(False,True,True)     # Will one-hot encode but not label encode
enc3 = CategoryEncoder(True,True,True)     # Will label encode first and then one-hot encode

# List of categorical columns you want to encode
categorical_columns = ['col_1', 'col_2']

enc1.fit(train_df, categorical_columns)
enc1.transform(test_df, categorical_columns) # Returns the dataframe encoded columns

참고 : 이것은 데이터 프레임에서 사용할 수없는 열 이름 전달과 같은 예외를 처리하지 않습니다.