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": "aaf391d922bd6de5efba871d514c6d47",
|
|
"translation_date": "2025-09-06T06:37:58+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://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
> ### [यो पाठ R मा उपलब्ध छ!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
|
|
|
|
### परिचय
|
|
|
|
वर्गीकरण मेसिन लर्निङ अनुसन्धानकर्ता र डेटा वैज्ञानिकको आधारभूत गतिविधिहरूमध्ये एक हो। बाइनरी मानको आधारभूत वर्गीकरण ("यो इमेल स्प्याम हो वा होइन?") देखि लिएर कम्प्युटर भिजन प्रयोग गरेर जटिल छवि वर्गीकरण र खण्डीकरणसम्म, डेटा वर्गमा क्रमबद्ध गर्न र यसबाट प्रश्न सोध्न सक्षम हुनु सधैं उपयोगी हुन्छ।
|
|
|
|
वैज्ञानिक तरिकामा प्रक्रिया बताउन, तपाईंको वर्गीकरण विधिले एक भविष्यवाणी मोडेल सिर्जना गर्दछ जसले इनपुट भेरिएबलहरू र आउटपुट भेरिएबलहरू बीचको सम्बन्ध म्याप गर्न सक्षम बनाउँछ।
|
|
|
|
|
|
|
|
> वर्गीकरण एल्गोरिदमहरूले सामना गर्नुपर्ने बाइनरी बनाम मल्टिक्लास समस्याहरू। [Jen Looper](https://twitter.com/jenlooper) द्वारा इन्फोग्राफिक
|
|
|
|
हाम्रो डेटा सफा गर्ने, दृश्यात्मक बनाउने, र हाम्रो ML कार्यहरूको लागि तयार गर्ने प्रक्रिया सुरु गर्नु अघि, आउनुहोस् मेसिन लर्निङले डेटा वर्गीकरण गर्न प्रयोग गर्न सक्ने विभिन्न तरिकाहरूको बारेमा थोरै सिकौं।
|
|
|
|
[स्ट्याटिस्टिक्स](https://wikipedia.org/wiki/Statistical_classification) बाट व्युत्पन्न, क्लासिक मेसिन लर्निङ प्रयोग गरेर वर्गीकरणले `smoker`, `weight`, र `age` जस्ता विशेषताहरू प्रयोग गर्दछ _X रोग विकासको सम्भावना_ निर्धारण गर्न। तपाईंले पहिले प्रदर्शन गरेको रिग्रेसन अभ्यासहरू जस्तै सुपरभाइज्ड लर्निङ प्रविधिको रूपमा, तपाईंको डेटा लेबल गरिएको छ र ML एल्गोरिदमहरूले ती लेबलहरू प्रयोग गरेर डेटासेटको वर्गहरू (वा 'विशेषताहरू') वर्गीकृत र भविष्यवाणी गर्दछ र तिनीहरूलाई समूह वा परिणाममा असाइन गर्दछ।
|
|
|
|
✅ परिकारको बारेमा डेटासेट कल्पना गर्न एक क्षण लिनुहोस्। मल्टिक्लास मोडेलले के उत्तर दिन सक्थ्यो? बाइनरी मोडेलले के उत्तर दिन सक्थ्यो? यदि तपाईंले पत्ता लगाउन चाहनुभयो कि कुनै परिकारले मेथी प्रयोग गर्ने सम्भावना छ कि छैन भने के हुन्छ? यदि तपाईंले तारा सौंफ, आर्टिचोक, फूलगोभी, र हर्सराडिशले भरिएको किराना झोला उपहार पाएर, तपाईंले सामान्य भारतीय परिकार बनाउन सक्नुहुन्छ भने के हुन्छ?
|
|
|
|
[](https://youtu.be/GuTeDbaNoEU "पागल रहस्यमय बास्केटहरू")
|
|
|
|
> 🎥 माथिको छविमा क्लिक गर्नुहोस्। 'Chopped' शोको सम्पूर्ण आधार 'रहस्यमय बास्केट' हो जहाँ शेफहरूले सामग्रीहरूको अनियमित छनोटबाट केही परिकार बनाउनुपर्छ। निश्चय नै ML मोडेलले मद्दत गर्थ्यो!
|
|
|
|
## हेलो 'क्लासिफायर'
|
|
|
|
हामीले यो परिकार डेटासेटबाट सोध्न चाहेको प्रश्न वास्तवमा **मल्टिक्लास प्रश्न** हो, किनकि हामीसँग काम गर्न धेरै सम्भावित राष्ट्रिय परिकारहरू छन्। सामग्रीहरूको एक ब्याच दिइएको छ, यी धेरै वर्गहरू मध्ये कुनमा डेटा फिट हुनेछ?
|
|
|
|
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)
|
|
```
|
|
|
|
तपाईंको डेटा सन्तुलित गरेर, तपाईंले यसलाई वर्गीकृत गर्दा राम्रो परिणाम प्राप्त गर्नुहुनेछ। बाइनरी वर्गीकरणको बारेमा सोच्नुहोस्। यदि तपाईंको अधिकांश डेटा एक वर्ग हो भने, ML मोडेलले उक्त वर्गलाई बढी बारम्बार भविष्यवाणी गर्नेछ, केवल त्यहाँ यसको लागि बढी डेटा भएको कारण। डेटा सन्तुलित गर्दा कुनै पनि असमान डेटा लिन्छ र यस असन्तुलनलाई हटाउन मद्दत गर्दछ।
|
|
|
|
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) प्रयोग गरेर अनुवाद गरिएको छ। हामी यथार्थताको लागि प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादहरूमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छ। यसको मूल भाषा मा रहेको मूल दस्तावेज़लाई आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीको लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याको लागि हामी जिम्मेवार हुने छैनौं। |