अच्छी तरह से कैसे एक नमूना फ्रेम से आदानों और आउटपुट के साथ एक छद्म कोड उदाहरण के बारे में उपयोगी होगा

@ chrish42 , एक उदाहरण बहुत अच्छा होगा।

FYI करें 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 , वास्तव में स्केलेर प्रोसेसिंग पाइप लाइन के साथ संगतता ही वह हिस्सा नहीं है जो मुझे रुचती है। मैं किसी डेटासेट में get_dummes () द्वारा किए गए परिवर्तन को सहेजने की क्षमता चाहूंगा, और फिर कहा कि रूपांतरण को लागू करें (ठीक उसी कॉलम को बनाते हुए), भले ही दूसरे डाटासेट में पहले वाले के मानों का एक उपसमूह हो। कुछ कॉलम आदि में, वास्तव में मेरा मतलब है "ट्रेन / परीक्षण ढांचे में प्रयोग करने योग्य"। क्या यह स्पष्टीकरण स्पष्ट है? (मुझे लगता है कि अभी भी जरूरत है किसी को एक उदाहरण जोड़ सकते हैं।)

मैं sklearn में OneHotEncoder वर्ग से अवगत हूँ, लेकिन इसकी अन्य सीमाएँ हैं।

मैंने @ chrish42 जैसी ही समस्या को

वर्तमान की सीमाओं का उदाहरण डमी मिलता है

मान लें कि हम निम्नलिखित df_train DataFrame के डेटा के साथ काम करते हैं

`` `
df_train = pandas.DataFrame ({"कार": ["सीट", "बीएमडब्ल्यू"], "रंग": ["लाल", "हरा"]})
pandas.get_dummies (df_train)

car_bmw car_seat color_green color_red
० ० १ ० १ १
१ १ ० १ १ ०

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_bmw car_seat color_green color_red
० ० १ ० १ १
१ ० ० १ १ ०

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 को वापस लौटने की उम्मीद करेंगे

`` `
get_dummies (df_test, accept_values_per_column = Accept_values_perm_column)

       car_bmw  car_seat  color_green  color_red

० ० १ ० १ १
१ ० ० १ १ ०
`` `

और उम्मीद करें कि 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

मूल प्रश्न अच्छी तरह से निर्दिष्ट नहीं है, इसलिए समापन।

और जब आप दूसरे रास्ते पर जा रहे हों, तो एन्कोडिंग से वापस श्रेणीबद्ध करने के लिए आप gradorical.from_codes का उपयोग करेंगे।

एक और बिट की अवांछित सलाह। यदि आप वर्गीकरणों पर गुणांक के सटीक अनुमानों के बारे में सभी परवाह करते हैं, तो एन्कोड किए गए कॉलमों में से एक को छोड़ दें अन्यथा आपको इंटरसेप्ट (यदि आपके पास एक है) के साथ मल्टीकोलिनरिटी होगी।

5 अक्टूबर, 2015 को 05:34 पर, जेफ रीबैक सूचनाएँ @ithub.com ने लिखा:

यदि आप संभवतया अनबोल्ड चर निर्दिष्ट करना चाहते हैं तो आपको बस अपने चर को श्रेणीबद्ध बनाने की आवश्यकता है। यह निर्माण समय पर या बाद में किया जा सकता है, डॉक्स देखें

[५]: df_train = pd.DataFrame ({"कार": श्रृंखला (["सीट", "बीएमडब्ल्यू"]) में। ), "रंग": [ "लाल", "हरी"]})

[६] में: df_train
आउट [6]:
कार का रंग
0 सीट लाल
1 बी.एम.डब्ल्यू हरा

[M] में: pd.get_dummies (df_train)
आउट [7]:
car_seat car_bmw car_merrs color_green color_red
० १ ० ० ० १
१ ० १ ० १ १ ०
मूल प्रश्न अच्छी तरह से निर्दिष्ट नहीं है, इसलिए समापन।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

@TomAugspurger @jreback मुझे लगता है कि मैं हाल ही में एक ही समस्या में चला गया हूं और मैं एक उदाहरण देना चाहूंगा

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

IsBadBuy Make_BMW Make_Mazda Make_Toyota
० ० ० ० १
१ १ ० १ १ ०
२ ० १ ० ०

test_a = pd.DataFrame ({"Make": ['Toyota', 'BMW']})
प्रिंट pd.get_dummies (test_a, कॉलम = ['मेक'])

Make_BMW Make_Toyota
० ० १
१ १ ०

यहां आदर्श रूप से Make_Mazda कॉलम को संरक्षित किया जाना चाहिए क्योंकि ML एल्गोरिदम समान संख्या में सुविधाओं की अपेक्षा करेगा और हमें परीक्षण में प्राप्त होने वाले मान ट्रेन में एक सबसेट होंगे।

एक श्रेणीबद्ध का उपयोग करें। यह स्तंभों की सही संख्या तक विस्तारित होगा। मैंने इस बारे में एक बात दी है यदि आप https://m.youtube.com/watch?v=KLPtEBokqQ0 में रुचि रखते हैं

    _____________________________

प्रेषक: अजय सक्सेना नोटिफिकेशन @github.com
प्रेषित: गुरुवार, 12 जनवरी, 2017 18:31
विषय: पुन: [पंडों-देव / पंडों] इच्छा सूची: get_dummies () ट्रेन / परीक्षण ढांचे (# 8918) के लिए उपयोग करने योग्य
To: पंडों-देव / पंडों [email protected]
Cc: टॉम ऑग्सपर्गर [email protected] , उल्लेख उल्लेख @noreply.github.com

@jreback मुझे लगता है कि मैं हाल ही में एक ही समस्या में चला गया हूं और मैं एक उदाहरण बताना चाहूंगा

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

IsBadBuy Make_BMW Make_Mazda Make_Toyota
० ० ० ० १
१ १ ० १ १ ०
२ ० १ ० ०

test_a = pd.DataFrame ({"Make": ['Toyota', 'BMW']})
प्रिंट pd.get_dummies (test_a, कॉलम = ['मेक'])

Make_BMW Make_Toyota
० ० १
१ १ ०

यहां आदर्श रूप से Make_Mazda कॉलम को संरक्षित किया जाना चाहिए क्योंकि ML एल्गोरिदम समान संख्या में सुविधाओं की अपेक्षा करेगा और हमें परीक्षण में प्राप्त होने वाले मान ट्रेन में एक सबसेट होंगे।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें, या थ्रेड को म्यूट करें।

धन्यवाद @TomAugspurger

PyTata Chicago 2016 में @TomAugspurger द्वारा दी गई बात वास्तव में अच्छी तरह से की गई थी। उन्होंने उन सभी कारणों को दर्शाने का शानदार काम किया जिनके कारण यह मुद्दा / अनुरोध बंद नहीं होना चाहिए। IMHO या तो उसकी कक्षा DummyEncoder या कुछ उचित समकक्षों को पंडों में उचित रूप से शामिल किया जाना चाहिए। हां, मैं उसके गितुब में जा सकता हूं और उसकी कक्षा की नकल / अनुकरण कर सकता हूं लेकिन यह सिर्फ पुस्तकालय के भीतर समर्थन करने के लिए बहुत अच्छा होगा।

मुझे लगता है कि एक पुस्तकालय की आवश्यकता है जो डेटा-मॉडलिंग में जल्दी जाता है
पाइपलाइन और पंडों के साथ अच्छी तरह से काम करता है।
लेकिन पांडा scikit- सीखने और इसके विपरीत पर निर्भर नहीं करता है। मुझे लगता है कि वहाँ है
दोनों के ऊपर बनी एक और लाइब्रेरी का कमरा।

बुध पर, 10 मई, 2017 को शाम 6:13 बजे, ब्रायन वायली सूचनाएं @github.com
लिखा था:

PyData Chicago 2016 की बात @TomAugspurger द्वारा दी गई है
https://github.com/TomAugspurger वास्तव में अच्छी तरह से किया गया था। उसने ए
इस मुद्दे / अनुरोध पर सभी कारणों को दर्शाने का शानदार काम करना चाहिए
बंद नहीं होना चाहिए। IMHO या तो उसकी कक्षा DummyEncoder या कुछ उचित
पंडों में समतुल्य को शामिल किया जाना चाहिए। हां मैं उसके गितुब में जा सकता हूं
और उसकी कक्षा की नकल करें / उसका अनुकरण करें लेकिन यह सिर्फ उसके लिए बहुत अच्छा होगा
पुस्तकालय के भीतर समर्थित है।

BTW मुझे लगता है कि @TomAugspurger https://github.com/TomAugspurger मेरा हो सकता है
नया पसंदीदा Pyata गुरु। मैं सब कुछ वह नीचे शिकार करने जा रहा हूँ
किया / पर काम कर रहा है और इसे अवशोषित करने की कोशिश .. एक डरावना / पीछा तरीके से नहीं .. आप
बस एक सामान्य तरीके से जानते हैं जो बिल्कुल भी डरावना नहीं है। :)

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/pandas-dev/pandas/issues/8918#issuecomment-30062538888 ,
या धागा म्यूट करें
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#aditional-trancersers
• 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 आयात करें

आयात एनपीपी के रूप में सुन्न
पीडी के रूप में आयात पांडा
sklearn.pipeline से TransformerMixin आयात करें
sklearn.pipeline से make_pipeline आयात करें

वर्ग डमीइंकोडर (ट्रांसफॉर्मरक्सिन):
डीफ़ फिट (स्व, एक्स, वाई = कोई नहीं):
self.index_ = X.index
self.columns_ = X.columns
self.cat_columns_ = X.select_dtypes (शामिल = ['श्रेणी'] कॉलम
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 से पांडा डेटाफ्रेम में डेटा आयात करते हैं

cnxn = pyodbc.connect ('DRIVER = {SQL Server}; SERVER = {XXXXX}; DATABASE = {ML_Learn_Taxi}; UID = {XXXX}; PWD = XXXX}');
sql = "" "
शीर्ष 1 CONVERT का चयन करें (int, [order_key]) order_key
, CONVERT (int, [service_date_key]) service_date_key
, [Order_source_desc]
, 1 के रूप में 'वापसी_फ्लैग'
[ML_Return_Customer] से। [Dbo] [।
जहां [क्रम_स्रोत_देस] = 'ऑनलाइन'
संघ
शीर्ष 2 CONVERT का चयन करें (int, [order_key])
, CONVERT (int, [service_date_key])
, [Order_source_desc]
2
[ML_Return_Customer] से। [Dbo] [।
जहां [क्रम_स्रोत_दैसी] = 'इनबाउंड कॉल'
संघ
शीर्ष 1 CONVERT का चयन करें (int, [order_key])
, CONVERT (int, [service_date_key])
, [Order_source_desc]
, 1
[ML_Return_Customer] से। [Dbo] [।
जहां [क्रम_स्रोत_दिल] = 'आउटबाउंड कॉल'
"" "

prod_sql = "" "
शीर्ष 1 CONVERT का चयन करें (int, [order_key]) order_key
, CONVERT (int, [service_date_key]) service_date_key
, [Order_source_desc]
, 1 के रूप में 'वापसी_फ्लैग'
[ML_Return_Customer] से। [Dbo] [।
जहां [क्रम_स्रोत_देस] = 'ऑनलाइन'
"" "

InputDataSet = pd.read_sql (sql, cnxn)
प्रोडडैटसेट = pd.read_sql (prod_sql, cnxn)

प्रिंट (" * * * * * डेटा

प्रिंट (" * श्रेणी कॉलम जानकारी"

InputDataSet.info ()

प्रिंट (" * रैखिक प्रतिगमन)

X = InputDataSet.drop ('रिटर्न_फ्लैग', अक्ष = 1)
y = InputDataSet ['return_flag']

A = ProdDataSet.drop ('रिटर्न_फ्लैग', अक्ष = 1)
बी = प्रोडडसेटसेट ['वापसी_फ्लैग']

एनके = डमीनेकर ()
enc.fit (एक्स)

बारिश = एनकाउंटरफॉर्म (एक्स)

उत्पादन = एनकाउंटरफॉर्म (ए)

प्रिंट (प्रॉड)

OUTPUT: * * * * डेटा