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
27 KiB
313 lines
27 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "76438ce4e5d48982d48f1b55c981caac",
|
|
"translation_date": "2025-08-29T17:57:44+00:00",
|
|
"source_file": "4-Classification/1-Introduction/README.md",
|
|
"language_code": "ne"
|
|
}
|
|
-->
|
|
# वर्गीकरणको परिचय
|
|
|
|
यी चार पाठहरूमा, तपाईं क्लासिक मेसिन लर्निङको एक आधारभूत ध्यान केन्द्रित गर्नेछौं - _वर्गीकरण_। हामी एशिया र भारतका सबै उत्कृष्ट परिकारहरूको डाटासेट प्रयोग गरेर विभिन्न वर्गीकरण एल्गोरिदमहरूको प्रयोग गर्नेछौं। आशा छ तपाईं भोकै हुनुहुन्छ!
|
|
|
|
|
|
|
|
> यी पाठहरूमा प्यान-एशियाली परिकारहरूको उत्सव मनाउनुहोस्! छवि [Jen Looper](https://twitter.com/jenlooper) द्वारा
|
|
|
|
वर्गीकरण [सुपरभाइज्ड लर्निङ](https://wikipedia.org/wiki/Supervised_learning) को एक प्रकार हो जसले रिग्रेसन प्रविधिहरूसँग धेरै समानता राख्छ। यदि मेसिन लर्निङ डाटासेटहरू प्रयोग गरेर मूल्यहरू वा वस्तुहरूको नामको भविष्यवाणी गर्ने बारेमा हो भने, वर्गीकरण सामान्यतया दुई समूहमा विभाजित हुन्छ: _बाइनरी वर्गीकरण_ र _मल्टिक्लास वर्गीकरण_।
|
|
|
|
[](https://youtu.be/eg8DJYwdMyg "वर्गीकरणको परिचय")
|
|
|
|
> 🎥 माथिको छविमा क्लिक गर्नुहोस्: MIT का John Guttag ले वर्गीकरणको परिचय दिनुहुन्छ
|
|
|
|
स्मरण गर्नुहोस्:
|
|
|
|
- **लिनियर रिग्रेसन** ले तपाईंलाई भेरिएबलहरू बीचको सम्बन्धको भविष्यवाणी गर्न र नयाँ डाटाप्वाइन्ट उक्त रेखासँग सम्बन्धित कहाँ पर्नेछ भनेर सटीक भविष्यवाणी गर्न मद्दत गर्यो। उदाहरणका लागि, तपाईं _सेप्टेम्बर बनाम डिसेम्बरमा कद्दूको मूल्य कति हुनेछ_ भविष्यवाणी गर्न सक्नुहुन्छ।
|
|
- **लजिस्टिक रिग्रेसन** ले तपाईंलाई "बाइनरी श्रेणीहरू" पत्ता लगाउन मद्दत गर्यो: यो मूल्य बिन्दुमा, _यो कद्दू सुन्तला हो वा गैर-सुन्तला_?
|
|
|
|
वर्गीकरणले विभिन्न एल्गोरिदमहरू प्रयोग गरेर डाटाप्वाइन्टको लेबल वा वर्ग निर्धारण गर्ने अन्य तरिकाहरू पत्ता लगाउँछ। आउनुहोस्, हामी यो परिकार डाटासँग काम गरौं र हेर्नुहोस् कि सामग्रीहरूको समूहलाई अवलोकन गरेर, हामी यसको उत्पत्तिको परिकार पत्ता लगाउन सक्छौं कि सक्दैनौं।
|
|
|
|
## [पाठ अघि क्विज](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/19/)
|
|
|
|
> ### [यो पाठ 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` जस्ता विशेषताहरू प्रयोग गर्दछ _X रोग विकासको सम्भावना_ निर्धारण गर्न। तपाईंले पहिले प्रदर्शन गरेको रिग्रेसन अभ्यासहरू जस्तै सुपरभाइज्ड लर्निङ प्रविधिको रूपमा, तपाईंको डाटा लेबल गरिएको छ र एमएल एल्गोरिदमहरूले ती लेबलहरू प्रयोग गरेर डाटासेटको वर्गहरू (वा 'विशेषताहरू') वर्गीकृत र भविष्यवाणी गर्दछ र तिनीहरूलाई समूह वा परिणाममा असाइन गर्दछ।
|
|
|
|
✅ परिकारहरूको बारेमा डाटासेट कल्पना गर्न एक क्षण लिनुहोस्। मल्टिक्लास मोडेलले के उत्तर दिन सक्छ? बाइनरी मोडेलले के उत्तर दिन सक्छ? यदि तपाईंले पत्ता लगाउन चाहनुहुन्छ कि कुनै परिकारले मेथी प्रयोग गर्ने सम्भावना छ कि छैन भने के हुन्छ? यदि तपाईंले तारा सौंफ, आर्टिचोक, फूलगोभी, र हर्सराडिशले भरिएको किराना झोला उपहार पाएर, तपाईंले एक सामान्य भारतीय परिकार बनाउन सक्नुहुन्छ भने के हुन्छ?
|
|
|
|
[](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. Python मा `create_ingredient()` नामक एक फङ्क्सन सिर्जना गर्नुहोस् जसले सामग्रीको डाटाफ्रेम सिर्जना गर्दछ। यो फङ्क्सनले एक अनुपयोगी स्तम्भ हटाएर सुरु गर्नेछ र सामग्रीहरूलाई तिनीहरूको गणनाको आधारमा क्रमबद्ध गर्नेछ:
|
|
|
|
```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) - "Synthetic Minority Over-sampling Technique" - प्रयोग गरेर यसलाई सन्तुलित गर्नुहोस्।
|
|
|
|
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://gray-sand-07a10f403.1.azurestaticapps.net/quiz/20/)
|
|
|
|
## समीक्षा र आत्म अध्ययन
|
|
|
|
SMOTE को API अन्वेषण गर्नुहोस्। यो कुन उपयोग केसहरूको लागि सबैभन्दा राम्रो प्रयोग गरिन्छ? यसले कुन समस्याहरू समाधान गर्दछ?
|
|
|
|
## असाइनमेन्ट
|
|
|
|
[वर्गीकरण विधिहरू अन्वेषण गर्नुहोस्](assignment.md)
|
|
|
|
---
|
|
|
|
**अस्वीकरण**:
|
|
यो दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) प्रयोग गरी अनुवाद गरिएको हो। हामी यथासम्भव सटीकता सुनिश्चित गर्न प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादहरूमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छन्। यसको मूल भाषामा रहेको मूल दस्तावेज़लाई आधिकारिक स्रोत मानिनुपर्छ। महत्त्वपूर्ण जानकारीका लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याका लागि हामी जिम्मेवार हुने छैनौं। |