42 KiB

Raw Permalink Blame History

श्रेणियों की भविष्यवाणी के लिए लॉजिस्टिक रिग्रेशन

प्री-लेक्चर क्विज़

यह पाठ R में उपलब्ध है!

परिचय

रिग्रेशन पर इस अंतिम पाठ में, जो कि एक बुनियादी क्लासिक मशीन लर्निंग तकनीक है, हम लॉजिस्टिक रिग्रेशन पर नज़र डालेंगे। आप इस तकनीक का उपयोग पैटर्न खोजने और बाइनरी श्रेणियों की भविष्यवाणी करने के लिए करेंगे। क्या यह कैंडी चॉकलेट है या नहीं? क्या यह बीमारी संक्रामक है या नहीं? क्या यह ग्राहक इस उत्पाद को चुनेगा या नहीं?

इस पाठ में, आप सीखेंगे:

डेटा विज़ुअलाइज़ेशन के लिए एक नई लाइब्रेरी
लॉजिस्टिक रिग्रेशन की तकनीकें

✅ इस प्रकार के रिग्रेशन के साथ काम करने की अपनी समझ को इस लर्न मॉड्यूल में गहरा करें।

पूर्वापेक्षा

कद्दू डेटा के साथ काम करने के बाद, अब हम इसके साथ पर्याप्त रूप से परिचित हैं कि यह महसूस कर सकें कि इसमें एक बाइनरी श्रेणी है जिसके साथ हम काम कर सकते हैं: Color।

आइए एक लॉजिस्टिक रिग्रेशन मॉडल बनाएं ताकि कुछ वेरिएबल्स के आधार पर किसी दिए गए कद्दू का रंग क्या होगा (नारंगी 🎃 या सफेद 👻) की भविष्यवाणी की जा सके।

हम रिग्रेशन के बारे में पाठ समूह में बाइनरी वर्गीकरण की बात क्यों कर रहे हैं? केवल भाषाई सुविधा के लिए, क्योंकि लॉजिस्टिक रिग्रेशन वास्तव में एक वर्गीकरण विधि है, हालांकि यह एक लीनियर-आधारित विधि है। डेटा को वर्गीकृत करने के अन्य तरीकों के बारे में अगले पाठ समूह में जानें।

प्रश्न को परिभाषित करें

हमारे उद्देश्यों के लिए, हम इसे बाइनरी के रूप में व्यक्त करेंगे: 'सफेद' या 'सफेद नहीं'। हमारे डेटासेट में एक 'धारीदार' श्रेणी भी है, लेकिन इसके कुछ ही उदाहरण हैं, इसलिए हम इसका उपयोग नहीं करेंगे। यह वैसे भी तब गायब हो जाती है जब हम डेटासेट से null मानों को हटा देते हैं।

🎃 मजेदार तथ्य, हम कभी-कभी सफेद कद्दू को 'भूत' कद्दू कहते हैं। इन्हें तराशना बहुत आसान नहीं होता, इसलिए ये नारंगी कद्दू जितने लोकप्रिय नहीं हैं, लेकिन ये देखने में बहुत अच्छे लगते हैं! तो हम अपने प्रश्न को इस तरह भी पुनः स्वरूपित कर सकते हैं: 'भूत' या 'भूत नहीं'। 👻

लॉजिस्टिक रिग्रेशन के बारे में

लॉजिस्टिक रिग्रेशन कुछ महत्वपूर्ण तरीकों से लीनियर रिग्रेशन से अलग है, जिसे आपने पहले सीखा था।

🎥 लॉजिस्टिक रिग्रेशन का संक्षिप्त वीडियो अवलोकन देखने के लिए ऊपर दी गई छवि पर क्लिक करें।

बाइनरी वर्गीकरण

लॉजिस्टिक रिग्रेशन लीनियर रिग्रेशन के समान सुविधाएँ प्रदान नहीं करता। पूर्व बाइनरी श्रेणी ("सफेद या सफेद नहीं") के बारे में भविष्यवाणी प्रदान करता है, जबकि बाद वाला निरंतर मानों की भविष्यवाणी करने में सक्षम है, उदाहरण के लिए कद्दू की उत्पत्ति और कटाई के समय को देखते हुए, इसकी कीमत कितनी बढ़ेगी।

इन्फोग्राफिक दसानी मडिपल्ली द्वारा

अन्य वर्गीकरण

लॉजिस्टिक रिग्रेशन के अन्य प्रकार भी हैं, जिनमें मल्टीनोमियल और ऑर्डिनल शामिल हैं:

मल्टीनोमियल, जिसमें एक से अधिक श्रेणियां होती हैं - "नारंगी, सफेद और धारीदार"।
ऑर्डिनल, जिसमें क्रमबद्ध श्रेणियां होती हैं, उपयोगी यदि हम अपने परिणामों को तार्किक रूप से क्रमबद्ध करना चाहते हैं, जैसे हमारे कद्दू जो आकारों की सीमित संख्या (मिनी, स्मॉल, मीडियम, लार्ज, एक्सएल, एक्सएक्सएल) द्वारा क्रमबद्ध होते हैं।

वेरिएबल्स का सहसंबंध होना आवश्यक नहीं है

याद रखें कि लीनियर रिग्रेशन अधिक सहसंबद्ध वेरिएबल्स के साथ बेहतर काम करता था? लॉजिस्टिक रिग्रेशन इसके विपरीत है - वेरिएबल्स का सहसंबद्ध होना आवश्यक नहीं है। यह इस डेटा के लिए काम करता है जिसमें सहसंबंध अपेक्षाकृत कमजोर हैं।

आपको बहुत सारे साफ डेटा की आवश्यकता है

लॉजिस्टिक रिग्रेशन अधिक डेटा का उपयोग करने पर अधिक सटीक परिणाम देगा; हमारा छोटा डेटासेट इस कार्य के लिए आदर्श नहीं है, इसलिए इसे ध्यान में रखें।

🎥 लीनियर रिग्रेशन के लिए डेटा तैयार करने का संक्षिप्त वीडियो अवलोकन देखने के लिए ऊपर दी गई छवि पर क्लिक करें।

✅ उन प्रकार के डेटा के बारे में सोचें जो लॉजिस्टिक रिग्रेशन के लिए उपयुक्त हो सकते हैं।

अभ्यास - डेटा को व्यवस्थित करें

सबसे पहले, डेटा को थोड़ा साफ करें, null मानों को हटाएं और केवल कुछ कॉलम चुनें:

निम्नलिखित कोड जोड़ें:


columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
pumpkins = full_pumpkins.loc[:, columns_to_select]

pumpkins.dropna(inplace=True)

आप हमेशा अपने नए डेटा फ्रेम पर एक नज़र डाल सकते हैं:

pumpkins.info

विज़ुअलाइज़ेशन - श्रेणीबद्ध प्लॉट

अब तक आपने स्टार्टर नोटबुक को कद्दू डेटा के साथ फिर से लोड कर लिया है और इसे इस तरह से साफ कर लिया है कि इसमें कुछ वेरिएबल्स, जिनमें Color शामिल है, का डेटासेट संरक्षित हो। आइए नोटबुक में डेटा फ्रेम को एक अलग लाइब्रेरी का उपयोग करके विज़ुअलाइज़ करें: Seaborn, जो पहले उपयोग किए गए Matplotlib पर आधारित है।

Seaborn आपके डेटा को विज़ुअलाइज़ करने के कुछ शानदार तरीके प्रदान करता है। उदाहरण के लिए, आप Variety और Color के लिए डेटा वितरण की तुलना एक श्रेणीबद्ध प्लॉट में कर सकते हैं।

catplot फ़ंक्शन का उपयोग करके, हमारे कद्दू डेटा pumpkins का उपयोग करके, और प्रत्येक कद्दू श्रेणी (नारंगी या सफेद) के लिए रंग मैपिंग निर्दिष्ट करके ऐसा प्लॉट बनाएं:
```
import seaborn as sns

palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}

sns.catplot(
data=pumpkins, y="Variety", hue="Color", kind="count",
palette=palette, 
)
```
डेटा का अवलोकन करके, आप देख सकते हैं कि Color डेटा Variety से कैसे संबंधित है।

✅ इस श्रेणीबद्ध प्लॉट को देखते हुए, आप कौन-कौन से रोचक अन्वेषणों की कल्पना कर सकते हैं?

डेटा पूर्व-प्रसंस्करण: फीचर और लेबल एन्कोडिंग

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

फीचर एन्कोडिंग के लिए दो मुख्य प्रकार के एन्कोडर हैं:

ऑर्डिनल एन्कोडर: यह ऑर्डिनल वेरिएबल्स के लिए उपयुक्त है, जो श्रेणीबद्ध वेरिएबल्स हैं जहां उनका डेटा तार्किक क्रम का पालन करता है, जैसे हमारे डेटासेट में Item Size कॉलम। यह एक मैपिंग बनाता है ताकि प्रत्येक श्रेणी को एक संख्या द्वारा दर्शाया जा सके, जो कॉलम में श्रेणी का क्रम है।
```
from sklearn.preprocessing import OrdinalEncoder

item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
ordinal_features = ['Item Size']
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
```
श्रेणीबद्ध एन्कोडर: यह नाममात्र वेरिएबल्स के लिए उपयुक्त है, जो श्रेणीबद्ध वेरिएबल्स हैं जहां उनका डेटा तार्किक क्रम का पालन नहीं करता, जैसे हमारे डेटासेट में Item Size के अलावा अन्य सभी फीचर्स। यह एक वन-हॉट एन्कोडिंग है, जिसका अर्थ है कि प्रत्येक श्रेणी को एक बाइनरी कॉलम द्वारा दर्शाया जाता है: एन्कोडेड वेरिएबल 1 के बराबर है यदि कद्दू उस Variety से संबंधित है और अन्यथा 0।
```
from sklearn.preprocessing import OneHotEncoder

categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
categorical_encoder = OneHotEncoder(sparse_output=False)
```

इसके बाद, ColumnTransformer का उपयोग कई एन्कोडर्स को एक ही चरण में संयोजित करने और उन्हें उपयुक्त कॉलम पर लागू करने के लिए किया जाता है।

    from sklearn.compose import ColumnTransformer
    
    ct = ColumnTransformer(transformers=[
        ('ord', ordinal_encoder, ordinal_features),
        ('cat', categorical_encoder, categorical_features)
        ])
    
    ct.set_output(transform='pandas')
    encoded_features = ct.fit_transform(pumpkins)

दूसरी ओर, लेबल को एन्कोड करने के लिए, हम scikit-learn LabelEncoder क्लास का उपयोग करते हैं, जो एक उपयोगिता क्लास है जो लेबल्स को सामान्य बनाने में मदद करता है ताकि वे केवल 0 और n_classes-1 (यहां, 0 और 1) के बीच मानों को शामिल करें।

    from sklearn.preprocessing import LabelEncoder

    label_encoder = LabelEncoder()
    encoded_label = label_encoder.fit_transform(pumpkins['Color'])

एक बार जब हमने फीचर्स और लेबल को एन्कोड कर लिया, तो हम उन्हें एक नए डेटा फ्रेम encoded_pumpkins में मर्ज कर सकते हैं।

    encoded_pumpkins = encoded_features.assign(Color=encoded_label)

✅ Item Size कॉलम के लिए ऑर्डिनल एन्कोडर का उपयोग करने के क्या फायदे हैं?

वेरिएबल्स के बीच संबंधों का विश्लेषण करें

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

इस प्रकार के विश्लेषण को करने का सबसे अच्छा तरीका डेटा को प्लॉट करना है। हम फिर से Seaborn catplot फ़ंक्शन का उपयोग करेंगे, Item Size, Variety और Color के बीच संबंधों को एक श्रेणीबद्ध प्लॉट में विज़ुअलाइज़ करने के लिए। डेटा को बेहतर तरीके से प्लॉट करने के लिए हम एन्कोडेड Item Size कॉलम और अनएन्कोडेड Variety कॉलम का उपयोग करेंगे।

    palette = {
    'ORANGE': 'orange',
    'WHITE': 'wheat',
    }
    pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']

    g = sns.catplot(
        data=pumpkins,
        x="Item Size", y="Color", row='Variety',
        kind="box", orient="h",
        sharex=False, margin_titles=True,
        height=1.8, aspect=4, palette=palette,
    )
    g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
    g.set_titles(row_template="{row_name}")

स्वॉर्म प्लॉट का उपयोग करें

चूंकि Color एक बाइनरी श्रेणी है (सफेद या नहीं), इसे विज़ुअलाइज़ेशन के लिए 'एक विशेष दृष्टिकोण' की आवश्यकता है। इस श्रेणी के अन्य वेरिएबल्स के साथ संबंध को विज़ुअलाइज़ करने के अन्य तरीके भी हैं।

आप Seaborn प्लॉट्स के साथ वेरिएबल्स को साइड-बाय-साइड विज़ुअलाइज़ कर सकते हैं।

मानों के वितरण को दिखाने के लिए एक 'स्वॉर्म' प्लॉट आज़माएं:
```
palette = {
0: 'orange',
1: 'wheat'
}
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
```

ध्यान दें: ऊपर दिया गया कोड एक चेतावनी उत्पन्न कर सकता है, क्योंकि Seaborn इतने सारे डेटा पॉइंट्स को स्वॉर्म प्लॉट में दर्शाने में विफल रहता है। एक संभावित समाधान मार्कर का आकार घटाना है, 'size' पैरामीटर का उपयोग करके। हालांकि, ध्यान दें कि यह प्लॉट की पठनीयता को प्रभावित करता है।

🧮 गणित दिखाएं

लॉजिस्टिक रिग्रेशन 'मैक्सिमम लाइकलीहुड' की अवधारणा पर आधारित है, जिसमें सिग्मॉइड फंक्शन्स का उपयोग किया जाता है। एक 'सिग्मॉइड फंक्शन' प्लॉट पर 'S' आकार जैसा दिखता है। यह एक मान लेता है और इसे 0 और 1 के बीच कहीं मैप करता है। इसका कर्व 'लॉजिस्टिक कर्व' भी कहलाता है। इसका सूत्र इस प्रकार दिखता है:

जहां सिग्मॉइड का मध्य बिंदु x के 0 बिंदु पर होता है, L कर्व का अधिकतम मान है, और k कर्व की तीव्रता है। यदि फंक्शन का परिणाम 0.5 से अधिक है, तो संबंधित लेबल को बाइनरी विकल्प के '1' वर्ग में दिया जाएगा। यदि नहीं, तो इसे '0' के रूप में वर्गीकृत किया जाएगा।

अपना मॉडल बनाएं

Scikit-learn में इन बाइनरी वर्गीकरण को खोजने के लिए एक मॉडल बनाना आश्चर्यजनक रूप से सरल है।

🎥 एक लीनियर रिग्रेशन मॉडल बनाने का संक्षिप्त वीडियो अवलोकन देखने के लिए ऊपर दी गई छवि पर क्लिक करें।

उन वेरिएबल्स का चयन करें जिन्हें आप अपने वर्गीकरण मॉडल में उपयोग करना चाहते हैं और train_test_split() को कॉल करके प्रशिक्षण और परीक्षण सेट को विभाजित करें:
```
from sklearn.model_selection import train_test_split

X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
y = encoded_pumpkins['Color']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```

अब आप अपने मॉडल को प्रशिक्षण दे सकते हैं, fit() को अपने प्रशिक्षण डेटा के साथ कॉल करके, और इसके परिणाम को प्रिंट कर सकते हैं:

from sklearn.metrics import f1_score, classification_report 
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('F1-score: ', f1_score(y_test, predictions))

अपने मॉडल के स्कोरबोर्ड पर एक नज़र डालें। यह बुरा नहीं है, यह देखते हुए कि आपके पास केवल लगभग 1000 पंक्तियों का डेटा है:

                   precision    recall  f1-score   support

                0       0.94      0.98      0.96       166
                1       0.85      0.67      0.75        33

    accuracy                                0.92       199
    macro avg           0.89      0.82      0.85       199
    weighted avg        0.92      0.92      0.92       199

    Predicted labels:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
    0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
    0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
    0 0 0 1 0 0 0 0 0 0 0 0 1 1]
    F1-score:  0.7457627118644068

बेहतर समझ के लिए एक कन्फ्यूजन मैट्रिक्स

जबकि आप ऊपर दिए गए आइटम्स को प्रिंट करके शर्तों में स्कोरबोर्ड रिपोर्ट प्राप्त कर सकते हैं, आप अपने मॉडल को अधिक आसानी से समझ सकते हैं यदि आप एक कन्फ्यूजन मैट्रिक्स का उपयोग करें ताकि यह समझ सकें कि मॉडल कैसा प्रदर्शन कर रहा है।

🎓 एक 'कन्फ्यूजन मैट्रिक्स' (या 'एरर मैट्रिक्स') एक तालिका है जो आपके मॉडल के सही बनाम गलत पॉज़िटिव्स और नेगेटिव्स को व्यक्त करती है, इस प्रकार भविष्यवाणियों की सटीकता को मापती है।

कन्फ्यूजन मैट्रिक्स का उपयोग करने के लिए, confusion_matrix() को कॉल करें:
```
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predictions)
```
अपने मॉडल की कन्फ्यूजन मैट्रिक्स पर एक नज़र डालें:
```
array([[162,   4],
       [ 11,  22]])
```

Scikit-learn में, कन्फ्यूजन मैट्रिक्स की पंक्तियाँ (axis 0) वास्तविक लेबल्स हैं और कॉलम्स (axis 1) भविष्यवाणी किए गए लेबल्स हैं।

	0	1
0	TN	FP
1	FN	TP

यहाँ क्या हो रहा है? मान लें कि हमारा मॉडल कद्दू को दो बाइनरी श्रेणियों के बीच वर्गीकृत करने के लिए कहा गया है, श्रेणी 'सफेद' और श्रेणी 'सफेद नहीं'।

यदि आपका मॉडल कद्दू को सफेद नहीं के रूप में भविष्यवाणी करता है और यह वास्तव में श्रेणी 'सफेद नहीं' से संबंधित है, तो हम इसे एक सही नेगेटिव कहते हैं, जिसे ऊपर बाईं संख्या द्वारा दिखाया गया है।
यदि आपका मॉडल कद्द कन्फ्यूजन मैट्रिक्स का प्रिसिजन और रिकॉल से क्या संबंध है? याद रखें, ऊपर प्रिंट किए गए क्लासिफिकेशन रिपोर्ट ने प्रिसिजन (0.85) और रिकॉल (0.67) दिखाया था।

प्रिसिजन = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461

रिकॉल = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666

✅ प्रश्न: कन्फ्यूजन मैट्रिक्स के अनुसार, मॉडल ने कैसा प्रदर्शन किया? उत्तर: बुरा नहीं; काफी संख्या में ट्रू नेगेटिव्स हैं, लेकिन कुछ फॉल्स नेगेटिव्स भी हैं।

आइए कन्फ्यूजन मैट्रिक्स के TP/TN और FP/FN मैपिंग की मदद से पहले देखे गए टर्म्स को फिर से समझते हैं:

🎓 प्रिसिजन: TP/(TP + FP) प्राप्त किए गए उदाहरणों में से प्रासंगिक उदाहरणों का अनुपात (जैसे कौन से लेबल सही तरीके से लेबल किए गए थे)

🎓 रिकॉल: TP/(TP + FN) प्रासंगिक उदाहरणों का वह अनुपात जो प्राप्त किया गया, चाहे वह सही तरीके से लेबल किया गया हो या नहीं

🎓 f1-स्कोर: (2 * प्रिसिजन * रिकॉल)/(प्रिसिजन + रिकॉल) प्रिसिजन और रिकॉल का भारित औसत, जिसमें सर्वश्रेष्ठ 1 और सबसे खराब 0 होता है

🎓 सपोर्ट: प्रत्येक लेबल के प्राप्त होने की संख्या

🎓 एक्यूरेसी: (TP + TN)/(TP + TN + FP + FN) किसी सैंपल के लिए सही तरीके से भविष्यवाणी किए गए लेबल का प्रतिशत

🎓 मैक्रो औसत: प्रत्येक लेबल के लिए बिना वजन वाले औसत मेट्रिक्स की गणना, लेबल असंतुलन को ध्यान में न रखते हुए

🎓 वेटेड औसत: प्रत्येक लेबल के लिए औसत मेट्रिक्स की गणना, लेबल असंतुलन को ध्यान में रखते हुए और उन्हें उनके सपोर्ट (प्रत्येक लेबल के लिए सही उदाहरणों की संख्या) द्वारा वेटिंग करके

✅ क्या आप सोच सकते हैं कि कौन सा मेट्रिक देखना चाहिए यदि आप चाहते हैं कि आपका मॉडल फॉल्स नेगेटिव्स की संख्या कम करे?

इस मॉडल के ROC कर्व को विज़ुअलाइज़ करें

🎥 ऊपर दी गई छवि पर क्लिक करें ROC कर्व्स का संक्षिप्त वीडियो अवलोकन देखने के लिए

आइए एक और विज़ुअलाइज़ेशन करें ताकि तथाकथित 'ROC' कर्व को देख सकें:

from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline

y_scores = model.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])

fig = plt.figure(figsize=(6, 6))
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()

Matplotlib का उपयोग करके, मॉडल का Receiving Operating Characteristic या ROC प्लॉट करें। ROC कर्व्स अक्सर किसी क्लासिफायर के आउटपुट को उसके ट्रू बनाम फॉल्स पॉजिटिव्स के संदर्भ में देखने के लिए उपयोग किए जाते हैं। "ROC कर्व्स आमतौर पर Y अक्ष पर ट्रू पॉजिटिव रेट और X अक्ष पर फॉल्स पॉजिटिव रेट दिखाते हैं।" इसलिए, कर्व की तीव्रता और मिडपॉइंट लाइन और कर्व के बीच की जगह महत्वपूर्ण होती है: आप एक ऐसा कर्व चाहते हैं जो जल्दी ऊपर और लाइन के ऊपर जाए। हमारे मामले में, शुरुआत में कुछ फॉल्स पॉजिटिव्स हैं, और फिर लाइन सही तरीके से ऊपर और आगे बढ़ती है:

अंत में, Scikit-learn के roc_auc_score API का उपयोग करके वास्तविक 'Area Under the Curve' (AUC) की गणना करें:

auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)

परिणाम है 0.9749908725812341। चूंकि AUC 0 से 1 तक होता है, आप एक बड़ा स्कोर चाहते हैं, क्योंकि एक मॉडल जो अपनी भविष्यवाणियों में 100% सही है उसका AUC 1 होगा; इस मामले में, मॉडल काफी अच्छा है।

भविष्य के क्लासिफिकेशन पाठों में, आप अपने मॉडल के स्कोर को सुधारने के लिए पुनरावृत्ति करना सीखेंगे। लेकिन अभी के लिए, बधाई हो! आपने ये रिग्रेशन पाठ पूरे कर लिए हैं!

🚀चुनौती

लॉजिस्टिक रिग्रेशन के बारे में और भी बहुत कुछ जानने को है! लेकिन सीखने का सबसे अच्छा तरीका है प्रयोग करना। ऐसा डेटासेट खोजें जो इस प्रकार के विश्लेषण के लिए उपयुक्त हो और इसके साथ एक मॉडल बनाएं। आपने क्या सीखा? सुझाव: Kaggle पर दिलचस्प डेटासेट्स आज़माएं।

पोस्ट-लेक्चर क्विज़

समीक्षा और स्व-अध्ययन

स्टैनफोर्ड के इस पेपर के पहले कुछ पृष्ठ पढ़ें, जिसमें लॉजिस्टिक रिग्रेशन के कुछ व्यावहारिक उपयोग बताए गए हैं। उन कार्यों के बारे में सोचें जो अब तक हमने अध्ययन किए गए रिग्रेशन प्रकारों में से किसी एक के लिए बेहतर उपयुक्त हैं। कौन सा सबसे अच्छा काम करेगा?

असाइनमेंट

इस रिग्रेशन को फिर से आज़माएं

अस्वीकरण:
यह दस्तावेज़ AI अनुवाद सेवा Co-op Translator का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता के लिए प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को आधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं।

42 KiB Raw Permalink Blame History