পাইথনে আমি কীভাবে একটি গরম এনকোড করতে পারি?


132

আমার কাছে ৮০% শ্রেণিবদ্ধ ভেরিয়েবলগুলির সাথে একটি মেশিন লার্নিং শ্রেণিবদ্ধকরণ সমস্যা রয়েছে। শ্রেণিবিন্যাসের জন্য কিছু শ্রেণিবদ্ধ ব্যবহার করতে চাইলে আমি কি একটি গরম এনকোডিং ব্যবহার করব? আমি কী কোডটি এনকোডিং ছাড়াই কোনও শ্রেণিবদ্ধের কাছে পাস করতে পারি?

বৈশিষ্ট্য নির্বাচনের জন্য আমি নিম্নলিখিতগুলি করার চেষ্টা করছি:

  1. আমি ট্রেনের ফাইলটি পড়েছি:

    num_rows_to_read = 10000
    train_small = pd.read_csv("../../dataset/train.csv",   nrows=num_rows_to_read)
  2. আমি শ্রেণিবদ্ধ বৈশিষ্ট্যগুলির ধরণটিকে 'বিভাগ' এ পরিবর্তন করি:

    non_categorial_features = ['orig_destination_distance',
                              'srch_adults_cnt',
                              'srch_children_cnt',
                              'srch_rm_cnt',
                              'cnt']
    
    for categorical_feature in list(train_small.columns):
        if categorical_feature not in non_categorial_features:
            train_small[categorical_feature] = train_small[categorical_feature].astype('category')
  3. আমি একটি গরম এনকোডিং ব্যবহার করি:

    train_small_with_dummies = pd.get_dummies(train_small, sparse=True)

সমস্যাটি হ'ল 3 য় অংশটি প্রায়শই আটকে যায়, যদিও আমি একটি শক্তিশালী মেশিন ব্যবহার করি।

সুতরাং, একটি গরম এনকোডিং ছাড়া আমি বৈশিষ্ট্যগুলির গুরুত্ব নির্ধারণের জন্য কোনও বৈশিষ্ট্য নির্বাচন করতে পারি না।

আপনি কি সুপারিশ করেন?

উত্তর:


159

পন্থা 1: আপনি পান্ডাস ডেটাফ্রেমে get_dummy ব্যবহার করতে পারেন।

উদাহরণ 1:

import pandas as pd
s = pd.Series(list('abca'))
pd.get_dummies(s)
Out[]: 
     a    b    c
0  1.0  0.0  0.0
1  0.0  1.0  0.0
2  0.0  0.0  1.0
3  1.0  0.0  0.0

উদাহরণ 2:

নিম্নলিখিত প্রদত্ত কলামটি একটি উত্তপ্ত রূপান্তর করবে। একাধিক ডমি রাখতে উপসর্গটি ব্যবহার করুন।

import pandas as pd

df = pd.DataFrame({
          'A':['a','b','a'],
          'B':['b','a','c']
        })
df
Out[]: 
   A  B
0  a  b
1  b  a
2  a  c

# Get one hot encoding of columns B
one_hot = pd.get_dummies(df['B'])
# Drop column B as it is now encoded
df = df.drop('B',axis = 1)
# Join the encoded df
df = df.join(one_hot)
df  
Out[]: 
       A  a  b  c
    0  a  0  1  0
    1  b  1  0  0
    2  a  0  0  1

পদ্ধতির 2: সাইকিট-শিখুন ব্যবহার করুন

তিনটি বৈশিষ্ট্য এবং চারটি নমুনা সহ একটি ডেটাসেট দেওয়া, আমরা এনকোডারটিকে প্রতিটি বৈশিষ্ট্য অনুযায়ী সর্বাধিক মান সন্ধান করি এবং বাইনারি এক-হট এনকোডিংয়ে ডেটা রূপান্তর করি।

>>> from sklearn.preprocessing import OneHotEncoder
>>> enc = OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])   
OneHotEncoder(categorical_features='all', dtype=<class 'numpy.float64'>,
   handle_unknown='error', n_values='auto', sparse=True)
>>> enc.n_values_
array([2, 3, 4])
>>> enc.feature_indices_
array([0, 2, 5, 9], dtype=int32)
>>> enc.transform([[0, 1, 1]]).toarray()
array([[ 1.,  0.,  0.,  1.,  0.,  0.,  1.,  0.,  0.]])

এই উদাহরণের জন্য এখানে লিঙ্কটি রয়েছে: http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html


20
সেটিং drop_first=Trueসঙ্গে get_dummiesঅপসারণ প্রয়োজন আলাদাভাবে মূল কলাম ড্রপ
OverflowingTheGlass

1
উদাহরণস্বরূপ 2, যোগদান ব্যবহার না করে ডেটাফ্রেমে নতুন কলামগুলিতে যোগদানের কোনও উপায় আছে? আমি সত্যিই একটি বড় ডেটাসেট নিয়ে কাজ করছি এবং যখন আমি এটি করার চেষ্টা করি তখন মেমোরিরর পাই।
জে ডাহলগ্রেন

আপনি যদি ডিফল্ট সারি ব্যবহার করে না থাকেন তবে আপনি জয়েন ব্যবহার না করেই ডেটাফ্রেমে নতুন কলাম যুক্ত করতে পারেন। [ "newColname"] = df2 [ "কর্নেল"] ডিএফ: আপনি ব্যবহার অনুলিপি করতে পারেন
Sayali Sonawane

1
উদাহরণস্বরূপ 2 ইমেজ ব্যবহার করা খারাপ ছিল
ভিলাসভ

9
@ ওভারফ্লোডিংগ্লাস- ড্রপ-ফার্স্ট = সত্য আসল কলামটি সরিয়ে দেয় না। এটি শ্রেণিবদ্ধ বৈশিষ্ট্যের প্রথম স্তরে নেমে যায় যাতে আপনি কে-কলামগুলির পরিবর্তে কে -১ কলাম দিয়ে শেষ করেন, কে বিভাগীয় বৈশিষ্ট্যের মূল পরিচয়।
গারিমা জৈন

42

বেসিক এক হট এনকোডিংয়ের জন্য পান্ডাস ব্যবহার করা অনেক সহজ। আপনি যদি আরও বিকল্পের সন্ধান করেন তবে আপনি ব্যবহার করতে পারেন scikit-learn

সঙ্গে মৌলিক এক গরম এনকোডিং-এর পান্ডাস আপনি কেবল আপনার ডেটা ফ্রেম পাস get_dummies ফাংশন।

উদাহরণস্বরূপ, যদি আমার imdb_movies নামে একটি ডেটাফ্রেম থাকে :

এখানে চিত্র বর্ণনা লিখুন

... এবং আমি রেটেড কলামটি এক-গরম এনকোড করতে চাই, আমি কেবল এটি করি:

pd.get_dummies(imdb_movies.Rated)

এখানে চিত্র বর্ণনা লিখুন

এটি প্রদত্ত রেটিংয়ের dataframeপ্রতিটি " স্তর " এর জন্য একটি কলাম সহ একটি নতুন ফেরত দেয় , সেই সাথে একটি প্রদত্ত পর্যবেক্ষণের জন্য এই রেটিংটির উপস্থিতি উল্লেখ করে 1 বা 0 হয়।

সাধারণত, আমরা এটির মূল অংশ হতে চাই dataframe। এই ক্ষেত্রে, আমরা কেবলমাত্র " কলাম-বাইন্ডিং " ব্যবহার করে আমাদের নতুন ডামি কোডেড ফ্রেমটি মূল ফ্রেমে সংযুক্ত করি

পান্ডাস কনক্যাট ফাংশনটি ব্যবহার করে আমরা কলাম-বাঁধাই করতে পারি :

rated_dummies = pd.get_dummies(imdb_movies.Rated)
pd.concat([imdb_movies, rated_dummies], axis=1)

এখানে চিত্র বর্ণনা লিখুন

আমরা এখন আমাদের পূর্ণ বিশ্লেষণ চালাতে পারি dataframe

সাধারণ ব্যবহারের কাজ

এটি করার জন্য আমি নিজেকে একটি ইউটিলিটি ফাংশন হিসাবে তৈরি করার পরামর্শ দেব :

def encode_and_bind(original_dataframe, feature_to_encode):
    dummies = pd.get_dummies(original_dataframe[[feature_to_encode]])
    res = pd.concat([original_dataframe, dummies], axis=1)
    return(res)

ব্যবহার :

encode_and_bind(imdb_movies, 'Rated')

ফলাফল :

এখানে চিত্র বর্ণনা লিখুন

এছাড়াও, @ পামলবু মন্তব্য অনুসারে, আপনি যদি মূল বৈশিষ্ট্য_টেন_কোডটি সরিয়ে ফাংশনটি করতে চান তবে এই সংস্করণটি ব্যবহার করুন:

def encode_and_bind(original_dataframe, feature_to_encode):
    dummies = pd.get_dummies(original_dataframe[[feature_to_encode]])
    res = pd.concat([original_dataframe, dummies], axis=1)
    res = res.drop([feature_to_encode], axis=1)
    return(res) 

আপনি নিম্নলিখিত হিসাবে একই সময়ে একাধিক বৈশিষ্ট্যগুলি এনকোড করতে পারেন:

features_to_encode = ['feature_1', 'feature_2', 'feature_3',
                      'feature_4']
for feature in features_to_encode:
    res = encode_and_bind(train_set, feature)

1
আসল বৈশিষ্ট্য_টি_কেনডটি মূল ডাটাফ্রেমের সাথে আপনি একটি উত্তপ্ত সমাপ্ত কলামগুলিকে সম্মতি জানানোর পরে আমি প্রস্তাব করব would
pmalbu

উত্তর দেওয়ার জন্য এই বিকল্পটি যুক্ত করা হয়েছে। ধন্যবাদ।
সাইবারনেটিক

28

আপনি এটি numpy.eyeব্যবহার করতে পারবেন এবং অ্যারে উপাদান নির্বাচন প্রক্রিয়াটি ব্যবহার করে:

import numpy as np
nb_classes = 6
data = [[2, 3, 4, 0]]

def indices_to_one_hot(data, nb_classes):
    """Convert an iterable of indices to one-hot encoded labels."""
    targets = np.array(data).reshape(-1)
    return np.eye(nb_classes)[targets]

এর রিটার্ন মান indices_to_one_hot(nb_classes, data)এখন

array([[[ 0.,  0.,  1.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  1.,  0.,  0.],
        [ 0.,  0.,  0.,  0.,  1.,  0.],
        [ 1.,  0.,  0.,  0.,  0.,  0.]]])

.reshape(-1)সেখানে আপনার কাছে সঠিক লেবেল বিন্যাস করতে (আপনি থাকতে পারে হয় [[2], [3], [4], [0]])।


1
এটি স্ট্রিংয়ের মান সহ কলামগুলির OHE এর জন্য কাজ করবে না।
অভিলাষ અવস্তি

2
@ অবিলাশ আওস্তি অবশ্যই ... তবে আপনি কেন এটি কাজ করবেন বলে আশা করবেন?
মার্টিন থোমা

22

প্রথমত, এক হট এনকোডের সহজতম উপায়: স্ক্লার্ন ব্যবহার করুন।

http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html

দ্বিতীয়ত, আমি মনে করি না যে একটি গরম এনকোডে পান্ডাস ব্যবহার করা এত সহজ (যদিও নিশ্চিত নয়)

পাইথনের জন্য পান্ডায় ডামি ভেরিয়েবল তৈরি করা

শেষ অবধি, আপনার জন্য কি একটি গরম এনকোড প্রয়োজনীয়? একটি গরম এনকোডিং তাত্পর্যপূর্ণভাবে বৈশিষ্ট্যগুলির সংখ্যা বাড়িয়ে তোলে, কোনও শ্রেণিবদ্ধকারীর চালনার সময় বা আপনি যে কোনও কিছু চালাতে যাচ্ছেন তা মারাত্মকভাবে বাড়িয়ে তোলে। বিশেষত যখন প্রতিটি শ্রেণিবদ্ধ বৈশিষ্ট্যটির অনেকগুলি স্তর থাকে। পরিবর্তে আপনি ডামি কোডিং করতে পারেন।

ডামি এনকোডিং ব্যবহার করা খুব কম সময় ও জটিলতার জন্য সাধারণত ভাল কাজ করে। জ্ঞানী অধ্যাপক একবার আমাকে বলেছিলেন, 'কম ইজ মোর'।

আপনি যদি চান তবে আমার কাস্টম এনকোডিংয়ের জন্য কোডটি এখানে।

from sklearn.preprocessing import LabelEncoder

#Auto encodes any dataframe column of type category or object.
def dummyEncode(df):
        columnsToEncode = list(df.select_dtypes(include=['category','object']))
        le = LabelEncoder()
        for feature in columnsToEncode:
            try:
                df[feature] = le.fit_transform(df[feature])
            except:
                print('Error encoding '+feature)
        return df

সম্পাদনা: পরিষ্কার হওয়ার তুলনা:

এক-হট এনকোডিং: এন স্তরগুলিকে এন -1 কলামে রূপান্তর করুন।

Index  Animal         Index  cat  mouse
  1     dog             1     0     0
  2     cat       -->   2     1     0
  3    mouse            3     0     1

আপনি যদি দেখতে পারেন যে আপনার শ্রেণিবদ্ধ বৈশিষ্ট্যটিতে বিভিন্ন ধরণের (বা স্তর) থাকে তবে এটি কীভাবে আপনার স্মৃতি বিস্ফোরিত করবে। মনে রাখবেন, এটি কেবলমাত্র একটি কলাম।

ডামি কোডিং:

Index  Animal         Index  Animal
  1     dog             1      0   
  2     cat       -->   2      1 
  3    mouse            3      2

পরিবর্তে সংখ্যার উপস্থাপনায় রূপান্তর করুন। কিছুটা নির্ভুলতার ব্যয় করে দুর্দান্তভাবে ফিচার স্পেস সংরক্ষণ করে।


1
1. আমার কাছে একটি ডেটা সেট রয়েছে যার ৮০% শ্রেণীবদ্ধ ভেরিয়েবল রয়েছে। আমার বোঝার জন্য, যদি আমি এই ডেটাটির জন্য কোনও শ্রেণিবদ্ধ ব্যবহার করতে চাই তবে আমাকে একটি গরম এনকোডিং অবশ্যই ব্যবহার করতে হবে, অন্যথায় একটি গরম এনকোডিং না করার ক্ষেত্রে শ্রেণিবদ্ধার শ্রেণিবদ্ধ ভেরিয়েবলগুলি সঠিক উপায়ে আচরণ করবে না? এনকোড না করার কোনও বিকল্প নেই? ২. আমি যদি স্যাপারস = ট্রু সহ পিডি.গেট_ডমিগুলি (ট্রেন_স্মাল, স্পারস = ট্রু) ব্যবহার করি - যা স্মৃতি সমস্যার সমাধান করে না? ৩. আমি কীভাবে এ জাতীয় সমস্যার কাছে যেতে পারি?
এভিকোহেন

আমি যেমন বলেছি, দুটি বিকল্প আছে। 1) একটি হট এনকোড -> প্রতিটি স্তরের শ্রেণিবদ্ধ বৈশিষ্ট্যগুলিকে একটি নতুন কলামে রূপান্তর করুন। 2) ডামি কোডিং -> প্রতিটি কলামকে সাংখ্যিক উপস্থাপনায় রূপান্তর করুন। আমি আমার উত্তরটি আরও পরিষ্কার করে পরিষ্কার করব তবে আপনি কেবল প্রদত্ত ফাংশনটি চালাতে পারেন এবং এটির কাজ করা উচিত
Wboy

17
"কিছুটা নির্ভুলতার জন্য।" আপনি কীভাবে "কিছুটা" বলতে পারেন? হতে পারে কিছু ক্ষেত্রে, তবে অন্যদের মধ্যে নির্ভুলতা অনেকটা আঘাত করতে পারে। এই সমাধানটির ফলে গুণগত বৈশিষ্ট্যগুলি অবিচ্ছিন্ন হিসাবে চিকিত্সা করার ফলাফল হয় যার অর্থ আপনার মডেলটি ডেটা থেকে সঠিকভাবে শিখবে না।
জোশ মোরেল

2
জোশ উপরে যেমন বলেছিলেন, আপনার দ্বিতীয় উদাহরণে আপনি মডেলকে বলে শেষ করেছেন mouse > cat > dogতবে এটি ঘটনাটি নয়। get_dummiesআমার অভিজ্ঞতা থেকে মডেল বান্ধব ডেটাগুলিতে শ্রেণিবদ্ধ ভেরিয়েবলগুলি স্থানান্তরিত করার সবচেয়ে সোজা এগিয়ে যাওয়ার উপায় (যদিও খুব সীমাবদ্ধ)
মার্টিন হে ল্যারি

5
এই সমাধানটি খুব বিপজ্জনক কিছু অন্যান্য মন্তব্য দ্বারা চিহ্নিত হিসাবে। এটি নির্বিচারে শ্রেণিবদ্ধ ভেরিয়েবলগুলিকে অর্ডার এবং দূরত্ব নির্ধারণ করে। এটি করা এলোমেলো উপায়ে মডেলের নমনীয়তা হ্রাস করে। গাছ ভিত্তিক মডেলগুলির জন্য, এই জাতীয় এনকোডিং সম্ভাব্য সাবসেটিং সম্ভাবনা হ্রাস করে। উদাহরণস্বরূপ, আপনি এখন কেবল দুটি সম্ভাব্য বিভাজন পেতে পারেন [[0), (1,2)] এবং [(0,1), (2)], এবং বিভাজন [(0,2), (1)] অসম্ভব। বিভাগের সংখ্যা বেশি হলে ক্ষতি অনেক বেশি তাৎপর্যপূর্ণ।
এলোমেলো নিশ্চয়তা

19

পান্ডাস সহ একটি গরম এনকোডিং খুব সহজ:

def one_hot(df, cols):
    """
    @param df pandas DataFrame
    @param cols a list of columns to encode 
    @return a DataFrame with one-hot encoding
    """
    for each in cols:
        dummies = pd.get_dummies(df[each], prefix=each, drop_first=False)
        df = pd.concat([df, dummies], axis=1)
    return df

সম্পাদনা করুন:

স্কলার্ন ব্যবহার করে ওয়ান_হোট করার আরেকটি উপায় LabelBinarizer:

from sklearn.preprocessing import LabelBinarizer 
label_binarizer = LabelBinarizer()
label_binarizer.fit(all_your_labels_list) # need to be global or remembered to use it later

def one_hot_encode(x):
    """
    One hot encode a list of sample labels. Return a one-hot encoded vector for each label.
    : x: List of sample Labels
    : return: Numpy array of one-hot encoded labels
    """
    return label_binarizer.transform(x)

14

আপনি numpy.eye ফাংশন ব্যবহার করতে পারেন।

import numpy as np

def one_hot_encode(x, n_classes):
    """
    One hot encode a list of sample labels. Return a one-hot encoded vector for each label.
    : x: List of sample Labels
    : return: Numpy array of one-hot encoded labels
     """
    return np.eye(n_classes)[x]

def main():
    list = [0,1,2,3,4,3,2,1,0]
    n_classes = 5
    one_hot_list = one_hot_encode(list, n_classes)
    print(one_hot_list)

if __name__ == "__main__":
    main()

ফলাফল

D:\Desktop>python test.py
[[ 1.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  0.  0.  1.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 1.  0.  0.  0.  0.]]

2
আপনি কি আমার উত্তরটি অনুলিপি করেছেন?
মার্টিন থোমা

@ মার্টিন থোমা - ​​আমার মনে হয়, আমি করি নি
ডিয়েটার

5

পান্ডস যেমন নির্দিষ্ট কলাম / গুলিগুলির একটি হট এনকোডিং পেতে "get_dummy" ফাংশন রয়েছে bu

এক-হট-এনকোডিংয়ের জন্য একটি লাইন কোড:

df=pd.concat([df,pd.get_dummies(df['column name'],prefix='column name')],axis=1).drop(['column name'],axis=1)

4

এখানে একটি সমাধান DictVectorizerএবং পান্ডাস DataFrame.to_dict('records')পদ্ধতি ব্যবহার করে একটি সমাধান দেওয়া হয়েছে ।

>>> import pandas as pd
>>> X = pd.DataFrame({'income': [100000,110000,90000,30000,14000,50000],
                      'country':['US', 'CAN', 'US', 'CAN', 'MEX', 'US'],
                      'race':['White', 'Black', 'Latino', 'White', 'White', 'Black']
                     })

>>> from sklearn.feature_extraction import DictVectorizer
>>> v = DictVectorizer()
>>> qualitative_features = ['country','race']
>>> X_qual = v.fit_transform(X[qualitative_features].to_dict('records'))
>>> v.vocabulary_
{'country=CAN': 0,
 'country=MEX': 1,
 'country=US': 2,
 'race=Black': 3,
 'race=Latino': 4,
 'race=White': 5}

>>> X_qual.toarray()
array([[ 0.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  1.,  0.],
       [ 1.,  0.,  0.,  0.,  0.,  1.],
       [ 0.,  1.,  0.,  0.,  0.,  1.],
       [ 0.,  0.,  1.,  1.,  0.,  0.]])

3

এক-হট এনকোডিংয়ের মানকে সূচক ভেরিয়েবলগুলিতে রূপান্তর করার চেয়ে আরও কিছু বেশি প্রয়োজন। সাধারণত এমএল প্রক্রিয়াটির জন্য আপনাকে এই কোডিংটিকে বৈধতা বা পরীক্ষামূলক ডেটা সেটগুলিতে বেশ কয়েকবার প্রয়োগ করা এবং আপনি যে মডেলটি রিয়েল-টাইম পর্যবেক্ষণ করা ডেটাতে তৈরি করেন তা প্রয়োগ করতে হয়। মডেলটি তৈরি করতে আপনার ব্যবহৃত ম্যাপিং (রূপান্তর) সংরক্ষণ করা উচিত। একটি ভাল সমাধানটি ব্যবহার করবে DictVectorizerবা LabelEncoder(তারপরে get_dummies। এখানে আপনি একটি ফাংশন ব্যবহার করতে পারেন:

def oneHotEncode2(df, le_dict = {}):
    if not le_dict:
        columnsToEncode = list(df.select_dtypes(include=['category','object']))
        train = True;
    else:
        columnsToEncode = le_dict.keys()   
        train = False;

    for feature in columnsToEncode:
        if train:
            le_dict[feature] = LabelEncoder()
        try:
            if train:
                df[feature] = le_dict[feature].fit_transform(df[feature])
            else:
                df[feature] = le_dict[feature].transform(df[feature])

            df = pd.concat([df, 
                              pd.get_dummies(df[feature]).rename(columns=lambda x: feature + '_' + str(x))], axis=1)
            df = df.drop(feature, axis=1)
        except:
            print('Error encoding '+feature)
            #df[feature]  = df[feature].convert_objects(convert_numeric='force')
            df[feature]  = df[feature].apply(pd.to_numeric, errors='coerce')
    return (df, le_dict)

এটি একটি পান্ডাস ডেটা ফ্রেমে কাজ করে এবং ডেটাফ্রেমের প্রতিটি কলামের জন্য এটি তৈরি করে এবং একটি ম্যাপিং ফিরে দেয়। সুতরাং আপনি এটিকে এটি কল করবেন:

train_data, le_dict = oneHotEncode2(train_data)

তারপরে পরীক্ষার ডেটাতে, অভিধানটি প্রশিক্ষণ থেকে ফিরে এসে পাস করার মাধ্যমে কল করা হয়:

test_data, _ = oneHotEncode2(test_data, le_dict)

একটি সমতুল্য পদ্ধতি ব্যবহার করা হয় DictVectorizer। একই সম্পর্কিত একটি পোস্ট আমার ব্লগে on আমি এখানে উল্লেখ করছি যেহেতু এটি কেবল get_dummy পোস্ট ব্যবহার করার মাধ্যমে এই পদ্ধতির পিছনে কিছু যুক্তি সরবরাহ করে (প্রকাশ: এটি আমার নিজের ব্লগ)।


3

আপনি কোডটি এনকোডিং না করে ক্যাটাবুস্ট ক্লাসিফায়ারে ডেটা পাস করতে পারেন। ক্যাটবুস্ট ওয়ান-হট এবং টার্গেট এক্সপেন্ডিং মানে এনকোডিং সম্পাদন করে স্বতন্ত্র ভেরিয়েবলগুলি পরিচালনা করে।


3

আপনি নিম্নলিখিতটিও করতে পারেন। নীচের জন্য নোট আপনি ব্যবহার করতে হবে না pd.concat

import pandas as pd 
# intialise data of lists. 
data = {'Color':['Red', 'Yellow', 'Red', 'Yellow'], 'Length':[20.1, 21.1, 19.1, 18.1],
       'Group':[1,2,1,2]} 

# Create DataFrame 
df = pd.DataFrame(data) 

for _c in df.select_dtypes(include=['object']).columns:
    print(_c)
    df[_c]  = pd.Categorical(df[_c])
df_transformed = pd.get_dummies(df)
df_transformed

আপনি সুস্পষ্ট কলামগুলি শ্রেণীবদ্ধেও পরিবর্তন করতে পারেন। উদাহরণস্বরূপ, আমি এখানে Colorএবং পরিবর্তন করছিGroup

import pandas as pd 
# intialise data of lists. 
data = {'Color':['Red', 'Yellow', 'Red', 'Yellow'], 'Length':[20.1, 21.1, 19.1, 18.1],
       'Group':[1,2,1,2]} 

# Create DataFrame 
df = pd.DataFrame(data) 
columns_to_change = list(df.select_dtypes(include=['object']).columns)
columns_to_change.append('Group')
for _c in columns_to_change:
    print(_c)
    df[_c]  = pd.Categorical(df[_c])
df_transformed = pd.get_dummies(df)
df_transformed

2

আমি জানি যে আমি এই পার্টিতে দেরি করেছি, তবে স্বয়ংক্রিয় উপায়ে ডেটাফ্রেমকে হট এনকোড করার সহজতম উপায় হ'ল এই ফাংশনটি ব্যবহার করা:

def hot_encode(df):
    obj_df = df.select_dtypes(include=['object'])
    return pd.get_dummies(df, columns=obj_df.columns).values

1

আমি এটি আমার অ্যাকোস্টিক মডেলটিতে ব্যবহার করেছি: সম্ভবত এটি আপনার মডেলকে সহায়তা করে।

def one_hot_encoding(x, n_out):
    x = x.astype(int)  
    shape = x.shape
    x = x.flatten()
    N = len(x)
    x_categ = np.zeros((N,n_out))
    x_categ[np.arange(N), x] = 1
    return x_categ.reshape((shape)+(n_out,))

0

অন্যান্য প্রশ্নগুলিতে যুক্ত করতে, আমাকে নম্পি ব্যবহার করে পাইথন ২.০ ফাংশনটি কীভাবে এটি দিয়েছি তা সরবরাহ করি:

def one_hot(y_):
    # Function to encode output labels from number indexes 
    # e.g.: [[5], [0], [3]] --> [[0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]]

    y_ = y_.reshape(len(y_))
    n_values = np.max(y_) + 1
    return np.eye(n_values)[np.array(y_, dtype=np.int32)]  # Returns FLOATS

n_values = np.max(y_) + 1উদাহরণস্বরূপ আপনি মিনি-ব্যাচগুলি ব্যবহার করেন তবে আপনাকে ভাল সংখ্যক নিউরন ব্যবহার করার জন্য লাইনটি হার্ড-কোডড হতে পারে।

ডেমো প্রকল্প / টিউটোরিয়াল যেখানে এই ফাংশনটি ব্যবহার করা হয়েছে: https://github.com/guillaume-chevalier/LSTM- হিউম্যান- কার্যকলাপ- পরিচিতি


0

এটি আমার পক্ষে কাজ করে:

pandas.factorize( ['B', 'C', 'D', 'B'] )[0]

আউটপুট:

[0, 1, 2, 0]

0

এটি হতে পারে এবং এটি সহজ হওয়া উচিত:

class OneHotEncoder:
    def __init__(self,optionKeys):
        length=len(optionKeys)
        self.__dict__={optionKeys[j]:[0 if i!=j else 1 for i in range(length)] for j in range(length)}

ব্যবহার:

ohe=OneHotEncoder(["A","B","C","D"])
print(ohe.A)
print(ohe.D)

0

@ মার্টিন থোমার উত্তর প্রসারিত করা হচ্ছে

def one_hot_encode(y):
    """Convert an iterable of indices to one-hot encoded labels."""
    y = y.flatten() # Sometimes not flattened vector is passed e.g (118,1) in these cases
    # the function ends up creating a tensor e.g. (118, 2, 1). flatten removes this issue
    nb_classes = len(np.unique(y)) # get the number of unique classes
    standardised_labels = dict(zip(np.unique(y), np.arange(nb_classes))) # get the class labels as a dictionary
    # which then is standardised. E.g imagine class labels are (4,7,9) if a vector of y containing 4,7 and 9 is
    # directly passed then np.eye(nb_classes)[4] or 7,9 throws an out of index error.
    # standardised labels fixes this issue by returning a dictionary;
    # standardised_labels = {4:0, 7:1, 9:2}. The values of the dictionary are mapped to keys in y array.
    # standardised_labels also removes the error that is raised if the labels are floats. E.g. 1.0; element
    # cannot be called by an integer index e.g y[1.0] - throws an index error.
    targets = np.vectorize(standardised_labels.get)(y) # map the dictionary values to array.
    return np.eye(nb_classes)[targets]

0

সংক্ষিপ্ত উত্তর

নমপি, পান্ডা বা অন্যান্য প্যাকেজ ব্যবহার না করে ওয়ান হট-এনকোডিং করার জন্য এখানে একটি ফাংশন is এটি পূর্ণসংখ্যা, বুলিয়ান বা স্ট্রিংগুলির (এবং সম্ভবত অন্যান্য ধরণেরও) একটি তালিকা নেয়।

import typing


def one_hot_encode(items: list) -> typing.List[list]:
    results = []
    # find the unique items (we want to unique items b/c duplicate items will have the same encoding)
    unique_items = list(set(items))
    # sort the unique items
    sorted_items = sorted(unique_items)
    # find how long the list of each item should be
    max_index = len(unique_items)

    for item in items:
        # create a list of zeros the appropriate length
        one_hot_encoded_result = [0 for i in range(0, max_index)]
        # find the index of the item
        one_hot_index = sorted_items.index(item)
        # change the zero at the index from the previous line to a one
        one_hot_encoded_result[one_hot_index] = 1
        # add the result
        results.append(one_hot_encoded_result)

    return results

উদাহরণ:

one_hot_encode([2, 1, 1, 2, 5, 3])

# [[0, 1, 0, 0],
#  [1, 0, 0, 0],
#  [1, 0, 0, 0],
#  [0, 1, 0, 0],
#  [0, 0, 0, 1],
#  [0, 0, 1, 0]]
one_hot_encode([True, False, True])

# [[0, 1], [1, 0], [0, 1]]
one_hot_encode(['a', 'b', 'c', 'a', 'e'])

# [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0], [0, 0, 0, 1]]

দীর্ঘ (এর) উত্তর

আমি জানি আমি ইতিমধ্যে এই প্রশ্নের উত্তর অনেক আছে, কিন্তু আমি দুটি জিনিস লক্ষ্য। প্রথমত, বেশিরভাগ উত্তরগুলিতে নম্পি এবং / অথবা পান্ডার মতো প্যাকেজ ব্যবহার করা হয়। এবং এটি একটি ভাল জিনিস। আপনি যদি প্রোডাকশন কোডটি লিখছেন তবে আপনার সম্ভবত নমুনা / পান্ডাস প্যাকেজগুলিতে প্রদত্ত মতো শক্তিশালী, দ্রুত অ্যালগরিদম ব্যবহার করা উচিত। তবে, শিক্ষার স্বার্থে, আমি মনে করি যে কারও উত্তর দেওয়া উচিত যা একটি স্বচ্ছ অ্যালগরিদম আছে এবং কেবল অন্য কারও অ্যালগরিদমের বাস্তবায়ন নয়। দ্বিতীয়ত, আমি লক্ষ করেছি যে উত্তরগুলির অনেকগুলি ওয়ান-হট এনকোডিংয়ের দৃ implementation় বাস্তবায়ন সরবরাহ করে না কারণ তারা নীচের একটি প্রয়োজনীয়তা পূরণ করে না। দরকারী, নির্ভুল এবং শক্তিশালী ও-হট এনকোডিং ফাংশনের জন্য নীচে কয়েকটি প্রয়োজনীয়তা (যেমন আমি তাদের দেখতে পাচ্ছি):

একটি-গরম এনকোডিং ফাংশন অবশ্যই:

  • ইনপুট হিসাবে বিভিন্ন ধরণের (যেমন পূর্ণসংখ্যা, স্ট্রিংস, ফ্লোটস ইত্যাদি) তালিকা পরিচালনা করুন
  • সদৃশগুলি সহ একটি ইনপুট তালিকা পরিচালনা করুন
  • ইনপুটগুলিতে অনুরূপ তালিকার একটি তালিকা (একই ক্রমে) ফেরত দিন
  • প্রতিটি তালিকার যতটা সম্ভব সংক্ষিপ্ত তালিকাগুলির একটি তালিকা ফিরিয়ে দিন

আমি এই প্রশ্নের অনেক উত্তর পরীক্ষা করেছি এবং তাদের বেশিরভাগ উপরোক্ত প্রয়োজনীয়তার একটিতে ব্যর্থ fail


0

এটা চেষ্টা কর:

!pip install category_encoders
import category_encoders as ce

categorical_columns = [...the list of names of the columns you want to one-hot-encode ...]
encoder = ce.OneHotEncoder(cols=categorical_columns, use_cat_names=True)
df_train_encoded = encoder.fit_transform(df_train_small)

df_encoded.head ()

ফলস্বরূপ ডেটাফ্রেম df_train_encodedমূল হিসাবে একই, তবে শ্রেণিবদ্ধ বৈশিষ্ট্যগুলি এখন তাদের এক-হট-এনকোড সংস্করণ দিয়ে প্রতিস্থাপন করা হয়েছে।

আরও তথ্য category_encoders এখানে


-1

এখানে আমি এই পদ্ধতির সাথে চেষ্টা করেছি:

import numpy as np
#converting to one_hot





def one_hot_encoder(value, datal):

    datal[value] = 1

    return datal


def _one_hot_values(labels_data):
    encoded = [0] * len(labels_data)

    for j, i in enumerate(labels_data):
        max_value = [0] * (np.max(labels_data) + 1)

        encoded[j] = one_hot_encoder(i, max_value)

    return np.array(encoded)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.