msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity

chore(i18n): sync translations with latest source changes (chunk 1/1, 12 changes)

Browse Source
update-translations
localizeflow[bot] 4 weeks ago
parent 98394876e6
commit 4efb2e21ed
12 changed files with 785 additions and 641 deletions
Show Stats Download Patch File Download Diff File

14
translations/pa/.co-op-translator.json
Unescape View File

@ -36,8 +36,8 @@
"language_code": "pa"
},
"1-Introduction/4-techniques-of-ML/README.md": {
"original_hash": "9d91f3af3758fdd4569fb410575995ef",
"translation_date": "2025-09-06T07:04:42+00:00",
"original_hash": "84b1715a6be62ef1697351dcc5d7b567",
"translation_date": "2026-04-26T18:39:45+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
"language_code": "pa"
},
@ -90,8 +90,8 @@
"language_code": "pa"
},
"2-Regression/3-Linear/README.md": {
"original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
"translation_date": "2026-04-20T18:53:29+00:00",
"original_hash": "8b776e731c35b171d316d01d0e7b1369",
"translation_date": "2026-04-26T18:39:02+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "pa"
},
@ -107,6 +107,12 @@
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
"language_code": "pa"
},
"2-Regression/3-Linear/solution/notebook.ipynb": {
"original_hash": "6781223ffbe8cfdaa38d0200f08e1288",
"translation_date": "2026-04-26T18:36:53+00:00",
"source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
"language_code": "pa"
},
"2-Regression/4-Logistic/README.md": {
"original_hash": "abf86d845c84330bce205a46b382ec88",
"translation_date": "2025-09-06T06:48:36+00:00",

129
translations/pa/1-Introduction/4-techniques-of-ML/README.md
Unescape View File

@ -1,80 +1,125 @@
# ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੇ ਤਕਨੀਕਾਂ
# ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੀਆਂ ਤਕਨੀਕਾਂ
ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ, ਵਰਤਣ ਅਤੇ ਰੱਖ-ਰਖਾਵ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਉਹ ਡਾਟਾ ਜੋ ਇਹ ਮਾਡਲ ਵਰਤਦੇ ਹਨ, ਕਈ ਹੋਰ ਵਿਕਾਸ ਕਾਰਜਪ੍ਰਣਾਲੀਆਂ ਤੋਂ ਬਹੁਤ ਵੱਖਰੀ ਹੈ। ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਪਸ਼ਟ ਕਰਾਂਗੇ ਅਤੇ ਮੁੱਖ ਤਕਨੀਕਾਂ ਦੀ ਰੂਪਰੇਖਾ ਪੇਸ਼ ਕਰਾਂਗੇ ਜੋ ਤੁਹਾਨੂੰ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ। ਤੁਸੀਂ:
ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ, ਵਰਤਣ ਅਤੇ ਸੰਭਾਲਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਉਹ ਡਾਟਾ ਜੋ ਇਹ ਵਰਤਦੇ ਹਨ, ਬਹੁਤ ਵੱਖਰੀ ਪ੍ਰਕਿਰਿਆ ਹੈ ਬਾਕੀ ਕਈ ਦੂਜੇ ਵਿਕਾਸ ਕੌਰਸਾਂ ਤੋਂ। ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਧਾਰਣ ਕਰਾਂਗੇ, ਅਤੇ ਮੁੱਖ ਤਕਨੀਕਾਂ ਨੂੰ ਰੂਪਰੇਖਾ ਵਿੱਚ ਪੇਸ਼ ਕਰਾਂਗੇ ਜੋ ਤੁਹਾਨੂੰ ਜਾਣਣੀ ਲਾਜ਼ਮੀ ਹਨ। ਤੁਸੀਂ:
- ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੇ ਅਧਾਰਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਉੱਚ ਪੱਧਰ 'ਤੇ ਸਮਝੋਗੇ।
- 'ਮਾਡਲ', 'ਪ੍ਰਿਡਿਕਸ਼ਨ', ਅਤੇ 'ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ' ਵਰਗੇ ਬੁਨਿਆਦੀ ਧਾਰਨਾਵਾਂ ਦੀ ਖੋਜ ਕਰੋਗੇ।
- ਉੱਚ ਪੱਧਰ 'ਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੇ ਅਧਾਰਭੂਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸਮਝੋਗੇ।
- 'ਮਾਡਲ', 'ਭਵਿੱਖਬਾਣੀਆਂ', ਅਤੇ 'ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ' ਵਰਗੀਆਂ ਮੂਢ ਤਕਨੀਕਾਂ ਦੀ ਖੋਜ ਕਰੋਂਗੇ।
## [ਪ੍ਰੀ-ਲੈਕਚਰ ਕਵਿਜ਼](https://ff-quizzes.netlify.app/en/ml/)
## [ਪ੍ਰੀ-ਲੇਕਚਰ ਕਿਊਜ਼](https://ff-quizzes.netlify.app/en/ml/)
[![ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਲਈ ਸ਼ੁਰੂਆਤੀ - ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੇ ਤਕਨੀਕਾਂ](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਲਈ ਸ਼ੁਰੂਆਤੀ - ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੇ ਤਕਨੀਕਾਂ")
[![ML for beginners - Techniques of Machine Learning](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML for beginners - Techniques of Machine Learning")
> 🎥 ਉਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿਕ ਕਰੋ ਇਸ ਪਾਠ ਨੂੰ ਸਮਝਣ ਲਈ ਇੱਕ ਛੋਟੀ ਵੀਡੀਓ ਦੇਖਣ ਲਈ।
> 🎥 ਇਸ ਪਾਠ ਨੂੰ ਸਮਝਾਉਂਦੇ ਛੋਟੇ ਵੀਡੀਓ ਲਈ ਉਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿਕ ਕਰੋ।
## ਪਰਿਚਯ
ਉੱਚ ਪੱਧਰ 'ਤੇ, ਮਸ਼ੀਨ ਲਰਨਿੰਗ (ML) ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਣਾਉਣ ਦੀ ਕਲਾ ਕਈ ਕਦਮਾਂ 'ਤੇ ਆਧਾਰਿਤ ਹੈ:
ਸਰਵੋচ্চ ਪੱਧਰ 'ਤੇ, ਮਸ਼ੀਨ ਲਰਨਿੰਗ (ML) ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਣਾਉਣ ਦਾ ਹੁਨਰ ਕਈ ਕਦਮਾਂ 'ਤੇ مشتمل ਹੁੰਦਾ ਹੈ:
1. **ਸਵਾਲ ਤੈਅ ਕਰੋ**। ਜ਼ਿਆਦਾਤਰ ML ਪ੍ਰਕਿਰਿਆਵਾਂ ਇੱਕ ਸਵਾਲ ਪੁੱਛਣ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਸਧਾਰਨ ਸ਼ਰਤਾਂ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮ ਜਾਂ ਨਿਯਮ-ਅਧਾਰਿਤ ਇੰਜਨ ਦੁਆਰਾ ਹੱਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ। ਇਹ ਸਵਾਲ ਅਕਸਰ ਡਾਟਾ ਦੇ ਇਕੱਠ 'ਤੇ ਆਧਾਰਿਤ ਅਨੁਮਾਨਾਂ ਦੇ ਆਸ-ਪਾਸ ਹੁੰਦੇ ਹਨ।
2. **ਡਾਟਾ ਇਕੱਠਾ ਕਰੋ ਅਤੇ ਤਿਆਰ ਕਰੋ**। ਆਪਣੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਤੁਹਾਨੂੰ ਡਾਟਾ ਦੀ ਲੋੜ ਹੈ। ਤੁਹਾਡੇ ਡਾਟਾ ਦੀ ਗੁਣਵੱਤਾ ਅਤੇ ਕਈ ਵਾਰ ਮਾਤਰਾ ਇਹ ਤੈਅ ਕਰੇਗੀ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਮੁਢਲੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਕਿੰਨਾ ਚੰਗਾ ਦੇ ਸਕਦੇ ਹੋ। ਡਾਟਾ ਨੂੰ ਵਿਜ਼ੁਅਲਾਈਜ਼ ਕਰਨਾ ਇਸ ਚਰਨ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਲੂ ਹੈ। ਇਸ ਚਰਨ ਵਿੱਚ ਡਾਟਾ ਨੂੰ ਟ੍ਰੇਨਿੰਗ ਅਤੇ ਟੈਸਟਿੰਗ ਸਮੂਹ ਵਿੱਚ ਵੰਡਣਾ ਵੀ ਸ਼ਾਮਲ ਹੈ ਤਾਂ ਜੋ ਮਾਡਲ ਬਣਾਇਆ ਜਾ ਸਕੇ।
3. **ਟ੍ਰੇਨਿੰਗ ਵਿਧੀ ਚੁਣੋ**। ਤੁਹਾਡੇ ਸਵਾਲ ਅਤੇ ਡਾਟਾ ਦੀ ਪ੍ਰਕਿਰਤੀ ਦੇ ਆਧਾਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਇਹ ਚੁਣਨਾ ਪਵੇਗਾ ਕਿ ਮਾਡਲ ਨੂੰ ਕਿਵੇਂ ਟ੍ਰੇਨ ਕਰਨਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਤੁਹਾਡੇ ਡਾਟਾ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਦਰਸਾ ਸਕੇ ਅਤੇ ਇਸ 'ਤੇ ਸਹੀ ਅਨੁਮਾਨ ਲਗਾ ਸਕੇ।
4. **ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰੋ**। ਆਪਣੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਐਲਗੋਰਿਥਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਡਲ ਨੂੰ ਡਾਟਾ ਵਿੱਚ ਪੈਟਰਨਾਂ ਨੂੰ ਪਛਾਣਨ ਲਈ ਟ੍ਰੇਨ ਕਰਦੇ ਹੋ। ਮਾਡਲ ਅੰਦਰੂਨੀ ਵਜ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਡਾਟਾ ਦੇ ਕੁਝ ਹਿੱਸਿਆਂ ਨੂੰ ਹੋਰਾਂ ਦੇ ਉੱਤੇ ਤਰਜੀਹ ਦੇਣ ਲਈ ਸਮਰਥਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
5. **ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਨ ਕਰੋ**। ਤੁਸੀਂ ਆਪਣੇ ਇਕੱਠੇ ਕੀਤੇ ਸੈਟ ਵਿੱਚੋਂ ਪਹਿਲਾਂ ਕਦੇ ਨਾ ਦੇਖੇ ਡਾਟਾ (ਆਪਣੇ ਟੈਸਟਿੰਗ ਡਾਟਾ) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਤਾਂ ਜੋ ਦੇਖਿਆ ਜਾ ਸਕੇ ਕਿ ਮਾਡਲ ਕਿਵੇਂ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।
6. **ਪੈਰਾਮੀਟਰ ਟਿਊਨਿੰਗ**। ਆਪਣੇ ਮਾਡਲ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਆਧਾਰ 'ਤੇ, ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਪੈਰਾਮੀਟਰ ਜਾਂ ਵੈਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੁਬਾਰਾ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਵਰਤੇ ਗਏ ਐਲਗੋਰਿਥਮ ਦੇ ਵਿਹਾਰ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹਨ।
7. **ਪ੍ਰਿਡਿਕਟ ਕਰੋ**। ਨਵੇਂ ਇਨਪੁਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਮਾਡਲ ਦੀ ਸਹੀਤਾ ਦੀ ਜਾਂਚ ਕਰੋ।
1. **ਸਵਾਲ ਨਿਰਧਾਰਤ ਕਰੋ**। ਜ਼ਿਆਦਾਤਰ ML ਪ੍ਰਕਿਰਿਆਵਾਂ ਕਿਸੇ ਸਵਾਲ ਨੂੰ ਪੁੱਛ ਕੇ ਸ਼ੁਰੂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਇੱਕ ਸਧਾਰਨ ਸਸ਼ਰਤੀ ਪ੍ਰੋਗਰਾਮ ਜਾਂ ਨਿਯਮ-ਅਧਾਰਿਤ ਇੰਜਣ ਦੁਆਰਾ ਜਵਾਬ ਨਹੀਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ। ਇਹ ਸਵਾਲ ਅਕਸਰ ਡਾਟਾ ਦੇ ਸੰਗ੍ਰਹਿ 'ਤੇ ਆਧਾਰਤ ਭਵਿੱਖਬਾਣੀਆਂ ਨਾਲ ਸੰਬੰਧਿਤ ਹੁੰਦੇ ਹਨ।
2. **ਡਾਟਾ ਇਕੱਠਾ ਕਰੋ ਅਤੇ ਤਿਆਰ ਕਰੋ**। ਆਪਣੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਤੁਹਾਨੂੰ ਡਾਟਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਡੇ ਡਾਟਾ ਦੀ ਗੁਣਵੱਤਾ ਅਤੇ ਕਈ ਵਾਰੀ ਮਾਤਰਾ ਵੀ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਸ਼ੁਰੂਆਤੀ ਸਵਾਲ ਦਾ ਕਿੰਨਾ ਚੰਗਾ ਜਵਾਬ ਦੇ ਸਕਦੇ ਹੋ। ਡਾਟਾ ਨੂੰ ਵਿਜ਼ੂਅਲਾਈਜ਼ ਕਰਨਾ ਕੇ ਇਸ ਪੜਾਅ ਦਾ ਅਹਿਮ ਹਿੱਸਾ ਹੈ। ਇਹ ਪੜਾਅ ਡਾਟਾ ਨੂੰ ਟ੍ਰੇਨਿੰਗ ਅਤੇ ਟੈਸਟਿੰਗ ਗਰੁੱਪ ਵਿੱਚ ਵੰਡਣ ਨੂੰ ਵੀ ਸਮਾਵੇਸ਼ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਮਾਡਲ ਬਣਾਇਆ ਜਾ ਸਕੇ।
3. **ਟ੍ਰੇਨਿੰਗ ਮੈਥਡ ਚੁਣੋ**। ਤੁਹਾਡੇ ਸਵਾਲ ਅਤੇ ਡਾਟਾ ਦੀ ਕਿਸਮ dian ਅਧਾਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਇਹ ਚੁਣਨਾ ਪਵੇਗਾ ਕਿ ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਕਿਵੇਂ ਟ੍ਰੇਨ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਜੋ ਇਹ ਤੁਹਾਡੇ ਡਾਟਾ ਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਦਰਸਾਉਂਦੇ ਹੋਏ ਸਹੀ ਭਵਿੱਖਬਾਣੀਆਂ ਕਰ ਸਕੇ। ਇਹ ਉਹ ਹਿੱਸਾ ਹੈ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਵਿਸ਼ੇਸ਼ਤਾ ਅਤੇ ਅਕਸਰ ਕਾਫੀ ਪ੍ਰਯੋਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
4. **ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰੋ**। ਆਪਣੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਅਲਗੋਰਿਧਮਾਂ ਦੇ ਸਹਾਰੇ ਮਾਡਲ ਨੂੰ ਡਾਟਾ ਵਿੱਚ ਪੈਟਰਨਜ਼ ਪਛਾਣਨ ਲਈ ਟ੍ਰੇਨ ਕਰੋਗੇ। ਮਾਡਲ ਅੰਦਰੂਨੀ ਵਜਨ ਵਰਤ ਸਕਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ताकि ਕੁਝ ਹਿੱਸਿਆਂ ਨੂੰ ਵੱਧ ਪਸੰਦ ਦਿੱਤੀ ਜਾ ਸਕੇ ਅਤੇ ਹੋਰਾਂ ਨਾਲੋਂ ਬਿਹਤਰ ਮਾਡਲ ਬਣ ਸਕੇ।
5. **ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ**। ਤੁਸੀਂ ਕਦੇ ਵੀ ਨਹੀਂ ਵੇਖੇ ਡਾਟਾ (ਆਪਣੇ ਟੈਸਟਿੰਗ ਡਾਟਾ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੇਖੋਗੇ ਕਿ ਮਾਡਲ ਕਿਵੇਂ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।
6. **ਪੈਰਾਮੀਟਰ ਟਿਊਨਿੰਗ**। ਆਪਣੇ ਮਾਡਲ ਦੇ ਪਰਦਰਸ਼ਨ ਦੇ ਆਧਾਰ 'ਤੇ, ਤੁਸੀਂ ਵੱਖਰੇ ਪੈਰਾਮੀਟਰ ਜਾਂ ਵੈਰੀਏਬਲਾਂ ਨੂੰ ਬਦਲ ਕੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੁਬਾਰਾ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਉਸ ਅਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਜੋ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਦਾ ਹੈ।
7. **ਭਵਿੱਖਬਾਣੀ ਕਰੋ**। ਨਵੇਂ ਇਨਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਮਾਡਲ ਦੀ ਸ਼ੁੱਧਤਾ ਦੀ ਜਾਂਚ ਕਰੋ।
## ਕਿਹੜਾ ਸਵਾਲ ਪੁੱਛਣਾ ਹੈ
## ਕਿਹੜਾ ਸਵਾਲ ਪੂਛਣਾ ਹੈ
ਕੰਪਿਊਟਰ ਡਾਟਾ ਵਿੱਚ ਲੁਕੇ ਹੋਏ ਪੈਟਰਨਾਂ ਦੀ ਖੋਜ ਕਰਨ ਵਿੱਚ ਖਾਸ ਤੌਰ 'ਤੇ ਨਿਪੁਣ ਹੁੰਦੇ ਹਨ। ਇਹ ਯੋਗਤਾ ਖੋਜਕਰਤਿਆਂ ਲਈ ਬਹੁਤ ਮਦਦਗਾਰ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਕਿਸੇ ਦਿੱਤੇ ਖੇਤਰ ਬਾਰੇ ਸਵਾਲ ਹੁੰਦੇ ਹਨ ਜੋ ਸਧਾਰਨ ਨਿਯਮ-ਅਧਾਰਿਤ ਇੰਜਨ ਬਣਾਉਣ ਦੁਆਰਾ ਆਸਾਨੀ ਨਾਲ ਹੱਲ ਨਹੀਂ ਕੀਤੇ ਜਾ ਸਕਦੇ। ਉਦਾਹਰਣ ਲਈ, ਇੱਕ ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਸਿਗਰਟ ਪੀਣ ਵਾਲਿਆਂ ਅਤੇ ਨਾ ਪੀਣ ਵਾਲਿਆਂ ਦੀ ਮੌਤ ਦਰ ਦੇ ਆਧਾਰ 'ਤੇ ਹੱਥੋਂ ਬਣਾਏ ਨਿਯਮਾਂ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋ ਸਕਦੇ ਹਨ।
ਕੰਪਿਊਟਰ ਡਾਟਾ ਵਿੱਚ ਛੁਪੇ ਹੋਏ ਪੈਟਰਨ ਖੋਜਣ ਵਿੱਚ ਕਾਬਿਲ ਹੁੰਦੇ ਹਨ। ਇਹ ਉਪਯੋਗਤਾ ਉਨ੍ਹਾਂ ਵਿਗਿਆਨੀਆਂ ਲਈ ਬਹੁਤ ਲਾਹੇਵੰਦ ਹੈ ਜਿਨ੍ਹਾਂ ਕੋਲ ਕਿਸੇ ਖੇਤਰ ਬਾਰੇ ਅਜਿਹੇ ਸਵਾਲ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਜਵਾਬ ਅਸਾਨੀ ਨਾਲ ਕਿਸੇ ਨਿਯਮ-ਅਧਾਰਿਤ ਇੰਜਣ ਨਾਲ ਨਹੀਂ ਮਿਲ ਸਕਦਾ। ਉਦਾਹਰਨ ਵਜੋਂ, ਇੱਕ ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਧੂമ੍ਰਪਾਨ ਕਰਨ ਵਾਲਿਆਂ ਵਿਰੁੱਧ ਅਧਧੂਮ੍ਰਪਾਨ ਕਰਨ ਵਾਲਿਆਂ ਦੀ ਮੌਤ ਦਰ ਬਾਰੇ ਹੱਥ-ਨਿਰਮਿਤ ਨਿਯਮ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋ ਸਕਦਾ ਹੈ।
ਜਦੋਂ ਕਈ ਹੋਰ ਵੈਰੀਏਬਲਾਂ ਨੂੰ ਸਮੀਕਰਨ ਵਿੱਚ ਲਿਆਂਦਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ML ਮਾਡਲ ਪਿਛਲੇ ਸਿਹਤ ਇਤਿਹਾਸ ਦੇ ਆਧਾਰ 'ਤੇ ਭਵਿੱਖ ਦੀ ਮੌਤ ਦਰਾਂ ਦੀ ਪੇਸ਼ਗੋਈ ਕਰਨ ਲਈ ਹੋਰ ਕੁਸ਼ਲ ਸਾਬਤ ਹੋ ਸਕਦਾ ਹੈ। ਇੱਕ ਹੋਰ ਖੁਸ਼ੀਦਾਇਕ ਉਦਾਹਰਣ ਅਪ੍ਰੈਲ ਮਹੀਨੇ ਵਿੱਚ ਕਿਸੇ ਦਿੱਤੇ ਸਥਾਨ ਲਈ ਮੌਸਮ ਦੀ ਪੇਸ਼ਗੋਈ ਕਰਨਾ ਹੋ ਸਕਦਾ ਹੈ, ਜੋ ਡਾਟਾ ਵਿੱਚ ਲੈਟੀਟਿਊਡ, ਲੌਂਗਿਟਿਊਡ, ਜਲਵਾਯੂ ਬਦਲਾਅ, ਸਮੁੰਦਰ ਦੇ ਨੇੜੇਪਨ, ਜੈਟ ਸਟ੍ਰੀਮ ਦੇ ਪੈਟਰਨ, ਅਤੇ ਹੋਰ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।
ਜਦੋਂ ਅਨੇਕ ਹੋਰ ਚਲਕ ਵਰਗੀਆਂ ਘਟਕਾਂ ਵਿਰੋਧੀ ਪ੍ਰਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਤਾਂ, ਇੱਕ ML ਮਾਡਲ ਪਿਛਲੇ ਸਿਹਤ ਇਤਿਹਾਸ ਆਧਾਰਿਤ ਭਵਿੱਖ ਦੀਆਂ ਮੌਤਾਂ ਦੀ ਦਰ ਨੂੰ ਬੇਹਤਰ ਅੰਦਾਜਾ ਕਰਨ ਵਿੱਚ ਹੋਰ ਲਾਭਕਾਰੀ ਸਾਬਤ ਹੋ ਸਕਦਾ ਹੈ। ਇੱਕ ਹੋਰ ਖੁਸ਼ਕਿਸਮਤ ਉਦਾਹਰਨ, ਕਿਸੇ ਇਸਥਾਨ ਲਈ ਅਪਰੈਲ ਮਹੀਨੇ ਦਾ ਮੌਸਮ ਅੰਦਾਜਾ ਕਰਨਾ ਹੈ, ਜਿੱਥੇ ਡਾਟਾ ਵਿੱਚ ਕੂਹ-ਰੇਖਾ, ਲੰਬਾਈ, ਜਲਵਾਯੂ ਪਰਿਵਰਤਨ, ਸਮੁੰਦਰ ਦੇ ਨੇੜੇਪਣ, ਜੈਟ ਸਟ੍ਰੀਮ ਦੇ ਪੈਟਰਨ ਆਦਿ ਸ਼ਾਮਲ ਹਨ।
✅ ਇਹ [ਸਲਾਈਡ ਡੈਕ](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) ਮੌਸਮ ਮਾਡਲਾਂ 'ਤੇ ML ਦੀ ਵਰਤੋਂ ਲਈ ਇੱਕ ਇਤਿਹਾਸਕ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਪੇਸ਼ ਕਰਦਾ ਹੈ।
✅ ਮੌਸਮ ਮਾਡਲਾਂ 'ਤੇ ਇਹ [ਸਲਾਈਡ ਡੈੱਕ](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) ਮੌਸਮ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ML ਦੀ ਵਰਤੋਂ ਲਈ ਇਤਿਹਾਸਕ ਨਜ਼ਰੀਆ ਦਿੰਦੀ ਹੈ।
## ਮਾਡਲ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਦੇ ਕੰਮ
## ਮਾਡਲ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਵਾਲੇ ਕੰਮ
ਮਾਡਲ ਬਣਾਉਣ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਕਈ ਕੰਮ ਪੂਰੇ ਕਰਨੇ ਪੈਂਦੇ ਹਨ। ਆਪਣੇ ਸਵਾਲ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਮਾਡਲ ਦੀ ਪੇਸ਼ਗੋਈਆਂ ਦੇ ਆਧਾਰ 'ਤੇ ਇੱਕ ਅਨੁਮਾਨ ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਕਈ ਤੱਤਾਂ ਦੀ ਪਛਾਣ ਅਤੇ ਸੰਰਚਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਆਪਣਾ ਮਾਡਲ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਕਈ ਕੰਮ ਸਪੂਰਤ ਕਰਨ ਲੋੜੀਂਦੇ ਹਨ। ਆਪਣੇ ਸਵਾਲ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਮਾਡਲ ਦੀਆਂ ਭਵਿੱਖਬਾਣੀਆਂ 'ਤੇ ਅਧਾਰਿਤ ਇੱਕ ਹਿਪੋਥੇਸਿਸ ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਕਈ ਤੱਤਾਂ ਦੀ ਪਹਚਾਣ ਤੇ ਸੰਰਚਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
### ਡਾਟਾ
ਤੁਹਾਡੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਯਕੀਨ ਨਾਲ ਦੇਣ ਲਈ, ਤੁਹਾਨੂੰ ਸਹੀ ਕਿਸਮ ਦੇ ਡਾਟਾ ਦੀ ਚੰਗੀ ਮਾਤਰਾ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਸਮੇਂ ਤੁਹਾਨੂੰ ਦੋ ਕੰਮ ਕਰਨੇ ਪੈਂਦੇ ਹਨ:
ਤੁਹਾਡੇ ਸਵਾਲ ਦਾ ਕਿਸੇ ਵੀ ਪੱਕੇ ਜਵਾਬ ਲਈ, ਤੁਹਾਨੂੰ ਢੇਰ ਸਾਰਾ ਸਹੀ ਕਿਸਮ ਦਾ ਡਾਟਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਸਮੇਂ ਤੁਹਾਨੂੰ ਦੋ ਚੀਜ਼ਾਂ ਕਰਨੀ ਹੁੰਦੀ ਹਨ:
- **ਡਾਟਾ ਇਕੱਠਾ ਕਰੋ**। ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਨਿਰਪੱਖਤਾ ਦੇ ਪਿਛਲੇ ਪਾਠ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਆਪਣੇ ਡਾਟਾ ਨੂੰ ਸਾਵਧਾਨੀ ਨਾਲ ਇਕੱਠਾ ਕਰੋ। ਇਸ ਡਾਟਾ ਦੇ ਸਰੋਤਾਂ, ਇਸ ਵਿੱਚ ਮੌਜੂਦ ਕਿਸੇ ਵੀ ਅੰਦਰੂਨੀ ਪੱਖਪਾਤ, ਅਤੇ ਇਸ ਦੇ ਮੂਲ ਨੂੰ ਦਸਤਾਵੇਜ਼ਬੱਧ ਕਰੋ।
- **ਡਾਟਾ ਤਿਆਰ ਕਰੋ**। ਡਾਟਾ ਤਿਆਰੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕਈ ਕਦਮ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਜੇਕਰ ਡਾਟਾ ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ ਤੋਂ ਆਉਂਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਇਕੱਠਾ ਅਤੇ ਸਧਾਰਨ ਕਰਨ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ। ਤੁਸੀਂ ਸਤਰਾਂ ਨੂੰ ਨੰਬਰਾਂ ਵਿੱਚ ਬਦਲ ਕੇ (ਜਿਵੇਂ ਅਸੀਂ [ਕਲਸਟਰਿੰਗ](../../5-Clustering/1-Visualize/README.md) ਵਿੱਚ ਕਰਦੇ ਹਾਂ) ਡਾਟਾ ਦੀ ਗੁਣਵੱਤਾ ਅਤੇ ਮਾਤਰਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਮੂਲ ਡਾਟਾ ਦੇ ਆਧਾਰ 'ਤੇ ਨਵਾਂ ਡਾਟਾ ਜਨਰੇਟ ਕਰ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਅਸੀਂ [ਕਲਾਸੀਫਿਕੇਸ਼ਨ](../../4-Classification/1-Introduction/README.md) ਵਿੱਚ ਕਰਦੇ ਹਾਂ)। ਤੁਸੀਂ ਡਾਟਾ ਨੂੰ ਸਾਫ ਅਤੇ ਸੋਧ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਅਸੀਂ [ਵੈਬ ਐਪ](../../3-Web-App/README.md) ਪਾਠ ਤੋਂ ਪਹਿਲਾਂ ਕਰਾਂਗੇ)। ਆਖਰਕਾਰ, ਤੁਸੀਂ ਇਸ ਨੂੰ ਰੈਂਡਮਾਈਜ਼ ਅਤੇ ਸ਼ਫਲ ਕਰਨ ਦੀ ਲੋੜ ਕਰ ਸਕਦੇ ਹੋ, ਤੁਹਾਡੇ ਟ੍ਰੇਨਿੰਗ ਤਕਨੀਕਾਂ ਦੇ ਆਧਾਰ 'ਤੇ।
- **ਡਾਟਾ ਇਕੱਠਾ ਕਰੋ**। ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਨਿਆਂ ਦੀ ਵਿਚਾਰਧਾਰਾ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਆਪਣਾ ਡਾਟਾ ਧਿਆਨ ਨਾਲ ਇਕੱਠਾ ਕਰੋ। ਇਸ ਡਾਟਾ ਦੇ ਸਰੋਤਾਂ ਨੂੰ ਜਾਣੋ, ਇਸ ਵਿੱਚ ਹੋ ਸਕਦੇ ਪੱਖਪਾਤਾਂ ਬਾਰੇ ਸਮਝੋ ਅਤੇ ਇਸਦਾ ਮੂਲ ਦਰਜ ਕਰੋ।
- **ਡਾਟਾ ਤਿਆਰ ਕਰੋ**। ਡਾਟਾ ਤਿਆਰ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕਈ ਕਦਮ ਹਨ। ਤੁਸੀਂ ਵੱਖਰੇ ਸਰੋਤਾਂ ਤੋਂ ਆਉਣ ਵਾਲੇ ਡਾਟੇ ਨੂੰ ਇਕੱਠਾ ਕਰਕੇ ਸਮਾਨ ਰੂਪ ਵਿੱਚ ਲਿਆ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਡਾਟੇ ਦੀ ਗੁਣਵੱਤਾ ਅਤੇ ਮਾਤਰਾ ਨੂੰ ਸੂਤਰਾਂ ਨੂੰ ਨੰਬਰਾਂ ਵਿੱਚ ਬਦਲ ਕੇ ਸੁਧਾਰ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਕਿ ਅਸੀਂ [ਕਲੱਸਟਰਿੰਗ](../../5-Clustering/1-Visualize/README.md) ਵਿੱਚ ਕਰਦੇ ਹਾਂ)। ਤੁਸੀਂ ਮੂਲ ਡਾਟਾ ਦੇ ਆਧਾਰ ਤੇ ਨਵਾਂ ਡਾਟਾ ਵੀ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਕਿ ਅਸੀਂ [ਕਲਾਸੀਫਿਕੇਸ਼ਨ](../../4-Classification/1-Introduction/README.md) ਵਿੱਚ ਕਰਦੇ ਹਾਂ)। ਤੁਸੀਂ ਡਾਟਾ ਨੂੰ ਸਾਫ-ਸੁਥਰਾ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਕਿ ਅਸੀਂ [ਵੈੱਬ ਐਪ](../../3-Web-App/README.md) ਸਬਕ ਤੋਂ ਪਹਿਲਾਂ ਕਰਾਂਗੇ)। ਆਖਿਰਕਾਰ, ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਟ੍ਰੇਨਿੰਗ ਤਕਨੀਕਾਂ ਅਨੁਸਾਰ ਰੈੰਡੀਮ ਕਰਨਾ ਅਤੇ ਸ਼ਫ਼ਲ ਕਰਨਾ ਵੀ ਚਾਹੁੰਦੇ ਹੋ ਸਕਦੇ ਹੋ।
✅ ਡਾਟਾ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਪਲ ਲਓ ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਇਸ ਦਾ ਆਕਾਰ ਤੁਹਾਡੇ ਇਰਾਦੇ ਸਵਾਲ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ। ਇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਡਾਟਾ ਤੁਹਾਡੇ ਦਿੱਤੇ ਕੰਮ ਵਿੱਚ ਚੰਗਾ ਪ੍ਰਦਰਸ਼ਨ ਨਾ ਕਰੇ, ਜਿਵੇਂ ਅਸੀਂ ਆਪਣੇ [ਕਲਸਟਰਿੰਗ](../../5-Clustering/1-Visualize/README.md) ਪਾਠਾਂ ਵਿੱਚ ਪਤਾ ਲਗਾਉਂਦੇ ਹਾਂ!
✅ ਆਪਣਾ ਡਾਟਾ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰਨ ਮਗਰੋਂ, ਕਿਰਪਾ ਕਰਕੇ ਦੇਖੋ ਕਿ ਇਸ ਦਾ ਸਰੂਪ ਤੁਹਾਡੇ ਇਰਾਦੇ ਬਨਾਏ ਸਵਾਲ ਦੀ ਪੂਰੀ ਜਾਂਚ ਕਰਨ ਯੋਗ ਹੈ ਜਾਂ ਨਹੀਂ। ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਡਾਟਾ ਤੁਹਾਡੇ ਨਿਰਧਾਰਤ ਕੰਮ ਵਿੱਚ ਚੰਗਾ ਪ੍ਰਦਰਸ਼ਨ ਨਾ ਕਰੇ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਆਪਣੇ [ਕਲੱਸਟਰਿੰਗ](../../5-Clustering/1-Visualize/README.md) ਪਾਠਾਂ ਵਿੱਚ ਵੇਖਦੇ ਹਾਂ!
### ਫੀਚਰ ਅਤੇ ਟਾਰਗਟ
### ਫੀਚਰ ਅਤੇ ਟਾਰਗੇਟ
[ਫੀਚਰ](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) ਤੁਹਾਡੇ ਡਾਟਾ ਦੀ ਇੱਕ ਮਾਪਣਯੋਗ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ। ਕਈ ਡਾਟਾਸੈਟ ਵਿੱਚ ਇਹ 'date', 'size', ਜਾਂ 'color' ਵਰਗੇ ਕਾਲਮ ਹੈਡਿੰਗ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਡਾ ਫੀਚਰ ਵੈਰੀਏਬਲ, ਆਮ ਤੌਰ 'ਤੇ ਕੋਡ ਵਿੱਚ `X` ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ, ਉਹ ਇਨਪੁਟ ਵੈਰੀਏਬਲ ਹੈ ਜੋ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ।
[ਫੀਚਰ](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) ਤੁਹਾਡੇ ਡਾਟੇ ਦੀ ਇੱਕ ਮਾਪੀ ਜਾ ਸਕਣ ਵਾਲੀ ਖਾਸੀਅਤ ਹੁੰਦੀ ਹੈ। ਕਈ ਡਾਟਾ ਸੈੱਟਾਂ ਵਿੱਚ ਇਹ ਕਾਲਮ ਦੀ ਸਿਰਲੇਖ ਵਜੋਂ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ 'ਤਾਰੀਖ', 'ਆਕਾਰ' ਜਾਂ 'ਰੰਗ'। ਤੁਹਾਡੀ ਫੀਚਰ ਵੈਰੀਏਬਲ, ਜੋ ਆਮਤੌਰ 'ਤੇ ਕੋਡ ਵਿੱਚ `X` ਰੂਪ ਵਿੱਚ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ, ਉਹ ਇਨਪੁੱਟ ਵੈਰੀਏਬਲ ਹੁੰਦੀ ਹੈ ਜੋ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
ਟਾਰਗਟ ਉਹ ਚੀਜ਼ ਹੈ ਜਿਸ ਦੀ ਤੁਸੀਂ ਪੇਸ਼ਗੋਈ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ। ਟਾਰਗਟ ਆਮ ਤੌਰ 'ਤੇ ਕੋਡ ਵਿੱਚ `y` ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਤੁਹਾਡੇ ਡਾਟਾ ਤੋਂ ਪੁੱਛੇ ਜਾ ਰਹੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦਰਸਾਉਂਦਾ ਹੈ: ਦਸੰਬਰ ਵਿੱਚ ਕਿਹੜੇ **ਰੰਗ** ਦੇ ਕੱਦੂ ਸਭ ਤੋਂ ਸਸਤੇ ਹੋਣਗੇ? ਸੈਨ ਫਰਾਂਸਿਸਕੋ ਵਿੱਚ ਕਿਹੜੇ ਪੜੋਸਾਂ ਵਿੱਚ ਰਿਅਲ ਐਸਟੇਟ ਦੀ **ਕੀਮਤ** ਸਭ ਤੋਂ ਵਧੀਆ ਹੋਵੇਗੀ? ਕਈ ਵਾਰ ਟਾਰਗਟ ਨੂੰ ਲੇਬਲ ਐਟ੍ਰਿਬਿਊਟ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਟਾਰਗੇਟ ਉਹ ਚੀਜ਼ ਹੈ ਜਿਸ ਦੀ ਤੁਸੀਂ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ। ਟਾਰਗੇਟ, ਜੋ ਆਮਤੌਰ 'ਤੇ ਕੋਡ ਵਿੱਚ `y` ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ, ਉਸ ਸਵਾਲ ਦਾ ਜਵਾਬ ਹੁੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਡਾਟੇ ਨੂੰ ਪੁੱਛ ਰਹੇ ਹੋ: ਦਸੰਬਰ ਵਿੱਚ, ਕੇਹੜਾ **ਰੰਗ** ਦੇ ਕੁੱਰਬੂਤ ਸਸਤੇ ਹੋਣਗੇ? ਸੈਨ ਫਰਾਂਸਿਸਕੋ ਵਿੱਚ, ਦਿੱਤੇ ਮੋਹੱਲਿਆਂ ਦੀ ਜਾਇਦਾਦ ਦੀਆਂ ਵਧੀਆ **ਕੀਮਤਾਂ** ਕਿਹੜੀਆਂ ਹੋਣਗੀਆਂ? ਕਈ ਵਾਰ ਟਾਰਗੇਟ ਨੂੰ ਲੇਬਲ ਅਟ੍ਰਿਬਿਊਟ ਵਜੋਂ ਵੀ ਸੈਜ਼ਾ ਦਿੰਦੇ ਹਨ।
### ਫੀਚਰ ਵੈਰੀਏਬਲ ਚੁਣਨਾ
### ਆਪਣੀ ਫੀਚਰ ਵੈਰੀਏਬਲ ਚੁਣੋ
🎓 **ਫੀਚਰ ਚੋਣ ਅਤੇ ਫੀਚਰ ਨਿਕਾਸ**। ਮਾਡਲ ਬਣਾਉਣ ਸਮੇਂ ਤੁਹਾਨੂੰ ਕਿਹੜਾ ਵੈਰੀਏਬਲ ਚੁਣਨਾ ਚਾਹੀਦਾ ਹੈ? ਤੁਸੀਂ ਸ਼ਾਇਦ ਫੀਚਰ ਚੋਣ ਜਾਂ ਫੀਚਰ ਨਿਕਾਸ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚੋਂ ਗੁਜ਼ਰੋਗੇ ਤਾਂ ਜੋ ਸਭ ਤੋਂ ਵਧੀਆ ਮਾਡਲ ਲਈ ਸਹੀ ਵੈਰੀਏਬਲ ਚੁਣ ਸਕੋ। ਹਾਲਾਂਕਿ ਇਹ ਦੋਵੇਂ ਇੱਕੋ ਜਿਹੇ ਨਹੀਂ ਹਨ: "ਫੀਚਰ ਨਿਕਾਸ ਮੂਲ ਫੀਚਰਾਂ ਦੇ ਫੰਕਸ਼ਨਾਂ ਤੋਂ ਨਵੇਂ ਫੀਚਰ ਬਣਾਉਂਦਾ ਹੈ, ਜਦਕਿ ਫੀਚਰ ਚੋਣ ਫੀਚਰਾਂ ਦੇ ਇੱਕ ਉਪਸੈਟ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ।" ([ਸਰੋਤ](https://wikipedia.org/wiki/Feature_selection))
🎓 **ਫੀਚਰ ਸਿਲੈਕਸ਼ਨ ਅਤੇ ਫੀਚਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ** ਮਾਡਲ ਬਣਾਉਂਦੇ ਸਮੇਂ ਤੁਸੀਂ ਕਿਸ ਵੈਰੀਏਬਲ ਨੂੰ ਚੁਣੋਗੇ, ਇਸ ਦਾ ਕੀਮਤੀ ਪ੍ਰਕਿਰਿਆ ਹੈ। ਤੁਹਾਡੇ ਲਈ ਫੀਚਰ ਸਿਲੈਕਸ਼ਨ ਜਾਂ ਫੀਚਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਸਭ ਤੋਂ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਨ ਵਾਲਾ ਮਾਡਲ ਚੁਣਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਪਰ ਇਹ ਦੋਵੇਂ ਇਕੋ ਨਹੀਂ ਹਨ: "ਫੀਚਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ ਮੂਲ ਫੀਚਰਾਂ ਦੇ ਫੰਕਸ਼ਨਾਂ ਤੋਂ ਨਵੇਂ ਫੀਚਰ ਬਣਾਉਂਦੀ ਹੈ, ਜਦਕਿ ਫੀਚਰ ਸਿਲੈਕਸ਼ਨ ਫੀਚਰਾਂ ਦਾ ਇੱਕ ਉੱਪਸੈੱਟ ਵਾਪਸ ਕਰਦਾ ਹੈ।" ([ਸਰੋਤ](https://wikipedia.org/wiki/Feature_selection))
### ਆਪਣੇ ਡਾਟਾ ਨੂੰ ਵਿਜ਼ੁਅਲਾਈਜ਼ ਕਰੋ
### ਡਾਟਾ ਨੂੰ ਵਿਜੂਅਲਾਈਜ਼ ਕਰੋ
ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਦੇ ਟੂਲਕਿਟ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਲੂ ਹੈ ਕਈ ਸ਼ਾਨਦਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਿਵੇਂ Seaborn ਜਾਂ MatPlotLib ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਾਟਾ ਨੂੰ ਵਿਜ਼ੁਅਲਾਈਜ਼ ਕਰਨ ਦੀ ਸ਼ਕਤੀ। ਆਪਣੇ ਡਾਟਾ ਨੂੰ ਵਿਜ਼ੁਅਲ ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਣਾ ਤੁਹਾਨੂੰ ਲੁਕੇ ਹੋਏ ਸੰਬੰਧਾਂ ਦੀ ਖੋਜ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇ ਸਕਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਲਾਭਦਾਇਕ ਬਣਾ ਸਕਦੇ ਹੋ। ਤੁਹਾਡੇ ਵਿਜ਼ੁਅਲਾਈਜ਼ੇਸ਼ਨ ਤੁਹਾਨੂੰ ਪੱਖਪਾਤ ਜਾਂ ਅਸੰਤੁਲਿਤ ਡਾਟਾ ਦੀ ਖੋਜ ਕਰਨ ਵਿੱਚ ਵੀ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ (ਜਿਵੇਂ ਅਸੀਂ [ਕਲਾਸੀਫਿਕੇਸ਼ਨ](../../4-Classification/2-Classifiers-1/README.md) ਵਿੱਚ ਪਤਾ ਲਗਾਉਂਦੇ ਹਾਂ)।
ਡਾਟਾ ਵਿਗਿਆਨੀ ਦੇ ਟੂਲਕਿਟ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਗੁਣ ਡਾਟਾ ਨੂੰ ਕਈ ਸ਼ਾਨਦਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਰਗੇ ਸੇਬੌਰਨ ਜਾਂ ਮੈਟਪਲਾਟਲਿਬ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਿਜ਼ੂਅਲਾਈਜ਼ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਹੈ। ਆਪਣਾ ਡਾਟਾ ਵਿਜ਼ੂਅਲ ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਣਾ ਤੁਹਾਨੂੰ ਲੁਕਵੇਂ ਸੰਬੰਧਾਂ ਦੀ ਸੂਝ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ। ਤੁਹਾਡੇ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਪੱਖਪਾਤ ਜਾਂ ਅਸਮਤੁਲਿਤ ਡਾਟਾ ਨੂੰ ਵੀ ਖੋਜਣ ਵਿੱਚ ਸਹਾਇਕ ਹੋ ਸਕਦੇ ਹਨ (ਜਿਵੇਂ ਕਿ ਅਸੀਂ [ਕਲਾਸੀਫਿਕੇਸ਼ਨ](../../4-Classification/2-Classifiers-1/README.md) ਵਿੱਚ ਪਤਾ ਲਗਾਉਂਦੇ ਹਾਂ)।
### ਆਪਣੇ ਡਾਟਾਸੈਟ ਨੂੰ ਵੰਡੋ
### ਆਪਣਾ ਡਾਟਾਸੈੱਟ ਵੰਡੋ
ਟ੍ਰੇਨਿੰਗ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਡਾਟਾਸੈਟ ਨੂੰ ਦੋ ਜਾਂ ਵੱਧ ਅਸਮਾਨ ਆਕਾਰ ਦੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਣਾ ਪੈਂਦਾ ਹੈ ਜੋ ਫਿਰ ਵੀ ਡਾਟਾ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਦਰਸਾਉਂਦੇ ਹਨ।
ਟ੍ਰੇਨਿੰਗ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਡਾਟਾਸੈੱਟ ਨੂੰ ਦੋ ਜਾਂ ਵੱਧ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਅਸਮਾਨ ਆਕਾਰ ਦੇ ਹੋਣ ਦੇ ਬਾਵਜੂਦ ਡਾਟੇ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਦਰਸਾਉਂਦੇ ਹੋਣ।
- **ਟ੍ਰੇਨਿੰਗ**। ਡਾਟਾਸੈਟ ਦਾ ਇਹ ਹਿੱਸਾ ਤੁਹਾਡੇ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਫਿੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸੈੱਟ ਮੂਲ ਡਾਟਾਸੈਟ ਦਾ ਜ਼ਿਆਦਾਤਰ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ।
- **ਟੈਸਟਿੰਗ**। ਇੱਕ ਟੈਸਟ ਡਾਟਾਸੈਟ ਇੱਕ ਸਵਤੰਤਰ ਗਰੁੱਪ ਹੈ, ਅਕਸਰ ਮੂਲ ਡਾਟਾ ਤੋਂ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸਦੀ ਵਰਤੋਂ ਤੁਸੀਂ ਬਣਾਏ ਮਾਡਲ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਕਰਦੇ ਹੋ।
- **ਵੈਲੀਡੇਟਿੰਗ**। ਇੱਕ ਵੈਲੀਡੇਸ਼ਨ ਸੈੱਟ ਇੱਕ ਛੋਟਾ ਸਵਤੰਤਰ ਗਰੁੱਪ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਤੁਸੀਂ ਮਾਡਲ ਦੇ ਹਾਈਪਰਪੈਰਾਮੀਟਰਾਂ ਜਾਂ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਸੁਧਾਰਨ ਲਈ ਕਰਦੇ ਹੋ। ਤੁਹਾਡੇ ਡਾਟਾ ਦੇ ਆਕਾਰ ਅਤੇ ਤੁਹਾਡੇ ਸਵਾਲ ਦੇ ਆਧਾਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਇਹ ਤੀਜਾ ਸੈੱਟ ਬਣਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੋ ਸਕਦੀ (ਜਿਵੇਂ ਅਸੀਂ [ਟਾਈਮ ਸੀਰੀਜ਼ ਫੋਰਕਾਸਟਿੰਗ](../../7-TimeSeries/1-Introduction/README.md) ਵਿੱਚ ਨੋਟ ਕਰਦੇ ਹਾਂ)।
- **ਟ੍ਰੇਨਿੰਗ**। ਡਾਟਾਸੈੱਟ ਦਾ ਇਹ ਹਿੱਸਾ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਫਿਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸੈੱਟ ਮੂਲ ਡਾਟਾਸੈੱਟ ਦਾ ਵੱਡਾ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ।
- **ਟੈਸਟਿੰਗ**। ਟੈਸਟ ਡਾਟਾਸੈੱਟ ਇੱਕ ਸੁਤੰਤਰ ਸਮੂਹ ਹੁੰਦਾ ਹੈ ਜੋ ਜ਼ਿਆਦਾਤਰ ਮੂਲ ਡਾਟੇ ਤੋਂ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ এবং ਜਿਸਦੀ ਵਰਤੋਂ ਮਾਡਲ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
- **ਵੈਲਿਡੇਟਿੰਗ**। ਵੈਲਿਚੇਕਸ਼ਨ ਸੈੱਟ ਛੋਟਾ ਸੁਤੰਤਰ ਉਦਾਹਰਨਾਂ ਦਾ ਸਮੂਹ ਹੁੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਮਾਡਲ ਦੇ ਹਾਈਪਰਪੈਰਾਮੀਟਰ ਜਾਂ ਬਣਤਰ ਨੂੰ ਟਿਊਨ ਕਰਨ ਲਈ ਵਰਤਦੇ ਹੋ। ਤੁਹਾਡੇ ਡਾਟਾ ਦੇ ਆਕਾਰ ਅਤੇ ਸਵਾਲ ਦੇ ਅਨੁਸਾਰ ਤੁਸੀਂ ਇਸ ਤੀਜੇ ਸੈੱਟ ਦੀ ਲੋੜ ਨਹੀਂ ਮਹਿਸੂਸ ਕਰ ਸਕਦੇ (ਜਿਵੇਂ ਕਿ ਅਸੀਂ [ਟਾਈਮ ਸੀਰੀਜ਼ ਫੋਰਕਾਸਟਿੰਗ](../../7-TimeSeries/1-Introduction/README.md) ਵਿੱਚ ਨੋਟ ਕਰਦੇ ਹਾਂ)।
## ਮਾਡਲ ਬਣਾਉਣਾ
ਆਪਣੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਹਾਡਾ ਉਦੇਸ਼ ਇੱਕ ਮਾਡਲ ਬਣਾਉਣਾ ਹੈ, ਜਾਂ ਤੁਹਾਡੇ ਡਾਟਾ ਦਾ ਇੱਕ ਸਾਂਖਿਕ ਪ੍ਰਤੀਨਿਧੀ, ਵੱਖ-ਵੱਖ ਐਲਗੋਰਿਥਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਨੂੰ **ਟ੍ਰੇਨ** ਕਰਨਾ। ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨਾ ਇਸ ਨੂੰ ਡਾਟਾ ਦੇ ਸਾਹਮਣੇ ਰੱਖਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਖੋਜੇ ਗਏ ਪੈਟਰਨਾਂ ਬਾਰੇ ਧਾਰਨਾ ਬਣਾਉਣ, ਵੈਲੀਡੇਟ ਕਰਨ, ਅਤੇ ਸਵੀਕਾਰ ਜਾਂ ਅਸਵੀਕਾਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
ਆਪਣੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਹਾਡਾ ਲਕੜ ਹੈ ਕਿ ਇੱਕ ਮਾਡਲ ਬਣਾਉ, ਜਾਂ ਤੁਹਾਡੇ ਡਾਟੇ ਦੀ ਸਾਂਖਿਆਕੀ ਪ੍ਰਤੀਨਿਧੀ ਬਣਾਉ, ਜੋ ਵੱਖਰੇ ਅਲਗੋਰਿਦਮ ਵਰਤ ਕੇ ਇਸਨੂੰ ਟ੍ਰੇਨ ਕਰੇ। ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨਾ ਇਸਨੂੰ ਡਾਟਾ ਨਾਲ ਸਾਹਮਣਾ ਕਰਵਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਪੈਟਰਨਾਂ ਬਾਰੇ ਅਸੁਮptions ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ ਜੋ ਇਹ ਖੋਜਦਾ, ਸੱਚ ਜਾਂ ਝੂਠ ਨੂੰ ਜਾਂਚਦਾ, ਤੇ ਕਬੂਲ ਜਾਂ ਠੁਕਰਾਉਂਦਾ ਹੈ।
### ਟ੍ਰੇਨਿੰਗ ਵਿਧੀ ਤੈਅ ਕਰੋ
### ਟ੍ਰੇਨਿੰਗ ਮੈਥਡ ਦਾ ਫੈਸਲਾ ਕਰੋ
ਤੁਹਾਡੇ ਸਵਾਲ ਅਤੇ ਤੁਹਾਡੇ ਡਾਟਾ ਦੀ ਪ੍ਰਕਿਰਤੀ ਦੇ ਆਧਾਰ 'ਤੇ, ਤੁਸੀਂ ਇਸ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਇੱਕ ਵਿਧੀ ਚੁਣੋਗੇ। [Scikit-learn ਦੀ ਦਸਤਾਵੇਜ਼](https://scikit-learn.org/stable/user_guide.html) ਵਿੱਚੋਂ ਗੁਜ਼ਰਦੇ ਹੋਏ - ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਇਸ ਕੋਰਸ ਵਿੱਚ ਕਰਦੇ ਹਾਂ - ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਖੋਜ ਸਕਦੇ ਹੋ। ਤੁਹਾਡੇ ਅਨੁਭਵ ਦੇ ਆਧਾਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਕਈ ਵੱਖ-ਵੱਖ ਵਿਧੀਆਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨੀ ਪਵੇਗੀ। ਤੁਸੀਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚੋਂ ਗੁਜ਼ਰਦੇ ਹੋ ਜਿੱਥੇ ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਮਾਡਲ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਮੁਲਾਂਕਨ ਕਰਦੇ ਹਨ, ਇਸ ਨੂੰ ਨਾ ਦੇਖੇ ਡਾਟਾ ਦੇਣ, ਸਹੀਤਾ, ਪੱਖਪਾਤ, ਅਤੇ ਹੋਰ ਗੁਣਵੱਤਾ-ਘਟਾਉਣ ਵਾਲੇ ਮੁੱਦਿਆਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ,
ਤੁਹਾਡੇ ਸਵਾਲ ਅਤੇ ਡਾਟਾ ਦੀ ਕਿਸਮ dian ਅਧਾਰ, ਤੁਸੀਂ ਟ੍ਰੇਨ ਕਰਨ ਦਾ ਇੱਕ ਮੈਥਡ ਚੁਣੋਗੇ। [ਸਕੀਟ-ਲਰਨ ਦੀ ਦਸਤਾਵੇਜ਼ੀ](https://scikit-learn.org/stable/user_guide.html) ਦੇ ਰਾਹੀਂ ਚੱਲਦੇ ਹੋਏ - ਜੋ ਅਸੀਂ ਇਸ ਕੋਰਸ ਵਿੱਚ ਵਰਤਦੇ ਹਾਂ - ਤੁਸੀਂ ਕਈ ਢੰਗਾਂ ਨਾਲ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰਨ ਦਾ ਪਤਾ ਲਾ ਸਕਦੇ ਹੋ। ਤੁਹਾਡੇ ਅਨੁਭਵ ਦੇ ਮੁਤਾਬਕ, ਤੁਸੀਂ ਸਭ ਤੋਂ ਵਧੀਆ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਕਈ ਵੱਖਰਾ ਤਰੀਕਿਆਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ। ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਵੱਡੇ ਅਕਸਰ ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿਚੋਂ ਲੰਘਦੇ ਹਨ ਜਿੱਥੇ ਉਨ੍ਹਾਂ ਅਣਦੇਖੇ ਡਾਟੇ ਨੂੰ ਮਾਡਲ ਵਿੱਚ ਫੀਡ ਕਰਕੇ ਇਸ ਦੀ ਸ਼ੁੱਧਤਾ, ਪੱਖਪਾਤ, ਅਤੇ ਹੋਰ ਕੁਆਲਿਟੀ ਥੀਮਾਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ ਅਤੇ ਕੰਮ ਲਈ ਸਭ ਤੋਂ ਢੁਕਵਾਂ ਟ੍ਰੇਨਿੰਗ ਮੈਥਡ ਚੁਣਦੇ ਹਨ।
### ਮਾਡਲ ਟ੍ਰੇਨ ਕਰੋ
ਆਪਣੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟੇ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਇਸਨੂੰ ਮਾਡਲ ਬਣਾਉਣ ਲਈ 'ਫਿਟ' ਕਰਨ ਲਈ ਤਿਆਰ ਹੋ। ਤੁਹਾਨੂੰ ਵਿਭਿੰਨ ML ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ 'model.fit' ਕੋਡ ਅਕਸਰ ਮਿਲੇਗਾ—ਸਿਰਫ ਇਸ ਸਮੇਂ ਹੀ ਤੁਸੀਂ ਆਪਣੀ ਫੀਚਰ ਵੈਰੀਏਬਲ (ਸਧਾਰਣ: 'X') ਅਤੇ ਟਾਰਗੇਟ ਵੈਰੀਏਬਲ ('y' ਆਮ ਤੌਰ) ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਐਰੇ ਭੇਜਦੇ ਹੋ।
### ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ
ਜਦੋਂ ਟ੍ਰੇਨਿੰਗ ਪ੍ਰਕਿਰਿਆ ਮੁਕੰਮਲ ਹੁੰਦੀ ਹੈ (ਇਹ ਵੱਡੇ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਕਈ ਦੌਰ ਜਾਂ 'ਏਪੌਕ' ਲੈ ਸਕਦਾ ਹੈ), ਤੁਸੀਂ ਟੈਸਟ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਡਲ ਦੀ ਕੋਟੀ ਨੂੰ ਅੰਕਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਡਾਟਾ ਮੂਲ ਡਾਟੇ ਦਾ ਇੱਕ ਉਪਸੈੱਟ ਹੁੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਮਾਡਲ ਪਹਿਲਾਂ ਜਾਂਚਿਆ ਨਹੀਂ ਹੁੰਦਾ। ਤੁਸੀਂ ਮਾਡਲ ਦੀ ਗੁਣਵੱਤਾ ਬਾਰੇ ਮੈਟ੍ਰਿਕਸ ਦਾ ਟੇਬਲ ਛਾਪ ਸਕਦੇ ਹੋ।
🎓 **ਮਾਡਲ ਫਿਟਿੰਗ**
ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਸੰਦਰਭ ਵਿੱਚ, ਮਾਡਲ ਫਿਟਿੰਗ ਮਾਡਲ ਦੇ ਅਧਾਰਭੂਤ ਫੰਕਸ਼ਨ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਕਹਿੰਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਡਾਟਿਆਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਉਹ ਪਹਿਲਾਂ ਨਹੀਂ ਦੇਖਿਆ।
🎓 **ਅੰਡਰਫਿਟਿੰਗ** ਅਤੇ **ਓਵਰਫਿਟਿੰਗ** ਆਮ ਸਮੱਸਿਆਵਾਂ ਹਨ ਜੋ ਮਾਡਲ ਦੀ ਗੁਣਵੱਤਾ ਨੂੰ ਖਰਾਬ ਕਰਦੀਆਂ ਹਨ, ਜਦੋਂ ਮਾਡਲ ਜਾਂ ਤਾਂ ਕਾਫ਼ੀ ਚੰਗਾ ਫਿਟ ਨਹੀਂ ਹੁੰਦਾ ਜਾਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਚੰਗਾ। ਇਹ ਮਾਡਲ ਨੂੰ ਆਪਣੀ ਟ੍ਰੇਨਿੰਗ ਡਾਟੇ ਨਾਲ ਬਹੁਤ ਜ਼ਿਆਦਾ ਜਾਂ ਬਹੁਤ ਘੱਟ ਮਿਲਦੇ-ਜੁਲਦੇ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ। ਇੱਕ ਓਵਰਫਿਟ ਮਾਡਲ ਟ੍ਰੇਨਿੰਗ ਡਾਟੇ ਨੂੰ ਬਹੁਤ ਵਧੀਆ ਪ੍ਰਿਜਣ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਸ ਨੇ ਡਾਟੇ ਦੇ ਵੇਰਵੇ ਅਤੇ ਸ਼ੋਰ ਬਹੁਤ ਵਧੀਆ ਸਿੱਖ ਲਿਆ ਹੈ। ਇੱਕ ਅੰਡਰਫਿਟ ਮਾਡਲ ਸਹੀ ਨਹੀਂ ਹੁੰਦਾ ਕਿਉਂਕਿ ਇਹ ਨਾ ਤੂੰ ਆਪਣੀ ਟ੍ਰੇਨਿੰਗ ਡਾਟੇ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰ ਪਾਉਂਦਾ ਹੈ ਨਾ ਹੀ ਉਹ ਡਾਟਾ ਜੋ ਇਸਨੇ ਪਹਿਲਾਂ ਨਹੀਂ ਦੇਖਿਆ।
![overfitting model](../../../../translated_images/pa/overfitting.1c132d92bfd93cb6.webp)
> ਇੰਫੋ ਗ੍ਰਾਫਿਕ ਵੱਲੋਂ [ਜੈਨ ਲੂਪਰ](https://twitter.com/jenlooper)
## ਪੈਰਾਮੀਟਰ ਟਿਊਨਿੰਗ
ਜਦੋਂ ਤੁਹਾਡੀ ਸ਼ੁਰੂਆਤੀ ਟ੍ਰੇਨਿੰਗ ਮੁਕੰਮਲ ਹੋ ਜਾਵੇ, ਤਾਂ ਮਾਡਲ ਦੀ ਗੁਣਵੱਤਾ ਦਾ ਅਵਲੋਕਨ ਕਰੋ ਅਤੇ ਇਸਦੇ 'ਹਾਈਪਰਪੈਰਾਮੀਟਰ' ਵਿੱਚ ਤਬਦੀਲੀ ਕਰਕੇ ਇਸਨੂੰ ਸੁਧਾਰਨ ਬਾਰੇ ਸੋਚੋ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹੋ [ਦਸਤਾਵੇਜ਼ੀ ਵਿੱਚ](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
## ਭਵਿੱਖਬਾਣੀ
ਇਹ ਉਹ ਸਮਾਂ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਬਿਲਕੁਲ ਨਵਾਂ ਡਾਟਾ ਲੈ ਕੇ ਆਪਣੇ ਮਾਡਲ ਦੀ ਸ਼ੁੱਧਤਾ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਕ 'ਪ੍ਰਯੋਗਿਕ' ML ਸੈਟਿੰਗ ਵਿੱਚ, ਜਿੱਥੇ ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਵਰਤਣ ਲਈ ਵੈੱਬ ਐਸੈੱਟਸ ਬਣਾ ਰਹੇ ਹੋ, ਇਹ ਪ੍ਰਕਿਰਿਆ ਯੂਜ਼ਰ ਇਨਪੁੱਟ (ਉਦਾਹਰਨ ਵਜੋਂ, ਬੱਟਨ ਦਬਾਉਣਾ) ਇਕੱਠਾ ਕਰਕੇ ਇੱਕ ਵੈਰੀਏਬਲ ਸੈੱਟ ਕਰਨ ਅਤੇ ਮਾਡਲ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਮੁਲਾਂਕਣ ਲਈ ਭੇਜਣ ਦੀ ਸ਼ਾਮਲ ਕਰ ਸਕਦੀ ਹੈ।
ਇਨ੍ਹਾਂ ਪਾਠਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਇਹ ਜਾਣੋਗੇ ਕਿ ਇਹ ਕਦਮ ਕਿਵੇਂ ਤਿਆਰ, ਬਣਾਉਣ, ਟੈਸਟ, ਮੁਲਾਂਕਣ ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਣਗੇ - ਇਹ ਸਾਰੇ ਡਾਟਾ ਵਿਗਿਆਨੀ ਦੀਆਂ ਹਰਕਤਾਂ ਹਨ ਅਤੇ ਵੱਧ-ਵੱਧ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ 'ਫੁੱਲ ਸਟੈਕ' ML ਇੰਜੀਨੀਅਰ ਬਣਨ ਦੇ ਸਫ਼ਰ ਵਿੱਚ ਅੱਗੇ ਵਧਦੇ ਹੋ।
---
## 🚀ਚੈਲੇੰਜ
ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਅਭਿਆਸਕ ਦੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਇੱਕ ਫਲੋ ਚਾਰਟ ਬਣਾਓ। ਤੁਸੀਂ ਇਸ ਸਮੇਂ ਪ੍ਰਕਿਰਿਆ ਦੇ ਕਿਹੜੇ ਹਿੱਸੇ ਵਿੱਚ ਹੋ? ਤੁਹਾਨੂੰ ਕਿਹੜੀਆਂ ਮੁਸ਼ਕਲਾਂ ਦਾ ਸਾਹਮਣਾ ਹੋ ਸਕਦਾ ਹੈ? ਤੁਹਾਨੂੰ ਕੀ ਚੀਜ਼ ਸੌਖੀ ਲੱਗਦੀ ਹੈ?
## [ਪੋਸਟ-ਲੇਕਚਰ ਕਿਊਜ਼](https://ff-quizzes.netlify.app/en/ml/)
## ਸਮੀਖਿਆ ਅਤੇ ਸਵਯੰ ਅਧਿਐਨ
ਡਾਟਾ ਸਾਇੰਟਿਸਟਾਂ ਨਾਲ ਇੰਟਰਵਿਊਜ਼ ਖੋਜੋ ਜੋ ਆਪਣੇ ਰੋਜ਼ਾਨਾ ਕੰਮ ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਹਨ। ਇੱਥੇ [ਇੱਕ](https://www.youtube.com/watch?v=Z3IjgbbCEfs) ਹੈ।
## ਅਸਾਈਨਮੈਂਟ
[ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਦਾ ਇੰਟਰਵਿਊ ਕਰੋ](assignment.md)
---
**ਅਸਵੀਕਾਰਨਾ**:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚਨਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ਅਸਵੀਕਾਰੋਪਤਰ**:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਆਟੋਮੈਟਿਕ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸਹੀਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੋਏ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

333
translations/pa/2-Regression/3-Linear/README.md
Unescape View File

@ -1,136 +1,136 @@
# ਸਕਾਇਕਿਟ-ਲਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਓ: ਰਿਗ੍ਰੈਸ਼ਨ ਚਾਰ ਤਰੀਕੇ
# ਸਕਿਕਿਟ-ਲਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਓ: ਰਿਗ੍ਰੈਸ਼ਨ ਚਾਰ ਤਰੀਕਿਆਂ ਨਾਲ
## ਸ਼ੁਰੂਆਤੀ ਨੋਟ
ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਉਸ ਸਮੇਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਅਸੀਂ ਇੱਕ **ਸੰਖਿਆਤਮਕ ਮੁੱਲ** ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ (ਉਦਾਹਰਨ ਲਈ, ਘਰ ਦੀ ਕੀਮਤ, ਤਾਪਮਾਨ, ਜਾਂ ਵਿਕਰੀ).
ਇਹ ਇੰਪੁੱਟ ਫੀਚਰਾਂ ਅਤੇ ਆਉਟਪੁੱਟ ਦਰਮਿਆਨ ਸੰਬੰਧ ਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਦਰਸਾਉਂਦੀ ਲੱਕੜੀ ਲੈ ਕੇ ਕੰਮ ਕਰਦੀ ਹੈ।
ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਉਸ ਵੇਲੇ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਅਸੀਂ ਇੱਕ **ਸੰਖਿਆਤਮਕ ਮੁੱਲ** ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨੀ ਹੋਵੇ (ਉਦਾਹਰਨ ਲਈ, ਘਰ ਦੀ ਕੀਮਤ, ਤਾਪਮਾਨ, ਜਾਂ ਵਿਕਰੀ)।
ਇਹ ਇਨਪੁੱਟ ਫੀਚਰਾਂ ਅਤੇ ਆਉਟਪੁੱਟ ਵਿਚਕਾਰ ਸੰਬੰਧ ਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਦਰਸਾਉਣ ਵਾਲੀ ਸਿੱਧੀ ਲਾਈਨ ਲੱਭ ਕੇ ਕੰਮ ਕਰਦੀ ਹੈ।
ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਧਿਆਨ ਕੇਵਲ ਸਮਝਣ ਵੱਲ ਹੈ ਇਸ ਤਰੀਕੇ ਨੂੰ ਸਮਝਣ 'ਤੇ ਜਦੋਂ ਕਿ ਅਸੀਂ ਹੋਰ ਵਿਕਸਤ ਰਿਗ੍ਰੈਸ਼ਨ ਤਕਨੀਕਾਂ ਵੇਖਾਂਗੇ।
![ਲਾਈਨੀਅਰ ਅਤੇ ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਇੰਨਫੋਗ੍ਰਾਫਿਕ](../../../../translated_images/pa/linear-polynomial.5523c7cb6576ccab.webp)
> ਇੰਨਫੋਗ੍ਰਾਫਿਕ [ਦਾਸਾਨੀ ਮਾਦਿਪੱਲੀ](https://twitter.com/dasani_decoded) ਵੱਲੋਂ
ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਸੰਕਲਪ ਨੂੰ ਸਮਝਣ 'ਤੇ ਧਿਆਨ ਦੇਵਾਂਗੇ ਜਿਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਹੋਰ ਉन्नਤ ਰਿਗ੍ਰੈਸ਼ਨ ਤਕਨੀਕਾਂ ਦੀ ਜਾਂਚ ਕਰਾਂਗੇ।
![Linear vs polynomial regression infographic](../../../../translated_images/pa/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)
### ਜਾਣਪਛਾਣ
> ### [ਇਹ ਪਾਠ R ਵਿੱਚ ਵੀ ਉਪਲਬਧ ਹੈ!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### ਪਰਿਚય
ਹੁਣ ਤੱਕ ਤੁਸੀਂ ਸਮਝਿਆ ਹੈ ਕਿ ਰਿਗ੍ਰੈਸ਼ਨ ਕੀ ਹੈ ਸਟੈਂਡਰਡ ਦੱਤੇਂ ਤੋਂ ਲੈ ਕੇ, ਜੋ ਕਿ ਅਸੀਂ ਉੱਥੇ ਇਸ ਪਾਠ ਦੌਰਾਨ ਵਰਤਾਂਗੇ. ਤੁਸੀਂ ਇਸਨੂੰ ਮੈਟਪਲੌਟਲਿਬ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵੀ ਵੇਖਿਆ ਹੈ।
ਹੁਣ ਤੱਕ ਤੁਸੀਂ ਸਮਝਿਆ ਹੈ ਕਿ ਰਿਗ੍ਰੈਸ਼ਨ ਕੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਕਦੂ ਦੀ ਕੀਮਤਾਂ ਵਾਲੇ ਨਮੂਨਾ ਡੇਟਾ ਨਾਲ, ਜਿਸਨੂੰ ਅਸੀਂ ਇਸ ਪਾਠ ਵਿੱਚ ਵਰਤਾਂਗੇ। ਤੁਸੀਂ ਇਸਨੂੰ ਮੈਟਪਲੌਟਲਿਬ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੇਖਿਆ ਵੀ ਹੈ।
ਹੁਣ ਤੁਸੀਂ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਲਈ ਰਿਗ੍ਰੈਸ਼ਨ ਵਿੱਚ ਗਹਿਰਾਈ ਵਿੱਚ ਜਾਣ ਲਈ ਤਿਆਰ ਹੋ। ਜਦੋਂ ਕਿ ਵਿਜੁਅਲਾਈਜ਼ੇਸ਼ਨ ਤੁਹਾਨੂੰ ਦੱਤੇ ਦਾ ਸਮਝ ਉਪਲਬਧ ਕਰਵਾਉਂਦੀ ਹੈ, ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੀ ਅਸਲ ਤਾਕਤ _ਮਾਡਲ ਟਰੇਨਿੰਗ_ ਵਿੱਚ ਹੈ। ਮਾਡਲ ਸਿੱਖਣਕਾਰੀ ਦੱਤੇ 'ਤੇ ਤਿਆਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਜੋ ਡੇਟਾ ਦੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਆਪੋ-ਆਪ ਦਿਖਾਉਂਦੇ ਹਨ, ਅਤੇ ਇਹ ਤੁਹਾਨੂੰ ਨਵੇਂ ਦੱਤੇ ਲਈ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦਿੰਦੇ ਹਨ, ਜਿਸ ਨੂੰ ਮਾਡਲ ਪਹਿਲਾਂ ਨਹੀਂ ਦੇਖਿਆ।
ਹੁਣ ਤੁਸੀਂ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਲਈ ਰਿਗ੍ਰੈਸ਼ਨ ਵਿੱਚ ਗਹਿਰਾਈ ਵਿੱਚ ਜਾਣ ਲਈ ਤਿਆਰ ਹੋ। ਜਦੋਂ ਕਿ ਵਿਜ਼ੂਅਲਾਈਜੇਸ਼ਨ ਡੇਟਾ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੀ ਅਸਲ ਤਾਕਤ _ਮਾਡਲ ਟ੍ਰੇਨਿੰਗ_ ਵਿੱਚ ਹੈ। ਮਾਡਲ ਪੁਰਾਣੇ ਡੇਟਾ ਤੇ ਟ੍ਰੇਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਤਾਂ ਜੋ ਖੁਦ-ਬ-ਖੁਦ ਡੇਟਾ ਦੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰ ਸਕਣ ਅਤੇ ਨਵੇਂ ਡੇਟਾ ਲਈ ਭਵਿੱਖਬਾਣੀ ਕਰ ਸਕਣ ਜੋ ਮਾਡਲ ਨੇ ਪਹਿਲਾਂ ਨਹੀਂ ਵੇਖਿਆ।
ਇਸ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਦੋ ਕਿਸਮ ਦੇ ਰਿਗ੍ਰੈਸ਼ਨ ਬਾਰੇ ਜ਼ਿਆਦਾ ਜਾਣੋਗੇ: _ਮੂਲ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ_ ਅਤੇ _ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ_, ਨਾਲ ਨਾਲ ਕੁਝ ਗਣਿਤ ਜੋ ਇਹ ਤਕਨੀਕਾਂ ਦਾ ਅਧਾਰ ਹੈ। ਇਹ ਮਾਡਲ ਸਾਨੂੰ ਪੰਪਕਿਨਾਂ ਦੀਆਂ ਕੀਮਤਾਂ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਦੇਣਗੇ ਜੋ ਵੱਖ-ਵੱਖ ਇੰਪੁੱਟ ਡੇਟਾ ਦੇ ਅਧਾਰ 'ਤੇ ਹਨ।
ਇਸ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਦੋ ਪ੍ਰਕਾਰ ਦੀਆਂ ਰਿਗ੍ਰੈਸ਼ਨ ਸਮਝੋਂਗੇ: _ਮੂਲ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ_ ਅਤੇ _ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ_, ਨਾਲ ਹੀ ਕੁਝ ਮੈਥਮੈਟਿਕਸ ਜੋ ਇਹ ਤਕਨੀਕਾਂ ਸਮਝਾਉਂਦੇ ਹਨ। ਅਜਿਹੇ ਮਾਡਲ ਸਾਡੇ ਲਈ ਵੱਖ-ਵੱਖ ਇਨਪੁੱਟ ਡੇਟਾ ਦੇ ਆਧਾਰ 'ਤੇ ਕਦੂ ਦੀ ਕੀਮਤ ਆਉਟਪੁੱਟ ਕਰਨਗੇ।
[![ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ML - ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਸਮਝਣਾ](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ML - ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਸਮਝਣਾ")
[![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ ਇੱਕ ਛੋਟਾ ਵੀਡੀਓ ਵੇਖਣ ਲਈ ਉਪਰ ਦਿੱਤੀ ਚਿੱਤਰ ਓਪਨ ਕਰੋ।
> 🎥 ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ ਛੋਟਾ ਵੀਡੀਓ ਵੇਖਣ ਲਈ ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
> ਸਾਡੇ ਇਸ ਪਾਠਕ੍ਰਮ ਵਿੱਚ ਵੱਡਾ ਗਣਿਤ ਗਿਆਨ ਨਹੀਂ ਲਿਆ ਜਾਂਦਾ, ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਹੋਰ ਖੇਤਰਾਂ ਦੇ ਵਿਦਿਆਰਥੀਆਂ ਲਈ ਅਸਾਨ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਇਸ ਲਈ ਨੋਟਸ, 🧮 ਕਾਲਆਊਟ, ਡਾਯਾਗ੍ਰਾਮ ਅਤੇ ਹੋਰ ਸਿੱਖਣ ਵਾਲੇ ਸੰਦ ਦੀ ਦੇਖਭਾਲ ਕਰੋ।
> ਇਸ ਕਰੀਕੁਲਮ ਵਿੱਚ, ਅਸੀਂ ਮਿਨੀਮਮ ਮੈਥ ਗਿਆਨ ਮੰਨਦੇ ਹਾਂ, ਅਤੇ ਵਿਦਿਆਰਥੀਆਂ ਲਈ ਜੋ ਹੋਰ ਖੇਤਰਾਂ ਤੋਂ ਆ ਰਹੇ ਹਨ, ਇਸਨੂੰ ਪਹੁੰਚਯੋਗ ਬਣਾਉਣ ਲਈ ਨੋਟ, 🧮 ਕਾਲਆਊਟਸ, ਡਾਇਗ੍ਰਾਮ ਅਤੇ ਹੋਰ ਸਿੱਖਣ ਵਾਲੇ ਸਾਧਨ ਸ਼ਾਮਲ ਕੀਤੇ ਹਨ।
### ਮੂਲ ਭੂਮਿਕਾ
### ਪੂਰਵ-ਆਵਸ਼੍ਯਕਤਾ
ਤੁਹਾਨੂੰ ਹੁਣ ਤੱਕ ਪੰਪਕਿਨ ਡੇਟਾ ਦੀ ਸੰਰਚਨਾ ਨਾਲ ਜਾਣੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਵੇਖ ਰਹੇ ਹਾਂ। ਇਹ ਡੇਟਾ ਇਸ ਪਾਠ ਦੇ ਨੋਟਬੁੱਕ.ipynb ਫਾਈਲ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਲੋਡ ਅਤੇ ਸਾਫ ਕੀਤਾ ਹੋਇਆ ਮਿਲੇਗਾ। ਫਾਈਲ ਵਿੱਚ, ਪੰਪਕਿਨ ਦੀ ਕੀਮਤ ਪ੍ਰਤੀ ਬਸ਼ਲ ਦਿਖਾਈ ਗਈ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਇਹ ਨੋਟਬੁੱਕਜ਼ ਵਿਜੁਅਲ ਸਟੂਡੀਓ ਕੋਡ ਵਿੱਚ ਕਰਨੇਲ ਵਿੱਚ ਚਲਾ ਸਕਦੇ ਹੋ।
ਹੁਣ ਤੱਕ ਤੁਸੀਂ ਉਸ ਕਦੂ ਡੇਟਾ ਦੀ ਸੰਰਚਨਾ ਨਾਲ ਪਰਚਿਤ ਹੋ ਜੋ ਅਸੀਂ ਜਾਂਚ ਰਹੇ ਹਾਂ। ਇਹ ਡੇਟਾ ਇਸ ਪਾਠ ਦੇ _notebook.ipynb_ ਫਾਈਲ ਵਿੱਚ ਪਹਿਲਾਂ ਲੋਡ ਅਤੇ ਸਾਫ ਸਿੱਧਾ ਕੀਤਾ ਹੋਇਆ ਹੈ। ਫਾਈਲ ਵਿੱਚ, ਕਦੂ ਦੀ ਕੀਮਤ ਸਲਾਨਾ ਪ੍ਰਤੀ ਬੁਸ਼ਲ ਦਰਜ਼ ਕੀਤੀ ਗਈ ਹੈ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਇਹ ਨੋਟਬੁੱਕਜ਼ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਕੋਡ ਵਿੱਚ ਕਰਨਲਾਂ ਵਿੱਚ ਚਲਾ ਸਕੋ।
### ਤਿਆਰੀ
ਇੱਕ ਯਾਦ ਕਰਾਉਣਾ, ਤੁਸੀਂ ਇਹ ਡੇਟਾ ਲੋਡ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਸਵਾਲ ਪੁੱਛ ਸਕੋ।
ਧਿਆਨ ਰੱਖਣ ਲਈ, ਤੁਸੀਂ ਇਸ ਡੇਟਾ ਨੂੰ ਲੋਡ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਜੋ ਇਸਦੇ ਬਾਰੇ ਸਵਾਲ ਪੁੱਛ ਸਕੋ।
- ਕਦੋਂ ਪੰਪਕਿਨ ਖਰੀਦਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਸਮਾਂ ਹੈ?
- ਮਿਨੀਏਚਰ ਪੰਪਕਿਨ ਦੇ ਕੇਸ ਦੀ ਕੀਮਤ ਕਿੰਨੀ ਹੋਵੇਗੀ?
- ਕੀ ਮੈਂ ਉਹਨਾਂ ਨੂੰ ਅਧਾ-ਬਸ਼ਲ ਟੋकरਿਆਂ ਵਿੱਚ ਖਰੀਦਾਂ ਜਾਂ 1 1/9 ਬਸ਼ਲ ਬਾਕਸ ਵਿੱਚ?
ਆਓ ਇਸ ਡੇਟਾ 'ਚ ਹੋਰ ਖੋਜ ਕਰੀਏ।
- ਕਦੂ ਖਰੀਦਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਸਮਾਂ ਕਦੋਂ ਹੈ?
- ਨanorרות ਕਦੂਆਂ ਦੀ ਇੱਕ ਕੇਸ ਦੀ ਕੀਮਤ ਕੀ ਹੋ ਸਕਦੀ ਹੈ?
- ਕੀ ਮੈਨੂੰ ਇਹਨਾਂ ਨੂੰ ਅੱਧਾ-ਬੁਸ਼ਲ ਟੋकरਿਆਂ ਵਿੱਚ ਖਰੀਦਣਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ 1 1/9 ਬੁਸ਼ਲ ਡੱਬੇ ਵਿੱਚ?
ਆਓ ਇਸ ਡੇਟਾ ਵਿੱਚ ਹੋਰ ਖੋਜ ਕਰੀਏ।
ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਪੈਂਡਸ ਦਾ ਡੇਟਾ ਫ੍ਰੇਮ ਬਣਾਇਆ ਅਤੇ ਮੂਲ ਡੇਟਾਸੈਟ ਦੇ ਹਿੱਸੇ ਨਾਲ ਭਰਿਆ, ਕੀਮਤ ਨੂੰ ਬਸ਼ਲ ਦੇ ਪੱਧਰ 'ਤੇ ਇੱਕਸਾਰ ਕਰਦੇ ਹੋਏ। ਪਰ ਇਸ ਤਰੀਕੇ ਨਾਲ, ਤੁਸੀਂ ਸਿਰਫ ਲਗਭਗ 400 ਡਾਟਾ ਪੁਆਇੰਟ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜੋ ਕਿ ਸਿਰਫ ਸ਼ਰਦ ਕਾਲ ਦੇ ਮਹੀਨੇ ਸਨ।
ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਪੈਂਡਾਸ ਡੇਟਾ ਫਰੇਮ ਬਣਾਇਆ ਸੀ ਅਤੇ ਮੂਲ ਡੇਟਾ ਸੈੱਟ ਨੂੰ ਬੁਸ਼ਲ ਦੀ ਕੀਮਤ ਦੇ ਅਨੁਸਾਰ ਪਰਮਾਣਿਤ ਕਰਕੇ ਭਰਿਆ ਸੀ। ਪਰ ਇਸ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ ਕੇਵਲ ਲਗਭਗ 400 ਡੇਟਾਪੌਇੰਟ ਹਾਸਲ ਕੀਤੇ ਜੋ ਸਿਰਫ਼ ਪਤਝੜ ਦੇ ਮਹੀਨਿਆਂ ਲਈ ਸਨ।
ਇਸ ਪਾਠ ਦੇ ਨਾਲ ਜੁੜੇ ਨੋਟਬੁੱਕ ਵਿੱਚ ਜੋ ਡੇਟਾ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਲੋਡ ਕੀਤਾ ਹੈ ਉਸ ਨੂੰ ਵੇਖੋ। ਡੇਟਾ ਪਹਿਲਾਂ ਹੀ ਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਸ਼ੁਰੂਆਤੀ scatterplot ਮਹੀਨੇ ਦਾ ਡੇਟਰ ਦਰਸਾਉਂਦਾ ਹੈ। ਸ਼ਾਇਦ ਅਸੀਂ ਇਸ ਡੇਟਾ ਕੁਝ ਹੋਰ ਸਾਫ਼-ਸਫਾਈ ਕਰਕੇ ਇਸ ਦੇ ਕੁਝ ਹੋਰ ਡੀਟੇਲ ਜਾ ਪਾ ਸਕਦੇ ਹਾਂ।
ਇਸ ਪਾਠ ਦੇ ਸਾਥ ਦੇ ਨੋਟਬੁੱਕ ਵਿੱਚ ਪਹਿਲਾਂ ਲੋਡ ਕੀਤੇ ਗਏ ਡੇਟਾ ਨੂੰ ਦੇਖੋ। ਡੇਟਾ ਪਹਿਲਾਂ ਲੋਡ ਕੀਤਾ ਹੋਇਆ ਹੈ ਅਤੇ ਪਹਿਲਾ ਸਕੈਟਰਪਲੌਟ ਦਰਸਾਇਆ ਗਿਆ ਹੈ ਜੋ ਮਹੀਨੇ ਦੇ ਡੇਟਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਸ਼ਾਇਦ ਅਸੀਂ ਇਸ ਡੇਟਾ ਦੀ ਕੁਝ ਹੋਰ ਵਿਸਥਾਰ ਜਾਣਣ ਲਈ ਇਸਨੂੰ ਹੋਰ ਸਾਫ ਕਰ ਸਕੀਏ।
## ਇੱਕ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ
## ਇੱਕ ਲਾਇਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਲੈੱਸਨ 1 ਵਿੱਚ ਸਿੱਖਿਆ, ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਅਭਿਆਸ ਦਾ ਲੱਕੜੀ ਦੀ ਰੇਖਾ ਖਿੱਚਣ ਦਾ ਟੀਚਾ ਹੁੰਦਾ ਹੈ ਤਾਂ ਕਿ:
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਪਾਠ 1 ਵਿੱਚ ਸਿਖਿਆ, ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਅਭਿਆਸ ਦਾ ਲਕੜ ਲਾਈਨ ਬਣਾਉਣ ਲਈ ਹੁੰਦਾ ਹੈ ਤਾਂ ਕਿ:
- **ਚਲ ਬਦਲ ਸੰਬੰਧ ਦਿਖਾਓ**। ਚਲਾਂ ਵਿਚਕਾਰ ਸੰਬੰਧ ਦਰਸਾਓ
- **ਭਵਿੱਖਬਾਣੀ ਕਰੋ**। ਇਹ ਭਵਿੱਖਬਾਣੀ ਕਰੋ ਕਿ ਨਵਾਂ ਡਾਟਾ ਅਧਾਰ ਲਾਈਨ ਦੇ ਕਿੱਥੇ ਪਏਗਾ।
ਇਹ ਆਮ ਤੌਰ 'ਤੇ **Least-Squares Regression** ਨੂੰ ਲਾਈਨ ਖਿੱਚਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "Least-Squares" ਸ਼ਬਦ ਮਾਡਲ ਵਿੱਚ ਕੁੱਲ ਗ਼ਲਤੀ ਘਟਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਹਰ ਡਾਟਾ ਪੁਆਇੰਟ ਲਈ, ਅਸੀਂ ਅਸਲੀ ਪੁਆਇੰਟ ਅਤੇ ਆਪਣੀ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ ਦਰਮਿਆਨ ਖੜ੍ਹੀ ਦੂਰੀ (ਜਿਸਨੂੰ `residual` ਕਹਿੰਦੇ ਹਨ) ਮਾਪਦੇ ਹਾਂ।
- **ਵੈਰੀਏਬਲ ਸੰਬੰਧ ਦਰਸਾਓ।** ਵੈਰੀਏਬਲਾਂ ਵਿਚਕਾਰ ਸੰਬੰਧ ਦਰਸਾਓ
- **ਭਵਿੱਖਬਾਣੀ ਕਰੋ।** ਨਵੇਂ ਡੇਟਾਪੌਇੰਟ ਕਿੱਥੇ ਪੈਂਦੇ ਹਨ, ਇਸਦਾ ਸਹੀ ਅੰਦਾਜ਼ਾ ਲਗਾਓ।
ਲੈਸਟ-ਸਕੁਆਰਸ ਰਿਗ੍ਰੈਸ਼ਨ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਲਾਈਨ ਖਿੱਚੀ ਜਾਂਦੀ ਹੈ। "ਲੈਸਟ-ਸਕੁਆਰਸ" ਸ਼ਬਦ ਸਾਡੀ ਮਾਡਲ ਵਿੱਚ ਕੁੱਲ ਗਲਤੀ ਘਟਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਹਰੇਕ ਡੇਟਾ ਪੁਆਇੰਟ ਲਈ, ਅਸੀਂ ਅਸਲ ਪੁਆਇੰਟ ਅਤੇ ਸਾਡੀ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ ਵਿਚਕਾਰ ਖੜ੍ਹੀ ਦੂਰੀ (ਜਿਸਨੂੰ ਰੈਜ਼ਿਡਿਊਅਲ ਕਹਿੰਦੇ ਹਨ) ਮਾਪਦੇ ਹਾਂ।
ਅਸੀਂ ਇਹ ਦੂਰੀਆਂ ਵਰਗਾ ਕਰਦੇ ਹਾਂ ਦੋ ਮੁੱਖ ਕਾਰਨਾਂ ਕਰਕੇ:
1. **ਦਿਸ਼ਾ ਦੀ ਬਜਾਏ ਅਕਾਰ**: ਅਸੀਂ -5 ਦੀ ਗ਼ਲਤੀ ਨੂੰ +5 ਜਿਵੇਂ ਹੀ ਮੰਨਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਵਰਗਾ ਕਰਨ ਨਾਲ ਸਾਰੇ ਮੁੱਲ ਸਕਾਰਾਤਮਕ ਹੋ ਜਾਂਦੇ ਹਨ।
1. **ਦਿਸ਼ਾ ਦੀ ਬਜਾਏ ਮਾਤਰਾ:** ਅਸੀਂ -5 ਦੀ ਗਲਤੀ ਨੂੰ +5 ਦੀ ਗਲਤੀ ਵਰਗਾ ਹੀ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਵਰਗਾ ਕਰਨ ਨਾਲ ਸਾਰੇ ਮੁੱਲ ਸਕਾਰਾਤਮਕ ਹੋ ਜਾਂਦੇ ਹਨ।
2. **ਬਹਿਰੂਏਂ (Outliers) ਨੂੰ ਸਜ਼ਾ ਦੇਣਾ**: ਵਰਗਾ ਕਰਨ ਨਾਲ ਵੱਡੀਆਂ ਗ਼ਲਤੀਆਂ ਨੂੰ ਹੋਰ ਭਾਰ ਮਿਲਦਾ ਹੈ, ਇਸ ਕਰਕੇ ਲਾਈਨ ਦੂਰੇ ਪੁਆਇੰਟਾਂ ਦੇ ਨੇੜੇ ਰਹਿੰਦੀ ਹੈ।
2. **ਆਊਟਲਾਇਅਰਜ਼ ਨੂੰ ਸਜ਼ਾ ਦੇਣਾ:** ਵਰਗਾ ਕਰਨ ਨਾਲ ਵੱਡੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਵੱਧ ਭਾਰ ਮਿਲਦਾ ਹੈ, ਜੋ ਲਾਈਨ ਨੂੰ ਦੂਰਦਰਾਜ਼ ਬਿੰਦੂਆਂ ਦੇ ਨੇੜੇ ਰਹਿਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ।
ਅਸੀਂ ਇਹ ਸਾਰੇ ਵਰਗੇ ਮੁੱਲ ਮਿਲਾ ਦੇਂਦੇ ਹਾਂ। ਸਾਡਾ ਟੀਚਾ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਉਹ ਲਾਈਨ ਲੱਭੀਏ ਜਿਸ ਲਈ ਇਹ ਅੰਤਿਮ ਜੋੜ ਘੱਟ ਤੋਂ ਘੱਟ ਹੋਵੇ—ਇਸੇ ਲਈ ਇਸਨੂੰ "Least-Squares" ਕਹਿੰਦੇ ਹਨ।
ਫਿਰ ਅਸੀਂ ਇਹ ਸਾਰੇ ਵਰਗੇ ਮੁੱਲ ਜੋੜ ਲੈਂਦੇ ਹਾਂ। ਸਾਡਾ ਲਕੜ ਹੈ ਉਹ ਖ਼ਾਸ ਲਾਈਨ ਲੱਭਣਾ ਜਿਸ ਤੇ ਇਹ ਕੁੱਲ ਜੋੜ ਸਭ ਤੋਂ ਘੱਟ ਹੁੰਦਾ ਹੈ (ਸਭ ਤੋਂ ਛੋਟਾ ਸੰਭਵ ਮੁੱਲ)—ਇਸ ਕਈ ਲਈ ਇਸਨੂੰ "ਲੈਸਟ-ਸਕੁਆਰਸ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
> **🧮 ਮੈਨੂੰ ਗਣਿਤ ਦਿਖਾਓ**
>
> ਇਹ ਲਾਈਨ, ਜਿਸਨੂੰ _ਸਭ ਤੋਂ ਵਧੀਆ ਫਿਟ ਲਾਈਨ_ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਇਸਨੂੰ [ਇਕ ਸਮੀਕਰਨ](https://en.wikipedia.org/wiki/Simple_linear_regression) ਰਾਹੀਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:
> ਇਸ ਲਾਈਨ ਨੂੰ _ਸਭ ਤੋਂ ਵਧੀਆ ਫਿੱਟ ਲਾਈਨ_ ਕਹਿੰਦੇ ਹਨ ਅਤੇ ਇਹ [ਇਕ ਸਮੀਕਰਨ](https://en.wikipedia.org/wiki/Simple_linear_regression) ਨਾਲ ਦਰਸਾਈ ਜਾ ਸਕਦੀ ਹੈ:
>
> ```
> Y = a + bX
> ```
>
> `X` ਨੂੰ 'ਵਿਆਖਿਆਤਮਕ ਚਲ' ਕਿਹਾ ਜਾਂਦਾ ਹੈ। `Y` ਨੂੰ 'ਆਧਾਰਿਤ ਚਲ' ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਲਾਈਨ ਦੀ ঢਲ `b` ਹੈ ਅਤੇ `a` y-ਇੰਟਰਸੈਪਟ ਹੈ, ਜਿਹੜਾ ਉਸ ਮੁੱਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਦੋਂ `X = 0` ਹੋਵੇ।
>
>![ਸਟੋਪ ਦੀ ਗਣਨਾ ਕਰੋ](../../../../translated_images/pa/slope.f3c9d5910ddbfcf9.webp)
>
> ਪਹਿਲਾਂ, ঢੱਲ `b` ਦੀ ਗਣਨਾ ਕਰੋ। ਇੰਨਫੋਗ੍ਰਾਫਿਕ [ਜੈਨ ਲੂਪਰ](https://twitter.com/jenlooper) ਵੱਲੋਂ
>
> ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਅਤੇ ਸਾਡੇ ਪੰਪਕਿਨ ਡੇਟਾ ਦੇ ਮੂਲ ਸਵਾਲ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦਿਆਂ: "ਪੰਪਕਿਨ ਦੀ ਕੀਮਤ ਮਹੀਨੇ ਪ੍ਰਤੀ ਬਸ਼ਲ ਦਿੱਤੇ ਜਾਣ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ", `X` ਕੀਮਤ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ `Y` ਵਿਕਰੀ ਦੇ ਮਹੀਨੇ ਨੂੰ।
>
>![ਸਮੀਕਰਨ ਪੂਰਾ ਕਰੋ](../../../../translated_images/pa/calculation.a209813050a1ddb1.webp)
>
> Y ਦਾ ਮੁੱਲ ਕੈਲਕੁਲੇਟ ਕਰੋ। ਜੇ ਤੁਸੀਂ ਲਗਭਗ 4 ਡਾਲਰ ਦੇ ਨੇੜੇ ਭੁਗਤਾਨ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਇਹ ਅਪ੍ਰੈਲ ਹੀ ਹੋ ਸਕਦਾ ਹੈ! ਇੰਨਫੋਗ੍ਰਾਫਿਕ [ਜੈਨ ਲੂਪਰ](https://twitter.com/jenlooper) ਵੱਲੋਂ
>
> ਜੋ ਗਣਿਤ ਲਾਈਨ ਦੀ ঢੱਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, ਉਸ ਨੂੰ ਦਰਸਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਇੰਟਰਸੈਪਟ 'ਤੇ ਵੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜਿਸ ਥਾਂ Y ਸਥਿਤ ਹੁੰਦਾ ਹੈ ਜਦੋਂ X = 0 ਹੋਵੇ।
>
> ਤੁਸੀਂ ਇਹ ਮੁੱਲ ਕੈਲਕੁਲੇਸ਼ਨ ਦਾ ਤਰੀਕਾ [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) ਵੈੱਬਸਾਈਟ ਤੇ ਵੇਖ ਸਕਦੇ ਹੋ। ਇੱਥੇ [Least-squares ਕੈਲਕੁਲੇਟਰ](https://www.mathsisfun.com/data/least-squares-calculator.html) ਤੇ ਵੀ ਜਾਓ ਹੇਠਾਂ ਵੇਖਣ ਲਈ ਕਿ ਕਿਸੇ ਸੰਖਿਆ ਦੇ ਮੁੱਲ ਲਾਈਨ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ।
## ਸਹਿਸੰਬੰਧ
ਹੋਰ ਇੱਕ ਸ਼ਬਦ ਸੋਝੀ ਰਹਿਣ ਲਈ ਸਮਝੋ ਉਹ ਹੈ **Correlation Coefficient** X ਅਤੇ Y ਚਲਾਂ ਦੇ ਵਿਚਕਾਰ। ਇੱਕ scatterplot ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ ਇਸ ਕੋਐਫੀਸ਼ੀਅਂਟ ਨੂੰ ਜਲਦੀ ਦੇਖ ਸਕਦੇ ਹੋ। ਜੇ ਡੇਟਾ ਪੁਆਇੰਟ ਇਕ ਲੰਮੀ ਰੇਖਾ ਵਿੱਚ scatter ਹੋਣ ਤਾਂ ਸਹਿਸੰਬੰਧ ਜ਼ਿਆਦਾ ਹੁੰਦਾ ਹੈ, ਪਰ ਜੇ ਪੁਆਇੰਟ ਦੁਨੀਆ ਭਰ ਵਿੱਚ scatter ਹੋਣ, ਸਹਿਸੰਬੰਧ ਘੱਟ ਹੁੰਦਾ ਹੈ।
ਇੱਕ ਵਧੀਆ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਉਹ ਹੋਵੇਗਾ ਜਿਸਦਾ Correlation Coefficient ਉੱਚਾ ਹੋਵੇ (0 ਦੀ ਬਜਾਏ 1 ਦੇ ਨੇੜੇ) Least-Squares Regression ਤਰੀਕੇ ਨਾਲ।
✅ ਇਸ ਪਾਠ ਨਾਲ ਜੁੜੇ ਨੋਟਬੁੱਕ ਨੂੰ ਰਨ ਕਰੋ ਅਤੇ ਮਹੀਨੇ ਤੋਂ ਕੀਮਤ scatterplot ਵੇਖੋ। ਕੀ ਮਹੀਨੇ ਨੂੰ ਕੀਮਤ ਨਾਲ ਸੰਬੰਧਿਤ ਡੇਟਾ ਵਿੱਚ ਉੱਚਾ ਜਾਂ ਘੱਟ ਸਹਿਸੰਬੰਧ ਮਹਿਲੂਸ ਹੁੰਦਾ ਹੈ, ਤੁਹਾਡੇ scatterplot ਦੇ ਵਿਜ਼ੂਅਲ ਅਨੁਭਵ ਮੁਤਾਬਕ? ਕੀ ਇਹ ਬਦਲਦਾ ਹੈ ਜੇ ਤੁਸੀਂ ਮਹੀਨੇ ਦੀ ਬਜਾਏ *ਸਾਲ ਦਾ ਦਿਨ* ਵਰਗਾ ਹੌਲੀ-ਥੋੜਾ ਮਾਪ ਲਵੋ (ਜਿਵੇਂ ਕਿ ਸਾਲ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਕਿੰਨੇ ਦਿਨ ਹੋਏ)?
ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਵਿੱਚ, ਅਸੀਂ ਮੰਨ ਲਏ ਹਾਂ ਕਿ ਅਸੀਂ ਡੇਟਾ ਸਾਫ਼ ਕਰ ਚੁੱਕੇ ਹਾਂ, ਅਤੇ ਇੱਕ ਡੇਟਾ ਫ੍ਰੇਮ ਬਣਾਇਆ ਹੈ ਜਿਸਦਾ ਨਾਮ ਹੈ `new_pumpkins`, ਜੋ ਇਸ ਤਰ੍ਹਾਂ ਹੈ:
ID | ਮਹੀਨਾ | ਸਾਲ ਦਾ ਦਿਨ | ਕਿਸਮ | ਸ਼ਹਿਰ | ਪੈਕেজ | ਘੱਟ ਕੀਮਤ | ਉੱਚ ਕੀਮਤ | ਕੀਮਤ
---|--------|-------------|-------|--------|----------|---------------|--------------|--------
70 | 9 | 267 | ਪਾਈ ਟਾਈਪ | ਬਾਲਟਿਮੋਰ | 1 1/9 ਬਸ਼ਲ ਕਾਰਟਨ | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | ਪਾਈ ਟਾਈਪ | ਬਾਲਟਿਮੋਰ | 1 1/9 ਬਸ਼ਲ ਕਾਰਟਨ | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | ਪਾਈ ਟਾਈਪ | ਬਾਲਟਿਮੋਰ | 1 1/9 ਬਸ਼ਲ ਕਾਰਟਨ | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | ਪਾਈ ਟਾਈਪ | ਬਾਲਟਿਮੋਰ | 1 1/9 ਬਸ਼ਲ ਕਾਰਟਨ | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | ਪਾਈ ਟਾਈਪ | ਬਾਲਟਿਮੋਰ | 1 1/9 ਬਸ਼ਲ ਕਾਰਟਨ | 15.0 | 15.0 | 13.636364
> ਡੇਟਾ ਸਾਫ਼ ਕਰਨ ਦਾ ਕੋਡ [`notebook.ipynb`](notebook.ipynb) ਵਿੱਚ ਉਪਲਬਧ ਹੈ। ਅਸੀਂ ਪਿਛਲੇ ਪਾਠ ਨਾਲੋ ਹੀ ਸਾਫ਼ੀਏ ਕਦਮ ਕੀਤੇ ਹਨ, ਅਤੇ `DayOfYear` ਕਾਲਮ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਭਿਵੈਕਤੀ ਨਾਲ ਕੈਲਕੁਲੇਟ ਕੀਤਾ ਹੈ:
>
> `X` 'ਵਿਆਖਿਆਤਮਕ ਵੈਰੀਏਬਲ' ਹੈ। `Y` 'ਨਿਰਭਰ ਵੈਰੀਏਬਲ' ਹੈ। ਲਾਈਨ ਦੀ ਢਲਾਣ `b` ਹੈ ਅਤੇ `a` y-ਇੰਟਰਸੈਪਟ ਹੈ, ਜੋ `X = 0` ਹੋਣ 'ਤੇ `Y` ਦਾ ਮੁੱਲ ਦੱਸਦਾ ਹੈ।
>
>![calculate the slope](../../../../translated_images/pa/slope.f3c9d5910ddbfcf9.webp)
>
> ਪਹਿਲਾਂ, ਢਲਾਣ `b` ਦੀ ਗਣਨਾ ਕਰੋ। ਇਨਫੋਗ੍ਰਾਫਿਕ [ਜੇਨ ਲੂਪਰ](https://twitter.com/jenlooper) ਵੱਲੋਂ।
>
> ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਸਾਡੇ ਕਦੂ ਡੇਟਾ ਦੇ ਮੂਲ ਸਵਾਲ ਦਾ ਗਿਆਨ ਕਰਦਾ: "ਹਰ ਮਹੀਨੇ ਪ੍ਰਤੀ ਬੁਸ਼ਲ ਕਦੂ ਦੀ ਕੀਮਤ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰੋ", `X` ਕੀਮਤ ਨੂੰ ਦਰਸਾਏਗਾ ਅਤੇ `Y` ਵਿਕਰੀ ਦੇ ਮਹੀਨੇ ਨੂੰ।
>
>![complete the equation](../../../../translated_images/pa/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 ਵੈਰੀਏਬਲਾਂ ਵਿਚਕਾਰ ਦਾ **ਕੋਰਲੇਸ਼ਨ ਕੋਇਫੀਸ਼ੀਅਂਟ**। ਸਕੈਟਰਪਲੌਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ ਇਸ ਕੋਇਫੀਸ਼ੀਅਂਟ ਨੂੰ ਤੁਰੰਤ ਵਿਜ਼ੂਲਾਈਜ਼ ਕਰ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਡੇਟਾਪੌਇੰਟ ਸਿੱਧੀ ਲਾਈਨ 'ਚ ਖਿੜੇ ਹੋਣ, ਤਾਂ ਕੋਰਲੇਸ਼ਨ ਉੱਚਾ ਹੁੰਦਾ ਹੈ, ਪਰ ਜੇ ਪੁਆਇੰਟ ਹਰ ਥਾਂ ਖਿੱਡੇ ਹੋਣ, ਤਾਂ ਕੋਰਲੇਸ਼ਨ ਘੱਟ ਹੁੰਦਾ ਹੈ।
ਵਧੀਆ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਉਹਹੋਂ ਜੋ ਲੈਸਟ-ਸਕੁਆਰਸ ਰਿਗ੍ਰੈਸ਼ਨ ਤਰੀਕੇ ਨਾਲ ਇੱਕ ਲਾਈਨ ਦੇ ਨਾਲ ਉੱਚ (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)
```
ਹੁਣ ਜਦੋਂ ਤੁਸੀਂ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਮੈਥ ਦੀ ਸਮਝ ਰੱਖਦੇ ਹੋ, ਆਓ ਇੱਕ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਈਏ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲੱਗ ਸਕੇ ਕਿ ਕਿਹੜਾ ਕਦੂ ਪੈਕੇਜ ਸਭ ਤੋਂ ਵਧੀਆ ਕੀਮਤ ਦੇਵੇਗਾ। ਜਿਹੜਾ ਕੋਈ ਅਜਿਹਾ ਛੁੱਟੀਆਂ ਵਾਲਾ ਕਦੂ ਪੈਚ ਲਈ ਕਦੂ ਖਰੀਦਦਾ ਹੈ, ਉਹ ਇਸ ਜਾਣਕਾਰੀ ਨੂੰ ਪੈਚ ਲਈ ਕਦੂ ਪੈਕੇਜਾਂ ਦੀ ਖਰੀਦ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਵਰਤ ਸਕਦਾ ਹੈ।
ਹੁਣ ਜਦੋਂ ਕਿ ਤੁਹਾਨੂੰ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਮੂਲ ਗਣਿਤ ਬਾਰੇ ਸਮਝ ਹੋ ਗਈ ਹੈ, ਚਲੋ ਇੱਕ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਈਏ ਤਾਂ ਜੋ ਦੇਖੀਏ ਕਿ ਅਸੀਂ ਕੋਈ ਪੰਪਕਿਨ ਪੈਕਜੇਂਗ ਦੇ ਚੰਗੇ ਕੀਮਤੀ ਪੰਪਕਿਨ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਨਹੀਂ। ਕੋਈ ਵਿਅਕਤੀ ਜੋ ਛੁੱਟੀਆਂ ਲਈ ਪੰਪਕਿਨ ਪੈਚ ਖਰੀਦ ਰਿਹਾ ਹੈ, ਉਹ ਆਪਣੀਆਂ ਖਰੀਦੀਆਂ ਨੂੰ optimize ਕਰਨ ਲਈ ਇਹ ਜਾਣਕਾਰੀ ਚਾਹੁੰਦਾ ਹੋ ਸਕਦਾ ਹੈ।
## ਕੋਰਲੇਸ਼ਨ ਦੀ ਤਲਾਸ਼
## ਸਹਿਸੰਬੰਧ ਲੱਭਣਾ
[![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")
[![ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ML - ਸਹਿਸੰਬੰਧ ਲੱਭਣਾ: ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਦੀ ਚਾਬੀ](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ML - ਸਹਿਸੰਬੰਧ ਲੱਭਣਾ: ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਦੀ ਚਾਬੀ")
> 🎥 ਉਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿੱਕ ਕਰਕੇ ਕੋਰਲੇਸ਼ਨ ਬਾਰੇ ਛੋਟਾ ਵੀਡੀਓ ਵੇਖੋ।
> 🎥 ਸਹਿਸੰਬੰਧ ਦਾ ਛੋਟਾ ਵੀਡੀਓ ਵੇਖਣ ਲਈ ਉਪਰ ਦਿੱਤੀ ਚਿੱਤਰ ਤਿੱਪੜੀ ਕਰੋ।
ਪਿਛਲੇ ਪਾਠ ਤੋਂ ਇਹ ਜਿਹੜਾ ਤੁਸੀਂ ਦੇਖਿਆ ਹੈ ਕਿ ਵੱਖ-ਵੱਖ ਮਹੀਨਿਆਂ ਦੀ ਔਸਤ ਕੀਮਤ ਇਸ ਪ੍ਰਕਾਰ ਹੈ:
ਪਿਛਲੇ ਪਾਠ ਤੋਂ ਤੁਸੀਂ ਦੇਖਿਆ ਹੋਵੇਗਾ ਕਿ ਵੱਖ-ਵੱਖ ਮਹੀਨਿਆਂ ਲਈ ਔਸਤ ਕੀਮਤ ਇਸ ਤਰ੍ਹਾਂ ਹੈ:
<img alt="Average price by month" src="../../../../translated_images/pa/barchart.a833ea9194346d76.webp" width="50%"/>
<img alt="ਮਹੀਨੇ ਲਈ ਔਸਤ ਕੀਮਤ" src="../../../../translated_images/pa/barchart.a833ea9194346d76.webp" width="50%"/>
ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੁਝ ਕੋਰਲੇਸ਼ਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ ਤਾਂ ਜੋ `Month` ਅਤੇ `Price` ਜਾਂ `DayOfYear` ਅਤੇ `Price` ਵਿਚਕਾਰ ਸੰਬੰਧ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰ ਸਕੀਏ। ਹੇਠਾਂ ਉਸ ਸੰਬੰਧ ਨੂੰ ਦਰਸਾਉਂਦਾ ਸਕੈਟਰਪਲੌਟ ਹੈ:
ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕਿਛ ਸਹਿਸੰਬੰਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਤਿਆਰ ਕਰਕੇ ਮਹੀਨਾ ਅਤੇ ਕੀਮਤ ਦੇ ਦਰਮਿਆਨ ਜਾਂ ਸਾਲ ਦੇ ਦਿਨ ਅਤੇ ਕੀਮਤ ਦੇ ਦਰਮਿਆਨ ਸੰਬੰਧ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰੀਏ। ਹੇਠਾਂ scatter plot ਹੈ ਜੋ ਬਾਅਦਲੇ ਸੰਬੰਧ ਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ:
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/pa/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
<img alt="ਕੀਮਤ ਵਿਰੁੱਧ ਸਾਲ ਦਾ ਦਿਨ scatter plot" src="../../../../translated_images/pa/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
ਚਲੋ ਵੇਖੀਏ ਕਿ `corr` ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਹਿਸੰਬੰਧ ਹੈ ਕਿ ਨਹੀਂ:
ਚਲੋ ਦੇਖੀਏ `corr` ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੋਈ ਕੋਰਲੇਸ਼ਨ ਹੈ:
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
ਲੱਗਦਾ ਹੈ ਕਿ ਸਹਿਸੰਬੰਧ ਕੁਝ ਘੱਟ ਹੈ, ਮਹੀਨੇ ਲਈ -0.15 ਅਤੇ ਸਾਲ ਦੇ ਦਿਨ ਲਈ -0.17, ਪਰ ਹੋ ਸਕਦਾ ਹੈ ਕੋਈ ਹੋਰ ਮਹੱਤਵਪੂਰਣ ਸੰਬੰਧ ਹੋਵੇ। ਲੱਗਦਾ ਹੈ ਕਿ ਕੀਮਤਾਂ ਦੀ ਵੱਖ-ਵੱਖ ਸ਼੍ਰੇਣੀਆਂ ਹਨ ਜੋ ਵੱਖ-ਵੱਖ ਪੰਪਕਿਨ ਕਿਸਮਾਂ ਨਾਲ ਸੰਬੰਧਤ ਹਨ। ਇਸ ਪਰਿਕਲਪਨਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ, ਆਓ ਹਰ ਸ਼੍ਰੇਣੀ ਨੂੰ ਵੱਖ-ਵੱਖ ਰੰਗ ਦੇ ਕੇ plot ਕਰੀਏ। `ax`参数 `scatter` plotting ਫੰਕਸ਼ਨ ਨੂੰ ਦੇ ਕੇ ਅਸੀਂ ਸਾਰੇ ਪੁਆਇੰਟ ਇਕੱਠੇ ਇੱਕ ਗ੍ਰਾਫ਼ 'ਤੇ ਦਰਸਾ ਸਕਦੇ ਹਾਂ:
ਲੱਗਦਾ ਹੈ ਕੋਰਲੇਸ਼ਨ ਕਾਫੀ ਘੱਟ ਹੈ, -0.15 `Month` ਦੇ ਨਾਲ ਅਤੇ -0.17 `DayOfYear` ਦੇ ਨਾਲ, ਪਰ ਹੋਰ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸੰਬੰਧ ਹੋ ਸਕਦਾ ਹੈ। ਵੱਖ-ਵੱਖ ਕਦੂ ਕਿਸਮਾਂ ਨਾਲ ਸਬੰਧਤ ਕਈ ਕੀਮਤ ਕਲੱਸਟਰ ਬਣਦੇ ਹਨ। ਇਸ ਨੂੰ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ, ਅਸੀਂ ਹਰ ਕਦੂ ਸ਼੍ਰੇਣੀ ਨੂੰ ਵੱਖਰੇ ਰੰਗ ਨਾਲ ਦਰਸਾਉਂਦੇ ਹਾਂ। `scatter` ਫੰਕਸ਼ਨ ਨੂੰ `ax` ਪੈਰਾਮੀਟਰ ਦੇ ਕੇ ਸਾਰੇ ਪੁਆਇੰਟ ਇਕੱਠੇ ਇੱਕ ਗ੍ਰਾਫ 'ਤੇ ਪਲੌਟ ਕਰ ਸਕਦੇ ਹਾਂ:
```python
ax=None
@ -139,75 +139,76 @@ 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)
```
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/pa/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
<img alt="ਕੀਮਤ ਵਿਰੁੱਧ ਸਾਲ ਦਾ ਦਿਨ scatter plot (ਰੰਗ ਨਾਲ)" src="../../../../translated_images/pa/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
ਸਾਡੀ ਜਾਂਚ ਇਹ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਕਿਸਮ ਦੀ ਵਧੇਰੇ ਅਸਰ ਪੂਰੀ ਕੀਮਤ 'ਤੇ ਹੁੰਦਾ ਹੈ ਨਾਂ ਕਿ ਵੇਚਣ ਦੀ ਅਸਲੀ ਤਾਰੀਖ 'ਤੇ। ਅਸੀਂ ਇਹ ਇੱਕ ਬਾਰ ਗ੍ਰਾਫ਼ ਨਾਲ ਵੇਖ ਸਕਦੇ ਹਾਂ:
ਸਾਡੇ ਅਧਿਐਨ ਮੁਤਾਬਕ, ਕਦੂ ਦੀ ਕਿਸਮ ਦੀ ਵਿਕਰੀ ਦੀ ਮਿਤੀ ਨਾਲੋਂ ਵੱਧ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ। ਇਹ ਅਸੀਂ ਇੱਕ ਬਾਰ ਗ੍ਰਾਫ ਨਾਲ ਵੀ ਵੇਖ ਸਕਦੇ ਹਾਂ:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
<img alt="Bar graph of price vs variety" src="../../../../translated_images/pa/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
<img alt="ਕੀਮਤ ਵਿਰੁੱਧ ਕਿਸਮ ਦਾ ਬਾਰ ਗ੍ਰਾਫ਼" src="../../../../translated_images/pa/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
ਆਓ ਇਸ ਵੇਲੇ ਸਿਰਫ਼ ਇੱਕ ਪੰਪਕਿਨ ਕਿਸਮ, 'ਪਾਈ ਟਾਈਪ' 'ਤੇ ਧਿਆਨ ਦਈਏ ਅਤੇ ਵੇਖੀਏ ਕਿ ਮਿਤੀ ਦੀ ਕੀਮਤ ਤੇ ਕੀ ਅਸਰ ਪੈਂਦਾ ਹੈ:
ਆਓ ਵਾਰਤੋਂ ਸਿਰਫ਼ ਇੱਕ ਕਦੂ ਕਿਸਮ ‘ਪਾਈ ਟਾਈਪ’ ਤੇ ਧਿਆਨ ਦਿਓ ਅਤੇ ਵੇਖੋ ਕਿ ਮਿਤੀ ਦਾ ਕੀ ਪ੍ਰਭਾਵ ਕੀਮਤ 'ਤੇ ਪੈਂਦਾ ਹੈ:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
<img alt="ਕੀਮਤ ਵਿਰੁੱਧ ਸਾਲ ਦਾ ਦਿਨ scatter plot - ਪਾਈ ਪੰਪਕਿਨ" src="../../../../translated_images/pa/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/pa/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
ਜੇ ਹੁਣ ਅਸੀਂ `Price` ਅਤੇ `DayOfYear` ਵਿੱਚ correlation ਗਣਨਾ ਕਰੀਏ `corr` ਫੰਕਸ਼ਨ ਨਾਲ, ਤਾਂ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਮਿਲੇਗਾ: `-0.27` - ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਕ predictive ਮਾਡਲ ਸਿੱਖਣਾ ਸਮਝਦਾਰ ਹੈ।
ਹੁਣ ਜੇ ਅਸੀਂ `corr` ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਕੇ `Price` ਅਤੇ `DayOfYear` ਵਿਚਕਾਰ ਕੋਰਲੇਸ਼ਨ ਕੈਲਕੁਲੇਟ ਕਰੀਏ, ਤਾਂ ਲਗਭਗ `-0.27` ਆਵੇਗਾ - ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਟ੍ਰੇਨਿੰਗ ਲਈ ਮਾਡਲ ਬਣਾਉਣਾ ਸਮਝਦਾਰ ਹੈ।
> ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਸਿਖਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਸਾਡਾ ਡੇਟਾ ਸਾਫ਼ ਹੋਵੇ। ਖਾਲੀ ਮੁੱਲਾਂ ਨਾਲ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਅਚ্ছে ਤਰ੍ਹਾਂ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਇਸ ਲਈ ਸਾਰੇ ਖਾਲੀ ਕੋਸ਼ਿਕਾਂ ਨੂੰ ਹਟਾਉਣਾ ਬਿਹਤਰ ਹੈ:
> ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸਾਡਾ ਡੇਟਾ ਸਾਫ ਹੈ। ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਗੈਰ-ਮੌਜੂਦ ਮੁੱਲਾਂ ਨਾਲ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਇਸ ਲਈ ਸਾਰੇ ਖਾਲੀ ਸੈੱਲ ਹਟਾਉਣਾ ਸਹੀ ਹੈ:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਨ੍ਹਾਂ ਖਾਲੀ ਮੁੱਲਾਂ ਨੂੰ ਉਸ ਕਾਲਮ ਦੀ ਸਾਰਥਕ ਔਸਤ ਮੁੱਲ ਨਾਲ ਭਰ ਦਿੱਤਾ ਜਾਵੇ।
ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਨ੍ਹਾਂ ਖਾਲੀ ਮੁੱਲਾਂ ਨੂੰ ਉਸ ਕਾਲਮ ਦੇ ਮੀਨ ਮੁੱਲ ਨਾਲ ਭਰ ਦਿੱਤਾ ਜਾਵੇ।
## ਸਰਲ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ
## ਸਧਾਰਣ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ
[![ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ML - ਸਕਾਇਕਿਟ-ਲਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਈਨੀਅਰ ਅਤੇ ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ML - ਸਕਾਇਕਿਟ-ਲਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਈਨੀਅਰ ਅਤੇ ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ")
[![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")
> 🎥 ਲਾਈਨੀਅਰ ਅਤੇ ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ ਛੋਟਾ ਵੀਡੀਓ ਵੇਖਣ ਲਈ ਉਪਰ ਦਿੱਤੀ ਚਿੱਤਰ ਤੇ ਕਲਿੱਕ ਕਰੋ।
> 🎥 ਉਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿੱਕ ਕਰ ਕੇ ਲਾਈਨੀਅਰ ਅਤੇ ਪੋਲੀਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ ਛੋਟਾ ਵੀਡੀਓ ਵੇਖੋ।
ਆਪਣਾ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਟਰੇਨ ਕਰਨ ਲਈ, ਅਸੀਂ **Scikit-learn** ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।
ਸਾਡਾ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਅਸੀਂ **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 ਡੇਟਾ ਸੈੱਟ ਦਾ ਆਕਾਰ ਹੈ।
> ਧਿਆਨ ਦਿਓ ਕਿ ਸਾਨੂੰ ਇੰਪੁੱਟ ਡੇਟਾ ਤੇ `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` ਮੈਥਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੇਟਾ 'ਤੇ ਫਿੱਟ ਕਰਦੇ ਹਾਂ:
ਆਖਿਰਕਾਰ, ਅਸਲ ਲਾਈਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਸਿਰਫ ਦੋ ਲਾਈਨਾਂ ਕੋਡ ਲੱਗਦੀਆਂ ਹਨ। ਅਸੀਂ `LinearRegression` ਆਬਜੈਕਟ ਬਣਾਉਂਦੇ ਹਾਂ, ਅਤੇ `fit` ਮੈਥਡ ਨਾਲ ਆਪਣੇ ਡੇਟਾ 'ਤੇ ਫਿੱਟ ਕਰਦੇ ਹਾਂ:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
`LinearRegression` ਓਬਜੈਕਟ `fit` ਕਰਨ ਤੋਂ ਬਾਦ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਸਾਰੇ ਕੋਐਫੀਸ਼ਿਅਂਟ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ `.coef_` ਪ੍ਰਾਪਰਟੀ ਰਾਹੀਂ ਪਹੁੰਚਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਿਰਫ ਇਕ ਕੋਐਫੀਸ਼ਿਅਂਟ ਹੈ, ਜੋ ਲਗਭਗ `-0.017` ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੀਮਤਾਂ ਸਮੇਂ ਨਾਲ ਕੁਝ ਘਟਦੀਆਂ ਹਨ, ਪਰ ਜ਼ਿਆਦਾ ਨਹੀਂ, ਲਗਭਗ 2 ਸੈਂਟ ਪ੍ਰਤੀ ਦਿਨ। ਅਸੀਂ ਵਾਈ-ਆਕਸਿਸ ਨਾਲ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਇੰਟਰਸੈਕਸ਼ਨ ਪੁਆਇੰਟ ਨੂੰ ਵੀ `lin_reg.intercept_` ਰਾਹੀਂ ਪਹੁੰਚ ਸਕਦੇ ਹਾਂ - ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ ਇਹ ਲਗਭਗ `21` ਹੋਵੇਗਾ, ਜੋ ਸਾਲ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਕੀਮਤ ਦਰਸਾਉਂਦਾ ਹੈ।
`LinearRegression` ਵਸਤੂ `fit` ਕਰਨ ਤੋਂ ਬਾਅਦ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਸਾਰੇ ਕੋਐਫੀਸ਼ੀਅੰਟਸ ਨੂੰ ਰੱਖਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਤੱਕ `.coef_` ਪ੍ਰਾਪਰਟੀ ਦੇ ਜ਼ਰੀਏ ਪਹੁੰਚ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਿਰਫ ਇਕ ਕੋਐਫੀਸ਼ੀਅੰਟ ਹੈ, ਜੋ ਲਗਭਗ `-0.017` ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੀਮਤਾਂ ਸਮੇਂ ਦੇ ਨਾਲ ਕੁਝ ਘਟਦੀਆਂ ਹਨ, ਪਰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਹੀਂ, ਲਗਭਗ 2 ਸੈਂਟ ਪ੍ਰਤੀ ਦਿਨ। ਅਸੀਂ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ Y-ਅਕਸ ਨਾਲ ਕੱਟਦਾ ਬਿੰਦੂ ਵੀ `lin_reg.intercept_` ਦੀ ਵਰਤੋਂ ਨਾਲ ਪਤਾ ਕਰ ਸਕਦੇ ਹਾਂ - ਇਹ ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ ਲਗਭਗ `21` ਹੋਵੇਗਾ, ਜੋ ਸਾਲ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਕੀਮਤ ਦਰਸਾਉਂਦਾ ਹੈ।
ਸਾਡਾ ਮਾਡਲ ਕਿੰਨਾ ਸਹੀ ਹੈ ਦੇਖਣ ਲਈ, ਅਸੀਂ ਟੈਸਟ ਡੇਟਾਸੇਟ 'ਤੇ ਕੀਮਤਾਂ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰ ਸਕਦੇ ਹਾਂ, ਫਿਰ ਉਹਨਾਂ ਭਵਿੱਖਬਾਣੀਆਂ ਨੂੰ ਉਮੀਦਵਾਰ ਮੁੱਲਾਂ ਨਾਲ ਕਿੰਨਾ ਨੇੜੇ ਹਨ ਮਾਪ ਸਕਦੇ ਹਾਂ। ਇਹ ਰੂਟ ਮੀਨ ਸਕਵੇਅਰ ਤਰੁੱਟ (RMSE) ਮੈਟਰਿਕਸ ਦੇ ਜ਼ਰੀਏ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਉਮੀਦਵਾਰ ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਕੀਤੇ ਮੁੱਲਾਂ ਵਿਚਕਾਰ ਸਾਰੇ ਵਰਗਾਂ ਦੇ ਫਰਕਾਂ ਦੇ ਮੀਨ ਦਾ ਵਰਗਮੂਲ ਹੁੰਦਾ ਹੈ।
ਸਾਡਾ ਮਾਡਲ ਕਿੰਨਾ ਠੀਕ ਹੈ, ਇਹ ਵੇਖਣ ਲਈ ਅਸੀਂ ਟੈਸਟ ਡੇਟਾਸੈੱਟ 'ਤੇ ਕੀਮਤਾਂ ਦੀ ਪੇਸ਼ਗੀਬੀ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਸਾਡੇ ਪੇਸ਼ਗੀਬੀ ਕੀਤੀ ਕੀਮਤਾਂ ਅਦਾਇਗੀ ਕੀਮਤਾਂ ਦੇ ਕਰੀਬ ਕਿੰਨੀ ਹਨ। ਇਹ ਰੂਟ ਮੂਨ ਸਕਵੇਅਰ ਐਰਰ (RMSE) ਮਾਪਦੰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਉਮੀਦ ਕੀਤੇ ਅਤੇ ਪੇਸ਼ਗੀਬੀ ਕੀਤੇ ਮੁੱਲਾਂ ਵਿਚਕਾਰ ਸਭ ਸਕਵੇਅਰ ਕੀਤੇ ਅੰਤਰਾਂ ਦੇ ਮੂਨ ਦਾ ਰੂਟ ਹੁੰਦਾ ਹੈ।
```python
pred = lin_reg.predict(X_test)
@ -216,15 +217,15 @@ rmse = np.sqrt(mean_squared_error(y_test,pred))
print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
```
ਸਾਡੀ ਤਰੁੱਟ ਲਗਭਗ 2 ਅੰਕ ਹੈ, ਜੋ ਕਿ ~17% ਹੈ। ਬਹੁਤ ਵਧੀਆ ਨਹੀਂ। ਮਾਡਲ ਦੀ ਕੁਆਲਟੀ ਦੀ ਇੱਕ ਹੋਰ ਸੂਚਕ ਹੈ **ਡਿਟਰਮੀਨੇਸ਼ਨ ਕੋਐਫੀਸ਼ੀਅੰਟ**, ਜੋ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:
ਸਾਡੇ ਭુલ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਭਗ 2 ਪੋਇੰਟ ਹੈ, ਜੋ ਕਿ ~17% ਹੈ। ਬਹੁਤ ਚੰਗਾ ਨਹੀਂ। ਮਾਡਲ ਗੁਣਵੱਤਾ ਦਾ ਇੱਕ ਹੋਰ ਸੰਕੇਤ ਹੈ **ਨੀਰਧਾਰਿਤਤਾ ਕੋਇਫ਼ੀਸ਼ਿਅਂਟ** (coefficient of determination), ਜਿਸ ਨੂੰ ਇਨ੍ਹਾਂ ਤਰ੍ਹਾਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
ਜੇਕਰ ਇਹ ਮੁੱਲ 0 ਹੈ, ਤਾਂ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮਾਡਲ ਇਨਪੁਟ ਡੇਟਾ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਨਹੀਂ ਲੈਂਦਾ, ਅਤੇ ਸਭ ਤੋਂ ਕਮਜ਼ੋਰ ਰੇਖੀਅ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਵਾਲੇ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਜੋ ਕੇਵਲ ਨਤੀਜੇ ਦਾ ਔਸਤ ਮੁੱਲ ਹੁੰਦਾ ਹੈ। ਮੁੱਲ 1 ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਅਸੀਂ ਬਿਲਕੁਲ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸਾਰੇ ਉਮੀਦਵਾਰ ਨਤੀਜੇ ਭਵਿੱਖਬਾਣੀ ਕਰ ਸਕਦੇ ਹਾਂ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਹ ਕੋਐਫੀਸ਼ੀਅੰਟ ਲਗਭਗ 0.06 ਹੈ, ਜੋ ਕਾਫ਼ੀ ਘੱਟ ਹੈ।
ਜੇ ਇਹ ਮੁੱਲ 0 ਹੈ, ਤਾਂ ਇਹ ਮਤਲਬ ਹੈ ਕਿ ਮਾਡਲ ਇਨਪੁੱਟ ਡੇਟਾ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਨਹੀਂ ਲੈਂਦਾ, ਅਤੇ ਇਹ ਸਭ ਤੋਂ ਮਾੜਾ ਰੇਖੀਅ ਪੇਸ਼ਗੀਬਾਜ਼ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਸਿਰਫ਼ ਨਤੀਜੇ ਦਾ ਮੀਨ ਮੁੱਲ ਹੁੰਦਾ ਹੈ। 1 ਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਸਾਰੀਆਂ ਉਮੀਦ ਕੀਤੀਆਂ ਨਤੀਜਿਆਂ ਨੂੰ ਬਿਲਕੁਲ ਸਹੀ ਢੰਗ ਨਾਲ ਪੇਸ਼ਗੀਬੀ ਕਰ ਸਕਦੇ ਹਾਂ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਕੋਇਫ਼ੀਸ਼ਿਅਂਟ ਲਗਭਗ 0.06 ਹੈ, ਜੋ ਕਾਫ਼ੀ ਘੱਟ ਹੈ।
ਅਸੀਂ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ ਦੇ ਨਾਲ ਟੈਸਟ ਡੇਟਾ ਨੂੰ ਵੀ ਪਲੌਟ ਕਰ ਸਕਦੇ ਹਾਂ ਤਾਂ ਜੋ ਦੇਖ ਸਕੀਏ ਕਿ ਸਾਡੇ ਹਾਲਾਤ ਵਿੱਚ ਰਿਗ੍ਰੈਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:
ਅਸੀਂ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ ਦੇ ਨਾਲ ਟੈਸਟ ਡੇਟਾ ਨੂੰ ਵੀ ਪਲਾਟ ਕਰ ਸਕਦੇ ਹਾਂ ਤਾਂ ਜੋ ਵੇਖ ਸਕੀਏ ਕਿ ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ ਰਿਗ੍ਰੈਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:
```python
plt.scatter(X_test,y_test)
@ -233,19 +234,19 @@ plt.plot(X_test,pred)
<img alt="Linear regression" src="../../../../translated_images/pa/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
## ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ
## Polynomial Regression
ਰੈਖੀਅ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ ਇੱਕ ਹੋਰ ਪ੍ਰਕਾਰ ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਹੈ। ਕਦੇ-ਕਦੇ ਵੈਰੀਏਬਲਾਂ ਵਿਚਕਾਰ ਰੇਖੀਅ ਸੰਬੰਧ ਹੁੰਦਾ ਹੈ – ਜਿਵੇਂ ਕਿ ਵਾਅਲੇ ਦੀ ਮਾਤਰਾ ਵਧਣ ਤੇ ਕੀਮਤ ਵਧਦੀ ਹੈ - ਪਰ ਕਈ ਵਾਰ ਇਨ੍ਹਾਂ ਸੰਬੰਧਾਂ ਨੂੰ ਸਿੱਧੀ ਲਾਈਨ ਜਾਂ ਸਮਤਲ ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।
ਰੈਕ ਸੀਧੇ ਰਿਗ੍ਰੈਸ਼ਨ ਦਾ ਇੱਕ ਹੋਰ ਕਿਸਮ ਪਾਲੀਨੋਮਾਈਅਲ ਰਿਗ੍ਰੈਸ਼ਨ ਹੈ। ਕਈ ਵਾਰੀ ਬਦਲਾਂ ਵਿੱਚ ਰੇਖੀਅ ਸੰਬੰਧ ਹੁੰਦਾ ਹੈ - ਜਿਵੇਂ ਵੌਲਿਊਮ ਵਿੱਚ ਵੱਡਾ ਕਦੂ, ਇਸਦੀ ਕੀਮਤ ਵੱਧ ਹੋਣਾ - ਪਰ ਕਈ ਵਾਰ ਇਹ ਸੰਬੰਧ ਸਿੱਧੀ ਲਾਈਨ ਜਾਂ ਸਮਤਲ ਨਾਲ ਬਿਆਨ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।
✅ ਇਨ੍ਹਾਂ ਵਿਚੋਂ ਕੁਝ ਹੋਰ ਉਦਾਹਰਨਾਂ ਲਈ [ਇੱਥੇ ਦੇਖੋ](https://online.stat.psu.edu/stat501/lesson/9/9.8) ਉਹ ਡਾਟਾ ਜੋ ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਵਰਤ ਸਕਦਾ ਹੈ।
✅ ਇੱਥੇ ਕੁਝ ਹੋਰ ਉਦਾਹਰਣਾਂ ਹਨ [Polynomial Regression ਲਈ](https://online.stat.psu.edu/stat501/lesson/9/9.8) ਜੋ ਇਸ ਕਿਸਮ ਦਾ ਡੇਟਾ ਵਰਤ ਸਕਦੇ ਹਨ।
ਮਿਤੀ ਅਤੇ ਕੀਮਤ ਦੇ ਸੰਬੰਧ ਨੂੰ ਫਿਰ ਤੋਂ ਦੇਖੋ। ਕੀ ਇਹ ਸਕੇਟਰਪਲਾਟ ਇਸ ਤਰ੍ਹਾਂ ਲੱਗਦਾ ਹੈ ਕਿ ਇਸਨੂੰ ਲਾਜ਼ਮੀ ਤੌਰ ਤੇ ਸਿੱਧੀ ਰੇਖਾ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ? ਕੀ ਕੀਮਤਾਂ ਨਹੀਂ ਉਤਾਰ-ਚੜ੍ਹਾਵ ਕਰ ਸਕਦੀਆਂ? ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਤੁਸੀਂ ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ।
Date ਅਤੇ Price ਵਿੱਚ ਸੰਬੰਧ ਨੂੰ ਫਿਰ ਤੋਂ ਵੇਖੋ। ਕੀ ਇਹ scatterplot ਜ਼ਰੂਰੀ ਤੌਰ ਤੇ ਸਿੱਧੀ ਰੇਖਾ ਵਾਲੀ ਵਿਸ਼ਲੇਸ਼ਣਾ ਲਈ ਹੈ? ਕੀ ਕੀਮਤਾਂ ਫਲਕਟੂਏਟ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ? ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਤੁਸੀਂ polynomial regression ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ।
✅ ਪੁਲਿਨੋਮਿਯਲ ਗਣਿਤੀ ਵਿਅੰਜਨ ਹਨ ਜੋ ਇਕ ਜਾਂ ਵੱਧ ਵੈਰੀਏਬਲਾਂ ਅਤੇ ਕੋਐਫੀਸ਼ੀਅੰਟਸ ਤੋਂ ਬਣੇ ਹੋ ਸਕਦੇ ਹਨ।
✅ ਪਾਲੀਨੋਮ ਸਮੀਕਰਨ ਮੈਥਮੈਟਿਕਲ ਪ੍ਰਗਟਾਵੇ ਹਨ ਜੋ ਇੱਕ ਜਾਂ ਵੱਧ ਵੈਰੀਏਬਲ ਅਤੇ ਕੋਐਫੀਸ਼ਿਅਂਟ ਰੱਖ ਸਕਦੇ ਹਨ
ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਗੁਮੜੇ ਵਾਲੀ ਲਾਈਨ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਗੈਰ-ਰੇਖੀਅ ਡੇਟਾ ਲਈ ਬਿਹਤਰ ਫਿੱਟ ਹੁੰਦੀ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਜੇ ਅਸੀਂ ਇਨਪੁਟ ਡੇਟਾ ਵਿੱਚ ਵਰਗ `DayOfYear` ਵੈਰੀਏਬਲ ਸ਼ਾਮਿਲ ਕਰੀਏ, ਤਾਂ ਅਸੀਂ ਪਾਰਾਬੋਲਿਕ ਕਰਵ ਨਾਲ ਡੇਟਾ ਨੂੰ ਫਿੱਟ ਕਰ ਸਕਦੇ ਹਾਂ, ਜਿਸਦਾ ਘੱਟੋ-ਘੱਟ ਪੁਆਇੰਟ ਸਾਲ ਦੇ ਅੰਦਰ ਕਿਸੇ ਬਿੰਦੂ 'ਤੇ ਹੋਵੇਗਾ।
ਪਾਲੀਨੋਮ ਰਿਗ੍ਰੈਸ਼ਨ ਇੱਕ ਘੁੰਮਾਵਦਾਰ ਲਾਈਨ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਗੈਰ-ਰੇਖੀਅ ਡੇਟਾ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਫਿੱਟ ਕਰਦਾ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਜੇ ਅਸੀਂ `DayOfYear` ਦੇ ਵਰਗ `DayOfYear²` ਨੂੰ ਇਨਪੁੱਟ ਡੇਟਾ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਸਾਡੇ ਡੇਟਾ ਨੂੰ ਇੱਕ ਪਰਾਬੋਲੀਅਕ ਵਕਰੀਆਂ ਨਾਲ ਫਿੱਟ ਕਰ ਸਕਦੇ ਹਾਂ, ਜੋ ਸਾਲ ਦੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਬਿੰਦੂ 'ਤੇ ਘੱਟੋ-ਘੱਟ ਹੋਵੇਗਾ।
Scikit-learn ਇੱਕ ਸਹਾਇਕ [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ਸ਼ਾਮਿਲ ਕਰਦਾ ਹੈ ਜਿਸ ਨਾਲ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਵੱਖ-ਵੱਖ ਕਦਮ ਇਕੱਠੇ ਜੋੜੇ ਜਾ ਸਕਦੇ ਹਨ। ਇੱਕ **pipeline** ਇੱਕ ਲੜੀ ਹੁੰਦੀ ਹੈ **estimators** ਦੀ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ pipeline ਤਿਆਰ ਕਰਾਂਗੇ ਜੋ ਪਹਿਲਾਂ ਮਾਡਲ ਵਿੱਚ ਪੁਲਿਨੋਮਿਯਲ ਫੀਚਰਜ਼ ਸ਼ਾਮਿਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਰਿਗ੍ਰੈਸ਼ਨ ਸਿਖਾਉਂਦਾ ਹੈ:
Scikit-learn ਵਿੱਚ ਇੱਕ ਮਦਦਗਾਰ [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ਸ਼ਾਮਿਲ ਹੈ ਜੋ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਵੱਖ-ਵੱਖ ਕਦਮ ਇਕੱਠੇ ਜੋੜਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ **pipeline** ਇੱਕ ਲੜੀ ਹੁੰਦੀ ਹੈ **estimators** ਦੀ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ pipeline ਬਣਾਵਾਂਗੇ ਜੋ ਪਹਿਲਾਂ ਪਾਲੀਨੋਮ ਫੀਚਰਾਂ ਨੂੰ ਜੋੜੇਗਾ ਅਤੇ ਫਿਰ ਰਿਗ੍ਰੈਸ਼ਨ ਨੂੰ ਟ੍ਰੇਨ ਕਰੇਗਾ:
```python
from sklearn.preprocessing import PolynomialFeatures
@ -256,36 +257,58 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
`PolynomialFeatures(2)` ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਇਨਪੁਟ ਡੇਟਾ ਦੇ ਸਭ ਦੂਜੇ ਡਿਗਰੀ ਪੁਲਿਨੋਮਿਯਲ ਸ਼ਾਮਿਲ ਕਰਾਂਗੇ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ ਇਹ ਸਿਰਫ `DayOfYear`<sup>2</sup> ਦਾ ਮਤਲਬ ਹੋਵੇਗਾ, ਪਰ ਜੇ ਦੋ ਇਨਪੁਟ ਵੈਰੀਏਬਲ X ਅਤੇ Y ਹਨ, ਤਾਂ ਇਹ X<sup>2</sup>, XY ਅਤੇ Y<sup>2</sup> ਸ਼ਾਮਿਲ ਕਰੇਗਾ। ਅਸੀਂ ਜਾਂਚਣ ਲਈ ਵੱਧ ਡਿਗਰੀ ਵਾਲੇ ਪੁਲਿਨੋਮਿਯਲ ਵੀ ਵਰਤ ਸਕਦੇ ਹਾਂ।
`PolynomialFeatures(2)` ਦੀ ਵਰਤੋਂ ਦਾ ਅਰਥ ਹੈ ਕਿ ਅਸੀਂ ਇਨਪੁੱਟ ਡੇਟਾ ਦੇ ਸਾਰੇ ਦੂਜਾ ਡਿਗਰੀ ਦੇ ਪਾਲੀਨੋਮ ਸ਼ਾਮਿਲ ਕਰਨਗੇ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ ਇਹ ਸਿਰਫ਼ `DayOfYear²` ਨੂੰ ਦਰਸਾਏਗਾ, ਪਰ ਜੇ ਦੋ ਵੈਰੀਏਬਲ X ਅਤੇ Y ਹਨ, ਤਾਂ ਇਸ ਨਾਲ X², XY ਅਤੇ Y² ਸ਼ਾਮਿਲ ਹੋਣਗੇ। ਅਸੀਂ ਜੇ ਪਸੰਦ ਕਰੀਏ ਤਾਂ ਵੱਧ ਡਿਗਰੀ ਦੇ ਪਾਲੀਨੋਮ ਵੀ ਸ਼ਾਮਿਲ ਕਰ ਸਕਦੇ ਹਾਂ।
Pipeline ਨੂੰ ਅਸੀਂ ਉਹੋ ਹੀ ਢੰਗ ਨਾਲ ਵਰਤ ਸਕਦੇ ਹਾਂ ਜਿਵੇਂ ਅਸਲ `LinearRegression` ਓਬਜੈਕਟ ਨੂੰ ਵਰਤਦੇ ਹਾਂ, मतलब ਅਸੀਂ pipeline ਨੂੰ `fit` ਕਰਕੇ, ਫਿਰ `predict` ਰਾਹੀਂ ਪੇਸ਼ਗੀਬੀ ਨਤੀਜੇ ਲੈ ਸਕਦੇ ਹਾਂ:
```python
pred = pipeline.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}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
Smooth approximation curve ਨੂੰ ਪਲਾਟ ਕਰਨ ਲਈ, ਅਸੀਂ ਸੀਧੇ ਅਨਆਰਡਰਡ ਟੈਸਟ ਡੇਟਾ ਉੱਤੇ ਪਲਾਟ ਕਰਨ ਦੀ ਬਜਾਏ, `np.linspace` ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਜੋ ਇਨਪੁੱਟ ਮੁੱਲਾਂ ਦੀ ਇੱਕ ਇਕਸਾਰ ਰੇਂਜ ਬਣਾਉਂਦਾ ਹੈ (ਜ਼ਿੱਗਜ਼ੈਗ ਲਾਈਨ ਬਣਨ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ):
```python
X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
y_range = pipeline.predict(X_range)
plt.scatter(X_test, y_test)
plt.plot(X_range, y_range)
```
Pipeline ਨੂੰ ਮੂਲ `LinearRegression` ਵਸਤੂ ਵਾਂਗ ਹੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ pipeline ਨੂੰ `fit` ਕਰਨਾ ਅਤੇ ਫਿਰ `predict` ਦੀ ਵਰਤੋਂ ਨਾਲ ਭਵਿੱਖਬਾਣੀਆਂ ਨਿਕਾਲਨਾ। ਹੇਠਾਂ ਦੀ ਗ੍ਰਾਫ ਵਿੱਚ ਟੈਸਟ ਡੇਟਾ ਤੇ ਅਨੁਮਾਨੀ ਤਿਰਛੀ ਲਾਈਨ(d curve) ਦਿੱਤੀ ਗਈ ਹੈ:
ਇੱਥੇ ਟੈਸਟ ਡੇਟਾ ਅਤੇ approximation curve ਦੀ ਗ੍ਰਾਫ਼ ਦਿੱਤੀ ਗਈ ਹੈ:
<img alt="Polynomial regression" src="../../../../translated_images/pa/poly-results.ee587348f0f1f60b.webp" width="50%" />
ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਨਾਲ ਅਸੀਂ ਥੋੜ੍ਹੀ ਘੱਟ MSE ਅਤੇ ਵੱਧ ਡਿਟਰਮੀਨੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ, ਪਰ ਜ਼ਿਆਦਾ ਮਾਹੱਤਵਪੂਰਨ ਨਹੀਂ। ਅਸੀਂ ਹੋਰ ਫੀਚਰਜ਼ ਦਾ ਵੀ ਧਿਆਨ ਰੱਖਣਾ ਪਵੇਗਾ!
ਪਾਲੀਨੋਮ ਰਿਗ੍ਰੈਸ਼ਨ ਦੀ ਵਰਤੋਂ ਨਾਲ ਅਸੀਂ ਥੋੜ੍ਹਾ ਘਟਾ RMSE ਅਤੇ ਵੱਧ ਨਿਰਧਾਰਿਤਤਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ, ਪਰ ਇਹ ਵੱਡਾ ਬਦਲਾਅ ਨਹੀਂ ਹੁੰਦਾ। ਸਾਨੂੰ ਹੋਰ ਫੀਚਰਾਂ ਦਾ ਵੀ ਧਿਆਨ ਵਿੱਚ ਲਿਆਉਣਾ ਪਵੇਗਾ!
> ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਪੰਪਕਿਨ ਦੀ ਘੱਟੋ-ਘੱਟ ਕੀਮਤ ਕਿਤੇ ਹਾਲੋਵੀਨ ਦੇ ਆਸ-ਪਾਸ ਆਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਇਸਦਾ ਕਿਵੇਂ ਵਿਆਖਿਆ ਕਰੋਂਗੇ?
> ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਨਿਊਨਤਮ ਕਦੂ ਦੀ ਕੀਮਤ ਹਾਲੋਵੀਨ ਦੇ ਨੇੜੇ ਹੀ ਹੁੰਦੀ ਹੈ। ਤੁਸੀਂ ਇਹ ਕਿਵੇਂ ਸਮਝਾ ਸਕਦੇ ਹੋ?
🎃 ਵਧਾਈ ਹੋ! ਤੁਸੀਂ ਇੱਕ ਐਸਾ ਮਾਡਲ ਬਣਾਇਆ ਹੈ ਜੋ ਪਾਈ ਪੰਪਕਿਨ ਦੀ ਕੀਮਤ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਸ਼ਾਇਦ ਇਹੀ ਪ੍ਰਕਿਰਿਆ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਦੇ ਪੰਪਕਿਨ ਲਈ ਦੁਹਰਾਉਣਗੇ, ਪਰ ਇਹ ਮਿਹਨਤੀ ਹੋਵੇਗਾ। ਹੁਣ ਸیکھੀਏ ਕਿ ਸਾਡੇ ਮਾਡਲ ਵਿੱਚ ਪੰਪਕਿਨ ਕਿਸਮ (variety) ਨੂੰ ਕਿਵੇਂ ਧਿਆਨ ਵਿੱਚ ਰੱਖਿਆ ਜਾਵੇ!
🎃 ਵਧਾਈ ਹੋ, ਤੁਸੀਂ ਇੱਕ ਐਸਾ ਮਾਡਲ ਬਣਾਇਆ ਹੈ ਜੋ ਪਾਈ ਕਦੂਆਂ ਦੀ ਕੀਮਤ ਪੇਸ਼ਗੀਬੀ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਸ਼ਾਇਦ ਇਹੀ ਪ੍ਰਕਿਰਿਆ ਸਾਰੇ ਕਦੂਆਂ ਦੀ ਕਿਸਮਾਂ ਲਈ ਦੁਹਰਾ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਥੱਕਾਵਟ ਭਰੀ ਹੋਵੇਗੀ। ਹੁਣ ਚਲੋ ਸਿੱਖਦੇ ਹਾਂ ਕਿ ਮਾਡਲ ਵਿੱਚ ਕਦੂ ਦੀ ਵਿਰਾਇਟੀ ਨੂੰ ਕਿਵੇਂ ਸ਼ਾਮਲ ਕਰਨਾ ਹੈ!
## ਵਰਗੀਕ੍ਰਿਤ ਫੀਚਰ
## Categorical Features
ਆਦਰਸ਼ ਦੁਨੀਆਂ ਵਿੱਚ, ਅਸੀਂ ਇੱਛਾ ਕਰਦੇ ਹਾਂ ਕਿ ਵੱਖ-ਵੱਖ ਪੰਪਕਿਨ ਕਿਸਮਾਂ ਲਈ ਕੀਮਤਾਂ ਇੱਕੋ ਮਾਡਲ ਨਾਲ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਯੋਗ ਹੋਣ। ਪਰ, `Variety` ਕਾਲਮ ਕੁਝ ਅਲੱਗ ਹੈ ਜਿਵੇਂ ਕਿ `Month` ਵਰਗੇ ਕਾਲਮਾਂ ਤੋਂ, ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਗੈਰ-ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਇਨ੍ਹਾਂ ਕਾਲਮਾਂ ਨੂੰ **ਵਰਗੀਕ੍ਰਿਤ** ਕਹਿੰਦੇ ਹਨ।
ਆਦਰਸ਼ ਦੁਨੀਆ ਵਿੱਚ, ਅਸੀਂ ਇੱਕੋ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਖ-ਵੱਖ ਕਦੂਆਂ ਦੀ ਕਿਸਮਾਂ ਲਈ ਕੀਮਤਾਂ ਦੀ ਪੇਸ਼ਗੀਬੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਪਰ `Variety` ਕਾਲਮ ਕੁਝ ਵੱਖਰਾ ਹੈ ਜਿਵੇਂ ਕਿ `Month` ਕਾਲਮ, ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਗੈਰ-ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਐਸੇ ਕਾਲਮ ਨੂੰ **categorical** ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
[![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")
> 🎥 ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ ਕਲਿੱਕ ਕਰੋ ਛੋਟੀ ਵੀਡੀਓ ਦੇਖਣ ਲਈ ਜਿਹੜੀ ਵਰਗੀਕ੍ਰਿਤ ਫੀਚਰ ਵਰਤਣ ਬਾਰੇ ਹੈ।
> 🎥 ਇੱਕ ਛੋਟੀ ਵੀਡੀਓ ਦੇਖਣ ਲਈ ਉੱਪਰ ਦਿੱਤੇ ਚਿੱਤਰ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਜਿਸ ਵਿੱਚ categorical ਫੀਚਰਾਂ ਦੀ ਵਰਤੋਂ ਦੱਸਿਆ ਗਿਆ ਹੈ।
ਇੱਥੇ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਔਸਤ ਕੀਮਤ ਕਿਸਮ ਅਨੁਸਾਰ ਕਿਵੇਂ ਨਿਰਭਰ ਕਰਦੀ ਹੈ:
ਇੱਥੇ ਤੁਸੀਂ ਜਾ ਸਕਦੇ ਹੋ ਕਿ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਅਨੁਸਾਰ ਔਸਤ ਕੀਮਤ ਕਿਵੇਂ ਵੱਖ-ਵੱਖ ਹੁੰਦੀ ਹੈ:
<img alt="Average price by variety" src="../../../../translated_images/pa/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
ਕਿਸਮ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਇਸਨੂੰ ਸੰਖਿਆਤਮਕ ਰੂਪ ਵਿੱਚ ਬਦਲਨਾ ਪਵੇਗਾ, ਜਾਂ ਇਸ ਨੂੰ **ਇੰਕੋਡ** ਕਰਨਾ ਪਵੇਗਾ। ਸਾਡੇ ਕੋਲ ਕਈ ਤਰੀਕੇ ਹਨ:
ਕਿਸਮ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਲੈਣ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਇਸਨੂੰ ਸੰਖਿਆਤਮਕ ਰੂਪ ਵਿੱਚ ਬਦਲਣਾ ਪਵੇਗਾ, ਜਾਂ ਇਸਨੂੰ **encode** ਕਰਨਾ ਪਵੇਗਾ। ਇਹ ਕਰਨ ਦੇ ਕੁਝ ਤਰੀਕੇ ਹਨ:
* ਸਧਾਰਣ **ਸੰਖਿਆਤਮਕ ਇੰਕੋਡਿੰਗ** ਇੱਕ ਵੱਖਰੀਆਂ ਕਿਸਮਾਂ ਦੀ ਸੂਚੀ ਬਣਾਏਗਾ, ਅਤੇ ਫਿਰ ਕਿਸਮ ਦੇ ਨਾਮ ਨੂੰ ਉਸ ਸੂਚੀ ਵਿੱਚ ਉਸ ਦੀ ਸੂਚਕਾਂਕ ਨਾਲ ਬਦਲੇਗਾ। ਇਹ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਲਈ ਚੰਗਾ ਨਹੀਂ, ਕਿਉਂਕਿ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਅਸਲ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਕੁਝ ਕੋਐਫੀਸ਼ੀਅੰਟ ਨਾਲ ਗੁਣਾ ਕਰਦਾ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਡੈਕਸ ਨੰਬਰ ਅਤੇ ਕੀਮਤ ਵਿਚਕਾਰ ਸੰਬੰਧ ਸਾਫ਼ ਤੌਰ ਤੇ ਗੈਰ-ਰੇਖੀਅ ਹੈ, ਭਾਵੇਂ ਸੀਮਿਤ ਇੰਡੈਕਸ ਕਿਸੇ ਖਾਸ ਢੰਗ ਨਾਲ ਕ੍ਰਮਵੱਧ ਹੋਣ।
* **ਵਨ-ਹੌਟ ਇੰਕੋਡਿੰਗ** `Variety` ਕਾਲਮ ਨੂੰ 4 ਵੱਖ-ਵੱਖ ਕਾਲਮਾਂ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗੀ, ਹਰ ਕਿਸਮ ਲਈ ਇੱਕ ਕਾਲਮ। ਹਰ ਕਾਲਮ ਵਿੱਚ `1` ਹੋਵੇਗਾ ਜੇ ਉਸ ਲਾਈਨ ਦੀ ਕਿਸਮ ਉਸ ਮੁਕੱਦਰ ਕਿਸਮ ਨਾਲ ਮਿਲਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ `0`। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਵਿੱਚ ਚਾਰ ਕੋਐਫੀਸ਼ੀਅੰਟ ਹੋਣਗੇ, ਹਰ ਪੰਪਕਿਨ ਕਿਸਮ ਲਈ ਇਕ, ਜੋ ਉਸ ਕਿਸਮ ਦੀ ਸ਼ੁਰੂਆਤੀ ਕੀਮਤ (ਜਾਂ ਵੱਧ ਕੀਮਤ) ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋਵੇਗਾ।
* ਸਧਾਰਣ **ਨੰਬਰਤਮਕ ਇਨਕੋਡਿੰਗ** ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦਾ ਇੱਕ ਟੇਬਲ ਬਣਾਈਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਉਸ ਟੇਬਲ ਵਿੱਚ ਕਿਸਮ ਦੇ ਨਾਮ ਦੀ ਥਾਂ ਉਸਦੀ ਇੰਡੈਕਸ ਰੱਖਦਾ ਹੈ। ਇਹ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਲਈ ਵਧੀਆ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਰਿਗ੍ਰੈਸ਼ਨ ਇੰਡੈਕਸ ਦਾ ਅਸਲੀ ਨੰਬਰਤਮਕ ਮੁੱਲ ਲੈਂਦਾ ਹੈ, ਅਤੇ ਨਤੀਜੇ ਵਿੱਚ ਉਸ ਨੂੰ ਕਿਸੇ ਕੋਐਫੀਸ਼ਿਅਂਟ ਨਾਲ ਗੁਣਾ ਕਰਦਾ ਹੈ। ਸਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਡੈਕਸ ਨੰਬਰ ਅਤੇ ਕੀਮਤ ਵਿਚਕਾਰ ਸਬੰਧ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਗੈਰ-ਰੇਖੀਅ ਹੈ, ਭਾਵੇਂ ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਪੈਦਾ ਹੈ ਕਿ ਇੰਡੈਸ ਮੁਕੱਦਮ ਸਪਸ਼ਟ ਤਰੀਕੇ ਨਾਲ ਆਯੋਜਿਤ ਹੁੰਦੇ ਹਨ।
* **One-hot encoding** `Variety` ਕਾਲਮ ਨੂੰ 4 ਵੱਖਰੇ ਕਾਲਮਾਂ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗਾ, ਹਰ ਕਿਸਮ ਲਈ ਇੱਕ। ਹਰ ਕਾਲਮ ਵਿੱਚ `1` ਹੋਵੇਗਾ ਜੇ उस ਕਿਸੇ ਦਿੱਗੀ ਤਤਰ ਕਿਸਮ ਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ `0`। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਵਿੱਚ ਚਾਰ ਕੋਐਫ਼ੀਸ਼ਿਅਂਟ ਹੋਣਗੇ, ਹਰ ਕਿਸਮ ਲਈ ਇੱਕ, ਜੋ ਉਸ ਕਿਸਮ ਲਈ "ਆਰੰਭਕ ਕੀਮਤ" ਜਾਂ ਫਿਰ "ਜੋੜਤੋਂ ਕੀਮਤ" ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਲਈ ਹੁੰਦਾ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਇੱਕ ਵਿਭਿੰਨਤਾ ਨੂੰ one-hot ਇੰਕੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:
ਕੋਡ ਹੇਠਾਂ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਇੱਕ ਕਿਸਮ ਨੂੰ one-hot encode ਕਰ ਸਕਦੇ ਹਾਂ:
```python
pd.get_dummies(new_pumpkins['Variety'])
@ -302,14 +325,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਨੂੰ one-hot ਇੰਕੋਡ ਕੀਤੀ ਕਿਸਮ ਨਾਲ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਸਾਨੂੰ ਸਿਰਫ਼ ਠੀਕ ਤਰ੍ਹਾਂ `X` ਅਤੇ `y` ਡੇਟਾ ਸ਼ੁਰੂ ਕਰਨਾ ਪਵੇਗਾ:
One-hot encode ਕੀਤੀ ਕਿਸਮ ਨੂੰ ਇਨਪੁੱਟ ਵਜੋਂ ਵਰਤ ਕੇ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਟ੍ਰੇਨ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਸਿਰਫ਼ `X` ਅਤੇ `y` ਡੇਟਾ ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਸ਼ੁਰੂ ਕਰਨਾ ਪੈਂਦਾ ਹੈ:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
ਹੋਰ ਕੋਡ ਬਿਲਕੁਲ ਪਿੱਛਲੇ ਜੇਵਾਂ ਹੀ ਹੈ ਜੋ ਅਸੀਂ Linear Regression ਲਈ ਵਰਤਿਆ। ਜੇ ਤੁਸੀਂ ਇਹ ਜਮ੍ਹਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਮੀਨ ਸਕਵੇਅਰ ਐਰਰ ਲਗਭਗ ਉਹੀ ਹੈ, ਪਰ ਨਿਰਣਯਾਂ ਦੀ ਕੋਐਫੀਸ਼ੀਅੰਟ ਕਾਫ਼ੀ ਵੱਧ (~77%) ਹੈ। ਹੋਰ ਵੀ ਠੀਕ ਭਵਿੱਖਬਾਣੀਆਂ ਲਈ, ਅਸੀਂ ਹੋਰ ਵਰਗੀਕ੍ਰਿਤ ਫੀਚਰਜ਼ ਨਾਲ ਨਾਲ ਗਿਣਤੀ ਯੋਗ ਫੀਚਰਜ (ਜਿਵੇਂ `Month` ਜਾਂ `DayOfYear`) ਵੀ ਜੋੜ ਸਕਦੇ ਹਾਂ। ਇੱਕ ਵੱਡਾ ਫੀਚਰ ਐਰੇ ਬਣਾਉਣ ਲਈ ਅਸੀਂ `join` ਵਰਤ ਸਕਦੇ ਹਾਂ:
ਕੋਡ ਦਾ ਬਾਕੀ ਹਿੱਸਾ ਉਹੀ ਹੈ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਸੀ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਟ੍ਰੇਨ ਕਰਨ ਲਈ। ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ ਕੋਸ਼ਿਸ਼ ਕਰੋਗੇ, ਤਾਂ ਵੇਖੋਗੇ ਕਿ ਮੀਨ ਸਕਵੇਅਰਡ ਐਰਰ ਲਗਭਗ ਵੱਧ ਤੋ ਵੱਧ ਇੱਕੋ ਜਿਹਾ ਹੈ, ਪਰ ਸਾਡੇ ਕੋਲ ਕੋਈ ਹਾਈ ਕੋਇਫ਼ੀਸ਼ਿਅਂਟ ਹੋਵੇਗਾ (~77%)। ਹੋਰ ਸਹੀ ਪੇਸ਼ਗੀਬੀ ਲਈ, ਅਸੀਂ ਹੋਰ ਕੈਟੇਗੌਰਿਕਲ ਫੀਚਰਾਂ ਨਾਲ ਨਾਲ ਸੰਖਿਆਤਮਕ ਫੀਚਰ ਜਿਵੇਂ ਕਿ `Month` ਜਾਂ `DayOfYear` ਵੀ ਧਿਆਨ ਵਿੱਚ ਲੈ ਸਕਦੇ ਹਾਂ। ਇੱਕ ਵੱਡਾ ਐਰੇ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ `join` ਵਰਤ ਸਕਦੇ ਹਾਂ:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -319,68 +342,68 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
ਇੱਥੇ ਅਸੀਂ `City` ਅਤੇ `Package` ਕਿਸਮਾਂ ਨੂੰ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹਾਂ, ਜਿਸ ਨਾਲ ਸਾਡੇ ਕੋਲ MSE 2.84 (10%) ਅਤੇ ਨਿਰਣਯ 0.94 ਆਉਂਦਾ ਹੈ!
ਇੱਥੇ ਅਸੀਂ `City` ਅਤੇ `Package` ਕਿਸਮ ਨੂੰ ਵੀ ਸ਼ਾਮਲ ਕਰਦੇ ਹਾਂ, ਜਿਸ ਨਾਲ ਸਾਨੂੰ RMSE 2.84 (10.5%), ਅਤੇ ਨਿਰਧਾਰਿਤਤਾ 0.94 ਮਿਲਦੀ ਹੈ!
## ਸਾਰਿਆਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ
## ਸਾਰਿਆਂ ਨੂੰ ਇਕੱਠੇ ਮਿਲਾਉਣਾ
ਸਾਰਿਆਂ ਤੋਂ ਵਧੀਆ ਮਾਡਲ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਉਪਰ ਦਿੱਤੇ ਉਦਾਹਰਨ ਤੋਂ ਮਿਲੇ ਜੁਲੇ (one-hot ਇੰਕੋਡ ਕੀਤੇ ਵਰਗੀਕ੍ਰਿਤ + ਗਿਣਤੀ ਯੋਗ) ਡੇਟਾ ਨੂੰ ਪੁਲਿਨੋਮਿਯਲ ਰਿਗ੍ਰੈਸ਼ਨ ਨਾਲ ਇਕੱਠਾ ਕਰ ਸਕਦੇ ਹਾਂ। ਤੁਹਾਡੇ ਸੁਵਿਧਾ ਲਈ ਪੂਰਾ ਕੋਡ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ:
ਸਰਵੋਤਮ ਮਾਡਲ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਮਿਸਾਲ ਦੇ ਤੌਰ 'ਤੇ ਜੋੜੇ ਹੋਏ (one-hot encode ਕੀਤੇ categorical + numeric) ਡੇਟਾ ਨੂੰ Polynomial Regression ਨਾਲ ਮਿਲਾ ਸਕਦੇ ਹਾਂ। ਤੁਹਾਡੇ පහਲੈ ਲਈ ਪੂਰਾ ਕੋਡ ਇੱਥੇ ਹੈ:
```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}%)')
# RMSE ਅਤੇ ਨਿਰਣਯ ਕੀਮਤ ਦੀ ਗਣਨਾ ਕਰੋ
rmse = mean_squared_error(y_test, pred, squared=False)
print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
ਇਸ ਨਾਲ ਸਾਨੂੰ ਲਗਭਗ 97% ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਨਿਰਣਯ ਕੋਐਫੀਸ਼ੀਅੰਟ ਅਤੇ MSE=2.23 (~8% ਭਵਿੱਖਬਾਣੀ ਤਰੁੱਟ) ਮਿਲੇਗਾ।
ਇਹ ਸਾਨੂੰ ਲਗਭਗ 97% ਦਾ ਸਭ ਤੋਂ ਚੰਗਾ ਨਿਰਧਾਰਿਤਤਾ ਕੋਇਫ਼ੀਸ਼ਿਅਂਟ ਅਤੇ RMSE=2.23 (~8% ਪੇਸ਼ਗੀਬੀ ਗਲਤੀ) ਦੇਵੇਗਾ।
| ਮਾਡਲ | MSE | ਨਿਰਣਯ |
|-------|-----|---------|
| ਮਾਡਲ | RMSE | ਨਿਰਧਾਰਿਤਤਾ |
|-------|-----|---------------|
| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynomial | 2.73 (17.0%) | 0.08 |
| `Variety` Linear | 5.24 (19.7%) | 0.77 |
| ਸਾਰੇ ਫੀਚਰਜ਼ Linear | 2.84 (10.5%) | 0.94 |
| ਸਾਰੇ ਫੀਚਰਜ਼ Polynomial | 2.23 (8.25%) | 0.97 |
| ਸਭ ਫੀਚਰ Linear | 2.84 (10.5%) | 0.94 |
| ਸਭ ਫੀਚਰ Polynomial | 2.23 (8.25%) | 0.97 |
🏆 ਵਧਾਈਆਂ! ਤੁਸੀਂ ਇੱਕ ਹੀ ਲੈਸਨ ਵਿੱਚ ਚਾਰ Regression ਮਾਡਲ ਬਣਾਏ, ਅਤੇ ਮਾਡਲ ਦੀ ਕੁਆਲਟੀ ਨੂੰ 97% ਤੱਕ ਸੁਧਾਰਿਆ। Regression ਦੇ ਆਖਰੀ ਸੈਕਸ਼ਨ ਵਿੱਚ, ਤੁਸੀਂ Logistic Regression ਬਾਰੇ ਸਿੱਖੋਗੇ ਜੋ ਕਿ ਕੈਟੇਗਰੀਜ਼ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
🏆 ਸ਼ਾਬਾਸ਼! ਤੁਸੀਂ ਇਕ ਹੀ ਪਾਠ ਵਿੱਚ ਚਾਰ Regression ਮਾਡਲ ਬਣਾਏ ਅਤੇ ਮਾਡਲ ਗੁਣਵੱਤਾ ਨੂੰ 97% ਤੱਕ ਬਿਹਤਰ ਕੀਤਾ। Regression ਦੇ ਅੰਤਿਮ ਭਾਗ ਵਿੱਚ ਤੁਸੀਂ ਲੋਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਬਾਰੇ ਸਿੱਖੋਗੇ, ਜੋ ਕੈਟੇਗਰੀਜ਼ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ।
---
## 🚀ਚੈਲੰਜ
## 🚀ਚੁਣੌਤੀ
ਇਸ ਨੋਟਬੁੱਕ ਵਿੱਚ ਕਈ ਵੱਖ-ਵੱਖ ਵੈਰੀਏਬਲਾਂ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਦੇਖੋ ਕਿ ਕਿਉਂਕਰੋਲੇਸ਼ਨ ਮਾਡਲ ਦੀ ਸਹੀਅਤਾ ਨਾਲ ਕਿਵੇਂ ਜੁੜਦੀ ਹੈ।
ਇਸ ਨੋਟਬੁੱਕ ਵਿੱਚ ਕਈ ਵੱਖ-ਵੱਖ ਵੈਰੀਏਬਲ ਟੈਸਟ ਕਰੋ ਅਤੇ ਵੇਖੋ ਕਿ ਸੰਬੰਧ ਮਾਡਲ ਦੀ ਸਹੀਤਾ ਨਾਲ ਕਿਵੇਂ ਮਿਲਦਾ ਹੈ।
## [ਪੋਸਟ-ਲੇਕਚਰ ਕੁਇਜ਼](https://ff-quizzes.netlify.app/en/ml/)
## [ਪੋਸਟ-ਲੈਕਚਰ ਕਵਿਜ਼](https://ff-quizzes.netlify.app/en/ml/)
## ਸਮੀਖਿਆ ਅਤੇ ਸਵੈਅਧਿਆਨ
## ਸਮੀਖਿਆ ਅਤੇ ਸਵੈਅਧਿਐਨ
ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਬਾਰੇ ਸਿੱਖਿਆ। ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਕਿਸਮਾਂ ਦਾ ਵੀ ਰਿਗ੍ਰੈਸ਼ਨ ਹੈ। ਸਟੀਪਵਾਈਜ਼, ਰਿਡਜ, ਲਾਸ਼ੋ ਅਤੇ ਇਲਾਸਟਿਕਨੇਟ ਤਕਨੀਕਾਂ ਬਾਰੇ ਪੜ੍ਹੋ। ਇੱਕ ਵਧੀਆ ਕੋਰਸ ਸਟੈਨਫੋਰਡ ਸਟੈਟਿਸਟਿਕਲ ਲਰਨਿੰਗ ਕੋਰਸ ਹੈ: [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਬਾਰੇ ਸਿੱਖਿਆ। ਹੋਰ ਮਹੱਤਵਪੂਰਣ ਰਿਗ੍ਰੈਸ਼ਨ ਦੀਆਂ ਕਿਸਮਾਂ ਹਨ। Stepwise, Ridge, Lasso ਅਤੇ Elasticnet ਤਕਨੀਕਾਂ ਬਾਰੇ ਪੜ੍ਹੋ। ਇੱਕ ਚੰਗਾ ਕੋਰਸ ਸਿੱਖਣ ਲਈ ਹੈ [Stanford Statistical Learning ਕੋਰਸ](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## ਅਸਾਈਨਮੈਂਟ
[ਇੱਕ ਮਾਡਲ ਬਣਾਓ](assignment.md)
[ਮਾਡਲ ਬਣਾਓ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ਡੀਸਕਲੇਮਰ**:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਰੱਖੋ ਕਿ ਆਟੋਮੇਟਿਕ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਣਸਹੀਤਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਹੀ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜ਼ਰੂਰੀ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਨਾਲ ਹੋਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਗਲਤ ਸਮਝਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।
**ਅਸਵੀਕਾਰੋਪਣ**:
ਇਹ ਦਸਤਾਵੇਜ਼ ਏਆਈ ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗ਼ਲਤੀਆਂ ਜਾਂ ਅਸਥਿਰਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼, ਆਪਣੇ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ, ਅਧਿਕਾਰਿਤ ਸਰੋਤ ਵਜੋਂ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆਵਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

77
translations/pa/2-Regression/3-Linear/solution/notebook.ipynb
Unescape View File

@ -4,14 +4,14 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## ਕਦੂ ਦੀ ਕੀਮਤ ਲਈ ਰੇਖੀ ਅਤੇ ਬਹੁਪਦਾਰ ਰਿਗ੍ਰੈਸ਼ਨ - ਪਾਠ 3\n",
"## ਕਦੂ ਦੀ ਕੀਮਤ ਲਈ ਰੈਖੀ ਅਤੇ ਪਾਲੀਨੋਮਿਯਲ ਰੈਗ੍ਰੈਸ਼ਨ - ਪਾਠ 3\n",
"\n",
"ਲੋੜੀਂਦੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਡਾਟਾਸੈਟ ਲੋਡ ਕਰੋ। ਡਾਟਾ ਨੂੰ ਇੱਕ ਡਾਟਾਫਰੇਮ ਵਿੱਚ ਬਦਲੋ ਜੋ ਡਾਟਾ ਦਾ ਇੱਕ ਹਿੱਸਾ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ:\n",
"ਲੋੜੀਂਦੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਡੇਟਾਸੈੱਟ ਨੂੰ ਲੋਡ ਕਰੋ। ਡੇਟਾ ਨੂੰ ਇੱਕ ਡੇਟਾ ਫਰੇਮ ਵਿੱਚ ਬਦਲੋ ਜਿਸ ਵਿੱਚ ਡੇਟਾ ਦਾ ਇੱਕ ਉਪਸੈੱਟ ਹੋਵੇ:\n",
"\n",
"- ਸਿਰਫ ਉਹ ਕਦੂ ਪ੍ਰਾਪਤ ਕਰੋ ਜੋ ਬੁਸ਼ਲ ਦੁਆਰਾ ਕੀਮਤ ਕੀਤੇ ਗਏ ਹਨ\n",
"- ਮਿਤੀ ਨੂੰ ਇੱਕ ਮਹੀਨੇ ਵਿੱਚ ਬਦਲੋ\n",
"- ਕੀਮਤ ਦੀ ਗਣਨਾ ਉੱਚ ਅਤੇ ਘੱਟ ਕੀਮਤਾਂ ਦੇ ਔਸਤ ਵਜੋਂ ਕਰੋ\n",
"- ਕੀਮਤ ਨੂੰ ਬੁਸ਼ਲ ਮਾਤਰਾ ਦੁਆਰਾ ਕੀਮਤ ਦਰਸਾਉਣ ਲਈ ਬਦਲੋ\n"
"- ਸਿਰਫ ਉਹ ਕਦੂ ਲਓ ਜੋ ਬਸ਼ਲ ਮੁਲ੍ਹਵਾਂ ਠਹਿਰਾਏ ਗਏ ਹਨ\n",
"- ਮੁਲ੍ਹਵਾ ਨੂੰ ਮਹੀਨੇ ਵਿੱਚ ਬਦਲੋ\n",
"- ਕੀਮਤ ਦੀ ਗਿਣਤੀ ਉੱਚੀ ਅਤੇ ਘੱਟ ਕੀਮਤਾਂ ਦੇ ਔਸਤ ਤੇ ਕਰੋ\n",
"- ਕੀਮਤ ਨੂੰ ਬਸ਼ਲ ਮਾਤਰਾ ਅਨੁਸਾਰ ਦਰਸਾਉਣ ਲਈ ਬਦਲੋ\n"
]
},
{
@ -377,7 +377,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"ਇੱਕ ਸਕੈਟਰਪਲਾਟ ਸਾਨੂੰ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਸਿਰਫ਼ ਅਗਸਤ ਤੋਂ ਦਸੰਬਰ ਤੱਕ ਦੇ ਮਹੀਨੇ ਦੇ ਡਾਟਾ ਹੈ। ਸਾਨੂੰ ਸੰਭਵਤ: ਨਤੀਜੇ ਲੀਨੀਅਰ ਢੰਗ ਨਾਲ ਕੱਢਣ ਲਈ ਹੋਰ ਡਾਟਾ ਦੀ ਲੋੜ ਹੈ।\n"
"ਇੱਕ ਸਕੈਟਰਪਲਾਟ ਸਾਨੂੰ ਯਾਦ ਦਿਲਾਉਂਦਾ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਸਿਰਫ਼ ਅਗਸਤ ਤੋਂ ਦਸੰਬਰ ਤੱਕ ਦਾ ਮਹੀਨੇ ਦਾ ਡੇਟਾ ਹੈ। ਸੰਭਵ ਹੈ ਕਿ ਸਾਨੂੰ ਲਕੀਰੀ ਰੂਪ ਵਿੱਚ ਨਤੀਜੇ ਕੱਢਣ ਲਈ ਹੋਰ ਡੇਟਾ ਦੀ ਲੋੜ ਹੋਵੇ।\n"
]
},
{
@ -447,7 +447,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"ਚਲੋ ਵੇਖੀਏ ਕਿ ਕੋਈ ਸਮਬੰਧ ਹੈ ਕਿ ਨਹੀਂ:\n"
]
},
{
"cell_type": "code",
@ -472,7 +474,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"ਲੱਗਦਾ ਹੈ ਕਿ ਸੰਬੰਧਤਾ ਕਾਫ਼ੀ ਛੋਟੀ ਹੈ, ਪਰ ਕੋਈ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਸੰਬੰਧ ਹੈ - ਕਿਉਂਕਿ ਉੱਪਰ ਦਿੱਤੇ ਗ੍ਰਾਫ ਵਿੱਚ ਕੀਮਤਾਂ ਦੇ ਬਿੰਦੂਆਂ ਵਿੱਚ ਕਈ ਵੱਖਰੇ ਕਲੱਸਟਰ ਦਿਖਾਈ ਦੇ ਰਹੇ ਹਨ। ਆਓ ਇੱਕ ਗ੍ਰਾਫ ਬਣਾਈਏ ਜੋ ਵੱਖ-ਵੱਖ ਕੱਦੂ ਦੀਆਂ ਕਿਸਮਾਂ ਦਿਖਾਵੇਗਾ:\n"
"ਲੱਗਦਾ ਹੈ ਕਿ ਸਬੰਧਤਾ ਕਾਫੀ ਛੋਟੀ ਹੈ, ਪਰ ਕੁਝ ਹੋਰ ਵਧੀਆ ਮਹੱਤਵਪੂਰਨ ਸੰਬੰਧ ਹੈ - ਕਿਉਂਕਿ ਉਪਰ ਦਿੱਤੀ ਗਈ ਪਲਾਟ ਵਿੱਚ ਕੀਮਤਾਂ ਦੇ ਕਈ ਵੱਖ-ਵੱਖ ਗਰੁੱਪ ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ। ਆਓ ਇਕ ਪਲਾਟ ਬਣਾਈਏ ਜੋ ਵੱਖ-ਵੱਖ ਕੱਦੂ ਦੀਆਂ ਕਿਸਮਾਂ ਦਿਖਾਏ:\n"
]
},
{
@ -535,7 +537,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"ਇਸ ਸਮੇਂ ਲਈ, ਆਓ ਸਿਰਫ ਇੱਕ ਕਿਸਮ - **ਪਾਈ ਕਿਸਮ** 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰੀਏ।\n"
]
},
{
"cell_type": "code",
@ -582,9 +586,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"### ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"### ਲੀਨਿਅਰ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"\n",
"ਅਸੀਂ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ Scikit Learn ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:\n"
"ਅਸੀਂ ਲੀਨਿਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਸਕਾਈਕਿਟ ਲਰਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:\n"
]
},
{
@ -662,7 +666,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"ਰੇਖਾ ਦਾ ਢਲਾਨ ਰੇਖੀ ਰਿਗ੍ਰੈਸ਼ਨ ਗੁਣਾਂਕਾਂ ਤੋਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:\n"
"ਰੇਖੀ ਰਿਗ੍ਰੈਸ਼ਨ ਕੋਐਫੀਸ਼ਿਯੰਟਾਂ ਤੋਂ ਲਾਈਨ ਦਾ ਢਲਾਨ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:\n"
]
},
{
@ -688,7 +692,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"ਅਸੀਂ ਤਿਆਰ ਕੀਤਾ ਮਾਡਲ ਕੀਮਤ ਦੀ ਭਵਿੱਖਬਣੀ ਕਰਨ ਲਈ ਵਰਤ ਸਕਦੇ ਹਾਂ:\n"
]
},
{
"cell_type": "code",
@ -716,11 +722,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"### ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"### ਪੋਲਿਨੋਮਿਆਲ ਰੈਗ੍ਰੈਸ਼ਨ\n",
"\n",
"ਕਈ ਵਾਰ ਫੀਚਰਾਂ ਅਤੇ ਨਤੀਜਿਆਂ ਦੇ ਵਿਚਕਾਰ ਸੰਬੰਧ ਮੂਲ ਰੂਪ ਵਿੱਚ ਗੈਰ-ਰੇਖੀ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ, ਕਦੂ ਦੀਆਂ ਕੀਮਤਾਂ ਸਰਦੀ ਦੇ ਮੌਸਮ ਵਿੱਚ (ਮਹੀਨੇ=1,2) ਉੱਚੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਫਿਰ ਗਰਮੀ ਦੇ ਮੌਸਮ ਵਿੱਚ ਘਟ ਜਾਂਦੀਆਂ ਹਨ (ਮਹੀਨੇ=5-7), ਅਤੇ ਫਿਰ ਵਧ ਜਾਂਦੀਆਂ ਹਨ। ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਇਸ ਸੰਬੰਧ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਨਹੀਂ ਪਕੜ ਸਕਦਾ।\n",
"ਕਈ ਵਾਰ ਫੀਚਰਾਂ ਅਤੇ ਨਤੀਜਿਆਂ ਵਿਚਕਾਰ ਸਬੰਧ ਸਵਭਾਵਿਕ ਤੌਰ ਤੇ ਗੈਰ-ਰੇਖੀ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ਸਰਦੀਆਂ (ਮਹੀਨੇ=1,2) ਵਿੱਚ ਕਦੂਆਂ ਦੀ ਕੀਮਤ ਵੱਧ ਸਕਦੀ ਹੈ, ਫਿਰ ਗਰਮੀ (ਮਹੀਨੇ=5-7) ਵਿੱਚ ਘਟਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਮੁੜ ਵਧਦੀ ਹੈ। ਲੀਨੀਅਰ ਰੈਗ੍ਰੈਸ਼ਨ ਇਸ ਸਬੰਧ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਲੱਭਣ ਵਿੱਚ ਅਸਮਰੱਥ ਹੈ।\n",
"\n",
"ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਵਾਧੂ ਫੀਚਰਾਂ ਸ਼ਾਮਲ ਕਰਨ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹਾਂ। ਇੱਕ ਸਧਾਰਨ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਇਨਪੁਟ ਫੀਚਰਾਂ ਤੋਂ ਪੋਲੀਨੋਮਿਅਲ ਵਰਤ ਕੇ ਨਵੇਂ ਫੀਚਰ ਬਣਾਏ ਜਾਣ, ਜਿਸ ਨਾਲ **ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ** ਹੁੰਦਾ ਹੈ। Scikit Learn ਵਿੱਚ, ਅਸੀਂ ਪਾਈਪਲਾਈਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੋਲੀਨੋਮਿਅਲ ਫੀਚਰਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਪ੍ਰੀ-ਕੰਪਿਊਟ ਕਰ ਸਕਦੇ ਹਾਂ:\n"
"ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਅਸੀਂ ਵਾਧੂ ਫੀਚਰ ਸ਼ਾਮਲ ਕਰਨ ਦੇ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹਾਂ। ਸਧਾਰਣ ਤਰੀਕਾ ਹੈ ਕਿ ਇਨਪੁਟ ਫੀਚਰਾਂ ਤੋਂ ਪੋਲਿਨੋਮਿਆਲ ਵਰਗੀ ਥਾਂ ਤੇ ਪੋਲਿਨੋਮਿਆਲ ਰੈਗ੍ਰੈਸ਼ਨ ਕਰਨਾ। ਸਕਿਟ-ਲਰਨ ਵਿੱਚ, ਅਸੀਂ ਪਾਇਪਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਟੋਮੈਟਿਕ ਤੌਰ 'ਤੇ ਪੋਲਿਨੋਮਿਆਲ ਫੀਚਰਾਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਕੈਲਕुलेਟ ਕਰ ਸਕਦੇ ਹਾਂ:\n"
]
},
{
@ -775,22 +781,25 @@
"score = pipeline.score(X_train,y_train)\n",
"print('Model determination: ', score)\n",
"\n",
"plt.scatter(X_test,y_test)\n",
"plt.plot(sorted(X_test),pipeline.predict(sorted(X_test)))"
"X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)\n",
"y_range = pipeline.predict(X_range)\n",
"\n",
"plt.scatter(X_test, y_test)\n",
"plt.plot(X_range, y_range)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ਕਿਸਮਾਂ ਨੂੰ ਐਨਕੋਡ ਕਰਨਾ\n",
"### ਕੋਡਿੰਗ ਦੇ ਤਰੀਕੇ\n",
"\n",
"ਇਕ ਆਦਰਸ਼ ਜਗਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕੋ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਖ-ਵੱਖ ਕੱਦੂ ਦੀਆਂ ਕਿਸਮਾਂ ਲਈ ਕੀਮਤਾਂ ਦੀ ਪੇਸ਼ਗੂਈ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਕਿਸਮ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਇਸਨੂੰ ਸੰਖਿਆਤਮਕ ਰੂਪ ਵਿੱਚ ਬਦਲਣਾ ਪਵੇਗਾ, ਜਾਂ **ਐਨਕੋਡ** ਕਰਨਾ ਪਵੇਗਾ। ਇਸਨੂੰ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ:\n",
"ਆਦਰਸ਼ ਦੁਨੀਆ ਵਿੱਚ, ਅਸੀਂ ਇੱਕੋ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਖ-ਵੱਖ ਲੱਕੜੀ ਦੀ ਕਿਸਮਾਂ ਲਈ ਕੀਮਤਾਂ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਕਿਸਮ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਇਸ ਨੂੰ ਗਿਣਤੀ ਰੂਪ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ, ਜਾਂ **ਕੋਡਿੰਗ**। ਇਸਨੂੰ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ:\n",
"\n",
"* ਸਧਾਰਨ ਸੰਖਿਆਤਮਕ ਐਨਕੋਡਿੰਗ, ਜੋ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੀ ਇੱਕ ਟੇਬਲ ਬਣਾਏਗੀ, ਅਤੇ ਫਿਰ ਉਸ ਟੇਬਲ ਵਿੱਚ ਕਿਸਮ ਦੇ ਨਾਮ ਨੂੰ ਇੱਕ ਇੰਡੈਕਸ ਨਾਲ ਬਦਲ ਦੇਵੇਗੀ। ਇਹ ਰੇਖੀ ਰਿਗ੍ਰੈਸ਼ਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਚਾਰ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਰੇਖੀ ਰਿਗ੍ਰੈਸ਼ਨ ਇੰਡੈਕਸ ਦੇ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੀ ਹੈ, ਅਤੇ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਸੰਭਵ ਹੈ ਕਿ ਕੀਮਤ ਨਾਲ ਸੰਖਿਆਤਮਕ ਤੌਰ 'ਤੇ ਸਬੰਧਿਤ ਨਾ ਹੋਵੇ।\n",
"* ਵਨ-ਹਾਟ ਐਨਕੋਡਿੰਗ, ਜੋ `Variety` ਕਾਲਮ ਨੂੰ 4 ਵੱਖ-ਵੱਖ ਕਾਲਮਾਂ ਨਾਲ ਬਦਲ ਦੇਵੇਗੀ, ਹਰ ਕਿਸਮ ਲਈ ਇੱਕ, ਜੋ 1 ਦਰਸਾਏਗੀ ਜੇਕਰ ਸੰਬੰਧਿਤ ਪੰਕਤੀ ਦਿੱਤੀ ਕਿਸਮ ਦੀ ਹੋਵੇ, ਅਤੇ ਨਹੀਂ ਤਾਂ 0।\n",
"* ਸਧਾਰਨ ਅੰਕਗਣਿਤ ਕੋਡਿੰਗ ਜੋ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੀ ਇੱਕ ਸਾਰਣੀ ਬਣਾਏਗੀ ਅਤੇ ਫਿਰ ਉਸ ਸਾਰਣੀ ਵਿੱਚ ਕਿਸਮ ਦੇ ਨਾਮ ਨੂੰ ਇੱਕ ਸੂਚਕ ਨਾਲ ਬਦਲ ਦੇਵੇਗੀ। ਇਹ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਚਾਰ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਸੂਚਕ ਦਾ ਅੰਕਗਣਿਤ ਮੁੱਲ ਧਿਆਨ ਵਿੱਚ ਲੈਂਦਾ ਹੈ, ਅਤੇ ਅਮੁਮਨ ਇਹ ਅੰਕ ਮੁੱਲ ਕੀਮਤ ਨਾਲ ਗਿਣਤੀਕ ਤੌਰ ਤੇ ਸਬੰਧਿਤ ਨਹੀਂ ਹੁੰਦਾ।\n",
"* ਵਨ-ਹੌਟ ਕੋਡਿੰਗ, ਜੋ `Variety` ਕਾਲਮ ਨੂੰ 4 ਵੱਖ-ਵੱਖ ਕਾਲਮਾਂ ਨਾਲ ਬਦਲ ਦੇਵੇਗੀ, ਇੱਕ ਹਰ ਕਿਸਮ ਲਈ, ਜੋ 1 ਹੋਵੇਗਾ ਜੇਕਰ ਦਿੱਤਾ ਗਇਆ ਕਤਾਰ ਉਸ ਕਿਸਮ ਦਾ ਹੋਵੇ ਅਤੇ 0 ਹੋਰਥਾਂ।\n",
"\n",
"ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਕਿਸਮ ਨੂੰ ਵਨ-ਹਾਟ ਐਨਕੋਡ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹਾਂ:\n"
"ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਕਿਸ ਤਰ੍ਹਾਂ ਕਿਸਮ ਦੀ ਵਨ-ਹੌਟ ਕੋਡਿੰਗ ਕਰ ਸਕਦੇ ਹਾਂ:\n"
]
},
{
@ -938,9 +947,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"### ਵੈਰਾਇਟੀ 'ਤੇ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"### ਵੈਰੀਟੀ 'ਤੇ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"\n",
"ਅਸੀਂ ਹੁਣ ਉਪਰੋਕਤ ਕੋਡ ਨੂੰ ਹੀ ਵਰਤਾਂਗੇ, ਪਰ `DayOfYear` ਦੀ ਬਜਾਏ ਅਸੀਂ ਆਪਣੀ ਇੱਕ-ਹਾਟ-ਇਨਕੋਡ ਕੀਤੀ ਵੈਰਾਇਟੀ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਵਰਤਾਂਗੇ:\n"
"ਹੁਣ ਅਸੀਂ ਉਪਰ ਦਿੱਤੇ ਸਮਾਨ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਪਰ `DayOfYear` ਦੀ ਬਜਾਏ ਅਸੀਂ ਆਪਣੀ ਵਨ-ਹੌਟ-ਇੰਕੋਡ ਕੀਤੀ ਵੈਰੀਟੀ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਵਰਤਾਂਗੇ:\n"
]
},
{
@ -988,7 +997,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"ਅਸੀਂ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਵੀ ਇਸੇ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਸੰਖਿਆਤਮਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਿਵੇਂ ਕਿ `Month` ਜਾਂ `DayOfYear` ਨਾਲ ਜੋੜ ਸਕਦੇ ਹਾਂ:\n"
"ਅਸੀਂ ਇਸੇ ਤਰੀਕੇ ਨਾਲ ਹੋਰ ਫੀਚਰਾਂ ਨੂੰ ਵੀ ਵਰਤ ਕੇ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਗਣਿਤੀ ਫੀਚਰਾਂ ਨਾਲ ਮਿਲਾ ਕੇ, ਜਿਵੇਂ ਕਿ `Month` ਜਾਂ `DayOfYear`:\n"
]
},
{
@ -1019,9 +1028,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"### ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"### ਪੋਲਿਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ\n",
"\n",
"ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ ਨੂੰ ਇੱਕ-ਹਾਟ-ਇਨਕੋਡ ਕੀਤੀਆਂ ਸ਼੍ਰੇਣੀਬੱਧ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਕੋਡ ਮੂਲ ਰੂਪ ਵਿੱਚ ਉਹੀ ਹੋਵੇਗਾ ਜਿਵੇਂ ਅਸੀਂ ਉੱਪਰ ਵੇਖਿਆ ਹੈ।\n"
"ਪੋਲਿਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ ਨੂੰ ਇੱਕ-ਹੋਟ-ਐਨਕੋਡ ਕੀਤੀਆਂ ਸ਼੍ਰੇਣੀਵਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਪੋਲਿਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ ਸਿਖਲਾਈ ਕਰਨ ਲਈ ਕੋਡ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਓਹੋ ਹੀ ਹੋਵੇਗਾ ਜੋ ਅਸੀਂ ਉੱਪਰ ਵੇਖਿਆ ਹੈ।\n"
]
},
{
@ -1068,7 +1077,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**ਅਸਵੀਕਾਰਨਾ**: \nਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ ਅਸੀਂ ਸਹੀਅਤ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਣਸ਼ੀਲਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਦਸਤਾਵੇਜ਼ ਦਾ ਮੂਲ ਰੂਪ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ਅਸਵੀਕਾਰੋਪੱਤਰ**: \nਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਕਿਸੇ ਭਰੋਸੇਯੋਗਤਾ ਦੇ ਅਭਾਵ ਹੋ ਸਕਦੇ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੇ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਪ੍ਰਮਾਣਿਕ ਸਰੋਤ ਵਜੋਂ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੇ ਉਪਯੋਗ ਤੋਂ ਉੱਪਜਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਭ੍ਰਮਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -1098,13 +1107,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "d77bd89ae7e79780c68c58bab91f13f8",
"translation_date": "2025-08-29T18:45:42+00:00",
"source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
"language_code": "pa"
}
"orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2

14
translations/pt-BR/.co-op-translator.json
Unescape View File

@ -36,8 +36,8 @@
"language_code": "pt-BR"
},
"1-Introduction/4-techniques-of-ML/README.md": {
"original_hash": "9d91f3af3758fdd4569fb410575995ef",
"translation_date": "2025-09-04T21:35:13+00:00",
"original_hash": "84b1715a6be62ef1697351dcc5d7b567",
"translation_date": "2026-04-26T18:42:13+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
"language_code": "pt-BR"
},
@ -90,8 +90,8 @@
"language_code": "pt-BR"
},
"2-Regression/3-Linear/README.md": {
"original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
"translation_date": "2026-04-20T19:03:03+00:00",
"original_hash": "8b776e731c35b171d316d01d0e7b1369",
"translation_date": "2026-04-26T18:41:47+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "pt-BR"
},
@ -107,6 +107,12 @@
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
"language_code": "pt-BR"
},
"2-Regression/3-Linear/solution/notebook.ipynb": {
"original_hash": "6781223ffbe8cfdaa38d0200f08e1288",
"translation_date": "2026-04-26T18:37:47+00:00",
"source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
"language_code": "pt-BR"
},
"2-Regression/4-Logistic/README.md": {
"original_hash": "abf86d845c84330bce205a46b382ec88",
"translation_date": "2025-09-04T21:23:34+00:00",

100
translations/pt-BR/1-Introduction/4-techniques-of-ML/README.md
Unescape View File

@ -1,117 +1,117 @@
# Técnicas de Aprendizado de Máquina
O processo de construir, usar e manter modelos de aprendizado de máquina e os dados que eles utilizam é muito diferente de muitos outros fluxos de trabalho de desenvolvimento. Nesta lição, vamos desmistificar o processo e delinear as principais técnicas que você precisa conhecer. Você irá:
O processo de construir, usar e manter modelos de aprendizado de máquina e os dados que eles utilizam é muito diferente de muitos outros fluxos de trabalho de desenvolvimento. Nesta lição, vamos desmistificar o processo e destacar as principais técnicas que você precisa conhecer. Você irá:
- Compreender os processos que sustentam o aprendizado de máquina em um nível geral.
- Entender os processos que fundamentam o aprendizado de máquina em um nível geral.
- Explorar conceitos básicos como 'modelos', 'previsões' e 'dados de treinamento'.
## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
[![ML para iniciantes - Técnicas de Aprendizado de Máquina](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML para iniciantes - Técnicas de Aprendizado de Máquina")
[![ML for beginners - Techniques of Machine Learning](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML for beginners - Techniques of Machine Learning")
> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre esta lição.
> 🎥 Clique na imagem acima para assistir a um vídeo curto explicando esta lição.
## Introdução
Em um nível geral, a prática de criar processos de aprendizado de máquina (ML) é composta por várias etapas:
Em alto nível, a arte de criar processos de aprendizado de máquina (ML) é composta por várias etapas:
1. **Definir a pergunta**. A maioria dos processos de ML começa com uma pergunta que não pode ser respondida por um programa condicional simples ou um mecanismo baseado em regras. Essas perguntas geralmente giram em torno de previsões baseadas em um conjunto de dados.
2. **Coletar e preparar os dados**. Para responder à sua pergunta, você precisa de dados. A qualidade e, às vezes, a quantidade dos seus dados determinarão o quão bem você pode responder à pergunta inicial. Visualizar os dados é um aspecto importante desta fase. Esta etapa também inclui dividir os dados em grupos de treinamento e teste para construir um modelo.
3. **Escolher um método de treinamento**. Dependendo da sua pergunta e da natureza dos seus dados, você precisa escolher como deseja treinar um modelo para refletir melhor seus dados e fazer previsões precisas. Esta é a parte do processo de ML que exige expertise específica e, frequentemente, uma quantidade considerável de experimentação.
4. **Treinar o modelo**. Usando seus dados de treinamento, você aplicará vários algoritmos para treinar um modelo que reconheça padrões nos dados. O modelo pode usar pesos internos que podem ser ajustados para privilegiar certas partes dos dados em detrimento de outras, a fim de construir um modelo melhor.
5. **Avaliar o modelo**. Você usa dados nunca antes vistos (seus dados de teste) do conjunto coletado para verificar o desempenho do modelo.
6. **Ajustar parâmetros**. Com base no desempenho do modelo, você pode refazer o processo usando diferentes parâmetros ou variáveis que controlam o comportamento dos algoritmos usados para treinar o modelo.
7. **Prever**. Use novas entradas para testar a precisão do modelo.
1. **Decidir a pergunta**. A maioria dos processos de ML começa fazendo uma pergunta que não pode ser respondida por um programa condicional simples ou um motor de regras. Essas perguntas geralmente giram em torno de previsões baseadas em uma coleção de dados.
2. **Coletar e preparar dados**. Para poder responder à sua pergunta, você precisa de dados. A qualidade e, às vezes, a quantidade dos seus dados determinarão quão bem você pode responder à sua pergunta inicial. Visualizar dados é um aspecto importante desta fase. Esta fase também inclui dividir os dados em um grupo de treinamento e um de teste para construir um modelo.
3. **Escolher um método de treinamento**. Dependendo da sua pergunta e da natureza dos seus dados, você precisa escolher como deseja treinar um modelo para melhor refletir seus dados e fazer previsões precisas. Esta é a parte do seu processo de ML que requer expertise específica e, frequentemente, uma quantidade considerável de experimentação.
4. **Treinar o modelo**. Usando seus dados de treinamento, você usará vários algoritmos para treinar um modelo a reconhecer padrões nos dados. O modelo pode usar pesos internos que podem ser ajustados para privilegiar certas partes dos dados em relação a outras para construir um modelo melhor.
5. **Avaliar o modelo**. Você usa dados nunca antes vistos (seus dados de teste) do seu conjunto coletado para ver como o modelo está performando.
6. **Ajuste de parâmetros**. Com base no desempenho do seu modelo, você pode refazer o processo usando diferentes parâmetros, ou variáveis, que controlam o comportamento dos algoritmos usados para treinar o modelo.
7. **Prever**. Use novas entradas para testar a precisão do seu modelo.
## Qual pergunta fazer
## Que pergunta fazer
Os computadores são particularmente habilidosos em descobrir padrões ocultos nos dados. Essa utilidade é muito útil para pesquisadores que têm perguntas sobre um determinado domínio que não podem ser facilmente respondidas criando um mecanismo baseado em regras condicionais. Dado um trabalho atuarial, por exemplo, um cientista de dados pode construir regras personalizadas sobre a mortalidade de fumantes versus não fumantes.
Computadores são particularmente habilidosos em descobrir padrões ocultos nos dados. Essa utilidade é muito útil para pesquisadores que têm perguntas sobre um domínio específico que não podem ser facilmente respondidas criando um motor de regras baseado em condições. Dada uma tarefa atuarial, por exemplo, um cientista de dados pode ser capaz de construir regras manuais sobre a mortalidade de fumantes versus não fumantes.
Quando muitas outras variáveis são incluídas na equação, no entanto, um modelo de ML pode ser mais eficiente para prever taxas de mortalidade futuras com base no histórico de saúde anterior. Um exemplo mais animador pode ser fazer previsões meteorológicas para o mês de abril em um determinado local com base em dados que incluem latitude, longitude, mudanças climáticas, proximidade ao oceano, padrões de correntes de jato e mais.
Quando muitas outras variáveis são trazidas para a equação, no entanto, um modelo de ML pode se mostrar mais eficiente para prever futuras taxas de mortalidade com base no histórico de saúde passado. Um exemplo mais animador pode ser fazer previsões meteorológicas para o mês de abril em uma determinada localização com base em dados que incluem latitude, longitude, mudanças climáticas, proximidade do oceano, padrões da corrente de jato e mais.
✅ Este [slide deck](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) sobre modelos meteorológicos oferece uma perspectiva histórica sobre o uso de ML na análise climática.
✅ Este [slide deck](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) sobre modelos meteorológicos oferece uma perspectiva histórica sobre o uso de ML na análise do tempo.
## Tarefas pré-construção
Antes de começar a construir seu modelo, há várias tarefas que você precisa completar. Para testar sua pergunta e formar uma hipótese com base nas previsões de um modelo, você precisa identificar e configurar vários elementos.
Antes de começar a construir seu modelo, existem várias tarefas que você precisa completar. Para testar sua pergunta e formar uma hipótese com base nas previsões de um modelo, você precisa identificar e configurar vários elementos.
### Dados
Para responder à sua pergunta com algum grau de certeza, você precisa de uma boa quantidade de dados do tipo certo. Há duas coisas que você precisa fazer neste momento:
Para poder responder à sua pergunta com qualquer tipo de certeza, você precisa de uma boa quantidade de dados do tipo certo. Há duas coisas que você precisa fazer neste ponto:
- **Coletar dados**. Lembre-se da lição anterior sobre justiça na análise de dados e colete seus dados com cuidado. Esteja atento às fontes desses dados, quaisquer vieses inerentes que possam ter e documente sua origem.
- **Preparar dados**. Há várias etapas no processo de preparação de dados. Você pode precisar reunir dados e normalizá-los se vierem de fontes diversas. Você pode melhorar a qualidade e a quantidade dos dados por meio de vários métodos, como converter strings em números (como fazemos em [Clustering](../../5-Clustering/1-Visualize/README.md)). Você também pode gerar novos dados com base nos originais (como fazemos em [Classificação](../../4-Classification/1-Introduction/README.md)). Você pode limpar e editar os dados (como faremos antes da lição de [Aplicativo Web](../../3-Web-App/README.md)). Por fim, pode ser necessário randomizar e embaralhar os dados, dependendo das técnicas de treinamento.
- **Coletar dados**. Mantendo em mente a lição anterior sobre justiça na análise de dados, colete seus dados com cuidado. Esteja ciente das fontes desses dados, quaisquer vieses inerentes que possam possuir, e documente sua origem.
- **Preparar dados**. Existem várias etapas no processo de preparação dos dados. Você pode precisar reunir dados e normalizá-los se eles vierem de fontes diversas. Você pode melhorar a qualidade e quantidade dos dados por vários métodos, tais como converter strings em números (como fazemos em [Clustering](../../5-Clustering/1-Visualize/README.md)). Você também pode gerar novos dados, baseados nos originais (como fazemos em [Classification](../../4-Classification/1-Introduction/README.md)). Você pode limpar e editar os dados (como faremos antes da lição [Web App](../../3-Web-App/README.md)). Finalmente, você também pode precisar randomizá-los e embaralhá-los, dependendo das suas técnicas de treinamento.
✅ Após coletar e processar seus dados, reserve um momento para verificar se sua estrutura permitirá que você responda à pergunta pretendida. Pode ser que os dados não funcionem bem na tarefa proposta, como descobrimos em nossas lições de [Clustering](../../5-Clustering/1-Visualize/README.md)!
✅ Após coletar e processar seus dados, reserve um momento para ver se sua forma permitirá que você responda à sua pergunta pretendida. Pode ser que os dados não tenham um bom desempenho na tarefa proposta, como descobrimos em nossas lições de [Clustering](../../5-Clustering/1-Visualize/README.md)!
### Features e Target
### Características e Alvo
Uma [feature](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) é uma propriedade mensurável dos seus dados. Em muitos conjuntos de dados, ela é expressa como um cabeçalho de coluna, como 'data', 'tamanho' ou 'cor'. Sua variável de feature, geralmente representada como `X` no código, representa a variável de entrada que será usada para treinar o modelo.
Uma [característica](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) é uma propriedade mensurável dos seus dados. Em muitos conjuntos de dados, é expressa como um cabeçalho de coluna como 'data', 'tamanho' ou 'cor'. Sua variável de característica, geralmente representada como `X` no código, representa a variável de entrada que será usada para treinar um modelo.
Um target é aquilo que você está tentando prever. O target, geralmente representado como `y` no código, representa a resposta à pergunta que você está tentando fazer com seus dados: em dezembro, qual **cor** de abóbora será mais barata? Em São Francisco, quais bairros terão o melhor **preço** de imóveis? Às vezes, o target também é chamado de atributo de rótulo.
Um alvo é algo que você está tentando prever. O alvo, geralmente representado como `y` no código, representa a resposta à pergunta que você está tentando fazer sobre seus dados: em dezembro, qual **cor** de abóboras será a mais barata? em San Francisco, quais bairros terão o melhor **preço** imobiliário? Às vezes, o alvo também é referido como atributo de rótulo.
### Selecionando sua variável de feature
### Selecionando sua variável de característica
🎓 **Seleção de Features e Extração de Features** Como saber qual variável escolher ao construir um modelo? Você provavelmente passará por um processo de seleção ou extração de features para escolher as variáveis certas para o modelo mais eficiente. No entanto, elas não são a mesma coisa: "A extração de features cria novas features a partir de funções das features originais, enquanto a seleção de features retorna um subconjunto das features." ([fonte](https://wikipedia.org/wiki/Feature_selection))
🎓 **Seleção de Características e Extração de Características** Como saber qual variável escolher ao construir um modelo? Você provavelmente passará por um processo de seleção ou extração de características para escolher as variáveis certas para o modelo mais performático. No entanto, elas não são a mesma coisa: "Extração de características cria novas características a partir de funções das características originais, enquanto seleção de características retorna um subconjunto das características." ([fonte](https://wikipedia.org/wiki/Feature_selection))
### Visualizar seus dados
### Visualize seus dados
Um aspecto importante do kit de ferramentas do cientista de dados é o poder de visualizar dados usando várias bibliotecas excelentes, como Seaborn ou MatPlotLib. Representar seus dados visualmente pode permitir que você descubra correlações ocultas que pode aproveitar. Suas visualizações também podem ajudar a identificar vieses ou dados desbalanceados (como descobrimos em [Classificação](../../4-Classification/2-Classifiers-1/README.md)).
Um aspecto importante do kit de ferramentas do cientista de dados é a capacidade de visualizar dados usando diversas bibliotecas excelentes como Seaborn ou MatPlotLib. Representar seus dados visualmente pode permitir que você descubra correlações ocultas que pode aproveitar. Suas visualizações também podem ajudar a descobrir viés ou dados desequilibrados (como descobrimos em [Classification](../../4-Classification/2-Classifiers-1/README.md)).
### Dividir seu conjunto de dados
### Divida seu conjunto de dados
Antes de treinar, você precisa dividir seu conjunto de dados em duas ou mais partes de tamanhos desiguais que ainda representem bem os dados.
Antes do treinamento, você precisa dividir seu conjunto de dados em duas ou mais partes de tamanho desigual que ainda representem bem os dados.
- **Treinamento**. Esta parte do conjunto de dados é ajustada ao seu modelo para treiná-lo. Este conjunto constitui a maior parte do conjunto de dados original.
- **Teste**. Um conjunto de teste é um grupo independente de dados, frequentemente extraído dos dados originais, que você usa para confirmar o desempenho do modelo construído.
- **Validação**. Um conjunto de validação é um grupo menor e independente de exemplos que você usa para ajustar os hiperparâmetros ou a arquitetura do modelo para melhorá-lo. Dependendo do tamanho dos seus dados e da pergunta que você está fazendo, pode não ser necessário construir este terceiro conjunto (como observamos em [Previsão de Séries Temporais](../../7-TimeSeries/1-Introduction/README.md)).
- **Teste**. Um conjunto de dados de teste é um grupo independente de dados, frequentemente colhido do dado original, que você usa para confirmar o desempenho do modelo construído.
- **Validação**. Um conjunto de validação é um grupo independente menor de exemplos que você usa para ajustar os hiperparâmetros, ou a arquitetura, do modelo para melhorar o modelo. Dependendo do tamanho dos seus dados e da pergunta que está fazendo, você pode não precisar construir esse terceiro conjunto (como observamos em [Previsão de Séries Temporais](../../7-TimeSeries/1-Introduction/README.md)).
## Construindo um modelo
Usando seus dados de treinamento, seu objetivo é construir um modelo, ou uma representação estatística dos seus dados, usando vários algoritmos para **treiná-lo**. Treinar um modelo o expõe aos dados e permite que ele faça suposições sobre padrões percebidos que descobre, valida e aceita ou rejeita.
Usando seus dados de treinamento, seu objetivo é construir um modelo, ou uma representação estatística dos seus dados, usando vários algoritmos para **treiná-lo**. Treinar um modelo o expõe aos dados e permite que ele faça suposições sobre padrões percebidos que descobre, valida, aceita ou rejeita.
### Decidir sobre um método de treinamento
### Decida um método de treinamento
Dependendo da sua pergunta e da natureza dos seus dados, você escolherá um método para treiná-lo. Explorando a [documentação do Scikit-learn](https://scikit-learn.org/stable/user_guide.html) - que usamos neste curso - você pode explorar várias maneiras de treinar um modelo. Dependendo da sua experiência, pode ser necessário tentar vários métodos diferentes para construir o melhor modelo. É provável que você passe por um processo em que cientistas de dados avaliam o desempenho de um modelo alimentando-o com dados não vistos, verificando sua precisão, vieses e outros problemas que degradam a qualidade, e selecionando o método de treinamento mais apropriado para a tarefa.
Dependendo da sua pergunta e da natureza dos seus dados, você escolherá um método para treiná-lo. Explorando a [documentação do Scikit-learn](https://scikit-learn.org/stable/user_guide.html) - que usamos neste curso - você pode explorar muitas formas de treinar um modelo. Dependendo da sua experiência, pode ser necessário tentar vários métodos diferentes para construir o melhor modelo. É provável que você passe por um processo no qual cientistas de dados avaliam o desempenho de um modelo alimentando-o com dados nunca vistos, verificando a precisão, o viés e outros problemas que degradam a qualidade, e selecionando o método de treinamento mais apropriado para a tarefa em questão.
### Treinar um modelo
### Treine um modelo
Com seus dados de treinamento em mãos, você está pronto para 'ajustá-los' e criar um modelo. Você notará que em muitas bibliotecas de ML encontrará o código 'model.fit' - é neste momento que você envia sua variável de feature como um array de valores (geralmente 'X') e uma variável de target (geralmente 'y').
Armado com seus dados de treinamento, você está pronto para 'ajustá-lo' para criar um modelo. Você notará que em muitas bibliotecas de ML você encontrará o código 'model.fit' - é nesse momento que você envia sua variável característica como um array de valores (geralmente 'X') e uma variável alvo (geralmente 'y').
### Avaliar o modelo
### Avalie o modelo
Uma vez concluído o processo de treinamento (pode levar muitas iterações, ou 'épocas', para treinar um modelo grande), você poderá avaliar a qualidade do modelo usando dados de teste para medir seu desempenho. Esses dados são um subconjunto dos dados originais que o modelo ainda não analisou. Você pode imprimir uma tabela de métricas sobre a qualidade do modelo.
Uma vez que o processo de treinamento esteja completo (pode levar muitas iterações, ou 'épocas', para treinar um modelo grande), você poderá avaliar a qualidade do modelo usando dados de teste para medir seu desempenho. Esses dados são um subconjunto dos dados originais que o modelo não analisou anteriormente. Você pode imprimir uma tabela de métricas sobre a qualidade do seu modelo.
🎓 **Ajuste do modelo**
No contexto de aprendizado de máquina, ajuste do modelo refere-se à precisão da função subjacente do modelo ao tentar analisar dados com os quais não está familiarizado.
No contexto do aprendizado de máquina, ajuste do modelo refere-se à precisão da função subjacente do modelo enquanto ele tenta analisar dados com os quais não está familiarizado.
🎓 **Subajuste** e **superajuste** são problemas comuns que degradam a qualidade do modelo, pois ele se ajusta de forma insuficiente ou excessiva. Isso faz com que o modelo faça previsões muito alinhadas ou pouco alinhadas com seus dados de treinamento. Um modelo superajustado prevê os dados de treinamento muito bem porque aprendeu os detalhes e ruídos dos dados excessivamente. Um modelo subajustado não é preciso, pois não consegue analisar com precisão nem seus dados de treinamento nem os dados que ainda não 'viu'.
🎓 **Underfitting** e **overfitting** são problemas comuns que degradam a qualidade do modelo, pois o modelo se ajusta ou não adequadamente. Isso causa o modelo a fazer previsões alinhadas ou muito pouco alinhadas com seus dados de treinamento. Um modelo overfit prevê os dados de treinamento muito bem porque aprendeu muito bem os detalhes e o ruído dos dados. Um modelo underfit não é preciso, pois não consegue analisar precisamente seus dados de treinamento nem dados que ainda não viu.
![modelo superajustado](../../../../1-Introduction/4-techniques-of-ML/images/overfitting.png)
![overfitting model](../../../../translated_images/pt-BR/overfitting.1c132d92bfd93cb6.webp)
> Infográfico por [Jen Looper](https://twitter.com/jenlooper)
## Ajuste de parâmetros
Depois de concluir o treinamento inicial, observe a qualidade do modelo e considere melhorá-lo ajustando seus 'hiperparâmetros'. Leia mais sobre o processo [na documentação](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
Uma vez que seu treinamento inicial esteja completo, observe a qualidade do modelo e considere melhorá-lo ajustando seus 'hiperparâmetros'. Leia mais sobre o processo [na documentação](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
## Previsão
Este é o momento em que você pode usar dados completamente novos para testar a precisão do modelo. Em um cenário de ML 'aplicado', onde você está construindo ativos web para usar o modelo em produção, este processo pode envolver coletar entrada do usuário (um clique de botão, por exemplo) para definir uma variável e enviá-la ao modelo para inferência ou avaliação.
Este é o momento em que você pode usar dados completamente novos para testar a precisão do seu modelo. Em um ambiente de ML 'aplicado', onde você está construindo ativos web para usar o modelo em produção, esse processo pode envolver coletar entradas do usuário (um clique de botão, por exemplo) para definir uma variável e enviá-la ao modelo para inferência ou avaliação.
Nestes módulos, você descobrirá como usar essas etapas para preparar, construir, testar, avaliar e prever - todos os gestos de um cientista de dados e mais, enquanto avança em sua jornada para se tornar um engenheiro de ML 'full stack'.
Nessas lições, você descobrirá como usar essas etapas para preparar, construir, testar, avaliar e prever - todos os gestos de um cientista de dados e mais, à medida que avança na jornada para se tornar um engenheiro de ML 'full stack'.
---
## 🚀Desafio
Desenhe um fluxograma refletindo as etapas de um profissional de ML. Onde você se vê agora no processo? Onde você prevê que encontrará dificuldades? O que parece fácil para você?
Desenhe um fluxograma refletindo as etapas de um praticante de ML. Onde você se vê agora no processo? Onde você prevê encontrar dificuldade? O que parece fácil para você?
## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
## Revisão e Autoestudo
## Revisão & Estudo Autônomo
Pesquise online entrevistas com cientistas de dados que discutem seu trabalho diário. Aqui está [uma](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
Procure online por entrevistas com cientistas de dados que discutem seu trabalho diário. Aqui está [uma](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
## Tarefa
@ -119,5 +119,7 @@ Pesquise online entrevistas com cientistas de dados que discutem seu trabalho di
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Aviso Legal**:
Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.
Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se tradução profissional feita por humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

250
translations/pt-BR/2-Regression/3-Linear/README.md
Unescape View File

@ -1,64 +1,65 @@
# Construir um modelo de regressão usando Scikit-learn: regressão de quatro formas
# Construindo um modelo de regressão usando Scikit-learn: regressão de quatro formas
## Nota para iniciantes
A regressão linear é usada quando queremos prever um **valor numérico** (por exemplo, preço de casa, temperatura ou vendas). Funciona encontrando uma linha reta que melhor representa a relação entre as variáveis de entrada e a saída.
A regressão linear é usada quando queremos prever um **valor numérico** (por exemplo, preço de casa, temperatura ou vendas).
Funciona encontrando uma linha reta que melhor representa a relação entre as características de entrada e o resultado.
Nesta lição, focamos em entender o conceito antes de explorar técnicas mais avançadas de regressão.
![Infográfico regressão linear vs polinomial](../../../../translated_images/pt-BR/linear-polynomial.5523c7cb6576ccab.webp)
> Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
Nesta lição, focamos em entender o conceito antes de explorar técnicas de regressão mais avançadas.
![Infográfico de regressão linear vs polinomial](../../../../translated_images/pt-BR/linear-polynomial.5523c7cb6576ccab.webp)
> Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
> ### [Esta lição está disponível em R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
> ### [Esta lição está disponível em R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introdução
Até agora, você explorou o que é regressão com dados de exemplo coletados do conjunto de dados de preços de abóboras que usaremos durante esta lição. Você também os visualizou usando Matplotlib.
Até agora, você explorou o que é regressão com dados de amostra coletados do conjunto de dados de preços de abóbora que usaremos durante esta lição. Você também o visualizou usando Matplotlib.
Agora você está pronto para se aprofundar em regressão para ML. Enquanto a visualização permite entender os dados, o verdadeiro poder do Machine Learning vem do _treinamento de modelos_. Modelos são treinados em dados históricos para capturar automaticamente dependências dos dados, permitindo prever resultados para novos dados, que o modelo ainda não viu.
Agora você está pronto para mergulhar mais fundo na regressão para ML. Enquanto a visualização permite que você compreenda os dados, o verdadeiro poder do Machine Learning vem do _treinamento de modelos_. Modelos são treinados com dados históricos para capturar automaticamente dependências dos dados e permitem que você preveja resultados para novos dados, que o modelo não viu antes.
Nesta lição, você aprenderá mais sobre dois tipos de regressão: _regressão linear básica_ e _regressão polinomial_, junto com um pouco da matemática subjacente a essas técnicas. Esses modelos permitirão prever preços de abóboras dependendo de diferentes dados de entrada.
Nesta lição, você aprenderá mais sobre dois tipos de regressão: _regressão linear básica_ e _regressão polinomial_, juntamente com parte da matemática por trás dessas técnicas. Esses modelos nos permitirão prever preços de abóboras dependendo de diferentes dados de entrada.
[![ML para iniciantes - Entendendo Regressão Linear](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
[![ML para iniciantes - Entendendo Regressão Linear](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML para iniciantes - Entendendo Regressão Linear")
> 🎥 Clique na imagem acima para uma breve visão geral em vídeo da regressão linear.
> 🎥 Clique na imagem acima para um vídeo curto sobre regressão linear.
> Ao longo deste currículo, assumimos conhecimento mínimo de matemática, e buscamos torná-lo acessível para estudantes de outras áreas, portanto fique atento a notas, 🧮 chamadas, diagramas e outras ferramentas de aprendizado para ajudar na compreensão.
> Ao longo deste currículo, assumimos conhecimento mínimo em matemática, buscando torná-lo acessível para estudantes de outras áreas, então fique atento a notas, 🧮 chamadas, diagramas e outras ferramentas de aprendizado para ajudar na compreensão.
### Pré-requisito
Você já deve estar familiarizado com a estrutura dos dados de abóboras que estamos analisando. Eles estão pré-carregados e pré-limpos no arquivo _notebook.ipynb_ desta lição. No arquivo, o preço da abóbora é exibido por alqueire em um novo dataframe. Certifique-se de que consegue executar esses notebooks em kernels no Visual Studio Code.
Você deve estar familiarizado agora com a estrutura dos dados da abóbora que estamos examinando. Você pode encontrá-los pré-carregados e pré-limpos no arquivo _notebook.ipynb_ desta lição. No arquivo, o preço da abóbora é exibido por alqueire em um novo data frame. Certifique-se de que pode executar esses notebooks em kernels no Visual Studio Code.
### Preparação
Como lembrete, você está carregando esses dados para poder fazer perguntas sobre eles.
- Quando é a melhor época para comprar abóboras?
- Qual preço posso esperar para uma caixa de abóboras miniatura?
- Devo comprá-las em cestas de meio alqueire ou por caixa de 1 1/9 alqueire?
- Quando é o melhor momento para comprar abóboras?
- Qual preço posso esperar de uma caixa de abóboras miniatura?
- Devo comprá-las em cestos de meio alqueire ou em caixas de 1 1/9 alqueire?
Vamos continuar investigando esses dados.
Na lição anterior, você criou um dataframe Pandas e o preencheu com parte do conjunto de dados original, padronizando os preços por alqueire. Fazendo isso, porém, você conseguiu apenas cerca de 400 pontos de dados e somente dos meses de outono.
Na lição anterior, você criou um data frame do Pandas e o populou com parte do conjunto de dados original, padronizando o preço por alqueire. Ao fazer isso, porém, você conseguiu apenas cerca de 400 pontos de dados e apenas para os meses de outono.
Veja os dados que pré-carregamos no notebook que acompanha esta lição. Os dados estão pré-carregados e um gráfico de dispersão inicial foi criado para mostrar os dados por mês. Talvez possamos obter mais detalhes sobre a natureza dos dados limpando-os melhor.
Dê uma olhada nos dados que pré-carregamos no notebook que acompanha esta lição. Os dados estão pré-carregados e foi plotado um gráfico de dispersão inicial para mostrar os dados de mês. Talvez possamos obter um pouco mais de detalhe sobre a natureza dos dados limpando-os mais.
## Uma linha de regressão linear
Como você aprendeu na Lição 1, o objetivo de um exercício de regressão linear é ser capaz de traçar uma linha para:
Como você aprendeu na Lição 1, o objetivo de um exercício de regressão linear é poder traçar uma linha para:
- **Mostrar relações entre variáveis**. Mostrar a relação entre variáveis
- **Mostrar relações entre variáveis**. Mostrar a relação entre as variáveis
- **Fazer previsões**. Fazer previsões precisas de onde um novo ponto de dados cairia em relação a essa linha.
É típico da **Regressão dos Mínimos Quadrados** traçar esse tipo de linha. O termo "Mínimos Quadrados" refere-se ao processo de minimizar o erro total em nosso modelo. Para cada ponto de dados, medimos a distância vertical (chamada resíduo) entre o ponto real e nossa linha de regressão.
É típico em **Regressão de Mínimos Quadrados** desenhar esse tipo de linha. O termo "Mínimos Quadrados" se refere ao processo de minimizar o erro total em nosso modelo. Para cada ponto de dados, medimos a distância vertical (chamada resíduo) entre o ponto real e nossa linha de regressão.
Elevamos essas distâncias ao quadrado por duas razões principais:
Elevamos essas distâncias ao quadrado por dois motivos principais:
1. **Magnitude sobre Direção:** Queremos tratar o erro de -5 da mesma forma que o erro de +5. Elevar ao quadrado torna todos os valores positivos.
1. **Magnitude sobre Direção:** Queremos tratar um erro de -5 igual a um erro de +5. Ao elevar ao quadrado, todos os valores ficam positivos.
2. **Penalizar Outliers:** Elevar ao quadrado dá mais peso a erros maiores, fazendo a linha ficar mais próxima dos pontos que estão distantes.
2. **Penalizando Outliers:** Elevar ao quadrado dá mais peso aos erros maiores, forçando a linha a ficar mais próxima dos pontos que estão distantes.
Depois somamos todos esses valores ao quadrado. Nosso objetivo é encontrar a linha específica onde essa soma final seja a menor possível—daí o nome "Mínimos Quadrados".
Então somamos todos esses valores ao quadrado. Nosso objetivo é encontrar a linha específica onde essa soma final seja a menor possível — daí o nome "Mínimos Quadrados".
> **🧮 Mostre a matemática**
> **🧮 Mostre-me a matemática**
>
> Essa linha, chamada _linha de melhor ajuste_, pode ser expressa por [uma equação](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
@ -66,61 +67,61 @@ Depois somamos todos esses valores ao quadrado. Nosso objetivo é encontrar a li
> Y = a + bX
> ```
>
> `X` é a 'variável explicativa'. `Y` é a 'variável dependente'. A inclinação da linha é `b` e `a` é o intercepto em y, que se refere ao valor de `Y` quando `X = 0`.
> `X` é a 'variável explicativa'. `Y` é a 'variável dependente'. A inclinação da linha é `b` e `a` é o intercepto y, que se refere ao valor de `Y` quando `X = 0`.
>
>![calcular a inclinação](../../../../translated_images/pt-BR/slope.f3c9d5910ddbfcf9.webp)
>
> Primeiro, calcule a inclinação `b`. Infográfico por [Jen Looper](https://twitter.com/jenlooper)
>
> Em outras palavras, e referindo-se à nossa questão original dos dados de abóbora: "prever o preço de uma abóbora por alqueire por mês", `X` se referiria ao preço e `Y` seria o mês da venda.
> Em outras palavras, e referindo à pergunta original dos nossos dados de abóbora: "prever o preço de uma abóbora por alqueire segundo o mês", `X` se referiria ao mês e `Y` se referiria ao preço de venda.
>
>![complete a equação](../../../../translated_images/pt-BR/calculation.a209813050a1ddb1.webp)
>![completar a equação](../../../../translated_images/pt-BR/calculation.a209813050a1ddb1.webp)
>
> Calcule o valor de Y. Se você está pagando em torno de $4, deve ser abril! Infográfico por [Jen Looper](https://twitter.com/jenlooper)
> Calcule o valor de Y. Se você está pagando cerca de $4, deve ser abril! Infográfico por [Jen Looper](https://twitter.com/jenlooper)
>
> A matemática que calcula a linha deve demonstrar a inclinação da linha, que também depende do intercepto, ou onde `Y` está situado quando `X = 0`.
> A matemática que calcula a linha deve demonstrar a inclinação da linha, que também depende do intercepto, ou onde `Y` se situa quando `X = 0`.
>
> Você pode observar o método de cálculo destes valores no site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Também visite [este calculador de Mínimos Quadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver como os valores dos números impactam a linha.
> Você pode observar o método de cálculo desses valores no site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Também visite [calculadora de mínimos quadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver como os valores dos números impactam a linha.
## Correlação
Mais um termo para entender é o **Coeficiente de Correlação** entre as variáveis X e Y dadas. Usando um gráfico de dispersão, você pode visualizar rapidamente esse coeficiente. Um gráfico com pontos de dados alinhados em uma linha nítida tem alta correlação, mas um gráfico com pontos dispersos entre X e Y tem baixa correlação.
Mais um termo para entender é o **Coeficiente de Correlação** entre as variáveis X e Y dadas. Usando um gráfico de dispersão, você pode visualizar rapidamente esse coeficiente. Um gráfico com pontos de dados alinhados em uma linha limpa tem alta correlação, mas um gráfico com pontos dispersos por toda parte tem baixa correlação.
Um bom modelo de regressão linear terá um Coeficiente de Correlação alto (próximo de 1 e não de 0) usando o método de Regressão dos Mínimos Quadrados com uma linha de regressão.
Um bom modelo de regressão linear será aquele que tem um alto Coeficiente de Correlação (mais próximo de 1 do que de 0) usando o método de Regressão de Mínimos Quadrados com uma linha de regressão.
✅ Execute o notebook que acompanha esta lição e olhe o gráfico de dispersão de Mês para Preço. Os dados associando Mês ao Preço nas vendas de abóbora parecem ter alta ou baixa correlação, de acordo com sua interpretação visual do gráfico? Isso muda se você usar uma medida mais detalhada em vez de `Month`, por exemplo, *dia do ano* (ou seja, número de dias desde o começo do ano)?
✅ Execute o notebook que acompanha esta lição e observe o gráfico de dispersão Mês versus Preço. Os dados associando Mês a Preço para vendas de abóboras parecem ter alta ou baixa correlação, segundo sua interpretação visual do gráfico de dispersão? Isso muda se você usar uma medida mais detalhada em vez de `Mês`, por exemplo, *dia do ano* (ou seja, número de dias desde o início do ano)?
No código abaixo, assumiremos que limpamos os dados e obtivemos um dataframe chamado `new_pumpkins`, semelhante ao seguinte:
No código abaixo, assumiremos que limpamos os dados e obtivemos um data frame chamado `new_pumpkins`, semelhante ao seguinte:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
ID | Mês | DiaDoAno | Variedade | Cidade | Embalagem | Preço Baixo | Preço Alto | Preço
---|-------|-----------|---------|------|---------|-----------|------------|-------
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
70 | 9 | 267 | TIPO TORTA | BALTIMORE | Caixas de 1 1/9 alqueire | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | TIPO TORTA | BALTIMORE | Caixas de 1 1/9 alqueire | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | TIPO TORTA | BALTIMORE | Caixas de 1 1/9 alqueire | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | TIPO TORTA | BALTIMORE | Caixas de 1 1/9 alqueire | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | TIPO TORTA | BALTIMORE | Caixas de 1 1/9 alqueire | 15.0 | 15.0 | 13.636364
> O código para limpar os dados está disponível em [`notebook.ipynb`](notebook.ipynb). Realizamos as mesmas etapas de limpeza da lição anterior e calculamos a coluna `DayOfYear` usando a expressão a seguir:
> O código para limpar os dados está disponível em [`notebook.ipynb`](notebook.ipynb). Realizamos os mesmos passos de limpeza da lição anterior e calculamos a coluna `DayOfYear` usando a seguinte expressão:
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
Agora que você entende a matemática por trás da regressão linear, vamos criar um modelo de Regressão para ver se podemos prever qual embalagem de abóboras terá os melhores preços. Alguém comprando abóboras para um campo de abóboras de feriado pode querer essa informação para otimizar suas compras.
Agora que você entendeu a matemática por trás da regressão linear, vamos criar um modelo de regressão para ver se podemos prever qual embalagem de abóboras terá os melhores preços. Alguém comprando abóboras para um patch de abóboras de feriado pode querer essa informação para otimizar suas compras dos pacotes.
## Procurando correlação
## Buscando correlação
[![ML para iniciantes - Procurando correlação: a chave para regressão linear](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML para iniciantes - Procurando correlação: a chave para regressão linear")
[![ML para iniciantes - Buscando Correlação: A Chave para Regressão Linear](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML para iniciantes - Buscando Correlação: A Chave para Regressão Linear")
> 🎥 Clique na imagem acima para uma breve visão geral em vídeo sobre correlação.
> 🎥 Clique na imagem acima para um vídeo curto sobre correlação.
Da lição anterior, você provavelmente viu que o preço médio para diferentes meses parece assim:
Na lição anterior, você provavelmente viu que o preço médio para diferentes meses parece assim:
<img alt="Preço médio por mês" src="../../../../translated_images/pt-BR/barchart.a833ea9194346d76.webp" width="50%"/>
Isso sugere que deve haver alguma correlação, e podemos tentar treinar um modelo de regressão linear para prever a relação entre `Month` e `Price`, ou entre `DayOfYear` e `Price`. Aqui está o gráfico de dispersão que mostra a última relação:
Isso sugere que deve haver alguma correlação, e podemos tentar treinar um modelo de regressão linear para prever a relação entre `Mês` e `Preço`, ou entre `DiaDoAno` e `Preço`. Aqui está o gráfico de dispersão que mostra a segunda relação:
<img alt="Gráfico de dispersão de preço vs dia do ano" src="../../../../translated_images/pt-BR/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
<img alt="Gráfico de dispersão de Preço vs. Dia do Ano" src="../../../../translated_images/pt-BR/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
Vamos ver se há correlação usando a função `corr`:
@ -128,8 +129,8 @@ Vamos ver se há correlação usando a função `corr`:
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
Parece que a correlação é pequena, -0,15 pelo `Month` e -0,17 pelo `DayOfMonth`, mas pode haver outra relação importante. Parece que existem diferentes clusters de preços correspondentes a diferentes variedades de abóboras. Para confirmar essa hipótese, vamos plotar cada categoria de abóbora usando uma cor diferente. Passando um parâmetro `ax` para a função `scatter`, podemos plotar todos os pontos no mesmo gráfico:
Parece que a correlação é bem pequena, -0.15 pelo `Mês` e -0.17 pelo `DiaDoAno`, mas pode haver outra relação importante. Parece que há diferentes grupos de preços correspondendo a diferentes variedades de abóbora. Para confirmar essa hipótese, vamos plotar cada categoria de abóbora com uma cor diferente. Passando um parâmetro `ax` para a função de plotagem `scatter`, podemos plotar todos os pontos no mesmo gráfico:
```python
ax=None
@ -138,42 +139,41 @@ 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)
```
<img alt="Gráfico de dispersão de Preço vs. Dia do Ano" src="../../../../translated_images/pt-BR/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
<img alt="Gráfico de dispersão de preço vs dia do ano colorido" src="../../../../translated_images/pt-BR/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
Nossa investigação sugere que a variedade tem mais efeito no preço geral que a data real de venda. Podemos ver isso com um gráfico de barras:
Nossa investigação sugere que a variedade tem mais efeito no preço geral do que a própria data de venda. Podemos ver isso em um gráfico de barras:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
<img alt="Gráfico de barras de preço por variedade" src="../../../../translated_images/pt-BR/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
<img alt="Gráfico de barras preço vs variedade" src="../../../../translated_images/pt-BR/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
Vamos focar momentaneamente apenas em uma variedade de abóbora, o 'tipo torta', e ver qual efeito a data tem no preço:
Vamos focar por enquanto em apenas uma variedade de abóbora, o 'tipo torta', e ver qual efeito a data tem no preço:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
<img alt="Gráfico de dispersão de preço vs dia do ano para abóboras tipo torta" src="../../../../translated_images/pt-BR/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
<img alt="Gráfico de dispersão de Preço vs. Dia do Ano" src="../../../../translated_images/pt-BR/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
Se agora calcularmos a correlação entre `Price` e `DayOfYear` usando a função `corr`, obteremos algo como `-0.27` — o que significa que treinar um modelo preditivo faz sentido.
Se agora calcularmos a correlação entre `Preço` e `DiaDoAno` usando a função `corr`, obteremos algo como `-0.27` - o que significa que faz sentido treinar um modelo preditivo.
> Antes de treinar um modelo de regressão linear, é importante garantir que nossos dados estejam limpos. Regressão linear não funciona bem com valores faltantes, portanto faz sentido eliminar todas as células vazias:
> Antes de treinar um modelo de regressão linear, é importante garantir que nossos dados estejam limpos. A regressão linear não funciona bem com valores ausentes, por isso faz sentido eliminar todas as células vazias:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Outra abordagem seria preencher esses valores vazios com a média da coluna correspondente.
## Regressão Linear Simples
[![ML para iniciantes - Regressão Linear e Polinomial usando Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML para iniciantes - Regressão Linear e Polinomial usando Scikit-learn")
> 🎥 Clique na imagem acima para uma breve visão geral em vídeo da regressão linear e polinomial.
> 🎥 Clique na imagem acima para um vídeo curto sobre regressão linear e polinomial.
Para treinar nosso modelo de Regressão Linear, usaremos a biblioteca **Scikit-learn**.
@ -182,32 +182,32 @@ from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Começamos separando os valores de entrada (recursos) e a saída esperada (rótulo) em arrays numpy separados:
Começamos separando os valores de entrada (features) e a saída esperada (rótulo) em arrays numpy separados:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Note que tivemos que realizar `reshape` nos dados de entrada para que o pacote Linear Regression os entendesse corretamente. A Regressão Linear espera uma matriz 2D como entrada, onde cada linha da matriz corresponde a um vetor de características de entrada. No nosso caso, já que temos apenas uma entrada, precisamos de uma matriz com formato N×1, onde N é o tamanho do conjunto de dados.
> Note que tivemos que realizar o `reshape` nos dados de entrada para que o pacote de Regressão Linear os entenda corretamente. Regressão Linear espera uma matriz 2D como entrada, onde cada linha da matriz corresponde a um vetor de recursos de entrada. No nosso caso, já que temos apenas uma entrada, precisamos de uma matriz com formato N&times;1, onde N é o tamanho do conjunto de dados.
Depois, precisamos dividir os dados em conjuntos de treino e teste para que possamos validar nosso modelo após o treinamento:
Depois, precisamos dividir os dados em datasets de treino e teste, para que possamos validar nosso modelo após o treinamento:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Finalmente, o treinamento do modelo de Regressão Linear real leva apenas duas linhas de código. Definimos o objeto `LinearRegression`, e ajustamos ele aos nossos dados usando o método `fit`:
Finalmente, o treinamento do modelo de Regressão Linear em si leva apenas duas linhas de código. Definimos o objeto `LinearRegression` e o ajustamos aos nossos dados usando o método `fit`:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
O objeto `LinearRegression` após o `fit` contém todos os coeficientes da regressão, que podem ser acessados usando a propriedade `.coef_`. No nosso caso, há apenas um coeficiente, que deve estar em torno de `-0.017`. Isso significa que os preços parecem cair um pouco com o tempo, mas não muito, cerca de 2 centavos por dia. Também podemos acessar o ponto de interseção da regressão com o eixo Y usando `lin_reg.intercept_` — será cerca de `21` no nosso caso, indicando o preço no início do ano.
O objeto `LinearRegression` após o ajuste (`fit`) contém todos os coeficientes da regressão, que podem ser acessados usando a propriedade `.coef_`. No nosso caso, há apenas um coeficiente, que deve estar em torno de `-0.017`. Isso significa que os preços parecem cair um pouco com o tempo, mas não muito, cerca de 2 centavos por dia. Também podemos acessar o ponto de interseção da regressão com o eixo Y usando `lin_reg.intercept_` - será cerca de `21` no nosso caso, indicando o preço no início do ano.
Para ver quão preciso nosso modelo é, podemos prever preços em um conjunto de dados de teste e então medir quão próximas estão nossas previsões dos valores esperados. Isso pode ser feito usando a métrica de erro quadrático médio da raiz (RMSE), que é a raiz da média de todas as diferenças ao quadrado entre o valor esperado e o previsto.
Para ver quão preciso nosso modelo é, podemos prever preços em um conjunto de dados de teste e depois medir quão próximas estão nossas previsões dos valores esperados. Isso pode ser feito usando a métrica raiz do erro quadrático médio (RMSE), que é a raiz da média de todas as diferenças quadráticas entre o valor esperado e o previsto.
```python
pred = lin_reg.predict(X_test)
@ -216,13 +216,13 @@ rmse = np.sqrt(mean_squared_error(y_test,pred))
print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
```
Nosso erro parece estar em torno de 2 pontos, o que é ~17%. Não muito bom. Outro indicador de qualidade do modelo é o **coeficiente de determinação**, que pode ser obtido assim:
Nosso erro parece ser em torno de 2 pontos, o que é ~17%. Não muito bom. Outro indicador da qualidade do modelo é o **coeficiente de determinação**, que pode ser obtido assim:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Se o valor for 0, isto significa que o modelo não leva em conta os dados de entrada, e atua como o *pior preditor linear*, que é simplesmente um valor médio do resultado. O valor 1 significa que podemos prever perfeitamente todas as saídas esperadas. No nosso caso, o coeficiente está em torno de 0.06, o que é bem baixo.
Se o valor for 0, significa que o modelo não leva os dados de entrada em conta e atua como o *pior preditor linear*, que é simplesmente um valor médio do resultado. O valor 1 significa que podemos prever perfeitamente todas as saídas esperadas. No nosso caso, o coeficiente está em torno de 0,06, que é bastante baixo.
Também podemos plotar os dados de teste junto com a linha de regressão para ver melhor como a regressão funciona no nosso caso:
@ -235,17 +235,17 @@ plt.plot(X_test,pred)
## Regressão Polinomial
Outro tipo de Regressão Linear é a Regressão Polinomial. Embora às vezes haja uma relação linear entre variáveis - quanto maior a abóbora em volume, maior o preço - às vezes essas relações não podem ser plotadas como um plano ou linha reta.
Outro tipo de Regressão Linear é a Regressão Polinomial. Embora às vezes haja uma relação linear entre variáveis — quanto maior a abóbora em volume, maior o preço — às vezes essas relações não podem ser plotadas como um plano ou linha reta.
✅ Aqui estão [mais alguns exemplos](https://online.stat.psu.edu/stat501/lesson/9/9.8) de dados que poderiam usar Regressão Polinomial
Observe novamente a relação entre Data e Preço. Este gráfico de dispersão parece que deveria necessariamente ser analisado por uma linha reta? Os preços não podem flutuar? Nesse caso, você pode tentar a regressão polinomial.
Dê outra olhada na relação entre Data e Preço. Este diagrama de dispersão parece que deve necessariamente ser analisado por uma linha reta? Os preços não podem oscilar? Neste caso, você pode tentar regressão polinomial.
✅ Polinômios são expressões matemáticas que podem consistir de uma ou mais variáveis e coeficientes
✅ Polinômios são expressões matemáticas que podem consistir em uma ou mais variáveis e coeficientes.
A regressão polinomial cria uma linha curva para ajustar melhor dados não lineares. No nosso caso, se incluirmos a variável ao quadrado `DayOfYear` nos dados de entrada, deveremos ser capazes de ajustar nossos dados com uma curva parabólica, que terá um mínimo em um certo ponto ao longo do ano.
A regressão polinomial cria uma linha curva para se ajustar melhor a dados não lineares. No nosso caso, se incluirmos uma variável `DayOfYear` ao quadrado nos dados de entrada, devemos ser capazes de ajustar nossos dados com uma curva parabólica, que terá um mínimo em um certo ponto dentro do ano.
O Scikit-learn inclui uma útil [API de pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes etapas do processamento de dados. Um **pipeline** é uma cadeia de **estimadores**. No nosso caso, criaremos um pipeline que primeiro adiciona características polinomiais ao nosso modelo, e então treina a regressão:
O Scikit-learn inclui uma API de [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) útil para combinar diferentes etapas de processamento de dados. Um **pipeline** é uma cadeia de **estimadores**. No nosso caso, criaremos um pipeline que primeiro adiciona características polinomiais ao nosso modelo e depois treina a regressão:
```python
from sklearn.preprocessing import PolynomialFeatures
@ -256,23 +256,45 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
Usar `PolynomialFeatures(2)` significa que vamos incluir todos os polinômios de segundo grau a partir dos dados de entrada. No nosso caso, isso significará apenas `DayOfYear`<sup>2</sup>, mas dado duas variáveis de entrada X e Y, isso adicionará X<sup>2</sup>, XY e Y<sup>2</sup>. Podemos também usar polinômios de grau maior, se quisermos.
Usar `PolynomialFeatures(2)` significa que incluiremos todos os polinômios de segundo grau dos dados de entrada. No nosso caso, isso significará apenas `DayOfYear`<sup>2</sup>, mas dado duas variáveis de entrada X e Y, isso adicionará X<sup>2</sup>, XY e Y<sup>2</sup>. Também podemos usar polinômios de grau mais alto, se quisermos.
Pipelines podem ser usados da mesma forma que o objeto original `LinearRegression`, ou seja, podemos `fit` o pipeline e depois usar `predict` para obter os resultados da predição:
```python
pred = pipeline.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}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
Para plotar a curva aproximada suave, usamos `np.linspace` para criar um intervalo uniforme de valores de entrada, em vez de plotar diretamente nos dados de teste não ordenados (o que produziria uma linha em zigue-zague):
```python
X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
y_range = pipeline.predict(X_range)
plt.scatter(X_test, y_test)
plt.plot(X_range, y_range)
```
Pipelines podem ser usados da mesma forma que o objeto original `LinearRegression`, ou seja, podemos `fit`ar o pipeline, e então usar `predict` para obter os resultados da predição. Aqui está o gráfico mostrando os dados de teste, e a curva de aproximação:
Aqui está o gráfico mostrando os dados de teste e a curva aproximada:
<img alt="Polynomial regression" src="../../../../translated_images/pt-BR/poly-results.ee587348f0f1f60b.webp" width="50%" />
Usando Regressão Polinomial, podemos obter erros quadráticos médios ligeiramente menores e coeficientes de determinação maiores, mas não significativamente. Precisamos levar em conta outras características!
Usando Regressão Polinomial, podemos obter um RMSE ligeiramente menor e uma determinação maior, mas não significativamente. Precisamos levar em conta outras características!
> Você pode ver que os preços mínimos das abóboras são observados em algum momento próximo ao Halloween. Como você pode explicar isso?
> Você pode ver que os preços mínimos de abóboras são observados em algum momento próximo ao Halloween. Como você pode explicar isso?
🎃 Parabéns, você acaba de criar um modelo que pode ajudar a prever o preço de abóboras para torta. Você provavelmente pode repetir o mesmo procedimento para todos os tipos de abóbora, mas isso seria trabalhoso. Vamos aprender agora como levar em conta a variedade de abóbora em nosso modelo!
🎃 Parabéns, você acabou de criar um modelo que pode ajudar a prever o preço de abóboras para torta. Você provavelmente pode repetir o mesmo procedimento para todos os tipos de abóboras, mas isso seria tedioso. Vamos aprender agora como levar a variedade da abóbora em conta no nosso modelo!
## Características Categóricas
No mundo ideal, queremos ser capazes de prever preços para diferentes variedades de abóbora usando o mesmo modelo. No entanto, a coluna `Variety` é um pouco diferente de colunas como `Month`, pois contém valores não numéricos. Essas colunas são chamadas de **categóricas**.
No mundo ideal, queremos ser capazes de prever preços para diferentes variedades de abóboras usando o mesmo modelo. No entanto, a coluna `Variety` é um pouco diferente de colunas como `Month`, pois contém valores não numéricos. Essas colunas são chamadas de **categóricas**.
[![ML para iniciantes - Predições de Características Categóricas com Regressão Linear](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML para iniciantes - Predições de Características Categóricas com Regressão Linear")
[![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")
> 🎥 Clique na imagem acima para um breve vídeo sobre o uso de características categóricas.
@ -280,12 +302,12 @@ Aqui você pode ver como o preço médio depende da variedade:
<img alt="Average price by variety" src="../../../../translated_images/pt-BR/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
Para levar a variedade em conta, primeiro precisamos convertê-la para forma numérica, ou **codificá-la**. Há várias formas para isso:
Para levar a variedade em conta, primeiro precisamos convertê-la para uma forma numérica, ou **codificá-la**. Existem várias maneiras de fazer isso:
* A simples **codificação numérica** constrói uma tabela das diferentes variedades, e depois substitui o nome da variedade por um índice nessa tabela. Isso não é a melhor ideia para regressão linear, porque a regressão linear pega o valor numérico real do índice, e o adiciona ao resultado, multiplicando por algum coeficiente. No nosso caso, a relação entre o número do índice e o preço é claramente não linear, mesmo que asseguremos que os índices estejam ordenados de alguma maneira específica.
* O **one-hot encoding** substituirá a coluna `Variety` por 4 colunas diferentes, uma para cada variedade. Cada coluna conterá `1` se a linha correspondente for de uma determinada variedade, e `0` caso contrário. Isso significa que haverá quatro coeficientes na regressão linear, um para cada variedade de abóbora, responsável pelo "preço inicial" (ou melhor, "preço adicional") para aquela variedade específica.
* Uma simples **codificação numérica** irá construir uma tabela das diferentes variedades e depois substituir o nome da variedade por um índice nessa tabela. Isso não é uma boa ideia para regressão linear, porque a regressão linear usa o valor numérico real do índice e o adiciona ao resultado, multiplicando por algum coeficiente. No nosso caso, a relação entre o número do índice e o preço é claramente não linear, mesmo que ordenemos os índices de alguma forma específica.
* **One-hot encoding** substituirá a coluna `Variety` por 4 colunas diferentes, uma para cada variedade. Cada coluna conterá `1` se a linha correspondente for daquela variedade, e `0` caso contrário. Isso significa que haverá quatro coeficientes na regressão linear, um para cada variedade de abóbora, responsável pelo "preço inicial" (ou melhor, "preço adicional") para aquela variedade em particular.
O código abaixo mostra como podemos fazer o one-hot encoding da variedade:
O código abaixo mostra como podemos fazer one-hot encoding para uma variedade:
```python
pd.get_dummies(new_pumpkins['Variety'])
@ -302,14 +324,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
Para treinar a regressão linear usando a variedade codificada por one-hot encoding como entrada, só precisamos inicializar corretamente os dados `X` e `y`:
Para treinar regressão linear usando a variedade codificada por one-hot como entrada, só precisamos inicializar os dados `X` e `y` corretamente:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
O resto do código é o mesmo que usamos acima para treinar a Regressão Linear. Se você tentar, verá que o erro quadrático médio fica mais ou menos o mesmo, mas obtemos um coeficiente de determinação muito maior (~77%). Para obter previsões ainda mais precisas, podemos levar mais características categóricas em conta, bem como características numéricas, como `Month` ou `DayOfYear`. Para obter uma grande matriz de características, podemos usar `join`:
O resto do código é o mesmo que usamos acima para treinar a Regressão Linear. Se você tentar, verá que o erro médio quadrático é aproximadamente o mesmo, mas obtemos um coeficiente de determinação muito maior (~77%). Para obter previsões ainda mais precisas, podemos levar em conta mais características categóricas, bem como características numéricas, como `Month` ou `DayOfYear`. Para obter um grande array de características, podemos usar `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -319,11 +341,11 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
Aqui também levamos em conta `City` e tipo de `Package`, o que nos dá MSE 2.84 (10%), e determinação 0.94!
Aqui também levamos em conta `City` e `Package`, o que nos dá RMSE 2,84 (10,5%) e determinação 0,94!
## Combinando tudo
## Colocando tudo junto
Para fazer o melhor modelo, podemos usar dados combinados (categóricos codificados one-hot + numéricos) do exemplo acima junto com a Regressão Polinomial. Aqui está o código completo para sua conveniência:
Para fazer o melhor modelo, podemos usar dados combinados (categóricos codificados por one-hot + numéricos) do exemplo acima junto com Regressão Polinomial. Aqui está o código completo para sua conveniência:
```python
# configurar dados de treinamento
@ -333,44 +355,44 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# fazer divisão treino-teste
# fazer divisão de treino-teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# configurar e treinar o pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# prever resultados para os dados de teste
# prever resultados para dados de teste
pred = pipeline.predict(X_test)
# calcular MSE e determinação
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
# calcular RMSE e coeficiente de determinação
rmse = mean_squared_error(y_test, pred, squared=False)
print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
Isso deve nos dar o melhor coeficiente de determinação de quase 97%, e MSE=2.23 (~8% de erro de previsão).
Isso deve nos dar o melhor coeficiente de determinação de quase 97%, e RMSE=2,23 (~8% de erro de previsão).
| Modelo | MSE | Determinação |
| Modelo | RMSE | Determinação |
|-------|-----|---------------|
| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polinomial | 2.73 (17.0%) | 0.08 |
| `Variety` Linear | 5.24 (19.7%) | 0.77 |
| Todas as características Linear | 2.84 (10.5%) | 0.94 |
| Todas as características Polinomial | 2.23 (8.25%) | 0.97 |
| Linear `DayOfYear` | 2,77 (17,2%) | 0,07 |
| Polinomial `DayOfYear` | 2,73 (17,0%) | 0,08 |
| Linear `Variety` | 5,24 (19,7%) | 0,77 |
| Linear com todas características | 2,84 (10,5%) | 0,94 |
| Polinomial com todas características | 2,23 (8,25%) | 0,97 |
🏆 Muito bem! Você criou quatro modelos de regressão em uma lição, e melhorou a qualidade do modelo para 97%. Na seção final sobre Regressão, você aprenderá sobre Regressão Logística para determinar categorias.
🏆 Muito bem! Você criou quatro modelos de regressão em uma lição e melhorou a qualidade do modelo para 97%. Na seção final sobre Regressão, você aprenderá sobre Regressão Logística para determinar categorias.
---
## 🚀Desafio
Teste várias variáveis diferentes neste notebook para ver como a correlação corresponde à precisão do modelo.
## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
## Revisão & Estudo Autônomo
## Revisão & Autoestudo
Nesta lição aprendemos sobre Regressão Linear. Existem outros tipos importantes de Regressão. Leia sobre as técnicas Stepwise, Ridge, Lasso e Elasticnet. Um bom curso para estudar e aprender mais é o [curso de Aprendizado Estatístico de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
@ -382,5 +404,5 @@ Nesta lição aprendemos sobre Regressão Linear. Existem outros tipos important
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Aviso Legal**:
Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos empenhemos pela precisão, por favor, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
Este documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, por favor, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

67
translations/pt-BR/2-Regression/3-Linear/solution/notebook.ipynb
Unescape View File

@ -6,12 +6,12 @@
"source": [
"## Regressão Linear e Polinomial para Precificação de Abóboras - Aula 3\n",
"\n",
"Carregue as bibliotecas necessárias e o conjunto de dados. Converta os dados para um dataframe contendo um subconjunto dos dados:\n",
"Carregue as bibliotecas e o conjunto de dados necessários. Converta os dados para um dataframe contendo um subconjunto dos dados:\n",
"\n",
"- Considere apenas abóboras com preços definidos por alqueire\n",
"- Converta a data para o formato de mês\n",
"- Calcule o preço como uma média entre os preços mais altos e mais baixos\n",
"- Converta o preço para refletir a precificação pela quantidade em alqueires\n"
"- Obtenha apenas abóboras precificadas por alqueire\n",
"- Converta a data para um mês\n",
"- Calcule o preço como uma média dos preços máximo e mínimo\n",
"- Converta o preço para refletir a precificação por quantidade de alqueire\n"
]
},
{
@ -377,7 +377,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Um gráfico de dispersão nos lembra que temos dados mensais apenas de agosto a dezembro. Provavelmente precisamos de mais dados para poder tirar conclusões de forma linear.\n"
"Um gráfico de dispersão nos lembra que só temos dados mensais de agosto a dezembro. Provavelmente precisamos de mais dados para poder tirar conclusões de forma linear.\n"
]
},
{
@ -447,7 +447,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Vamos ver se há correlação:\n"
]
},
{
"cell_type": "code",
@ -472,7 +474,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Parece que a correlação é bem pequena, mas há alguma outra relação mais importante - porque os pontos de preço no gráfico acima parecem ter vários clusters distintos. Vamos fazer um gráfico que mostrará diferentes variedades de abóbora:\n"
"Parece que a correlação é bem pequena, mas existe alguma outra relação mais importante - porque os pontos de preço no gráfico acima parecem ter vários agrupamentos distintos. Vamos fazer um gráfico que mostrará diferentes variedades de abóbora:\n"
]
},
{
@ -535,7 +537,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Por enquanto, vamos nos concentrar apenas em uma variedade - **tipo de torta**.\n"
]
},
{
"cell_type": "code",
@ -584,7 +588,7 @@
"source": [
"### Regressão Linear\n",
"\n",
"Usaremos o Scikit Learn para treinar um modelo de regressão linear:\n"
"Usaremos o Scikit Learn para treinar o modelo de regressão linear:\n"
]
},
{
@ -662,7 +666,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"A inclinação da linha pode ser determinada a partir dos coeficientes de regressão linear:\n"
"A inclinação da linha pode ser determinada a partir dos coeficientes da regressão linear:\n"
]
},
{
@ -688,7 +692,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Podemos usar o modelo treinado para prever o preço:\n"
]
},
{
"cell_type": "code",
@ -718,9 +724,9 @@
"source": [
"### Regressão Polinomial\n",
"\n",
"Às vezes, a relação entre as características e os resultados é inerentemente não linear. Por exemplo, os preços de abóboras podem ser altos no inverno (meses=1,2), depois caírem no verão (meses=5-7) e subirem novamente. A regressão linear não consegue capturar essa relação com precisão.\n",
"Às vezes, a relação entre as características e os resultados é inerentemente não linear. Por exemplo, os preços da abóbora podem ser altos no inverno (meses=1,2), depois cair no verão (meses=5-7) e então subir novamente. A regressão linear não consegue encontrar essa relação com precisão.\n",
"\n",
"Nesse caso, podemos considerar adicionar características extras. Uma maneira simples é usar polinômios das características de entrada, o que resultaria em **regressão polinomial**. No Scikit Learn, podemos pré-computar automaticamente características polinomiais usando pipelines:\n"
"Nesse caso, podemos considerar adicionar características extras. Uma forma simples é usar polinômios das características de entrada, o que resultaria em **regressão polinomial**. No Scikit Learn, podemos pré-calcular automaticamente as características polinomiais usando pipelines: \n"
]
},
{
@ -775,20 +781,23 @@
"score = pipeline.score(X_train,y_train)\n",
"print('Model determination: ', score)\n",
"\n",
"plt.scatter(X_test,y_test)\n",
"plt.plot(sorted(X_test),pipeline.predict(sorted(X_test)))"
"X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)\n",
"y_range = pipeline.predict(X_range)\n",
"\n",
"plt.scatter(X_test, y_test)\n",
"plt.plot(X_range, y_range)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Codificando variedades\n",
"### Variedades de codificação\n",
"\n",
"No mundo ideal, queremos ser capazes de prever os preços de diferentes variedades de abóbora usando o mesmo modelo. Para levar a variedade em consideração, primeiro precisamos convertê-la para uma forma numérica, ou seja, **codificar**. Existem várias maneiras de fazer isso:\n",
"No mundo ideal, queremos ser capazes de prever preços para diferentes variedades de abóbora usando o mesmo modelo. Para levar a variedade em conta, primeiro precisamos convertê-la para forma numérica, ou **codificar**. Há várias maneiras de fazer isso:\n",
"\n",
"* Codificação numérica simples, que cria uma tabela com as diferentes variedades e, em seguida, substitui o nome da variedade por um índice nessa tabela. Essa não é a melhor ideia para regressão linear, porque a regressão linear considera o valor numérico do índice, e esse valor numérico provavelmente não terá uma correlação direta com o preço.\n",
"* Codificação one-hot, que substitui a coluna `Variety` por 4 colunas diferentes, uma para cada variedade, que conterão 1 se a linha correspondente for da variedade em questão, e 0 caso contrário.\n",
"* Codificação numérica simples que construirá uma tabela das diferentes variedades, e então substituirá o nome da variedade por um índice nessa tabela. Esta não é a melhor ideia para regressão linear, pois a regressão linear considera o valor numérico do índice, e esse valor numérico provavelmente não se correlaciona numericamente com o preço.\n",
"* Codificação one-hot, que substituirá a coluna `Variety` por 4 colunas diferentes, uma para cada variedade, que conterá 1 se a linha correspondente for da variedade dada, e 0 caso contrário.\n",
"\n",
"O código abaixo mostra como podemos realizar a codificação one-hot de uma variedade:\n"
]
@ -938,9 +947,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"### Regressão Linear em Variedade\n",
"### Regressão Linear na Variedade\n",
"\n",
"Agora usaremos o mesmo código mencionado acima, mas, em vez de `DayOfYear`, utilizaremos nossa variedade codificada em one-hot como entrada:\n"
"Agora usaremos o mesmo código acima, mas em vez de `DayOfYear` usaremos nossa variedade codificada em one-hot como entrada:\n"
]
},
{
@ -988,7 +997,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos também tentar usar outras características da mesma maneira e combiná-las com características numéricas, como `Month` ou `DayOfYear`:\n"
"Também podemos tentar usar outras características da mesma maneira e combiná-las com características numéricas, como `Month` ou `DayOfYear`:\n"
]
},
{
@ -1021,7 +1030,7 @@
"source": [
"### Regressão Polinomial\n",
"\n",
"A regressão polinomial também pode ser usada com características categóricas que foram codificadas em one-hot. O código para treinar a regressão polinomial seria essencialmente o mesmo que vimos acima.\n"
"A regressão polinomial também pode ser usada com características categóricas que são codificadas em one-hot. O código para treinar a regressão polinomial seria essencialmente o mesmo que vimos acima.\n"
]
},
{
@ -1068,7 +1077,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**Aviso Legal**: \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Aviso Legal**: \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -1098,13 +1107,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "d77bd89ae7e79780c68c58bab91f13f8",
"translation_date": "2025-08-29T22:47:23+00:00",
"source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
"language_code": "br"
}
"orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2

14
translations/pt-PT/.co-op-translator.json
Unescape View File

@ -36,8 +36,8 @@
"language_code": "pt-PT"
},
"1-Introduction/4-techniques-of-ML/README.md": {
"original_hash": "9d91f3af3758fdd4569fb410575995ef",
"translation_date": "2025-09-05T08:44:28+00:00",
"original_hash": "84b1715a6be62ef1697351dcc5d7b567",
"translation_date": "2026-04-26T18:41:00+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
"language_code": "pt-PT"
},
@ -90,8 +90,8 @@
"language_code": "pt-PT"
},
"2-Regression/3-Linear/README.md": {
"original_hash": "26c53a922f1f1e8542b0ea41ff52221a",
"translation_date": "2026-04-20T18:58:00+00:00",
"original_hash": "8b776e731c35b171d316d01d0e7b1369",
"translation_date": "2026-04-26T18:40:33+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "pt-PT"
},
@ -107,6 +107,12 @@
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
"language_code": "pt-PT"
},
"2-Regression/3-Linear/solution/notebook.ipynb": {
"original_hash": "6781223ffbe8cfdaa38d0200f08e1288",
"translation_date": "2026-04-26T18:37:20+00:00",
"source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
"language_code": "pt-PT"
},
"2-Regression/4-Logistic/README.md": {
"original_hash": "abf86d845c84330bce205a46b382ec88",
"translation_date": "2025-09-05T08:37:08+00:00",

102
translations/pt-PT/1-Introduction/4-techniques-of-ML/README.md
Unescape View File

@ -1,117 +1,117 @@
# Técnicas de Aprendizagem Automática
O processo de construir, utilizar e manter modelos de aprendizagem automática e os dados que eles utilizam é muito diferente de muitos outros fluxos de trabalho de desenvolvimento. Nesta lição, vamos desmistificar o processo e delinear as principais técnicas que precisa conhecer. Você irá:
O processo de construir, usar e manter modelos de aprendizagem automática e os dados que utilizam é um processo muito diferente de muitos outros fluxos de trabalho de desenvolvimento. Nesta lição, vamos desmistificar o processo e delinear as principais técnicas que precisa de conhecer. Você irá:
- Compreender os processos que sustentam a aprendizagem automática a um nível elevado.
- Explorar conceitos básicos como 'modelos', 'previsões' e 'dados de treino'.
- Explorar conceitos base como 'modelos', 'previsões' e 'dados de treino'.
## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ml/)
[![ML para iniciantes - Técnicas de Aprendizagem Automática](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML para iniciantes - Técnicas de Aprendizagem Automática")
[![ML for beginners - Techniques of Machine Learning](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML for beginners - Techniques of Machine Learning")
> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre esta lição.
> 🎥 Clique na imagem acima para um vídeo curto que percorre esta lição.
## Introdução
De forma geral, o processo de criação de processos de aprendizagem automática (ML) é composto por várias etapas:
A um nível elevado, a arte de criar processos de aprendizagem automática (ML) é composta por vários passos:
1. **Definir a pergunta**. A maioria dos processos de ML começa com uma pergunta que não pode ser respondida por um programa condicional simples ou um motor baseado em regras. Estas perguntas geralmente giram em torno de previsões baseadas numa coleção de dados.
2. **Recolher e preparar os dados**. Para responder à sua pergunta, precisa de dados. A qualidade e, por vezes, a quantidade dos seus dados determinarão o quão bem pode responder à pergunta inicial. Visualizar os dados é um aspeto importante desta fase. Esta fase também inclui dividir os dados em grupos de treino e teste para construir um modelo.
3. **Escolher um método de treino**. Dependendo da sua pergunta e da natureza dos seus dados, precisa de escolher como deseja treinar um modelo para refletir melhor os seus dados e fazer previsões precisas. Esta é a parte do processo de ML que requer conhecimentos específicos e, muitas vezes, uma quantidade considerável de experimentação.
4. **Treinar o modelo**. Usando os seus dados de treino, utilizará vários algoritmos para treinar um modelo que reconheça padrões nos dados. O modelo pode usar pesos internos que podem ser ajustados para privilegiar certas partes dos dados em detrimento de outras, a fim de construir um modelo melhor.
5. **Avaliar o modelo**. Utiliza dados nunca antes vistos (os seus dados de teste) do conjunto recolhido para verificar o desempenho do modelo.
6. **Ajustar parâmetros**. Com base no desempenho do modelo, pode refazer o processo utilizando diferentes parâmetros ou variáveis que controlam o comportamento dos algoritmos usados para treinar o modelo.
7. **Prever**. Use novos dados de entrada para testar a precisão do modelo.
1. **Decidir a questão**. A maioria dos processos ML começa por colocar uma questão que não pode ser respondida por um programa condicional simples ou motor baseado em regras. Estas questões muitas vezes giram em torno de previsões baseadas numa coleção de dados.
2. **Recolher e preparar dados**. Para conseguir responder à sua questão, precisa de dados. A qualidade e, por vezes, a quantidade dos seus dados determinarão o quão bem poderá responder à sua questão inicial. Visualizar os dados é um aspecto importante desta fase. Esta fase inclui também a divisão dos dados em grupos de treino e teste para construir um modelo.
3. **Escolher um método de treino**. Dependendo da sua questão e da natureza dos seus dados, precisa de escolher como deseja treinar um modelo para refletir melhor os seus dados e fazer previsões precisas sobre os mesmos. Esta é a parte do seu processo ML que requer especialização específica e, muitas vezes, um considerável número de experimentações.
4. **Treinar o modelo**. Usando os seus dados de treino, irá utilizar vários algoritmos para treinar um modelo a reconhecer padrões nos dados. O modelo pode aproveitar pesos internos que podem ser ajustados para privilegiar certas partes dos dados em relação a outras para construir um modelo melhor.
5. **Avaliar o modelo**. Usa dados nunca antes vistos (os seus dados de teste) do seu conjunto recolhido para ver como o modelo está a desempenhar-se.
6. **Ajuste de parâmetros**. Com base no desempenho do seu modelo, pode repetir o processo usando diferentes parâmetros, ou variáveis, que controlam o comportamento dos algoritmos usados para treinar o modelo.
7. **Prever**. Use novas entradas para testar a precisão do seu modelo.
## Que pergunta fazer
## Que questão colocar
Os computadores são particularmente habilidosos em descobrir padrões ocultos nos dados. Esta capacidade é muito útil para investigadores que têm perguntas sobre um determinado domínio que não podem ser facilmente respondidas criando um motor de regras condicionais. Dada uma tarefa atuarial, por exemplo, um cientista de dados pode ser capaz de construir regras manuais sobre a mortalidade de fumadores versus não fumadores.
Os computadores são particularmente habilidosos a descobrir padrões ocultos nos dados. Esta utilidade é muito útil para investigadores que têm questões sobre um dado domínio que não podem ser facilmente respondidas através da criação de um motor de regras condicional. Dada uma tarefa atuarial, por exemplo, um cientista de dados pode ser capaz de construir regras feitas à mão em torno da mortalidade de fumadores vs não fumadores.
Quando muitas outras variáveis são introduzidas na equação, no entanto, um modelo de ML pode revelar-se mais eficiente para prever taxas de mortalidade futuras com base no histórico de saúde passado. Um exemplo mais animador pode ser fazer previsões meteorológicas para o mês de abril numa determinada localização com base em dados que incluem latitude, longitude, alterações climáticas, proximidade ao oceano, padrões da corrente de jato, entre outros.
Quando muitas outras variáveis entram na equação, no entanto, um modelo ML pode revelar-se mais eficiente para prever taxas futuras de mortalidade com base no histórico de saúde passado. Um exemplo mais animador pode ser fazer previsões meteorológicas para o mês de abril numa dada localização com base em dados que incluem latitude, longitude, alterações climáticas, proximidade do oceano, padrões da corrente de jato e mais.
✅ Este [conjunto de slides](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) sobre modelos meteorológicos oferece uma perspetiva histórica sobre o uso de ML na análise do clima.
✅ Esta [apresentação de slides](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) sobre modelos meteorológicos oferece uma perspetiva histórica para o uso de ML na análise meteorológica.
## Tarefas pré-construção
Antes de começar a construir o seu modelo, há várias tarefas que precisa de completar. Para testar a sua pergunta e formar uma hipótese com base nas previsões de um modelo, precisa de identificar e configurar vários elementos.
Antes de começar a construir o seu modelo, há várias tarefas que precisa de completar. Para testar a sua questão e formar uma hipótese com base nas previsões de um modelo, precisa de identificar e configurar vários elementos.
### Dados
Para responder à sua pergunta com algum grau de certeza, precisa de uma boa quantidade de dados do tipo certo. Há duas coisas que precisa de fazer neste momento:
Para poder responder à sua questão com algum grau de certeza, precisa de uma boa quantidade de dados do tipo certo. Há duas coisas que precisa de fazer neste ponto:
- **Recolher dados**. Tendo em mente a lição anterior sobre justiça na análise de dados, recolha os seus dados com cuidado. Esteja atento às fontes desses dados, a quaisquer preconceitos inerentes que possam ter e documente a sua origem.
- **Preparar dados**. Há vários passos no processo de preparação de dados. Pode ser necessário reunir dados e normalizá-los se vierem de fontes diversas. Pode melhorar a qualidade e a quantidade dos dados através de vários métodos, como converter strings em números (como fazemos em [Clustering](../../5-Clustering/1-Visualize/README.md)). Também pode gerar novos dados com base nos originais (como fazemos em [Classificação](../../4-Classification/1-Introduction/README.md)). Pode limpar e editar os dados (como faremos antes da lição sobre [Aplicações Web](../../3-Web-App/README.md)). Por fim, pode ser necessário randomizar e embaralhar os dados, dependendo das suas técnicas de treino.
- **Recolher dados**. Tendo em conta a lição anterior sobre justiça na análise de dados, recolha os seus dados com cuidado. Esteja atento às fontes destes dados, a quaisquer preconceitos inerentes que possam ter, e documente a sua origem.
- **Preparar dados**. Existem vários passos no processo de preparação de dados. Pode precisar de consolidar dados e normalizá-los se vierem de fontes diversas. Pode melhorar a qualidade e quantidade dos dados através de vários métodos, como converter strings em números (como fazemos em [Clustering](../../5-Clustering/1-Visualize/README.md)). Pode também gerar novos dados, baseados nos originais (como fazemos em [Classificação](../../4-Classification/1-Introduction/README.md)). Pode limpar e editar os dados (como faremos antes da lição da [Aplicação Web](../../3-Web-App/README.md)). Finalmente, pode também precisar de os aleatorizar e baralhar, dependendo das suas técnicas de treino.
✅ Após recolher e processar os seus dados, reserve um momento para verificar se a sua estrutura permitirá abordar a pergunta pretendida. Pode ser que os dados não funcionem bem na sua tarefa, como descobrimos nas nossas lições de [Clustering](../../5-Clustering/1-Visualize/README.md)!
✅ Depois de recolher e processar os seus dados, tome um momento para ver se a sua forma permitirá que aborde a sua questão pretendida. Pode acontecer que os dados não desempenhem bem na tarefa dada, como descobrimos nas nossas lições de [Clustering](../../5-Clustering/1-Visualize/README.md)!
### Features e Target
### Características e Alvo
Uma [feature](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) é uma propriedade mensurável dos seus dados. Em muitos conjuntos de dados, é expressa como um cabeçalho de coluna, como 'data', 'tamanho' ou 'cor'. A sua variável de feature, geralmente representada como `X` no código, representa a variável de entrada que será usada para treinar o modelo.
Uma [característica](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) é uma propriedade mensurável dos seus dados. Em muitos conjuntos de dados é expressa como o título de uma coluna como 'data', 'tamanho' ou 'cor'. A sua variável característica, geralmente representada como `X` em código, representa a variável de entrada que será usada para treinar um modelo.
Um target é aquilo que está a tentar prever. O target, geralmente representado como `y` no código, representa a resposta à pergunta que está a tentar fazer aos seus dados: em dezembro, qual será a **cor** das abóboras mais baratas? Em São Francisco, que bairros terão o melhor **preço** imobiliário? Às vezes, o target também é referido como atributo de rótulo.
Um alvo é aquilo que está a tentar prever. O alvo, geralmente representado como `y` em código, representa a resposta à questão que está a tentar colocar aos seus dados: em dezembro, que **cor** as abóboras serão mais baratas? em São Francisco, que bairros terão o melhor **preço** imobiliário? Por vezes o alvo também é referido como um atributo de etiqueta.
### Selecionar a sua variável de feature
### Selecionar a sua variável característica
🎓 **Seleção de Features e Extração de Features** Como saber qual variável escolher ao construir um modelo? Provavelmente passará por um processo de seleção de features ou extração de features para escolher as variáveis certas para o modelo mais eficiente. No entanto, não são a mesma coisa: "A extração de features cria novas features a partir de funções das features originais, enquanto a seleção de features retorna um subconjunto das features." ([fonte](https://wikipedia.org/wiki/Feature_selection))
🎓 **Seleção de Características e Extração de Características** Como sabe qual variável escolher ao construir um modelo? Provavelmente passará por um processo de seleção de características ou extração de características para escolher as variáveis certas para o modelo mais performante. Contudo, não são a mesma coisa: "A extração de características cria novas características a partir de funções das características originais, enquanto a seleção de características retorna um subconjunto das características." ([fonte](https://wikipedia.org/wiki/Feature_selection))
### Visualizar os seus dados
### Visualize os seus dados
Um aspeto importante do conjunto de ferramentas de um cientista de dados é a capacidade de visualizar dados usando várias bibliotecas excelentes, como Seaborn ou MatPlotLib. Representar os seus dados visualmente pode permitir-lhe descobrir correlações ocultas que pode aproveitar. As suas visualizações também podem ajudá-lo a identificar preconceitos ou dados desequilibrados (como descobrimos em [Classificação](../../4-Classification/2-Classifiers-1/README.md)).
Um aspeto importante do kit de ferramentas do cientista de dados é o poder de visualizar dados usando várias excelentes bibliotecas como Seaborn ou MatPlotLib. Representar visualmente os seus dados pode permitir-lhe descobrir correlações ocultas que pode aproveitar. As suas visualizações também podem ajudar a descobrir enviesamentos ou dados desequilibrados (como descobrimos em [Classificação](../../4-Classification/2-Classifiers-1/README.md)).
### Dividir o seu conjunto de dados
### Divida o seu conjunto de dados
Antes de treinar, precisa de dividir o seu conjunto de dados em duas ou mais partes de tamanhos desiguais que ainda representem bem os dados.
Antes do treino, precisa de dividir o seu conjunto de dados em duas ou mais partes de tamanho desigual que ainda representem bem os dados.
- **Treino**. Esta parte do conjunto de dados é ajustada ao seu modelo para treiná-lo. Este conjunto constitui a maior parte do conjunto de dados original.
- **Teste**. Um conjunto de teste é um grupo independente de dados, muitas vezes retirado dos dados originais, que utiliza para confirmar o desempenho do modelo construído.
- **Validação**. Um conjunto de validação é um grupo independente menor de exemplos que utiliza para ajustar os hiperparâmetros ou a arquitetura do modelo, a fim de melhorá-lo. Dependendo do tamanho dos seus dados e da pergunta que está a fazer, pode não ser necessário construir este terceiro conjunto (como notamos em [Previsão de Séries Temporais](../../7-TimeSeries/1-Introduction/README.md)).
- **Treino**. Esta parte do conjunto de dados é ajustada ao seu modelo para o treinar. Este conjunto constitui a maioria do conjunto de dados original.
- **Teste**. Um conjunto de dados de teste é um grupo independente de dados, muitas vezes recolhidos do conjunto original, que usa para confirmar o desempenho do modelo construído.
- **Validação**. Um conjunto de validação é um grupo independente menor de exemplos que usa para ajustar os hiperparâmetros, ou arquitetura, do modelo para melhorar o modelo. Dependendo do tamanho dos seus dados e da questão que está a colocar, pode não precisar de construir este terceiro conjunto (como notamos em [Previsão de Séries Temporais](../../7-TimeSeries/1-Introduction/README.md)).
## Construir um modelo
## Construção de um modelo
Usando os seus dados de treino, o seu objetivo é construir um modelo, ou uma representação estatística dos seus dados, utilizando vários algoritmos para **treiná-lo**. Treinar um modelo expõe-no aos dados e permite-lhe fazer suposições sobre padrões percebidos que descobre, valida e aceita ou rejeita.
Usando os seus dados de treino, o seu objetivo é construir um modelo, ou uma representação estatística dos seus dados, usando vários algoritmos para **treiná-lo**. Treinar um modelo expõe-no a dados e permite que faça suposições sobre padrões percebidos que descobre, valida e aceita ou rejeita.
### Decidir sobre um método de treino
### Decida um método de treino
Dependendo da sua pergunta e da natureza dos seus dados, escolherá um método para treiná-lo. Explorando a [documentação do Scikit-learn](https://scikit-learn.org/stable/user_guide.html) - que usamos neste curso - pode descobrir várias formas de treinar um modelo. Dependendo da sua experiência, pode ter de experimentar vários métodos diferentes para construir o melhor modelo. É provável que passe por um processo em que os cientistas de dados avaliam o desempenho de um modelo alimentando-o com dados não vistos, verificando a precisão, preconceitos e outros problemas que degradam a qualidade, e selecionando o método de treino mais apropriado para a tarefa em questão.
Dependendo da sua questão e da natureza dos seus dados, irá escolher um método para os treinar. Percorrendo a [documentação do Scikit-learn](https://scikit-learn.org/stable/user_guide.html) - que usamos neste curso - pode explorar várias formas de treinar um modelo. Dependendo da sua experiência, pode ter de tentar vários métodos diferentes para construir o melhor modelo. Provavelmente passará por um processo onde os cientistas de dados avaliam o desempenho de um modelo ao alimentá-lo com dados nunca vistos, verificando a precisão, enviesamento e outras questões que degradam a qualidade, e selecionando o método de treino mais apropriado para a tarefa em questão.
### Treinar um modelo
Com os seus dados de treino, está pronto para 'ajustá-los' para criar um modelo. Notará que em muitas bibliotecas de ML encontrará o código 'model.fit' - é neste momento que envia a sua variável de feature como um array de valores (geralmente 'X') e uma variável target (geralmente 'y').
Armado com os seus dados de treino, está pronto para 'ajustar' o modelo. Vai notar que em muitas bibliotecas ML encontra o código 'model.fit' - é neste momento que envia a sua variável característica como um array de valores (normalmente 'X') e uma variável alvo (normalmente 'y').
### Avaliar o modelo
Uma vez concluído o processo de treino (pode levar muitas iterações, ou 'épocas', para treinar um modelo grande), poderá avaliar a qualidade do modelo utilizando dados de teste para medir o seu desempenho. Estes dados são um subconjunto dos dados originais que o modelo ainda não analisou. Pode imprimir uma tabela de métricas sobre a qualidade do modelo.
Uma vez concluído o processo de treino (pode levar muitas iterações, ou 'épocas', para treinar um modelo grande), poderá avaliar a qualidade do modelo usando dados de teste para medir o seu desempenho. Estes dados são um subconjunto dos dados originais que o modelo não analisou previamente. Pode imprimir uma tabela de métricas sobre a qualidade do seu modelo.
🎓 **Ajuste do modelo**
No contexto da aprendizagem automática, o ajuste do modelo refere-se à precisão da função subjacente do modelo enquanto tenta analisar dados com os quais não está familiarizado.
No contexto da aprendizagem automática, ajuste do modelo refere-se à precisão da função subjacente do modelo enquanto tenta analisar dados com os quais não está familiarizado.
🎓 **Subajuste** e **sobreajuste** são problemas comuns que degradam a qualidade do modelo, pois o modelo ajusta-se ou não suficientemente bem ou bem demais. Isso faz com que o modelo faça previsões muito alinhadas ou pouco alinhadas com os seus dados de treino. Um modelo sobreajustado prevê os dados de treino muito bem porque aprendeu os detalhes e o ruído dos dados em excesso. Um modelo subajustado não é preciso, pois não consegue analisar com precisão nem os dados de treino nem os dados que ainda não 'viu'.
🎓 **Subajuste** e **sobreajuste** são problemas comuns que degradam a qualidade do modelo, pois o modelo ajusta-se demasiado pouco ou demasiado. Isto faz com que o modelo faça previsões alinhadas demasiado estreitamente ou demasiado frouxamente com os dados de treino. Um modelo sobreajustado prevê os dados de treino muito bem porque aprendeu os detalhes e o ruído dos dados demasiado bem. Um modelo subajustado não é preciso pois não consegue analisar com precisão nem os seus dados de treino nem dados que ainda não 'viu'.
![modelo sobreajustado](../../../../1-Introduction/4-techniques-of-ML/images/overfitting.png)
> Infográfico por [Jen Looper](https://twitter.com/jenlooper)
![overfitting model](../../../../translated_images/pt-PT/overfitting.1c132d92bfd93cb6.webp)
> Infografia por [Jen Looper](https://twitter.com/jenlooper)
## Ajuste de parâmetros
Depois de concluir o treino inicial, observe a qualidade do modelo e considere melhorá-lo ajustando os seus 'hiperparâmetros'. Leia mais sobre o processo [na documentação](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
Uma vez concluído o treino inicial, observe a qualidade do modelo e considere melhorá-lo ajustando os seus 'hiperparâmetros'. Leia mais sobre o processo [na documentação](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
## Previsão
Este é o momento em que pode usar dados completamente novos para testar a precisão do seu modelo. Num cenário de ML 'aplicado', onde está a construir ativos web para usar o modelo em produção, este processo pode envolver a recolha de input do utilizador (um clique num botão, por exemplo) para definir uma variável e enviá-la ao modelo para inferência ou avaliação.
Este é o momento em que pode usar dados completamente novos para testar a precisão do seu modelo. Num cenário ML 'aplicado', onde está a construir recursos web para usar o modelo em produção, este processo pode envolver recolher a entrada do utilizador (um clique de botão, por exemplo) para definir uma variável e enviá-la para o modelo para inferência, ou avaliação.
Nestes módulos, descobrirá como usar estes passos para preparar, construir, testar, avaliar e prever - todos os gestos de um cientista de dados e mais, à medida que progride na sua jornada para se tornar um engenheiro de ML 'full stack'.
Nestes módulos, irá descobrir como usar estes passos para preparar, construir, testar, avaliar e prever – todos os gestos de um cientista de dados e mais, enquanto avança na sua jornada para se tornar um engenheiro ML 'full stack'.
---
## 🚀Desafio
Desenhe um fluxograma refletindo os passos de um praticante de ML. Onde se encontra neste momento no processo? Onde prevê que encontrará dificuldades? O que lhe parece fácil?
Desenhe um diagrama de fluxos refletindo os passos de um praticante de ML. Onde é que se vê agora no processo? Onde prevê que terá dificuldades? O que lhe parece fácil?
## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ml/)
## Revisão e Estudo Individual
## Revisão e Estudo Autónomo
Pesquise online entrevistas com cientistas de dados que discutam o seu trabalho diário. Aqui está [uma](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
Procure online entrevistas com cientistas de dados que discutam o seu trabalho diário. Aqui está [uma](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
## Tarefa
@ -119,5 +119,7 @@ Pesquise online entrevistas com cientistas de dados que discutam o seu trabalho
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Aviso Legal**:
Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte oficial. Para informações críticas, recomenda-se uma tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes do uso desta tradução.
Este documento foi traduzido utilizando o serviço de tradução automática [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor tenha em conta que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas resultantes do uso desta tradução.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

259
translations/pt-PT/2-Regression/3-Linear/README.md
Unescape View File

@ -1,135 +1,136 @@
# Construir um modelo de regressão usando Scikit-learn: regressão de quatro formas
# Construa um modelo de regressão usando Scikit-learn: regressão de quatro formas
## Nota para iniciantes
A regressão linear é usada quando queremos prever um **valor numérico** (por exemplo, preço da casa, temperatura ou vendas). Funciona encontrando uma linha reta que melhor representa a relação entre as características de entrada e o resultado.
A regressão linear é usada quando queremos prever um **valor numérico** (por exemplo, preço da casa, temperatura ou vendas).
Funciona encontrando uma linha reta que melhor representa a relação entre as características de entrada e a saída.
Nesta lição, focamos em entender o conceito antes de explorar técnicas de regressão mais avançadas.
![Infográfico de regressão linear vs polinomial](../../../../translated_images/pt-PT/linear-polynomial.5523c7cb6576ccab.webp)
> Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Questionário pré-aula](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
> ### [Esta lição está disponível em R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introdução
Até agora explorou o que é regressão com dados de exemplo recolhidos do conjunto de dados de preços de abóboras que iremos usar ao longo desta lição. Também visualizou esses dados usando Matplotlib.
Até agora explorou o que é regressão com dados de amostra recolhidos do conjunto de dados de preços de abóboras que iremos usar ao longo desta lição. Também o visualizou usando Matplotlib.
Agora está pronto para mergulhar mais fundo na regressão para ML. Enquanto a visualização permite dar sentido aos dados, o verdadeiro poder do Machine Learning vem do _treino de modelos_. Os modelos são treinados em dados históricos para captar automaticamente as dependências dos dados, e permitem prever resultados para novos dados, que o modelo ainda não viu.
Agora está pronto para aprofundar a regressão para ML. Enquanto a visualização lhe permite compreender os dados, o verdadeiro poder do Machine Learning vem do _treino de modelos_. Os modelos são treinados com dados históricos para capturar automaticamente dependências dos dados, e permitem prever resultados para novos dados, que o modelo ainda não viu.
Nesta lição, irá aprender mais sobre dois tipos de regressão: _regressão linear básica_ e _regressão polinomial_, juntamente com alguma da matemática subjacente a estas técnicas. Esses modelos permitirão prever preços de abóboras dependendo de diferentes dados de entrada.
Nesta lição, aprenderá mais sobre dois tipos de regressão: _regressão linear básica_ e _regressão polinomial_, juntamente com alguma da matemática subjacente a estas técnicas. Esses modelos permitir-nos-ão prever os preços das abóboras dependendo de diferentes dados de entrada.
[![ML para iniciantes - Compreender Regressão Linear](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML para iniciantes - Compreender Regressão Linear")
[![ML para iniciantes - Compreendendo a Regressão Linear](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML para iniciantes - Compreendendo a Regressão Linear")
> 🎥 Clique na imagem acima para uma curta visão geral em vídeo da regressão linear.
> 🎥 Clique na imagem acima para um breve vídeo de apresentação da regressão linear.
> Ao longo deste currículo, assumimos um conhecimento matemático mínimo, buscando tornar acessível para estudantes de outras áreas, por isso esteja atento a notas, 🧮 destaques, diagramas e outras ferramentas de aprendizagem para ajudar na compreensão.
> Ao longo deste currículo, assumimos conhecimentos mínimos de matemática, e procuramos torná-la acessível para estudantes provenientes de outras áreas, por isso repare nas notas, 🧮 chamadas, diagramas e outras ferramentas de aprendizagem para ajudar a compreensão.
### Pré-requisitos
Deve estar agora familiarizado com a estrutura dos dados de abóboras que estamos a examinar. Pode encontrá-los pré-carregados e pré-limpados no ficheiro _notebook.ipynb_ desta lição. No ficheiro, o preço da abóbora está apresentado por alqueire num novo data frame. Certifique-se de que pode executar estes notebooks em núcleos (kernels) no Visual Studio Code.
Deverá estar familiarizado agora com a estrutura dos dados da abóbora que estamos a examinar. Pode encontrá-los pré-carregados e pré-limpados no ficheiro _notebook.ipynb_ desta lição. No ficheiro, o preço da abóbora é mostrado por alqueire num novo dataframe. Assegure-se de que consegue executar estes cadernos no kernel do Visual Studio Code.
### Preparação
Como lembrete, está a carregar estes dados para fazer perguntas a eles.
Como lembrete, está a carregar estes dados para lhes fazer perguntas.
- Qual é a melhor altura para comprar abóboras?
- Que preço posso esperar por uma caixa de pequenas abóboras?
- Devo comprá-las em cestos de meio alqueire ou numa caixa de 1 1/9 alqueire?
Vamos continuar a aprofundar estes dados.
- Qual é o melhor momento para comprar abóboras?
- Que preço posso esperar por um pacote de mini abóboras?
- Devo comprá-las em cestos de meio alqueire ou em caixas de 1 1/9 alqueire?
Vamos continuar a explorar estes dados.
Na lição anterior, criou um data frame do Pandas e preencheu-o com parte do conjunto de dados original, padronizando os preços por alqueire. Ao fazer isso, no entanto, conseguiu recolher cerca de 400 pontos de dados e apenas para os meses de outono.
Na lição anterior, criou um dataframe Pandas e povoou-o com parte do conjunto de dados original, padronizando o preço por alqueire. Ao fazer isso, no entanto, conseguiu apenas cerca de 400 pontos de dados e apenas para os meses de outono.
Veja os dados que pré-carregámos no notebook que acompanha esta lição. Os dados vêm pré-carregados e um gráfico de dispersão inicial foi traçado para mostrar os dados do mês. Talvez possamos obter um pouco mais de detalhe sobre a natureza dos dados fazendo uma limpeza maior.
Veja os dados que pré-carregámos no caderno que acompanha esta lição. Os dados estão pré-carregados e foi traçado um gráfico de dispersão inicial para mostrar os dados do mês. Talvez possamos obter um pouco mais de detalhe sobre a natureza dos dados limpando-os mais.
## Uma linha de regressão linear
Como aprendeu na Lição 1, o objetivo de um exercício de regressão linear é conseguir traçar uma linha para:
Como aprendeu na Lição 1, o objetivo de um exercício de regressão linear é poder traçar uma linha para:
- **Mostrar relações entre variáveis**. Mostrar a relação entre variáveis
- **Fazer previsões**. Fazer previsões precisas sobre onde um novo ponto de dados cairia em relação a essa linha.
- **Mostrar relações entre variáveis**. Mostrar a relação entre variáveis
- **Fazer previsões**. Fazer previsões precisas sobre onde um novo ponto de dados cairia em relação a essa linha.
É típico da **Regressão pelo Método dos Mínimos Quadrados** desenhar este tipo de linha. O termo "Mínimos Quadrados" refere-se ao processo de minimizar o erro total no nosso modelo. Para cada ponto de dados, medimos a distância vertical (chamada resíduo) entre o ponto real e a nossa linha de regressão.
É típico da **Regressão de Mínimos Quadrados** desenhar este tipo de linha. O termo "Mínimos Quadrados" refere-se ao processo de minimizar o erro total no nosso modelo. Para cada ponto de dados, medimos a distância vertical (chamada resíduo) entre o ponto real e a nossa linha de regressão.
Elevamos ao quadrado essas distâncias por duas razões principais:
Elevamos essas distâncias ao quadrado por duas razões principais:
1. **Magnitude sobre direção:** Queremos tratar um erro de -5 da mesma forma que um erro de +5. Elevar ao quadrado torna todos os valores positivos.
1. **Magnitude em vez de Direção:** Queremos tratar um erro de -5 da mesma forma que um erro de +5. Elevar ao quadrado torna todos os valores positivos.
2. **Penalização de outliers:** Elevar ao quadrado dá mais peso a erros maiores, obrigando a linha a ficar mais próxima dos pontos distantes.
2. **Penalizar Outliers:** Elevar ao quadrado dá mais peso aos erros maiores, forçando a linha a manter-se mais perto dos pontos que estão longe.
Depois somamos todos esses valores ao quadrado. O nosso objetivo é encontrar a linha específica onde essa soma final é a menor possível—daí o nome "Mínimos Quadrados".
Depois somamos todos esses valores ao quadrado. O nosso objetivo é encontrar a linha específica onde esta soma final é a menor (o menor valor possível)—daí o nome "Mínimos Quadrados".
> **🧮 Mostre-me a matemática**
>
> Esta linha, chamada de _linha de melhor ajuste_, pode ser expressa por [uma equação](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> **🧮 Mostre-me a matemática**
>
> Esta linha, chamada de _linha de melhor ajuste_, pode ser expressa por [uma equação](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` é a 'variável explicativa'. `Y` é a 'variável dependente'. O declive da linha é `b` e `a` é o intercepto em y, que se refere ao valor de `Y` quando `X = 0`.
>
>![calcular o declive](../../../../translated_images/pt-PT/slope.f3c9d5910ddbfcf9.webp)
>
> Primeiro, calcule o declive `b`. Infográfico por [Jen Looper](https://twitter.com/jenlooper)
>
> Por outras palavras, e referindo-nos à pergunta original dos dados das abóboras: "prever o preço por alqueire da abóbora por mês", `X` referir-se-ia ao preço e `Y` ao mês da venda.
>
>![completar a equação](../../../../translated_images/pt-PT/calculation.a209813050a1ddb1.webp)
>
> Calcule o valor de Y. Se está a pagar cerca de 4 dólares, deve ser abril! Infográfico por [Jen Looper](https://twitter.com/jenlooper)
>
> A matemática que calcula a linha deve demonstrar o declive da linha, que também depende do intercepto, ou de onde `Y` está situado quando `X = 0`.
>
> Pode observar o método de cálculo destes valores no site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Visite também [esta calculadora de mínimos quadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver como os valores numéricos impactam a linha.
>
> `X` é a 'variável explicativa'. `Y` é a 'variável dependente'. A inclinação da linha é `b` e `a` é o intercepto-y, que refere o valor de `Y` quando `X = 0`.
>
>![calcular a inclinação](../../../../translated_images/pt-PT/slope.f3c9d5910ddbfcf9.webp)
>
> Primeiro, calcule a inclinação `b`. Infográfico por [Jen Looper](https://twitter.com/jenlooper)
>
> Por outras palavras, e referindo à questão original dos nossos dados da abóbora: "prever o preço de uma abóbora por alqueire por mês", `X` referir-se-ia ao preço e `Y` ao mês da venda.
>
>![completar a equação](../../../../translated_images/pt-PT/calculation.a209813050a1ddb1.webp)
>
> Calcule o valor de Y. Se está a pagar cerca de 4$, deve ser abril! Infográfico por [Jen Looper](https://twitter.com/jenlooper)
>
> A matemática que calcula a linha deve demonstrar a inclinação da linha, que também depende do intercepto, ou onde `Y` está situado quando `X = 0`.
>
> Pode observar o método de cálculo destes valores no site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Visite também [este Calculador de mínimos quadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver como os valores dos números impactam a linha.
## Correlação
Mais um termo a compreender é o **Coeficiente de Correlação** entre as variáveis X e Y dadas. Usando um gráfico de dispersão, pode visualizar rapidamente este coeficiente. Um gráfico com pontos de dados dispersos numa linha limpa tem alta correlação, mas um gráfico com pontos dispersos por todo o lado entre X e Y tem baixa correlação.
Mais um termo a compreender é o **Coeficiente de Correlação** entre as variáveis X e Y dadas. Usando um gráfico de dispersão, pode rapidamente visualizar este coeficiente. Um gráfico com pontos de dados dispersos numa linha arrumada tem alta correlação, mas um gráfico com pontos dispersos por toda a parte entre X e Y tem baixa correlação.
Um bom modelo de regressão linear será aquele que tem um Coeficiente de Correlação alto (mais próximo de 1 do que de 0) usando o método dos mínimos quadrados com uma linha de regressão.
Um bom modelo de regressão linear será aquele que tem um alto (mais próximo de 1 do que de 0) Coeficiente de Correlação usando o método de Regressão de Mínimos Quadrados com uma linha de regressão.
✅ Execute o notebook que acompanha esta lição e observe o gráfico de dispersão Mês versus Preço. Os dados que associam Mês a Preço para vendas de abóboras parecem ter alta ou baixa correlação, segundo a sua interpretação visual do gráfico de dispersão? Isso muda se usar uma medida mais pormenorizada em vez de `Mês`, por exemplo *dia do ano* (isto é, número de dias desde o início do ano)?
✅ Execute o caderno que acompanha esta lição e observe o gráfico de dispersão Mês vs Preço. Os dados que associam Mês a Preço para vendas de abóboras parecem ter alta ou baixa correlação, de acordo com a sua interpretação visual do gráfico de dispersão? Isso muda se usar uma medida mais detalhada em vez de `Mês`, por exemplo, *dia do ano* (isto é, número de dias desde o início do ano)?
No código abaixo, vamos assumir que limpámos os dados e obtivemos um data frame chamado `new_pumpkins`, semelhante ao seguinte:
No código abaixo, assumiremos que limpámos os dados e obtivemos um dataframe chamado `new_pumpkins`, semelhante ao seguinte:
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
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
> O código para limpar os dados está disponível em [`notebook.ipynb`](notebook.ipynb). Realizámos os mesmos passos de limpeza da lição anterior e calculámos a coluna `DayOfYear` usando a seguinte expressão:
> O código para limpar os dados está disponível em [`notebook.ipynb`](notebook.ipynb). Realizámos os mesmos passos de limpeza que na lição anterior, e calculámos a coluna `DayOfYear` usando a seguinte expressão:
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
Agora que compreende a matemática por trás da regressão linear, vamos criar um modelo de regressão para ver se conseguimos prever que pacote de abóboras terá os melhores preços. Alguém a comprar abóboras para uma decoração de abóboras para o feriado pode querer esta informação para optimizar as suas compras de pacotes de abóboras para a decoração.
Agora que entende a matemática por trás da regressão linear, vamos criar um modelo de regressão para ver se conseguimos prever qual o pacote de abóboras que terá os melhores preços. Alguém a comprar abóboras para um campo de abóboras de férias poderá querer esta informação para otimizar as suas compras de pacotes para o campo.
## Procurar correlação
## Procurando Correlação
[![ML para iniciantes - Procurar correlação: a chave para regressão linear](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML para iniciantes - Procurar correlação: a chave para regressão linear")
[![ML para iniciantes - Procurando Correlação: A Chave para Regressão Linear](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML para iniciantes - Procurando Correlação: A Chave para Regressão Linear")
> 🎥 Clique na imagem acima para uma breve visão geral em vídeo da correlação.
> 🎥 Clique na imagem acima para um breve vídeo de apresentação sobre correlação.
Na lição anterior provavelmente viu que o preço médio para diferentes meses se parece com isto:
Na lição anterior provavelmente viu que o preço médio para diferentes meses é assim:
<img alt="Preço médio por mês" src="../../../../translated_images/pt-PT/barchart.a833ea9194346d76.webp" width="50%"/>
Isto sugere que deve haver alguma correlação, e podemos tentar treinar um modelo de regressão linear para prever a relação entre `Month` e `Price`, ou entre `DayOfYear` e `Price`. Aqui está o gráfico de dispersão que mostra esta última relação:
Isto sugere que deve haver alguma correlação, e podemos tentar treinar um modelo de regressão linear para prever a relação entre `Month` e `Price`, ou entre `DayOfYear` e `Price`. Aqui está o gráfico de dispersão que mostra a última relação:
<img alt="Gráfico de dispersão do preço vs dia do ano" src="../../../../translated_images/pt-PT/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
<img alt="Gráfico de dispersão do Preço vs. Dia do Ano" src="../../../../translated_images/pt-PT/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
Vamos ver se existe correlação usando a função `corr`:
Vamos ver se há correlação usando a função `corr`:
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
Parece que a correlação é bastante pequena, -0.15 pelo `Month` e -0.17 pelo `DayOfMonth`, mas pode haver outra relação importante. Parece que há diferentes agrupamentos de preços correspondendo a diferentes variedades de abóbora. Para confirmar esta hipótese, vamos representar cada categoria de abóboras com uma cor diferente. Ao passar o parâmetro `ax` para a função de plotagem `scatter` podemos plotar todos os pontos no mesmo gráfico:
Parece que a correlação é bastante pequena, -0.15 por `Month` e -0.17 por `DayOfYear`, mas pode haver outra relação importante. Parece que existem diferentes grupos de preços correspondentes a diferentes variedades de abóboras. Para confirmar esta hipótese, vamos traçar cada categoria de abóbora usando uma cor diferente. Passando um parâmetro `ax` para a função de plotagem `scatter` podemos traçar todos os pontos no mesmo gráfico:
```python
ax=None
@ -139,42 +140,42 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
<img alt="Gráfico de dispersão do preço vs dia do ano com cores" src="../../../../translated_images/pt-PT/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
<img alt="Gráfico de dispersão do Preço vs. Dia do Ano" src="../../../../translated_images/pt-PT/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
A nossa investigação sugere que a variedade tem mais efeito no preço global do que a data real de venda. Podemos ver isso num gráfico de barras:
A nossa investigação sugere que a variedade tem mais efeito no preço global do que a data de venda. Podemos ver isto com um gráfico de barras:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
<img alt="Gráfico de barras do preço por variedade" src="../../../../translated_images/pt-PT/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
<img alt="Gráfico de barras do preço vs variedade" src="../../../../translated_images/pt-PT/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
Vamos focar-nos para já apenas numa variedade de abóboras, a do tipo 'pie', e ver que efeito a data tem no preço:
Vamos focar por ora numa só variedade de abóbora, o tipo 'pie type', e ver que efeito a data tem no preço:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
<img alt="Gráfico de dispersão do preço vs dia do ano para abóboras 'pie'" src="../../../../translated_images/pt-PT/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
<img alt="Gráfico de dispersão do Preço vs. Dia do Ano" src="../../../../translated_images/pt-PT/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
Se agora calcularmos a correlação entre `Price` e `DayOfYear` usando a função `corr`, obteremos algo como `-0.27` - o que significa que treinar um modelo preditivo faz sentido.
Se agora calcularmos a correlação entre `Price` e `DayOfYear` usando a função `corr`, obteremos algo como `-0.27` - o que significa que faz sentido treinar um modelo preditivo.
> Antes de treinar um modelo de regressão linear, é importante garantir que os nossos dados estão limpos. A regressão linear não funciona bem com valores em falta, portanto faz sentido livrar-se de todas as células vazias:
> Antes de treinar um modelo de regressão linear, é importante garantir que os dados estão limpos. A regressão linear não funciona bem com valores em falta, por isso faz sentido eliminar todas as células vazias:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Outra abordagem seria preencher esses valores vazios com a média da coluna correspondente.
Outra abordagem seria preencher esses valores vazios com valores médios da coluna correspondente.
## Regressão Linear Simples
[![ML para iniciantes - Regressão Linear e Polinomial usando Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML para iniciantes - Regressão Linear e Polinomial usando Scikit-learn")
> 🎥 Clique na imagem acima para uma breve visão geral em vídeo da regressão linear e polinomial.
> 🎥 Clique na imagem acima para um breve vídeo de apresentação sobre regressão linear e polinomial.
Para treinar o nosso modelo de Regressão Linear, vamos usar a biblioteca **Scikit-learn**.
Para treinar o nosso modelo de Regressão Linear, iremos usar a biblioteca **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
@ -189,9 +190,9 @@ X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Repare que tivemos de fazer um `reshape` nos dados de entrada para que o pacote de Regressão Linear os compreendesse corretamente. A Regressão Linear espera uma matriz 2D como entrada, onde cada linha da matriz corresponde a um vetor de características de entrada. No nosso caso, como temos apenas uma entrada, precisamos de uma matriz com forma N&times;1, onde N é o tamanho do conjunto de dados.
> Note que tivemos de realizar um `reshape` nos dados de entrada para que o pacote de Regressão Linear os entenda corretamente. Regressão Linear espera um array 2D como entrada, em que cada linha do array corresponde a um vetor de características de entrada. No nosso caso, como temos apenas uma entrada - precisamos de um array com formato N&times;1, onde N é o tamanho do conjunto de dados.
Depois, é necessário dividir os dados nos conjuntos de treino e de teste, para que possamos validar o modelo após o treino:
Depois, precisamos dividir os dados em conjuntos de treino e teste, para podermos validar o nosso modelo após o treino:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
@ -204,9 +205,9 @@ lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
O objeto `LinearRegression` após o treino (`fit`) contém todos os coeficientes da regressão, que podem ser acedidos através da propriedade `.coef_`. No nosso caso, há apenas um coeficiente, que deverá ser cerca de `-0.017`. Isto significa que os preços parecem diminuir um pouco com o tempo, mas não demasiado, cerca de 2 cêntimos por dia. Também podemos aceder ao ponto de interseção da regressão com o eixo Y usando `lin_reg.intercept_` - será cerca de `21` no nosso caso, indicando o preço no início do ano.
O objeto `LinearRegression` depois de ajustado (`fit`) contém todos os coeficientes da regressão, que podem ser acedidos usando a propriedade `.coef_`. No nosso caso, há apenas um coeficiente, que deverá estar por volta de `-0.017`. Isso significa que os preços parecem baixar um pouco com o tempo, mas não muito, cerca de 2 cêntimos por dia. Podemos também aceder ao ponto de interseção da regressão com o eixo Y usando `lin_reg.intercept_` - será cerca de `21` no nosso caso, indicando o preço no início do ano.
Para ver quão preciso é o nosso modelo, podemos prever preços num conjunto de dados de teste, e depois medir quão próximas estão as nossas previsões dos valores esperados. Isto pode ser feito usando a métrica root mean square error (RMSE), que é a raiz da média de todas as diferenças quadráticas entre o valor esperado e o previsto.
Para ver quão preciso é o nosso modelo, podemos prever preços num conjunto de dados de teste, e depois medir quão próximas as nossas previsões estão dos valores esperados. Isto pode ser feito usando a métrica de erro quadrático médio da raiz (RMSE), que é a raiz da média de todas as diferenças ao quadrado entre o valor esperado e o previsto.
```python
pred = lin_reg.predict(X_test)
@ -215,15 +216,15 @@ rmse = np.sqrt(mean_squared_error(y_test,pred))
print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
```
O nosso erro parece ser cerca de 2 pontos, o que é ~17%. Nada muito bom. Outro indicador da qualidade do modelo é o **coeficiente de determinação**, que pode ser obtido assim:
O nosso erro parece ser cerca de 2 pontos, o que é ~17%. Não muito bom. Outro indicador da qualidade do modelo é o **coeficiente de determinação**, que pode ser obtido assim:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Se o valor for 0, significa que o modelo não tem em conta os dados de entrada, e atua como o *pior preditor linear*, que é simplesmente o valor médio do resultado. O valor 1 significa que podemos prever perfeitamente todas as saídas esperadas. No nosso caso, o coeficiente é cerca de 0.06, o que é bastante baixo.
Se o valor for 0, significa que o modelo não tem em conta os dados de entrada, e funciona como o *pior preditor linear*, que é simplesmente um valor médio do resultado. O valor 1 significa que podemos prever perfeitamente todas as saídas esperadas. No nosso caso, o coeficiente está por volta de 0.06, o que é bastante baixo.
Também podemos desenhar os dados de teste juntamente com a linha de regressão para vermos melhor como funciona a regressão no nosso caso:
Podemos também traçar os dados de teste juntamente com a linha de regressão para vermos melhor como a regressão funciona no nosso caso:
```python
plt.scatter(X_test,y_test)
@ -234,17 +235,17 @@ plt.plot(X_test,pred)
## Regressão Polinomial
Outro tipo de Regressão Linear é a Regressão Polinomial. Embora por vezes haja uma relação linear entre variáveis - quanto maior a abóbora em volume, maior o preço - por vezes essas relações não podem ser representadas por um plano ou linha reta.
Outro tipo de Regressão Linear é a Regressão Polinomial. Embora por vezes haja uma relação linear entre variáveis - quanto maior a abóbora em volume, maior o preço - por vezes essas relações não podem ser representadas como um plano ou linha reta.
✅ Aqui estão [mais alguns exemplos](https://online.stat.psu.edu/stat501/lesson/9/9.8) de dados que poderiam usar Regressão Polinomial
Veja outra vez a relação entre Data e Preço. Este gráfico de dispersão parece que deve necessariamente ser analisado por uma linha reta? Será que os preços não podem flutuar? Neste caso, pode tentar a regressão polinomial.
Dê outra vista de olhos à relação entre Data e Preço. Este gráfico de dispersão parece necessariamente deva ser analisado por uma linha reta? Não podem os preços oscilar? Neste caso, pode tentar regressão polinomial.
✅ Os polinómios são expressões matemáticas que podem consistir em uma ou mais variáveis e coeficientes
✅ Polinómios são expressões matemáticas que podem consistir de uma ou mais variáveis e coeficientes
A regressão polinomial cria uma linha curva para melhor ajustar dados não lineares. No nosso caso, se incluirmos uma variável ao quadrado `DayOfYear` nos dados de entrada, deveremos ser capazes de ajustar os nossos dados com uma curva parabólica, que terá um mínimo em certo ponto dentro do ano.
A regressão polinomial cria uma linha curva para melhor ajustar os dados não lineares. No nosso caso, se incluirmos uma variável ao quadrado `DayOfYear` nos dados de entrada, deveremos conseguir ajustar os nossos dados com uma curva parabólica, que terá um mínimo em certo ponto durante o ano.
O Scikit-learn inclui uma API útil de [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes passos do processamento de dados. Um **pipeline** é uma cadeia de **estimadores**. No nosso caso, vamos criar um pipeline que primeiro adiciona características polinomiais ao nosso modelo, e depois treina a regressão:
O Scikit-learn inclui uma útil [API para pipelines](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) para combinar diferentes passos do processamento de dados. Um **pipeline** é uma cadeia de **estimadores**. No nosso caso, vamos criar um pipeline que primeiro adiciona características polinomiais ao nosso modelo, e depois treina a regressão:
```python
from sklearn.preprocessing import PolynomialFeatures
@ -255,36 +256,58 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
Usar `PolynomialFeatures(2)` significa que vamos incluir todos os polinómios de segundo grau a partir dos dados de entrada. No nosso caso, isso significará apenas `DayOfYear`<sup>2</sup>, mas dado duas variáveis de entrada X e Y, isso adicionaria X<sup>2</sup>, XY e Y<sup>2</sup>. Também podemos usar polinómios de grau superior se quisermos.
Usar `PolynomialFeatures(2)` significa que iremos incluir todos os polinómios de segundo grau dos dados de entrada. No nosso caso, isso significa apenas `DayOfYear`<sup>2</sup>, mas dado duas variáveis de entrada X e Y, isto adicionaria X<sup>2</sup>, XY e Y<sup>2</sup>. Podemos também usar polinómios de grau superior se quisermos.
Os pipelines podem ser usados da mesma forma que o objeto original `LinearRegression`, ou seja, podemos `fit` o pipeline e depois usar `predict` para obter os resultados da previsão. Aqui está o gráfico mostrando os dados de teste e a curva de aproximação:
Pipelines podem ser usados da mesma forma que o objeto original `LinearRegression`, ou seja, podemos `fit` o pipeline, e depois usar `predict` para obter os resultados da previsão:
```python
pred = pipeline.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}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
Para traçar a curva de aproximação suave, usamos `np.linspace` para criar um intervalo uniforme de valores de entrada, em vez de traçar diretamente sobre os dados de teste desordenados (o que produziria uma linha em zig-zag):
```python
X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
y_range = pipeline.predict(X_range)
plt.scatter(X_test, y_test)
plt.plot(X_range, y_range)
```
Aqui está o gráfico que mostra os dados de teste e a curva de aproximação:
<img alt="Polynomial regression" src="../../../../translated_images/pt-PT/poly-results.ee587348f0f1f60b.webp" width="50%" />
Usando Regressão Polinomial, podemos obter um MSE ligeiramente inferior e um coeficiente de determinação mais alto, mas não de forma significativa. Precisamos de ter em conta outras características!
Usando Regressão Polinomial, podemos obter um RMSE ligeiramente mais baixo e um coeficiente de determinação mais alto, mas não significativamente. Precisamos de ter em conta outras características!
> Pode ver que os preços mínimos das abóboras ocorrem por volta do Halloween. Como pode explicar isso?
> Pode ver que os preços mínimos das abóboras são observados por volta do Halloween. Como pode explicar isto?
🎃 Parabéns, acabou de criar um modelo que pode ajudar a prever o preço de abóboras para torta. Provavelmente poderá repetir o mesmo procedimento para todos os tipos de abóbora, mas isso seria aborrecido. Vamos aprender agora como ter em conta a variedade de abóbora no nosso modelo!
🎃 Parabéns, acaba de criar um modelo que pode ajudar a prever o preço das abóboras para torta. Provavelmente pode repetir o mesmo procedimento para todos os tipos de abóbora, mas isso seria trabalhoso. Vamos agora aprender a ter em conta a variedade da abóbora no nosso modelo!
## Características Categóricas
No mundo ideal, queremos ser capazes de prever preços para diferentes variedades de abóbora usando o mesmo modelo. No entanto, a coluna `Variety` é um pouco diferente das colunas como `Month`, porque contém valores não numéricos. Essas colunas são chamadas **categóricas**.
No mundo ideal, queremos ser capazes de prever preços para diferentes variedades de abóboras usando o mesmo modelo. Contudo, a coluna `Variety` é algo diferente de colunas como `Month`, porque contém valores não numéricos. Essas colunas são chamadas **categóricas**.
[![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")
> 🎥 Clique na imagem acima para um breve vídeo explicativo sobre o uso de características categóricas.
> 🎥 Clique na imagem acima para ver um breve vídeo sobre o uso de características categóricas.
Aqui pode ver como o preço médio depende da variedade:
<img alt="Average price by variety" src="../../../../translated_images/pt-PT/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
Para ter a variedade em conta, primeiro precisamos convertê-la para forma numérica, ou **codificá-la**. Existem várias maneiras de o fazer:
Para ter em conta a variedade, primeiro precisamos de a converter em forma numérica, ou **codificar**. Existem várias formas de o fazer:
* A simples **codificação numérica** constrói uma tabela de diferentes variedades, e depois substitui o nome da variedade por um índice nessa tabela. Isto não é a melhor ideia para regressão linear, porque a regressão linear toma o valor numérico real do índice, e adiciona-o ao resultado, multiplicando por algum coeficiente. No nosso caso, a relação entre o número do índice e o preço é claramente não linear, mesmo se assegurarmos que os índices estão ordenados de alguma forma específica.
* A **codificação one-hot** vai substituir a coluna `Variety` por 4 colunas diferentes, uma para cada variedade. Cada coluna terá `1` se a linha correspondente for de uma dada variedade, e `0` caso contrário. Isto significa que haverá quatro coeficientes na regressão linear, um para cada variedade de abóbora, responsável pelo "preço inicial" (ou antes "preço adicional") para aquela variedade particular.
* Uma simples **codificação numérica** construirá uma tabela das diferentes variedades, e depois substituirá o nome da variedade por um índice nessa tabela. Esta não é a melhor ideia para regressão linear, porque a regressão linear utiliza o valor numérico real do índice, adicionando-o ao resultado, multiplicando por algum coeficiente. No nosso caso, a relação entre o número do índice e o preço é claramente não linear, mesmo que asseguremos que os índices estão ordenados de alguma forma específica.
* A **codificação one-hot** substituirá a coluna `Variety` por 4 colunas diferentes, uma para cada variedade. Cada coluna terá o valor `1` se a linha correspondente for daquela variedade, e `0` caso contrário. Isto significa que haverá quatro coeficientes na regressão linear, um para cada variedade de abóbora, responsável pelo "preço inicial" (ou antes "preço adicional") para aquela variedade em particular.
O código abaixo mostra como podemos codificar uma variedade usando one-hot:
O código abaixo mostra como podemos fazer a codificação one-hot de uma variedade:
```python
pd.get_dummies(new_pumpkins['Variety'])
@ -301,14 +324,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
Para treinar a regressão linear usando variedade codificada one-hot como entrada, só precisamos inicializar os dados `X` e `y` corretamente:
Para treinar regressão linear usando variedade codificada em one-hot como entrada, só precisamos inicializar corretamente os dados `X` e `y`:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
O resto do código é igual ao que usamos anteriormente para treinar a regressão linear. Se tentar, verá que o erro quadrático médio é mais ou menos o mesmo, mas obtemos um coeficiente de determinação muito mais alto (~77%). Para obter previsões ainda mais precisas, podemos levar mais características categóricas em conta, bem como características numéricas, como `Month` ou `DayOfYear`. Para obter um grande array de características, podemos usar `join`:
O resto do código é igual ao que usamos acima para treinar a Regressão Linear. Se tentar, verá que o erro quadrático médio é cerca do mesmo, mas obtemos um coeficiente de determinação muito mais elevado (~77%). Para obter previsões ainda mais precisas, podemos ter em conta mais características categóricas, bem como características numéricas, como `Month` ou `DayOfYear`. Para obter um único grande array de características, podemos usar `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -318,14 +341,14 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
Aqui também levamos em conta `City` e tipo de `Package`, o que nos dá MSE 2.84 (10%), e determinação 0.94!
Aqui também temos em conta `City` e `Package` (embalagem), o que nos dá RMSE 2.84 (10.5%), e determinação 0.94!
## Juntando tudo
Para fazer o melhor modelo, podemos usar dados combinados (categóricos codificados one-hot + numéricos) do exemplo acima juntamente com a Regressão Polinomial. Aqui está o código completo para sua conveniência:
Para fazer o melhor modelo, podemos usar dados combinados (características categóricas codificadas one-hot + numéricas) do exemplo acima juntamente com regressão polinomial. Aqui está o código completo para sua conveniência:
```python
# configurar dados de treino
# preparar dados de treino
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
@ -339,47 +362,47 @@ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# prever resultados para os dados de teste
# prever resultados para dados de teste
pred = pipeline.predict(X_test)
# calcular MSE e determinação
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
# calcular RMSE e determinação
rmse = mean_squared_error(y_test, pred, squared=False)
print(f'RMSE: {rmse:3.3} ({rmse/pred.mean()*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
Isto deverá dar-nos o melhor coeficiente de determinação de quase 97%, e MSE=2.23 (~8% de erro de previsão).
Isto deverá dar-nos o melhor coeficiente de determinação de quase 97%, e RMSE=2.23 (~8% de erro de previsão).
| Modelo | MSE | Determinação |
| Modelo | RMSE | Determinação |
|-------|-----|---------------|
| Linear `DayOfYear` | 2.77 (17.2%) | 0.07 |
| Polinomial `DayOfYear` | 2.73 (17.0%) | 0.08 |
| Linear `Variety` | 5.24 (19.7%) | 0.77 |
| Linear com todas as características | 2.84 (10.5%) | 0.94 |
| Polinomial com todas as características | 2.23 (8.25%) | 0.97 |
| Todas as características Linear | 2.84 (10.5%) | 0.94 |
| Todas as características Polinomial | 2.23 (8.25%) | 0.97 |
🏆 Muito bem! Criou quatro modelos de regressão numa lição, e melhorou a qualidade do modelo para 97%. Na secção final de Regressão, vai aprender sobre Regressão Logística para determinar categorias.
🏆 Muito bem! Criou quatro modelos de Regressão numa lição, e melhorou a qualidade do modelo para 97%. Na secção final sobre Regressão, aprenderá sobre Regressão Logística para determinar categorias.
---
## 🚀Desafio
Teste várias variáveis diferentes neste notebook para ver como a correlação corresponde à precisão do modelo.
## [Questionário pós-aula](https://ff-quizzes.netlify.app/en/ml/)
## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
## Revisão & Auto-estudo
## Revisão & Autoestudo
Nesta lição aprendemos sobre Regressão Linear. Existem outros tipos importantes de Regressão. Leia sobre as técnicas Stepwise, Ridge, Lasso e Elasticnet. Um bom curso para estudar e aprender mais é o [curso de Aprendizagem Estatística de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
Nesta lição aprendemos sobre Regressão Linear. Existem outros tipos importantes de Regressão. Leia sobre as técnicas Stepwise, Ridge, Lasso e Elasticnet. Um bom curso para estudar e aprender mais é o [Curso de Aprendizagem Estatística de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Tarefa
## Trabalho
[Construa um Modelo](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Aviso Legal**:
Este documento foi traduzido utilizando o serviço de tradução automática [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor tenha em conta que traduções automáticas podem conter erros ou imprecisões. O documento original, no seu idioma nativo, deve ser considerado a fonte oficial. Para informação crítica, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes da utilização desta tradução.
**Aviso Legal**:
Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, tenha em atenção que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

67
translations/pt-PT/2-Regression/3-Linear/solution/notebook.ipynb
Unescape View File

@ -4,14 +4,14 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## Regressão Linear e Polinomial para Preços de Abóboras - Aula 3\n",
"## Regressão Linear e Polinomial para Preço de Abóboras - Aula 3\n",
"\n",
"Carregue as bibliotecas necessárias e o conjunto de dados. Converta os dados para um dataframe contendo um subconjunto dos dados:\n",
"Carregue as bibliotecas e o conjunto de dados necessários. Converta os dados para um dataframe contendo um subconjunto dos dados:\n",
"\n",
"- Obtenha apenas abóboras com preços por alqueire\n",
"- Obtenha apenas as abóboras com preço por alqueire\n",
"- Converta a data para um mês\n",
"- Calcule o preço como uma média entre os preços altos e baixos\n",
"- Converta o preço para refletir o valor por quantidade de alqueires\n"
"- Calcule o preço como uma média dos preços alto e baixo\n",
"- Converta o preço para refletir o preço por quantidade de alqueire\n"
]
},
{
@ -377,7 +377,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Um gráfico de dispersão lembra-nos que só temos dados mensais de agosto a dezembro. Provavelmente precisamos de mais dados para conseguir tirar conclusões de forma linear.\n"
"Um gráfico de dispersão recorda-nos que só temos dados mensais de agosto a dezembro. Provavelmente precisamos de mais dados para poder tirar conclusões de forma linear.\n"
]
},
{
@ -447,7 +447,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Vamos ver se há correlação:\n"
]
},
{
"cell_type": "code",
@ -472,7 +474,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Parece que a correlação é bastante pequena, mas existe alguma outra relação mais importante - porque os pontos de preço no gráfico acima parecem ter vários clusters distintos. Vamos criar um gráfico que mostre diferentes variedades de abóbora:\n"
"Parece que a correlação é bastante pequena, mas há outra relação mais importante – porque os pontos de preço no gráfico acima parecem ter vários agrupamentos distintos. Vamos fazer um gráfico que mostre diferentes variedades de abóboras:\n"
]
},
{
@ -535,7 +537,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Por enquanto, vamos concentrar-nos apenas numa variedade - **tipo de tarte**.\n"
]
},
{
"cell_type": "code",
@ -662,7 +666,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"A inclinação da linha pode ser determinada a partir dos coeficientes de regressão linear:\n"
"A inclinação da linha pode ser determinada a partir dos coeficientes da regressão linear:\n"
]
},
{
@ -688,7 +692,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Podemos usar o modelo treinado para prever o preço:\n"
]
},
{
"cell_type": "code",
@ -718,9 +724,9 @@
"source": [
"### Regressão Polinomial\n",
"\n",
"Por vezes, a relação entre as características e os resultados é intrinsecamente não linear. Por exemplo, os preços das abóboras podem ser altos no inverno (meses=1,2), depois cair no verão (meses=5-7) e voltar a subir novamente. A regressão linear não consegue captar esta relação com precisão.\n",
"Por vezes, a relação entre as características e os resultados é inherentemente não linear. Por exemplo, os preços da abóbora podem ser elevados no inverno (meses=1,2), depois diminuir durante o verão (meses=5-7), e depois subir novamente. A regressão linear não consegue encontrar esta relação com precisão.\n",
"\n",
"Neste caso, podemos considerar adicionar características adicionais. Uma forma simples é usar polinómios das características de entrada, o que resultaria numa **regressão polinomial**. No Scikit Learn, podemos pré-computar automaticamente características polinomiais utilizando pipelines:\n"
"Neste caso, podemos considerar adicionar características extras. Uma forma simples é usar polinómios das características de entrada, o que resultaria numa **regressão polinomial**. No Scikit Learn, podemos pré-calcular automaticamente características polinomiais usando pipelines: \n"
]
},
{
@ -775,22 +781,25 @@
"score = pipeline.score(X_train,y_train)\n",
"print('Model determination: ', score)\n",
"\n",
"plt.scatter(X_test,y_test)\n",
"plt.plot(sorted(X_test),pipeline.predict(sorted(X_test)))"
"X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)\n",
"y_range = pipeline.predict(X_range)\n",
"\n",
"plt.scatter(X_test, y_test)\n",
"plt.plot(X_range, y_range)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Codificação de variedades\n",
"### Variedades de codificação\n",
"\n",
"No mundo ideal, queremos ser capazes de prever os preços para diferentes variedades de abóbora usando o mesmo modelo. Para levar a variedade em consideração, primeiro precisamos convertê-la para uma forma numérica, ou **codificar**. Existem várias maneiras de fazer isso:\n",
"No mundo ideal, queremos conseguir prever preços para diferentes variedades de abóbora utilizando o mesmo modelo. Para ter em conta a variedade, primeiro precisamos convertê-la para uma forma numérica, ou **codificar**. Existem várias formas de o fazermos:\n",
"\n",
"* Codificação numérica simples que cria uma tabela com diferentes variedades e, em seguida, substitui o nome da variedade por um índice nessa tabela. Esta não é a melhor ideia para regressão linear, porque a regressão linear leva em conta o valor numérico do índice, e o valor numérico provavelmente não terá correlação numérica com o preço.\n",
"* Codificação one-hot, que substitui a coluna `Variety` por 4 colunas diferentes, uma para cada variedade, que conterão 1 se a linha correspondente for da variedade dada, e 0 caso contrário.\n",
"* Codificação numérica simples que irá construir uma tabela das diferentes variedades, e depois substituir o nome da variedade por um índice nessa tabela. Esta não é a melhor ideia para regressão linear, porque a regressão linear leva em consideração o valor numérico do índice, e o valor numérico provavelmente não se correlaciona numericamente com o preço.\n",
"* Codificação one-hot, que irá substituir a coluna `Variety` por 4 colunas diferentes, uma para cada variedade, que conterá 1 se a linha correspondente for da variedade dada, e 0 caso contrário.\n",
"\n",
"O código abaixo mostra como podemos codificar uma variedade usando one-hot:\n"
"O código abaixo mostra como podemos codificar one-hot uma variedade:\n"
]
},
{
@ -938,9 +947,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"### Regressão Linear sobre Variedade\n",
"### Regressão Linear na Variedade\n",
"\n",
"Agora vamos usar o mesmo código mencionado acima, mas em vez de `DayOfYear`, utilizaremos a nossa variedade codificada em one-hot como entrada:\n"
"Vamos agora usar o mesmo código de cima, mas em vez de `DayOfYear` vamos usar a nossa variedade codificada one-hot como entrada:\n"
]
},
{
@ -988,7 +997,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos também tentar usar outras funcionalidades da mesma maneira e combiná-las com funcionalidades numéricas, como `Month` ou `DayOfYear`:\n"
"Também podemos tentar usar outras características da mesma forma, e combiná-las com características numéricas, como `Month` ou `DayOfYear`:\n"
]
},
{
@ -1021,7 +1030,7 @@
"source": [
"### Regressão Polinomial\n",
"\n",
"A regressão polinomial também pode ser utilizada com características categóricas que foram codificadas em one-hot. O código para treinar a regressão polinomial seria essencialmente o mesmo que vimos acima.\n"
"A regressão polinomial também pode ser usada com características categóricas que são codificadas em one-hot. O código para treinar a regressão polinomial seria essencialmente o mesmo que vimos acima.\n"
]
},
{
@ -1068,7 +1077,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**Aviso Legal**: \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, é importante ter em conta que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes da utilização desta tradução.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Aviso Legal**: \nEste documento foi traduzido utilizando o serviço de tradução automática [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes da utilização desta tradução.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -1098,13 +1107,7 @@
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "d77bd89ae7e79780c68c58bab91f13f8",
"translation_date": "2025-09-03T19:17:56+00:00",
"source_file": "2-Regression/3-Linear/solution/notebook.ipynb",
"language_code": "pt"
}
"orig_nbformat": 2
},
"nbformat": 4,
"nbformat_minor": 2

Write Preview
Loading…
Cancel
Save