ML-For-Beginners/translations/te/4-Classification/1-Introduction

వర్గీకరణకు పరిచయం

ఈ నాలుగు పాఠాలలో, మీరు క్లాసిక్ మెషీన్ లెర్నింగ్ యొక్క ఒక ప్రాథమిక దృష్టి - వర్గీకరణ ను అన్వేషించబోతున్నారు. ఆసియా మరియు భారతదేశంలోని అన్ని అద్భుతమైన వంటకాల గురించి డేటాసెట్‌తో వివిధ వర్గీకరణ అల్గోరిథమ్స్ ఉపయోగించడం ద్వారా మనం నడవబోతున్నాము. మీరు ఆకలిగా ఉన్నారని ఆశిస్తున్నాము!

ఈ పాఠాలలో పాన్-ఆసియన్ వంటకాలను జరుపుకోండి! చిత్రం జెన్ లూపర్ ద్వారా

వర్గీకరణ అనేది సూపర్వైజ్డ్ లెర్నింగ్ యొక్క ఒక రూపం, ఇది రిగ్రెషన్ సాంకేతికతలతో చాలా సామాన్యమైనది. మెషీన్ లెర్నింగ్ డేటాసెట్లను ఉపయోగించి విలువలు లేదా పేర్లను అంచనా వేయడమే అయితే, వర్గీకరణ సాధారణంగా రెండు గుంపులుగా విభజించబడుతుంది: బైనరీ వర్గీకరణ మరియు బహుళ వర్గీకరణ.

🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: MIT యొక్క జాన్ గుట్‌టాగ్ వర్గీకరణను పరిచయం చేస్తారు

గమనించండి:

• లీనియర్ రిగ్రెషన్ మీరు వేరియబుల్స్ మధ్య సంబంధాలను అంచనా వేయడంలో మరియు కొత్త డేటాపాయింట్ ఆ లైన్‌కు సంబంధించి ఎక్కడ పడుతుందో ఖచ్చితంగా అంచనా వేయడంలో సహాయపడింది. ఉదాహరణకు, మీరు సెప్టెంబర్ మరియు డిసెంబర్‌లో పంప్కిన్ ధర ఎంత ఉంటుందో అంచనా వేయవచ్చు.
• లాజిస్టిక్ రిగ్రెషన్ "బైనరీ వర్గాలు" కనుగొనడంలో సహాయపడింది: ఈ ధర వద్ద, ఈ పంప్కిన్ నారింజ రంగులో ఉందా లేదా కాదు?

వర్గీకరణ వివిధ అల్గోరిథమ్స్ ఉపయోగించి డేటాపాయింట్ యొక్క లేబుల్ లేదా తరగతిని నిర్ణయించడానికి ఇతర మార్గాలను కనుగొంటుంది. మనం ఈ వంటకాల డేటాతో పని చేసి, ఒక సమూహం పదార్థాలను పరిశీలించి, దాని వంటక మూలాన్ని నిర్ణయించగలమా అని చూద్దాం.

పాఠం ముందు క్విజ్

ఈ పాఠం R లో అందుబాటులో ఉంది!

పరిచయం

వర్గీకరణ మెషీన్ లెర్నింగ్ పరిశోధకుడు మరియు డేటా శాస్త్రవేత్త యొక్క ప్రాథమిక కార్యకలాపాలలో ఒకటి. ఒక బైనరీ విలువ ("ఈ ఇమెయిల్ స్పామ్ కాదా?") యొక్క ప్రాథమిక వర్గీకరణ నుండి, కంప్యూటర్ విజన్ ఉపయోగించి సంక్లిష్ట చిత్రం వర్గీకరణ మరియు విభజన వరకు, డేటాను తరగతులుగా వర్గీకరించి దానిపై ప్రశ్నలు అడగడం ఎప్పుడూ ఉపయోగకరం.

ప్రక్రియను మరింత శాస్త్రీయంగా చెప్పాలంటే, మీ వర్గీకరణ పద్ధతి ఇన్‌పుట్ వేరియబుల్స్ మరియు అవుట్‌పుట్ వేరియబుల్స్ మధ్య సంబంధాన్ని మ్యాప్ చేయగల ఒక అంచనా మోడల్‌ను సృష్టిస్తుంది.

వర్గీకరణ అల్గోరిథమ్స్ నిర్వహించాల్సిన బైనరీ మరియు బహుళ వర్గ సమస్యలు. ఇన్ఫోగ్రాఫిక్ జెన్ లూపర్ ద్వారా

మన డేటాను శుభ్రపరచడం, దాన్ని విజువలైజ్ చేయడం మరియు ML పనుల కోసం సిద్ధం చేయడం ప్రారంభించే ముందు, మెషీన్ లెర్నింగ్ డేటాను వర్గీకరించడానికి ఉపయోగించగల వివిధ మార్గాల గురించి కొంత తెలుసుకుందాం.

సంఖ్యాశాస్త్రం నుండి ఉద్భవించిన వర్గీకరణ క్లాసిక్ మెషీన్ లెర్నింగ్ ఉపయోగించి smoker, weight, మరియు age వంటి లక్షణాలను ఉపయోగించి X వ్యాధి అభివృద్ధి చెందే అవకాశాన్ని నిర్ణయిస్తుంది. మీరు ముందుగా చేసిన రిగ్రెషన్ వ్యాయామాల్లా, ఇది సూపర్వైజ్డ్ లెర్నింగ్ సాంకేతికత, మీ డేటా లేబుల్డ్ ఉంటుంది మరియు ML అల్గోరిథమ్స్ ఆ లేబుల్స్ ఉపయోగించి డేటాసెట్ యొక్క తరగతులు (లక్షణాలు) వర్గీకరించి వాటిని ఒక గుంపు లేదా ఫలితానికి కేటాయిస్తాయి.

✅ వంటకాల గురించి ఒక డేటాసెట్‌ను ఊహించండి. బహుళ వర్గ మోడల్ ఏమి సమాధానం చెప్పగలదు? బైనరీ మోడల్ ఏమి సమాధానం చెప్పగలదు? మీరు ఒక వంటకం మెంతులు ఉపయోగించే అవకాశం ఉందా అని నిర్ణయించాలనుకుంటే? మీరు ఒక గ్రోసరీ బ్యాగ్‌లో స్టార్ అనీస్, ఆర్టిచోక్స్, కాలీఫ్లవర్, మరియు హోర్సరాడిష్ ఉన్నప్పుడు, మీరు ఒక సాధారణ భారతీయ వంటకం తయారుచేయగలరా?

🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి. 'Chopped' షో యొక్క మొత్తం భావన 'మిస్టరీ బాస్కెట్' - అక్కడ చెఫ్స్ రాండమ్ పదార్థాలతో వంటకం తయారుచేయాలి. ఖచ్చితంగా ML మోడల్ సహాయపడేది!

హలో 'క్లాసిఫయర్'

ఈ వంటకాల డేటాసెట్ నుండి అడగదలచిన ప్రశ్న వాస్తవానికి బహుళ వర్గ ప్రశ్న ఎందుకంటే మనకు అనేక జాతీయ వంటకాలు ఉన్నాయి. పదార్థాల బ్యాచ్ ఇచ్చినప్పుడు, ఈ అనేక తరగతులలో ఏది డేటాకు సరిపోతుంది?

Scikit-learn వివిధ అల్గోరిథమ్స్ అందిస్తుంది, మీరు పరిష్కరించదలచిన సమస్య రకాన్ని ఆధారంగా డేటాను వర్గీకరించడానికి. తదుపరి రెండు పాఠాలలో, మీరు ఈ అల్గోరిథమ్స్ గురించి తెలుసుకుంటారు.

వ్యాయామం - మీ డేటాను శుభ్రపరచి సమతుల్యం చేయండి

ఈ ప్రాజెక్ట్ ప్రారంభించే ముందు మొదటి పని, మీ డేటాను శుభ్రపరచి సమతుల్యం చేయడం, మెరుగైన ఫలితాలు పొందడానికి. ఈ ఫోల్డర్ రూట్‌లో ఉన్న ఖాళీ notebook.ipynb ఫైల్‌తో ప్రారంభించండి.

మొదట ఇన్‌స్టాల్ చేయవలసినది imblearn. ఇది Scikit-learn ప్యాకేజీ, ఇది డేటాను మెరుగ్గా సమతుల్యం చేయడానికి సహాయపడుతుంది (ఈ పనిని మీరు కొద్దిసేపట్లో నేర్చుకుంటారు).

1. imblearn ఇన్‌స్టాల్ చేయడానికి, ఇలా pip install నడపండి:

   pip install imblearn
   

2. మీ డేటాను దిగుమతి చేసుకోవడానికి మరియు దాన్ని విజువలైజ్ చేయడానికి అవసరమైన ప్యాకేజీలను దిగుమతి చేసుకోండి, అలాగే imblearn నుండి SMOTE ను దిగుమతి చేసుకోండి.

   import pandas as pd
   import matplotlib.pyplot as plt
   import matplotlib as mpl
   import numpy as np
   from imblearn.over_sampling import SMOTE
   

   ఇప్పుడు మీరు డేటాను దిగుమతి చేసుకోవడానికి సిద్ధంగా ఉన్నారు.

3. తదుపరి పని డేటాను దిగుమతి చేసుకోవడం:

   df  = pd.read_csv('../data/cuisines.csv')
   

   read_csv() ఉపయోగించి cusines.csv ఫైల్ యొక్క కంటెంట్‌ను చదివి df వేరియబుల్‌లో ఉంచుతుంది.

4. డేటా ఆకారాన్ని తనిఖీ చేయండి:

   df.head()
   

   మొదటి ఐదు వరుసలు ఇలా ఉంటాయి:

   |     | 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        |
   

5. info() పిలిచి ఈ డేటా గురించి సమాచారం పొందండి:

   df.info()
   

   మీ అవుట్‌పుట్ ఇలా ఉంటుంది:

   <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() పిలిచి డేటాను బార్లుగా ప్లాట్ చేయండి:

   df.cuisine.value_counts().plot.barh()
   

   

   వంటకాల సంఖ్య పరిమితి ఉన్నప్పటికీ, డేటా పంపిణీ అసమానంగా ఉంది. మీరు దీన్ని సరిచేయవచ్చు! ముందుగా, మరింత అన్వేషించండి.

2. వంటకాల వారీగా ఎంత డేటా ఉందో కనుగొని ప్రింట్ చేయండి:

   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}')
   

   అవుట్‌పుట్ ఇలా ఉంటుంది:

   thai df: (289, 385)
   japanese df: (320, 385)
   chinese df: (442, 385)
   indian df: (598, 385)
   korean df: (799, 385)
   

పదార్థాలను కనుగొనడం

ఇప్పుడు మీరు డేటాలో లోతుగా వెళ్ళి వంటకాల వారీగా సాధారణ పదార్థాలు ఏమిటో తెలుసుకోవచ్చు. వంటకాల మధ్య గందరగోళం సృష్టించే పునరావృత డేటాను శుభ్రపరచాలి, కాబట్టి ఈ సమస్య గురించి తెలుసుకుందాం.

1. పదార్థాల డేటాఫ్రేమ్ సృష్టించడానికి Python లో create_ingredient() ఫంక్షన్ సృష్టించండి. ఈ ఫంక్షన్ ఉపయోగకరంలేని కాలమ్‌ను తొలగించి, పదార్థాలను వారి కౌంట్ ఆధారంగా సర్దుతుంది:

   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
   

   ఇప్పుడు మీరు ఆ ఫంక్షన్ ఉపయోగించి వంటకాల వారీగా టాప్ టెన్ అత్యంత ప్రాచుర్యం పొందిన పదార్థాల ఆలోచన పొందవచ్చు.

2. create_ingredient() పిలిచి barh() పిలిచి ప్లాట్ చేయండి:

   thai_ingredient_df = create_ingredient_df(thai_df)
   thai_ingredient_df.head(10).plot.barh()
   

   

3. జపనీస్ డేటా కోసం అదే చేయండి:

   japanese_ingredient_df = create_ingredient_df(japanese_df)
   japanese_ingredient_df.head(10).plot.barh()
   

   

4. ఇప్పుడు చైనీస్ పదార్థాల కోసం:

   chinese_ingredient_df = create_ingredient_df(chinese_df)
   chinese_ingredient_df.head(10).plot.barh()
   

   

5. ఇండియన్ పదార్థాలను ప్లాట్ చేయండి:

   indian_ingredient_df = create_ingredient_df(indian_df)
   indian_ingredient_df.head(10).plot.barh()
   

   

6. చివరగా, కొరియన్ పదార్థాలను ప్లాట్ చేయండి:

   korean_ingredient_df = create_ingredient_df(korean_df)
   korean_ingredient_df.head(10).plot.barh()
   

   

7. ఇప్పుడు, వేర్వేరు వంటకాల మధ్య గందరగోళం సృష్టించే అత్యంత సాధారణ పదార్థాలను drop() పిలిచి తొలగించండి:

   అందరూ అన్నం, వెల్లుల్లి మరియు అల్లం ఇష్టపడతారు!

   feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
   labels_df = df.cuisine #.unique()
   feature_df.head()
   

డేటాసెట్‌ను సమతుల్యం చేయండి

ఇప్పుడు మీరు డేటాను శుభ్రపరిచిన తర్వాత, SMOTE - "సింథటిక్ మైనారిటీ ఓవర్-సాంప్లింగ్ టెక్నిక్" - ఉపయోగించి దాన్ని సమతుల్యం చేయండి.

1. fit_resample() పిలవండి, ఈ వ్యూహం ఇంటర్‌పోలేషన్ ద్వారా కొత్త నమూనాలను సృష్టిస్తుంది.

   oversample = SMOTE()
   transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
   

   మీ డేటాను సమతుల్యం చేయడం ద్వారా, మీరు దాన్ని వర్గీకరించేటప్పుడు మెరుగైన ఫలితాలు పొందుతారు. ఒక బైనరీ వర్గీకరణ గురించి ఆలోచించండి. మీ డేటాలో ఎక్కువ భాగం ఒక తరగతికి చెందినట్లయితే, ML మోడల్ ఆ తరగతిని ఎక్కువగా అంచనా వేయగలదు, ఎందుకంటే దానికి ఎక్కువ డేటా ఉంటుంది. డేటాను సమతుల్యం చేయడం ఏదైనా వక్రీకృత డేటాను తీసుకుని ఈ అసమతుల్యతను తొలగించడంలో సహాయపడుతుంది.

2. ఇప్పుడు పదార్థాల వారీగా లేబుల్స్ సంఖ్యను తనిఖీ చేయండి:

   print(f'new label count: {transformed_label_df.value_counts()}')
   print(f'old label count: {df.cuisine.value_counts()}')
   

   మీ అవుట్‌పుట్ ఇలా ఉంటుంది:

   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
   

   డేటా చక్కగా శుభ్రపరచబడింది, సమతుల్యం చేయబడింది, మరియు చాలా రుచికరంగా ఉంది!

3. చివరి దశలో, లేబుల్స్ మరియు లక్షణాలను కలిగి ఉన్న మీ సమతుల్య డేటాను కొత్త డేటాఫ్రేమ్‌లో సేవ్ చేయండి, దీన్ని ఫైల్‌గా ఎగుమతి చేయవచ్చు:

   transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
   

4. transformed_df.head() మరియు transformed_df.info() ఉపయోగించి డేటాను మరొకసారి చూడవచ్చు. భవిష్యత్తు పాఠాల కోసం ఈ డేటా కాపీని సేవ్ చేయండి:

   transformed_df.head()
   transformed_df.info()
   transformed_df.to_csv("../data/cleaned_cuisines.csv")
   

   ఈ తాజా CSV ఇప్పుడు రూట్ డేటా ఫోల్డర్‌లో కనిపిస్తుంది.

---

🚀సవాలు

ఈ పాఠ్యాంశంలో అనేక ఆసక్తికరమైన డేటాసెట్లు ఉన్నాయి. data ఫోల్డర్లలో వెతకండి మరియు ఏవైనా బైనరీ లేదా బహుళ వర్గీకరణకు అనుకూలమైన డేటాసెట్లు ఉన్నాయా చూడండి? మీరు ఆ డేటాసెట్ నుండి ఏ ప్రశ్నలు అడగాలనుకుంటారు?

పాఠం తర్వాత క్విజ్

సమీక్ష & స్వీయ అధ్యయనం

SMOTE యొక్క API ను అన్వేషించండి. ఇది ఏ ఉపయోగాల కోసం ఉత్తమంగా ఉపయోగించబడుతుంది? ఇది ఏ సమస్యలను పరిష్కరిస్తుంది?

అసైన్‌మెంట్

వర్గీకరణ పద్ధతులను అన్వేషించండి

---

అస్పష్టత:
ఈ పత్రాన్ని AI అనువాద సేవ Co-op Translator ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారులు కోసం మేము బాధ్యత వహించము.