सामग्री की तालिका

· परिचय
∘ क्यों नहीं .get_dummies() ?
· आयात डेटा
∘ आयाम
∘ श्रेणीबद्ध चर की संख्या
∘ श्रेणीबद्ध चर फ़िल्टर करें
∘ अतिरिक्त कॉलम की अनुमानित संख्या
· एक हॉट एन्कोडिंग (ओएचई)
∘ अतिरिक्त कॉलम की वास्तविक संख्या

परिचय

मशीनें नंबरों से प्यार करती हैं टेक्स्ट डेटा की इतनी शौकीन नहीं हैं

बहुत सारा डेटा टेक्स्ट डेटा के रूप में आता है। डेटा वैज्ञानिकों को इस डेटा को एक संख्यात्मक डेटा प्रकार में बदलने में सक्षम होने की आवश्यकता है ताकि हमारे मशीन लर्निंग एल्गोरिदम में विस्फोट न हो

हमारे पहले मशीन लर्निंग 101 ट्यूटोरियल में, हम सीखेंगे कि डेटा सेट में वन हॉट एनकोड (ओएचई) श्रेणीबद्ध चर कैसे करें।

हम आवास बिक्री डेटा पर एक डेटा सेट लेंगे और हम डमी वैरिएबल बनाने के लिए इस डेटा फ़्रेम की सभी स्पष्ट विशेषताओं को एन्कोड करेंगे जो 0️ या 1 का मान लेगी । इन डमी वेरिएबल्स को फिर से मूल डेटा फ़्रेम में जोड़ा जाएगा।

बदले में, हमें ️ मूल टेक्स्ट कॉलम को भी छोड़ना होगा जो एन्कोड किए गए थे, क्योंकि हमारे मशीन लर्निंग एल्गोरिदम इन्हें ❌ पसंद नहीं करेंगे

क्यों नहीं .get_dummies( ) ?

.get_dummies() विधि का उपयोग करने के लिए श्रेणीबद्ध चर को एन्कोडिंग करने का एक वैकल्पिक तरीका है । इसके बजाय इस तरीके का इस्तेमाल क्यों नहीं करते?

इसका उत्तर इसलिए है क्योंकि .get_dummies( ) बड़े डेटा सेट के लिए OHE का उपयोग करने की तुलना में बहुत कम कुशल है OHE अधिक कुशल है क्योंकि यह संपूर्ण डेटा फ़्रेम को केवल आउटपुट करने के बजाय स्पार्स मैट्रिक्स नामक किसी चीज़ का लाभ उठाता है।

डेटा आयात कर रहा है

इस ट्यूटोरियल का डेटा मेरे जीथब पर पाया जा सकता है ।

# Import libraries
import pandas as pd
import numpy as np
import warnings

# Ignore warnings
warnings.filterwarnings("ignore")
    
# Import data
data = pd.read_csv("Housing_Sales_Data.csv")

# Display subset of data frame
data.iloc[:,:10].head()

.shape का उपयोग करके , हम अपने आवास डेटा फ्रेम के आयाम पा सकते हैं: 1379 पंक्तियाँ और 80 कॉलम।

# Inspect df dimensions
data.shape

.value_counts( ) मेथड का उपयोग करके , हम अपने डेटा फ्रेम में प्रत्येक प्रकार के वेरिएबल की संख्या की गणना कर सकते हैं हमें डेटा टाइप ऑब्जेक्ट (स्ट्रिंग वेरिएबल्स) के 43 कॉलम मिलेंगे। ये हमारे श्रेणीबद्ध स्तंभ हैं।

# Count data types
data.dtypes.value_counts()

      
                

                    
                    
                
            

अब हम एक वेरिएबल, मास्क बनाएंगे , जो हमें अपने डेटा फ्रेम से गैर-श्रेणीबद्ध कॉलम को फ़िल्टर करने में सक्षम करेगा। मुखौटा प्रत्येक सुविधा के लिए एक बूलियन मान लेगा, यह इस बात पर निर्भर करता है कि सुविधा एक श्रेणीबद्ध चर है या नहीं।

# Create mask variable
mask = data.dtypes == np.object

# Display mask
mask

      
                

                    
                    
                
            

# Select only categorical variables
categorical_cols = data.columns[mask]

यह देखने के लिए अच्छा अभ्यास है कि आप कितने अतिरिक्त चर बनाने की अपेक्षा करते हैं, यह देखने के लिए कि आपकी अनुमानित संख्या अंत में बनाए गए स्तंभों की वास्तविक संख्या के साथ संरेखित होती है या नहीं।

यह निर्धारित करने के लिए कि कितने अतिरिक्त कॉलम बनाए जाएंगे, हम लैम्ब्डा फ़ंक्शन का उपयोग करते हैं। प्रत्येक श्रेणीबद्ध चर के लिए, लैम्ब्डा फ़ंक्शन उस सुविधा के लिए अद्वितीय कक्षाओं की संख्या लौटाएगा।

# Determine number of extra columns
num_ohe_cols = (data[categorical_cols]
                .apply(lambda x: x.nunique())
                .sort_values(ascending=False))

# Display first 10 rows
num_ohe_cols.head(10)

      
                

                    
                    
                
            

हम केवल एक मान के साथ एन्कोडिंग सुविधाओं में रुचि नहीं लेंगे, इसलिए इन्हें डेटा फ़्रेम से हटा देंगे ❌ इस अवसर पर केवल एक मान वाली कोई विशेषता नहीं है, लेकिन यह एक उपयोगी कदम है।

# No need to encode if there is only one value
small_num_ohe_cols = num_ohe_cols.loc[num_ohe_cols>1]

एक उदाहरण के रूप में, नेबरहुड 25 डमी चर बनाएगा, क्योंकि इसमें 25 अद्वितीय वर्ग हैं (ऊपर देखें)। इन नए स्तंभों को मूल डेटा फ़्रेम में वापस जोड़ने से पहले, हम मूल पड़ोस स्तंभ को छोड़ देंगे क्योंकि इसकी अब आवश्यकता नहीं होगी (और इसके डेटा प्रकार के कारण इसका उपयोग नहीं किया जा सकता है)! इस प्रकार, हम 25 चर जोड़ रहे हैं ... लेकिन 1 घटा रहे हैं।

# Subtract 1 value from each feature
small_num_ohe_cols -= 1

# Sum of new features
small_num_ohe_cols.sum()

वन हॉट एनकोडिंग (ओएचई)

OneHotEncoder को आयात करने से पहले , हम एन्कोडिंग से पहले और बाद में कॉलम में अंतर की गणना करने के लिए अपने डेटा फ़्रेम की प्रतिलिपि बनाएंगे।

# Copy of the data
data_ohe = data.copy()

# Import OneHotEncoder
from sklearn.preprocessing import OneHotEncoder

# Initialise
ohe = OneHotEncoder()

# The encoders
ohe = OneHotEncoder(drop="first")

सौभाग्य से ... यह भविष्यवाणी पर कोई महत्वपूर्ण प्रभाव नहीं डालता है जो मुख्य रूप से मशीन लर्निंग से संबंधित है इसलिए, हम इसका उपयोग यहां नहीं करेंगे।

अब, हम एक for लूप बनाने जा रहे हैं यह लूप होगा:

1. प्रत्येक श्रेणीबद्ध विशेषता के माध्यम से लूप करें
2. एक विरल सरणी वापस करने के लिए डेटा को एक हॉट एनकोड करें
3. मूल डेटा फ़्रेम से संबद्ध स्तंभ निकालें
4. स्तंभ से सभी अद्वितीय वर्ग लेबल के नाम प्राप्त करें
5. मूल्य के अनुसार प्रत्येक एन्कोडेड कॉलम के लिए कॉलम नाम बनाएँ
6. नया डेटा फ्रेम बनाएं
7. नए एन्कोडेड डेटा फ़्रेम को मूल डेटा फ़्रेम में जोड़ें

# (1) - Loop through categorical variables
for col in num_ohe_cols.index:
    
    # (2) - OHE data to get sparse matrix
    new_dat = ohe.fit_transform(data_ohe[[col]])
    
    # (3) - Remove this column from original df
    data_ohe = data_ohe.drop(col, axis=1)
    
     # (4) - Get unique value names
    cats = ohe.categories_
    
    # (5) - Create column names
    new_cols = ['_'.join([col,cat]) for cat in cats[0]]
    
    # (6) - Create new df
    new_df = pd.DataFrame(new_dat.toarray(),columns=new_cols)
    
    # (7) - Append df
    data_ohe = pd.concat([data_ohe, new_df], axis =1)

फ़ाउंडेशन को इससे हटा दिए जाने के बाद यह डेटा फ़्रेम मूल डेटा फ़्रेम में जोड़ा जाता है । यह प्रक्रिया मूल डेटा फ्रेम में सभी 43 श्रेणीबद्ध चर के लिए दोहराती है

अतिरिक्त कॉलम की वास्तविक संख्या

जब हमने प्रत्येक श्रेणीबद्ध चर को एन्कोड किया है और सभी डमी चर को मूल डेटा फ़्रेम में वापस जोड़ दिया है ... अब हम यह पता लगाना चाहते हैं कि एन्कोडिंग द्वारा कितने अतिरिक्त कॉलम बनाए गए थे। याद कीजिए, हम 215 की उम्मीद कर रहे हैं!

हम दोनों डेटा फ़्रेमों पर .shape[1] का उपयोग करते हैं (नए डमी चर वाले और हमारे मूल वाले)। यह दोनों डेटा फ़्रेमों में स्तंभों की संख्या लौटाएगा। फिर हम केवल एक को दूसरे से घटाते हैं।

# Column difference is as calculated above
data_ohe.shape[1] - data.shape[1]

खत्म!

इसके साथ, यह ट्यूटोरियल समाप्त हो गया है! मुझे आशा है कि आपको यह मददगार लगा होगा। अगली बार तक … मटर का सूप ✌️