python - যবহ - পাইথন প্রোগ্রামিং কি



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

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

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

  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 য় অংশটি প্রায়শই আটকে যায়, যদিও আমি একটি শক্তিশালী মেশিন ব্যবহার করি।

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

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


Answer #1

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

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-Human-Activity-Recognition


Answer #2

আপনি 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.]]

Answer #3

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


Answer #4

আপনি নিম্নলিখিতটিও করতে পারেন। নীচের জন্য নোট আপনি 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

Answer #5

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

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

Answer #6

এক-হট এনকোডিংয়ের জন্য মানগুলি সূচক ভেরিয়েবলগুলিতে রূপান্তর করার চেয়ে আরও কিছু বেশি প্রয়োজন। সাধারণত এমএল প্রক্রিয়াটির জন্য আপনাকে এই কোডিংটিকে বৈধতা বা পরীক্ষামূলক ডেটা সেটগুলিতে বেশ কয়েকবার প্রয়োগ করা এবং আপনি যে মডেলটি রিয়েল-টাইম পর্যবেক্ষণ করা ডেটাতে তৈরি করেন তা প্রয়োগ করা প্রয়োজন। মডেলটি তৈরি করতে আপনার ব্যবহৃত ম্যাপিং (রূপান্তর) সংরক্ষণ করা উচিত। একটি ভাল সমাধান DictVectorizer বা LabelEncoder DictVectorizer ব্যবহার করবে (তারপরে 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 ব্যবহার। একই সম্পর্কিত একটি পোস্ট আমার ব্লগে। আমি এখানে উল্লেখ করছি যেহেতু এটি কেবল get_dummy post ব্যবহার করার মাধ্যমে এই পদ্ধতির পিছনে কিছু যুক্তি সরবরাহ করে (প্রকাশ: এটি আমার নিজের ব্লগ)।


Answer #7

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

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

আউটপুট:

[0, 1, 2, 0]

Answer #8

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

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)

Answer #9

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

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

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

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

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)

Answer #10

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

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

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


Answer #11

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

Answer #12

পন্থা 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





one-hot-encoding