# ಸ್ಕೈಕಿಟ್-ಲರ್ನ್ ಬಳಸಿ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ತಯಾರಿಸುವುದು: ರೆಗ್ರೆಷನ್ ನಾಲ್ಕು ವಿಧಾನಗಳು ## ಪ್ರಾರಂಭಿಕ ಟಿಪ್ಪಣಿ ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಅನ್ನು ನಾವು **ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯ** (ಉದಾಹರಣೆಗೆ, ಮನೆ ಬೆಲೆ, ತಾಪಮಾನ ಅಥವಾ ಮಾರಾಟ) ಅನ್ನು ಊಹಿಸಲು ಬಯಸುವಾಗ ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಇನ್ಪುಟ್ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಔಟ್‌ಪುಟ್ ನಡುವಣ ಸಂಬಂಧವನ್ನು ಉತ್ತಮವಾಗಿ ಪ್ರತಿನಿಧಿಸುವ ಸರಳ ರೇಖೆಯನ್ನು ಹುಡುಕುವುದರಿಂದ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಪಾಠದಲ್ಲಿ, ನಾವು ಹೆಚ್ಚು ಮುಂದುವರಿದ ರೆಗ್ರೆಷನ್ ತಂತ್ರಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಮೊದಲು ಕನ್ಸೆಪ್ಟ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ. ![ಲೀನಿಯರ್ ಮತ್ತು ಪೊಲಿನೋಮಿಯಲ್ ರೆಗ್ರೆಷನ್ ಇನ್ಫೋಗ್ರಾಫಿಕ್](../../../../translated_images/kn/linear-polynomial.5523c7cb6576ccab.webp) > ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ದಾಸನಿ ಮಡಿಪಳ್ಳಿ](https://twitter.com/dasani_decoded) ಅವರಿಂದ ## [ಪೂರ್ವ-ಲೆಕ್ಚರ್ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/) > ### [ಈ ಪಾಠ R ಭಾಷೆಯಲ್ಲಿ ಲಭ್ಯವಿದೆ!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html) ### ಪರಿಚಯ ಇಲ್ಲಿಯವರೆಗಿನಂತೆ ನೀವು ರೆಗರೇಶನ್ ಏನೆಂದು ತಿಳಿದುಕೊಂಡಿದ್ದೀರಿ ಮತ್ತು ಇದು ನಾವು ಈ ಪಾಠದಲ್ಲಿ ಬಳಸಲಿರುವ ಕಡಲೆಕಾಯಿ ಬೆಲೆಗಳ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿರುವ ಮಾದರಿ ಡೇಟಾದೊಂದಿಗೆ ಆಗಿತ್ತು. ನೀವು ಇದನ್ನು ಮೆಟ್ಪ್ಲಾಟ್‌ಲಿಬ್ ಬಳಸಿ ದೃಶ್ಯೀಕರಿಸಿರುವಿರಿ. ಈಗ ನೀವು ಎಂಎಲ್ ನ ರೆಗ್ರೆಷನನ್ನು ಇನ್ನೂ ಆಳವಾಗಿ ಅಧ್ಯಯನ ಮಾಡಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ. ದೃಶ್ಯೀಕರಣವು ಡೇಟಾವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯಮಾಡುತ್ತದೆ ಆದರೆ ಯಥಾರ್ಥ ಶಕ್ತಿ ಮಷೀನ್ ಲರ್ನಿಂಗಿನಲ್ಲಿ ಬರುತ್ತದೆ _ಮಾಡೆಲ್ಗಳನ್ನು ತರಬೇತುಗೊಳಿಸುವುದರಿಂದ_. ಮಾಡೆಲ್ಗಳು ಇತಿಹಾಸದ ಡೇಟಾದಲ್ಲಿ ತರಬೇತುಗೊಳ್ಳುತ್ತವೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಡೇಟಾ ಅವಲಂಬನೆಗಳನ್ನು ಹಿಡಿದುಕೊಳ್ಳುತ್ತವೆ, ಮತ್ತು ಹೊಸ ಡೇಟಾಗೆ ಫಲಿತಾಂಶಗಳನ್ನು ಊಹಿಸಲು ಸಹಾಯಮಾಡುತ್ತವೆ, ಇದು ಮಾಡೆಲು ಹಿಂದಿನಿಂದಲೇ ನೋಡುವುದಿಲ್ಲ. ಈ ಪಾಠದಲ್ಲಿ ನೀವು ಎರಡು ಪ್ರಕಾರದ ರೆಗ್ರೆಷನ್ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ತಿಳಿಯುತ್ತೀರಿ: _ಮೂಲಭೂತ ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್_ ಮತ್ತು _ಪೊಲಿನೋಮಿಯಲ್ ರೆಗ್ರೆಷನ್_, ಜೊತೆಯಲ್ಲಿ ಈ ತಂತ್ರಗಳ ಮೂಲ ಗಣಿತ. ಆ ಮಾದರಿಗಳು ವಿವಿಧ ಇನ್‌ಪುಟ್ ಡೇಟಾದ ಮೇಲೆ ಆಧರಿಸಿ ಕಡಲೆಕಾಯಿ ಬೆಲೆಗಳನ್ನು ಊಹಿಸಲು ನಮಗೆ ಸಹಾಯಮಾಡುತ್ತವೆ. [![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression") > 🎥 ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಅನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವಿಡಿಯೋ ಮೂಲಕ ನೋಡಲು ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. > ಈ ಕುರಿತ ಶಿಖರಣೆಯಲ್ಲಿ, ನಾವು ಗಣಿತದ ಕನಿಷ್ಠ ಜ್ಞಾನದನ್ನೇ ಊಹಿಸಿಕೊಂಡಿದ್ದು, ಬೇರೆ ಕ್ಷೇತ್ರಗಳಿಂದ ಬಂದ ಶಿಕ್ಷಣಾರ್ಥಿಗಳಿಗೆ ಸುಲಭವಾಗುವಂತೆ ಮಾಡಬೇಕಾಗಿದೆ, ಆದ್ದರಿಂದ ಟಿಪ್ಪಣಿಗಳು, 🧮 ಖಾತರಿಪಡಿಸುವ ಪದಗಳು, ರೇಖಾಚಿತ್ರಗಳು ಮತ್ತು ಇತರೆ ಕಲಿಕಾ ಟೂಲ್‌ಗಳನ್ನು ಗಮನಿಸಿ. ### ಪೂರ್ವಾ ಅವಶ್ಯಕತೆ ನೀವು ಈಗಾಗಲೆ ಈ ಪಾಠದ ಕಡಲೆಕಾಯಿ ಡೇಟಾ ರಚನೆಯೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದೀರಿ. ಈ ಡೇಟಾ ಪೂರ್ವaload ಮಾಡಲ್ಪಟ್ಟಿರುವುದು ಮತ್ತು ಪೂರ್ವ-ಶುದ್ಧೀಕರಿಸಲ್ಪಟ್ಟಿದ್ದು ಈ ಪಾಠದ _notebook.ipynb_ ಫೈಲ್‌ನಲ್ಲಿ ಇದೆ. ಫೈಲ್‌ನಲ್ಲಿ ಕಡಲೆಕಾಯಿ ಬೆಲೆ ಹೊಸ ಡೇಟಾ ಫ್ರೇಮ್‌ನಲ್ಲಿ ಪ್ರತಿ ಬுஷೆಲ್‌ಗೆ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆ. Visual Studio Code‌ನಲ್ಲಿ kernels ನಲ್ಲಿ ಈ ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ನಡಿಸಲು ನೀವು ಸಾಧ್ಯವಾಗಬೇಕು. ### ತಯಾರಿ ಮತ್ತೆ ನೆನಪಿಸಿಕೊಳ್ಳಿ, ನೀವು ಈ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದನ್ನು ಲೋಡ್ ಮಾಡುತ್ತಿದ್ದೀರಿ ಮತ್ತು ಅದರಿಂದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು. - ಕಡಲೆಕಾಯಿಗಳನ್ನು ಖರೀದಿಸಲು ಉತ್ತಮ ಸಮಯ ಯಾವುದು? - ಸಣ್ಣ ಕಡಲೆಕಾಯಿ ಸಂಕೆಯಲ್ಲಿ ಬೆಲೆ ಎಷ್ಟು ನಿರೀಕ್ಷಿಸಬಹುದು? - ಅವುಗಳನ್ನು ಅರ್ಧ ಬಷೆಲ್ ಟೋकरಿ ಅಥವಾ 1 1/9 ಬಷೆಲ್ ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಖರೀದಿಸಬೇಕೆ? ನಾವು ಈ ಡೇಟಾದಲ್ಲಿ ಇನ್ನೂ ಆಳವಾಗಿ ತಿದ್ದಿ ನೋಡೋಣ. ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಪಾಂಡಾಸ್ ಡೇಟಾ ಫ್ರೇಮ್ನ್ನು ಸೃಷ್ಟಿಸಿದಿರಿ ಮತ್ತು ಮೂಲ ಡೇಟಾಸೆಟ್‌ನ ಒಂದು ಭಾಗದಿಂದ ಅಂದರ್ಜಾಲದಲ್ಲಿ ಬಷೆಲ್ ಮೂಲಕ ಬೆಲೆಯನ್ನು ನಿಯಮಿತಗೊಳಿಸಿದ್ದೀರಿ. ಆದರೂ ಅದು ಕೇವಲ 400 ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳಷ್ಟೇ ಮತ್ತು ಅದು ಸೀಮಿತವಾಗಿತ್ತು ಪತನ ಮಾಸಗಳ ಮೇಲೆ. ಈ ಪಾಠದ ಜೊತೆಗೆ ಲೋಡ್ ಮಾಡಲಾದ ಡೇಟಾದ ನೋಡಿ. ಡೇಟಾವನ್ನು ಪೂರ್ವaload ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಮೊದಲ scatterplot ತಿಂಗಳು ಡೇಟಾವನ್ನು ತೋರಿಸಲು ರೇಖಾಚಿತ್ರ ಮಾಡಲಾಗಿದೆ. ಡೇಟಾ ನಿರ್ಮಲಗೊಳಿಸುವ ಮೂಲಕ ಅದು ಇನ್ನಷ್ಟು ವಿವರಗಳನ್ನು ಕೊಡಬಹುದಾಗಿದೆ. ## ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ರೇಖೆ ಪಾಠ 1ರಲ್ಲಿ ಕಲಿತದ್ದರಂತೆ, ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ವ್ಯಾಯಾಮದ ಉದ್ದೇಶ: - **ಚರದ ನಡುವಣ ಸಂಬಂಧ ತೋರಿಸುವುದು**. ಚರಗಳ ನಡುವೆ ಸಂಬಂಧವನ್ನು ತೋರಿಸಿ - **ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು**. ಹೊಸ ಡೇಟಾಪಾಯಿಂಟು ಆ ರೇಖೆಯ ಎಲ್ಲಿ ಬರುತ್ತದೆ ಎಂದು ಸರಿಯಾಗಿ ಊಹಿಸಲು **ಲೀಸ್ಟ್ಸ್ಕ್ವೇರ್ಸ್ ರೆಗ್ರೆಷನ್**‌ನಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಇಂತಹ ರೇಖೆಯನ್ನು ರೇಖೆಸುತ್ತಾರೆ. "ಲೀಸ್ಟ್ಸ್ಕ್ವೇರ್ಸ್" ಎಂಬ ಪದವು ನಮ್ಮ ಮಾದರಿಯಲ್ಲಿನ ತೊಂದರೆಯನ್ನು ಕನಿಷ್ಠಗೊಳಿಸುವ ಪ್ರಕ್ರಿಯೆಗೆ ಸೂಚನೆ ನೀಡುತ್ತದೆ. ಪ್ರತಿ ಡೇಟಾಪಾಯಿಂಟ್‌ಗಾಗಿ ನಾವು ವಾಸ್ತವಿಕ ಬಿಂದುವಿನ ಮತ್ತು ನಮ್ಮ ರೆಗ್ರೆಷನ್ ರೇಖೆಯ ನಡುವೆ ಲಂಬ ದೂರವನ್ನು (ಬಾಕಿ ಅಥವಾ ಶೇಷವೆಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಮಾಪಿಸುತ್ತೇವೆ. ಈ ದೂರಗಳನ್ನು ಎರಡು ಪ್ರಮುಖ ಕಾರಣಗಳಿಂದ ವರ್ಗಾಕಾರ ಮಾಡುತ್ತೇವೆ: 1. **ದಿಕ್ಕಿನ ಮೇಲೆ ಮಹತ್ವಕ್ಕಿಂತ ಮಿತಿಮೀರುವುದರ ಮೇಲೆ ಗಮನ**: -5 ಎಂಬ ತಪ್ಪನ್ನು +5 ಎಂಬ ತಪ್ಪಿನಂತೆ ಟ್ರೀಟ್ ಮಾಡಬೇಕು. ವರ್ಗಾಕಾರವು ಎಲ್ಲ ಮೌಲ್ಯಗಳನ್ನು ಧನಾತ್ಮಕವಾಗಿಸುತ್ತದೆ. 2. **ಅಲೌಕಿಕ ಅಂಕಿಗಳನ್ನು ಶಿಕ್ಷಿಸುವುದು**: ಹೆಚ್ಚುವರಿ ತಪ್ಪುಗಳಿಗೆ ಹೆಚ್ಚು ತೂಕ ನೀಡುವುದರಿಂದ ರೇಖೆಯು ದೂರದ ಅಂಕಿಗಳ ಹತ್ತಿರ ಉಳಿಯಲು ಬಾಧ್ಯವಾಗುತ್ತದೆ. ನಂತರ ನಾವು ಈ ಎಲ್ಲಾ ವರ್ಗಾಕೃತ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ನಮ್ಮ ಗುರಿ ಈ ಅಂತಿಮ ಮೊತ್ತವನ್ನು ಕನಿಷ್ಠಗೊಳಿಸುವ ನಿರ್ದಿಷ್ಟ ರೇಖೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವುದು — ಆದ್ದರಿಂದ "ಲೀಸ್ಟ್ಸ್ಕ್ವೇರ್ಸ್" ಎಂದು ಹೆಸರು. > **🧮 ಗಣಿತವನ್ನೂ ತೋರಿಸಿ** > > ಈ ರೇಖೆಯನ್ನು, _最佳合适的线_ ಎಂದು ಕರೆಯುತ್ತಾರೆ ಹಾಗೂ ಅದನ್ನು [ಸಮೀಕರಣ](https://en.wikipedia.org/wiki/Simple_linear_regression) ಮೂಲಕ ವ್ಯಕ್ತಪಡಿಸಬಹುದು: > > ``` > Y = a + bX > ``` > > `X` 'ವಿವರಣೆಮಾಡುವ ಚರ' ಎಂದರೆ, `Y` 'ಆಧಾರಿತ ಚರ' ಎನ್ನುವುದು. ರೇಖೆಯ ಸ್ಲೋಪ್ ಅನ್ನು `b` ಮತ್ತು `a` ಅನ್ನು y-ಅಡ್ಡಕೋನ ಎಂದು ಕರೆಯುತ್ತಾರೆ, ಇದಕ್ಕೆ ಅರ್ಥವು `X = 0` ಆಗಿದ್ದಾಗ `Y`ರ ಮೌಲ್ಯ. > >![ಸ್ಲೋಪ್ಗೆ ಲೆಕ್ಕ ಹಾಕಿ](../../../../translated_images/kn/slope.f3c9d5910ddbfcf9.webp) > > ಮೊದಲಾಗಿ, ಸ್ಲೋಪ್ `b`ನ ಲೆಕ್ಕ ಹಾಕಿ. ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ಅವರಿಂದ > > ಬೇರೊಂದು ಮಾತಿನಲ್ಲಿ, ಕಡಲೆಕಾಯಿ ಡೇಟಾದ ಮೂಲ ಪ್ರಶ್ನೆಯನ್ನು ಉಲ್ಲೇಖಿಸಿ: "ತಿಂಗಳ ಪ್ರತಿ ಬಷೆಲ್‌ಗೆ ಕಡಲೆಕಾಯಿ ಬೆಲೆಯನ್ನು ಊಹಿಸಿ", `X` ಬೆಲೆಗೆ ಮತ್ತು `Y` ಮಾರಾಟ ತಿಂಗಳಿಗೆ ಇದೆ. > >![ಸಮೀಕರಣ ಪೂರ್ಣಗೊಳಿಸಿ](../../../../translated_images/kn/calculation.a209813050a1ddb1.webp) > > Y ಮೌಲ್ಯ ಲೆಕ್ಕ ಹಾಕಿ. ನೀವು ಸುಮಾರು $4 ಅಂದರೆ ಅದು ಏಪ್ರಿಲ್ ಆಗಿರಬೇಕು! ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ಅವರಿಂದ > > ರೇಖೆ ಲೆಕ್ಕ ಹಾಕುವ ಗಣಿತವು ರೇಖೆಯ ಸ್ಲೋಪ್ ಅನ್ನು ಮತ್ತು `X=0` ಆಗಿದ್ದಾಗ `Y` ಇಲ್ಲಿರುವ ಅಡ್ಡಕೋನವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. > > ಈ ಮೌಲ್ಯಗಳ ಲೆಕ್ಕಿಸುವ ವಿಧಾನವನ್ನು [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) ವೆಬ್ ತಾಣದಲ್ಲಿ ನೋಡಬಹುದು. ಸಂಖ್ಯೆ ಮೌಲ್ಯಗಳು ರೇಖೆಯ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ ಎಂಬುದನ್ನು ಹೀಗೆ [ಲೀಸ್ಟ್ಸ್ಕ್ವೇರ್ಸ್ ಕ್ಯಾಲ್ಕ್ಯುಲೆಟರ್](https://www.mathsisfun.com/data/least-squares-calculator.html) ನಲ್ಲಿ ನೋಡಬಹುದು. ## ಸಹಸಂಬಂಧ ಮತ್ತೊಂದು ಪದವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಿದೆ: ಕೊಟ್ಟಿರುವ X ಮತ್ತು Y ಚರಗಳ ನಡುವೆ **ಸಹಸಂಬಂಧಗಳ ಗುಣಸ್ತರ**. ಸ್ಕೆಟರ್ಪ್ಲಾಟ್ ಬಳಸಿ, ನೀವು ಈ ಗುಣಸ್ತರವನ್ನು ತ್ವರಿತವಾಗಿ ದೃಶ್ಯೀಕರಿಸಬಹುದು. ಸ್ಕೆಟರ್ಪ್ಲಾಟ್ ನಲ್ಲಿ ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳು ಸರಳ ರೇಖೆಯಲ್ಲಿ ಕುಳಿತಿದ್ದರೆ ಸಹಸಂಬಂಧವು ಹೆಚ್ಚು, ಆದರೆ ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳು ಎಲ್ಲೆಡೆ ಹರಡಿದ್ದರೆ ಸಮಾಲೋಚನೆಯು ಕಡಿಮೆ. ಒಳ್ಳೆಯ ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿ ಏನೇನಾದರೂ, ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ರೇಖೆಯ ಮೂಲಕ Least-Squares Regression ವಿಧಾನದಿಂದ ಬಲವಾದ (0ಕ್ಕಿಂತ 1 ಕ್ಕೆ ಹತ್ತಿರುವ) ಸಹಸಂಬಂಧ ಗುಣಸ್ತರ ಹೊಂದಿರುತ್ತದೆ. ✅ ಈ ಪಾಠದ ಜೊತೆಗೆ ಕಂಪ್ಯೂಟ್ ಆಗುವ ನೋಟ್ಬುಕ್ ಅನ್ನು ಓಡಿಸಿ ಮತ್ತು ತಿಂಗಳು ಮತ್ತು ಬೆಲೆ ಸ್ಕೆಟರ್ಪ್ಲಾಟ್ ನೋಡಿರಿ. ನಿಮ್ಮ ದೃಶ್ಯಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆಯ ಪ್ರಕಾರ, ಕಡಲೆಕಾಯಿ ಮಾರಾಟದ ತಿಂಗಳಿಂದ ಬೆಲೆಗೆ ಇರುವ ಡೇಟಾ ಸಾಕಷ್ಟು ಉತ್ತಮ ಅಥವಾ ಕಡಿಮೆ ಸಹಸಂಬಂಧ ಹೊಂದಿದೆಯೆ? ಮತ್ತು `Month` ಬದಲಿಗೆ ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಮಾಪನ, ಉದಾ. *ವರ್ಷದ ದಿನ* (ಅಂದರೆ ವರ್ಷ ಆರಂಭದಿಂದ ದಿನಗಳ ಸಂಖ್ಯೆ) ಉಪಯೋಗಿಸಿದರೆ ಏನಾದರೂ ಬದಲಾಗುತ್ತದೆಯೆ? ಕೆಳಗಿನ ಕೋಡ್‌ನಲ್ಲಿ, ನಾವು ಡೇಟಾವನ್ನು ಶುದ್ಧಗೊಳಿಸಿದ್ದು ಮತ್ತು ಹೀಗೊಂದು `new_pumpkins` ಎಂಬ ಡೇಟಾಫ್ರೇಮ್ ಹೊಂದಿದ್ದೇವೆಂದು ಊಹಿಸೋಣ. ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price ---|-------|-----------|---------|------|---------|-----------|------------|------- 70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364 71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636 72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636 73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545 74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364 > ಡೇಟಾ ಶುರುಮಾಡಲು ಕೆಳಗಿನ [`notebook.ipynb`](notebook.ipynb) ಲಭ್ಯವಿದೆ. ನಾವು ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಮಾಡಿದ ಹಾಗೆ ಅದೇ ಶುದ್ಧತೆಯ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿದ್ದೇವೆ ಮತ್ತು ಈ ರೀತಿಯ ಸೂಚನೆಯೊಂದಿಗೆ `DayOfYear` ಕಾಲಮ್ ಅನ್ನು ಲೆಕ್ಕಿಸಿದ್ದಾರೆ: ```python day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days) ``` ಈಗ ನೀವು ಲೀನಿಯರ್ ರೆಗ್ರೆಷನಿನ ಹಿಂದಿನ ಗಣಿತವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ, ನಾವು ಒಂದು ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ಸೃಷ್ಟಿಸೋಣ, ಯಾವುದರಿಂದ ಕಡಲೆಕಾಯಿ ಪ್ಯಾಕೇಜುಗಳಲ್ಲಿ ಯಾವದು ಉತ್ತಮ ಬೆಲೆ ಕೊಡುತ್ತದೆ ಎಂದು ಊಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಹಿಂದಿನ ಹಬ್ಬದ ಕಡಲೆಕಾಯಿ ಪ್ಯಾಚ್ ಖರೀದಿಸುವವರು ತಮ್ಮ ಖರೀದಿಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಈ ಮಾಹಿತಿಯನ್ನು ಬಯಸಬಹುದು. ## ಸಹಸಂಬಂಧ ಹುಡುಕುವುದು [![ML for beginners - Looking for Correlation: The Key to Linear Regression](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression") > 🎥 ಸಹಸಂಬಂಧದ ಕುರಿತ ಸಂಕ್ಷಿಪ್ತ ವಿಡಿಯೋವನ್ನೂ ಮೇಲಿನ ಚಿತ್ರ ಕ್ಲಿಕ್ಕಿಸಿ ನೋಡಿ. ಹಿಂದಿನ ಪಾಠದಿಂದ ನೀವು ನೋಡಿರುವಿರಬಹುದು, ಬೇರೆಯಾದ ತಿಂಗಳುಗಳ ಸರಾಸರಿ ಬೆಲೆ ಹೀಗಿದೆ: Average price by month ಇದರಿಂದ ನಾವು ಕಣ್ತುಂಬಿಕೊಳ್ಳಬಹುದು ಸಹಸಂಬಂಧವಿದೆ, ನಾವು ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಮಾಡಿ `Month` ಮತ್ತು `Price` ಅಥವಾ `DayOfYear` ಮತ್ತು `Price` ನಡುವಣ ಸಂಬಂಧವನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು. ಕೆಳಗಿನ ಸ್ಕೆಟರ್ಪ್ಲಾಟ್ ಎರಡನೇ ಸಂಬಂಧವನ್ನು ತೋರಿಸುತ್ತದೆ: Scatter plot of Price vs. Day of Year `corr` ಫಂಕ್ಷನ್ ಬಳಸಿ ಸಹಸಂಬಂಧವನ್ನು ನೋಡೋಣ: ```python print(new_pumpkins['Month'].corr(new_pumpkins['Price'])) print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price'])) ``` `Month` ಅಂಕಗಳ ಸಹಸಂಬಂಧ -0.15 ಮತ್ತು `DayOfMonth` ಸಹಸಂಬಂಧ -0.17 ಇದಾಗಿದ್ದು ತಗ್ಗು ತೋರಿಸುತ್ತಿದೆ, ಆದರೆ ಇನ್ನೂ ಒಂದು ಪ್ರಮುಖ ಸಂಬಂಧ ಇರಬಹುದು. ಬೇರೆ ಬೇರೆ ಕಡಲೆಕಾಯಿ ವಿಧಗಳು ಬೆಲೆಗೆ ವಿಭಿನ್ನ ಗುಂಪು ರೂಪಿಸುತ್ತವೆ ಎಂದು ತೋರುತ್ತದೆ. ಈ ಊಹೆಯನ್ನು ದೃಢಪಡಿಸಲು, ಪ್ರತಿಯೊಂದು ಕಡಲೆಕಾಯಿ ವರ್ಗವನ್ನು ಬೇರೆ ಬಣ್ಣದಲ್ಲಿ ಹಿಡಿದು ಸ್ಕೆಟರ್ ಮಾಡೋಣ. `scatter` ಫಂಕ್ಷನ್‌ಗೆ `ax` ಪ್ಯಾರಾಮೀಟರ್ ನೀಡುವ ಮೂಲಕ ಎಲ್ಲಾ ಬಿಂದುಗಳನ್ನು ಒಂದೇ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಬಿಡಬಹುದು: ```python ax=None colors = ['red','blue','green','yellow'] for i,var in enumerate(new_pumpkins['Variety'].unique()): df = new_pumpkins[new_pumpkins['Variety']==var] ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var) ``` Scatter plot of Price vs. Day of Year ನಮ್ಮ ಪರಿಶೀಲನೆಯು ಸೂಚಿಸುತ್ತದೆ, ಕಡಲೆಕಾಯಿ ವಿಧವು ಮಾರಾಟ ದಿನಾಂಕಕ್ಕಿಂತ ಹೆಚ್ಚು ಬೆಲೆಗೆ ಪ್ರಭಾವ ಬೀರುತ್ತದೆ. ಇದನ್ನು ಬಾರ್ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು: ```python new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar') ``` Bar graph of price vs variety ಈಗ ನಾವು ಒಂದು ಕಡಲೆಕಾಯಿ ವಿಧವಾಗಿಯೇ ('ಪೈ ಟೈಪ್') ಗಮನಕೊಡೋಣ ಮತ್ತು ದಿನಾಂಕದ ಬೆಲೆಗೆ ಪರಿಣಾಮ ಎಷ್ಟು ನೋಡಿ: ```python pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE'] pie_pumpkins.plot.scatter('DayOfYear','Price') ``` Scatter plot of Price vs. Day of Year ಈಗ `corr` ಫಂಕ್ಷನ್ ಬಳಸಿ `Price` ಮತ್ತು `DayOfYear` ನಡುವಣ ಸಹಸಂಬಂಧ ಲೆಕ್ಕಿಸಿದರೆ, `-0.27` ಲಕ್ಷ್ಯನ್ಸ್ - ಇದು ಊಹಿಸುವ ಮಾದರಿಯನ್ನು ತರಬೇತುಮಾಡುವುದು ಅರ್ಥಪೂರ್ಣವೆಂದು ಸೂಚಿಸುತ್ತದೆ. > ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ತರಬೇತು ಮಾಡಿಕೊಳ್ಳೋ ಮೊದಲು, ಡೇಟಾ ಶುದ್ಧವಾಗಿರಬೇಕು. ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಖಾಲಿ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಖಾಲಿ ಸೆಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಸೂಕ್ತ. ```python pie_pumpkins.dropna(inplace=True) pie_pumpkins.info() ``` ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಖಾಲಿ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿಯೊಂದು ಕಾಲಮ್-ನ ಸರಾಸರಿ ಮೌಲ್ಯಗಳಿಂದ ತುಂಬಿಸುವುದು. ## ಸರಳ ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ [![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn") > 🎥 ಲೀನಿಯರ್ ಮತ್ತು ಪೊಲಿನೋಮಿಯಲ್ ರೆಗ್ರೆಷನ್ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತ ವಿಡಿಯೋವನ್ನು ಮೇಲಿನ ಚಿತ್ರ ಕ್ಲಿಕ್ ಮಾಡಿ ನೋಡಿ. ನಮ್ಮ ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ತರಬೇತು ಮಾಡುವುದಕ್ಕೆ ನಾವು **ಸ್ಕೈಕಿಟ್-ಲರ್ನ್** ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಲಿದ್ದೇವೆ. ```python from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error from sklearn.model_selection import train_test_split ``` ನಾವು ಮೊದಲಿಗೆ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯಗಳನ್ನು (ವೈಶಿಷ್ಟ್ಯಗಳು) ಮತ್ತು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್ (ಲೇಬಲ್) ಅನ್ನು ವಿಭಜಿಸಿ numpy ಅರೆಗಳಲ್ಲಿ ಇಡುತ್ತೇವೆ: ```python X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1) y = pie_pumpkins['Price'] ``` > ಗಮನಿಸಿ, ನಾವು ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಪ್ಯಾಕೇಜ್‌ ಸರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇನ್‌ಪುಟ್ ಡೇಟಾ `reshape` ಮಾಡಬೇಕಾಯಿತು. ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ 2D ಅರೆ ಇನ್‌ಪುಟ್ ಅನ್ನು ಎಕ್ಸ್ಪೆಕ್ಟ್ ಮಾಡುತ್ತದೆ, ಇದರಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಸಾಲು ಇನ್‌ಪುಟ್ ವೈಶಿಷ್ಟ್ಯಗಳ ವೆಕ್ಟರ್ ಆಗಿದ್ದು, ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಒಂದೇ ಇನ್‌ಪುಟ್ ಇದೆ, ಆದ್ದರಿಂದ N×1 ಆಕೃತಿ ಅಗತ್ಯ ಇದೆ, ಇಲ್ಲಿ N ಡೇಟಾಸೆಟ್ ಗಾತ್ರ. ನಂತರ, ನಾವು ಡೇಟಾವನ್ನು ತರಬೇತು ಮತ್ತು ಪರೀಕ್ಷೆ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ವಿಭಾಗಿಸಬೇಕಾಗಿದೆ, ಇದರಿಂದ ನಾವು ತರಬೇತಿ ಬಳಿಕ ನಮೂನೆಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು: ```python X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) ``` ಕರೈವಾಗಿ, ಲೀನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯ ತರಬೇತಿ ಎರಡು ಸಾಲುಗಳಲ್ಲಿ ನಡತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವು `LinearRegression` ವಸ್ತುವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ, `fit` ವಿಧಾನ ಬಳಸಿ ಅದನ್ನು ಡೇಟಾಗೆ ಹೊಂದಿಸುತ್ತೇವೆ: ```python lin_reg = LinearRegression() lin_reg.fit(X_train,y_train) ``` `fit` ಮಾಡಿದ ನಂತರ `LinearRegression` ವಸ್ತುವಿನಲ್ಲಿ ರಿಗ್ರೆಶನ್‌ನ ಎಲ್ಲಾ ಗುಣಾಂಕಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಅವುಗಳನ್ನು `.coef_` ಪ್ರಾಪರ್ಟಿ ಬಳಸಿ ಪ್ರವೇಶಿಸಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಒಬ್ಬೊಬ್ಬ ಗುಣಾಂಕ ಮಾತ್ರ ಇದೆ, ಅದು `-0.017` ಸುತ್ತಲೂ ಇರಬೇಕು. ಅಂದರೆ, ಬೆಲೆಗಳು ಸಮಯದ ಜೊತೆಗೆ ಸ್ವಲ್ಪ ಇಳಿಯುತ್ತಿದ್ದಂತೆ ತೋರುತ್ತದೆ, ಆದರೆ ಹೇಗಾಗಲೀ ಹೆಚ್ಚು ಅಲ್ಲ, ಪ್ರತಿ ದಿನಕ್ಕೊಂದು 2 ಸೆಂಟುಗಳಷ್ಟು. ನಾವು regression ನ intersection point ಅನ್ನು Y-ಅಕ್ಷದೊಂದಿಗೆ `lin_reg.intercept_` ಬಳಸಿ ಪಡೆಯಬಹುದು - ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಇದು ಸುತ್ತಲೂ `21` ಇರುತ್ತದೆ, ಇದು ವರ್ಷದ ಆರಂಭದಲ್ಲಿ ಬೆಲೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಮ್ಮ ಮಾದರಿಯ ಎಷ್ಟು ನಿಖರವಾಗಿದೆ ಎಂದು ನೋಡಲು, ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾ ಸೆಟ್ ಮೇಲೆ ಬೆಲೆಗಳನ್ನು ಊಹಿಸಬಹುದು, ನಂತರ ನಮ್ಮ ಊಹೆಗಳು ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯಗಳಷ್ಟಿಗೆ ಎಷ್ಟು ಹತ್ತಿರವಿದ್ದಾವೆಯೋ ಅಳೆಯಬಹುದು. ಇದನ್ನು ರೂಟ್ ಮೀನ್ ಸ್ಕ್ವೇರ್ ಎರರ್ (RMSE) ಮೆಟ್ರಿಕ್ ಬಳಸಿ ಮಾಡಬಹುದು, ಅದು ನಿರೀಕ್ಷಿತ ಮತ್ತು ಊಹಿಸಲಾದ ಮೌಲ್ಯಗಳ ನಡುವಿನ ಎಲ್ಲ ಚದರ ವ್ಯತ್ಯಾಸಗಳ ಸರಾಸರಿಯ ರೂಟ್ ಆಗಿದೆ. ```python pred = lin_reg.predict(X_test) rmse = np.sqrt(mean_squared_error(y_test,pred)) print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)') ``` ನಮ್ಮ ದೋಷವು ಸುತ್ತಲೂ 2 ಅಂಕಗಳಷ್ಟಿದೆ, ಅದು ~17% ಆಗಿದೆ. ತುಂಬಾ ಚೆನ್ನಾಗಿಲ್ಲ. ಮಾದರಿಯ ಗುಣಮಟ್ಟದ ಇನ್ನೊಂದು ಸೂಚ್ಯಂಕವು **ನಿರ್ಧಾರ коэффициент** ಆಗಿದ್ದು, ಇದನ್ನು ಈ ರೀತಿ ಪಡೆಯಬಹುದು: ```python score = lin_reg.score(X_train,y_train) print('Model determination: ', score) ``` ಅದರ ಮೌಲ್ಯವು 0 ಆಗಿದ್ದರೆ, ಅಂದರೆ ಮಾದರಿ ಒಳಮೂಲ್ಯವನ್ನು ಗಮನಿಸದಂತೆ ನಡೆಯುತ್ತದೆ, ಮತ್ತು ಇದು *ಅತ್ಯಂತ ಕೆಟ್ಟ ರೇಖೀಯ ಊಹಿಸುವಿಕೆಯಾಗುತ್ತದೆ*, ಇದು ಫಲಿತಾಂಶಗಳ ಸರಾಸರಿ ಮೌಲ್ಯ ಮಾತ್ರ. ಮೌಲ್ಯ 1 ಅಂದರೆ ನಾವು ಎಲ್ಲಾ ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಊಹಿಸಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, коэффициент ಸುತ್ತಲೂ 0.06 ಇದೆ, ಅದು ಕಡಿಮೆ. ನಾವು regression ರೇಖೆ ಜೊತೆಗೆ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಚಿತ್ರಿಸಬಹುದು, ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ regression ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆಯೋ ಹೆಚ್ಚು ಚೆನ್ನಾಗಿ ನೋಡಲು: ```python plt.scatter(X_test,y_test) plt.plot(X_test,pred) ``` Linear regression ## ಪೋಟಿನ್‌ಷಿಯಲ್ ರಿಗ್ರೆಶನ್ ಇನ್ನೊಂದು ರೀತಿಯ ಲಿನಿಯರ್ ರಿಗ್ರೆಶನ್ ಆಗಿದೆ ಪೋಟಿನ್‌ಷಿಯಲ್ ರಿಗ್ರೆಶನ್. ಕೆಲವು ಬಾರಿ ಚರಗಳ ನಡುವೆ ರೇಖೀಯ ಸಂಬಂಧವಿರಬಹುದು — ಭೌತಮಾಪನದಲ್ಲಿ ದೊಡ್ಡ ಕಿಂಬುಮಂದಿ ಇದ್ದರೆ ಬೆಲೆ ಹೆಚ್ಚು ಇರುತ್ತದೆ — ಆದರೆ ಕೆಲವು ವೇಳೆ ಈ ಸಂಬಂಧಗಳು ಸಮತಲವೋ ಅಥವಾ ಸರಳ ರೇಖೆಯಾಗಿ ಇರಲೇಬೇಕು ಅಂತಿಲ್ಲ. ✅ ಇಲ್ಲಿ [ಇನ್ನು ಕೆಲವು ಉದಾಹರಣೆಗಳು](https://online.stat.psu.edu/stat501/lesson/9/9.8) ಇವೆ ಪೋಟಿನ್ಶಿಯಲ್ ರಿಗ್ರೆಶನ್ ಬಳಸಬಹುದಾದ ಮಾಹಿತಿ ಮತ್ತೆ Date ಮತ್ತು Price ನಡುವಿನ ಸಂಬಂಧವನ್ನು ನೋಡಿ. ಈ scatterplot ಅನ್ನು ಖಂಡಿತವಾಗಿ ಸರಳ ರೇಖೆಯಿಂದ ವಿಶ್ಲೇಷಿಸಬೇಕೆಂದು ಭಾವಿಸಲಿಯೇ? ಬೆಲೆಗಳು ಕನ್ನಡದಂತೆ ಬದಲಾಗುವುದಿಲ್ಲವೆ? ಇದೇ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಪೋಟಿನ್‌ಷಿಯಲ್ ರಿಗ್ರೆಶನ್ ಪ್ರಯತ್ನಿಸಬಹುದು. ✅ ಪೋಲಿನೋಮಿಯಲ್ಸ್ ಎಂಬವು ಗಣಿತೀಯ ಸೂಚನೆಗಳು, ಅವು ಒಂದಷ್ಟು ಚರಗಳು ಮತ್ತು ಗುಣಾಂಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಪೋಟಿನ್‌ಷಿಯಲ್ ರಿಗ್ರೆಶನ್ ಅಸಮರೇಖೀಯ ಡೇಟಾವನ್ನು ಉತ್ತಮವಾಗಿ ಹೊಂದಿಸಲು ಮೃದುವಾದ ರೇಖೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು `DayOfYear` ಮುಂದಂಪು 2 ನೇ ಘಾತಾಂಶವನ್ನು ಒಳಗೊಂಡರೆ, ನಾವು ಡೇಟಾವನ್ನು ಪಾರಾಬೋಲಿಕ್ ವಕ್ರಕ್ಕೆ ಹೊಂದಿಸಬಲ್ಲವು, ಅದು ವರ್ಷದ ಕೆಲವು ಬುಗ್ಗೆಯಲ್ಲಿ ಕನಿಷ್ಠ ಅಂಶ ಹೊಂದಿರುತ್ತದೆ. ಸ್ಕೈಕಿಟ್-ಲೇನೊ ಸೇರಿಸಿದ್ದಕ್ಕೆ ಉಪಯುಕ್ತವಾದ [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ಇದೆ ವಿವಿಧ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ ಹಂತಗಳನ್ನು ಸಂಯೋಜಿಸಲು. ಒಂದು **ಪೈಪ್ಲೈನ್** ಎಂದರೆ **ಎಸ್ಟಿಮೇಟರ್ಸ್** ಸರಪಳಿಯಾಗಿದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು ಮೊದಲಿಗೆ ಬಾಹುಘಾತ ځانګಣಗಳನ್ನು ಸೇರಿಸುವ ಪೈಪ್ಲೈನ್ ಸೃಷ್ಟಿಸಿ, ನಂತರ regression ತರಬೇತಿನ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ: ```python from sklearn.preprocessing import PolynomialFeatures from sklearn.pipeline import make_pipeline pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression()) pipeline.fit(X_train,y_train) ``` `PolynomialFeatures(2)` ಬಳಸಿ ಅಂದರೆ ನಾವು ಒಳಪಡಿಸುವ ಎಲ್ಲಾ 2ನೇ ಶ್ರೇಣಿಯ ಪೋಲಿನೋಮಿಯಲ್ಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ನಮ್ಮಲ್ಲಿ ಅದು `DayOfYear`2 ಮಾತ್ರವಾಗಿರುತ್ತದೆ, ಆದರೆ ಎರಡು ಇನ್‌ಪುಟ್ ಚರಗಳು X ಮತ್ತು Y ಇದ್ದರೆ, ಅದು X2, XY ಮತ್ತು Y2 ಸೇರಿಸುತ್ತದೆ. ನಾವು ಇನ್ನೂ ಹೆಚ್ಚಿನ ಘಾತಾಂಶಗಳನ್ನು ಬಳಸಬಹುದು ಬೇಕಾದರೆ. ಪೈಪ್ಲೈನ್‌ಗಳನ್ನು ಮೂಲ `LinearRegression` ವಸ್ತುವಿನ ಹಾಗೆ ಬಳಸಿ, ಅಂದರೆ ನಾವು ಪೈಪ್ಲೈನ್ ಅನ್ನು `fit` ಮಾಡಿ, ನಂತರ `predict` ಬಳಸಿ ಊಹಿಸಬಹುದು. ಇದು ಪರೀಕ್ಷಾ ಡೇಟಾ ಮತ್ತು ಅನುಮಾನ ತುಂಬಿದ ವಕ್ರವನ್ನ ತೋರಿಸುವ ಗ್ರಾಫ್ ಆಗಿದೆ: Polynomial regression ಪೋಟಿನ್‌ಷಿಯಲ್ ರಿಗ್ರೆಶನ್ ಬಳಸಿ, ನಾವು ಸ್ವಲ್ಪ ಕಡಿಮೆ MSE ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ಧಾರ коэффициент ಪಡೆಯಬಹುದು, ಆದರೆ ಗಮನಾರ್ಹವಾಗಿ ಅಲ್ಲ. ನಾವು ಇತರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಗಮನಿಸಬೇಕಾಗುತ್ತದೆ! > ನೀವು ನೋಡಬಹುದು ಕನಿಷ್ಠ ಕಿಂಬುಮಂದಿ ಬೆಲೆಗಳು ಹ್ಯಾಲೋವೀನ್ ಸಮಯದಲ್ಲಿ ಕಂಡುಬರುತ್ತವೆ. ಇದನ್ನು ಹೇಗೆ ವಿವರಿಸಬಹುದು? 🎃 ಅಭಿನಂದನೆಗಳು, ನೀವು ಪೈ ಕಿಂಬುಮಂದಿಗಳ ಬೆಲೆಯನ್ನು ಊಹಿಸಲು ಸಹಾಯ ಮಾಡುವ ಮಾದರಿಯನ್ನು ಸೃಷ್ಟಿಸಿದ್ದೀರಿ. ನೀವು ಬಹುಮಾನಿತವಾಗಿ ಎಲ್ಲ ಕಿಂಬುಮಂದಿ ಪ್ರಭೇದಗಳಿಗೆ ಇದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಬಹುದು, ಆದರೆ ಅದು ತುಚ್ಛಮಾಡುತ್ತದೆ. ಈಗ ನಾವು ಹೇಗೆ ಕಿಂಬುಮಂದಿ ಪ್ರಭೇದಗಳನ್ನು ನಮೂದಿನಲ್ಲಿಯೇ ಸೇರಿಸಬೇಕೆಂದು ಕಲಿಯೋಣ! ## ವರ್ಗೀಕೃತ ಗುಣಲಕ್ಷಣಗಳು ಐಡಿಯಲ್ ಲೋಕದಲ್ಲಿ, ನಾವು ಬಿನ್ನಹಗಳ ಬೆಲೆಗಳನ್ನು ವಿಭಿನ್ನ ಬಗೆಯ ಕಿಂಬುಮಂದಿಗಳಿಗೆ ಒಂದೇ ಮಾದರಿಯಿಂದ ಊಹಿಸಬಯಸುತ್ತೇವೆ. ಆದಾಗ್ಯೂ, `Variety` ಕಾಲಮ್ ಯಾವುದೋ ವಿಭಿನ್ನವಾಗಿದೆ, ಅದು `Month` ಬಗೆಗಿನ ಕಾಲಂಗಳಂತೆಯೇ ಅಲ್ಲ, ಏಕೆಂದರೆ ಅದು ಸಂಖ್ಯೆ ಆಧಾರಿತ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಲ್ಲ. ಇಂತಹ ಕಾಲಂಗಳನ್ನು **ವರ್ಗೀಕೃತ** ಎಂದು ಕರೆಯುತ್ತಾರೆ. [![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression") > 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ವರ್ಗೀಕೃತ ಲಕ್ಷಣಗಳ ಬಳಕೆ ಕುರಿತು ಸಣ್ಣ ವಿಡಿಯೋ ಪರಿಚಯವನ್ನು ವೀಕ್ಷಿಸಿ. ಇಲ್ಲಿ ನೀವು ಮುಂದೆ ನೋಡಬಹುದು ಸರಾಸರಿ ಬೆಲೆ ಪ್ರಭೇದಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ: Average price by variety ವಿಭಿನ್ನತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮೊದಲು ನಾವಿಗೆ ಅದನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ರೂಪಕ್ಕೆ ಪರಿವರ್ತನೆ ಮಾಡಬೇಕು, ಅದನ್ನು **ಎಂಕೋಡ್** ಮಾಡಬೇಕು. ಇದಕ್ಕಾಗಿ ಕೆಲವು ವಿಧಾನಗಳಿವೆ: * ಸರಳ **ಸಂಖ್ಯಾ ಎಂಕೋಡಿಂಗ್** ವಿಭಿನ್ನ ಪ್ರಭೇದಗಳ ಪಟ್ಟಿಯನ್ನು ನಿರ್ಮಿಸಿ, ನಂತರ ಪ್ರಭೇದದ ಹೆಸರನ್ನು ಅದರಲ್ಲಿ ಎಂಬ ಸೂಚ್ಯಂಕದಿಂದ ಬದಲಿಸುವುದು. ಇದು ಲಿನಿಯರ್ ರಿಗ್ರೆಶನಿಗಾಗಿ ಉತ್ತಮ ಕಲ್ಪನೆ ಅಲ್ಲ, ಏಕೆಂದರೆ ಲಿನಿಯರ್ ರಿಗ್ರೆಶನ್ ಸೂಚ್ಯಂಕದ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯವನ್ನು ತೆಗೆದು, ಅದನ್ನು ಗುಣಾಂತರದೊಂದಿಗೆ ಫಲಿತಾಂಶಕ್ಕೆ ಸೇರುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆಯು ಬೆಲೆಯೊಂದಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಅಸಮರೇಶೀಯವಾಗಿದೆ, אף ಆಗ ನಾವು ಸೂಚ್ಯಂಕಗಳನ್ನು ವಿಶೇಷ ರೀತಿಯಲ್ಲಿ ಕ್ರಮಗೊಳಿಸಿದರೂ ಸಹ. * **ಒನ್-ಹಾಟ್ ಎಂಕೋಡಿಂಗ್** `Variety` ಕಾಲಮ್ ಅನ್ನು 4 ಬಿನ್ನಹಗಳಿಗೆ, ಪ್ರತಿ ಒಂದು ಪ್ರಭೇದಕ್ಕೆ ಒಂದು ಕಾಲಮ್ ಅನ್ನು ಬದಲಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಕಾಲಮ್ ಅನ್ನು `1` ಇಡುತ್ತದೆ ಆ ಸಾಲು ಆ ನಿರ್ದಿಷ್ಟ ಪ್ರಭೇದಕ್ಕೆ ಸೇರಿದರೆ, ಇಲ್ಲದಿದ್ದರೆ `0`. ಅಂದರೆ ಲಿನಿಯರ್ ರಿಗ್ರೆಶನ್ ನಲ್ಲಿ ನಾಲ್ಕು ಗುಣಾಂಕಗಳಿರುತ್ತವೆ, ಪ್ರತಿ ಕಿಂಬುಮಂದಿ ಪ್ರಭೇದಕ್ಕೆ ಒಂದು, ಅದರ “ಆರಂಭ ಬೆಲೆ” (ಅಥವಾ “ಸಂಬಂಧಿತ ಹೆಚ್ಚುವರಿ ಬೆಲೆ”) ನಿಗದಿಮಾಡುತ್ತದೆ. ಕೆಳಗಿನ ಕೋಡ್ ಒನ್-ಹಾಟ್ ಎಂಕೋಡಿಂಗ್ ಹೇಗೆ ಮಾಡಬಹುದು ತೋರಿಸುತ್ತದೆ: ```python pd.get_dummies(new_pumpkins['Variety']) ``` ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE ----|-----------|-----------|--------------------------|---------- 70 | 0 | 0 | 0 | 1 71 | 0 | 0 | 0 | 1 ... | ... | ... | ... | ... 1738 | 0 | 1 | 0 | 0 1739 | 0 | 1 | 0 | 0 1740 | 0 | 1 | 0 | 0 1741 | 0 | 1 | 0 | 0 1742 | 0 | 1 | 0 | 0 ಒನ್-ಹಾಟ್ ಎಂಕೋಡ್ ಮಾಡಿದ variety ನೊಂದಿಗೆ ಲಿನಿಯರ್ ರಿಗ್ರೆಶನ್ ತರಬೇತಿಗೆ `X` ಮತ್ತು `y` ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಆರಂಭಿಸೋಣ: ```python X = pd.get_dummies(new_pumpkins['Variety']) y = new_pumpkins['Price'] ``` ಕೋಡ್ ಇದನ್ನು ಮಾಡುವುದು ಲಿನಿಯರ್ ರಿಗ್ರೆಶನ್ ತರಬೇತಿಗೆಮೇಲಿನಂತೆಯೇ. ನೀವು ಪ್ರಯತ್ನಿಸಿದರೆ, ನೀವು ಸುತ್ತಲೂ ಸಮಾನ ದೋಷ (MSE) ಮತ್ತು ಹೆಚ್ಚಿನ ನಿರ್ಧಾರ коэффициcent (~77%) ನೋಡಬಹುದು. ಇನ್ನೂ ನಿಖರ ಊಹೆಗಳಿಗೆ, ನಾವು ಇನ್ನಷ್ಟು ವರ್ಗೀಕೃತ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮತ್ತು ಸಂಖ್ಯಾತ್ಮಕ ಗುಣಲಕ್ಷಣಗಳನ್ನು (ಹಾಗು `Month`, `DayOfYear` ಮುಂತಾದ) ಸೇರಿಸಬಹುದು. ಒಂದೇ ದೊಡ್ಡ ಗುಣಲಕ್ಷಣ ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯಲು, ನಾವು `join` ಬಳಸಬಹುದು: ```python X = pd.get_dummies(new_pumpkins['Variety']) \ .join(new_pumpkins['Month']) \ .join(pd.get_dummies(new_pumpkins['City'])) \ .join(pd.get_dummies(new_pumpkins['Package'])) y = new_pumpkins['Price'] ``` ಇಲ್ಲಿ ನಾವು `City` ಮತ್ತು `Package` ಪ್ರಕಾರವನ್ನು ಕೂಡ ಸೇರಿಸುತ್ತೇವೆ, ಇದು MSE 2.84 (10%), ಮತ್ತು ನಿರ್ಧಾರ 0.94 ಇರಿಸುತ್ತದೆ! ## ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಸೇರಿಸುವುದು ಉತ್ತಮ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು, ನಾವು ಮೇಲಿನ ಉದಾಹರಣೆಯ (ಒನ್-ಹಾಟ್ ಎಂಕೋಡ್ ಮಾಡಿದ ವರ್ಗೀಕೃತ + ಸಂಖ್ಯಾತ್ಮಕ) ಡೇಟಾ ಪೋಟಿನ್‌ಷಿಯಲ್ ರಿಗ್ರೆಶನ್ ಜೊತೆಗೆ ಬಳಸಿ. ಇದು ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕಾಗಿ ಸಂಪೂರ್ಣ ಕೋಡ್: ```python # ತರಬೇತಿ ಡೇಟಾ ವ್ಯವಸ್ಥೆಯೋಡಿಸಲಾಗುತ್ತದೆ X = pd.get_dummies(new_pumpkins['Variety']) \ .join(new_pumpkins['Month']) \ .join(pd.get_dummies(new_pumpkins['City'])) \ .join(pd.get_dummies(new_pumpkins['Package'])) y = new_pumpkins['Price'] # ತರಬೇತಿ-ಪರೀಕ್ಷೆ ವಿಭಾಜನೆ ಮಾಡಿ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) # ನಿಮಿಷಾ ಮತ್ತು ತರಬೇತಿ ಪೈಪ್ಲೈನ್ ವ್ಯವಸ್ಥೆಯೋಡಿಸಿ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression()) pipeline.fit(X_train,y_train) # ಪರೀಕ್ಷಾ ಡೇಟಾ ಫಲಿತಾಂಶಗಳನ್ನು ಭವಿಷ್ಯ ವಾಣಿ ಮಾಡಿ pred = pipeline.predict(X_test) # MSE ಮತ್ತು ನಿರ್ಧಾರ ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ mse = np.sqrt(mean_squared_error(y_test,pred)) print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') score = pipeline.score(X_train,y_train) print('Model determination: ', score) ``` ಇದು ನಮಗೆ ಅತ್ಯುತ್ತಮ ನಿರ್ಧಾರ коэффициcent ಸುತ್ತಲೂ 97%, ಮತ್ತು MSE=2.23 (~8% ಊಹೆ ದೋಷ) ಕೊಡಬೇಕು. | ಮಾದರಿ | MSE | ನಿರ್ಧಾರ | |-------|-----|---------| | `DayOfYear` ಲಿನಿಯರ್ | 2.77 (17.2%) | 0.07 | | `DayOfYear` ಪೋಲಿನೋಮಿಯಲ್ | 2.73 (17.0%) | 0.08 | | `Variety` ಲಿನಿಯರ್ | 5.24 (19.7%) | 0.77 | | ಎಲ್ಲ ಗುಣಲಕ್ಷಣಗಳು ಲಿನಿಯರ್ | 2.84 (10.5%) | 0.94 | | ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳು ಪೋಲಿನೋಮಿಯಲ್ | 2.23 (8.25%) | 0.97 | 🏆 ಚೆನ್ನಾಗಿದೆ! ನೀವು ಒಂದೇ ಪಾಠದಲ್ಲಿ ನಾಲ್ಕು regression ಮಾದರಿಗಳನ್ನು ಸೃಷ್ಟಿಸಿದಿರಿ, ಮತ್ತು ಮಾದರಿಯ ಗುಣಮಟ್ಟವನ್ನು 97% ಗೆ ಸುಧಾರಿಸಿದಿರಿ. regression ನ ಕೊನೆಯ ವಿಭಾಗದಲ್ಲಿ, ನೀವು ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ಧರಿಸಲು Logistic Regression ಕುರಿತು ಕಲಿಯುತ್ತೀರಿ. --- ## 🚀ಚಲೆಂಜ್ ಈ ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ ವಿಭಿನ್ನ ಚರಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ ನೋಡಿರಿ, ಸಹಸಂಬಂಧ ಮಾದರಿಯ ճշտತೆಗೆ ಹೇಗಿದೆ ಎಂದು. ## [ಪಾಠೋತ್ತರ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/) ## ಪರಿಚಯ & ಸ್ವ-अಧ್ಯಯನ ಈ ಪಾಠದಲ್ಲಿ ನಾವು ಲಿನಿಯರ್ ರಿಗ್ರೆಶನ್ ಬಗ್ಗೆ ಕಲಿತೇವೆ. ಇತರ ಪ್ರಮುಖ ರಿಗ್ರೆಶನ್ ಪ್ರಕಾರಗಳಿವೆ. Stepwise, Ridge, Lasso ಮತ್ತು Elasticnet ತಂತ್ರಗಳ ಕುರಿತು ಓದು. ಇನ್ನಷ್ಟು ತಿಳಿಯಲು ಉತ್ತಮ ಪಾಠವೊಂದಾಗಿದೆ [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ## ಹಂತವಾರು ಕೃತಿ [ಮಾದರಿ ನಿರ್ಮಿಸಿ](assignment.md) --- **ತಪ್ಪು ನಿವಾರಣೆ**: ಈ ದಾಖಲೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಗಾಗಿ ಪ್ರಯತ್ನಿಸಿದರೂ ಸಹ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಸುಳ್ಳು ಮಾಹಿತಿಗಳು ಇರಬಹುದೆಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ದಸ್ತಾವೇಜು ಅದರ ಸ್ವಭಾವಿಕ ಜನರ ಭಾಷೆಯಲ್ಲಿ ಅಧಿಕಾರದ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗೆ, ನಿಪುಣ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ಗೊಂದಲಗಳಿಗೆ ಅಥವಾ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.