|
|
# ವರ್ಗಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್
|
|
|
|
|
|
|
|
|
|
|
|
## [ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
> ### [ಈ ಪಾಠ R ನಲ್ಲಿ ಲಭ್ಯವಿದೆ!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
|
|
|
|
|
|
## ಪರಿಚಯ
|
|
|
|
|
|
ರಿಗ್ರೆಶನ್ ಕುರಿತು ಈ ಅಂತಿಮ ಪಾಠದಲ್ಲಿ, ಮೂಲ _ಕ್ಲಾಸಿಕ್_ ಎಂಎಲ್ ತಂತ್ರಗಳಲ್ಲಿ ಒಂದಾದ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಅನ್ನು ನೋಡೋಣ. ನೀವು ಈ ತಂತ್ರವನ್ನು ದ್ವಿಮೂಲ್ಯ ವರ್ಗಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಮಾದರಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಬಳಸುತ್ತೀರಿ. ಈ ಕ್ಯಾಂಡಿ ಚಾಕೊಲೇಟ್ ಆಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ? ಈ ರೋಗ ಸಂಕ್ರಾಮಕವೇ ಅಥವಾ ಇಲ್ಲವೇ? ಈ ಗ್ರಾಹಕ ಈ ಉತ್ಪನ್ನವನ್ನು ಆರಿಸುವನೋ ಅಥವಾ ಇಲ್ಲವೇ?
|
|
|
|
|
|
ಈ ಪಾಠದಲ್ಲಿ ನೀವು ಕಲಿಯುವಿರಿ:
|
|
|
|
|
|
- ಡೇಟಾ ದೃಶ್ಯೀಕರಣಕ್ಕಾಗಿ ಹೊಸ ಗ್ರಂಥಾಲಯ
|
|
|
- ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ತಂತ್ರಗಳು
|
|
|
|
|
|
✅ ಈ ರೀತಿಯ ರಿಗ್ರೆಶನ್ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರ ಬಗ್ಗೆ ನಿಮ್ಮ ಅರ್ಥವನ್ನು ಗಾಢಗೊಳಿಸಿ ಈ [ಕಲಿಕೆ ಘಟಕದಲ್ಲಿ](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott)
|
|
|
|
|
|
## ಪೂರ್ವಾಪೇಕ್ಷಿತ
|
|
|
|
|
|
ಪಂಪ್ಕಿನ್ ಡೇಟಾ ಜೊತೆ ಕೆಲಸ ಮಾಡಿದ ನಂತರ, ನಾವು ಈಗ ಅದರಲ್ಲಿ ಒಂದು ದ್ವಿಮೂಲ್ಯ ವರ್ಗವಿದೆ ಎಂದು ತಿಳಿದುಕೊಂಡಿದ್ದೇವೆ: `Color`.
|
|
|
|
|
|
ನಾವು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸೋಣ, ಕೆಲವು ಚರಗಳನ್ನು ನೀಡಿದಾಗ, _ಒಂದು ಪಂಪ್ಕಿನ್ ಯಾವ ಬಣ್ಣದಾಗಿರಬಹುದು_ (ಕಿತ್ತಳೆ 🎃 ಅಥವಾ ಬಿಳಿ 👻).
|
|
|
|
|
|
> ನಾವು ರಿಗ್ರೆಶನ್ ಕುರಿತು ಪಾಠ ಗುಂಪಿನಲ್ಲಿ ದ್ವಿಮೂಲ್ಯ ವರ್ಗೀಕರಣವನ್ನು ಏಕೆ ಚರ್ಚಿಸುತ್ತಿದ್ದೇವೆ? ಭಾಷಾಶೈಲಿಯ ಅನುಕೂಲಕ್ಕಾಗಿ ಮಾತ್ರ, ಏಕೆಂದರೆ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ [ನಿಜವಾಗಿಯೂ ವರ್ಗೀಕರಣ ವಿಧಾನವಾಗಿದೆ](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), ಆದರೂ ಲೀನಿಯರ್ ಆಧಾರಿತದಾಗಿದೆ. ಮುಂದಿನ ಪಾಠ ಗುಂಪಿನಲ್ಲಿ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವ ಇತರ ವಿಧಾನಗಳನ್ನು ತಿಳಿಯಿರಿ.
|
|
|
|
|
|
## ಪ್ರಶ್ನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ
|
|
|
|
|
|
ನಮ್ಮ ಉದ್ದೇಶಕ್ಕಾಗಿ, ನಾವು ಇದನ್ನು ದ್ವಿಮೂಲ್ಯವಾಗಿ ವ್ಯಕ್ತಪಡಿಸುತ್ತೇವೆ: 'ಬಿಳಿ' ಅಥವಾ 'ಬಿಳಿಯಲ್ಲ'. ನಮ್ಮ ಡೇಟಾಸೆಟ್ನಲ್ಲಿ 'ಸ್ಟ್ರೈಪ್ಡ್' ಎಂಬ ವರ್ಗವೂ ಇದೆ ಆದರೆ ಅದರ ಉದಾಹರಣೆಗಳು ಕಡಿಮೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಡೇಟಾಸೆಟ್ನಿಂದ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದ ಮೇಲೆ ಅದು ಅಳಿದುಹೋಗುತ್ತದೆ.
|
|
|
|
|
|
> 🎃 ಮನರಂಜನೆಯ ವಿಷಯ, ನಾವು ಕೆಲವೊಮ್ಮೆ ಬಿಳಿ ಪಂಪ್ಕಿನ್ಗಳನ್ನು 'ಭೂತ' ಪಂಪ್ಕಿನ್ಗಳು ಎಂದು ಕರೆಯುತ್ತೇವೆ. ಅವುಗಳನ್ನು ಕತ್ತರಿಸುವುದು ಸುಲಭವಲ್ಲ, ಆದ್ದರಿಂದ ಅವು ಕಿತ್ತಳೆ ಪಂಪ್ಕಿನ್ಗಳಷ್ಟು ಜನಪ್ರಿಯವಲ್ಲ ಆದರೆ ಅವು ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತವೆ! ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಪ್ರಶ್ನೆಯನ್ನು 'ಭೂತ' ಅಥವಾ 'ಭೂತವಲ್ಲ' ಎಂದು ಮರುರೂಪಿಸಬಹುದು. 👻
|
|
|
|
|
|
## ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಬಗ್ಗೆ
|
|
|
|
|
|
ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ನಿಂದ, ನೀವು ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಕಲಿತಿದ್ದೀರಿ, ಕೆಲವು ಪ್ರಮುಖ ರೀತಿಗಳಲ್ಲಿ ಭಿನ್ನವಾಗಿದೆ.
|
|
|
|
|
|
[](https://youtu.be/KpeCT6nEpBY "ಎಂಎಲ್ ಆರಂಭಿಕರಿಗೆ - ಯಂತ್ರ ಅಧ್ಯಯನ ವರ್ಗೀಕರಣಕ್ಕಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು")
|
|
|
|
|
|
> 🎥 ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಕುರಿತು ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.
|
|
|
|
|
|
### ದ್ವಿಮೂಲ್ಯ ವರ್ಗೀಕರಣ
|
|
|
|
|
|
ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ನಂತೆ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ. ಮೊದಲದು ದ್ವಿಮೂಲ್ಯ ವರ್ಗದ ಬಗ್ಗೆ ಭವಿಷ್ಯವಾಣಿ ನೀಡುತ್ತದೆ ("ಬಿಳಿ ಅಥವಾ ಬಿಳಿಯಲ್ಲ") ಆದರೆ ಎರಡನೆಯದು ನಿರಂತರ ಮೌಲ್ಯಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ ಪಂಪ್ಕಿನ್ ಮೂಲ ಮತ್ತು ಹಾರ್ವೆಸ್ಟ್ ಸಮಯ ನೀಡಿದಾಗ, _ಅದರ ಬೆಲೆ ಎಷ್ಟು ಏರಬಹುದು_.
|
|
|
|
|
|
|
|
|
> ಇನ್ಫೋಗ್ರಾಫಿಕ್: [ದಾಸನಿ ಮಡಿಪಳ್ಳಿ](https://twitter.com/dasani_decoded)
|
|
|
|
|
|
### ಇತರ ವರ್ಗೀಕರಣಗಳು
|
|
|
|
|
|
ಮಲ್ಟಿನೋಮಿಯಲ್ ಮತ್ತು ಆರ್ಡಿನಲ್ ಸೇರಿದಂತೆ ಇತರ ವಿಧದ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ಗಳಿವೆ:
|
|
|
|
|
|
- **ಮಲ್ಟಿನೋಮಿಯಲ್**, ಇದು ಒಂದುಕ್ಕಿಂತ ಹೆಚ್ಚು ವರ್ಗಗಳನ್ನು ಹೊಂದಿದೆ - "ಕಿತ್ತಳೆ, ಬಿಳಿ ಮತ್ತು ಸ್ಟ್ರೈಪ್ಡ್".
|
|
|
- **ಆರ್ಡಿನಲ್**, ಇದು ಕ್ರಮಬದ್ಧ ವರ್ಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಉದಾಹರಣೆಗೆ ನಮ್ಮ ಪಂಪ್ಕಿನ್ಗಳು ಸಣ್ಣ, ಮಧ್ಯಮ, ದೊಡ್ಡ ಇತ್ಯಾದಿ ಗಾತ್ರಗಳಲ್ಲಿ ಕ್ರಮಬದ್ಧವಾಗಿದ್ದರೆ.
|
|
|
|
|
|
|
|
|
|
|
|
### ಚರಗಳು ಹೊಂದಾಣಿಕೆ ಹೊಂದಬೇಕಾಗಿಲ್ಲ
|
|
|
|
|
|
ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ ಹೆಚ್ಚು ಹೊಂದಾಣಿಕೆಯ ಚರಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತಿತ್ತು ಎಂದು ನೆನಪಿಸಿಕೊಳ್ಳಿ? ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಅದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿದೆ - ಚರಗಳು ಹೊಂದಾಣಿಕೆ ಹೊಂದಬೇಕಾಗಿಲ್ಲ. ಇದು ಸ್ವಲ್ಪ ದುರ್ಬಲ ಹೊಂದಾಣಿಕೆ ಇರುವ ಈ ಡೇಟಾಗೆ ಸೂಕ್ತವಾಗಿದೆ.
|
|
|
|
|
|
### ನಿಮಗೆ ಬಹಳಷ್ಟು ಸ್ವಚ್ಛ ಡೇಟಾ ಬೇಕು
|
|
|
|
|
|
ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಹೆಚ್ಚು ಡೇಟಾ ಬಳಸಿದರೆ ಹೆಚ್ಚು ನಿಖರ ಫಲಿತಾಂಶ ನೀಡುತ್ತದೆ; ನಮ್ಮ ಸಣ್ಣ ಡೇಟಾಸೆಟ್ ಈ ಕಾರ್ಯಕ್ಕೆ ಸೂಕ್ತವಲ್ಲ, ಅದನ್ನು ಗಮನದಲ್ಲಿಡಿ.
|
|
|
|
|
|
[](https://youtu.be/B2X4H9vcXTs "ಎಂಎಲ್ ಆರಂಭಿಕರಿಗೆ - ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ಗೆ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ತಯಾರಿ")
|
|
|
|
|
|
> 🎥 ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ಗೆ ಡೇಟಾ ತಯಾರಿಕೆ ಕುರಿತು ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ
|
|
|
|
|
|
✅ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ಗೆ ಸೂಕ್ತವಾಗುವ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಬಗ್ಗೆ ಯೋಚಿಸಿ
|
|
|
|
|
|
## ಅಭ್ಯಾಸ - ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ
|
|
|
|
|
|
ಮೊದಲು, ಡೇಟಾವನ್ನು ಸ್ವಲ್ಪ ಸ್ವಚ್ಛಗೊಳಿಸಿ, ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ಕೆಲವು ಕಾಲಮ್ಗಳನ್ನು ಮಾತ್ರ ಆಯ್ಕೆಮಾಡಿ:
|
|
|
|
|
|
1. ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
|
|
|
|
|
|
```python
|
|
|
|
|
|
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
|
|
|
pumpkins = full_pumpkins.loc[:, columns_to_select]
|
|
|
|
|
|
pumpkins.dropna(inplace=True)
|
|
|
```
|
|
|
|
|
|
ನೀವು ಯಾವಾಗಲೂ ನಿಮ್ಮ ಹೊಸ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ನೋಡಬಹುದು:
|
|
|
|
|
|
```python
|
|
|
pumpkins.info
|
|
|
```
|
|
|
|
|
|
### ದೃಶ್ಯೀಕರಣ - ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್
|
|
|
|
|
|
ಈಗ ನೀವು ಮತ್ತೆ [ಸ್ಟಾರ್ಟರ್ ನೋಟ್ಬುಕ್](./notebook.ipynb) ಅನ್ನು ಪಂಪ್ಕಿನ್ ಡೇಟಾ ಜೊತೆಗೆ ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸಿದ್ದೀರಿ, ಇದರಲ್ಲಿ ಕೆಲವು ಚರಗಳೊಂದಿಗೆ `Color` ಕೂಡ ಇದೆ. ನೋಟ್ಬುಕ್ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಬೇರೆ ಗ್ರಂಥಾಲಯ ಬಳಸಿ ದೃಶ್ಯೀಕರಿಸೋಣ: [Seaborn](https://seaborn.pydata.org/index.html), ಇದು Matplotlib ಮೇಲೆ ನಿರ್ಮಿತವಾಗಿದೆ, ನಾವು ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಬಳಸಿದ್ದೇವೆ.
|
|
|
|
|
|
Seaborn ನಿಮ್ಮ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಕೆಲವು ಚೆನ್ನಾದ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಪ್ರತಿ `Variety` ಮತ್ತು `Color` ಗೆ ಡೇಟಾ ವಿತರಣೆಗಳನ್ನು ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್ನಲ್ಲಿ ಹೋಲಿಸಬಹುದು.
|
|
|
|
|
|
1. `catplot` ಫಂಕ್ಷನ್ ಬಳಸಿ, ನಮ್ಮ ಪಂಪ್ಕಿನ್ ಡೇಟಾ `pumpkins` ಮತ್ತು ಪ್ರತಿ ಪಂಪ್ಕಿನ್ ವರ್ಗಕ್ಕೆ ಬಣ್ಣ ನಕ್ಷೆ (ಕಿತ್ತಳೆ ಅಥವಾ ಬಿಳಿ) ಸೂಚಿಸಿ, ಇಂತಹ ಪ್ಲಾಟ್ ರಚಿಸಿ:
|
|
|
|
|
|
```python
|
|
|
import seaborn as sns
|
|
|
|
|
|
palette = {
|
|
|
'ORANGE': 'orange',
|
|
|
'WHITE': 'wheat',
|
|
|
}
|
|
|
|
|
|
sns.catplot(
|
|
|
data=pumpkins, y="Variety", hue="Color", kind="count",
|
|
|
palette=palette,
|
|
|
)
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
ಡೇಟಾವನ್ನು ಗಮನಿಸಿದರೆ, ಬಣ್ಣ ಡೇಟಾ `Variety` ಗೆ ಹೇಗೆ ಸಂಬಂಧಿಸಿದೆ ಎಂದು ಕಾಣಬಹುದು.
|
|
|
|
|
|
✅ ಈ ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್ ನೀಡಿದಾಗ, ನೀವು ಯಾವ ರೀತಿ ಆಸಕ್ತಿದಾಯಕ ಅನ್ವೇಷಣೆಗಳನ್ನು ಕಲ್ಪಿಸಬಹುದು?
|
|
|
|
|
|
### ಡೇಟಾ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆ: ವೈಶಿಷ್ಟ್ಯ ಮತ್ತು ಲೇಬಲ್ ಎನ್ಕೋಡಿಂಗ್
|
|
|
ನಮ್ಮ ಪಂಪ್ಕಿನ್ ಡೇಟಾಸೆಟ್ನ ಎಲ್ಲಾ ಕಾಲಮ್ಗಳಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳಿವೆ. ವರ್ಗೀಕೃತ ಡೇಟಾ ಮಾನವರಿಗೆ ಸುಲಭ ಆದರೆ ಯಂತ್ರಗಳಿಗೆ ಅಲ್ಲ. ಯಂತ್ರ ಅಧ್ಯಯನ ಆಲ್ಗಾರಿದಮ್ಗಳು ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ. ಆದ್ದರಿಂದ ಎನ್ಕೋಡಿಂಗ್ ಡೇಟಾ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆಯ ಅತ್ಯಂತ ಮುಖ್ಯ ಹಂತವಾಗಿದೆ, ಇದು ವರ್ಗೀಕೃತ ಡೇಟಾವನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾಗೆ ಪರಿವರ್ತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಯಾವುದೇ ಮಾಹಿತಿ ಕಳೆದುಕೊಳ್ಳದೆ. ಉತ್ತಮ ಎನ್ಕೋಡಿಂಗ್ ಉತ್ತಮ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.
|
|
|
|
|
|
ವೈಶಿಷ್ಟ್ಯ ಎನ್ಕೋಡಿಂಗ್ಗೆ ಎರಡು ಪ್ರಮುಖ ಎನ್ಕೋಡರ್ ಪ್ರಕಾರಗಳಿವೆ:
|
|
|
|
|
|
1. ಆರ್ಡಿನಲ್ ಎನ್ಕೋಡರ್: ಇದು ಆರ್ಡಿನಲ್ ಚರಗಳಿಗೆ ಸೂಕ್ತ, ಅಂದರೆ ಅವುಗಳ ಡೇಟಾ ತರ್ಕಬದ್ಧ ಕ್ರಮವನ್ನು ಅನುಸರಿಸುವ ವರ್ಗೀಕೃತ ಚರಗಳು, ನಮ್ಮ ಡೇಟಾಸೆಟ್ನ `Item Size` ಕಾಲಮ್ನಂತೆ. ಇದು ಪ್ರತಿ ವರ್ಗವನ್ನು ಸಂಖ್ಯೆಯಿಂದ ಪ್ರತಿನಿಧಿಸುವ ನಕ್ಷೆಯನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಕಾಲಮ್ನಲ್ಲಿ ವರ್ಗದ ಕ್ರಮವಾಗಿದೆ.
|
|
|
|
|
|
```python
|
|
|
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)
|
|
|
```
|
|
|
|
|
|
2. ವರ್ಗೀಕೃತ ಎನ್ಕೋಡರ್: ಇದು ನಾಮಮಾತ್ರ ಚರಗಳಿಗೆ ಸೂಕ್ತ, ಅಂದರೆ ಅವುಗಳ ಡೇಟಾ ತರ್ಕಬದ್ಧ ಕ್ರಮವನ್ನು ಅನುಸರಿಸುವುದಿಲ್ಲ, ನಮ್ಮ ಡೇಟಾಸೆಟ್ನ `Item Size` ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳಿಗೆ. ಇದು ಒನ್-ಹಾಟ್ ಎನ್ಕೋಡಿಂಗ್ ಆಗಿದ್ದು, ಪ್ರತಿ ವರ್ಗವನ್ನು ಬೈನರಿ ಕಾಲಮ್ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ: ಪಂಪ್ಕಿನ್ ಆ ವರ್ಗಕ್ಕೆ ಸೇರಿದರೆ ಎನ್ಕೋಡಿಂಗ್ ಮೌಲ್ಯ 1, ಇಲ್ಲದಿದ್ದರೆ 0.
|
|
|
|
|
|
```python
|
|
|
from sklearn.preprocessing import OneHotEncoder
|
|
|
|
|
|
categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
|
|
|
categorical_encoder = OneHotEncoder(sparse_output=False)
|
|
|
```
|
|
|
ನಂತರ, `ColumnTransformer` ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹಲವಾರು ಎನ್ಕೋಡರ್ಗಳನ್ನು ಒಂದೇ ಹಂತದಲ್ಲಿ ಸಂಯೋಜಿಸಿ ಸೂಕ್ತ ಕಾಲಮ್ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
|
|
|
|
|
|
```python
|
|
|
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)
|
|
|
```
|
|
|
ಮತ್ತೊಂದೆಡೆ, ಲೇಬಲ್ ಎನ್ಕೋಡಿಂಗ್ ಮಾಡಲು, ನಾವು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ನ `LabelEncoder` ವರ್ಗವನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಲೇಬಲ್ಗಳನ್ನು 0 ರಿಂದ n_classes-1 (ಇಲ್ಲಿ 0 ಮತ್ತು 1) ಮೌಲ್ಯಗಳ ನಡುವೆ ಸಾಮಾನ್ಯೀಕರಿಸಲು ಸಹಾಯ ಮಾಡುವ ಉಪಯುಕ್ತ ವರ್ಗ.
|
|
|
|
|
|
```python
|
|
|
from sklearn.preprocessing import LabelEncoder
|
|
|
|
|
|
label_encoder = LabelEncoder()
|
|
|
encoded_label = label_encoder.fit_transform(pumpkins['Color'])
|
|
|
```
|
|
|
ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಲೇಬಲ್ ಅನ್ನು ಎನ್ಕೋಡ್ ಮಾಡಿದ ನಂತರ, ಅವುಗಳನ್ನು ಹೊಸ ಡೇಟಾಫ್ರೇಮ್ `encoded_pumpkins` ಗೆ ಮರ್ಜ್ ಮಾಡಬಹುದು.
|
|
|
|
|
|
```python
|
|
|
encoded_pumpkins = encoded_features.assign(Color=encoded_label)
|
|
|
```
|
|
|
✅ `Item Size` ಕಾಲಮ್ಗೆ ಆರ್ಡಿನಲ್ ಎನ್ಕೋಡರ್ ಬಳಸುವುದರಿಂದ ಏನು ಲಾಭಗಳಿವೆ?
|
|
|
|
|
|
### ಚರಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ
|
|
|
|
|
|
ಈಗ ನಾವು ಡೇಟಾವನ್ನು ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆ ಮಾಡಿದ್ದೇವೆ, ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಲೇಬಲ್ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ಮಾದರಿ ಲೇಬಲ್ ಅನ್ನು ವೈಶಿಷ್ಟ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು.
|
|
|
ಈ ರೀತಿಯ ವಿಶ್ಲೇಷಣೆಗೆ ಉತ್ತಮ ವಿಧಾನ ಡೇಟಾವನ್ನು ಪ್ಲಾಟ್ ಮಾಡುವುದು. ನಾವು ಮತ್ತೆ Seaborn `catplot` ಫಂಕ್ಷನ್ ಬಳಸಿ, `Item Size`, `Variety` ಮತ್ತು `Color` ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್ನಲ್ಲಿ ದೃಶ್ಯೀಕರಿಸುವೆವು. ಉತ್ತಮವಾಗಿ ಪ್ಲಾಟ್ ಮಾಡಲು ನಾವು ಎನ್ಕೋಡ್ ಮಾಡಿದ `Item Size` ಕಾಲಮ್ ಮತ್ತು ಎನ್ಕೋಡ್ ಮಾಡದ `Variety` ಕಾಲಮ್ ಬಳಸುತ್ತೇವೆ.
|
|
|
|
|
|
```python
|
|
|
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}")
|
|
|
```
|
|
|
|
|
|
|
|
|
### ಸ್ವಾರ್ಮ್ ಪ್ಲಾಟ್ ಬಳಸಿ
|
|
|
|
|
|
ಬಣ್ಣವು ದ್ವಿಮೂಲ್ಯ ವರ್ಗ (ಬಿಳಿ ಅಥವಾ ಬಿಳಿಯಲ್ಲ) ಆಗಿರುವುದರಿಂದ, ಅದನ್ನು ದೃಶ್ಯೀಕರಿಸಲು 'ವಿಶೇಷ ವಿಧಾನ' ಬೇಕಾಗುತ್ತದೆ. ಈ ವರ್ಗದ ಸಂಬಂಧವನ್ನು ಇತರ ಚರಗಳೊಂದಿಗೆ ದೃಶ್ಯೀಕರಿಸುವ ಇನ್ನೂ ಕೆಲವು ವಿಧಾನಗಳಿವೆ.
|
|
|
|
|
|
ನೀವು Seaborn ಪ್ಲಾಟ್ಗಳೊಂದಿಗೆ ಚರಗಳನ್ನು ಪಕ್ಕಪಕ್ಕವಾಗಿ ದೃಶ್ಯೀಕರಿಸಬಹುದು.
|
|
|
|
|
|
1. ಮೌಲ್ಯಗಳ ವಿತರಣೆ ತೋರಿಸಲು 'ಸ್ವಾರ್ಮ್' ಪ್ಲಾಟ್ ಪ್ರಯತ್ನಿಸಿ:
|
|
|
|
|
|
```python
|
|
|
palette = {
|
|
|
0: 'orange',
|
|
|
1: 'wheat'
|
|
|
}
|
|
|
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
**ಎಚ್ಚರಿಕೆ**: ಮೇಲಿನ ಕೋಡ್ ಎಚ್ಚರಿಕೆ ನೀಡಬಹುದು, ಏಕೆಂದರೆ Seaborn ಇಷ್ಟು ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳನ್ನು ಸ್ವಾರ್ಮ್ ಪ್ಲಾಟ್ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲು ವಿಫಲವಾಗಬಹುದು. ಒಂದು ಪರಿಹಾರವೆಂದರೆ 'size' ಪರಿಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು. ಆದರೆ ಇದು ಪ್ಲಾಟ್ ಓದಲು ಕಷ್ಟವಾಗಬಹುದು.
|
|
|
|
|
|
> **🧮 ಗಣಿತವನ್ನು ತೋರಿಸಿ**
|
|
|
>
|
|
|
> ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ 'ಗರಿಷ್ಠ ಸಾಧ್ಯತೆ' ಎಂಬ ತತ್ವವನ್ನು [ಸಿಗ್ಮಾಯ್ಡ್ ಫಂಕ್ಷನ್ಗಳು](https://wikipedia.org/wiki/Sigmoid_function) ಬಳಸಿ ಅವಲಂಬಿಸುತ್ತದೆ. ಪ್ಲಾಟ್ನಲ್ಲಿ 'ಸಿಗ್ಮಾಯ್ಡ್ ಫಂಕ್ಷನ್' 'S' ಆಕಾರದಂತೆ ಕಾಣುತ್ತದೆ. ಇದು ಒಂದು ಮೌಲ್ಯವನ್ನು ತೆಗೆದು ಅದನ್ನು 0 ಮತ್ತು 1 ನಡುವೆ ನಕ್ಷೆ ಮಾಡುತ್ತದೆ. ಇದರ ವಕ್ರವನ್ನು 'ಲಾಜಿಸ್ಟಿಕ್ ವಕ್ರ' ಎಂದು ಕರೆಯುತ್ತಾರೆ. ಇದರ ಸೂತ್ರ ಹೀಗಿದೆ:
|
|
|
>
|
|
|
> 
|
|
|
>
|
|
|
> ಇಲ್ಲಿ ಸಿಗ್ಮಾಯ್ಡ್ನ ಮಧ್ಯಬಿಂದುವು x ರ 0 ಬಿಂದುವಿನಲ್ಲಿ ಇರುತ್ತದೆ, L ವಕ್ರದ ಗರಿಷ್ಠ ಮೌಲ್ಯ, ಮತ್ತು k ವಕ್ರದ ತೀವ್ರತೆ. ಫಂಕ್ಷನ್ ಫಲಿತಾಂಶ 0.5 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಇದ್ದರೆ, ಆ ಲೇಬಲ್ '1' ವರ್ಗಕ್ಕೆ ನೀಡಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, '0' ಎಂದು ವರ್ಗೀಕರಿಸಲಾಗುತ್ತದೆ.
|
|
|
|
|
|
## ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ
|
|
|
|
|
|
ಈ ದ್ವಿಮೂಲ್ಯ ವರ್ಗೀಕರಣವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವುದು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ನಲ್ಲಿ ಆಶ್ಚರ್ಯಕರವಾಗಿ ಸರಳವಾಗಿದೆ.
|
|
|
|
|
|
[](https://youtu.be/MmZS2otPrQ8 "ಎಂಎಲ್ ಆರಂಭಿಕರಿಗೆ - ಡೇಟಾ ವರ್ಗೀಕರಣಕ್ಕಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್")
|
|
|
|
|
|
> 🎥 ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿ ನಿರ್ಮಾಣದ ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ
|
|
|
|
|
|
1. ನಿಮ್ಮ ವರ್ಗೀಕರಣ ಮಾದರಿಯಲ್ಲಿ ಬಳಸಬೇಕಾದ ಚರಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್ಗಳನ್ನು `train_test_split()` ಕರೆ ಮಾಡಿ ವಿಭಜಿಸಿ:
|
|
|
|
|
|
```python
|
|
|
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)
|
|
|
|
|
|
```
|
|
|
|
|
|
2. ಈಗ ನೀವು `fit()` ಅನ್ನು ನಿಮ್ಮ ತರಬೇತಿ ಡೇಟಾ ಜೊತೆ ಕರೆಸಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಬಹುದು ಮತ್ತು ಅದರ ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸಿ:
|
|
|
|
|
|
```python
|
|
|
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 ಸಾಲುಗಳ ಡೇಟಾ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಪರಿಗಣಿಸಿದರೆ:
|
|
|
|
|
|
```output
|
|
|
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
|
|
|
```
|
|
|
|
|
|
## ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಮೂಲಕ ಉತ್ತಮ ಅರ್ಥಮಾಡಿಕೆ
|
|
|
|
|
|
ನೀವು ಮೇಲಿನ ಐಟಂಗಳನ್ನು ಮುದ್ರಿಸುವ ಮೂಲಕ ಸ್ಕೋರ್ಬೋರ್ಡ್ ವರದಿಯನ್ನು ಪಡೆಯಬಹುದು, ಆದರೆ ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಹೆಚ್ಚು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು [ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) ಅನ್ನು ಬಳಸಬಹುದು, ಇದು ಮಾದರಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ತಿಳಿಸುತ್ತದೆ.
|
|
|
|
|
|
> 🎓 '[ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್](https://wikipedia.org/wiki/Confusion_matrix)' (ಅಥವಾ 'ದೋಷ ಮ್ಯಾಟ್ರಿಕ್ಸ್') ಒಂದು ಟೇಬಲ್ ಆಗಿದ್ದು, ನಿಮ್ಮ ಮಾದರಿಯ ನಿಜವಾದ ಮತ್ತು ತಪ್ಪು ಧನಾತ್ಮಕ ಮತ್ತು ನಕಾರಾತ್ಮಕಗಳನ್ನು ತೋರಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಭವಿಷ್ಯವಾಣಿಗಳ ನಿಖರತೆಯನ್ನು ಅಳೆಯುತ್ತದೆ.
|
|
|
|
|
|
1. ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಬಳಸಲು, `confusion_matrix()` ಅನ್ನು ಕರೆ ಮಾಡಿ:
|
|
|
|
|
|
```python
|
|
|
from sklearn.metrics import confusion_matrix
|
|
|
confusion_matrix(y_test, predictions)
|
|
|
```
|
|
|
|
|
|
ನಿಮ್ಮ ಮಾದರಿಯ ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ನೋಡಿ:
|
|
|
|
|
|
```output
|
|
|
array([[162, 4],
|
|
|
[ 11, 22]])
|
|
|
```
|
|
|
|
|
|
ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ನಲ್ಲಿ, ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಸಾಲುಗಳು (ಅಕ್ಷ 0) ನಿಜವಾದ ಲೇಬಲ್ಗಳು ಮತ್ತು ಕಾಲಮ್ಗಳು (ಅಕ್ಷ 1) ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಲೇಬಲ್ಗಳು.
|
|
|
|
|
|
| | 0 | 1 |
|
|
|
| :---: | :---: | :---: |
|
|
|
| 0 | TN | FP |
|
|
|
| 1 | FN | TP |
|
|
|
|
|
|
ಇಲ್ಲಿ ಏನಾಗುತ್ತಿದೆ? ನಮ್ಮ ಮಾದರಿಯನ್ನು ಎರಡು ದ್ವಿಮೂಲ್ಯ ವರ್ಗಗಳಾದ 'ಬಿಳಿ' ಮತ್ತು 'ಬಿಳಿಯಲ್ಲ' ಪಂಪ್ಕಿನ್ಗಳನ್ನು ವರ್ಗೀಕರಿಸಲು ಕೇಳಲಾಗಿದೆ ಎಂದು ಹೇಳೋಣ.
|
|
|
|
|
|
- ನಿಮ್ಮ ಮಾದರಿ ಪಂಪ್ಕಿನ್ ಅನ್ನು ಬಿಳಿಯಲ್ಲ ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ 'ಬಿಳಿಯಲ್ಲ' ವರ್ಗಕ್ಕೆ ಸೇರಿದರೆ, ಅದನ್ನು ನಿಜ ನಕಾರಾತ್ಮಕ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ಮೇಲಿನ ಎಡ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.
|
|
|
- ನಿಮ್ಮ ಮಾದರಿ ಪಂಪ್ಕಿನ್ ಅನ್ನು ಬಿಳಿ ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ 'ಬಿಳಿಯಲ್ಲ' ವರ್ಗಕ್ಕೆ ಸೇರಿದರೆ, ಅದನ್ನು ತಪ್ಪು ಧನಾತ್ಮಕ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ಕೆಳಗಿನ ಎಡ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.
|
|
|
- ನಿಮ್ಮ ಮಾದರಿ ಪಂಪ್ಕಿನ್ ಅನ್ನು ಬಿಳಿಯಲ್ಲ ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ 'ಬಿಳಿ' ವರ್ಗಕ್ಕೆ ಸೇರಿದರೆ, ಅದನ್ನು ತಪ್ಪು ಧನಾತ್ಮಕ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ಮೇಲಿನ ಬಲ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.
|
|
|
- ನಿಮ್ಮ ಮಾದರಿ ಪಂಪ್ಕಿನ್ ಅನ್ನು ಬಿಳಿ ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ 'ಬಿಳಿ' ವರ್ಗಕ್ಕೆ ಸೇರಿದರೆ, ಅದನ್ನು ನಿಜ ಧನಾತ್ಮಕ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ಕೆಳಗಿನ ಬಲ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.
|
|
|
ನೀವು ಊಹಿಸಿದ್ದಂತೆ, ಹೆಚ್ಚು ಸಂಖ್ಯೆಯ ಸತ್ಯ ಧನಾತ್ಮಕಗಳು ಮತ್ತು ಸತ್ಯ ನಕಾರಾತ್ಮಕಗಳನ್ನು ಹೊಂದಿರುವುದು ಮತ್ತು ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ತಪ್ಪು ಧನಾತ್ಮಕಗಳು ಮತ್ತು ತಪ್ಪು ನಕಾರಾತ್ಮಕಗಳನ್ನು ಹೊಂದಿರುವುದು ಇಷ್ಟಕರ, ಇದು ಮಾದರಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.
|
|
|
|
|
|
ಸಂಕುಚಿತ ಮ್ಯಾಟ್ರಿಕ್ಸ್ precision ಮತ್ತು recall ಗೆ ಹೇಗೆ ಸಂಬಂಧಿಸಿದೆ? ಮೇಲಿನ ವರ್ಗೀಕರಣ ವರದಿ precision (0.85) ಮತ್ತು recall (0.67) ಅನ್ನು ತೋರಿಸಿತು ಎಂದು ನೆನಪಿಡಿ.
|
|
|
|
|
|
Precision = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
|
|
|
|
|
|
Recall = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
|
|
|
|
|
|
✅ ಪ್ರಶ್ನೆ: ಸಂಕುಚಿತ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಪ್ರಕಾರ, ಮಾದರಿ ಹೇಗೆ ಮಾಡಿತು? ಉತ್ತರ: ಕೆಟ್ಟದಿಲ್ಲ; ಸತ್ಯ ನಕಾರಾತ್ಮಕಗಳ ಸಂಖ್ಯೆ ಚೆನ್ನಾಗಿದೆ ಆದರೆ ಕೆಲವು ತಪ್ಪು ನಕಾರಾತ್ಮಕಗಳೂ ಇದ್ದವು.
|
|
|
|
|
|
ನಾವು ಮೊದಲು ನೋಡಿದ ಪದಗಳನ್ನು ಸಂಕುಚಿತ ಮ್ಯಾಟ್ರಿಕ್ಸ್ನ TP/TN ಮತ್ತು FP/FN ನ ನಕ್ಷೆ ಸಹಾಯದಿಂದ ಮತ್ತೆ ಪರಿಶೀಲಿಸೋಣ:
|
|
|
|
|
|
🎓 Precision: TP/(TP + FP) ಪಡೆದ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಸಂಬಂಧಿತ ಉದಾಹರಣೆಗಳ ಭಾಗ (ಉದಾ: ಯಾವ ಲೇಬಲ್ಗಳು ಚೆನ್ನಾಗಿ ಲೇಬಲ್ ಮಾಡಲಾಯಿತು)
|
|
|
|
|
|
🎓 Recall: TP/(TP + FN) ಪಡೆದ ಸಂಬಂಧಿತ ಉದಾಹರಣೆಗಳ ಭಾಗ, ಚೆನ್ನಾಗಿ ಲೇಬಲ್ ಮಾಡಲಾದವು ಅಥವಾ ಇಲ್ಲದವು
|
|
|
|
|
|
🎓 f1-score: (2 * precision * recall)/(precision + recall) precision ಮತ್ತು recall ನ ತೂಕಿತ ಸರಾಸರಿ, ಉತ್ತಮ 1 ಮತ್ತು ಕೆಟ್ಟ 0
|
|
|
|
|
|
🎓 Support: ಪ್ರತಿಯೊಂದು ಲೇಬಲ್ಗೆ ಪಡೆದ ಸಂಭವಗಳ ಸಂಖ್ಯೆ
|
|
|
|
|
|
🎓 Accuracy: (TP + TN)/(TP + TN + FP + FN) ಮಾದರಿ ನಿಖರವಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಲೇಬಲ್ಗಳ ಶೇಕಡಾವಾರು
|
|
|
|
|
|
🎓 Macro Avg: ಲೇಬಲ್ ಅಸಮತೋಲನವನ್ನು ಪರಿಗಣಿಸದೆ ಪ್ರತಿಯೊಂದು ಲೇಬಲ್ಗೆ ಅತೂಕವಿಲ್ಲದ ಸರಾಸರಿ ಮೌಲ್ಯಗಳ ಲೆಕ್ಕಾಚಾರ
|
|
|
|
|
|
🎓 Weighted Avg: ಲೇಬಲ್ ಅಸಮತೋಲನವನ್ನು ಪರಿಗಣಿಸಿ, ಪ್ರತಿಯೊಂದು ಲೇಬಲ್ಗೆ ಸತ್ಯ ಉದಾಹರಣೆಗಳ ಸಂಖ್ಯೆಯ ಮೂಲಕ ತೂಕ ನೀಡುವ ಮೂಲಕ ಸರಾಸರಿ ಮೌಲ್ಯಗಳ ಲೆಕ್ಕಾಚಾರ
|
|
|
|
|
|
✅ ನೀವು ನಿಮ್ಮ ಮಾದರಿ ತಪ್ಪು ನಕಾರಾತ್ಮಕಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಬಯಸಿದರೆ ಯಾವ ಮೌಲ್ಯವನ್ನು ಗಮನಿಸಬೇಕು ಎಂದು ನೀವು ಯೋಚಿಸಬಹುದೇ?
|
|
|
|
|
|
## ಈ ಮಾದರಿಯ ROC ವಕ್ರವನ್ನು ದೃಶ್ಯೀಕರಿಸಿ
|
|
|
|
|
|
[](https://youtu.be/GApO575jTA0 "ML for beginners - Analyzing Logistic Regression Performance with ROC Curves")
|
|
|
|
|
|
> 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ROC ವಕ್ರಗಳ ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ
|
|
|
|
|
|
ನಾವು 'ROC' ವಕ್ರವನ್ನು ನೋಡಲು ಇನ್ನೊಂದು ದೃಶ್ಯೀಕರಣ ಮಾಡೋಣ:
|
|
|
|
|
|
```python
|
|
|
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](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) ಅಥವಾ ROC ಅನ್ನು ರೇಖಾಚಿತ್ರಗೊಳಿಸಿ. ROC ವಕ್ರಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವರ್ಗೀಕರಿಸುವವರ ಸತ್ಯ ಮತ್ತು ತಪ್ಪು ಧನಾತ್ಮಕಗಳ ದೃಷ್ಟಿಕೋನದಿಂದ ಫಲಿತಾಂಶವನ್ನು ನೋಡಲು ಬಳಸಲಾಗುತ್ತದೆ. "ROC ವಕ್ರಗಳು ಸಾಮಾನ್ಯವಾಗಿ Y ಅಕ್ಷದಲ್ಲಿ ಸತ್ಯ ಧನಾತ್ಮಕ ದರ ಮತ್ತು X ಅಕ್ಷದಲ್ಲಿ ತಪ್ಪು ಧನಾತ್ಮಕ ದರವನ್ನು ಹೊಂದಿರುತ್ತವೆ." ಆದ್ದರಿಂದ, ವಕ್ರದ ತೀವ್ರತೆ ಮತ್ತು ಮಧ್ಯರೇಖೆ ಮತ್ತು ವಕ್ರದ ನಡುವಿನ ಸ್ಥಳವು ಮಹತ್ವಪೂರ್ಣ: ನೀವು ವಕ್ರವು ಶೀಘ್ರವಾಗಿ ಮೇಲಕ್ಕೆ ಹೋಗಿ ರೇಖೆಯನ್ನು ಮೀರಿ ಹೋಗುವಂತೆ ಬಯಸುತ್ತೀರಿ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಆರಂಭದಲ್ಲಿ ತಪ್ಪು ಧನಾತ್ಮಕಗಳಿವೆ, ನಂತರ ರೇಖೆ ಸರಿಯಾಗಿ ಮೇಲಕ್ಕೆ ಹೋಗುತ್ತದೆ:
|
|
|
|
|
|
|
|
|
|
|
|
ಕೊನೆಗೆ, Scikit-learn ನ [`roc_auc_score` API](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) ಬಳಸಿ ನಿಜವಾದ 'ವಕ್ರದ ಕೆಳಗಿನ ಪ್ರದೇಶ' (AUC) ಅನ್ನು ಲೆಕ್ಕಿಸಿ:
|
|
|
|
|
|
```python
|
|
|
auc = roc_auc_score(y_test,y_scores[:,1])
|
|
|
print(auc)
|
|
|
```
|
|
|
ಫಲಿತಾಂಶ `0.9749908725812341`. AUC 0 ರಿಂದ 1 ರವರೆಗೆ ಇರುತ್ತದೆ, ನೀವು ದೊಡ್ಡ ಅಂಕೆಯನ್ನು ಬಯಸುತ್ತೀರಿ, ಏಕೆಂದರೆ 100% ನಿಖರ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಮಾಡುವ ಮಾದರಿಯ AUC 1 ಆಗಿರುತ್ತದೆ; ಈ ಪ್ರಕರಣದಲ್ಲಿ, ಮಾದರಿ _ಚೆನ್ನಾಗಿದೆ_.
|
|
|
|
|
|
ಭವಿಷ್ಯದಲ್ಲಿ ವರ್ಗೀಕರಣ ಪಾಠಗಳಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ಮಾದರಿಯ ಅಂಕೆಗಳನ್ನು ಸುಧಾರಿಸಲು ಹೇಗೆ ಪುನರಾವರ್ತನೆ ಮಾಡಬೇಕೆಂದು ಕಲಿಯುತ್ತೀರಿ. ಆದರೆ ಈಗ, ಅಭಿನಂದನೆಗಳು! ನೀವು ಈ ರಿಗ್ರೆಶನ್ ಪಾಠಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೀರಿ!
|
|
|
|
|
|
---
|
|
|
## 🚀ಸವಾಲು
|
|
|
|
|
|
ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ಅನೇಕ ವಿಷಯಗಳಿವೆ! ಆದರೆ ಕಲಿಯಲು ಉತ್ತಮ ಮಾರ್ಗ ಪ್ರಯೋಗ ಮಾಡುವುದು. ಈ ರೀತಿಯ ವಿಶ್ಲೇಷಣೆಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಹುಡುಕಿ ಮತ್ತು ಅದರಿಂದ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ. ನೀವು ಏನು ಕಲಿತೀರಿ? ಸಲಹೆ: ಆಸಕ್ತಿದಾಯಕ ಡೇಟಾಸೆಟ್ಗಳಿಗಾಗಿ [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) ಪ್ರಯತ್ನಿಸಿ.
|
|
|
|
|
|
## [ಪಾಠೋತ್ತರ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
|
|
|
|
|
|
ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ನ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಗಳ ಕುರಿತು [ಸ್ಟ್ಯಾನ್ಫರ್ಡ್ನ ಈ ಪೇಪರ್](https://web.stanford.edu/~jurafsky/slp3/5.pdf) ನ ಮೊದಲ ಕೆಲವು ಪುಟಗಳನ್ನು ಓದಿ. ನಾವು ಈವರೆಗೆ ಅಧ್ಯಯನ ಮಾಡಿದ ರಿಗ್ರೆಶನ್ ಕಾರ್ಯಗಳಿಗೆ ಯಾವುದು ಉತ್ತಮ ಎಂದು ಯೋಚಿಸಿ. ಯಾವುದು ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ?
|
|
|
|
|
|
## ನಿಯೋಜನೆ
|
|
|
|
|
|
[ಈ ರಿಗ್ರೆಶನ್ ಅನ್ನು ಮರುಪ್ರಯತ್ನಿಸುವುದು](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**ಅಸ್ವೀಕರಣ**:
|
|
|
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
