You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
313 lines
26 KiB
313 lines
26 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "aaf391d922bd6de5efba871d514c6d47",
|
|
"translation_date": "2025-09-05T10:28:19+00:00",
|
|
"source_file": "4-Classification/1-Introduction/README.md",
|
|
"language_code": "hi"
|
|
}
|
|
-->
|
|
# वर्गीकरण का परिचय
|
|
|
|
इन चार पाठों में, आप क्लासिक मशीन लर्निंग के एक महत्वपूर्ण पहलू - _वर्गीकरण_ - का अन्वेषण करेंगे। हम एशिया और भारत के सभी अद्भुत व्यंजनों के बारे में एक डेटासेट का उपयोग करके विभिन्न वर्गीकरण एल्गोरिदम का उपयोग करना सीखेंगे। उम्मीद है कि आप भूखे हैं!
|
|
|
|
|
|
|
|
> इन पाठों में पैन-एशियाई व्यंजनों का जश्न मनाएं! छवि [Jen Looper](https://twitter.com/jenlooper) द्वारा
|
|
|
|
वर्गीकरण [सुपरवाइज्ड लर्निंग](https://wikipedia.org/wiki/Supervised_learning) का एक रूप है, जो रिग्रेशन तकनीकों के साथ बहुत समानता रखता है। यदि मशीन लर्निंग का उद्देश्य डेटासेट का उपयोग करके चीजों के मान या नाम की भविष्यवाणी करना है, तो वर्गीकरण आम तौर पर दो समूहों में विभाजित होता है: _बाइनरी वर्गीकरण_ और _मल्टीक्लास वर्गीकरण_।
|
|
|
|
[](https://youtu.be/eg8DJYwdMyg "वर्गीकरण का परिचय")
|
|
|
|
> 🎥 ऊपर दी गई छवि पर क्लिक करें: MIT के John Guttag वर्गीकरण का परिचय देते हैं
|
|
|
|
याद रखें:
|
|
|
|
- **लिनियर रिग्रेशन** ने आपको वेरिएबल्स के बीच संबंधों की भविष्यवाणी करने और यह अनुमान लगाने में मदद की कि एक नया डेटा पॉइंट उस रेखा के संबंध में कहां गिरेगा। उदाहरण के लिए, आप भविष्यवाणी कर सकते हैं कि _सितंबर बनाम दिसंबर में कद्दू की कीमत क्या होगी_।
|
|
- **लॉजिस्टिक रिग्रेशन** ने आपको "बाइनरी श्रेणियों" की खोज करने में मदद की: इस मूल्य बिंदु पर, _क्या यह कद्दू नारंगी है या नारंगी नहीं है_?
|
|
|
|
वर्गीकरण विभिन्न एल्गोरिदम का उपयोग करके यह निर्धारित करता है कि किसी डेटा पॉइंट का लेबल या वर्ग क्या हो सकता है। आइए इस व्यंजन डेटा के साथ काम करें और देखें कि क्या हम सामग्री के एक समूह को देखकर उसके मूल व्यंजन का निर्धारण कर सकते हैं।
|
|
|
|
## [पाठ-पूर्व क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
> ### [यह पाठ R में भी उपलब्ध है!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
|
|
|
|
### परिचय
|
|
|
|
वर्गीकरण मशीन लर्निंग शोधकर्ता और डेटा वैज्ञानिक की मूलभूत गतिविधियों में से एक है। बाइनरी मान ("क्या यह ईमेल स्पैम है या नहीं?") के सरल वर्गीकरण से लेकर, कंप्यूटर विज़न का उपयोग करके जटिल छवि वर्गीकरण और खंडन तक, डेटा को वर्गों में छांटना और उससे प्रश्न पूछना हमेशा उपयोगी होता है।
|
|
|
|
वैज्ञानिक दृष्टिकोण से कहें तो, आपका वर्गीकरण तरीका एक प्रेडिक्टिव मॉडल बनाता है जो इनपुट वेरिएबल्स और आउटपुट वेरिएबल्स के बीच संबंध को मैप करने में सक्षम बनाता है।
|
|
|
|
|
|
|
|
> बाइनरी बनाम मल्टीक्लास समस्याएं जिन्हें वर्गीकरण एल्गोरिदम संभाल सकते हैं। इन्फोग्राफिक [Jen Looper](https://twitter.com/jenlooper) द्वारा
|
|
|
|
हमारे डेटा को साफ करने, उसका विज़ुअलाइज़ेशन करने और हमारे एमएल कार्यों के लिए तैयार करने की प्रक्रिया शुरू करने से पहले, आइए जानें कि मशीन लर्निंग का उपयोग करके डेटा को वर्गीकृत करने के विभिन्न तरीके क्या हैं।
|
|
|
|
[सांख्यिकी](https://wikipedia.org/wiki/Statistical_classification) से व्युत्पन्न, क्लासिक मशीन लर्निंग का उपयोग करके वर्गीकरण विशेषताओं का उपयोग करता है, जैसे `smoker`, `weight`, और `age`, यह निर्धारित करने के लिए कि _किसी बीमारी के विकसित होने की संभावना कितनी है_। एक सुपरवाइज्ड लर्निंग तकनीक के रूप में, जो आपने पहले रिग्रेशन अभ्यासों में की थी, आपका डेटा लेबल किया गया होता है और एमएल एल्गोरिदम उन लेबल्स का उपयोग डेटा सेट की कक्षाओं (या 'विशेषताओं') को वर्गीकृत और भविष्यवाणी करने और उन्हें एक समूह या परिणाम में असाइन करने के लिए करते हैं।
|
|
|
|
✅ एक पल लें और व्यंजनों के बारे में एक डेटासेट की कल्पना करें। एक मल्टीक्लास मॉडल क्या उत्तर दे सकता है? एक बाइनरी मॉडल क्या उत्तर दे सकता है? यदि आप यह निर्धारित करना चाहते हैं कि कोई विशेष व्यंजन मेथी का उपयोग करता है या नहीं, तो क्या होगा? यदि आपके पास स्टार ऐनीज़, आर्टिचोक, फूलगोभी, और हॉर्सरैडिश से भरा एक ग्रॉसरी बैग है, तो क्या आप एक विशिष्ट भारतीय व्यंजन बना सकते हैं?
|
|
|
|
[](https://youtu.be/GuTeDbaNoEU "पागल मिस्ट्री बास्केट्स")
|
|
|
|
> 🎥 ऊपर दी गई छवि पर क्लिक करें। शो 'Chopped' का पूरा आधार 'मिस्ट्री बास्केट' है, जहां शेफ को यादृच्छिक सामग्री से कुछ व्यंजन बनाना होता है। निश्चित रूप से एक एमएल मॉडल ने मदद की होगी!
|
|
|
|
## हैलो 'क्लासिफायर'
|
|
|
|
हम इस व्यंजन डेटासेट से जो प्रश्न पूछना चाहते हैं, वह वास्तव में एक **मल्टीक्लास प्रश्न** है, क्योंकि हमारे पास काम करने के लिए कई संभावित राष्ट्रीय व्यंजन हैं। सामग्री के एक बैच को देखते हुए, इन कई वर्गों में से डेटा किस वर्ग में फिट होगा?
|
|
|
|
Scikit-learn विभिन्न प्रकार की समस्याओं को हल करने के लिए डेटा को वर्गीकृत करने के लिए कई अलग-अलग एल्गोरिदम प्रदान करता है। अगले दो पाठों में, आप इन एल्गोरिदम के बारे में जानेंगे।
|
|
|
|
## अभ्यास - अपने डेटा को साफ और संतुलित करें
|
|
|
|
इस प्रोजेक्ट को शुरू करने से पहले पहला कार्य यह है कि आप अपने डेटा को साफ और **संतुलित** करें ताकि बेहतर परिणाम प्राप्त हो सकें। इस फ़ोल्डर की रूट में _notebook.ipynb_ फ़ाइल से शुरुआत करें।
|
|
|
|
पहली चीज़ जो आपको इंस्टॉल करनी है वह है [imblearn](https://imbalanced-learn.org/stable/)। यह एक Scikit-learn पैकेज है जो आपको डेटा को बेहतर संतुलित करने की अनुमति देगा (आप इस कार्य के बारे में थोड़ी देर में और जानेंगे)।
|
|
|
|
1. `imblearn` को इंस्टॉल करने के लिए, `pip install` चलाएं, इस प्रकार:
|
|
|
|
```python
|
|
pip install imblearn
|
|
```
|
|
|
|
1. अपने डेटा को आयात करने और विज़ुअलाइज़ करने के लिए आवश्यक पैकेज आयात करें, साथ ही `imblearn` से `SMOTE` भी आयात करें।
|
|
|
|
```python
|
|
import pandas as pd
|
|
import matplotlib.pyplot as plt
|
|
import matplotlib as mpl
|
|
import numpy as np
|
|
from imblearn.over_sampling import SMOTE
|
|
```
|
|
|
|
अब आप डेटा को आयात करने के लिए तैयार हैं।
|
|
|
|
1. अगला कार्य डेटा को आयात करना होगा:
|
|
|
|
```python
|
|
df = pd.read_csv('../data/cuisines.csv')
|
|
```
|
|
|
|
`read_csv()` का उपयोग करके, _cusines.csv_ फ़ाइल की सामग्री को पढ़ा जाएगा और इसे वेरिएबल `df` में रखा जाएगा।
|
|
|
|
1. डेटा का आकार जांचें:
|
|
|
|
```python
|
|
df.head()
|
|
```
|
|
|
|
पहले पांच पंक्तियाँ इस प्रकार दिखती हैं:
|
|
|
|
```output
|
|
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
|
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
|
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
|
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
|
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
|
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
|
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
|
```
|
|
|
|
1. इस डेटा के बारे में जानकारी प्राप्त करें `info()` को कॉल करके:
|
|
|
|
```python
|
|
df.info()
|
|
```
|
|
|
|
आपका आउटपुट इस प्रकार दिखता है:
|
|
|
|
```output
|
|
<class 'pandas.core.frame.DataFrame'>
|
|
RangeIndex: 2448 entries, 0 to 2447
|
|
Columns: 385 entries, Unnamed: 0 to zucchini
|
|
dtypes: int64(384), object(1)
|
|
memory usage: 7.2+ MB
|
|
```
|
|
|
|
## अभ्यास - व्यंजनों के बारे में जानना
|
|
|
|
अब काम अधिक दिलचस्प होने लगता है। आइए व्यंजन के अनुसार डेटा के वितरण की खोज करें।
|
|
|
|
1. डेटा को बार के रूप में प्लॉट करें `barh()` को कॉल करके:
|
|
|
|
```python
|
|
df.cuisine.value_counts().plot.barh()
|
|
```
|
|
|
|
|
|
|
|
व्यंजनों की संख्या सीमित है, लेकिन डेटा का वितरण असमान है। आप इसे ठीक कर सकते हैं! ऐसा करने से पहले, थोड़ा और अन्वेषण करें।
|
|
|
|
1. पता करें कि प्रत्येक व्यंजन के लिए कितना डेटा उपलब्ध है और इसे प्रिंट करें:
|
|
|
|
```python
|
|
thai_df = df[(df.cuisine == "thai")]
|
|
japanese_df = df[(df.cuisine == "japanese")]
|
|
chinese_df = df[(df.cuisine == "chinese")]
|
|
indian_df = df[(df.cuisine == "indian")]
|
|
korean_df = df[(df.cuisine == "korean")]
|
|
|
|
print(f'thai df: {thai_df.shape}')
|
|
print(f'japanese df: {japanese_df.shape}')
|
|
print(f'chinese df: {chinese_df.shape}')
|
|
print(f'indian df: {indian_df.shape}')
|
|
print(f'korean df: {korean_df.shape}')
|
|
```
|
|
|
|
आउटपुट इस प्रकार दिखता है:
|
|
|
|
```output
|
|
thai df: (289, 385)
|
|
japanese df: (320, 385)
|
|
chinese df: (442, 385)
|
|
indian df: (598, 385)
|
|
korean df: (799, 385)
|
|
```
|
|
|
|
## सामग्री की खोज
|
|
|
|
अब आप डेटा में गहराई से जा सकते हैं और जान सकते हैं कि प्रत्येक व्यंजन के लिए विशिष्ट सामग्री क्या हैं। आपको बार-बार आने वाले डेटा को साफ करना चाहिए जो व्यंजनों के बीच भ्रम पैदा करता है, तो आइए इस समस्या के बारे में जानें।
|
|
|
|
1. एक फ़ंक्शन `create_ingredient()` Python में बनाएं, जो एक सामग्री डेटा फ्रेम बनाए। यह फ़ंक्शन एक अनुपयोगी कॉलम को हटाकर और सामग्री को उनकी गिनती के अनुसार छांटकर शुरू करेगा:
|
|
|
|
```python
|
|
def create_ingredient_df(df):
|
|
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
|
|
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
|
|
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
|
|
inplace=False)
|
|
return ingredient_df
|
|
```
|
|
|
|
अब आप इस फ़ंक्शन का उपयोग करके प्रत्येक व्यंजन के लिए शीर्ष दस सबसे लोकप्रिय सामग्री का अंदाजा लगा सकते हैं।
|
|
|
|
1. `create_ingredient()` को कॉल करें और इसे `barh()` को कॉल करके प्लॉट करें:
|
|
|
|
```python
|
|
thai_ingredient_df = create_ingredient_df(thai_df)
|
|
thai_ingredient_df.head(10).plot.barh()
|
|
```
|
|
|
|
|
|
|
|
1. जापानी डेटा के लिए भी ऐसा ही करें:
|
|
|
|
```python
|
|
japanese_ingredient_df = create_ingredient_df(japanese_df)
|
|
japanese_ingredient_df.head(10).plot.barh()
|
|
```
|
|
|
|
|
|
|
|
1. अब चीनी सामग्री के लिए:
|
|
|
|
```python
|
|
chinese_ingredient_df = create_ingredient_df(chinese_df)
|
|
chinese_ingredient_df.head(10).plot.barh()
|
|
```
|
|
|
|
|
|
|
|
1. भारतीय सामग्री को प्लॉट करें:
|
|
|
|
```python
|
|
indian_ingredient_df = create_ingredient_df(indian_df)
|
|
indian_ingredient_df.head(10).plot.barh()
|
|
```
|
|
|
|
|
|
|
|
1. अंत में, कोरियाई सामग्री को प्लॉट करें:
|
|
|
|
```python
|
|
korean_ingredient_df = create_ingredient_df(korean_df)
|
|
korean_ingredient_df.head(10).plot.barh()
|
|
```
|
|
|
|
|
|
|
|
1. अब, सबसे सामान्य सामग्री को हटा दें जो विभिन्न व्यंजनों के बीच भ्रम पैदा करती हैं, `drop()` को कॉल करके:
|
|
|
|
हर कोई चावल, लहसुन और अदरक पसंद करता है!
|
|
|
|
```python
|
|
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
|
|
labels_df = df.cuisine #.unique()
|
|
feature_df.head()
|
|
```
|
|
|
|
## डेटासेट को संतुलित करें
|
|
|
|
अब जब आपने डेटा को साफ कर लिया है, तो [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "सिंथेटिक माइनॉरिटी ओवर-सैंपलिंग टेक्नीक" - का उपयोग करके इसे संतुलित करें।
|
|
|
|
1. `fit_resample()` को कॉल करें, यह रणनीति इंटरपोलेशन द्वारा नए सैंपल उत्पन्न करती है।
|
|
|
|
```python
|
|
oversample = SMOTE()
|
|
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
|
|
```
|
|
|
|
अपने डेटा को संतुलित करके, आपके पास इसे वर्गीकृत करते समय बेहतर परिणाम होंगे। एक बाइनरी वर्गीकरण के बारे में सोचें। यदि आपके अधिकांश डेटा एक वर्ग के हैं, तो एक एमएल मॉडल उस वर्ग की अधिक बार भविष्यवाणी करेगा, केवल इसलिए कि उसके लिए अधिक डेटा है। डेटा को संतुलित करना किसी भी असंतुलित डेटा को लेता है और इस असंतुलन को दूर करने में मदद करता है।
|
|
|
|
1. अब आप सामग्री के प्रति लेबल की संख्या की जांच कर सकते हैं:
|
|
|
|
```python
|
|
print(f'new label count: {transformed_label_df.value_counts()}')
|
|
print(f'old label count: {df.cuisine.value_counts()}')
|
|
```
|
|
|
|
आपका आउटपुट इस प्रकार दिखता है:
|
|
|
|
```output
|
|
new label count: korean 799
|
|
chinese 799
|
|
indian 799
|
|
japanese 799
|
|
thai 799
|
|
Name: cuisine, dtype: int64
|
|
old label count: korean 799
|
|
indian 598
|
|
chinese 442
|
|
japanese 320
|
|
thai 289
|
|
Name: cuisine, dtype: int64
|
|
```
|
|
|
|
डेटा साफ, संतुलित और बहुत स्वादिष्ट है!
|
|
|
|
1. अंतिम चरण यह है कि आपके संतुलित डेटा, जिसमें लेबल और विशेषताएं शामिल हैं, को एक नए डेटा फ्रेम में सहेजें जिसे एक फ़ाइल में निर्यात किया जा सके:
|
|
|
|
```python
|
|
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
|
|
```
|
|
|
|
1. आप `transformed_df.head()` और `transformed_df.info()` का उपयोग करके डेटा पर एक और नज़र डाल सकते हैं। भविष्य के पाठों में उपयोग के लिए इस डेटा की एक प्रति सहेजें:
|
|
|
|
```python
|
|
transformed_df.head()
|
|
transformed_df.info()
|
|
transformed_df.to_csv("../data/cleaned_cuisines.csv")
|
|
```
|
|
|
|
यह ताजा CSV अब रूट डेटा फ़ोल्डर में पाया जा सकता है।
|
|
|
|
---
|
|
|
|
## 🚀चुनौती
|
|
|
|
इस पाठ्यक्रम में कई दिलचस्प डेटासेट शामिल हैं। `data` फ़ोल्डर्स को खंगालें और देखें कि क्या उनमें से कोई ऐसा डेटासेट है जो बाइनरी या मल्टी-क्लास वर्गीकरण के लिए उपयुक्त हो? आप इस डेटासेट से कौन से प्रश्न पूछेंगे?
|
|
|
|
## [पाठ-उत्तर क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## समीक्षा और स्व-अध्ययन
|
|
|
|
SMOTE के API का अन्वेषण करें। यह किन उपयोग मामलों के लिए सबसे अच्छा उपयोग किया जाता है? यह किन समस्याओं को हल करता है?
|
|
|
|
## असाइनमेंट
|
|
|
|
[वर्गीकरण विधियों का अन्वेषण करें](assignment.md)
|
|
|
|
---
|
|
|
|
**अस्वीकरण**:
|
|
यह दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता के लिए प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को आधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं। |