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 7/10, 100 files)

Browse Source
pull/915/head
localizeflow[bot] 2 months ago
parent 07ac3d9c7a
commit f07ce14f6b
100 changed files with 23777 additions and 0 deletions
Show Stats Download Patch File Download Diff File

17
translations/kn/6-NLP/4-Hotel-Reviews-1/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T14:48:23+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/R/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

174
translations/kn/6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb
Unescape View File

@ -0,0 +1,174 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": 3
},
"orig_nbformat": 4,
"coopTranslator": {
"original_hash": "2d05e7db439376aa824f4b387f8324ca",
"translation_date": "2025-12-19T16:49:31+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# EDA\n",
"import pandas as pd\n",
"import time"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def get_difference_review_avg(row):\n",
" return row[\"Average_Score\"] - row[\"Calc_Average_Score\"]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Load the hotel reviews from CSV\n",
"print(\"Loading data file now, this could take a while depending on file size\")\n",
"start = time.time()\n",
"df = pd.read_csv('../../data/Hotel_Reviews.csv')\n",
"end = time.time()\n",
"print(\"Loading took \" + str(round(end - start, 2)) + \" seconds\")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# What shape is the data (rows, columns)?\n",
"print(\"The shape of the data (rows, cols) is \" + str(df.shape))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# value_counts() creates a Series object that has index and values\n",
"# in this case, the country and the frequency they occur in reviewer nationality\n",
"nationality_freq = df[\"Reviewer_Nationality\"].value_counts()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# What reviewer nationality is the most common in the dataset?\n",
"print(\"The highest frequency reviewer nationality is \" + str(nationality_freq.index[0]).strip() + \" with \" + str(nationality_freq[0]) + \" reviews.\")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# What is the top 10 most common nationalities and their frequencies?\n",
"print(\"The top 10 highest frequency reviewer nationalities are:\")\n",
"print(nationality_freq[0:10].to_string())\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# How many unique nationalities are there?\n",
"print(\"There are \" + str(nationality_freq.index.size) + \" unique nationalities in the dataset\")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# What was the most frequently reviewed hotel for the top 10 nationalities - print the hotel and number of reviews\n",
"for nat in nationality_freq[:10].index:\n",
" # First, extract all the rows that match the criteria into a new dataframe\n",
" nat_df = df[df[\"Reviewer_Nationality\"] == nat] \n",
" # Now get the hotel freq\n",
" freq = nat_df[\"Hotel_Name\"].value_counts()\n",
" print(\"The most reviewed hotel for \" + str(nat).strip() + \" was \" + str(freq.index[0]) + \" with \" + str(freq[0]) + \" reviews.\") \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# How many reviews are there per hotel (frequency count of hotel) and do the results match the value in `Total_Number_of_Reviews`?\n",
"# First create a new dataframe based on the old one, removing the uneeded columns\n",
"hotel_freq_df = df.drop([\"Hotel_Address\", \"Additional_Number_of_Scoring\", \"Review_Date\", \"Average_Score\", \"Reviewer_Nationality\", \"Negative_Review\", \"Review_Total_Negative_Word_Counts\", \"Positive_Review\", \"Review_Total_Positive_Word_Counts\", \"Total_Number_of_Reviews_Reviewer_Has_Given\", \"Reviewer_Score\", \"Tags\", \"days_since_review\", \"lat\", \"lng\"], axis = 1)\n",
"# Group the rows by Hotel_Name, count them and put the result in a new column Total_Reviews_Found\n",
"hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count')\n",
"# Get rid of all the duplicated rows\n",
"hotel_freq_df = hotel_freq_df.drop_duplicates(subset = [\"Hotel_Name\"])\n",
"print()\n",
"print(hotel_freq_df.to_string())\n",
"print(str(hotel_freq_df.shape))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# While there is an `Average_Score` for each hotel according to the dataset, \n",
"# you can also calculate an average score (getting the average of all reviewer scores in the dataset for each hotel)\n",
"# Add a new column to your dataframe with the column header `Calc_Average_Score` that contains that calculated average. \n",
"df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)\n",
"# Add a new column with the difference between the two average scores\n",
"df[\"Average_Score_Difference\"] = df.apply(get_difference_review_avg, axis = 1)\n",
"# Create a df without all the duplicates of Hotel_Name (so only 1 row per hotel)\n",
"review_scores_df = df.drop_duplicates(subset = [\"Hotel_Name\"])\n",
"# Sort the dataframe to find the lowest and highest average score difference\n",
"review_scores_df = review_scores_df.sort_values(by=[\"Average_Score_Difference\"])\n",
"print(review_scores_df[[\"Average_Score_Difference\", \"Average_Score\", \"Calc_Average_Score\", \"Hotel_Name\"]])\n",
"# Do any hotels have the same (rounded to 1 decimal place) `Average_Score` and `Calc_Average_Score`?\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

391
translations/kn/6-NLP/5-Hotel-Reviews-2/README.md
Unescape View File

@ -0,0 +1,391 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2c742993fe95d5bcbb2846eda3d442a1",
"translation_date": "2025-12-19T14:43:57+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/README.md",
"language_code": "kn"
}
-->
# ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳೊಂದಿಗೆ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ
ನೀವು ಈಗಾಗಲೇ ಡೇಟಾಸೆಟ್ ಅನ್ನು ವಿವರವಾಗಿ ಅನ್ವೇಷಿಸಿದ್ದೀರಿ, ಈಗ ಕಾಲಮ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ ನಂತರ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ NLP ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೋಟೆಲ್‌ಗಳ ಬಗ್ಗೆ ಹೊಸ洞察ಗಳನ್ನು ಪಡೆಯುವ ಸಮಯವಾಗಿದೆ.
## [ಪೂರ್ವ-ಲೇಕ್ಚರ್ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
### ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ ಕಾರ್ಯಾಚರಣೆಗಳು
ನೀವು ಗಮನಿಸಿದ್ದಂತೆ, ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಕೆಲವು ಸಮಸ್ಯೆಗಳಿವೆ. ಕೆಲವು ಕಾಲಮ್‌ಗಳು ಅರ್ಥವಿಲ್ಲದ ಮಾಹಿತಿಯಿಂದ ತುಂಬಿವೆ, ಇತರವು ತಪ್ಪಾಗಿವೆ ಎಂದು ತೋರುತ್ತದೆ. ಅವು ಸರಿಯಾಗಿದ್ದರೆ, ಅವು ಹೇಗೆ ಲೆಕ್ಕಿಸಲ್ಪಟ್ಟಿವೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಿಲ್ಲ, ಮತ್ತು ಉತ್ತರಗಳನ್ನು ನಿಮ್ಮ ಸ್ವಂತ ಲೆಕ್ಕಾಚಾರಗಳಿಂದ ಸ್ವತಂತ್ರವಾಗಿ ಪರಿಶೀಲಿಸಲಾಗುವುದಿಲ್ಲ.
## ವ್ಯಾಯಾಮ: ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ
ಡೇಟಾವನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸ್ವಚ್ಛಗೊಳಿಸಿ. ನಂತರ ಉಪಯುಕ್ತವಾಗುವ ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಿ, ಇತರ ಕಾಲಮ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಿಸಿ, ಮತ್ತು ಕೆಲವು ಕಾಲಮ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆಗೆದುಹಾಕಿ.
1. ಪ್ರಾಥಮಿಕ ಕಾಲಮ್ ಪ್ರಕ್ರಿಯೆ
1. `lat` ಮತ್ತು `lng` ಅನ್ನು ತೆಗೆದುಹಾಕಿ
2. `Hotel_Address` ಮೌಲ್ಯಗಳನ್ನು ಕೆಳಗಿನ ಮೌಲ್ಯಗಳಿಂದ ಬದಲಿಸಿ (ವಿಳಾಸದಲ್ಲಿ ನಗರ ಮತ್ತು ದೇಶದ ಹೆಸರು ಇದ್ದರೆ, ಅದನ್ನು ಕೇವಲ ನಗರ ಮತ್ತು ದೇಶಕ್ಕೆ ಬದಲಿಸಿ).
ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಇವು ಮಾತ್ರ ನಗರಗಳು ಮತ್ತು ದೇಶಗಳು:
ಆಂಸ್ಟರ್ಡ್ಯಾಮ್, ನೆದರ್ಲ್ಯಾಂಡ್ಸ್
ಬಾರ್ಸಿಲೋನಾ, ಸ್ಪೇನ್
ಲಂಡನ್, ಯುನೈಟೆಡ್ ಕಿಂಗ್‌ಡಮ್
ಮಿಲಾನ್, ಇಟಲಿ
ಪ್ಯಾರಿಸ್, ಫ್ರಾನ್ಸ್
ವಿಯೆನ್ನಾ, ಆಸ್ಟ್ರಿಯಾ
```python
def replace_address(row):
if "Netherlands" in row["Hotel_Address"]:
return "Amsterdam, Netherlands"
elif "Barcelona" in row["Hotel_Address"]:
return "Barcelona, Spain"
elif "United Kingdom" in row["Hotel_Address"]:
return "London, United Kingdom"
elif "Milan" in row["Hotel_Address"]:
return "Milan, Italy"
elif "France" in row["Hotel_Address"]:
return "Paris, France"
elif "Vienna" in row["Hotel_Address"]:
return "Vienna, Austria"
# ಎಲ್ಲಾ ವಿಳಾಸಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತ, ಹೆಚ್ಚು ಉಪಯುಕ್ತ ರೂಪದಲ್ಲಿ ಬದಲಾಯಿಸಿ
df["Hotel_Address"] = df.apply(replace_address, axis = 1)
# value_counts() ನ ಮೊತ್ತವು ವಿಮರ್ಶೆಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಗೆ ಸೇರಬೇಕು
print(df["Hotel_Address"].value_counts())
```
ಈಗ ನೀವು ದೇಶ ಮಟ್ಟದ ಡೇಟಾವನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು:
```python
display(df.groupby("Hotel_Address").agg({"Hotel_Name": "nunique"}))
```
| Hotel_Address | Hotel_Name |
| :--------------------- | :--------: |
| Amsterdam, Netherlands | 105 |
| Barcelona, Spain | 211 |
| London, United Kingdom | 400 |
| Milan, Italy | 162 |
| Paris, France | 458 |
| Vienna, Austria | 158 |
2. ಹೋಟೆಲ್ ಮೆಟಾ-ವಿಮರ್ಶೆ ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
1. `Additional_Number_of_Scoring` ಅನ್ನು ತೆಗೆದುಹಾಕಿ
2. `Total_Number_of_Reviews` ಅನ್ನು ಆ ಹೋಟೆಲ್‌ಗೆ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಇರುವ ವಿಮರ್ಶೆಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯಿಂದ ಬದಲಿಸಿ
3. `Average_Score` ಅನ್ನು ನಮ್ಮ ಸ್ವಂತ ಲೆಕ್ಕಿಸಿದ ಅಂಕದಿಂದ ಬದಲಿಸಿ
```python
# `Additional_Number_of_Scoring` ಅನ್ನು ತೆಗೆದುಹಾಕಿ
df.drop(["Additional_Number_of_Scoring"], axis = 1, inplace=True)
# `Total_Number_of_Reviews` ಮತ್ತು `Average_Score` ಅನ್ನು ನಮ್ಮ ಸ್ವಂತ ಲೆಕ್ಕಹಾಕಿದ ಮೌಲ್ಯಗಳಿಂದ ಬದಲಾಯಿಸಿ
df.Total_Number_of_Reviews = df.groupby('Hotel_Name').transform('count')
df.Average_Score = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
```
3. ವಿಮರ್ಶೆ ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
1. `Review_Total_Negative_Word_Counts`, `Review_Total_Positive_Word_Counts`, `Review_Date` ಮತ್ತು `days_since_review` ಅನ್ನು ತೆಗೆದುಹಾಕಿ
2. `Reviewer_Score`, `Negative_Review`, ಮತ್ತು `Positive_Review` ಅನ್ನು ಹಾಗೆಯೇ ಇಡಿರಿ,
3. ಈಗಿಗೆ `Tags` ಅನ್ನು ಇಡಿರಿ
- ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಟ್ಯಾಗ್‌ಗಳ ಮೇಲೆ ಕೆಲವು ಹೆಚ್ಚುವರಿ ಫಿಲ್ಟರಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಲಾಗುವುದು ಮತ್ತು ನಂತರ ಟ್ಯಾಗ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗುವುದು
4. ವಿಮರ್ಶಕರ ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
1. `Total_Number_of_Reviews_Reviewer_Has_Given` ಅನ್ನು ತೆಗೆದುಹಾಕಿ
2. `Reviewer_Nationality` ಅನ್ನು ಇಡಿರಿ
### ಟ್ಯಾಗ್ ಕಾಲಮ್‌ಗಳು
`Tag` ಕಾಲಮ್ ಸಮಸ್ಯೆಯಾಗಿದೆ ಏಕೆಂದರೆ ಅದು ಕಾಲಮ್‌ನಲ್ಲಿ ಪಠ್ಯ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಪಟ್ಟಿ. ದುರದೃಷ್ಟವಶಾತ್, ಈ ಕಾಲಮ್‌ನ ಉಪ ವಿಭಾಗಗಳ ಕ್ರಮ ಮತ್ತು ಸಂಖ್ಯೆ ಯಾವಾಗಲೂ ಒಂದೇ ರೀತಿಯಲ್ಲ. ಮಾನವನಿಗೆ ಸರಿಯಾದ ವಾಕ್ಯಗಳನ್ನು ಗುರುತಿಸುವುದು ಕಷ್ಟ, ಏಕೆಂದರೆ 515,000 ಸಾಲುಗಳು, 1427 ಹೋಟೆಲ್‌ಗಳು ಇವೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದು ವಿಮರ್ಶಕನು ಆಯ್ಕೆಮಾಡಬಹುದಾದ ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಆಯ್ಕೆಗಳು ಇವೆ. ಇಲ್ಲಿ NLP ಪ್ರಭಾವಶಾಲಿ. ನೀವು ಪಠ್ಯವನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಿ ಸಾಮಾನ್ಯ ವಾಕ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿದು ಅವುಗಳನ್ನು ಎಣಿಸಬಹುದು.
ದುರದೃಷ್ಟವಶಾತ್, ನಾವು ಏಕಪದಗಳಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿಲ್ಲ, ಆದರೆ ಬಹುಪದ ವಾಕ್ಯಗಳಲ್ಲಿ (ಉದಾ: *Business trip*). ಇಷ್ಟು ದೊಡ್ಡ ಡೇಟಾದ ಮೇಲೆ ಬಹುಪದ ಫ್ರೀಕ್ವೆನ್ಸಿ ವಿತರಣಾ ಆಲ್ಗೋರಿದಮ್ ಅನ್ನು ನಡೆಸುವುದು (6762646 ಪದಗಳು) ಬಹಳ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಆದರೆ ಡೇಟಾವನ್ನು ನೋಡದೆ ಇದನ್ನು ಅಗತ್ಯ ವೆಚ್ಚವೆಂದು ಭಾಸವಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಅನ್ವೇಷಣಾತ್ಮಕ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಉಪಯುಕ್ತವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನೀವು ಟ್ಯಾಗ್‌ಗಳ ಮಾದರಿಯನ್ನು ನೋಡಿದ್ದೀರಿ ಉದಾ: `[' Business trip ', ' Solo traveler ', ' Single Room ', ' Stayed 5 nights ', ' Submitted from a mobile device ']` , ನೀವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಹಳ ಕಡಿಮೆ ಮಾಡಲು ಸಾಧ್ಯವಿದೆಯೇ ಎಂದು ಕೇಳಬಹುದು. ಅದೃಷ್ಟವಶಾತ್, ಸಾಧ್ಯ - ಆದರೆ ಮೊದಲು ನೀವು ಆಸಕ್ತಿಯ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಖಚಿತಪಡಿಸಲು ಕೆಲವು ಹಂತಗಳನ್ನು ಅನುಸರಿಸಬೇಕು.
### ಟ್ಯಾಗ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು
ಡೇಟಾಸೆಟ್‌ನ ಗುರಿ ಭಾವನೆ ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು, ಇದು ನಿಮಗೆ ಅತ್ಯುತ್ತಮ ಹೋಟೆಲ್ ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ (ನಿಮಗಾಗಿ ಅಥವಾ ಗ್ರಾಹಕನಿಗೆ ಹೋಟೆಲ್ ಶಿಫಾರಸು ಬಾಟ್ ಮಾಡಲು). ನೀವು ಟ್ಯಾಗ್‌ಗಳು ಅಂತಿಮ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಉಪಯುಕ್ತವೋ ಇಲ್ಲವೋ ಎಂದು ಕೇಳಿಕೊಳ್ಳಬೇಕು. ಇಲ್ಲಿದೆ ಒಂದು ವ್ಯಾಖ್ಯಾನ (ನೀವು ಬೇರೆ ಕಾರಣಗಳಿಗಾಗಿ ಡೇಟಾಸೆಟ್ ಬೇಕಾದರೆ ವಿಭಿನ್ನ ಟ್ಯಾಗ್‌ಗಳು ಒಳಗಾಗಬಹುದು/ಬಾಹ್ಯವಾಗಬಹುದು):
1. ಪ್ರಯಾಣದ ಪ್ರಕಾರ ಸಂಬಂಧಿಸಿದೆ, ಮತ್ತು ಅದು ಉಳಿಯಬೇಕು
2. ಅತಿಥಿ ಗುಂಪಿನ ಪ್ರಕಾರ ಮುಖ್ಯವಾಗಿದೆ, ಮತ್ತು ಅದು ಉಳಿಯಬೇಕು
3. ಅತಿಥಿ ಉಳಿದ ಕೊಠಡಿ, ಸೂಟ್ ಅಥವಾ ಸ್ಟುಡಿಯೋ ಪ್ರಕಾರ ಅಸಂಬಂಧಿತ (ಎಲ್ಲಾ ಹೋಟೆಲ್‌ಗಳಲ್ಲಿಯೂ ಮೂಲತಃ ಒಂದೇ ರೀತಿಯ ಕೊಠಡಿಗಳು ಇವೆ)
4. ವಿಮರ್ಶೆ ಸಲ್ಲಿಸಿದ ಸಾಧನ ಅಸಂಬಂಧಿತ
5. ವಿಮರ್ಶಕನು ಉಳಿದ ರಾತ್ರಿ ಸಂಖ್ಯೆ *ಸಂಬಂಧಿಸಬಹುದು* ಆದರೆ ಅದು ದೂರದೃಷ್ಟಿ ಮತ್ತು ಬಹುಶಃ ಅಸಂಬಂಧಿತ
ಸಾರಾಂಶವಾಗಿ, **2 ವಿಧದ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಉಳಿಸಿ ಮತ್ತು ಇತರವನ್ನು ತೆಗೆದುಹಾಕಿ**.
ಮೊದಲು, ನೀವು ಟ್ಯಾಗ್‌ಗಳನ್ನು ಉತ್ತಮ ಸ್ವರೂಪದಲ್ಲಿ ಇರಿಸುವವರೆಗೆ ಎಣಿಸಲು ಬಯಸುವುದಿಲ್ಲ, ಅಂದರೆ ಚದರ ಕೊಠಡಿಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು. ನೀವು ಇದನ್ನು ಹಲವಾರು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು, ಆದರೆ ವೇಗವಾಗಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಬಹಳ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಗೆ ಸಮಯ ಬೇಕಾಗಬಹುದು. ಅದೃಷ್ಟವಶಾತ್, pandas ಇದನ್ನು ಸುಲಭವಾಗಿ ಮಾಡುತ್ತದೆ.
```Python
# ತೆರೆಯುವ ಮತ್ತು ಮುಚ್ಚುವ ಕೋಷ್ಠಕಗಳನ್ನು ತೆಗೆದುಹಾಕಿ
df.Tags = df.Tags.str.strip("[']")
# ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳನ್ನು ಕೂಡ ತೆಗೆದುಹಾಕಿ
df.Tags = df.Tags.str.replace(" ', '", ",", regex = False)
```
ಪ್ರತಿ ಟ್ಯಾಗ್ ಹೀಗೆ ಆಗುತ್ತದೆ: `Business trip, Solo traveler, Single Room, Stayed 5 nights, Submitted from a mobile device`.
ಮುಂದೆ ಸಮಸ್ಯೆ ಕಂಡುಬರುತ್ತದೆ. ಕೆಲವು ವಿಮರ್ಶೆಗಳು ಅಥವಾ ಸಾಲುಗಳು 5 ಕಾಲಮ್‌ಗಳಿವೆ, ಕೆಲವು 3, ಕೆಲವು 6. ಇದು ಡೇಟಾಸೆಟ್ ರಚನೆಯ ಪರಿಣಾಮ, ಮತ್ತು ಸರಿಪಡಿಸಲು ಕಷ್ಟ. ನೀವು ಪ್ರತಿಯೊಂದು ವಾಕ್ಯದ ಫ್ರೀಕ್ವೆನ್ಸಿ ಎಣಿಕೆ ಪಡೆಯಲು ಬಯಸುತ್ತೀರಿ, ಆದರೆ ಅವು ಪ್ರತಿ ವಿಮರ್ಶೆಯಲ್ಲಿ ವಿಭಿನ್ನ ಕ್ರಮದಲ್ಲಿವೆ, ಆದ್ದರಿಂದ ಎಣಿಕೆ ತಪ್ಪಾಗಬಹುದು, ಮತ್ತು ಹೋಟೆಲ್‌ಗೆ ಅದು ಅರ್ಹವಾದ ಟ್ಯಾಗ್ ನೀಡಲಾಗದಿರಬಹುದು.
ಬದಲಿಗೆ ನೀವು ವಿಭಿನ್ನ ಕ್ರಮವನ್ನು ನಮ್ಮ ಲಾಭಕ್ಕೆ ಬಳಸುತ್ತೀರಿ, ಏಕೆಂದರೆ ಪ್ರತಿಯೊಂದು ಟ್ಯಾಗ್ ಬಹುಪದವಾಗಿದೆ ಆದರೆ ಕಾಮಾ ಮೂಲಕ ವಿಭಜಿಸಲಾಗಿದೆ! ಸರಳ ವಿಧಾನವೆಂದರೆ 6 ತಾತ್ಕಾಲಿಕ ಕಾಲಮ್‌ಗಳನ್ನು ರಚಿಸಿ, ಪ್ರತಿಯೊಂದು ಟ್ಯಾಗ್ ಅನ್ನು ಅದರ ಕ್ರಮಕ್ಕೆ ಹೊಂದಿಕೊಂಡು ಕಾಲಮ್‌ಗೆ ಸೇರಿಸಿ. ನಂತರ ಆ 6 ಕಾಲಮ್‌ಗಳನ್ನು ಒಂದು ದೊಡ್ಡ ಕಾಲಮ್‌ಗೆ ಮರ್ಜ್ ಮಾಡಿ `value_counts()` ವಿಧಾನವನ್ನು ಆ ಕಾಲಮ್ ಮೇಲೆ ಚಾಲನೆ ಮಾಡಬಹುದು. ಅದನ್ನು ಮುದ್ರಿಸಿದಾಗ, 2428 ವಿಭಿನ್ನ ಟ್ಯಾಗ್‌ಗಳಿವೆ. ಇಲ್ಲಿದೆ ಸಣ್ಣ ಮಾದರಿ:
| Tag | Count |
| ------------------------------ | ------ |
| Leisure trip | 417778 |
| Submitted from a mobile device | 307640 |
| Couple | 252294 |
| Stayed 1 night | 193645 |
| Stayed 2 nights | 133937 |
| Solo traveler | 108545 |
| Stayed 3 nights | 95821 |
| Business trip | 82939 |
| Group | 65392 |
| Family with young children | 61015 |
| Stayed 4 nights | 47817 |
| Double Room | 35207 |
| Standard Double Room | 32248 |
| Superior Double Room | 31393 |
| Family with older children | 26349 |
| Deluxe Double Room | 24823 |
| Double or Twin Room | 22393 |
| Stayed 5 nights | 20845 |
| Standard Double or Twin Room | 17483 |
| Classic Double Room | 16989 |
| Superior Double or Twin Room | 13570 |
| 2 rooms | 12393 |
ಕೆಲವು ಸಾಮಾನ್ಯ ಟ್ಯಾಗ್‌ಗಳು `Submitted from a mobile device` ನಮಗೆ ಉಪಯೋಗವಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಎಣಿಸುವ ಮೊದಲು ತೆಗೆದುಹಾಕುವುದು ಬುದ್ಧಿವಂತಿಕೆ, ಆದರೆ ಇದು ವೇಗವಾದ ಕಾರ್ಯವಾಗಿರುವುದರಿಂದ ಅವುಗಳನ್ನು ಉಳಿಸಿ ನಿರ್ಲಕ್ಷಿಸಬಹುದು.
### ಉಳಿದಿರುವ ಟ್ಯಾಗ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು
ಈ ಟ್ಯಾಗ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಹಂತ 1, ಇದು ಪರಿಗಣಿಸಬೇಕಾದ ಟ್ಯಾಗ್‌ಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ಸ್ವಲ್ಪ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಗಮನಿಸಿ ನೀವು ಅವುಗಳನ್ನು ಡೇಟಾಸೆಟ್‌ನಿಂದ ತೆಗೆದುಹಾಕುವುದಿಲ್ಲ, ಕೇವಲ ವಿಮರ್ಶೆಗಳ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಎಣಿಕೆ/ಉಳಿಸುವ ಮೌಲ್ಯಗಳ ಪರಿಗಣನೆಗೆ ತೆಗೆದುಹಾಕುತ್ತೀರಿ.
| Length of stay | Count |
| ---------------- | ------ |
| Stayed 1 night | 193645 |
| Stayed 2 nights | 133937 |
| Stayed 3 nights | 95821 |
| Stayed 4 nights | 47817 |
| Stayed 5 nights | 20845 |
| Stayed 6 nights | 9776 |
| Stayed 7 nights | 7399 |
| Stayed 8 nights | 2502 |
| Stayed 9 nights | 1293 |
| ... | ... |
ಕೊಠಡಿಗಳ, ಸೂಟ್‌ಗಳ, ಸ್ಟುಡಿಯೋಗಳ, ಅಪಾರ್ಟ್‌ಮೆಂಟ್‌ಗಳ ಬಹುಮತ variety ಇದೆ. ಅವು ಎಲ್ಲವೂ ಅಂದಾಜು ಮಾಡಬಹುದಾದ ಅರ್ಥ ಹೊಂದಿವೆ ಮತ್ತು ನಿಮಗೆ ಸಂಬಂಧವಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಪರಿಗಣನೆಗೆ ತೆಗೆದುಹಾಕಿ.
| Type of room | Count |
| ----------------------------- | ----- |
| Double Room | 35207 |
| Standard Double Room | 32248 |
| Superior Double Room | 31393 |
| Deluxe Double Room | 24823 |
| Double or Twin Room | 22393 |
| Standard Double or Twin Room | 17483 |
| Classic Double Room | 16989 |
| Superior Double or Twin Room | 13570 |
ಕೊನೆಗೆ, ಮತ್ತು ಇದು ಸಂತೋಷದಾಯಕ (ಏಕೆಂದರೆ ಬಹಳ ಪ್ರಕ್ರಿಯೆ ಬೇಕಾಗಲಿಲ್ಲ), ನೀವು ಕೆಳಗಿನ *ಉಪಯುಕ್ತ* ಟ್ಯಾಗ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತೀರಿ:
| Tag | Count |
| --------------------------------------------- | ------ |
| Leisure trip | 417778 |
| Couple | 252294 |
| Solo traveler | 108545 |
| Business trip | 82939 |
| Group (combined with Travellers with friends) | 67535 |
| Family with young children | 61015 |
| Family with older children | 26349 |
| With a pet | 1405 |
ನೀವು ವಾದಿಸಬಹುದು `Travellers with friends` ಮತ್ತು `Group` ಬಹುಶಃ ಒಂದೇ, ಮತ್ತು ಮೇಲಿನಂತೆ ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು ನ್ಯಾಯಸಮ್ಮತ. ಸರಿಯಾದ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಗುರುತಿಸುವ ಕೋಡ್ [Tags ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) ನಲ್ಲಿ ಇದೆ.
ಕೊನೆಯ ಹಂತವು ಈ ಟ್ಯಾಗ್‌ಗಳಿಗಾಗಿ ಹೊಸ ಕಾಲಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು. ನಂತರ, ಪ್ರತಿಯೊಂದು ವಿಮರ್ಶೆ ಸಾಲಿಗೆ, `Tag` ಕಾಲಮ್ ಹೊಸ ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಒಂದೊಂದರೊಂದಿಗೆ ಹೊಂದಿದರೆ, 1 ಸೇರಿಸಿ, ಇಲ್ಲದಿದ್ದರೆ 0 ಸೇರಿಸಿ. ಅಂತಿಮ ಫಲಿತಾಂಶವು ಎಷ್ಟು ವಿಮರ್ಶಕರು ಈ ಹೋಟೆಲ್ ಆಯ್ಕೆಮಾಡಿದ್ದಾರೆ ಎಂಬ ಎಣಿಕೆ ಆಗಿರುತ್ತದೆ, ಉದಾ: ವ್ಯವಹಾರ ಅಥವಾ ವಿಶ್ರಾಂತಿ, ಅಥವಾ ಪಶುಪಾಲನೆಗಾಗಿ, ಮತ್ತು ಇದು ಹೋಟೆಲ್ ಶಿಫಾರಸು ಮಾಡುವಾಗ ಉಪಯುಕ್ತ ಮಾಹಿತಿ.
```python
# ಟ್ಯಾಗ್‌ಗಳನ್ನು ಹೊಸ ಕಾಲಮ್ಗಳಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
# Hotel_Reviews_Tags.py ಫೈಲ್, ಅತ್ಯಂತ ಪ್ರಮುಖ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ
# ವಿಶ್ರಾಂತಿ ಪ್ರವಾಸ, ಜೋಡಿ, ಏಕಾಂಗ ಪ್ರವಾಸಿ, ವ್ಯವಹಾರಿಕ ಪ್ರವಾಸ, ಸ್ನೇಹಿತರೊಂದಿಗೆ ಪ್ರಯಾಣಿಕರೊಂದಿಗೆ ಗುಂಪು
# ಯುವ ಮಕ್ಕಳೊಂದಿಗೆ ಕುಟುಂಬ, ಹಿರಿಯ ಮಕ್ಕಳೊಂದಿಗೆ ಕುಟುಂಬ, ಪಶುವೊಂದರೊಂದಿಗೆ
df["Leisure_trip"] = df.Tags.apply(lambda tag: 1 if "Leisure trip" in tag else 0)
df["Couple"] = df.Tags.apply(lambda tag: 1 if "Couple" in tag else 0)
df["Solo_traveler"] = df.Tags.apply(lambda tag: 1 if "Solo traveler" in tag else 0)
df["Business_trip"] = df.Tags.apply(lambda tag: 1 if "Business trip" in tag else 0)
df["Group"] = df.Tags.apply(lambda tag: 1 if "Group" in tag or "Travelers with friends" in tag else 0)
df["Family_with_young_children"] = df.Tags.apply(lambda tag: 1 if "Family with young children" in tag else 0)
df["Family_with_older_children"] = df.Tags.apply(lambda tag: 1 if "Family with older children" in tag else 0)
df["With_a_pet"] = df.Tags.apply(lambda tag: 1 if "With a pet" in tag else 0)
```
### ನಿಮ್ಮ ಫೈಲ್ ಉಳಿಸಿ
ಕೊನೆಗೆ, ಡೇಟಾಸೆಟ್ ಅನ್ನು ಈಗಿನ ಸ್ಥಿತಿಯಲ್ಲಿ ಹೊಸ ಹೆಸರಿನಿಂದ ಉಳಿಸಿ.
```python
df.drop(["Review_Total_Negative_Word_Counts", "Review_Total_Positive_Word_Counts", "days_since_review", "Total_Number_of_Reviews_Reviewer_Has_Given"], axis = 1, inplace=True)
# ಲೆಕ್ಕ ಹಾಕಲಾದ ಕಾಲಮ್‌ಗಳೊಂದಿಗೆ ಹೊಸ ಡೇಟಾ ಫೈಲ್ ಉಳಿಸಲಾಗುತ್ತಿದೆ
print("Saving results to Hotel_Reviews_Filtered.csv")
df.to_csv(r'../data/Hotel_Reviews_Filtered.csv', index = False)
```
## ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ ಕಾರ್ಯಾಚರಣೆಗಳು
ಈ ಕೊನೆಯ ವಿಭಾಗದಲ್ಲಿ, ನೀವು ವಿಮರ್ಶೆ ಕಾಲಮ್‌ಗಳಿಗೆ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಅನ್ವಯಿಸಿ ಫಲಿತಾಂಶಗಳನ್ನು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಉಳಿಸುವಿರಿ.
## ವ್ಯಾಯಾಮ: ಫಿಲ್ಟರ್ ಮಾಡಿದ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಉಳಿಸಿ
ಈಗ ನೀವು ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಉಳಿಸಿದ ಫಿಲ್ಟರ್ ಮಾಡಿದ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತಿದ್ದೀರಿ, **ಮೂಲ ಡೇಟಾಸೆಟ್ ಅಲ್ಲ**.
```python
import time
import pandas as pd
import nltk as nltk
from nltk.corpus import stopwords
from nltk.sentiment.vader import SentimentIntensityAnalyzer
nltk.download('vader_lexicon')
# CSV ನಿಂದ ಫಿಲ್ಟರ್ ಮಾಡಲಾದ ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ
df = pd.read_csv('../../data/Hotel_Reviews_Filtered.csv')
# ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಇಲ್ಲಿ ಸೇರಿಸಲಾಗುವುದು
# ಕೊನೆಗೆ ಹೊಸ NLP ಡೇಟಾ ಸೇರಿಸಿದ ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳನ್ನು ಉಳಿಸಲು ಮರೆಯಬೇಡಿ
print("Saving results to Hotel_Reviews_NLP.csv")
df.to_csv(r'../data/Hotel_Reviews_NLP.csv', index = False)
```
### ನಿಲ್ಲಿಸುವ ಪದಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು
ನೀವು ನೆಗೆಟಿವ್ ಮತ್ತು ಪಾಸಿಟಿವ್ ವಿಮರ್ಶೆ ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ ನಡೆಸಿದರೆ, ಅದು ಬಹಳ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಶಕ್ತಿಶಾಲಿ ಟೆಸ್ಟ್ ಲ್ಯಾಪ್‌ಟಾಪ್‌ನಲ್ಲಿ ವೇಗವಾದ CPU ಇದ್ದು, 12 - 14 ನಿಮಿಷಗಳವರೆಗೆ ತೆಗೆದುಕೊಂಡಿತು, ಯಾವ ಭಾವನೆ ಗ್ರಂಥಾಲಯ ಬಳಸಿದೆಯೋ ಅವನ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಇದು (ಸಾಪೇಕ್ಷವಾಗಿ) ದೀರ್ಘ ಸಮಯ, ಆದ್ದರಿಂದ ಅದನ್ನು ವೇಗಗೊಳಿಸಲು ಸಾಧ್ಯವಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು ಸೂಕ್ತ.
ನಿಲ್ಲಿಸುವ ಪದಗಳು ಅಥವಾ ಸಾಮಾನ್ಯ ಇಂಗ್ಲಿಷ್ ಪದಗಳು, ಅವು ವಾಕ್ಯದ ಭಾವನೆಯನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ, ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಮೊದಲ ಹಂತ. ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದರಿಂದ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ ವೇಗವಾಗಿ ನಡೆಯುತ್ತದೆ, ಆದರೆ ಕಡಿಮೆ ನಿಖರವಾಗುವುದಿಲ್ಲ (ನಿಲ್ಲಿಸುವ ಪದಗಳು ಭಾವನೆಗೆ ಪ್ರಭಾವ ಬೀರುವುದಿಲ್ಲ, ಆದರೆ ವಿಶ್ಲೇಷಣೆಯನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತವೆ).
ಅತ್ಯಂತ ದೀರ್ಘ ನೆಗೆಟಿವ್ ವಿಮರ್ಶೆ 395 ಪದಗಳಿತ್ತು, ಆದರೆ ನಿಲ್ಲಿಸುವ ಪದಗಳನ್ನು ತೆಗೆದುಹಾಕಿದ ನಂತರ ಅದು 195 ಪದಗಳಾಗಿದೆ.
ನಿಲ್ಲಿಸುವ ಪದಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಕೂಡ ವೇಗವಾದ ಕಾರ್ಯ, 2 ವಿಮರ್ಶೆ ಕಾಲಮ್‌ಗಳಿಂದ 515,000 ಸಾಲುಗಳಲ್ಲಿ 3.3 ಸೆಕೆಂಡುಗಳಲ್ಲಿ ತೆಗೆದುಕೊಂಡಿತು. ನಿಮ್ಮ ಸಾಧನದ CPU ವೇಗ, RAM, SSD ಇದ್ದೇ ಇಲ್ಲ, ಮತ್ತು ಇತರ ಕೆಲವು ಅಂಶಗಳ ಮೇಲೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಕಾರ್ಯದ ಸಾಪೇಕ್ಷ ಸಣ್ಣತೆ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಯ ಸಮಯವನ್ನು ಸುಧಾರಿಸಿದರೆ, ಅದನ್ನು ಮಾಡುವುದು ಲಾಭದಾಯಕ.
```python
from nltk.corpus import stopwords
# CSV ನಿಂದ ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ
df = pd.read_csv("../../data/Hotel_Reviews_Filtered.csv")
# ಸ್ಟಾಪ್ ಪದಗಳನ್ನು ತೆಗೆದುಹಾಕಿ - ಹೆಚ್ಚಿನ ಪಠ್ಯಕ್ಕೆ ಇದು ನಿಧಾನವಾಗಬಹುದು!
# ರಯಾನ್ ಹ್ಯಾನ್ (Kaggle ನಲ್ಲಿ ryanxjhan) ವಿವಿಧ ಸ್ಟಾಪ್ ಪದಗಳ ತೆಗೆದುಹಾಕುವ ವಿಧಾನಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಳೆಯುವ ಉತ್ತಮ ಪೋಸ್ಟ್ ಹೊಂದಿದ್ದಾರೆ
# https://www.kaggle.com/ryanxjhan/fast-stop-words-removal # ರಯಾನ್ ಶಿಫಾರಸು ಮಾಡುವ ವಿಧಾನವನ್ನು ಬಳಸುವುದು
start = time.time()
cache = set(stopwords.words("english"))
def remove_stopwords(review):
text = " ".join([word for word in review.split() if word not in cache])
return text
# ಎರಡೂ ಕಾಲಮ್‌ಗಳಿಂದ ಸ್ಟಾಪ್ ಪದಗಳನ್ನು ತೆಗೆದುಹಾಕಿ
df.Negative_Review = df.Negative_Review.apply(remove_stopwords)
df.Positive_Review = df.Positive_Review.apply(remove_stopwords)
```
### ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ ನಡೆಸುವುದು
ಈಗ ನೀವು ನೆಗೆಟಿವ್ ಮತ್ತು ಪಾಸಿಟಿವ್ ವಿಮರ್ಶೆ ಕಾಲಮ್‌ಗಳಿಗೆ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಲೆಕ್ಕಿಸಿ, 2 ಹೊಸ ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು. ಭಾವನೆ ಪರೀಕ್ಷೆ ವಿಮರ್ಶಕರ ಅಂಕದೊಂದಿಗೆ ಹೋಲಿಕೆ ಮಾಡುವುದು. ಉದಾಹರಣೆಗೆ, ಭಾವನೆ ವಿಶ್ಲೇಷಕನು ನೆಗೆಟಿವ್ ವಿಮರ್ಶೆಗೆ 1 (ಅತ್ಯಂತ ಧನಾತ್ಮಕ ಭಾವನೆ) ಮತ್ತು ಪಾಸಿಟಿವ್ ವಿಮರ್ಶೆಗೆ 1 ಎಂದು ಅಂದಾಜಿಸಿದರೆ, ಆದರೆ ವಿಮರ್ಶಕನು ಹೋಟೆಲ್‌ಗೆ ಕನಿಷ್ಠ ಅಂಕ ನೀಡಿದ್ದರೆ, ವಿಮರ್ಶೆ ಪಠ್ಯ ಮತ್ತು ಅಂಕ ಹೊಂದಿಕೆಯಾಗುತ್ತಿಲ್ಲ ಅಥವಾ ಭಾವನೆ ವಿಶ್ಲೇಷಕನು ಭಾವನೆಯನ್ನು ಸರಿಯಾಗಿ ಗುರುತಿಸಲಿಲ್ಲ. ಕೆಲವು ಭಾವನೆ ಅಂಕಗಳು ಸಂಪೂರ್ಣ ತಪ್ಪಾಗಿರಬಹುದು, ಮತ್ತು ಬಹುಶಃ ಅದು ವಿವರಿಸಬಹುದಾಗಿದೆ, ಉದಾ: ವಿಮರ್ಶೆ ಅತ್ಯಂತ ವ್ಯಂಗ್ಯಾತ್ಮಕವಾಗಿರಬಹುದು "ನಾನು ಬಿಸಿಲಿಲ್ಲದ ಕೊಠಡಿಯಲ್ಲಿ ನಿದ್ರೆ ಮಾಡಿದ್ದೇನೆ ಎಂದು ಖಂಡಿತವಾಗಿ ಪ್ರೀತಿಸಿದೆ" ಮತ್ತು ಭಾವನೆ ವಿಶ್ಲೇಷಕನು ಅದನ್ನು ಧನಾತ್ಮಕ ಭಾವನೆ ಎಂದು ಭಾವಿಸುತ್ತದೆ, ಆದರೆ ಮಾನವ ಓದಿದರೆ ಅದು ವ್ಯಂಗ್ಯ ಎಂದು ತಿಳಿಯುತ್ತದೆ.
NLTK ವಿಭಿನ್ನ ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಕರನ್ನು ಕಲಿಯಲು ಒದಗಿಸುತ್ತದೆ, ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಿ ಭಾವನೆ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ನಿಖರವಾಗಿದೆಯೇ ಎಂದು ನೋಡಬಹುದು. ಇಲ್ಲಿ VADER ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ ಬಳಸಲಾಗಿದೆ.
> Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
```python
from nltk.sentiment.vader import SentimentIntensityAnalyzer
# ವಾಡರ್ ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಕವನ್ನು ರಚಿಸಿ (ನೀವು ಪ್ರಯತ್ನಿಸಬಹುದಾದ NLTK ನಲ್ಲಿ ಇತರರೂ ಇದ್ದಾರೆ)
vader_sentiment = SentimentIntensityAnalyzer()
# ಹುಟ್ಟೋ, ಸಿ.ಜೆ. & ಗಿಲ್ಬರ್ಟ್, ಇ.ಇ. (2014). ವಾಡರ್: ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ಪಠ್ಯದ ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆಗೆ ನಿಯಮಾಧಾರಿತ ಸರಳ ಮಾದರಿ. ಎಂಟನೇ ಅಂತಾರಾಷ್ಟ್ರೀಯ ವೆಬ್ಲಾಗ್ ಮತ್ತು ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ಸಮ್ಮೇಳನ (ICWSM-14). ಆನ್ ಅರ್ಬರ್, MI, ಜೂನ್ 2014.
# ವಿಮರ್ಶೆಗೆ 3 ಇನ್ಪುಟ್ ಸಾಧ್ಯತೆಗಳಿವೆ:
# ಅದು "ನಕಾರಾತ್ಮಕವಿಲ್ಲ" ಆಗಿರಬಹುದು, ಆ ಸಂದರ್ಭದಲ್ಲಿ 0 ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ
# ಅದು "ಧನಾತ್ಮಕವಿಲ್ಲ" ಆಗಿರಬಹುದು, ಆ ಸಂದರ್ಭದಲ್ಲಿ 0 ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ
# ಅದು ವಿಮರ್ಶೆಯಾಗಿರಬಹುದು, ಆ ಸಂದರ್ಭದಲ್ಲಿ ಭಾವನೆಯನ್ನು ಲೆಕ್ಕಿಸಿ
def calc_sentiment(review):
if review == "No Negative" or review == "No Positive":
return 0
return vader_sentiment.polarity_scores(review)["compound"]
```
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಂತರ ನೀವು ಭಾವನೆಯನ್ನು ಲೆಕ್ಕಹಾಕಲು ಸಿದ್ಧರಾಗಿದ್ದಾಗ, ನೀವು ಪ್ರತಿಯೊಂದು ವಿಮರ್ಶೆಗೆ ಇದನ್ನು ಹೀಗೆ ಅನ್ವಯಿಸಬಹುದು:
```python
# ನಕಾರಾತ್ಮಕ ಭಾವನೆ ಮತ್ತು ಧನಾತ್ಮಕ ಭಾವನೆ ಕಾಲಮ್ ಸೇರಿಸಿ
print("Calculating sentiment columns for both positive and negative reviews")
start = time.time()
df["Negative_Sentiment"] = df.Negative_Review.apply(calc_sentiment)
df["Positive_Sentiment"] = df.Positive_Review.apply(calc_sentiment)
end = time.time()
print("Calculating sentiment took " + str(round(end - start, 2)) + " seconds")
```
ಇದು ನನ್ನ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಸುಮಾರು 120 ಸೆಕೆಂಡುಗಳು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಪ್ರತಿ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಇದು ಬದಲಾಗಬಹುದು. ನೀವು ಫಲಿತಾಂಶಗಳನ್ನು ಮುದ್ರಿಸಿ ಭಾವನೆ ವಿಮರ್ಶೆಗೆ ಹೊಂದಿಕೆಯಾಗಿದೆಯೇ ಎಂದು ನೋಡಲು ಬಯಸಿದರೆ:
```python
df = df.sort_values(by=["Negative_Sentiment"], ascending=True)
print(df[["Negative_Review", "Negative_Sentiment"]])
df = df.sort_values(by=["Positive_Sentiment"], ascending=True)
print(df[["Positive_Review", "Positive_Sentiment"]])
```
ಚಾಲೆಂಜ್‌ನಲ್ಲಿ ಬಳಸುವ ಮೊದಲು ಫೈಲ್‌ನೊಂದಿಗೆ ಮಾಡಬೇಕಾದ ಕೊನೆಯ ಕೆಲಸ, ಅದನ್ನು ಉಳಿಸುವುದು! ನೀವು ನಿಮ್ಮ ಎಲ್ಲಾ ಹೊಸ ಕಾಲಮ್‌ಗಳನ್ನು ಮರುಕ್ರಮಗೊಳಿಸುವುದನ್ನು ಪರಿಗಣಿಸಬೇಕು, ಇದರಿಂದ ಅವುಗಳನ್ನು ಕೆಲಸ ಮಾಡಲು ಸುಲಭವಾಗುತ್ತದೆ (ಮಾನವನಿಗೆ ಇದು ಒಂದು ಸೌಂದರ್ಯ ಬದಲಾವಣೆ).
```python
# ಕಾಲಮ್ಗಳನ್ನು ಮರುಕ್ರಮಗೊಳಿಸಿ (ಇದು ಸೌಂದರ್ಯಕ್ಕಾಗಿ, ಆದರೆ ನಂತರ ಡೇಟಾವನ್ನು ಅನ್ವೇಷಿಸಲು ಸುಲಭವಾಗಿಸಲು)
df = df.reindex(["Hotel_Name", "Hotel_Address", "Total_Number_of_Reviews", "Average_Score", "Reviewer_Score", "Negative_Sentiment", "Positive_Sentiment", "Reviewer_Nationality", "Leisure_trip", "Couple", "Solo_traveler", "Business_trip", "Group", "Family_with_young_children", "Family_with_older_children", "With_a_pet", "Negative_Review", "Positive_Review"], axis=1)
print("Saving results to Hotel_Reviews_NLP.csv")
df.to_csv(r"../data/Hotel_Reviews_NLP.csv", index = False)
```
ನೀವು ಸಂಪೂರ್ಣ ಕೋಡ್ ಅನ್ನು [ವಿಶ್ಲೇಷಣಾ ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb)ಗಾಗಿ ಚಲಾಯಿಸಬೇಕು (ನೀವು [ನಿಮ್ಮ ಫಿಲ್ಟರಿಂಗ್ ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) ಅನ್ನು ಚಲಾಯಿಸಿ Hotel_Reviews_Filtered.csv ಫೈಲ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ).
ಪುನಃ ಪರಿಶೀಲಿಸಲು, ಹಂತಗಳು ಇವು:
1. ಮೂಲ ಡೇಟಾಸೆಟ್ ಫೈಲ್ **Hotel_Reviews.csv** ಅನ್ನು ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ [ಎಕ್ಸ್‌ಪ್ಲೋರರ್ ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb) ಮೂಲಕ ಅನ್ವೇಷಿಸಲಾಗಿದೆ
2. Hotel_Reviews.csv ಅನ್ನು [ಫಿಲ್ಟರಿಂಗ್ ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡಿ **Hotel_Reviews_Filtered.csv** ಅನ್ನು ಪಡೆದಿದ್ದಾರೆ
3. Hotel_Reviews_Filtered.csv ಅನ್ನು [ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣಾ ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) ಮೂಲಕ ಪ್ರಕ್ರಿಯೆ ಮಾಡಿ **Hotel_Reviews_NLP.csv** ಅನ್ನು ಪಡೆದಿದ್ದಾರೆ
4. ಕೆಳಗಿನ NLP ಚಾಲೆಂಜ್‌ನಲ್ಲಿ Hotel_Reviews_NLP.csv ಅನ್ನು ಬಳಸಿ
### ಸಮಾರೋಪ
ನೀವು ಪ್ರಾರಂಭಿಸಿದಾಗ, ನಿಮಗೆ ಕಾಲಮ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ಇರುವ ಡೇಟಾಸೆಟ್ ಇತ್ತು ಆದರೆ ಅದರಲ್ಲಿ ಎಲ್ಲವೂ ಪರಿಶೀಲಿಸಲಾಗಲಿಲ್ಲ ಅಥವಾ ಬಳಸಲಾಗಲಿಲ್ಲ. ನೀವು ಡೇಟಾವನ್ನು ಅನ್ವೇಷಿಸಿ, ಬೇಕಾಗದವನ್ನೆಲ್ಲಾ ಫಿಲ್ಟರ್ ಮಾಡಿ, ಟ್ಯಾಗ್‌ಗಳನ್ನು ಉಪಯುಕ್ತವಾದುದಾಗಿ ಪರಿವರ್ತಿಸಿ, ನಿಮ್ಮ ಸ್ವಂತ ಸರಾಸರಿಗಳನ್ನು ಲೆಕ್ಕಹಾಕಿ, ಕೆಲವು ಭಾವನಾತ್ಮಕ ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಸಹಜ ಪಠ್ಯವನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡುವ ಬಗ್ಗೆ ಕೆಲವು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯಗಳನ್ನು ಕಲಿತಿದ್ದೀರಿ.
## [ಪಾಠೋತ್ತರ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ಚಾಲೆಂಜ್
ನೀವು ಈಗ ನಿಮ್ಮ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಭಾವನೆಗಾಗಿ ವಿಶ್ಲೇಷಿಸಿದ್ದೀರಿ, ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ನೀವು ಕಲಿತ ತಂತ್ರಗಳನ್ನು (ಶ್ರೇಣೀಕರಣ, ಬಹುಶಃ?) ಬಳಸಿಕೊಂಡು ಭಾವನೆಯ ಸುತ್ತಲೂ ಮಾದರಿಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಪ್ರಯತ್ನಿಸಿ.
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
[ಈ ಲರ್ನ್ ಮೋಡ್ಯೂಲ್](https://docs.microsoft.com/en-us/learn/modules/classify-user-feedback-with-the-text-analytics-api/?WT.mc_id=academic-77952-leestott) ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ ಮತ್ತು ಪಠ್ಯದಲ್ಲಿ ಭಾವನೆಯನ್ನು ಅನ್ವೇಷಿಸಲು ವಿಭಿನ್ನ ಸಾಧನಗಳನ್ನು ಬಳಸಿ.
## ನಿಯೋಜನೆ
[ಬೇರೊಂದು ಡೇಟಾಸೆಟ್ ಪ್ರಯತ್ನಿಸಿ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/kn/6-NLP/5-Hotel-Reviews-2/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "daf144daa552da6a7d442aff6f3e77d8",
"translation_date": "2025-12-19T14:46:09+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/assignment.md",
"language_code": "kn"
}
-->
# ಬೇರೆ ಡೇಟಾಸೆಟ್ ಪ್ರಯತ್ನಿಸಿ
## ಸೂಚನೆಗಳು
ನೀವು ಈಗಾಗಲೇ ಪಠ್ಯಕ್ಕೆ ಭಾವನೆಯನ್ನು ನಿಯೋಜಿಸಲು NLTK ಬಳಸದ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ, ಈಗ ಬೇರೆ ಡೇಟಾಸೆಟ್ ಪ್ರಯತ್ನಿಸಿ. ನೀವು ಅದಕ್ಕೆ ಸುತ್ತಲೂ ಕೆಲವು ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಿಕೆ ಮಾಡಬೇಕಾಗಬಹುದು, ಆದ್ದರಿಂದ ಒಂದು ನೋಟ್ಬುಕ್ ರಚಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಚಿಂತನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ದಾಖಲೆ ಮಾಡಿ. ನೀವು ಏನು ಕಂಡುಹಿಡಿಯುತ್ತೀರಿ?
## ಮೌಲ್ಯಮಾಪನ
| ಮಾನದಂಡಗಳು | ಉದಾಹರಣೀಯ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆಗೆ ಅಗತ್ಯ |
| -------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------- |
| | ಭಾವನೆ ಹೇಗೆ ನಿಯೋಜಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುವ ಚೆನ್ನಾಗಿ ದಾಖಲೆ ಮಾಡಲಾದ ಸೆಲ್‌ಗಳೊಂದಿಗೆ ಸಂಪೂರ್ಣ ನೋಟ್ಬುಕ್ ಮತ್ತು ಡೇಟಾಸೆಟ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ | ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಉತ್ತಮ ವಿವರಣೆಗಳಿಲ್ಲ | ನೋಟ್ಬುಕ್ ದೋಷಪೂರಿತವಾಗಿದೆ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

0
translations/kn/6-NLP/5-Hotel-Reviews-2/notebook.ipynb
Unescape View File

172
translations/kn/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb
Unescape View File

@ -0,0 +1,172 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"orig_nbformat": 4,
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"coopTranslator": {
"original_hash": "033cb89c85500224b3c63fd04f49b4aa",
"translation_date": "2025-12-19T16:49:43+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import time\n",
"import ast"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def replace_address(row):\n",
" if \"Netherlands\" in row[\"Hotel_Address\"]:\n",
" return \"Amsterdam, Netherlands\"\n",
" elif \"Barcelona\" in row[\"Hotel_Address\"]:\n",
" return \"Barcelona, Spain\"\n",
" elif \"United Kingdom\" in row[\"Hotel_Address\"]:\n",
" return \"London, United Kingdom\"\n",
" elif \"Milan\" in row[\"Hotel_Address\"]: \n",
" return \"Milan, Italy\"\n",
" elif \"France\" in row[\"Hotel_Address\"]:\n",
" return \"Paris, France\"\n",
" elif \"Vienna\" in row[\"Hotel_Address\"]:\n",
" return \"Vienna, Austria\" \n",
" else:\n",
" return row.Hotel_Address\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Load the hotel reviews from CSV\n",
"start = time.time()\n",
"df = pd.read_csv('../../data/Hotel_Reviews.csv')\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# dropping columns we will not use:\n",
"df.drop([\"lat\", \"lng\"], axis = 1, inplace=True)\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Replace all the addresses with a shortened, more useful form\n",
"df[\"Hotel_Address\"] = df.apply(replace_address, axis = 1)\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# Drop `Additional_Number_of_Scoring`\n",
"df.drop([\"Additional_Number_of_Scoring\"], axis = 1, inplace=True)\n",
"# Replace `Total_Number_of_Reviews` and `Average_Score` with our own calculated values\n",
"df.Total_Number_of_Reviews = df.groupby('Hotel_Name').transform('count')\n",
"df.Average_Score = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# Process the Tags into new columns\n",
"# The file Hotel_Reviews_Tags.py, identifies the most important tags\n",
"# Leisure trip, Couple, Solo traveler, Business trip, Group combined with Travelers with friends, \n",
"# Family with young children, Family with older children, With a pet\n",
"df[\"Leisure_trip\"] = df.Tags.apply(lambda tag: 1 if \"Leisure trip\" in tag else 0)\n",
"df[\"Couple\"] = df.Tags.apply(lambda tag: 1 if \"Couple\" in tag else 0)\n",
"df[\"Solo_traveler\"] = df.Tags.apply(lambda tag: 1 if \"Solo traveler\" in tag else 0)\n",
"df[\"Business_trip\"] = df.Tags.apply(lambda tag: 1 if \"Business trip\" in tag else 0)\n",
"df[\"Group\"] = df.Tags.apply(lambda tag: 1 if \"Group\" in tag or \"Travelers with friends\" in tag else 0)\n",
"df[\"Family_with_young_children\"] = df.Tags.apply(lambda tag: 1 if \"Family with young children\" in tag else 0)\n",
"df[\"Family_with_older_children\"] = df.Tags.apply(lambda tag: 1 if \"Family with older children\" in tag else 0)\n",
"df[\"With_a_pet\"] = df.Tags.apply(lambda tag: 1 if \"With a pet\" in tag else 0)\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# No longer need any of these columns\n",
"df.drop([\"Review_Date\", \"Review_Total_Negative_Word_Counts\", \"Review_Total_Positive_Word_Counts\", \"days_since_review\", \"Total_Number_of_Reviews_Reviewer_Has_Given\"], axis = 1, inplace=True)\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Saving results to Hotel_Reviews_Filtered.csv\n",
"Filtering took 23.74 seconds\n"
]
}
],
"source": [
"# Saving new data file with calculated columns\n",
"print(\"Saving results to Hotel_Reviews_Filtered.csv\")\n",
"df.to_csv(r'../../data/Hotel_Reviews_Filtered.csv', index = False)\n",
"end = time.time()\n",
"print(\"Filtering took \" + str(round(end - start, 2)) + \" seconds\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

137
translations/kn/6-NLP/5-Hotel-Reviews-2/solution/2-notebook.ipynb
Unescape View File

@ -0,0 +1,137 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"orig_nbformat": 4,
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"coopTranslator": {
"original_hash": "341efc86325ec2a214f682f57a189dfd",
"translation_date": "2025-12-19T16:49:54+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/2-notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# Load the hotel reviews from CSV (you can )\n",
"import pandas as pd \n",
"\n",
"df = pd.read_csv('../../data/Hotel_Reviews_Filtered.csv')\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# We want to find the most useful tags to keep\n",
"# Remove opening and closing brackets\n",
"df.Tags = df.Tags.str.strip(\"[']\")\n",
"# remove all quotes too\n",
"df.Tags = df.Tags.str.replace(\" ', '\", \",\", regex = False)\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# removing this to take advantage of the 'already a phrase' fact of the dataset \n",
"# Now split the strings into a list\n",
"tag_list_df = df.Tags.str.split(',', expand = True)\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# Remove leading and trailing spaces\n",
"df[\"Tag_1\"] = tag_list_df[0].str.strip()\n",
"df[\"Tag_2\"] = tag_list_df[1].str.strip()\n",
"df[\"Tag_3\"] = tag_list_df[2].str.strip()\n",
"df[\"Tag_4\"] = tag_list_df[3].str.strip()\n",
"df[\"Tag_5\"] = tag_list_df[4].str.strip()\n",
"df[\"Tag_6\"] = tag_list_df[5].str.strip()\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# Merge the 6 columns into one with melt\n",
"df_tags = df.melt(value_vars=[\"Tag_1\", \"Tag_2\", \"Tag_3\", \"Tag_4\", \"Tag_5\", \"Tag_6\"])\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"The shape of the tags with no filtering: (2514684, 2)\n",
" index count\n",
"0 Leisure trip 338423\n",
"1 Couple 205305\n",
"2 Solo traveler 89779\n",
"3 Business trip 68176\n",
"4 Group 51593\n",
"5 Family with young children 49318\n",
"6 Family with older children 21509\n",
"7 Travelers with friends 1610\n",
"8 With a pet 1078\n"
]
}
],
"source": [
"# Get the value counts\n",
"tag_vc = df_tags.value.value_counts()\n",
"# print(tag_vc)\n",
"print(\"The shape of the tags with no filtering:\", str(df_tags.shape))\n",
"# Drop rooms, suites, and length of stay, mobile device and anything with less count than a 1000\n",
"df_tags = df_tags[~df_tags.value.str.contains(\"Standard|room|Stayed|device|Beds|Suite|Studio|King|Superior|Double\", na=False, case=False)]\n",
"tag_vc = df_tags.value.value_counts().reset_index(name=\"count\").query(\"count > 1000\")\n",
"# Print the top 10 (there should only be 9 and we'll use these in the filtering section)\n",
"print(tag_vc[:10])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**: \nಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
]
}

260
translations/kn/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb
Unescape View File

@ -0,0 +1,260 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"orig_nbformat": 4,
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"coopTranslator": {
"original_hash": "705bf02633759f689abc37b19749a16d",
"translation_date": "2025-12-19T16:50:06+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"[nltk_data] Downloading package vader_lexicon to\n[nltk_data] /Users/jenlooper/nltk_data...\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
"True"
]
},
"metadata": {},
"execution_count": 9
}
],
"source": [
"import time\n",
"import pandas as pd\n",
"import nltk as nltk\n",
"from nltk.corpus import stopwords\n",
"from nltk.sentiment.vader import SentimentIntensityAnalyzer\n",
"nltk.download('vader_lexicon')\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"vader_sentiment = SentimentIntensityAnalyzer()\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"# There are 3 possibilities of input for a review:\n",
"# It could be \"No Negative\", in which case, return 0\n",
"# It could be \"No Positive\", in which case, return 0\n",
"# It could be a review, in which case calculate the sentiment\n",
"def calc_sentiment(review): \n",
" if review == \"No Negative\" or review == \"No Positive\":\n",
" return 0\n",
" return vader_sentiment.polarity_scores(review)[\"compound\"] \n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# Load the hotel reviews from CSV\n",
"df = pd.read_csv(\"../../data/Hotel_Reviews_Filtered.csv\")\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"# Remove stop words - can be slow for a lot of text!\n",
"# Ryan Han (ryanxjhan on Kaggle) has a great post measuring performance of different stop words removal approaches\n",
"# https://www.kaggle.com/ryanxjhan/fast-stop-words-removal # using the approach that Ryan recommends\n",
"start = time.time()\n",
"cache = set(stopwords.words(\"english\"))\n",
"def remove_stopwords(review):\n",
" text = \" \".join([word for word in review.split() if word not in cache])\n",
" return text\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"# Remove the stop words from both columns\n",
"df.Negative_Review = df.Negative_Review.apply(remove_stopwords) \n",
"df.Positive_Review = df.Positive_Review.apply(remove_stopwords)\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Removing stop words took 5.77 seconds\n"
]
}
],
"source": [
"end = time.time()\n",
"print(\"Removing stop words took \" + str(round(end - start, 2)) + \" seconds\")\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Calculating sentiment columns for both positive and negative reviews\n",
"Calculating sentiment took 201.07 seconds\n"
]
}
],
"source": [
"# Add a negative sentiment and positive sentiment column\n",
"print(\"Calculating sentiment columns for both positive and negative reviews\")\n",
"start = time.time()\n",
"df[\"Negative_Sentiment\"] = df.Negative_Review.apply(calc_sentiment)\n",
"df[\"Positive_Sentiment\"] = df.Positive_Review.apply(calc_sentiment)\n",
"end = time.time()\n",
"print(\"Calculating sentiment took \" + str(round(end - start, 2)) + \" seconds\")\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" Negative_Review Negative_Sentiment\n",
"186584 So bad experience memories I hotel The first n... -0.9920\n",
"129503 First charged twice room booked booking second... -0.9896\n",
"307286 The staff Had bad experience even booking Janu... -0.9889\n",
"452092 No WLAN room Incredibly rude restaurant staff ... -0.9884\n",
"201293 We usually traveling Paris 2 3 times year busi... -0.9873\n",
"... ... ...\n",
"26899 I would say however one night expensive even d... 0.9933\n",
"138365 Wifi terribly slow I speed test network upload... 0.9938\n",
"79215 I find anything hotel first I walked past hote... 0.9938\n",
"278506 The property great location There bakery next ... 0.9945\n",
"339189 Guys I like hotel I wish return next year Howe... 0.9948\n",
"\n",
"[515738 rows x 2 columns]\n",
" Positive_Review Positive_Sentiment\n",
"137893 Bathroom Shower We going stay twice hotel 2 ni... -0.9820\n",
"5839 I completely disappointed mad since reception ... -0.9780\n",
"64158 get everything extra internet parking breakfas... -0.9751\n",
"124178 I didnt like anythig Room small Asked upgrade ... -0.9721\n",
"489137 Very rude manager abusive staff reception Dirt... -0.9703\n",
"... ... ...\n",
"331570 Everything This recently renovated hotel class... 0.9984\n",
"322920 From moment stepped doors Guesthouse Hotel sta... 0.9985\n",
"293710 This place surprise expected good actually gre... 0.9985\n",
"417442 We celebrated wedding night Langham I commend ... 0.9985\n",
"132492 We arrived super cute boutique hotel area expl... 0.9987\n",
"\n",
"[515738 rows x 2 columns]\n"
]
}
],
"source": [
"df = df.sort_values(by=[\"Negative_Sentiment\"], ascending=True)\n",
"print(df[[\"Negative_Review\", \"Negative_Sentiment\"]])\n",
"df = df.sort_values(by=[\"Positive_Sentiment\"], ascending=True)\n",
"print(df[[\"Positive_Review\", \"Positive_Sentiment\"]])\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"# Reorder the columns (This is cosmetic, but to make it easier to explore the data later)\n",
"df = df.reindex([\"Hotel_Name\", \"Hotel_Address\", \"Total_Number_of_Reviews\", \"Average_Score\", \"Reviewer_Score\", \"Negative_Sentiment\", \"Positive_Sentiment\", \"Reviewer_Nationality\", \"Leisure_trip\", \"Couple\", \"Solo_traveler\", \"Business_trip\", \"Group\", \"Family_with_young_children\", \"Family_with_older_children\", \"With_a_pet\", \"Negative_Review\", \"Positive_Review\"], axis=1)\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Saving results to Hotel_Reviews_NLP.csv\n"
]
}
],
"source": [
"print(\"Saving results to Hotel_Reviews_NLP.csv\")\n",
"df.to_csv(r\"../../data/Hotel_Reviews_NLP.csv\", index = False)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

17
translations/kn/6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:48:53+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/6-NLP/5-Hotel-Reviews-2/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T14:49:25+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/R/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

40
translations/kn/6-NLP/README.md
Unescape View File

@ -0,0 +1,40 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1eb379dc2d0c9940b320732d16083778",
"translation_date": "2025-12-19T13:03:21+00:00",
"source_file": "6-NLP/README.md",
"language_code": "kn"
}
-->
# ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ ಆರಂಭಿಸುವುದು
ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ (NLP) ಎಂದರೆ ಮಾನವ ಭಾಷೆಯನ್ನು ಮಾತನಾಡುವ ಮತ್ತು ಬರೆಯುವ ರೀತಿಯಲ್ಲಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಕಂಪ್ಯೂಟರ್ ಪ್ರೋಗ್ರಾಮಿನ ಸಾಮರ್ಥ್ಯ. ಇದನ್ನು ನೈಸರ್ಗಿಕ ಭಾಷೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯ (AI) ಒಂದು ಘಟಕವಾಗಿದೆ. NLP 50 ವರ್ಷಗಳಿಗಿಂತ ಹೆಚ್ಚು ಕಾಲದಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದು, ಭಾಷಾಶಾಸ್ತ್ರ ಕ್ಷೇತ್ರದಲ್ಲಿ ಮೂಲಗಳನ್ನು ಹೊಂದಿದೆ. ಈ ಸಂಪೂರ್ಣ ಕ್ಷೇತ್ರವು ಯಂತ್ರಗಳಿಗೆ ಮಾನವ ಭಾಷೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುವುದಕ್ಕೆ ನಿರ್ದೇಶಿತವಾಗಿದೆ. ಇದನ್ನು ನಂತರ ಸ್ಪೆಲ್ ಚೆಕ್ ಅಥವಾ ಯಂತ್ರ ಅನುವಾದದಂತಹ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಬಹುದು. ಇದಕ್ಕೆ ವೈದ್ಯಕೀಯ ಸಂಶೋಧನೆ, ಹುಡುಕಾಟ ಎಂಜಿನ್‌ಗಳು ಮತ್ತು ವ್ಯವಹಾರ ಬುದ್ಧಿವಂತಿಕೆ ಸೇರಿದಂತೆ ಹಲವಾರು ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ನೈಜ ಜಗತ್ತಿನ ಅನೇಕ ಅನ್ವಯಿಕೆಗಳಿವೆ.
## ಪ್ರಾದೇಶಿಕ ವಿಷಯ: ಯುರೋಪಿಯನ್ ಭಾಷೆಗಳು ಮತ್ತು ಸಾಹಿತ್ಯ ಮತ್ತು ಯುರೋಪಿನ ರೋಮ್ಯಾಂಟಿಕ್ ಹೋಟೆಲ್ಗಳು ❤️
ಪಠ್ಯಕ್ರಮದ ಈ ವಿಭಾಗದಲ್ಲಿ, ನೀವು ಯಂತ್ರ ಅಧ್ಯಯನದ ಅತ್ಯಂತ ವ್ಯಾಪಕ ಬಳಕೆಗಳಲ್ಲಿ ಒಂದಾದ ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ (NLP) ಪರಿಚಯಿಸಲ್ಪಡುತ್ತೀರಿ. ಗಣನೀಯ ಭಾಷಾಶಾಸ್ತ್ರದಿಂದ ಪಡೆದ ಈ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯ ವರ್ಗವು ಮಾನವರು ಮತ್ತು ಯಂತ್ರಗಳ ನಡುವೆ ಧ್ವನಿ ಅಥವಾ ಪಠ್ಯ ಸಂವಹನದ ಮೂಲಕ ಸೇತುವೆಯಾಗಿದೆ.
ಈ ಪಾಠಗಳಲ್ಲಿ ನಾವು NLP ಮೂಲಭೂತಗಳನ್ನು ಕಲಿಯುತ್ತೇವೆ, ಚಿಕ್ಕ ಸಂಭಾಷಣಾತ್ಮಕ ಬಾಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಯಂತ್ರ ಅಧ್ಯಯನವು ಈ ಸಂಭಾಷಣೆಗಳನ್ನು ಹೇಗೆ ಹೆಚ್ಚು 'ಸ್ಮಾರ್ಟ್' ಆಗಿ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯುತ್ತೇವೆ. ನೀವು ಕಾಲದಲ್ಲಿ ಹಿಂದಕ್ಕೆ ಪ್ರಯಾಣ ಮಾಡಿ, ಜೆನ್ ಆಸ್ಟೆನ್ ಅವರ 1813 ರಲ್ಲಿ ಪ್ರಕಟಿತ ಕ್ಲಾಸಿಕ್ ناವಲ **ಪ್ರೈಡ್ ಅಂಡ್ ಪ್ರೆಜುಡಿಸ್** ನ ಎಲಿಜಬೆತ್ ಬೆನೆಟ್ ಮತ್ತು ಮಿಸ್ಟರ್ ಡಾರ್ಸಿಯವರೊಂದಿಗೆ ಸಂಭಾಷಣೆ ಮಾಡುತ್ತೀರಿ. ನಂತರ, ಯುರೋಪಿನ ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳ ಮೂಲಕ ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಕಲಿಯುವ ಮೂಲಕ ನಿಮ್ಮ ಜ್ಞಾನವನ್ನು ವಿಸ್ತರಿಸುತ್ತೀರಿ.
![ಪ್ರೈಡ್ ಅಂಡ್ ಪ್ರೆಜುಡಿಸ್ ಪುಸ್ತಕ ಮತ್ತು ಚಹಾ](../../../translated_images/p&p.279f1c49ecd889419e4ce6206525e9aa30d32a976955cd24daa636c361c6391f.kn.jpg)
> ಫೋಟೋ <a href="https://unsplash.com/@elaineh?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">ಎಲೈನ್ ಹೌಲಿನ್</a> ಅವರಿಂದ <a href="https://unsplash.com/s/photos/pride-and-prejudice?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">ಅನ್ಸ್ಪ್ಲ್ಯಾಶ್</a> ನಲ್ಲಿ
## ಪಾಠಗಳು
1. [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆಗೆ ಪರಿಚಯ](1-Introduction-to-NLP/README.md)
2. [ಸಾಮಾನ್ಯ NLP ಕಾರ್ಯಗಳು ಮತ್ತು ತಂತ್ರಗಳು](2-Tasks/README.md)
3. [ಯಂತ್ರ ಅಧ್ಯಯನದೊಂದಿಗೆ ಅನುವಾದ ಮತ್ತು ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ](3-Translation-Sentiment/README.md)
4. [ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು](4-Hotel-Reviews-1/README.md)
5. [ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆಗೆ NLTK](5-Hotel-Reviews-2/README.md)
## ಕ್ರೆಡಿಟ್ಸ್
ಈ ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ ಪಾಠಗಳನ್ನು ☕ ಸಹಿತ [ಸ್ಟೀಫನ್ ಹೌವೆಲ್](https://twitter.com/Howell_MSFT) ರವರು ಬರೆಯಲಾಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/6-NLP/data/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "ee0670655c89e4719319764afb113624",
"translation_date": "2025-12-19T14:25:29+00:00",
"source_file": "6-NLP/data/README.md",
"language_code": "kn"
}
-->
ಈ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಟೆಲ್ ವಿಮರ್ಶಾ ಡೇಟಾವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

201
translations/kn/7-TimeSeries/1-Introduction/README.md
Unescape View File

@ -0,0 +1,201 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "662b509c39eee205687726636d0a8455",
"translation_date": "2025-12-19T16:06:38+00:00",
"source_file": "7-TimeSeries/1-Introduction/README.md",
"language_code": "kn"
}
-->
# ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಪರಿಚಯ
![ಕಾಲ ಸರಣಿಗಳ ಸಾರಾಂಶವನ್ನು ಸ್ಕೆಚ್‌ನೋಟ್‌ನಲ್ಲಿ](../../../../translated_images/ml-timeseries.fb98d25f1013fc0c59090030080b5d1911ff336427bec31dbaf1ad08193812e9.kn.png)
> ಸ್ಕೆಚ್‌ನೋಟ್ [ಟೊಮೊಮಿ ಇಮುರು](https://www.twitter.com/girlie_mac) ಅವರಿಂದ
ಈ ಪಾಠದಲ್ಲಿ ಮತ್ತು ಮುಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ತಿಳಿದುಕೊಳ್ಳುತ್ತೀರಿ, ಇದು ಎಂಎಲ್ ವಿಜ್ಞಾನಿಯ repertoire ನಲ್ಲಿ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಮೌಲ್ಯಯುತ ಭಾಗವಾಗಿದೆ, ಆದರೆ ಇತರ ವಿಷಯಗಳಿಗಿಂತ ಸ್ವಲ್ಪ ಕಡಿಮೆ ಪರಿಚಿತವಾಗಿದೆ. ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಒಂದು ರೀತಿಯ 'ಕ್ರಿಸ್ಟಲ್ ಬಾಲ್' ಆಗಿದೆ: ಬೆಲೆ ಮುಂತಾದ ಚರದ ಹಿಂದಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಆಧಾರದ ಮೇಲೆ, ನೀವು ಅದರ ಭವಿಷ್ಯದ ಸಾಧ್ಯ ಮೌಲ್ಯವನ್ನು ಊಹಿಸಬಹುದು.
[![ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಪರಿಚಯ](https://img.youtube.com/vi/cBojo1hsHiI/0.jpg)](https://youtu.be/cBojo1hsHiI "ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಪರಿಚಯ")
> 🎥 ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಕುರಿತು ವೀಡಿಯೋಗಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ
## [ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
ಇದು ವ್ಯವಹಾರಕ್ಕೆ ನೇರವಾಗಿ ಅನ್ವಯಿಸುವ ಬೆಲೆ ನಿಗದಿ, ಇನ್ವೆಂಟರಿ ಮತ್ತು ಸರಬರಾಜು ಸರಪಳಿ ಸಮಸ್ಯೆಗಳಂತಹ ಸಮಸ್ಯೆಗಳಿಗೆ ನೇರ ಅನ್ವಯವಿರುವ ಉಪಯುಕ್ತ ಮತ್ತು ಆಸಕ್ತಿದಾಯಕ ಕ್ಷೇತ್ರವಾಗಿದೆ. ಭವಿಷ್ಯದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮವಾಗಿ ಊಹಿಸಲು ಹೆಚ್ಚಿನ ಒಳನೋಟಗಳನ್ನು ಪಡೆಯಲು ಡೀಪ್ ಲರ್ನಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದರೂ, ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿ ಕ್ಲಾಸಿಕ್ ಎಂಎಲ್ ತಂತ್ರಜ್ಞಾನಗಳಿಂದ ಬಹುಮಟ್ಟಿಗೆ ಪ್ರಭಾವಿತವಾಗಿರುವ ಕ್ಷೇತ್ರವಾಗಿಯೇ ಉಳಿದಿದೆ.
> ಪೆನ್ ಸ್ಟೇಟ್‌ನ ಉಪಯುಕ್ತ ಕಾಲ ಸರಣಿ ಪಠ್ಯಕ್ರಮವನ್ನು [ಇಲ್ಲಿ](https://online.stat.psu.edu/stat510/lesson/1) ಕಾಣಬಹುದು
## ಪರಿಚಯ
ನೀವು ಸಮಯದೊಂದಿಗೆ ಎಷ್ಟು ಬಾರಿ ಮತ್ತು ಎಷ್ಟು ಕಾಲ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಡೇಟಾವನ್ನು ಒದಗಿಸುವ ಸ್ಮಾರ್ಟ್ ಪಾರ್ಕಿಂಗ್ ಮೀಟರ್‌ಗಳ ಸರಣಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಊಹಿಸೋಣ.
> ಮೀಟರ್‌ನ ಹಿಂದಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಆಧಾರದ ಮೇಲೆ, ಸರಬರಾಜು ಮತ್ತು ಬೇಡಿಕೆಯ ನಿಯಮಗಳ ಪ್ರಕಾರ ಅದರ ಭವಿಷ್ಯದ ಮೌಲ್ಯವನ್ನು ನೀವು ಊಹಿಸಬಹುದಾದರೆ?
ನಿಮ್ಮ ಗುರಿಯನ್ನು ಸಾಧಿಸಲು ಯಾವಾಗ ಕ್ರಮ ಕೈಗೊಳ್ಳಬೇಕೆಂದು ನಿಖರವಾಗಿ ಊಹಿಸುವುದು ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿಯಿಂದ ಎದುರಿಸಬಹುದಾದ ಸವಾಲಾಗಿದೆ. ಜನರು ಪಾರ್ಕಿಂಗ್ ಸ್ಥಳ ಹುಡುಕುತ್ತಿರುವ ಸಮಯದಲ್ಲಿ ಹೆಚ್ಚು ಶುಲ್ಕ ವಿಧಿಸುವುದು ಅವರಿಗೆ ಸಂತೋಷಕರವಾಗುವುದಿಲ್ಲ, ಆದರೆ ಇದು ರಸ್ತೆಗಳ ಸ್ವಚ್ಛತೆಯನ್ನು ಕಾಪಾಡಲು ಆದಾಯವನ್ನು ಉತ್ಪಾದಿಸುವ ಖಚಿತ ಮಾರ್ಗವಾಗಿರುತ್ತದೆ!
ಕಾಲ ಸರಣಿ ಆಲ್ಗಾರಿಥಮ್‌ಗಳ ಕೆಲವು ಪ್ರಕಾರಗಳನ್ನು ಅನ್ವೇಷಿಸಿ, ಕೆಲವು ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ ಮತ್ತು ಸಿದ್ಧಪಡಿಸಲು ನೋಟ್ಬುಕ್ ಪ್ರಾರಂಭಿಸೋಣ. ನೀವು ವಿಶ್ಲೇಷಿಸುವ ಡೇಟಾ GEFCom2014 ಭವಿಷ್ಯವಾಣಿ ಸ್ಪರ್ಧೆಯಿಂದ ತೆಗೆದುಕೊಂಡಿದೆ. ಇದು 2012 ರಿಂದ 2014 ರವರೆಗೆ 3 ವರ್ಷಗಳ ಗಂಟೆಗಟ್ಟಲೆ ವಿದ್ಯುತ್ ಲೋಡ್ ಮತ್ತು ತಾಪಮಾನ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ವಿದ್ಯುತ್ ಲೋಡ್ ಮತ್ತು ತಾಪಮಾನದ ಇತಿಹಾಸದ ಮಾದರಿಗಳನ್ನು ಆಧರಿಸಿ, ನೀವು ಭವಿಷ್ಯದ ವಿದ್ಯುತ್ ಲೋಡ್ ಮೌಲ್ಯಗಳನ್ನು ಊಹಿಸಬಹುದು.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನೀವು ಇತಿಹಾಸದ ಲೋಡ್ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಬಳಸಿಕೊಂಡು ಒಂದು ಕಾಲ ಹಂತವನ್ನು ಮುಂಚಿತವಾಗಿ ಊಹಿಸುವುದನ್ನು ಕಲಿಯುತ್ತೀರಿ. ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ಆದರೆ, ಹಿನ್ನೆಲೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಉಪಯುಕ್ತ.
## ಕೆಲವು ವ್ಯಾಖ್ಯಾನಗಳು
'ಕಾಲ ಸರಣಿ' ಎಂಬ ಪದವನ್ನು ಎದುರಿಸಿದಾಗ, ಅದರ ಬಳಕೆಯನ್ನು ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ.
🎓 **ಕಾಲ ಸರಣಿ**
ಗಣಿತದಲ್ಲಿ, "ಕಾಲ ಸರಣಿ ಎಂದರೆ ಸಮಯ ಕ್ರಮದಲ್ಲಿ ಸೂಚಿಸಲ್ಪಟ್ಟ (ಅಥವಾ ಪಟ್ಟಿ ಮಾಡಲಾದ ಅಥವಾ ಗ್ರಾಫ್ ಮಾಡಲಾದ) ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳ ಸರಣಿ. ಸಾಮಾನ್ಯವಾಗಿ, ಕಾಲ ಸರಣಿ ಎಂದರೆ ಸಮಯದಲ್ಲಿ ಸಮಾನ ಅಂತರದ ಕ್ರಮವಾಗಿ ತೆಗೆದುಕೊಂಡ ಸರಣಿ." ಕಾಲ ಸರಣಿಯ ಉದಾಹರಣೆ ಎಂದರೆ [ಡೌ ಜೋನ್ಸ್ ಇಂಡಸ್ಟ್ರಿಯಲ್ ಅವರೆಜ್](https://wikipedia.org/wiki/Time_series) ನ ದೈನಂದಿನ ಮುಚ್ಚುವ ಮೌಲ್ಯ. ಕಾಲ ಸರಣಿ ಪ್ಲಾಟ್‌ಗಳು ಮತ್ತು ಸಾಂಖ್ಯಿಕ ಮಾದರೀಕರಣವನ್ನು ಸಿಗ್ನಲ್ ಪ್ರೊಸೆಸಿಂಗ್, ಹವಾಮಾನ ಭವಿಷ್ಯವಾಣಿ, ಭೂಕಂಪ ಭವಿಷ್ಯವಾಣಿ ಮತ್ತು ಇತರ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಕಾಣಬಹುದು, ಅಲ್ಲಿ ಘಟನೆಗಳು ಸಂಭವಿಸುತ್ತವೆ ಮತ್ತು ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಸಮಯದೊಂದಿಗೆ ಪ್ಲಾಟ್ ಮಾಡಬಹುದು.
🎓 **ಕಾಲ ಸರಣಿ ವಿಶ್ಲೇಷಣೆ**
ಕಾಲ ಸರಣಿ ವಿಶ್ಲೇಷಣೆ ಎಂದರೆ ಮೇಲ್ಕಂಡ ಕಾಲ ಸರಣಿ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು. ಕಾಲ ಸರಣಿ ಡೇಟಾ ವಿಭಿನ್ನ ರೂಪಗಳನ್ನು ಹೊಂದಬಹುದು, ಉದಾಹರಣೆಗೆ 'ವಿರಾಮಿತ ಕಾಲ ಸರಣಿ' ಇದು ವಿರಾಮದ ಘಟನೆಗೆ ಮುಂಚೆ ಮತ್ತು ನಂತರದ ಕಾಲ ಸರಣಿಯ ಬೆಳವಣಿಗೆಯ ಮಾದರಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುತ್ತದೆ. ಕಾಲ ಸರಣಿಗೆ ಬೇಕಾದ ವಿಶ್ಲೇಷಣೆ ಡೇಟಾದ ಸ್ವಭಾವದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಕಾಲ ಸರಣಿ ಡೇಟಾ ಸ್ವತಃ ಸಂಖ್ಯೆಗಳ ಅಥವಾ ಅಕ್ಷರಗಳ ಸರಣಿಯಾಗಿರಬಹುದು.
ನಿರ್ವಹಿಸಬೇಕಾದ ವಿಶ್ಲೇಷಣೆ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಅವುಗಳಲ್ಲಿ ಫ್ರೀಕ್ವೆನ್ಸಿ-ಡೊಮೇನ್ ಮತ್ತು ಟೈಮ್-ಡೊಮೇನ್, ರೇಖೀಯ ಮತ್ತು ಅರೆಖೀಯ, ಮತ್ತು ಇನ್ನಷ್ಟು ಸೇರಿವೆ. ಈ ರೀತಿಯ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಅನೇಕ ಮಾರ್ಗಗಳ ಬಗ್ಗೆ [ಇಲ್ಲಿ](https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm) ತಿಳಿದುಕೊಳ್ಳಿ.
🎓 **ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ**
ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ ಎಂದರೆ ಹಿಂದಿನ ಸಂಗ್ರಹಿತ ಡೇಟಾದ ಮಾದರಿಗಳನ್ನು ಆಧರಿಸಿ ಭವಿಷ್ಯದ ಮೌಲ್ಯಗಳನ್ನು ಊಹಿಸಲು ಮಾದರಿಯನ್ನು ಬಳಸುವುದು. ಕಾಲ ಸರಣಿ ಡೇಟಾವನ್ನು ಅನ್ವೇಷಿಸಲು ರಿಗ್ರೆಶನ್ ಮಾದರಿಗಳನ್ನು ಬಳಸಬಹುದು, ಸಮಯ ಸೂಚ್ಯಂಕಗಳನ್ನು x ಚರಗಳಾಗಿ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಬಳಸಿಕೊಂಡು, ಆದರೆ ಇಂತಹ ಡೇಟಾವನ್ನು ವಿಶೇಷ ಮಾದರಿಗಳ ಮೂಲಕ ವಿಶ್ಲೇಷಿಸುವುದು ಉತ್ತಮ.
ಕಾಲ ಸರಣಿ ಡೇಟಾ ಕ್ರಮಬದ್ಧ ವೀಕ್ಷಣೆಗಳ ಪಟ್ಟಿ ಆಗಿದ್ದು, ರೇಖೀಯ ರಿಗ್ರೆಶನ್ ಮೂಲಕ ವಿಶ್ಲೇಷಿಸಬಹುದಾದ ಡೇಟಾದಂತೆ ಅಲ್ಲ. ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಮಾದರಿ ARIMA, ಇದು "ಆಟೋರೆಗ್ರೆಸಿವ್ ಇಂಟಿಗ್ರೇಟೆಡ್ ಮೂವಿಂಗ್ ಅವರೆಜ್" ಎಂಬ ಅಕ್ಷರಶಃ.
[ARIMA ಮಾದರಿಗಳು](https://online.stat.psu.edu/stat510/lesson/1/1.1) "ಸರಣಿಯ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿನ ಮೌಲ್ಯಗಳು ಮತ್ತು ಹಿಂದಿನ ಊಹಾ ದೋಷಗಳಿಗೆ ಸಂಬಂಧಿಸುತ್ತದೆ." ಅವು ಸಮಯ-ಡೊಮೇನ್ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಅತ್ಯಂತ ಸೂಕ್ತವಾಗಿವೆ, ಅಲ್ಲಿ ಡೇಟಾ ಸಮಯದೊಂದಿಗೆ ಕ್ರಮಬದ್ಧವಾಗಿದೆ.
> ARIMA ಮಾದರಿಗಳ ಹಲವು ಪ್ರಕಾರಗಳಿವೆ, ಅವುಗಳ ಬಗ್ಗೆ ನೀವು [ಇಲ್ಲಿ](https://people.duke.edu/~rnau/411arim.htm) ತಿಳಿದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಮುಂದಿನ ಪಾಠದಲ್ಲಿ ಅವುಗಳ ಬಗ್ಗೆ ಸ್ಪರ್ಶಿಸುವಿರಿ.
ಮುಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು [ಏಕಚರ ಕಾಲ ಸರಣಿ](https://itl.nist.gov/div898/handbook/pmc/section4/pmc44.htm) ಬಳಸಿ ARIMA ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವಿರಿ, ಇದು ಸಮಯದೊಂದಿಗೆ ಮೌಲ್ಯ ಬದಲಾಗುವ ಒಂದು ಚರವನ್ನು ಗಮನಿಸುತ್ತದೆ. ಈ ರೀತಿಯ ಡೇಟಾದ ಉದಾಹರಣೆ [ಈ ಡೇಟಾಸೆಟ್](https://itl.nist.gov/div898/handbook/pmc/section4/pmc4411.htm) ಆಗಿದ್ದು, ಇದು ಮಾಉನಾ ಲೋಆ ವೀಕ್ಷಣಾಲಯದಲ್ಲಿ ಮಾಸಿಕ CO2 ಸಾಂದ್ರತೆಯನ್ನು ದಾಖಲಿಸುತ್ತದೆ:
| CO2 | YearMonth | Year | Month |
| :----: | :-------: | :---: | :---: |
| 330.62 | 1975.04 | 1975 | 1 |
| 331.40 | 1975.13 | 1975 | 2 |
| 331.87 | 1975.21 | 1975 | 3 |
| 333.18 | 1975.29 | 1975 | 4 |
| 333.92 | 1975.38 | 1975 | 5 |
| 333.43 | 1975.46 | 1975 | 6 |
| 331.85 | 1975.54 | 1975 | 7 |
| 330.01 | 1975.63 | 1975 | 8 |
| 328.51 | 1975.71 | 1975 | 9 |
| 328.41 | 1975.79 | 1975 | 10 |
| 329.25 | 1975.88 | 1975 | 11 |
| 330.97 | 1975.96 | 1975 | 12 |
✅ ಈ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಸಮಯದೊಂದಿಗೆ ಬದಲಾಗುವ ಚರವನ್ನು ಗುರುತಿಸಿ
## ಗಮನಿಸಬೇಕಾದ ಕಾಲ ಸರಣಿ ಡೇಟಾ ಲಕ್ಷಣಗಳು
ಕಾಲ ಸರಣಿ ಡೇಟಾವನ್ನು ನೋಡಿದಾಗ, ಅದರಲ್ಲಿ [ನಿರ್ದಿಷ್ಟ ಲಕ್ಷಣಗಳು](https://online.stat.psu.edu/stat510/lesson/1/1.1) ಇವೆಂದು ನೀವು ಗಮನಿಸಬಹುದು, ಅವುಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಅವುಗಳ ಮಾದರಿಗಳನ್ನು ಉತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಅವುಗಳನ್ನು ತಗ್ಗಿಸಬೇಕಾಗಬಹುದು. ಕಾಲ ಸರಣಿ ಡೇಟಾವನ್ನು ನೀವು ವಿಶ್ಲೇಷಿಸಲು ಬಯಸುವ 'ಸಿಗ್ನಲ್' ಎಂದು ಪರಿಗಣಿಸಿದರೆ, ಈ ಲಕ್ಷಣಗಳನ್ನು 'ಶಬ್ದ' ಎಂದು ಭಾವಿಸಬಹುದು. ಈ 'ಶಬ್ದ' ಅನ್ನು ಕೆಲವು ಸಾಂಖ್ಯಿಕ ತಂತ್ರಗಳನ್ನು ಬಳಸಿ ಕಡಿಮೆ ಮಾಡಬೇಕಾಗಬಹುದು.
ಕಾಲ ಸರಣಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಕೆಲವು ಪರಿಕಲ್ಪನೆಗಳು ಇಲ್ಲಿವೆ:
🎓 **ಪ್ರವೃತ್ತಿಗಳು**
ಪ್ರವೃತ್ತಿಗಳು ಎಂದರೆ ಸಮಯದೊಂದಿಗೆ ಅಳೆಯಬಹುದಾದ ಏರಿಕೆ ಮತ್ತು ಇಳಿಕೆಗಳು. [ಇನ್ನಷ್ಟು ಓದಿ](https://machinelearningmastery.com/time-series-trends-in-python). ಕಾಲ ಸರಣಿಯ ಸನ್ನಿವೇಶದಲ್ಲಿ, ನಿಮ್ಮ ಕಾಲ ಸರಣಿಯಿಂದ ಪ್ರವೃತ್ತಿಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ ತೆಗೆದುಹಾಕುವುದು.
🎓 **[ಹಂಗಾಮಿ ಪ್ರಭಾವ](https://machinelearningmastery.com/time-series-seasonality-with-python/)**
ಹಂಗಾಮಿ ಪ್ರಭಾವ ಎಂದರೆ ಹಬ್ಬದ ಸಮಯದ ವ್ಯಾಪಾರ ಹೆಚ್ಚಳದಂತಹ ನಿಯಮಿತ ಅಸ್ಥಿರತೆಗಳು. [ನೋಡಿ](https://itl.nist.gov/div898/handbook/pmc/section4/pmc443.htm) ವಿವಿಧ ರೀತಿಯ ಪ್ಲಾಟ್‌ಗಳು ಡೇಟಾದಲ್ಲಿ ಹಂಗಾಮಿ ಪ್ರಭಾವವನ್ನು ಹೇಗೆ ತೋರಿಸುತ್ತವೆ.
🎓 **ಅಸಾಮಾನ್ಯ ಮೌಲ್ಯಗಳು**
ಅಸಾಮಾನ್ಯ ಮೌಲ್ಯಗಳು ಸಾಮಾನ್ಯ ಡೇಟಾ ವ್ಯತ್ಯಾಸದಿಂದ ಬಹಳ ದೂರದಲ್ಲಿರುತ್ತವೆ.
🎓 **ದೀರ್ಘಾವಧಿ ಚಕ್ರ**
ಹಂಗಾಮಿ ಪ್ರಭಾವದಿಂದ ಸ್ವತಂತ್ರವಾಗಿ, ಡೇಟಾ ದೀರ್ಘಾವಧಿ ಚಕ್ರವನ್ನು ತೋರಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ ಒಂದು ವರ್ಷಕ್ಕಿಂತ ಹೆಚ್ಚು ಕಾಲ ಇರುವ ಆರ್ಥಿಕ ಕುಸಿತ.
🎓 **ಸ್ಥಿರ ವ್ಯತ್ಯಾಸ**
ಸಮಯದೊಂದಿಗೆ, ಕೆಲವು ಡೇಟಾ ಸ್ಥಿರ ಅಸ್ಥಿರತೆಗಳನ್ನು ತೋರಿಸುತ್ತವೆ, ಉದಾಹರಣೆಗೆ ದಿನ ಮತ್ತು ರಾತ್ರಿ ಎನರ್ಜಿ ಬಳಕೆ.
🎓 **ಅಕಸ್ಮಾತ್ ಬದಲಾವಣೆಗಳು**
ಡೇಟಾ ಅಕಸ್ಮಾತ್ ಬದಲಾವಣೆಯನ್ನು ತೋರಿಸಬಹುದು, ಇದಕ್ಕೆ ಹೆಚ್ಚಿನ ವಿಶ್ಲೇಷಣೆ ಬೇಕಾಗಬಹುದು. ಉದಾಹರಣೆಗೆ COVID ಕಾರಣದಿಂದ ವ್ಯವಹಾರಗಳ ಅಕಸ್ಮಾತ್ ಮುಚ್ಚುವಿಕೆ ಡೇಟಾದಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನುಂಟುಮಾಡಿತು.
✅ ಇಲ್ಲಿ [ನಮೂನಾ ಕಾಲ ಸರಣಿ ಪ್ಲಾಟ್](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python) ಇದೆ, ಇದು ಕೆಲವು ವರ್ಷಗಳ ಕಾಲ ದಿನನಿತ್ಯದ ಆಟದ ಕರೆನ್ಸಿ ಖರ್ಚನ್ನು ತೋರಿಸುತ್ತದೆ. ಈ ಡೇಟಾದಲ್ಲಿ ಮೇಲ್ಕಂಡ ಲಕ್ಷಣಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ಗುರುತಿಸಬಹುದೇ?
![ಆಟದ ಕರೆನ್ಸಿ ಖರ್ಚು](../../../../translated_images/currency.e7429812bfc8c6087b2d4c410faaa4aaa11b2fcaabf6f09549b8249c9fbdb641.kn.png)
## ಅಭ್ಯಾಸ - ವಿದ್ಯುತ್ ಬಳಕೆ ಡೇಟಾ ಮೂಲಕ ಪ್ರಾರಂಭಿಸುವುದು
ಹಿಂದಿನ ಬಳಕೆಯನ್ನು ಆಧರಿಸಿ ಭವಿಷ್ಯದ ವಿದ್ಯುತ್ ಬಳಕೆಯನ್ನು ಊಹಿಸಲು ಕಾಲ ಸರಣಿ ಮಾದರಿಯನ್ನು ರಚಿಸುವುದನ್ನು ಪ್ರಾರಂಭಿಸೋಣ.
> ಈ ಉದಾಹರಣೆಯ ಡೇಟಾ GEFCom2014 ಭವಿಷ್ಯವಾಣಿ ಸ್ಪರ್ಧೆಯಿಂದ ತೆಗೆದುಕೊಂಡಿದೆ. ಇದು 2012 ರಿಂದ 2014 ರವರೆಗೆ 3 ವರ್ಷಗಳ ಗಂಟೆಗಟ್ಟಲೆ ವಿದ್ಯುತ್ ಲೋಡ್ ಮತ್ತು ತಾಪಮಾನ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
>
> ಟಾವ್ ಹಾಂಗ್, ಪಿಯೆರ್ರೆ ಪಿನ್ಸನ್, ಶು ಫಾನ್, ಹಮಿದ್ರೆಜಾ ಜರೆಪೌರ್, ಅಲ್ಬೆರ್ಟೋ ಟ್ರೊಕೊಲ್ಲಿ ಮತ್ತು ರಾಬ್ ಜೆ. ಹಿಂಡ್ಮನ್, "ಪ್ರಾಬಬಿಲಿಸ್ಟಿಕ್ ಎನರ್ಜಿ ಫೋರ್ಕಾಸ್ಟಿಂಗ್: ಗ್ಲೋಬಲ್ ಎನರ್ಜಿ ಫೋರ್ಕಾಸ್ಟಿಂಗ್ ಸ್ಪರ್ಧೆ 2014 ಮತ್ತು ಮುಂದಿನದು", ಇಂಟರ್‌ನ್ಯಾಷನಲ್ ಜರ್ನಲ್ ಆಫ್ ಫೋರ್ಕಾಸ್ಟಿಂಗ್, ವಾಲ್ಯೂಮ್ 32, ಸಂಖ್ಯೆ 3, ಪುಟಗಳು 896-913, ಜುಲೈ-ಸೆಪ್ಟೆಂಬರ್, 2016.
1. ಈ ಪಾಠದ `working` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ _notebook.ipynb_ ಫೈಲ್ ತೆರೆಯಿರಿ. ಡೇಟಾ ಲೋಡ್ ಮತ್ತು ದೃಶ್ಯೀಕರಣಕ್ಕೆ ಸಹಾಯ ಮಾಡುವ ಲೈಬ್ರರಿಗಳನ್ನು ಸೇರಿಸುವುದರಿಂದ ಪ್ರಾರಂಭಿಸಿ
```python
import os
import matplotlib.pyplot as plt
from common.utils import load_data
%matplotlib inline
```
ಗಮನಿಸಿ, ನೀವು ಒಳಗೊಂಡಿರುವ `common` ಫೋಲ್ಡರ್‌ನ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ, ಇದು ನಿಮ್ಮ ಪರಿಸರವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ ಮತ್ತು ಡೇಟಾ ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
2. ನಂತರ, `load_data()` ಮತ್ತು `head()` ಅನ್ನು ಕರೆಸಿ ಡೇಟಾವನ್ನು ಡೇಟಾಫ್ರೇಮ್ ಆಗಿ ಪರಿಶೀಲಿಸಿ:
```python
data_dir = './data'
energy = load_data(data_dir)[['load']]
energy.head()
```
ನೀವು ದಿನಾಂಕ ಮತ್ತು ಲೋಡ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಎರಡು ಕಾಲಮ್‌ಗಳಿವೆ ಎಂದು ನೋಡಬಹುದು:
| | load |
| :-----------------: | :----: |
| 2012-01-01 00:00:00 | 2698.0 |
| 2012-01-01 01:00:00 | 2558.0 |
| 2012-01-01 02:00:00 | 2444.0 |
| 2012-01-01 03:00:00 | 2402.0 |
| 2012-01-01 04:00:00 | 2403.0 |
3. ಈಗ, `plot()` ಅನ್ನು ಕರೆಸಿ ಡೇಟಾವನ್ನು ಪ್ಲಾಟ್ ಮಾಡಿ:
```python
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
![energy plot](../../../../translated_images/energy-plot.5fdac3f397a910bc6070602e9e45bea8860d4c239354813fa8fc3c9d556f5bad.kn.png)
4. ಈಗ, 2014 ರ ಜುಲೈ ಮೊದಲ ವಾರವನ್ನು `[from date]: [to date]` ಮಾದರಿಯಲ್ಲಿ `energy` ಗೆ ಇನ್ಪುಟ್ ನೀಡುವ ಮೂಲಕ ಪ್ಲಾಟ್ ಮಾಡಿ:
```python
energy['2014-07-01':'2014-07-07'].plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
![july](../../../../translated_images/july-2014.9e1f7c318ec6d5b30b0d7e1e20be3643501f64a53f3d426d7c7d7b62addb335e.kn.png)
ಅದ್ಭುತವಾದ ಪ್ಲಾಟ್! ಈ ಪ್ಲಾಟ್‌ಗಳನ್ನು ನೋಡಿ ಮೇಲ್ಕಂಡ ಲಕ್ಷಣಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ನೀವು ಗುರುತಿಸಬಹುದೇ? ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸುವ ಮೂಲಕ ನಾವು ಏನು ಊಹಿಸಬಹುದು?
ಮುಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ARIMA ಮಾದರಿಯನ್ನು ರಚಿಸಿ ಕೆಲವು ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡುತ್ತೀರಿ.
---
## 🚀ಸವಾಲು
ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯವಾಣಿಯಿಂದ ಲಾಭ ಪಡೆಯಬಹುದಾದ ಎಲ್ಲಾ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ವಿಚಾರಣಾ ಕ್ಷೇತ್ರಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ. ಈ ತಂತ್ರಗಳನ್ನು ಕಲೆಯಲ್ಲಿಯೂ ಅನ್ವಯಿಸಬಹುದೇ? ಆರ್ಥಿಕಶಾಸ್ತ್ರದಲ್ಲಿ? ಪರಿಸರಶಾಸ್ತ್ರದಲ್ಲಿ? ಚಿಲ್ಲರೆ ವ್ಯಾಪಾರದಲ್ಲಿ? ಕೈಗಾರಿಕೆಯಲ್ಲಿ? ಹಣಕಾಸಿನಲ್ಲಿ? ಇನ್ನೆಲ್ಲಿ?
## [ಪೋಸ್ಟ್-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ಇಲ್ಲಿ ನಾವು ಅವುಗಳನ್ನು ಒಳಗೊಂಡಿಲ್ಲದಿದ್ದರೂ, ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ಕೆಲವೊಮ್ಮೆ ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಯ ಕ್ಲಾಸಿಕ್ ವಿಧಾನಗಳನ್ನು ಸುಧಾರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಅವುಗಳ ಬಗ್ಗೆ [ಈ ಲೇಖನದಲ್ಲಿ](https://medium.com/microsoftazure/neural-networks-for-forecasting-financial-and-economic-time-series-6aca370ff412) ಇನ್ನಷ್ಟು ಓದಿ
## ಹವಾಲೆ
[ಇನ್ನಷ್ಟು ಕಾಲ ಸರಣಿಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಿ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/kn/7-TimeSeries/1-Introduction/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "d1781b0b92568ea1d119d0a198b576b4",
"translation_date": "2025-12-19T16:08:29+00:00",
"source_file": "7-TimeSeries/1-Introduction/assignment.md",
"language_code": "kn"
}
-->
# ಇನ್ನಷ್ಟು ಕಾಲ ಸರಣಿಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಿ
## ಸೂಚನೆಗಳು
ನೀವು ಈ ವಿಶೇಷ ಮಾದರಿಯನ್ನು ಅಗತ್ಯವಿರುವ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನೋಡಿ ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ ಬಗ್ಗೆ ಕಲಿಯಲು ಪ್ರಾರಂಭಿಸಿದ್ದೀರಿ. ನೀವು ಶಕ್ತಿ ಸುತ್ತಲೂ ಕೆಲವು ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿದ್ದೀರಿ. ಈಗ, ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಯಿಂದ ಲಾಭ ಪಡೆಯಬಹುದಾದ ಇನ್ನಷ್ಟು ಡೇಟಾವನ್ನು ಹುಡುಕಿ. ಮೂರು ಉದಾಹರಣೆಗಳನ್ನು ಕಂಡುಹಿಡಿದು (ಪ್ರಯತ್ನಿಸಿ [Kaggle](https://kaggle.com) ಮತ್ತು [Azure Open Datasets](https://azure.microsoft.com/en-us/services/open-datasets/catalog/?WT.mc_id=academic-77952-leestott)) ಅವುಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಒಂದು ನೋಟ್ಬುಕ್ ರಚಿಸಿ. ಅವುಗಳಲ್ಲಿ ಇರುವ ಯಾವುದೇ ವಿಶೇಷ ಲಕ್ಷಣಗಳನ್ನು (ಹಂಗಾಮಿ, ತೀವ್ರ ಬದಲಾವಣೆಗಳು, ಅಥವಾ ಇತರ ಪ್ರವೃತ್ತಿಗಳು) ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಸೂಚಿಸಿ.
## ಮೌಲ್ಯಮಾಪನ
| ಮಾನದಂಡಗಳು | ಉದಾತ್ತ | ಸಮರ್ಪಕ | ಸುಧಾರಣೆಯ ಅಗತ್ಯವಿದೆ |
| -------- | ------------------------------------------------------ | ---------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| | ಮೂರು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಚಿತ್ರಿಸಿ ಮತ್ತು ವಿವರಿಸಲಾಗಿದೆ | ಎರಡು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಚಿತ್ರಿಸಿ ಮತ್ತು ವಿವರಿಸಲಾಗಿದೆ | ಕೆಲವು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಮಾತ್ರ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಚಿತ್ರಿಸಲಾಗಿದೆ ಅಥವಾ ವಿವರಿಸಲಾಗಿದೆ ಅಥವಾ ನೀಡಲಾದ ಡೇಟಾ ಅಪರ್ಯಾಪ್ತವಾಗಿದೆ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/7-TimeSeries/1-Introduction/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T16:14:38+00:00",
"source_file": "7-TimeSeries/1-Introduction/solution/Julia/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/7-TimeSeries/1-Introduction/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T16:15:12+00:00",
"source_file": "7-TimeSeries/1-Introduction/solution/R/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

172
translations/kn/7-TimeSeries/1-Introduction/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

63
translations/kn/7-TimeSeries/1-Introduction/working/notebook.ipynb
Unescape View File

@ -0,0 +1,63 @@
{
"cells": [
{
"source": [
"# ಡೇಟಾ ಸೆಟ್ ಅಪ್\n",
"\n",
"ಈ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ, ನಾವು ಹೇಗೆ ಮಾಡುವುದು ಎಂದು ತೋರಿಸುತ್ತೇವೆ:\n",
"\n",
"ಈ ಮೋಡ್ಯೂಲ್‌ಗಾಗಿ ಕಾಲ ಸರಣಿಯ ಡೇಟಾವನ್ನು ಸೆಟ್ ಅಪ್ ಮಾಡುವುದು\n",
"ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸುವುದು\n",
"ಈ ಉದಾಹರಣೆಯಲ್ಲಿನ ಡೇಟಾ GEFCom2014 ಮುನ್ಸೂಚನಾ ಸ್ಪರ್ಧೆಯಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ1. ಇದು 2012 ಮತ್ತು 2014 ರ ನಡುವೆ 3 ವರ್ಷಗಳ ಗಂಟೆಗಂಟೆಯ ವಿದ್ಯುತ್ ಲೋಡ್ ಮತ್ತು ತಾಪಮಾನ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.\n",
"\n",
"1ಟಾವ್ ಹಾಂಗ್, ಪಿಯೆರ್ರೆ ಪಿನ್ಸನ್, ಶು ಫ್ಯಾನ್, ಹಮಿದ್ರೆಜಾ ಜರೆಪೌರ್, ಅಲ್ಬೆರ್ಟೋ ಟ್ರೊಕೋಲ್ಲಿ ಮತ್ತು ರಾಬ್ ಜೆ. ಹಿಂಡ್ಮನ್, \"ಪ್ರಾಬಬಿಲಿಸ್ಟಿಕ್ ಎನರ್ಜಿ ಫೋರ್ಕಾಸ್ಟಿಂಗ್: ಗ್ಲೋಬಲ್ ಎನರ್ಜಿ ಫೋರ್ಕಾಸ್ಟಿಂಗ್ ಸ್ಪರ್ಧೆ 2014 ಮತ್ತು ಮುಂದಿನ ಕಾಲ\", ಇಂಟರ್‌ನ್ಯಾಷನಲ್ ಜರ್ನಲ್ ಆಫ್ ಫೋರ್ಕಾಸ್ಟಿಂಗ್, ವಾಲ್ಯೂಮ್ 32, ಸಂಖ್ಯೆ 3, ಪುಟಗಳು 896-913, ಜುಲೈ-ಸೆಪ್ಟೆಂಬರ್, 2016.\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
],
"metadata": {
"kernel_info": {
"name": "python3"
},
"kernelspec": {
"name": "python37364bit8d3b438fb5fc4430a93ac2cb74d693a7",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"nteract": {
"version": "nteract-front-end@1.0.0"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"coopTranslator": {
"original_hash": "5e2bbe594906dce3aaaa736d6dac6683",
"translation_date": "2025-12-19T17:36:37+00:00",
"source_file": "7-TimeSeries/1-Introduction/working/notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

409
translations/kn/7-TimeSeries/2-ARIMA/README.md
Unescape View File

@ -0,0 +1,409 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "917dbf890db71a322f306050cb284749",
"translation_date": "2025-12-19T16:12:07+00:00",
"source_file": "7-TimeSeries/2-ARIMA/README.md",
"language_code": "kn"
}
-->
# ARIMA ಬಳಸಿ ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿ
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ತಿಳಿದುಕೊಂಡಿದ್ದೀರಿ ಮತ್ತು ಒಂದು ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿದ್ದೀರಿ, ಅದು ಒಂದು ಕಾಲಾವಧಿಯಲ್ಲಿ ವಿದ್ಯುತ್ ಲೋಡ್‌ನ ಅಸ್ಥಿರತೆಯನ್ನು ತೋರಿಸುತ್ತದೆ.
[![ARIMA ಗೆ ಪರಿಚಯ](https://img.youtube.com/vi/IUSk-YDau10/0.jpg)](https://youtu.be/IUSk-YDau10 "ARIMA ಗೆ ಪರಿಚಯ")
> 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ವೀಡಿಯೋ ನೋಡಿ: ARIMA ಮಾದರಿಗಳ ಸಂಕ್ಷಿಪ್ತ ಪರಿಚಯ. ಉದಾಹರಣೆ R ನಲ್ಲಿ ಮಾಡಲಾಗಿದೆ, ಆದರೆ ತತ್ವಗಳು ಸರ್ವತ್ರ ಅನ್ವಯವಾಗುತ್ತವೆ.
## [ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
## ಪರಿಚಯ
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು [ARIMA: *A*uto*R*egressive *I*ntegrated *M*oving *A*verage](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average) ಬಳಸಿ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ವಿಶೇಷ ವಿಧಾನವನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತೀರಿ. ARIMA ಮಾದರಿಗಳು ವಿಶೇಷವಾಗಿ [ನಾನ್-ಸ್ಟೇಷನರಿ](https://wikipedia.org/wiki/Stationary_process) ಆಗಿರುವ ಡೇಟಾಗೆ ಹೊಂದಿಕೊಳ್ಳಲು ಸೂಕ್ತವಾಗಿವೆ.
## ಸಾಮಾನ್ಯ ತತ್ವಗಳು
ARIMA ಜೊತೆ ಕೆಲಸ ಮಾಡಲು, ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಕೆಲವು ತತ್ವಗಳಿವೆ:
- 🎓 **ಸ್ಟೇಷನರಿ**. ಸಾಂಖ್ಯಿಕ ದೃಷ್ಟಿಕೋನದಿಂದ, ಸ್ಟೇಷನರಿ ಎಂದರೆ ಕಾಲದಲ್ಲಿ ಸರಿದೂಗಿಸಿದಾಗ ಡೇಟಾದ ವಿತರಣೆಯು ಬದಲಾಗದಿರುವುದು. ನಾನ್-ಸ್ಟೇಷನರಿ ಡೇಟಾ ಎಂದರೆ, ವಿಶ್ಲೇಷಿಸಲು ಪರಿವರ್ತನೆ ಮಾಡಬೇಕಾದ ಪ್ರವೃತ್ತಿಗಳಿಂದ ಅಸ್ಥಿರತೆ ತೋರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಋತುವಿನ ಪ್ರಭಾವದಿಂದ ಡೇಟಾದಲ್ಲಿ ಅಸ್ಥಿರತೆ ಉಂಟಾಗಬಹುದು ಮತ್ತು ಅದನ್ನು 'seasonal-differencing' ಪ್ರಕ್ರಿಯೆಯಿಂದ ತೆಗೆದುಹಾಕಬಹುದು.
- 🎓 **[ಡಿಫರೆನ್ಸಿಂಗ್](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. ಡಿಫರೆನ್ಸಿಂಗ್ ಎಂದರೆ, ನಾನ್-ಸ್ಟೇಷನರಿ ಡೇಟಾವನ್ನು ಅದರ ಅಸ್ಥಿರ ಪ್ರವೃತ್ತಿಯನ್ನು ತೆಗೆದುಹಾಕಿ ಸ್ಟೇಷನರಿ ಮಾಡಲು ಪರಿವರ್ತಿಸುವ ಪ್ರಕ್ರಿಯೆ. "ಡಿಫರೆನ್ಸಿಂಗ್ ಕಾಲ ಸರಣಿಯ ಮಟ್ಟದಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಪ್ರವೃತ್ತಿ ಮತ್ತು ಋತುವಿನ ಅಸ್ಥಿರತೆಯನ್ನು ನಿವಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ ಕಾಲ ಸರಣಿಯ ಸರಾಸರಿಯನ್ನು ಸ್ಥಿರಗೊಳಿಸುತ್ತದೆ." [ಶಿಕ್ಷಾಂಗ್ ಇತ್ಯಾದಿಗಳ ಪತ್ರಿಕೆ](https://arxiv.org/abs/1904.07632)
## ಕಾಲ ಸರಣಿಯ ಸನ್ನಿವೇಶದಲ್ಲಿ ARIMA
ARIMA ಭಾಗಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ಅದು ಕಾಲ ಸರಣಿಯನ್ನು ಹೇಗೆ ಮಾದರಿಮಾಡಲು ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳೋಣ.
- **AR - AutoRegressive**. Autoregressive ಮಾದರಿಗಳು, ಹೆಸರಿನಂತೆ, ನಿಮ್ಮ ಡೇಟಾದ ಹಿಂದಿನ ಮೌಲ್ಯಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು 'ಹಿಂದಕ್ಕೆ' ನೋಡುತ್ತವೆ ಮತ್ತು ಅವುಗಳ ಬಗ್ಗೆ ಊಹೆ ಮಾಡುತ್ತವೆ. ಈ ಹಿಂದಿನ ಮೌಲ್ಯಗಳನ್ನು 'ಲ್ಯಾಗ್'ಗಳು ಎಂದು ಕರೆಯುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ಪೆನ್ಸಿಲ್ ಮಾರಾಟದ ಮಾಸಿಕ ಡೇಟಾ. ಪ್ರತಿ ತಿಂಗಳ ಮಾರಾಟ ಮೊತ್ತವನ್ನು 'ವಿಕಸಿಸುತ್ತಿರುವ ಚರ' ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಈ ಮಾದರಿ "ವಿಕಸಿಸುತ್ತಿರುವ ಚರವು ತನ್ನ ಸ್ವಂತ ಲ್ಯಾಗ್ (ಹಿಂದಿನ) ಮೌಲ್ಯಗಳ ಮೇಲೆ ರಿಗ್ರೆಶನ್ ಆಗುತ್ತದೆ." [ವಿಕಿಪೀಡಿಯ](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average)
- **I - Integrated**. ARMA ಮಾದರಿಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ARIMA ಯಲ್ಲಿರುವ 'I' ಅದರ *[ಒಕ್ಕೂಟ](https://wikipedia.org/wiki/Order_of_integration)* ಅಂಶವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಡಿಫರೆನ್ಸಿಂಗ್ ಹಂತಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ ಡೇಟಾ 'ಒಕ್ಕೂಟ' ಆಗುತ್ತದೆ ಮತ್ತು ನಾನ್-ಸ್ಟೇಷನರಿ ಅಸ್ಥಿರತೆಯನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
- **MA - Moving Average**. ಈ ಮಾದರಿಯ [moving-average](https://wikipedia.org/wiki/Moving-average_model) ಅಂಶವು ಲ್ಯಾಗ್‌ಗಳ ಪ್ರಸ್ತುತ ಮತ್ತು ಹಿಂದಿನ ಮೌಲ್ಯಗಳನ್ನು ಗಮನಿಸಿ ನಿರ್ಧರಿಸಲಾದ ಔಟ್‌ಪುಟ್ ಚರವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ಮುಖ್ಯಾಂಶ: ARIMA ವಿಶೇಷ ರೀತಿಯ ಕಾಲ ಸರಣಿ ಡೇಟಾಗೆ ಅತ್ಯಂತ ಸಮೀಪವಾಗಿ ಹೊಂದಿಕೊಳ್ಳಲು ಬಳಸಲಾಗುತ್ತದೆ.
## ಅಭ್ಯಾಸ - ARIMA ಮಾದರಿ ನಿರ್ಮಿಸಿ
ಈ ಪಾಠದಲ್ಲಿ [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/working) ಫೋಲ್ಡರ್ ತೆರೆಯಿರಿ ಮತ್ತು [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/2-ARIMA/working/notebook.ipynb) ಫೈಲ್ ಅನ್ನು ಹುಡುಕಿ.
1. `statsmodels` ಪೈಥಾನ್ ಲೈಬ್ರರಿಯನ್ನು ಲೋಡ್ ಮಾಡಲು ನೋಟ್ಬುಕ್ ಅನ್ನು ರನ್ ಮಾಡಿ; ARIMA ಮಾದರಿಗಳಿಗೆ ಇದನ್ನು ನೀವು ಬಳಸುತ್ತೀರಿ.
1. ಅಗತ್ಯವಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ
1. ಈಗ, ಡೇಟಾ ಪ್ಲಾಟ್ ಮಾಡಲು ಉಪಯುಕ್ತವಾದ ಇನ್ನಷ್ಟು ಲೈಬ್ರರಿಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ:
```python
import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime as dt
import math
from pandas.plotting import autocorrelation_plot
from statsmodels.tsa.statespace.sarimax import SARIMAX
from sklearn.preprocessing import MinMaxScaler
from common.utils import load_data, mape
from IPython.display import Image
%matplotlib inline
pd.options.display.float_format = '{:,.2f}'.format
np.set_printoptions(precision=2)
warnings.filterwarnings("ignore") # ಎಚ್ಚರಿಕೆ ಸಂದೇಶಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಲು ಸೂಚಿಸಿ
```
1. `/data/energy.csv` ಫೈಲ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗೆ ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ನೋಡಿ:
```python
energy = load_data('./data')[['load']]
energy.head(10)
```
1. ಜನವರಿ 2012 ರಿಂದ ಡಿಸೆಂಬರ್ 2014 ರವರೆಗೆ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಎನರ್ಜಿ ಡೇಟಾವನ್ನು ಪ್ಲಾಟ್ ಮಾಡಿ. ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ನಾವು ಈ ಡೇಟಾವನ್ನು ನೋಡಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ಯಾವುದೇ ಆಶ್ಚರ್ಯವಿಲ್ಲ:
```python
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
ಈಗ, ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸೋಣ!
### ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ರಚಿಸಿ
ನಿಮ್ಮ ಡೇಟಾ ಲೋಡ್ ಆದ ಮೇಲೆ, ಅದನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸಬಹುದು. ನೀವು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಸೆಟ್‌ನಲ್ಲಿ ತರಬೇತಿಮಾಡುತ್ತೀರಿ. ಸಾಮಾನ್ಯವಾಗಿ, ಮಾದರಿ ತರಬೇತಿ ಮುಗಿದ ನಂತರ, ನೀವು ಅದರ ನಿಖರತೆಯನ್ನು ಪರೀಕ್ಷಾ ಸೆಟ್ ಬಳಸಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತೀರಿ. ಪರೀಕ್ಷಾ ಸೆಟ್ ತರಬೇತಿ ಸೆಟ್‌ನ ನಂತರದ ಕಾಲಾವಧಿಯನ್ನು ಒಳಗೊಂಡಿರಬೇಕು, ಇದರಿಂದ ಮಾದರಿ ಭವಿಷ್ಯದ ಕಾಲಾವಧಿಗಳಿಂದ ಮಾಹಿತಿ ಪಡೆಯುವುದಿಲ್ಲ.
1. 2014 ಸೆಪ್ಟೆಂಬರ್ 1 ರಿಂದ ಅಕ್ಟೋಬರ್ 31 ರವರೆಗೆ ಎರಡು ತಿಂಗಳ ಅವಧಿಯನ್ನು ತರಬೇತಿ ಸೆಟ್‌ಗೆ ಮೀಸಲಿಡಿ. ಪರೀಕ್ಷಾ ಸೆಟ್ 2014 ನವೆಂಬರ್ 1 ರಿಂದ ಡಿಸೆಂಬರ್ 31 ರವರೆಗೆ ಎರಡು ತಿಂಗಳ ಅವಧಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:
```python
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```
ಈ ಡೇಟಾ ದೈನಂದಿನ ಎನರ್ಜಿ ಬಳಕೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವುದರಿಂದ, ಬಲವಾದ ಋತುವಿನ ಮಾದರಿಯಿದೆ, ಆದರೆ ಬಳಕೆ ಇತ್ತೀಚಿನ ದಿನಗಳ ಬಳಕೆಗೆ ಹೆಚ್ಚು ಸಮಾನವಾಗಿದೆ.
1. ವ್ಯತ್ಯಾಸಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಿ:
```python
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
![ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ](../../../../translated_images/train-test.8928d14e5b91fc942f0ca9201b2d36c890ea7e98f7619fd94f75de3a4c2bacb9.kn.png)
ಆದ್ದರಿಂದ, ಡೇಟಾವನ್ನು ತರಬೇತಿಗೆ ಸಾಪೇಕ್ಷವಾಗಿ ಸಣ್ಣ ಕಾಲಾವಧಿ ವಿಂಡೋ ಬಳಸುವುದು ಸಾಕಾಗುತ್ತದೆ.
> ಟಿಪ್ಪಣಿ: ARIMA ಮಾದರಿಯನ್ನು ಹೊಂದಿಸಲು ನಾವು ಬಳಸುವ ಫಂಕ್ಷನ್ ಫಿಟಿಂಗ್ ಸಮಯದಲ್ಲಿ ಇನ್-ಸ್ಯಾಂಪಲ್ ಮಾನ್ಯತೆ ಬಳಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಮಾನ್ಯತೆ ಡೇಟಾವನ್ನು ಹೊರತುಪಡಿಸುತ್ತೇವೆ.
### ತರಬೇತಿಗೆ ಡೇಟಾವನ್ನು ಸಿದ್ಧಪಡಿಸಿ
ಈಗ, ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್ ಮೂಲಕ ತರಬೇತಿಗೆ ಸಿದ್ಧಪಡಿಸಬೇಕು. ನೀವು ಬೇಕಾದ ಕಾಲಾವಧಿಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಂತೆ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ, ಮತ್ತು ಡೇಟಾವನ್ನು 0,1 ನಡುವಿನ ಅಂತರಾಳದಲ್ಲಿ ಪ್ರಕ್ಷೇಪಿಸಲು ಸ್ಕೇಲ್ ಮಾಡಿ.
1. ಮೂಲ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಮೇಲ್ಕಂಡ ಕಾಲಾವಧಿಗಳ ಪ್ರಕಾರ ಮತ್ತು 'load' ಮತ್ತು ದಿನಾಂಕ ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಂತೆ ಫಿಲ್ಟರ್ ಮಾಡಿ:
```python
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
test = energy.copy()[energy.index >= test_start_dt][['load']]
print('Training data shape: ', train.shape)
print('Test data shape: ', test.shape)
```
ಡೇಟಾದ ಆಕಾರವನ್ನು ನೋಡಬಹುದು:
```output
Training data shape: (1416, 1)
Test data shape: (48, 1)
```
1. ಡೇಟಾವನ್ನು (0, 1) ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಸ್ಕೇಲ್ ಮಾಡಿ.
```python
scaler = MinMaxScaler()
train['load'] = scaler.fit_transform(train)
train.head(10)
```
1. ಮೂಲ ಮತ್ತು ಸ್ಕೇಲ್ಡ್ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿ:
```python
energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12)
train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12)
plt.show()
```
![ಮೂಲ](../../../../translated_images/original.b2b15efe0ce92b8745918f071dceec2231661bf49c8db6918e3ff4b3b0b183c2.kn.png)
> ಮೂಲ ಡೇಟಾ
![ಸ್ಕೇಲ್ಡ್](../../../../translated_images/scaled.e35258ca5cd3d43f86d5175e584ba96b38d51501f234abf52e11f4fe2631e45f.kn.png)
> ಸ್ಕೇಲ್ಡ್ ಡೇಟಾ
1. ಈಗ ನೀವು ಸ್ಕೇಲ್ಡ್ ಡೇಟಾವನ್ನು ಕ್ಯಾಲಿಬ್ರೇಟ್ ಮಾಡಿದ್ದೀರಿ, ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಸ್ಕೇಲ್ ಮಾಡಬಹುದು:
```python
test['load'] = scaler.transform(test)
test.head()
```
### ARIMA ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ
ARIMA ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವ ಸಮಯ ಬಂದಿದೆ! ನೀವು ಈಗ ಮೊದಲು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ `statsmodels` ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೀರಿ.
ಈಗ ನೀವು ಕೆಲವು ಹಂತಗಳನ್ನು ಅನುಸರಿಸಬೇಕು
1. `SARIMAX()` ಅನ್ನು ಕರೆ ಮಾಡಿ ಮತ್ತು ಮಾದರಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು p, d, q ಮತ್ತು P, D, Q ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಪಾಸ್ ಮಾಡಿ.
2. ತರಬೇತಿ ಡೇಟಾ ಮೇಲೆ ಮಾದರಿಯನ್ನು ಸಿದ್ಧಪಡಿಸಲು fit() ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆ ಮಾಡಿ.
3. `forecast()` ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆ ಮಾಡಿ ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಹಂತಗಳ ಸಂಖ್ಯೆ (ಹೋರೈಜನ್) ಅನ್ನು ಸೂಚಿಸಿ.
> 🎓 ಈ ಎಲ್ಲಾ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಏಕೆ? ARIMA ಮಾದರಿಯಲ್ಲಿ ಮೂರು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿವೆ, ಅವು ಕಾಲ ಸರಣಿಯ ಪ್ರಮುಖ ಅಂಶಗಳನ್ನು ಮಾದರಿಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ: ಋತುವಿನ ಪ್ರಭಾವ, ಪ್ರವೃತ್ತಿ ಮತ್ತು ಶಬ್ದ. ಈ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು:
`p`: ಮಾದರಿಯ ಸ್ವಯಂ-ಪ್ರತಿಗಾಮಿ ಅಂಶಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಪ್ಯಾರಾಮೀಟರ್, ಇದು *ಹಿಂದಿನ* ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
`d`: ಮಾದರಿಯ ಒಕ್ಕೂಟ ಭಾಗಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಪ್ಯಾರಾಮೀಟರ್, ಇದು ಕಾಲ ಸರಣಿಗೆ ಅನ್ವಯಿಸುವ *ಡಿಫರೆನ್ಸಿಂಗ್* (🎓 ಡಿಫರೆನ್ಸಿಂಗ್ ನೆನಪಿಸಿಕೊಳ್ಳಿ 👆) ಪ್ರಮಾಣವನ್ನು ಪ್ರಭಾವಿಸುತ್ತದೆ.
`q`: ಮಾದರಿಯ ಚಲಿಸುವ ಸರಾಸರಿ ಭಾಗಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಪ್ಯಾರಾಮೀಟರ್.
> ಟಿಪ್ಪಣಿ: ನಿಮ್ಮ ಡೇಟಾದಲ್ಲಿ ಋತುವಿನ ಅಂಶವಿದ್ದರೆ - ಇದರಲ್ಲಿ ಇದೆ - ನಾವು ಋತುವಿನ ARIMA ಮಾದರಿಯನ್ನು (SARIMA) ಬಳಸುತ್ತೇವೆ. ಆ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಇನ್ನೊಂದು ಪ್ಯಾರಾಮೀಟರ್ ಸೆಟ್ ಅನ್ನು ಬಳಸಬೇಕು: `P`, `D`, ಮತ್ತು `Q` , ಅವು `p`, `d`, ಮತ್ತು `q` ನಂತೆ ಸಂಬಂಧಿಸಿದವು, ಆದರೆ ಮಾದರಿಯ ಋತುವಿನ ಅಂಶಗಳಿಗೆ ಸಂಬಂಧಿಸಿದವು.
1. ನಿಮ್ಮ ಇಚ್ಛಿತ ಹೋರೈಜನ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಿ. 3 ಗಂಟೆಗಳ ಪ್ರಯತ್ನ ಮಾಡೋಣ:
```python
# ಮುಂದಿನ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಹೆಜ್ಜೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ
HORIZON = 3
print('Forecasting horizon:', HORIZON, 'hours')
```
ARIMA ಮಾದರಿಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಉತ್ತಮ ಮೌಲ್ಯಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಸವಾಲಿನಾಯಕವಾಗಬಹುದು ಏಕೆಂದರೆ ಇದು ಸ್ವಲ್ಪ ವಿಷಯಾತ್ಮಕ ಮತ್ತು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನೀವು [`pyramid` ಲೈಬ್ರರಿಯಿಂದ](https://alkaline-ml.com/pmdarima/0.9.0/modules/generated/pyramid.arima.auto_arima.html) `auto_arima()` ಫಂಕ್ಷನ್ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಬಹುದು.
1. ಈಗಾಗಲೇ ಕೆಲವು ಕೈಯಿಂದ ಆಯ್ಕೆಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ ಉತ್ತಮ ಮಾದರಿಯನ್ನು ಹುಡುಕಿ.
```python
order = (4, 1, 0)
seasonal_order = (1, 1, 0, 24)
model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order)
results = model.fit()
print(results.summary())
```
ಫಲಿತಾಂಶಗಳ ಟೇಬಲ್ ಮುದ್ರಿತವಾಗುತ್ತದೆ.
ನೀವು ನಿಮ್ಮ ಮೊದಲ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ! ಈಗ ಅದನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು.
### ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ
ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು, ನೀವು 'walk forward' ಮಾನ್ಯತೆ ಎಂದು ಕರೆಯುವ ವಿಧಾನವನ್ನು ಅನುಸರಿಸಬಹುದು. ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಕಾಲ ಸರಣಿ ಮಾದರಿಗಳನ್ನು ಪ್ರತಿ ಹೊಸ ಡೇಟಾ ಲಭ್ಯವಾಗುವಾಗ ಮರುತರಬೇತಿಮಾಡಲಾಗುತ್ತದೆ. ಇದರಿಂದ ಮಾದರಿ ಪ್ರತಿ ಕಾಲ ಹಂತದಲ್ಲಿ ಉತ್ತಮ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು.
ಕಾಲ ಸರಣಿಯ ಆರಂಭದಿಂದ ಈ ತಂತ್ರವನ್ನು ಬಳಸಿ, ತರಬೇತಿ ಡೇಟಾ ಸೆಟ್‌ನಲ್ಲಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಿ. ನಂತರ ಮುಂದಿನ ಕಾಲ ಹಂತದ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿ. ಭವಿಷ್ಯವಾಣಿ ತಿಳಿದಿರುವ ಮೌಲ್ಯಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ. ನಂತರ ತರಬೇತಿ ಸೆಟ್ ಅನ್ನು ತಿಳಿದಿರುವ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಿ ವಿಸ್ತರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ.
> ಟಿಪ್ಪಣಿ: ನೀವು ತರಬೇತಿ ಸೆಟ್ ವಿಂಡೋವನ್ನು ಸ್ಥಿರವಾಗಿರಿಸಬೇಕು, ಇದರಿಂದ ಪ್ರತಿ ಬಾರಿ ಹೊಸ ವೀಕ್ಷಣೆಯನ್ನು ಸೇರಿಸುವಾಗ, ಆರಂಭದ ವೀಕ್ಷಣೆಯನ್ನು ತೆಗೆದುಹಾಕಬಹುದು ಮತ್ತು ತರಬೇತಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗುತ್ತದೆ.
ಈ ಪ್ರಕ್ರಿಯೆ ಮಾದರಿ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಹೆಚ್ಚು ದೃಢವಾದ ಅಂದಾಜನ್ನು ನೀಡುತ್ತದೆ. ಆದರೆ, ಇದರಿಂದ ಅನೇಕ ಮಾದರಿಗಳನ್ನು ರಚಿಸುವ ಗಣನೆ ವೆಚ್ಚ ಬರುತ್ತದೆ. ಡೇಟಾ ಸಣ್ಣದಾಗಿದ್ದರೆ ಅಥವಾ ಮಾದರಿ ಸರಳವಾಗಿದ್ದರೆ ಇದು ಸ್ವೀಕಾರಾರ್ಹ, ಆದರೆ ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಸಮಸ್ಯೆಯಾಗಬಹುದು.
Walk-forward ಮಾನ್ಯತೆ ಕಾಲ ಸರಣಿ ಮಾದರಿಯ ಮೌಲ್ಯಮಾಪನದ ಚಿನ್ನದ ಮಾನದಂಡವಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ಯೋಜನೆಗಳಿಗೆ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
1. ಪ್ರತಿ HORIZON ಹಂತಕ್ಕೆ ಪರೀಕ್ಷಾ ಡೇಟಾ ಪಾಯಿಂಟ್ ರಚಿಸಿ.
```python
test_shifted = test.copy()
for t in range(1, HORIZON+1):
test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H')
test_shifted = test_shifted.dropna(how='any')
test_shifted.head(5)
```
| | | load | load+1 | load+2 |
| ---------- | -------- | ---- | ------ | ------ |
| 2014-12-30 | 00:00:00 | 0.33 | 0.29 | 0.27 |
| 2014-12-30 | 01:00:00 | 0.29 | 0.27 | 0.27 |
| 2014-12-30 | 02:00:00 | 0.27 | 0.27 | 0.30 |
| 2014-12-30 | 03:00:00 | 0.27 | 0.30 | 0.41 |
| 2014-12-30 | 04:00:00 | 0.30 | 0.41 | 0.57 |
ಡೇಟಾ ಅದರ ಹೋರೈಜನ್ ಪಾಯಿಂಟ್ ಪ್ರಕಾರ ಅಡ್ಡವಾಗಿ ಸರಿಸಲಾಗಿದೆ.
1. ಈ ಸ್ಲೈಡಿಂಗ್ ವಿಂಡೋ ವಿಧಾನವನ್ನು ಬಳಸಿ ಪರೀಕ್ಷಾ ಡೇಟಾದ ಉದ್ದದ ಲೂಪ್‌ನಲ್ಲಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿ:
```python
%%time
training_window = 720 # ತರಬೇತಿಗೆ 30 ದಿನಗಳು (720 ಗಂಟೆಗಳು) ಮೀಸಲಿಡಿ
train_ts = train['load']
test_ts = test_shifted
history = [x for x in train_ts]
history = history[(-training_window):]
predictions = list()
order = (2, 1, 0)
seasonal_order = (1, 1, 0, 24)
for t in range(test_ts.shape[0]):
model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order)
model_fit = model.fit()
yhat = model_fit.forecast(steps = HORIZON)
predictions.append(yhat)
obs = list(test_ts.iloc[t])
# ತರಬೇತಿ ವಿಂಡೋವನ್ನು ಸರಿಸಿ
history.append(obs[0])
history.pop(0)
print(test_ts.index[t])
print(t+1, ': predicted =', yhat, 'expected =', obs)
```
ತರಬೇತಿ ನಡೆಯುತ್ತಿರುವುದನ್ನು ನೀವು ನೋಡಬಹುದು:
```output
2014-12-30 00:00:00
1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323]
2014-12-30 01:00:00
2 : predicted = [0.3 0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126]
2014-12-30 02:00:00
3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795]
```
1. ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ನಿಜವಾದ ಲೋಡ್ ಜೊತೆಗೆ ಹೋಲಿಸಿ:
```python
eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)])
eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1]
eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')
eval_df['actual'] = np.array(np.transpose(test_ts)).ravel()
eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])
eval_df.head()
```
ಔಟ್‌ಪುಟ್
| | | timestamp | h | prediction | actual |
| --- | ---------- | --------- | --- | ---------- | -------- |
| 0 | 2014-12-30 | 00:00:00 | t+1 | 3,008.74 | 3,023.00 |
| 1 | 2014-12-30 | 01:00:00 | t+1 | 2,955.53 | 2,935.00 |
| 2 | 2014-12-30 | 02:00:00 | t+1 | 2,900.17 | 2,899.00 |
| 3 | 2014-12-30 | 03:00:00 | t+1 | 2,917.69 | 2,886.00 |
| 4 | 2014-12-30 | 04:00:00 | t+1 | 2,946.99 | 2,963.00 |
ಗಂಟೆಗಟ್ಟಲೆ ಡೇಟಾದ ಭವಿಷ್ಯವಾಣಿ ಮತ್ತು ನಿಜವಾದ ಲೋಡ್ ಅನ್ನು ಗಮನಿಸಿ. ಇದು ಎಷ್ಟು ನಿಖರವಾಗಿದೆ?
### ಮಾದರಿಯ ನಿಖರತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ
ನಿಮ್ಮ ಮಾದರಿಯ ನಿಖರತೆಯನ್ನು ಎಲ್ಲಾ ಭವಿಷ್ಯವಾಣಿಗಳ ಮೇಲೆ ಸರಾಸರಿ ಶೇಕಡಾವಾರು ದೋಷ (MAPE) ಪರೀಕ್ಷಿಸುವ ಮೂಲಕ ಪರಿಶೀಲಿಸಿ.
> **🧮 ಗಣಿತವನ್ನು ತೋರಿಸಿ**
>
> ![MAPE](../../../../translated_images/mape.fd87bbaf4d346846df6af88b26bf6f0926bf9a5027816d5e23e1200866e3e8a4.kn.png)
>
> [MAPE](https://www.linkedin.com/pulse/what-mape-mad-msd-time-series-allameh-statistics/) ಅನ್ನು ಮೇಲಿನ ಸೂತ್ರದಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಅನುಪಾತವಾಗಿ ಭವಿಷ್ಯವಾಣಿ ನಿಖರತೆಯನ್ನು ತೋರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. actual<sub>t</sub> ಮತ್ತು predicted<sub>t</sub> ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು actual<sub>t</sub> ಮೂಲಕ ಭಾಗಿಸಲಾಗುತ್ತದೆ. "ಈ ಲೆಕ್ಕಾಚಾರದಲ್ಲಿ ಪರಮ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿ ಭವಿಷ್ಯವಾಣಿ ಸಮಯದ ಬಿಂದುವಿಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಹೊಂದಿಸಿದ ಬಿಂದುಗಳ ಸಂಖ್ಯೆ n ಮೂಲಕ ಭಾಗಿಸಲಾಗುತ್ತದೆ." [wikipedia](https://wikipedia.org/wiki/Mean_absolute_percentage_error)
1. ಸಮೀಕರಣವನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಿ:
```python
if(HORIZON > 1):
eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual']
print(eval_df.groupby('h')['APE'].mean())
```
1. ಒಂದು ಹಂತದ MAPE ಅನ್ನು ಲೆಕ್ಕಹಾಕಿ:
```python
print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%')
```
ಒಂದು ಹಂತದ ಭವಿಷ್ಯವಾಣಿ MAPE: 0.5570581332313952 %
1. ಬಹು ಹಂತದ ಭವಿಷ್ಯವಾಣಿ MAPE ಅನ್ನು ಮುದ್ರಿಸಿ:
```python
print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%')
```
```output
Multi-step forecast MAPE: 1.1460048657704118 %
```
ಒಳ್ಳೆಯ ಕಡಿಮೆ ಸಂಖ್ಯೆ ಉತ್ತಮ: MAPE 10 ಇರುವ ಭವಿಷ್ಯವಾಣಿ 10% ತಪ್ಪಿದೆ ಎಂದು ಪರಿಗಣಿಸಿ.
1. ಆದರೆ ಯಾವಾಗಲೂ ಹಾಗೆಯೇ, ಈ ರೀತಿಯ ನಿಖರತೆ ಅಳೆಯುವಿಕೆಯನ್ನು ದೃಶ್ಯವಾಗಿ ನೋಡುವುದು ಸುಲಭ, ಆದ್ದರಿಂದ ಅದನ್ನು ರೇಖಾಚಿತ್ರಗೊಳಿಸೋಣ:
```python
if(HORIZON == 1):
## ಏಕ ಹಂತದ ಭವಿಷ್ಯವಾಣಿ ರೇಖಾಚಿತ್ರಣ
eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8))
else:
## ಬಹು ಹಂತದ ಭವಿಷ್ಯವಾಣಿ ರೇಖಾಚಿತ್ರಣ
plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']]
for t in range(1, HORIZON+1):
plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values
fig = plt.figure(figsize=(15, 8))
ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)
ax = fig.add_subplot(111)
for t in range(1, HORIZON+1):
x = plot_df['timestamp'][(t-1):]
y = plot_df['t+'+str(t)][0:len(x)]
ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t))
ax.legend(loc='best')
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
![a time series model](../../../../translated_images/accuracy.2c47fe1bf15f44b3656651c84d5e2ba9b37cd929cd2aa8ab6cc3073f50570f4e.kn.png)
🏆 ಅತ್ಯುತ್ತಮ ನಿಖರತೆಯೊಂದಿಗೆ ಮಾದರಿಯನ್ನು ತೋರಿಸುವ ಅತ್ಯಂತ ಚೆನ್ನಾದ ರೇಖಾಚಿತ್ರ. ಶುಭಾಶಯಗಳು!
---
## 🚀ಸವಾಲು
ಟೈಮ್ ಸೀರಿಸ್ ಮಾದರಿಯ ನಿಖರತೆಯನ್ನು ಪರೀಕ್ಷಿಸುವ ವಿಧಾನಗಳನ್ನು ಆಳವಾಗಿ ಅಧ್ಯಯನ ಮಾಡಿ. ಈ ಪಾಠದಲ್ಲಿ ನಾವು MAPE ಬಗ್ಗೆ ಸ್ಪರ್ಶಿಸಿದ್ದೇವೆ, ಆದರೆ ನೀವು ಬಳಸಬಹುದಾದ ಇತರ ವಿಧಾನಗಳಿವೆಯೇ? ಅವುಗಳನ್ನು ಸಂಶೋಧಿಸಿ ಮತ್ತು ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸಿ. ಸಹಾಯಕ ದಾಖಲೆ [ಇಲ್ಲಿ](https://otexts.com/fpp2/accuracy.html) ಲಭ್ಯವಿದೆ
## [ಪಾಠೋತ್ತರ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ಈ ಪಾಠವು ARIMA ಬಳಸಿ ಟೈಮ್ ಸೀರಿಸ್ ಭವಿಷ್ಯವಾಣಿಯ ಮೂಲಭೂತಗಳನ್ನು ಮಾತ್ರ ಸ್ಪರ್ಶಿಸುತ್ತದೆ. [ಈ ಸಂಗ್ರಹಾಲಯ](https://microsoft.github.io/forecasting/) ಮತ್ತು ಅದರ ವಿವಿಧ ಮಾದರಿ ಪ್ರಕಾರಗಳನ್ನು ಆಳವಾಗಿ ಅಧ್ಯಯನ ಮಾಡಿ ಟೈಮ್ ಸೀರಿಸ್ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ಇತರ ವಿಧಾನಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳಲು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಿ.
## ನಿಯೋಜನೆ
[ಹೊಸ ARIMA ಮಾದರಿ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/kn/7-TimeSeries/2-ARIMA/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1c814013e10866dfd92cdb32caaae3ac",
"translation_date": "2025-12-19T16:14:00+00:00",
"source_file": "7-TimeSeries/2-ARIMA/assignment.md",
"language_code": "kn"
}
-->
# ಹೊಸ ARIMA ಮಾದರಿ
## ಸೂಚನೆಗಳು
ನೀವು ಈಗಾಗಲೇ ARIMA ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ, ಹೊಸ ಡೇಟಾ ಬಳಸಿ ಹೊಸದೊಂದು ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ ([Duke ನಿಂದ ಈ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಪ್ರಯತ್ನಿಸಿ](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). ನಿಮ್ಮ ಕೆಲಸವನ್ನು ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಟಿಪ್ಪಣಿ ಮಾಡಿ, ಡೇಟಾ ಮತ್ತು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ದೃಶ್ಯೀಕರಿಸಿ, ಮತ್ತು MAPE ಬಳಸಿ ಅದರ ನಿಖರತೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ.
## ಮೌಲ್ಯಮಾಪನ
| ಮಾನದಂಡಗಳು | ಉದಾಹರಣೀಯ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆಯ ಅಗತ್ಯವಿದೆ |
| -------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- | ----------------------------------- |
| | ಹೊಸ ARIMA ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ, ಪರೀಕ್ಷಿಸಿ, ದೃಶ್ಯೀಕರಣಗಳೊಂದಿಗೆ ವಿವರಿಸಿ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಸೂಚಿಸಿದ ನೋಟ್ಬುಕ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ. | ಪ್ರಸ್ತುತಪಡಿಸಿದ ನೋಟ್ಬುಕ್ ಟಿಪ್ಪಣಿಸದ ಅಥವಾ ದೋಷಗಳಿರುವುದು | ಅಪೂರ್ಣ ನೋಟ್ಬುಕ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/7-TimeSeries/2-ARIMA/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T16:15:43+00:00",
"source_file": "7-TimeSeries/2-ARIMA/solution/Julia/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/7-TimeSeries/2-ARIMA/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T16:16:17+00:00",
"source_file": "7-TimeSeries/2-ARIMA/solution/R/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

1101
translations/kn/7-TimeSeries/2-ARIMA/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

59
translations/kn/7-TimeSeries/2-ARIMA/working/notebook.ipynb
Unescape View File

@ -0,0 +1,59 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": 3
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "523ec472196307b3c4235337353c9ceb",
"translation_date": "2025-12-19T17:37:45+00:00",
"source_file": "7-TimeSeries/2-ARIMA/working/notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# ARIMA ಬಳಸಿ ಕಾಲ ಸರಣಿ ಮುನ್ಸೂಚನೆ\n",
"\n",
"ಈ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ, ನಾವು ಹೇಗೆ ಮಾಡುವುದು ಎಂದು ತೋರಿಸುತ್ತೇವೆ:\n",
"- ARIMA ಕಾಲ ಸರಣಿ ಮುನ್ಸೂಚನೆ ಮಾದರಿಗಾಗಿ ಕಾಲ ಸರಣಿ ಡೇಟಾವನ್ನು ತರಬೇತಿಗೆ ಸಿದ್ಧಪಡಿಸುವುದು\n",
"- ಸರಳ ARIMA ಮಾದರಿಯನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ ಮುಂದಿನ HORIZON ಹಂತಗಳನ್ನು ಮುನ್ಸೂಚಿಸುವುದು (ಕಾಲ *t+1* ರಿಂದ *t+HORIZON* ವರೆಗೆ)\n",
"- ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು\n",
"\n",
"ಈ ಉದಾಹರಣೆಯಲ್ಲಿನ ಡೇಟಾ GEFCom2014 ಮುನ್ಸೂಚನೆ ಸ್ಪರ್ಧೆಯಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ<sup>1</sup>. ಇದು 2012 ರಿಂದ 2014 ರವರೆಗೆ 3 ವರ್ಷಗಳ ಗಂಟೆಗಂಟೆ ವಿದ್ಯುತ್ ಲೋಡ್ ಮತ್ತು ತಾಪಮಾನ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಕಾರ್ಯವು ಭವಿಷ್ಯದ ವಿದ್ಯುತ್ ಲೋಡ್ ಮೌಲ್ಯಗಳನ್ನು ಮುನ್ಸೂಚಿಸುವುದಾಗಿದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಇತಿಹಾಸದ ಲೋಡ್ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಬಳಸಿಕೊಂಡು ಒಂದು ಕಾಲ ಹಂತ ಮುನ್ಸೂಚಿಸುವುದನ್ನು ತೋರಿಸುತ್ತೇವೆ.\n",
"\n",
"<sup>1</sup>ಟಾವ್ ಹಾಂಗ್, ಪಿಯೆರ್ರೆ ಪಿನ್ಸನ್, ಶು ಫ್ಯಾನ್, ಹಮಿದ್ರೆಜಾ ಜರೈಪೌರ್, ಅಲ್ಬೆರ್ಟೋ ಟ್ರೊಕೋಲ್ಲಿ ಮತ್ತು ರಾಬ್ ಜೆ. ಹಿಂಡ್ಮನ್, \"ಪ್ರೊಬಬಿಲಿಸ್ಟಿಕ್ ಎನರ್ಜಿ ಫೋರ್ಕಾಸ್ಟಿಂಗ್: ಗ್ಲೋಬಲ್ ಎನರ್ಜಿ ಫೋರ್ಕಾಸ್ಟಿಂಗ್ ಸ್ಪರ್ಧೆ 2014 ಮತ್ತು ನಂತರ\", ಇಂಟರ್‌ನ್ಯಾಷನಲ್ ಜರ್ನಲ್ ಆಫ್ ಫೋರ್ಕಾಸ್ಟಿಂಗ್, ವಾಲ್ಯೂಮ್ 32, ಸಂಖ್ಯೆ 3, ಪುಟಗಳು 896-913, ಜುಲೈ-ಸೆಪ್ಟೆಂಬರ್, 2016.\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pip install statsmodels"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**: \nಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
]
}

402
translations/kn/7-TimeSeries/3-SVR/README.md
Unescape View File

@ -0,0 +1,402 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "482bccabe1df958496ea71a3667995cd",
"translation_date": "2025-12-19T15:59:58+00:00",
"source_file": "7-TimeSeries/3-SVR/README.md",
"language_code": "kn"
}
-->
# ಸಮಯ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ ಸಹಾಯ ವಕ್ಟರ್ ರೆಗ್ರೆಸರ್‌ನೊಂದಿಗೆ
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಸಮಯ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಗಾಗಿ ARIMA ಮಾದರಿಯನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ಕಲಿತಿರಿ. ಈಗ ನೀವು ನಿರಂತರ ಡೇಟಾವನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಳಸುವ ರೆಗ್ರೆಸರ್ ಮಾದರಿ ಆಗಿರುವ Support Vector Regressor ಮಾದರಿಯನ್ನು ನೋಡಲಿದ್ದೀರಿ.
## [ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ಪರಿಚಯ
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ರೆಗ್ರೆಷನ್‌ಗಾಗಿ [**SVM**: **S**ಪೋರ್ಟ್ **V**ೆಕ್ಟರ್ **M**ಶೀನ್](https://en.wikipedia.org/wiki/Support-vector_machine) ಬಳಸಿ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ವಿಶೇಷ ವಿಧಾನವನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತೀರಿ, ಅಥವಾ **SVR: Support Vector Regressor**.
### ಸಮಯ ಸರಣಿಯ ಸಂದರ್ಭದಲ್ಲಿ SVR [^1]
ಸಮಯ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಯಲ್ಲಿ SVR ಮಹತ್ವವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೊದಲು, ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಕೆಲವು ಪ್ರಮುಖ ಸಂಪ್ರದಾಯಗಳು ಇಲ್ಲಿವೆ:
- **ರೆಗ್ರೆಷನ್:** ನಿರಂತರ ಮೌಲ್ಯಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ನೀಡಲಾದ ಇನ್ಪುಟ್‌ಗಳ ಸೆಟ್‌ನಿಂದ ಸೂಪರ್ವೈಸ್ಡ್ ಲರ್ನಿಂಗ್ ತಂತ್ರ. ಆಲೋಚನೆ ಎಂದರೆ ಫೀಚರ್ ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಅತಿ ಹೆಚ್ಚು ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ವಕ್ರರೇಖೆ (ಅಥವಾ ರೇಖೆ) ಅನ್ನು ಹೊಂದಿಸುವುದು. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ [ಇಲ್ಲಿ ಕ್ಲಿಕ್ ಮಾಡಿ](https://en.wikipedia.org/wiki/Regression_analysis).
- **ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ಮಷೀನ್ (SVM):** ವರ್ಗೀಕರಣ, ರೆಗ್ರೆಷನ್ ಮತ್ತು ಔಟ್‌ಲೈಯರ್ ಪತ್ತೆಗಾಗಿ ಬಳಸುವ ಒಂದು ವಿಧದ ಸೂಪರ್ವೈಸ್ಡ್ ಮಷೀನ್ ಲರ್ನಿಂಗ್ ಮಾದರಿ. ಈ ಮಾದರಿ ಫೀಚರ್ ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಒಂದು ಹೈಪರ್ಪ್ಲೇನ್ ಆಗಿದ್ದು, ವರ್ಗೀಕರಣದಲ್ಲಿ ಇದು ಗಡಿಬಿಡಿ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ರೆಗ್ರೆಷನ್‌ನಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. SVM ನಲ್ಲಿ, ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಹೆಚ್ಚಿನ ಆಯಾಮಗಳ ಸ್ಥಳಕ್ಕೆ ಪರಿವರ್ತಿಸಲು Kernel ಫಂಕ್ಷನ್ ಬಳಸಲಾಗುತ್ತದೆ, ಇದರಿಂದ ಅವುಗಳನ್ನು ಸುಲಭವಾಗಿ ವಿಭಜಿಸಬಹುದು. SVM ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ [ಇಲ್ಲಿ ಕ್ಲಿಕ್ ಮಾಡಿ](https://en.wikipedia.org/wiki/Support-vector_machine).
- **ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ರೆಗ್ರೆಸರ್ (SVR):** SVM ರ ಒಂದು ವಿಧ, ಅತಿ ಹೆಚ್ಚು ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಅತ್ಯುತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆಯನ್ನು (SVM ನಲ್ಲಿ ಹೈಪರ್ಪ್ಲೇನ್) ಕಂಡುಹಿಡಿಯಲು.
### ಏಕೆ SVR? [^1]
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ನೀವು ARIMA ಬಗ್ಗೆ ಕಲಿತಿರಿ, ಇದು ಸಮಯ ಸರಣಿ ಡೇಟಾವನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಅತ್ಯಂತ ಯಶಸ್ವಿ ಸಾಂಖ್ಯಿಕ ರೇಖೀಯ ವಿಧಾನವಾಗಿದೆ. ಆದರೆ, ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಸಮಯ ಸರಣಿ ಡೇಟಾದಲ್ಲಿ *ಅರೇಖೀಯತೆ* ಇರುತ್ತದೆ, ಇದನ್ನು ರೇಖೀಯ ಮಾದರಿಗಳಿಂದ ನಕ್ಷೆ ಹಾಕಲಾಗುವುದಿಲ್ಲ. ಇಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ರೆಗ್ರೆಷನ್ ಕಾರ್ಯಗಳಿಗೆ ಡೇಟಾದಲ್ಲಿನ ಅರೇಖೀಯತೆಯನ್ನು ಪರಿಗಣಿಸುವ SVM ಯ ಶಕ್ತಿ SVR ಅನ್ನು ಸಮಯ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಯಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿಸುತ್ತದೆ.
## ಅಭ್ಯಾಸ - SVR ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ
ಡೇಟಾ ತಯಾರಿಕೆಗೆ ಮೊದಲ ಕೆಲವು ಹಂತಗಳು ಹಿಂದಿನ [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA) ಪಾಠದಂತೆಯೇ ಇವೆ.
ಈ ಪಾಠದಲ್ಲಿ [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/3-SVR/working) ಫೋಲ್ಡರ್ ತೆರೆಯಿರಿ ಮತ್ತು [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/3-SVR/working/notebook.ipynb) ಫೈಲ್ ಅನ್ನು ಹುಡುಕಿ.[^2]
1. ನೋಟ್ಬುಕ್ ಅನ್ನು ರನ್ ಮಾಡಿ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡಿ: [^2]
```python
import sys
sys.path.append('../../')
```
```python
import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime as dt
import math
from sklearn.svm import SVR
from sklearn.preprocessing import MinMaxScaler
from common.utils import load_data, mape
```
2. `/data/energy.csv` ಫೈಲ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗೆ ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ನೋಡಿ: [^2]
```python
energy = load_data('../../data')[['load']]
```
3. ಜನವರಿ 2012 ರಿಂದ ಡಿಸೆಂಬರ್ 2014 ರವರೆಗೆ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಎನರ್ಜಿ ಡೇಟಾವನ್ನು ಪ್ಲಾಟ್ ಮಾಡಿ: [^2]
```python
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
![ಪೂರ್ಣ ಡೇಟಾ](../../../../translated_images/full-data.a82ec9957e580e976f651a4fc38f280b9229c6efdbe3cfe7c60abaa9486d2cbe.kn.png)
ಈಗ, ನಮ್ಮ SVR ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸೋಣ.
### ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ರಚಿಸಿ
ನಿಮ್ಮ ಡೇಟಾ ಈಗ ಲೋಡ್ ಆಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸಬಹುದು. ನಂತರ ನೀವು SVR ಗೆ ಅಗತ್ಯವಿರುವ ಸಮಯ-ಹಂತ ಆಧಾರಿತ ಡೇಟಾಸೆಟ್ ರಚಿಸಲು ಡೇಟಾವನ್ನು ಮರುರೂಪಗೊಳಿಸುವಿರಿ. ನೀವು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಸೆಟ್‌ನಲ್ಲಿ ತರಬೇತಿಮಾಡುತ್ತೀರಿ. ಮಾದರಿ ತರಬೇತಿ ಮುಗಿದ ನಂತರ, ನೀವು ಅದರ ನಿಖರತೆಯನ್ನು ತರಬೇತಿ ಸೆಟ್, ಪರೀಕ್ಷಾ ಸೆಟ್ ಮತ್ತು ನಂತರ ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತೀರಿ. ಮಾದರಿ ಭವಿಷ್ಯದ ಸಮಯ ಅವಧಿಗಳಿಂದ ಮಾಹಿತಿ ಪಡೆಯದಂತೆ ಪರೀಕ್ಷಾ ಸೆಟ್ ತರಬೇತಿ ಸೆಟ್‌ನ ನಂತರದ ಅವಧಿಯನ್ನು ಒಳಗೊಂಡಿರಬೇಕು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು [^2] (*ಒವರ್‌ಫಿಟಿಂಗ್* ಎಂದು ಕರೆಯಲ್ಪಡುವ ಪರಿಸ್ಥಿತಿ).
1. 2014 ಸೆಪ್ಟೆಂಬರ್ 1 ರಿಂದ ಅಕ್ಟೋಬರ್ 31 ರವರೆಗೆ ಎರಡು ತಿಂಗಳ ಅವಧಿಯನ್ನು ತರಬೇತಿ ಸೆಟ್‌ಗೆ ಮೀಸಲಿಡಿ. ಪರೀಕ್ಷಾ ಸೆಟ್ 2014 ನವೆಂಬರ್ 1 ರಿಂದ ಡಿಸೆಂಬರ್ 31 ರವರೆಗೆ ಎರಡು ತಿಂಗಳ ಅವಧಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ: [^2]
```python
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```
2. ವ್ಯತ್ಯಾಸಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಿ: [^2]
```python
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
![ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ](../../../../translated_images/train-test.ead0cecbfc341921d4875eccf25fed5eefbb860cdbb69cabcc2276c49e4b33e5.kn.png)
### ತರಬೇತಿಗಾಗಿ ಡೇಟಾವನ್ನು ತಯಾರಿಸಿ
ಈಗ, ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್ ಮೂಲಕ ತರಬೇತಿಗಾಗಿ ತಯಾರಿಸಬೇಕಾಗಿದೆ. ನೀವು ಬೇಕಾದ ಕಾಲಾವಧಿಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಂತೆ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ, ಮತ್ತು ಡೇಟಾ 0 ಮತ್ತು 1 ನಡುವಿನ ಅಂತರಾಳದಲ್ಲಿ ಪ್ರಕ್ಷೇಪಿತವಾಗುವಂತೆ ಸ್ಕೇಲ್ ಮಾಡಬೇಕು.
1. ಪ್ರಾರಂಭಿಕ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಮೇಲ್ಕಂಡ ಕಾಲಾವಧಿಗಳನ್ನೂ ಮತ್ತು 'load' ಕಾಲಮ್ ಜೊತೆಗೆ ದಿನಾಂಕವನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಂತೆ ಫಿಲ್ಟರ್ ಮಾಡಿ: [^2]
```python
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
test = energy.copy()[energy.index >= test_start_dt][['load']]
print('Training data shape: ', train.shape)
print('Test data shape: ', test.shape)
```
```output
Training data shape: (1416, 1)
Test data shape: (48, 1)
```
2. ತರಬೇತಿ ಡೇಟಾವನ್ನು (0, 1) ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಸ್ಕೇಲ್ ಮಾಡಿ: [^2]
```python
scaler = MinMaxScaler()
train['load'] = scaler.fit_transform(train)
```
4. ಈಗ, ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಸ್ಕೇಲ್ ಮಾಡಿ: [^2]
```python
test['load'] = scaler.transform(test)
```
### ಸಮಯ-ಹಂತಗಳೊಂದಿಗೆ ಡೇಟಾ ರಚಿಸಿ [^1]
SVR ಗಾಗಿ, ನೀವು ಇನ್ಪುಟ್ ಡೇಟಾವನ್ನು `[batch, timesteps]` ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತೀರಿ. ಆದ್ದರಿಂದ, ನೀವು ಇತ್ತೀಚೆಗೆ ಇರುವ `train_data` ಮತ್ತು `test_data` ಅನ್ನು ಮರುರೂಪಗೊಳಿಸಿ, ಹೊಸ ಆಯಾಮವು ಸಮಯ ಹಂತಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ.
```python
# ನಂಪೈ ಅರೆಗಳಾಗಿ ಪರಿವರ್ತನೆ ಮಾಡಲಾಗುತ್ತಿದೆ
train_data = train.values
test_data = test.values
```
ಈ ಉದಾಹರಣೆಗೆ, ನಾವು `timesteps = 5` ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ಮಾದರಿಗೆ ಇನ್ಪುಟ್‌ಗಳು ಮೊದಲ 4 ಸಮಯ ಹಂತಗಳ ಡೇಟಾಗಳಾಗಿದ್ದು, ಔಟ್‌ಪುಟ್ 5ನೇ ಸಮಯ ಹಂತದ ಡೇಟಾಗಿರುತ್ತದೆ.
```python
timesteps=5
```
ನೋಡಿದಂತೆ, ತರಬೇತಿ ಡೇಟಾವನ್ನು 2D ಟೆನ್ಸರ್‌ಗೆ ಪರಿವರ್ತಿಸುವ nested list comprehension:
```python
train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
train_data_timesteps.shape
```
```output
(1412, 5)
```
ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು 2D ಟೆನ್ಸರ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು:
```python
test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
test_data_timesteps.shape
```
```output
(44, 5)
```
ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾದಿಂದ ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು:
```python
x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
```
```output
(1412, 4) (1412, 1)
(44, 4) (44, 1)
```
### SVR ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ [^1]
ಈಗ, SVR ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವ ಸಮಯ. ಈ ಅನುಷ್ಠಾನ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ನೀವು [ಈ ಡಾಕ್ಯುಮೆಂಟೇಶನ್](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html) ಅನ್ನು ನೋಡಿ. ನಮ್ಮ ಅನುಷ್ಠಾನಕ್ಕಾಗಿ, ನಾವು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ:
1. `SVR()` ಅನ್ನು ಕರೆಸಿ ಮತ್ತು ಮಾದರಿ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು kernel, gamma, c ಮತ್ತು epsilon ಅನ್ನು ಪಾಸ್ ಮಾಡಿ
2. `fit()` ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಸಿ ತರಬೇತಿ ಡೇಟಾಗೆ ಮಾದರಿಯನ್ನು ತಯಾರಿಸಿ
3. `predict()` ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಸಿ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡಿ
ಈಗ ನಾವು SVR ಮಾದರಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ. ಇಲ್ಲಿ ನಾವು [RBF kernel](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel) ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು gamma, C ಮತ್ತು epsilon ಅನ್ನು ಕ್ರಮವಾಗಿ 0.5, 10 ಮತ್ತು 0.05 ಎಂದು ಹೊಂದಿಸುತ್ತೇವೆ.
```python
model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)
```
#### ತರಬೇತಿ ಡೇಟಾದ ಮೇಲೆ ಮಾದರಿಯನ್ನು ಹೊಂದಿಸಿ [^1]
```python
model.fit(x_train, y_train[:,0])
```
```output
SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
```
#### ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡಿ [^1]
```python
y_train_pred = model.predict(x_train).reshape(-1,1)
y_test_pred = model.predict(x_test).reshape(-1,1)
print(y_train_pred.shape, y_test_pred.shape)
```
```output
(1412, 1) (44, 1)
```
ನೀವು ನಿಮ್ಮ SVR ಅನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ! ಈಗ ಅದನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡೋಣ.
### ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ [^1]
ಮೌಲ್ಯಮಾಪನಕ್ಕಾಗಿ, ಮೊದಲು ನಾವು ಡೇಟಾವನ್ನು ಮೂಲ ಮಾಪಕಕ್ಕೆ ಮರುಸ್ಕೇಲ್ ಮಾಡುತ್ತೇವೆ. ನಂತರ, ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು, ನಾವು ಮೂಲ ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಸಮಯ ಸರಣಿ ಪ್ಲಾಟ್ ಅನ್ನು ಚಿತ್ರಿಸುತ್ತೇವೆ ಮತ್ತು MAPE ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸುತ್ತೇವೆ.
ಭವಿಷ್ಯವಾಣಿ ಮತ್ತು ಮೂಲ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸ್ಕೇಲ್ ಮಾಡಿ:
```python
# ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಪನ ಮಾಡುವುದು
y_train_pred = scaler.inverse_transform(y_train_pred)
y_test_pred = scaler.inverse_transform(y_test_pred)
print(len(y_train_pred), len(y_test_pred))
```
```python
# ಮೂಲ ಮೌಲ್ಯಗಳನ್ನು ಮಾಪನಗೊಳಿಸುವುದು
y_train = scaler.inverse_transform(y_train)
y_test = scaler.inverse_transform(y_test)
print(len(y_train), len(y_test))
```
#### ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾದ ಮೇಲೆ ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ [^1]
ನಮ್ಮ ಪ್ಲಾಟ್‌ನ x-ಅಕ್ಷದಲ್ಲಿ ತೋರಿಸಲು ಡೇಟಾಸೆಟ್‌ನಿಂದ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ನಾವು ಮೊದಲ ```timesteps-1``` ಮೌಲ್ಯಗಳನ್ನು ಮೊದಲ ಔಟ್‌ಪುಟ್‌ಗೆ ಇನ್ಪುಟ್ ಆಗಿ ಬಳಸುತ್ತಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ಔಟ್‌ಪುಟ್‌ಗಾಗಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಅದರಿಂದ ನಂತರ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ.
```python
train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
test_timestamps = energy[test_start_dt:].index[timesteps-1:]
print(len(train_timestamps), len(test_timestamps))
```
```output
1412 44
```
ತರಬೇತಿ ಡೇಟಾದ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಪ್ಲಾಟ್ ಮಾಡಿ:
```python
plt.figure(figsize=(25,6))
plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.title("Training data prediction")
plt.show()
```
![ತರಬೇತಿ ಡೇಟಾ ಭವಿಷ್ಯವಾಣಿ](../../../../translated_images/train-data-predict.3c4ef4e78553104ffdd53d47a4c06414007947ea328e9261ddf48d3eafdefbbf.kn.png)
ತರಬೇತಿ ಡೇಟಾದ MAPE ಅನ್ನು ಮುದ್ರಿಸಿ
```python
print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')
```
```output
MAPE for training data: 1.7195710200875551 %
```
ಪರೀಕ್ಷಾ ಡೇಟಾದ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಪ್ಲಾಟ್ ಮಾಡಿ
```python
plt.figure(figsize=(10,3))
plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.show()
```
![ಪರೀಕ್ಷಾ ಡೇಟಾ ಭವಿಷ್ಯವಾಣಿ](../../../../translated_images/test-data-predict.8afc47ee7e52874f514ebdda4a798647e9ecf44a97cc927c535246fcf7a28aa9.kn.png)
ಪರೀಕ್ಷಾ ಡೇಟಾದ MAPE ಅನ್ನು ಮುದ್ರಿಸಿ
```python
print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')
```
```output
MAPE for testing data: 1.2623790187854018 %
```
🏆 ನೀವು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಫಲಿತಾಂಶವನ್ನು ಪಡೆದಿದ್ದೀರಿ!
### ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ [^1]
```python
# ಲೋಡ್ ಮೌಲ್ಯಗಳನ್ನು numpy ಅರೆ ಆಗಿ ಹೊರತೆಗೆಯುವುದು
data = energy.copy().values
# ಮಾಪನ
data = scaler.transform(data)
# ಮಾದರಿ ಇನ್‌ಪುಟ್ ಅಗತ್ಯದ ಪ್ರಕಾರ 2D ಟೆನ್ಸರ್ ಗೆ ಪರಿವರ್ತಿಸುವುದು
data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
print("Tensor shape: ", data_timesteps.shape)
# ಡೇಟಾದಿಂದ ಇನ್‌ಪುಟ್‌ಗಳು ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
print("X shape: ", X.shape,"\nY shape: ", Y.shape)
```
```output
Tensor shape: (26300, 5)
X shape: (26300, 4)
Y shape: (26300, 1)
```
```python
# ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿ
Y_pred = model.predict(X).reshape(-1,1)
# ವಿಲೋಮ ಮಾಪನ ಮತ್ತು ಆಕಾರ ಬದಲಿಸಿ
Y_pred = scaler.inverse_transform(Y_pred)
Y = scaler.inverse_transform(Y)
```
```python
plt.figure(figsize=(30,8))
plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(Y_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.show()
```
![ಪೂರ್ಣ ಡೇಟಾ ಭವಿಷ್ಯವಾಣಿ](../../../../translated_images/full-data-predict.4f0fed16a131c8f3bcc57a3060039dc7f2f714a05b07b68c513e0fe7fb3d8964.kn.png)
```python
print('MAPE: ', mape(Y_pred, Y)*100, '%')
```
```output
MAPE: 2.0572089029888656 %
```
🏆 ಅತ್ಯುತ್ತಮ ಪ್ಲಾಟ್‌ಗಳು, ಉತ್ತಮ ನಿಖರತೆಯ ಮಾದರಿಯನ್ನು ತೋರಿಸುತ್ತಿವೆ. ಶುಭಾಶಯಗಳು!
---
## 🚀ಸವಾಲು
- ಮಾದರಿಯನ್ನು ರಚಿಸುವಾಗ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು (gamma, C, epsilon) ಅನ್ನು ಬದಲಾಯಿಸಿ ಮತ್ತು ಡೇಟಾದ ಮೇಲೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ ಯಾವ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಸೆಟ್ ಪರೀಕ್ಷಾ ಡೇಟಾದ ಮೇಲೆ ಉತ್ತಮ ಫಲಿತಾಂಶ ನೀಡುತ್ತದೆ ಎಂದು ನೋಡಿ. ಈ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿಯಲು, ನೀವು [ಈ ಡಾಕ್ಯುಮೆಂಟೇಶನ್](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel) ಅನ್ನು ನೋಡಿ.
- ಮಾದರಿಗಾಗಿ ವಿಭಿನ್ನ kernel ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಅವುಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ವಿಶ್ಲೇಷಿಸಿ. ಸಹಾಯಕ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ [ಇಲ್ಲಿ](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) ಲಭ್ಯವಿದೆ.
- ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಹಿಂದಕ್ಕೆ ನೋಡಲು ಮಾದರಿಗಾಗಿ `timesteps` ಗೆ ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ.
## [ಪೋಸ್ಟ್-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ಈ ಪಾಠವು ಸಮಯ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಗಾಗಿ SVR ಅನ್ವಯವನ್ನು ಪರಿಚಯಿಸುವುದಾಗಿತ್ತು. SVR ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ನೀವು [ಈ ಬ್ಲಾಗ್](https://www.analyticsvidhya.com/blog/2020/03/support-vector-regression-tutorial-for-machine-learning/) ಅನ್ನು ನೋಡಿ. ಈ [scikit-learn ಡಾಕ್ಯುಮೆಂಟೇಶನ್](https://scikit-learn.org/stable/modules/svm.html) ಸಾಮಾನ್ಯವಾಗಿ SVM ಗಳ, [SVR ಗಳ](https://scikit-learn.org/stable/modules/svm.html#regression) ಮತ್ತು ಬಳಸಬಹುದಾದ ವಿವಿಧ [kernel ಫಂಕ್ಷನ್‌ಗಳು](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) ಮತ್ತು ಅವುಗಳ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಕುರಿತು ಸಮಗ್ರ ವಿವರಣೆ ನೀಡುತ್ತದೆ.
## ನಿಯೋಜನೆ
[ಹೊಸ SVR ಮಾದರಿ](assignment.md)
## ಕ್ರೆಡಿಟ್‌ಗಳು
[^1]: ಈ ವಿಭಾಗದ ಪಠ್ಯ, ಕೋಡ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಅನ್ನು [@AnirbanMukherjeeXD](https://github.com/AnirbanMukherjeeXD) ಕೊಡುಗೆ ನೀಡಿದ್ದಾರೆ
[^2]: ಈ ವಿಭಾಗದ ಪಠ್ಯ, ಕೋಡ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಅನ್ನು [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA) ನಿಂದ ತೆಗೆದುಕೊಂಡಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

31
translations/kn/7-TimeSeries/3-SVR/assignment.md
Unescape View File

@ -0,0 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "94aa2fc6154252ae30a3f3740299707a",
"translation_date": "2025-12-19T16:01:44+00:00",
"source_file": "7-TimeSeries/3-SVR/assignment.md",
"language_code": "kn"
}
-->
# ಹೊಸ SVR ಮಾದರಿ
## ಸೂಚನೆಗಳು [^1]
ನೀವು ಈಗಾಗಲೇ SVR ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ, ಹೊಸ ಡೇಟಾ ಬಳಸಿ ಹೊಸದೊಂದು ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ (Duke ನಿಂದ [ಈ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಪ್ರಯತ್ನಿಸಿ](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). ನಿಮ್ಮ ಕೆಲಸವನ್ನು ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಟಿಪ್ಪಣಿ ಮಾಡಿ, ಡೇಟಾ ಮತ್ತು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ದೃಶ್ಯೀಕರಿಸಿ, ಮತ್ತು ಸೂಕ್ತ ಪ್ಲಾಟ್‌ಗಳು ಮತ್ತು MAPE ಬಳಸಿ ಅದರ ನಿಖರತೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ. ವಿವಿಧ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಮತ್ತು ಟೈಮ್‌ಸ್ಟೆಪ್ಸ್‌ಗಾಗಿ ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ.
## ರೂಬ್ರಿಕ್ [^1]
| ಮಾನದಂಡಗಳು | ಉದಾಹರಣೀಯ | ಸಮರ್ಪಕ | ಸುಧಾರಣೆಯ ಅಗತ್ಯ |
| -------- | ------------------------------------------------------------ | --------------------------------------------------------- | ----------------------------------- |
| | SVR ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ, ಪರೀಕ್ಷಿಸಿ, ದೃಶ್ಯೀಕರಣಗಳೊಂದಿಗೆ ವಿವರಿಸಿ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಸೂಚಿಸುವ ನೋಟ್ಬುಕ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ. | ಪ್ರಸ್ತುತಪಡಿಸಿದ ನೋಟ್ಬುಕ್ ಟಿಪ್ಪಣಿಸದಿರುವುದು ಅಥವಾ ದೋಷಗಳನ್ನು ಹೊಂದಿದೆ. | ಅಪೂರ್ಣ ನೋಟ್ಬುಕ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ |
[^1]:ಈ ವಿಭಾಗದ ಪಠ್ಯವು [ARIMA ನಿಂದ ನೀಡಲಾದ ಕಾರ್ಯ](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/assignment.md) ಆಧಾರಿತವಾಗಿದೆ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

1035
translations/kn/7-TimeSeries/3-SVR/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

711
translations/kn/7-TimeSeries/3-SVR/working/notebook.ipynb
Unescape View File

@ -0,0 +1,711 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "fv9OoQsMFk5A"
},
"source": [
"# ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ರೆಗ್ರೆಸರ್ ಬಳಸಿ ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ಈ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ, ನಾವು ಹೇಗೆ ಮಾಡುವುದು ಎಂದು ತೋರಿಸುತ್ತೇವೆ:\n",
"\n",
"- 2D ಕಾಲ ಸರಣಿ ಡೇಟಾವನ್ನು SVM ರೆಗ್ರೆಸರ್ ಮಾದರಿಗಾಗಿ ತರಬೇತಿಗೆ ಸಿದ್ಧಪಡಿಸುವುದು\n",
"- RBF ಕರ್ಣಲ್ ಬಳಸಿ SVR ಅನ್ನು ಜಾರಿಗೆ ತರುವುದು\n",
"- ಪ್ಲಾಟ್‌ಗಳು ಮತ್ತು MAPE ಬಳಸಿ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## ಮೋಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import sys\n",
"sys.path.append('../../')"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"id": "M687KNlQFp0-"
},
"outputs": [],
"source": [
"import os\n",
"import warnings\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import pandas as pd\n",
"import datetime as dt\n",
"import math\n",
"\n",
"from sklearn.svm import SVR\n",
"from sklearn.preprocessing import MinMaxScaler\n",
"from common.utils import load_data, mape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Cj-kfVdMGjWP"
},
"source": [
"## ಡೇಟಾ ಸಿದ್ಧತೆ\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8fywSjC6GsRz"
},
"source": [
"### ಡೇಟಾ ಲೋಡ್ ಮಾಡಿ\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 363
},
"id": "aBDkEB11Fumg",
"outputId": "99cf7987-0509-4b73-8cc2-75d7da0d2740"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>load</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>2012-01-01 00:00:00</th>\n",
" <td>2698.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2012-01-01 01:00:00</th>\n",
" <td>2558.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2012-01-01 02:00:00</th>\n",
" <td>2444.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2012-01-01 03:00:00</th>\n",
" <td>2402.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2012-01-01 04:00:00</th>\n",
" <td>2403.0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" load\n",
"2012-01-01 00:00:00 2698.0\n",
"2012-01-01 01:00:00 2558.0\n",
"2012-01-01 02:00:00 2444.0\n",
"2012-01-01 03:00:00 2402.0\n",
"2012-01-01 04:00:00 2403.0"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"energy = load_data('../../data')[['load']]\n",
"energy.head(5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "O0BWP13rGnh4"
},
"source": [
"### ಡೇಟಾವನ್ನು ಚಿತ್ರಿಸಿ\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 486
},
"id": "hGaNPKu_Gidk",
"outputId": "7f89b326-9057-4f49-efbe-cb100ebdf76d"
},
"outputs": [],
"source": [
"energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)\n",
"plt.xlabel('timestamp', fontsize=12)\n",
"plt.ylabel('load', fontsize=12)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IPuNor4eGwYY"
},
"source": [
"### ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ ರಚಿಸಿ\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ysvsNyONGt0Q"
},
"outputs": [],
"source": [
"train_start_dt = '2014-11-01 00:00:00'\n",
"test_start_dt = '2014-12-30 00:00:00'"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 548
},
"id": "SsfdLoPyGy9w",
"outputId": "d6d6c25b-b1f4-47e5-91d1-707e043237d7"
},
"outputs": [],
"source": [
"energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \\\n",
" .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \\\n",
" .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)\n",
"plt.xlabel('timestamp', fontsize=12)\n",
"plt.ylabel('load', fontsize=12)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XbFTqBw6G1Ch"
},
"source": [
"### ತರಬೇತಿಗಾಗಿ ಡೇಟಾ ಸಿದ್ಧಪಡಿಸುವುದು\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ಈಗ, ನಿಮ್ಮ ಡೇಟಾವನ್ನು ತರಬೇತಿಗಾಗಿ ತಯಾರಿಸಲು ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್ ಮಾಡುವ ಅಗತ್ಯವಿದೆ.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "cYivRdQpHDj3",
"outputId": "a138f746-461c-4fd6-bfa6-0cee094c4aa1"
},
"outputs": [],
"source": [
"train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]\n",
"test = energy.copy()[energy.index >= test_start_dt][['load']]\n",
"\n",
"print('Training data shape: ', train.shape)\n",
"print('Test data shape: ', test.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ಡೇಟಾವನ್ನು (0, 1) ಶ್ರೇಣಿಯಲ್ಲಿ ಮಾಪಿಸಿ.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 363
},
"id": "3DNntGQnZX8G",
"outputId": "210046bc-7a66-4ccd-d70d-aa4a7309949c"
},
"outputs": [],
"source": [
"scaler = MinMaxScaler()\n",
"train['load'] = scaler.fit_transform(train)\n",
"train.head(5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 206
},
"id": "26Yht-rzZexe",
"outputId": "20326077-a38a-4e78-cc5b-6fd7af95d301"
},
"outputs": [],
"source": [
"test['load'] = scaler.transform(test)\n",
"test.head(5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "x0n6jqxOQ41Z"
},
"source": [
"### ಕಾಲಚರಣಗಳೊಂದಿಗೆ ಡೇಟಾ ರಚನೆ\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fdmxTZtOQ8xs"
},
"source": [
"ನಮ್ಮ SVR ಗಾಗಿ, ನಾವು ಇನ್‌ಪುಟ್ ಡೇಟಾವನ್ನು `[batch, timesteps]` ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ನಾವು ಇತ್ತೀಚಿನ `train_data` ಮತ್ತು `test_data` ಅನ್ನು ಪುನರ್‌ರೂಪಗೊಳಿಸುತ್ತೇವೆ ಹಾಗಾಗಿ ಒಂದು ಹೊಸ ಆಯಾಮವು timesteps ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಗೆ, ನಾವು `timesteps = 5` ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ಮಾದರಿಯ ಇನ್‌ಪುಟ್‌ಗಳು ಮೊದಲ 4 timesteps ಗಾಗಿ ಡೇಟಾಗಳಾಗಿದ್ದು, ಔಟ್‌ಪುಟ್ 5ನೇ timestep ಗಾಗಿ ಡೇಟಾಗಿರುತ್ತದೆ.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Rpju-Sc2HFm0"
},
"outputs": [],
"source": [
"# Converting to numpy arrays\n",
"\n",
"train_data = train.values\n",
"test_data = test.values"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Selecting the timesteps\n",
"\n",
"timesteps=None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "O-JrsrsVJhUQ",
"outputId": "c90dbe71-bacc-4ec4-b452-f82fe5aefaef"
},
"outputs": [],
"source": [
"# Converting data to 2D tensor\n",
"\n",
"train_data_timesteps=None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "exJD8AI7KE4g",
"outputId": "ce90260c-f327-427d-80f2-77307b5a6318"
},
"outputs": [],
"source": [
"# Converting test data to 2D tensor\n",
"\n",
"test_data_timesteps=None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "2u0R2sIsLuq5"
},
"outputs": [],
"source": [
"x_train, y_train = None\n",
"x_test, y_test = None\n",
"\n",
"print(x_train.shape, y_train.shape)\n",
"print(x_test.shape, y_test.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8wIPOtAGLZlh"
},
"source": [
"## SVR ಮಾದರಿ ರಚನೆ ಮಾಡುವುದು\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "EhA403BEPEiD"
},
"outputs": [],
"source": [
"# Create model using RBF kernel\n",
"\n",
"model = None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "GS0UA3csMbqp",
"outputId": "d86b6f05-5742-4c1d-c2db-c40510bd4f0d"
},
"outputs": [],
"source": [
"# Fit model on training data"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Rz_x8S3UrlcF"
},
"source": [
"### ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿ\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "XR0gnt3MnuYS",
"outputId": "157e40ab-9a23-4b66-a885-0d52a24b2364"
},
"outputs": [],
"source": [
"# Making predictions\n",
"\n",
"y_train_pred = None\n",
"y_test_pred = None"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_2epncg-SGzr"
},
"source": [
"## ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ವಿಶ್ಲೇಷಣೆ ಮಾಡುವುದು\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Scaling the predictions\n",
"\n",
"y_train_pred = scaler.inverse_transform(y_train_pred)\n",
"y_test_pred = scaler.inverse_transform(y_test_pred)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "xmm_YLXhq7gV",
"outputId": "18392f64-4029-49ac-c71a-a4e2411152a1"
},
"outputs": [],
"source": [
"# Scaling the original values\n",
"\n",
"y_train = scaler.inverse_transform(y_train)\n",
"y_test = scaler.inverse_transform(y_test)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "u3LBj93coHEi",
"outputId": "d4fd49e8-8c6e-4bb0-8ef9-ca0b26d725b4"
},
"outputs": [],
"source": [
"# Extract the timesteps for x-axis\n",
"\n",
"train_timestamps = None\n",
"test_timestamps = None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.figure(figsize=(25,6))\n",
"# plot original output\n",
"# plot predicted output\n",
"plt.legend(['Actual','Predicted'])\n",
"plt.xlabel('Timestamp')\n",
"plt.title(\"Training data prediction\")\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LnhzcnYtXHCm",
"outputId": "f5f0d711-f18b-4788-ad21-d4470ea2c02b"
},
"outputs": [],
"source": [
"print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 225
},
"id": "53Q02FoqQH4V",
"outputId": "53e2d59b-5075-4765-ad9e-aed56c966583"
},
"outputs": [],
"source": [
"plt.figure(figsize=(10,3))\n",
"# plot original output\n",
"# plot predicted output\n",
"plt.legend(['Actual','Predicted'])\n",
"plt.xlabel('Timestamp')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "clOAUH-SXCJG",
"outputId": "a3aa85ff-126a-4a4a-cd9e-90b9cc465ef5"
},
"outputs": [],
"source": [
"print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "DHlKvVCId5ue"
},
"source": [
"## ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ ಭವಿಷ್ಯವಾಣಿ\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "cOFJ45vreO0N",
"outputId": "35628e33-ecf9-4966-8036-f7ea86db6f16"
},
"outputs": [],
"source": [
"# Extracting load values as numpy array\n",
"data = None\n",
"\n",
"# Scaling\n",
"data = None\n",
"\n",
"# Transforming to 2D tensor as per model input requirement\n",
"data_timesteps=None\n",
"\n",
"# Selecting inputs and outputs from data\n",
"X, Y = None, None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ESSAdQgwexIi"
},
"outputs": [],
"source": [
"# Make model predictions\n",
"\n",
"# Inverse scale and reshape\n",
"Y_pred = None\n",
"Y = None"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 328
},
"id": "M_qhihN0RVVX",
"outputId": "a89cb23e-1d35-437f-9d63-8b8907e12f80"
},
"outputs": [],
"source": [
"plt.figure(figsize=(30,8))\n",
"# plot original output\n",
"# plot predicted output\n",
"plt.legend(['Actual','Predicted'])\n",
"plt.xlabel('Timestamp')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "AcN7pMYXVGTK",
"outputId": "7e1c2161-47ce-496c-9d86-7ad9ae0df770"
},
"outputs": [],
"source": [
"print('MAPE: ', mape(Y_pred, Y)*100, '%')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"collapsed_sections": [],
"name": "Recurrent_Neural_Networks.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.1"
},
"coopTranslator": {
"original_hash": "e86ce102239a14c44585623b9b924a74",
"translation_date": "2025-12-19T17:34:36+00:00",
"source_file": "7-TimeSeries/3-SVR/working/notebook.ipynb",
"language_code": "kn"
}
},
"nbformat": 4,
"nbformat_minor": 1
}

39
translations/kn/7-TimeSeries/README.md
Unescape View File

@ -0,0 +1,39 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "61342603bad8acadbc6b2e4e3aab3f66",
"translation_date": "2025-12-19T13:11:51+00:00",
"source_file": "7-TimeSeries/README.md",
"language_code": "kn"
}
-->
# ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿ ಪರಿಚಯ
ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿ ಎಂದರೆ ಏನು? ಇದು ಭೂತಕಾಲದ ಪ್ರವೃತ್ತಿಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಭವಿಷ್ಯದ ಘಟನೆಗಳನ್ನು ಊಹಿಸುವುದಾಗಿದೆ.
## ಪ್ರಾದೇಶಿಕ ವಿಷಯ: ವಿಶ್ವದ ವಿದ್ಯುತ್ ಬಳಕೆ ✨
ಈ ಎರಡು ಪಾಠಗಳಲ್ಲಿ, ನೀವು ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿಗೆ ಪರಿಚಿತರಾಗುತ್ತೀರಿ, ಇದು ಯಂತ್ರ ಅಧ್ಯಯನದ ಒಂದು ಸ್ವಲ್ಪ ಕಡಿಮೆ ಪರಿಚಿತ ಕ್ಷೇತ್ರವಾಗಿದ್ದು, ಕೈಗಾರಿಕೆ ಮತ್ತು ವ್ಯವಹಾರ ಅನ್ವಯಿಕೆಗಳ ಸೇರಿದಂತೆ ಇತರ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಅತ್ಯಂತ ಮೌಲ್ಯವಂತವಾಗಿದೆ. ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ಈ ಮಾದರಿಗಳ ಉಪಯುಕ್ತತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಬಳಸಬಹುದು, ಆದರೆ ನಾವು ಇವುಗಳನ್ನು ಶ್ರೇಣೀಕೃತ ಯಂತ್ರ ಅಧ್ಯಯನದ ಸಂದರ್ಭದಲ್ಲಿ ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ ಏಕೆಂದರೆ ಮಾದರಿಗಳು ಭೂತಕಾಲದ ಆಧಾರದ ಮೇಲೆ ಭವಿಷ್ಯದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಊಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.
ನಮ್ಮ ಪ್ರಾದೇಶಿಕ ಗಮನವು ವಿಶ್ವದ ವಿದ್ಯುತ್ ಬಳಕೆಯ ಮೇಲೆ ಇದೆ, ಇದು ಭೂತಕಾಲದ ಲೋಡ್ ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ಭವಿಷ್ಯದ ವಿದ್ಯುತ್ ಬಳಕೆಯನ್ನು ಊಹಿಸುವುದನ್ನು ಕಲಿಯಲು ಆಸಕ್ತಿದಾಯಕ ಡೇಟಾಸೆಟ್ ಆಗಿದೆ. ಈ ರೀತಿಯ ಭವಿಷ್ಯವಾಣಿ ವ್ಯವಹಾರ ಪರಿಸರದಲ್ಲಿ ಅತ್ಯಂತ ಸಹಾಯಕವಾಗಬಹುದು ಎಂದು ನೀವು ನೋಡಬಹುದು.
![electric grid](../../../translated_images/electric-grid.0c21d5214db09ffae93c06a87ca2abbb9ba7475ef815129c5b423d7f9a7cf136.kn.jpg)
ರಾಜಸ್ಥಾನದಲ್ಲಿ ರಸ್ತೆಯ ಮೇಲೆ ವಿದ್ಯುತ್ ಕಂಬಗಳ ಫೋಟೋವನ್ನು [Peddi Sai hrithik](https://unsplash.com/@shutter_log?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) ಅವರು [Unsplash](https://unsplash.com/s/photos/electric-india?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) ನಲ್ಲಿ ತೆಗೆದಿದ್ದಾರೆ
## ಪಾಠಗಳು
1. [ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿಗೆ ಪರಿಚಯ](1-Introduction/README.md)
2. [ARIMA ಕಾಲ ಸರಣಿ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವುದು](2-ARIMA/README.md)
3. [ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಗೆ Support Vector Regressor ನಿರ್ಮಿಸುವುದು](3-SVR/README.md)
## ಕ್ರೆಡಿಟ್ಸ್
"ಕಾಲ ಸರಣಿಯ ಭವಿಷ್ಯವಾಣಿ ಪರಿಚಯ" ಅನ್ನು ⚡️ [Francesca Lazzeri](https://twitter.com/frlazzeri) ಮತ್ತು [Jen Looper](https://twitter.com/jenlooper) ರವರು ಬರೆಯಲಾಗಿದೆ. ಈ ನೋಟ್ಬುಕ್‌ಗಳು ಮೊದಲು ಆನ್ಲೈನ್‌ನಲ್ಲಿ [Azure "Deep Learning For Time Series" ರೆಪೊ](https://github.com/Azure/DeepLearningForTimeSeriesForecasting) ನಲ್ಲಿ ಪ್ರಕಟವಾಗಿದ್ದು, ಮೂಲತಃ Francesca Lazzeri ಅವರು ಬರೆದಿದ್ದಾರೆ. SVR ಪಾಠವನ್ನು [Anirban Mukherjee](https://github.com/AnirbanMukherjeeXD) ಅವರು ಬರೆದಿದ್ದಾರೆ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

336
translations/kn/8-Reinforcement/1-QLearning/README.md
Unescape View File

@ -0,0 +1,336 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "911efd5e595089000cb3c16fce1beab8",
"translation_date": "2025-12-19T15:50:39+00:00",
"source_file": "8-Reinforcement/1-QLearning/README.md",
"language_code": "kn"
}
-->
# ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ ಮತ್ತು ಕ್ಯೂ-ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ
![ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ಬಲವರ್ಧನೆಯ ಸಾರಾಂಶವನ್ನು ಸ್ಕೆಚ್‌ನೋಟ್‌ನಲ್ಲಿ](../../../../translated_images/ml-reinforcement.94024374d63348dbb3571c343ca7ddabef72adac0b8086d47164b769ba3a8a1d.kn.png)
> ಸ್ಕೆಚ್‌ನೋಟ್: [ಟೊಮೊಮಿ ಇಮುರಾ](https://www.twitter.com/girlie_mac)
ಬಲವರ್ಧಿತ ಅಧ್ಯಯನವು ಮೂರು ಪ್ರಮುಖ ಕಲ್ಪನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಏಜೆಂಟ್, ಕೆಲವು ಸ್ಥಿತಿಗಳು ಮತ್ತು ಪ್ರತಿ ಸ್ಥಿತಿಗೆ ಕ್ರಿಯೆಗಳ ಒಂದು ಸೆಟ್. ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯಲ್ಲಿ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಮೂಲಕ, ಏಜೆಂಟ್‌ಗೆ ಬಹುಮಾನ ನೀಡಲಾಗುತ್ತದೆ. ಮತ್ತೆ ಕಂಪ್ಯೂಟರ್ ಆಟ ಸೂಪರ್ ಮಾರಿಯೋವನ್ನು ಕಲ್ಪಿಸಿ. ನೀವು ಮಾರಿಯೋ, ನೀವು ಆಟದ ಮಟ್ಟದಲ್ಲಿ ಇದ್ದೀರಿ, ಒಂದು ಹಿಮ್ಮುಖದ ಬದಿಯ ಬಳಿ ನಿಂತಿದ್ದೀರಿ. ನಿಮ್ಮ ಮೇಲಿರುವುದು ನಾಣ್ಯ. ನೀವು ಮಾರಿಯೋ ಆಗಿದ್ದೀರಿ, ಆಟದ ಮಟ್ಟದಲ್ಲಿ, ನಿರ್ದಿಷ್ಟ ಸ್ಥಾನದಲ್ಲಿ ... ಅದು ನಿಮ್ಮ ಸ್ಥಿತಿ. ಬಲಕ್ಕೆ ಒಂದು ಹೆಜ್ಜೆ ಸಾಗುವುದು (ಒಂದು ಕ್ರಿಯೆ) ನಿಮ್ಮನ್ನು ಬದಿಯ ಮೇಲೆ ಕಳುಹಿಸುತ್ತದೆ, ಮತ್ತು ಅದರಿಂದ ನಿಮಗೆ ಕಡಿಮೆ ಸಂಖ್ಯಾತ್ಮಕ ಅಂಕ ಸಿಗುತ್ತದೆ. ಆದರೆ, ಜಂಪ್ ಬಟನ್ ಒತ್ತಿದರೆ ನೀವು ಒಂದು ಅಂಕ ಪಡೆಯುತ್ತೀರಿ ಮತ್ತು ಜೀವಂತವಾಗಿರುತ್ತೀರಿ. ಅದು ಧನಾತ್ಮಕ ಫಲಿತಾಂಶ ಮತ್ತು ಅದಕ್ಕೆ ಧನಾತ್ಮಕ ಸಂಖ್ಯಾತ್ಮಕ ಅಂಕ ನೀಡಬೇಕು.
ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ ಮತ್ತು ಸಿಮ್ಯುಲೇಟರ್ (ಆಟ) ಬಳಸಿ, ನೀವು ಆಟವನ್ನು ಹೇಗೆ ಆಡಬೇಕು ಎಂದು ಕಲಿಯಬಹುದು, ಬಹುಮಾನವನ್ನು ಗರಿಷ್ಠಗೊಳಿಸುವುದು ಎಂದರೆ ಜೀವಂತವಾಗಿದ್ದು ಸಾಧ್ಯವಾದಷ್ಟು ಅಂಕಗಳನ್ನು ಪಡೆಯುವುದು.
[![ಬಲವರ್ಧಿತ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo)
> 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ಡ್ಮಿಟ್ರಿ ಬಲವರ್ಧಿತ ಅಧ್ಯಯನವನ್ನು ಚರ್ಚಿಸುವುದನ್ನು ಕೇಳಿ
## [ಪೂರ್ವ-ವ್ಯಾಖ್ಯಾನ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
## ಪೂರ್ವಾಪೇಕ್ಷೆಗಳು ಮತ್ತು ಸೆಟಪ್
ಈ ಪಾಠದಲ್ಲಿ, ನಾವು ಪೈಥಾನ್‌ನಲ್ಲಿ ಕೆಲವು ಕೋಡ್‌ಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಲಿದ್ದೇವೆ. ನೀವು ಈ ಪಾಠದ ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್ ಕೋಡ್ ಅನ್ನು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಅಥವಾ ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಎಲ್ಲಿ ಬೇಕಾದರೂ ಚಾಲನೆ ಮಾಡಬಲ್ಲಿರಿ.
ನೀವು [ಪಾಠ ನೋಟ್ಬುಕ್](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) ತೆರೆಯಬಹುದು ಮತ್ತು ಈ ಪಾಠವನ್ನು ಅನುಸರಿಸಬಹುದು.
> **ಗಮನಿಸಿ:** ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ಕ್ಲೌಡ್‌ನಿಂದ ತೆರೆಯುತ್ತಿದ್ದರೆ, ನೀವು [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py) ಫೈಲ್ ಅನ್ನು ಕೂಡ ಪಡೆಯಬೇಕು, ಇದು ನೋಟ್ಬುಕ್ ಕೋಡ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಅದನ್ನು ನೋಟ್ಬುಕ್ ಇರುವ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಸೇರಿಸಿ.
## ಪರಿಚಯ
ಈ ಪಾಠದಲ್ಲಿ, ನಾವು ರಷ್ಯನ್ ಸಂಗೀತ ರಚಯಿತೃ [ಸೆರ್ಗೇ ಪ್ರೊಕೊಫಿಯೆವ್](https://en.wikipedia.org/wiki/Sergei_Prokofiev) ಅವರ ಸಂಗೀತ ಕಥೆಯ ಪ್ರೇರಣೆಯಿಂದ **[ಪೀಟರ್ ಮತ್ತು ವೋಲ್ಫ್](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)** ಜಗತ್ತನ್ನು ಅನ್ವೇಷಿಸುವೆವು. ನಾವು **ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ** ಬಳಸಿ ಪೀಟರ್ ತನ್ನ ಪರಿಸರವನ್ನು ಅನ್ವೇಷಿಸಿ, ರುಚಿಕರ ಆಪಲ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ ಮತ್ತು ನರಿ ಭೇಟಿಯಾಗುವುದನ್ನು ತಪ್ಪಿಸುವಂತೆ ಮಾಡುತ್ತೇವೆ.
**ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ** (RL) ಒಂದು ಅಧ್ಯಯನ ತಂತ್ರಜ್ಞಾನ, ಇದು ನಮಗೆ ಒಂದು **ಪರಿಸರ**ದಲ್ಲಿ **ಏಜೆಂಟ್**ನ ಅತ್ಯುತ್ತಮ ವರ್ತನೆಯನ್ನು ಅನೇಕ ಪ್ರಯೋಗಗಳನ್ನು ನಡೆಸಿ ಕಲಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಪರಿಸರದಲ್ಲಿ ಏಜೆಂಟ್‌ಗೆ ಕೆಲವು **ಗುರಿ** ಇರಬೇಕು, ಅದು **ಬಹುಮಾನ ಕಾರ್ಯ** ಮೂಲಕ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ.
## ಪರಿಸರ
ಸರಳತೆಗೆ, ಪೀಟರ್‌ನ ಜಗತ್ತನ್ನು `width` x `height` ಗಾತ್ರದ ಚದರ ಫಲಕ ಎಂದು ಪರಿಗಣಿಸೋಣ, ಹೀಗೆ:
![ಪೀಟರ್‌ನ ಪರಿಸರ](../../../../translated_images/environment.40ba3cb66256c93fa7e92f6f7214e1d1f588aafa97d266c11d108c5c5d101b6c.kn.png)
ಈ ಫಲಕದ ಪ್ರತಿ ಸೆಲ್ ಇವುಗಳಲ್ಲಿ ಒಂದಾಗಿರಬಹುದು:
* **ಭೂಮಿ**, ಇದರಲ್ಲಿ ಪೀಟರ್ ಮತ್ತು ಇತರ ಜೀವಿಗಳು ನಡೆಯಬಹುದು.
* **ನೀರು**, ಇದರಲ್ಲಿ ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ನಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ.
* **ಮರ** ಅಥವಾ **ಹುಲ್ಲು**, ವಿಶ್ರಾಂತಿ ಪಡೆಯಲು ಸ್ಥಳ.
* **ಆಪಲ್**, ಇದು ಪೀಟರ್ ತನ್ನ ಆಹಾರಕ್ಕಾಗಿ ಹುಡುಕಲು ಇಚ್ಛಿಸುವ ವಸ್ತು.
* **ನರಿ**, ಇದು ಅಪಾಯಕಾರಿಯಾಗಿದ್ದು ತಪ್ಪಿಸಿಕೊಳ್ಳಬೇಕು.
ಈ ಪರಿಸರದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು Python ನಲ್ಲಿ ಪ್ರತ್ಯೇಕ ಮಾಯಾಜಾಲ [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py) ಇದೆ. ಈ ಕೋಡ್ ನಮ್ಮ ಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮುಖ್ಯವಲ್ಲದ ಕಾರಣ, ನಾವು ಈ ಮಾಯಾಜಾಲವನ್ನು ಆಮದುಮಾಡಿ ಮಾದರಿ ಫಲಕವನ್ನು ರಚಿಸಲು ಬಳಸುತ್ತೇವೆ (ಕೋಡ್ ಬ್ಲಾಕ್ 1):
```python
from rlboard import *
width, height = 8,8
m = Board(width,height)
m.randomize(seed=13)
m.plot()
```
ಈ ಕೋಡ್ ಮೇಲಿನ ಪರಿಸರದ ಚಿತ್ರವನ್ನು ಮುದ್ರಣ ಮಾಡಬೇಕು.
## ಕ್ರಿಯೆಗಳು ಮತ್ತು ನೀತಿ
ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪೀಟರ್‌ನ ಗುರಿ ಆಪಲ್ ಹುಡುಕುವುದು, ನರಿ ಮತ್ತು ಇತರ ಅಡ್ಡಿ ಅಡ್ಡಿಗಳನ್ನು ತಪ್ಪಿಸುವುದು. ಇದಕ್ಕಾಗಿ, ಅವನು ಸುತ್ತಾಡಿ ಆಪಲ್ ಕಂಡುಹಿಡಿಯಬಹುದು.
ಆದ್ದರಿಂದ, ಯಾವುದೇ ಸ್ಥಾನದಲ್ಲಿ ಅವನು ಕೆಳಗಿನ ಕ್ರಿಯೆಗಳೊಂದನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು: ಮೇಲಕ್ಕೆ, ಕೆಳಗೆ, ಎಡಕ್ಕೆ ಮತ್ತು ಬಲಕ್ಕೆ.
ನಾವು ಆ ಕ್ರಿಯೆಗಳನ್ನು ಡಿಕ್ಷನರಿಯಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಿ, ಅವುಗಳನ್ನು ಸಂಬಂಧಿತ ಸಂಯೋಜನೆ ಬದಲಾವಣೆಗಳ ಜೋಡಿಗೆ ನಕ್ಷೆ ಮಾಡುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, ಬಲಕ್ಕೆ ಸಾಗುವುದು (`R`) ಜೋಡಿ `(1,0)`ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. (ಕೋಡ್ ಬ್ಲಾಕ್ 2):
```python
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
action_idx = { a : i for i,a in enumerate(actions.keys()) }
```
ಸಾರಾಂಶವಾಗಿ, ಈ ದೃಶ್ಯದ ತಂತ್ರ ಮತ್ತು ಗುರಿ ಹೀಗಿವೆ:
- **ತಂತ್ರ**, ನಮ್ಮ ಏಜೆಂಟ್ (ಪೀಟರ್) ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಅದನ್ನು **ನೀತಿ** ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ನೀತಿ ಎಂದರೆ ಯಾವುದೇ ಸ್ಥಿತಿಯಲ್ಲಿ ಕ್ರಿಯೆಯನ್ನು ನೀಡುವ ಕಾರ್ಯ. ನಮ್ಮಲ್ಲಿ, ಸಮಸ್ಯೆಯ ಸ್ಥಿತಿ ಫಲಕದಿಂದ ಮತ್ತು ಆಟಗಾರನ ಪ್ರಸ್ತುತ ಸ್ಥಾನದಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗಿದೆ.
- **ಗುರಿ**, ಬಲವರ್ಧಿತ ಅಧ್ಯಯನದ ಗುರಿ ಉತ್ತಮ ನೀತಿಯನ್ನು ಕಲಿಯುವುದು, ಇದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಮೂಲಭೂತವಾಗಿ, ನಾವು ಸರಳ ನೀತಿ ಎಂದರೆ **ಯಾದೃಚ್ಛಿಕ ನಡೆ** ಅನ್ನು ಪರಿಗಣಿಸೋಣ.
## ಯಾದೃಚ್ಛಿಕ ನಡೆ
ಮೊದಲು, ನಾವು ಯಾದೃಚ್ಛಿಕ ನಡೆ ತಂತ್ರವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ ನಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸೋಣ. ಯಾದೃಚ್ಛಿಕ ನಡೆ ಮೂಲಕ, ನಾವು ಅನುಮತಿಸಲಾದ ಕ್ರಿಯೆಗಳಲ್ಲಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಮುಂದಿನ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ, ಆಪಲ್ ತಲುಪುವವರೆಗೆ (ಕೋಡ್ ಬ್ಲಾಕ್ 3).
1. ಕೆಳಗಿನ ಕೋಡ್ ಬಳಸಿ ಯಾದೃಚ್ಛಿಕ ನಡೆ ಅನುಷ್ಠಾನಗೊಳಿಸಿ:
```python
def random_policy(m):
return random.choice(list(actions))
def walk(m,policy,start_position=None):
n = 0 # ಹೆಜ್ಜೆಗಳ ಸಂಖ್ಯೆ
# ಪ್ರಾರಂಭಿಕ ಸ್ಥಾನವನ್ನು ಹೊಂದಿಸಿ
if start_position:
m.human = start_position
else:
m.random_start()
while True:
if m.at() == Board.Cell.apple:
return n # ಯಶಸ್ಸು!
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
return -1 # ನರಿ ತಿಂದ ಅಥವಾ ಮುಳುಗಿದ
while True:
a = actions[policy(m)]
new_pos = m.move_pos(m.human,a)
if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
m.move(a) # ನಿಜವಾದ ಚಲನೆ ಮಾಡಿ
break
n+=1
walk(m,random_policy)
```
`walk` ಕರೆ ಸಂಬಂಧಿತ ಮಾರ್ಗದ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು, ಇದು ಪ್ರತಿ ಓಟದಲ್ಲಿ ಬದಲಾಗಬಹುದು.
1. ಯಾದೃಚ್ಛಿಕ ನಡೆ ಪ್ರಯೋಗವನ್ನು ಹಲವಾರು ಬಾರಿ (ಹೇಳಿ, 100) ನಡೆಸಿ, ಫಲಿತಾಂಶದ ಅಂಕಿಅಂಶಗಳನ್ನು ಮುದ್ರಿಸಿ (ಕೋಡ್ ಬ್ಲಾಕ್ 4):
```python
def print_statistics(policy):
s,w,n = 0,0,0
for _ in range(100):
z = walk(m,policy)
if z<0:
w+=1
else:
s += z
n += 1
print(f"Average path length = {s/n}, eaten by wolf: {w} times")
print_statistics(random_policy)
```
ಗಮನಿಸಿ, ಮಾರ್ಗದ ಸರಾಸರಿ ಉದ್ದವು ಸುಮಾರು 30-40 ಹೆಜ್ಜೆಗಳಷ್ಟಿದೆ, ಇದು ಬಹಳಷ್ಟು, ಏಕೆಂದರೆ ಸಮೀಪದ ಆಪಲ್‌ಗೆ ಸರಾಸರಿ ದೂರವು ಸುಮಾರು 5-6 ಹೆಜ್ಜೆಗಳಷ್ಟಿದೆ.
ನೀವು ಪೀಟರ್‌ನ ಚಲನವಲನವನ್ನು ಯಾದೃಚ್ಛಿಕ ನಡೆ ಸಮಯದಲ್ಲಿ ಹೇಗಿದೆ ಎಂದು ಕೂಡ ನೋಡಬಹುದು:
![ಪೀಟರ್‌ನ ಯಾದೃಚ್ಛಿಕ ನಡೆ](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)
## ಬಹುಮಾನ ಕಾರ್ಯ
ನಮ್ಮ ನೀತಿಯನ್ನು ಹೆಚ್ಚು ಬುದ್ಧಿವಂತಿಕೆಯಿಂದ ಮಾಡಲು, ಯಾವ ಚಲನೆಗಳು "ಮೇಲ್ಮಟ್ಟ" ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಇದಕ್ಕಾಗಿ, ನಾವು ನಮ್ಮ ಗುರಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು.
ಗುರಿಯನ್ನು **ಬಹುಮಾನ ಕಾರ್ಯ** ಮೂಲಕ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಇದು ಪ್ರತಿ ಸ್ಥಿತಿಗೆ ಕೆಲವು ಅಂಕ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸಂಖ್ಯೆ ಹೆಚ್ಚು ಇದ್ದರೆ, ಬಹುಮಾನ ಕಾರ್ಯ ಉತ್ತಮ. (ಕೋಡ್ ಬ್ಲಾಕ್ 5)
```python
move_reward = -0.1
goal_reward = 10
end_reward = -10
def reward(m,pos=None):
pos = pos or m.human
if not m.is_valid(pos):
return end_reward
x = m.at(pos)
if x==Board.Cell.water or x == Board.Cell.wolf:
return end_reward
if x==Board.Cell.apple:
return goal_reward
return move_reward
```
ಬಹುಮಾನ ಕಾರ್ಯಗಳ ಬಗ್ಗೆ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ, ಬಹುತೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ, *ನಾವು ಆಟದ ಕೊನೆಯಲ್ಲಿ ಮಾತ್ರ ಮಹತ್ವದ ಬಹುಮಾನವನ್ನು ಪಡೆಯುತ್ತೇವೆ*. ಇದರರ್ಥ ನಮ್ಮ ಅಲ್ಗೋರಿದಮ್ "ಚೆನ್ನಾದ" ಹೆಜ್ಜೆಗಳನ್ನು ನೆನಪಿಡಬೇಕು, ಅವು ಕೊನೆಯಲ್ಲಿ ಧನಾತ್ಮಕ ಬಹುಮಾನಕ್ಕೆ ಕಾರಣವಾಗುತ್ತವೆ ಮತ್ತು ಅವುಗಳ ಮಹತ್ವವನ್ನು ಹೆಚ್ಚಿಸಬೇಕು. ಹಾಗೆಯೇ, ಕೆಟ್ಟ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗುವ ಎಲ್ಲಾ ಚಲನೆಯನ್ನು ತಡೆಯಬೇಕು.
## ಕ್ಯೂ-ಅಧ್ಯಯನ
ನಾವು ಇಲ್ಲಿ ಚರ್ಚಿಸುವ ಅಲ್ಗೋರಿದಮ್ ಅನ್ನು **ಕ್ಯೂ-ಅಧ್ಯಯನ** ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಅಲ್ಗೋರಿದಮ್‌ನಲ್ಲಿ, ನೀತಿ ಒಂದು ಕಾರ್ಯ (ಅಥವಾ ಡೇಟಾ ರಚನೆ) ಮೂಲಕ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು **ಕ್ಯೂ-ಟೇಬಲ್** ಎಂದು ಕರೆಯುತ್ತಾರೆ. ಇದು ನೀಡಲಾದ ಸ್ಥಿತಿಯಲ್ಲಿ ಪ್ರತಿ ಕ್ರಿಯೆಯ "ಚೆನ್ನಾಗಿರುವಿಕೆ" ಅನ್ನು ದಾಖಲಿಸುತ್ತದೆ.
ಇದನ್ನು ಕ್ಯೂ-ಟೇಬಲ್ ಎಂದು ಕರೆಯುತ್ತಾರೆ ಏಕೆಂದರೆ ಅದನ್ನು ಟೇಬಲ್ ಅಥವಾ ಬಹು-ಮಾನದ ಅರೇ ಆಗಿ ಪ್ರತಿನಿಧಿಸುವುದು ಅನುಕೂಲಕರ. ನಮ್ಮ ಫಲಕವು `width` x `height` ಆಯಾಮಗಳಿದ್ದು, ನಾವು ಕ್ಯೂ-ಟೇಬಲ್ ಅನ್ನು numpy ಅರೇ ಆಗಿ `width` x `height` x `len(actions)` ಆಕಾರದಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಬಹುದು: (ಕೋಡ್ ಬ್ಲಾಕ್ 6)
```python
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
```
ನಾವು ಕ್ಯೂ-ಟೇಬಲ್‌ನ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಸಮಾನ ಮೌಲ್ಯದಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ನಮ್ಮಲ್ಲಿ - 0.25. ಇದು "ಯಾದೃಚ್ಛಿಕ ನಡೆ" ನೀತಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಪ್ರತಿ ಸ್ಥಿತಿಯಲ್ಲಿ ಎಲ್ಲಾ ಚಲನೆಗಳು ಸಮಾನವಾಗಿ ಉತ್ತಮ. ನಾವು `plot` ಕಾರ್ಯಕ್ಕೆ ಕ್ಯೂ-ಟೇಬಲ್ ಅನ್ನು ಪಾಸ್ ಮಾಡಿ ಫಲಕದಲ್ಲಿ ಟೇಬಲ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸಬಹುದು: `m.plot(Q)`.
![ಪೀಟರ್‌ನ ಪರಿಸರ](../../../../translated_images/env_init.04e8f26d2d60089e128f21d22e5fef57d580e559f0d5937b06c689e5e7cdd438.kn.png)
ಪ್ರತಿ ಸೆಲ್‌ನ ಮಧ್ಯದಲ್ಲಿ ಚಲನೆಯ ಇಚ್ಛಿತ ದಿಕ್ಕನ್ನು ಸೂಚಿಸುವ "ಬಾಣ" ಇದೆ. ಎಲ್ಲಾ ದಿಕ್ಕುಗಳು ಸಮಾನವಾಗಿರುವುದರಿಂದ, ಬಿಂದು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
ಈಗ ನಾವು ಸಿಮ್ಯುಲೇಶನ್ ನಡೆಸಿ, ನಮ್ಮ ಪರಿಸರವನ್ನು ಅನ್ವೇಷಿಸಿ, ಮತ್ತು ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯಗಳ ಉತ್ತಮ ವಿತರಣೆ ಕಲಿಯಬೇಕು, ಇದು ಆಪಲ್‌ಗೆ ದಾರಿಯನ್ನು ಹೆಚ್ಚು ವೇಗವಾಗಿ ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
## ಕ್ಯೂ-ಅಧ್ಯಯನದ ಸಾರಾಂಶ: ಬೆಲ್ಮನ್ ಸಮೀಕರಣ
ನಾವು ಚಲಿಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಪ್ರತಿ ಕ್ರಿಯೆಗೆ ಸಂಬಂಧಿಸಿದ ಬಹುಮಾನ ಇರುತ್ತದೆ, ಅಂದರೆ ನಾವು ತಕ್ಷಣದ ಬಹುಮಾನ ಆಧರಿಸಿ ಮುಂದಿನ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಆದರೆ, ಬಹುತೇಕ ಸ್ಥಿತಿಗಳಲ್ಲಿ, ಚಲನೆ ನಮ್ಮ ಗುರಿ ಆಪಲ್ ತಲುಪುವುದನ್ನು ಸಾಧಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಯಾವ ದಿಕ್ಕು ಉತ್ತಮ ಎಂದು ತಕ್ಷಣ ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
> ತಕ್ಷಣದ ಫಲಿತಾಂಶವೇ ಮುಖ್ಯವಲ್ಲ, ಆದರೆ ಸಿಮ್ಯುಲೇಶನ್ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯುವ ಅಂತಿಮ ಫಲಿತಾಂಶವೇ ಮುಖ್ಯ.
ಈ ವಿಳಂಬಿತ ಬಹುಮಾನವನ್ನು ಪರಿಗಣಿಸಲು, ನಾವು **[ಡೈನಾಮಿಕ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್](https://en.wikipedia.org/wiki/Dynamic_programming)** ತತ್ವಗಳನ್ನು ಬಳಸಬೇಕು, ಇದು ನಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಯೋಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ನಾವು ಈಗ ಸ್ಥಿತಿ *s* ನಲ್ಲಿ ಇದ್ದೇವೆಂದು ಕಲ್ಪಿಸೋಣ, ಮತ್ತು ಮುಂದಿನ ಸ್ಥಿತಿ *s'* ಗೆ ಸಾಗಲು ಬಯಸುತ್ತೇವೆ. ಇದರಿಂದ, ನಾವು ತಕ್ಷಣದ ಬಹುಮಾನ *r(s,a)* ಪಡೆಯುತ್ತೇವೆ, ಇದು ಬಹುಮಾನ ಕಾರ್ಯದಿಂದ ವ್ಯಾಖ್ಯಾನಿತ, ಜೊತೆಗೆ ಕೆಲವು ಭವಿಷ್ಯ ಬಹುಮಾನ. ನಮ್ಮ ಕ್ಯೂ-ಟೇಬಲ್ ಪ್ರತಿ ಕ್ರಿಯೆಯ "ಆಕರ್ಷಕತೆ" ಅನ್ನು ಸರಿಯಾಗಿ ಪ್ರತಿಬಿಂಬಿಸುವುದಾಗಿ ಊಹಿಸಿದರೆ, ಸ್ಥಿತಿ *s'* ನಲ್ಲಿ ನಾವು ಕ್ರಿಯೆ *a'* ಆಯ್ಕೆಮಾಡುತ್ತೇವೆ, ಅದು ಗರಿಷ್ಠ ಮೌಲ್ಯದ *Q(s',a')* ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸ್ಥಿತಿ *s* ನಲ್ಲಿ ನಾವು ಪಡೆಯಬಹುದಾದ ಅತ್ಯುತ್ತಮ ಭವಿಷ್ಯ ಬಹುಮಾನವನ್ನು `max`<sub>a'</sub>*Q(s',a')* ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು (ಇಲ್ಲಿ ಗರಿಷ್ಠವು ಎಲ್ಲಾ ಸಾಧ್ಯ ಕ್ರಿಯೆಗಳ ಮೇಲೆ ಲೆಕ್ಕಿಸಲಾಗುತ್ತದೆ).
ಇದು ಸ್ಥಿತಿ *s* ನಲ್ಲಿ ಕ್ರಿಯೆ *a* ಗೆ ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಿಸುವ **ಬೆಲ್ಮನ್ ಸೂತ್ರ** ನೀಡುತ್ತದೆ:
<img src="../../../../translated_images/bellman-equation.7c0c4c722e5a6b7c208071a0bae51664965050848e4f8a84bb377cd18bdd838b.kn.png"/>
ಇಲ್ಲಿ γ ಅನ್ನು **ಡಿಸ್ಕೌಂಟ್ ಫ್ಯಾಕ್ಟರ್** ಎಂದು ಕರೆಯುತ್ತಾರೆ, ಇದು ನೀವು ಪ್ರಸ್ತುತ ಬಹುಮಾನವನ್ನು ಭವಿಷ್ಯ ಬಹುಮಾನಕ್ಕಿಂತ ಎಷ್ಟು ಪ್ರಾಧಾನ್ಯತೆ ನೀಡಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.
## ಅಧ್ಯಯನ ಅಲ್ಗೋರಿದಮ್
ಮೇಲಿನ ಸಮೀಕರಣವನ್ನು ಆಧರಿಸಿ, ನಾವು ಈಗ ನಮ್ಮ ಅಧ್ಯಯನ ಅಲ್ಗೋರಿದಮ್‌ಗೆ ಪ್ಸ್ಯೂಡೋ-ಕೋಡ್ ಬರೆಯಬಹುದು:
* ಎಲ್ಲಾ ಸ್ಥಿತಿಗಳು ಮತ್ತು ಕ್ರಿಯೆಗಳಿಗಾಗಿ ಸಮಾನ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಕ್ಯೂ-ಟೇಬಲ್ Q ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ
* ಅಧ್ಯಯನ ದರ α ← 1 ಸೆಟ್ ಮಾಡಿ
* ಅನೇಕ ಬಾರಿ ಸಿಮ್ಯುಲೇಶನ್ ಪುನರಾವರ್ತಿಸಿ
1. ಯಾದೃಚ್ಛಿಕ ಸ್ಥಾನದಿಂದ ಪ್ರಾರಂಭಿಸಿ
1. ಪುನರಾವರ್ತಿಸಿ
1. ಸ್ಥಿತಿ *s* ನಲ್ಲಿ ಕ್ರಿಯೆ *a* ಆಯ್ಕೆಮಾಡಿ
2. ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸಿ ಮತ್ತು ಹೊಸ ಸ್ಥಿತಿ *s'* ಗೆ ಸಾಗಿರಿ
3. ಆಟದ ಅಂತ್ಯ ಅಥವಾ ಒಟ್ಟು ಬಹುಮಾನ ತುಂಬಾ ಕಡಿಮೆ ಇದ್ದರೆ ಸಿಮ್ಯುಲೇಶನ್ ನಿಲ್ಲಿಸಿ
4. ಹೊಸ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಹುಮಾನ *r* ಲೆಕ್ಕಿಸಿ
5. ಬೆಲ್ಮನ್ ಸಮೀಕರಣದ ಪ್ರಕಾರ ಕ್ಯೂ-ಕಾರ್ಯವನ್ನು ನವೀಕರಿಸಿ: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
6. *s* ← *s'*
7. ಒಟ್ಟು ಬಹುಮಾನವನ್ನು ನವೀಕರಿಸಿ ಮತ್ತು α ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿ.
## ಅನ್ವೇಷಣೆ ಮತ್ತು ಉಪಯೋಗ
ಮೇಲಿನ ಅಲ್ಗೋರಿದಮ್‌ನಲ್ಲಿ, ನಾವು 2.1 ಹಂತದಲ್ಲಿ ಕ್ರಿಯೆಯನ್ನು ಹೇಗೆ ಆಯ್ಕೆ ಮಾಡಬೇಕು ಎಂದು ಸ್ಪಷ್ಟಪಡಿಸಿಲ್ಲ. ನಾವು ಕ್ರಿಯೆಯನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಿದರೆ, ನಾವು ಪರಿಸರವನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ **ಅನ್ವೇಷಿಸುತ್ತೇವೆ**, ಮತ್ತು ನಾವು ಬಹುಶಃ ಹೆಚ್ಚು ಸಾರಿ ಸಾಯಬಹುದು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಹೋಗದ ಪ್ರದೇಶಗಳನ್ನು ಅನ್ವೇಷಿಸಬಹುದು. ಪರ್ಯಾಯವಾಗಿ, ನಾವು ಈಗಾಗಲೇ ತಿಳಿದಿರುವ ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯಗಳನ್ನು **ಉಪಯೋಗಿಸಿ**, ಸ್ಥಿತಿ *s* ನಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಕ್ರಿಯೆಯನ್ನು (ಹೆಚ್ಚಿನ ಕ್ಯೂ-ಮೌಲ್ಯ) ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಆದರೆ ಇದು ಇತರ ಸ್ಥಿತಿಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ನಾವು ಅತ್ಯುತ್ತಮ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯದಿರಬಹುದು.
ಆದ್ದರಿಂದ, ಉತ್ತಮ ವಿಧಾನವು ಅನ್ವೇಷಣೆ ಮತ್ತು ಉಪಯೋಗದ ನಡುವೆ ಸಮತೋಲನ ಸಾಧಿಸುವುದು. ಇದು ಸ್ಥಿತಿ *s* ನಲ್ಲಿ ಕ್ರಿಯೆಯನ್ನು ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯಗಳಿಗೆ ಅನುಪಾತಿಕ ಪ್ರಾಬಬಿಲಿಟಿಗಳೊಂದಿಗೆ ಆಯ್ಕೆಮಾಡುವ ಮೂಲಕ ಮಾಡಬಹುದು. ಆರಂಭದಲ್ಲಿ, ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯಗಳು ಎಲ್ಲವೂ ಸಮಾನವಾಗಿರುವಾಗ, ಇದು ಯಾದೃಚ್ಛಿಕ ಆಯ್ಕೆ ಆಗಿರುತ್ತದೆ, ಆದರೆ ನಾವು ನಮ್ಮ ಪರಿಸರವನ್ನು ಹೆಚ್ಚು ಕಲಿತಂತೆ, ನಾವು ಅತ್ಯುತ್ತಮ ಮಾರ್ಗವನ್ನು ಅನುಸರಿಸುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚಾಗುತ್ತದೆ ಮತ್ತು ಏಜೆಂಟ್‌ಗಿಗೆ ಕೆಲವೊಮ್ಮೆ ಅನ್ವೇಷಿಸದ ಮಾರ್ಗವನ್ನು ಆಯ್ಕೆಮಾಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.
## ಪೈಥಾನ್ ಅನುಷ್ಠಾನ
ನಾವು ಈಗ ಅಧ್ಯಯನ ಅಲ್ಗೋರಿದಮ್ ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದೇವೆ. ಅದಕ್ಕೆ ಮುಂಚೆ, ನಾವು ಕ್ಯೂ-ಟೇಬಲ್‌ನ任意 ಸಂಖ್ಯೆಗಳನ್ನೂ ಸಂಬಂಧಿತ ಕ್ರಿಯೆಗಳ ಪ್ರಾಬಬಿಲಿಟಿಗಳ ವೆಕ್ಟರ್‌ಗೆ ಪರಿವರ್ತಿಸುವ ಕಾರ್ಯ ಬೇಕಾಗುತ್ತದೆ.
1. `probs()` ಎಂಬ ಕಾರ್ಯವನ್ನು ರಚಿಸಿ:
```python
def probs(v,eps=1e-4):
v = v-v.min()+eps
v = v/v.sum()
return v
```
ನಾವು ಮೂಲ ವೆಕ್ಟರ್‌ಗೆ ಕೆಲವು `eps` ಸೇರಿಸುತ್ತೇವೆ, ಆರಂಭಿಕ ಸ್ಥಿತಿಯಲ್ಲಿ ಎಲ್ಲ ಘಟಕಗಳೂ ಸಮಾನವಾಗಿರುವಾಗ ಶೂನ್ಯದಿಂದ ಭಾಗಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು.
5000 ಪ್ರಯೋಗಗಳ ಮೂಲಕ ಅಧ್ಯಯನ ಅಲ್ಗೋರಿದಮ್ ಅನ್ನು ನಡೆಸಿ, ಇದನ್ನು **ಎಪೋಕ್ಸ್** ಎಂದು ಕರೆಯುತ್ತಾರೆ: (ಕೋಡ್ ಬ್ಲಾಕ್ 8)
```python
for epoch in range(5000):
# ಪ್ರಾರಂಭಿಕ ಬಿಂದುವನ್ನು ಆಯ್ಕೆಮಾಡಿ
m.random_start()
# ಪ್ರಯಾಣವನ್ನು ಪ್ರಾರಂಭಿಸಿ
n=0
cum_reward = 0
while True:
x,y = m.human
v = probs(Q[x,y])
a = random.choices(list(actions),weights=v)[0]
dpos = actions[a]
m.move(dpos,check_correctness=False) # ನಾವು ಆಟಗಾರನಿಗೆ ಫಲಕದ ಹೊರಗೆ ಚಲಿಸಲು ಅನುಮತಿಸುತ್ತೇವೆ, ಇದು ಎಪಿಸೋಡ್ ಅನ್ನು ಮುಕ್ತಾಯಗೊಳಿಸುತ್ತದೆ
r = reward(m)
cum_reward += r
if r==end_reward or cum_reward < -1000:
lpath.append(n)
break
alpha = np.exp(-n / 10e5)
gamma = 0.5
ai = action_idx[a]
Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max())
n+=1
```
ಈ ಅಲ್ಗೋರಿದಮ್ ಅನ್ನು ನಿರ್ವಹಿಸಿದ ನಂತರ, ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯಗಳು ನವೀಕರಿಸಲಾಗುತ್ತದೆ, ಅವು ಪ್ರತಿ ಹೆಜ್ಜೆಯಲ್ಲಿ ವಿಭಿನ್ನ ಕ್ರಿಯೆಗಳ ಆಕರ್ಷಕತೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ. ನಾವು ಕ್ಯೂ-ಟೇಬಲ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು, ಪ್ರತಿ ಸೆಲ್‌ನಲ್ಲಿ ಒಂದು ವೆಕ್ಟರ್ ಅನ್ನು ಚಿತ್ರಿಸಿ ಅದು ಚಲನೆಯ ಇಚ್ಛಿತ ದಿಕ್ಕನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಸರಳತೆಗೆ, ನಾವು ಬಾಣದ ತಲೆ ಬದಲು ಸಣ್ಣ ವೃತ್ತವನ್ನು ಬಿಡುತ್ತೇವೆ.
<img src="../../../../translated_images/learned.ed28bcd8484b5287a31925c96c43b43e2c2bb876b8ca41a0e1e754f77bb3db20.kn.png"/>
## ನೀತಿ ಪರಿಶೀಲನೆ
ಕ್ಯೂ-ಟೇಬಲ್ ಪ್ರತಿ ಸ್ಥಿತಿಯಲ್ಲಿ ಪ್ರತಿ ಕ್ರಿಯೆಯ "ಆಕರ್ಷಕತೆ" ಅನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದನ್ನು ಬಳಸಿ ನಮ್ಮ ಜಗತ್ತಿನಲ್ಲಿ ಪರಿಣಾಮಕಾರಿ ನ್ಯಾವಿಗೇಶನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಸುಲಭ. ಸರಳ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು ಗರಿಷ್ಠ ಕ್ಯೂ-ಟೇಬಲ್ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು: (ಕೋಡ್ ಬ್ಲಾಕ್ 9)
```python
def qpolicy_strict(m):
x,y = m.human
v = probs(Q[x,y])
a = list(actions)[np.argmax(v)]
return a
walk(m,qpolicy_strict)
```
> ನೀವು ಮೇಲಿನ ಕೋಡ್ ಅನ್ನು ಹಲವಾರು ಬಾರಿ ಪ್ರಯತ್ನಿಸಿದರೆ, ಕೆಲವೊಮ್ಮೆ ಅದು "ಹ್ಯಾಂಗ್" ಆಗುತ್ತದೆ ಎಂದು ನೀವು ಗಮನಿಸಬಹುದು, ಮತ್ತು ಅದನ್ನು ಮಧ್ಯಂತರಗೊಳಿಸಲು ನೀವು ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ STOP ಬಟನ್ ಒತ್ತಬೇಕಾಗುತ್ತದೆ. ಇದು ಸಂಭವಿಸುವುದು ಏಕೆಂದರೆ ಎರಡು ಸ್ಥಿತಿಗಳು ಪರಸ್ಪರ ಅತ್ಯುತ್ತಮ Q-ಮೌಲ್ಯದ ದೃಷ್ಟಿಯಿಂದ "ಸೂಚಿಸುವ" ಸಂದರ್ಭಗಳು ಇರಬಹುದು, ಇಂತಹ ಸಂದರ್ಭದಲ್ಲಿ ಏಜೆಂಟ್ ಆ ಸ್ಥಿತಿಗಳ ನಡುವೆ ಅನಂತಕಾಲ ಚಲಿಸುತ್ತಿರುತ್ತದೆ.
## 🚀ಸವಾಲು
> **ಕಾರ್ಯ 1:** `walk` ಫಂಕ್ಷನ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಿ, ಮಾರ್ಗದ ಗರಿಷ್ಠ ಉದ್ದವನ್ನು ನಿರ್ದಿಷ್ಟ ಹೆಜ್ಜೆಗಳ ಸಂಖ್ಯೆಯಿಂದ (ಹೇಳಿ, 100) ಮಿತಿಗೊಳಿಸಿ, ಮತ್ತು ಮೇಲಿನ ಕೋಡ್ ಈ ಮೌಲ್ಯವನ್ನು ಸಮಯಕಾಲಕ್ಕೆ ಹಿಂತಿರುಗಿಸುವುದನ್ನು ಗಮನಿಸಿ.
> **ಕಾರ್ಯ 2:** `walk` ಫಂಕ್ಷನ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಿ, ಅದು ಈಗಾಗಲೇ ಹೋಗಿದ್ದ ಸ್ಥಳಗಳಿಗೆ ಹಿಂದಿರುಗದಂತೆ ಮಾಡಿ. ಇದರಿಂದ `walk` ಲೂಪ್ ಆಗುವುದನ್ನು ತಡೆಯಬಹುದು, ಆದರೆ ಏಜೆಂಟ್ ಇನ್ನೂ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲದ ಸ್ಥಳದಲ್ಲಿ "ಹುಡುಗಲ್ಪಟ್ಟ" ಸ್ಥಿತಿಯಲ್ಲಿ ಇರಬಹುದು.
## ನ್ಯಾವಿಗೇಶನ್
ಮುಂಬರುವ ನ್ಯಾವಿಗೇಶನ್ ನೀತಿ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ನಾವು ಬಳಸಿದ ನೀತಿಯೇ ಉತ್ತಮವಾಗಿರುತ್ತದೆ, ಅದು ಅನ್ವೇಷಣೆ ಮತ್ತು ಉಪಯೋಗವನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಈ ನೀತಿಯಲ್ಲಿ, ನಾವು Q-ಟೇಬಲ್‌ನ ಮೌಲ್ಯಗಳಿಗೆ ಅನುಪಾತವಾಗಿ ಪ್ರತಿ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟ ಸಾಧ್ಯತೆಯಿಂದ ಆಯ್ಕೆಮಾಡುತ್ತೇವೆ. ಈ ತಂತ್ರವು ಏಜೆಂಟ್ ಈಗಾಗಲೇ ಅನ್ವೇಷಿಸಿದ ಸ್ಥಾನಕ್ಕೆ ಹಿಂತಿರುಗುವ ಸಾಧ್ಯತೆಯನ್ನು ಇನ್ನೂ ಹೊಂದಿರಬಹುದು, ಆದರೆ ಕೆಳಗಿನ ಕೋಡ್‌ನಿಂದ ನೀವು ನೋಡಬಹುದು, ಇದು ಗುರಿ ಸ್ಥಳಕ್ಕೆ ತುಂಬಾ ಚಿಕ್ಕ ಸರಾಸರಿ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ (`print_statistics` 100 ಬಾರಿ ಸಿಮ್ಯುಲೇಶನ್ ನಡೆಸುತ್ತದೆ): (ಕೋಡ್ ಬ್ಲಾಕ್ 10)
```python
def qpolicy(m):
x,y = m.human
v = probs(Q[x,y])
a = random.choices(list(actions),weights=v)[0]
return a
print_statistics(qpolicy)
```
ಈ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ನೀವು ಹಿಂದಿನದಿಗಿಂತ ಬಹಳ ಕಡಿಮೆ ಸರಾಸರಿ ಮಾರ್ಗದ ಉದ್ದವನ್ನು 3-6 ರ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಪಡೆಯಬೇಕು.
## ಕಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು
ನಾವು ಉಲ್ಲೇಖಿಸಿದಂತೆ, ಕಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆ ಅನ್ವೇಷಣೆ ಮತ್ತು ಸಮಸ್ಯಾ ಸ್ಥಳದ ರಚನೆಯ ಬಗ್ಗೆ ಪಡೆದ ಜ್ಞಾನವನ್ನು ಅನ್ವೇಷಿಸುವ ನಡುವಿನ ಸಮತೋಲನವಾಗಿದೆ. ಕಲಿಕೆಯ ಫಲಿತಾಂಶಗಳು (ಏಜೆಂಟ್ ಗುರಿ ತಲುಪಲು ಚಿಕ್ಕ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಸಾಮರ್ಥ್ಯ) ಸುಧಾರಿತವಾಗಿದೆ, ಆದರೆ ಕಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಸರಾಸರಿ ಮಾರ್ಗದ ಉದ್ದ ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಸಹ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ:
<img src="../../../../translated_images/lpathlen1.0534784add58d4ebf25c21d4a1da9bceab4f96743a35817f1b49ab963c64c572.kn.png"/>
ಕಲಿಕೆಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ:
- **ಸರಾಸರಿ ಮಾರ್ಗದ ಉದ್ದ ಹೆಚ್ಚಾಗುತ್ತದೆ**. ಇಲ್ಲಿ ನಾವು ನೋಡುತ್ತಿರುವುದು ಪ್ರಾರಂಭದಲ್ಲಿ ಸರಾಸರಿ ಮಾರ್ಗದ ಉದ್ದ ಹೆಚ್ಚಾಗುತ್ತದೆ. ಇದು ಬಹುಶಃ ಪರಿಸರದ ಬಗ್ಗೆ ಏನೂ ತಿಳಿಯದಿರುವಾಗ, ನಾವು ಕೆಟ್ಟ ಸ್ಥಿತಿಗಳಲ್ಲಿ, ನೀರು ಅಥವಾ ನರಿ ಬಳಿ ಸಿಕ್ಕಿಬಿದ್ದಿರಬಹುದು ಎಂಬುದರಿಂದ ಆಗುತ್ತದೆ. ನಾವು ಹೆಚ್ಚು ಕಲಿತಂತೆ ಮತ್ತು ಈ ಜ್ಞಾನವನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದಂತೆ, ನಾವು ಪರಿಸರವನ್ನು ಹೆಚ್ಚು ಅನ್ವೇಷಿಸಬಹುದು, ಆದರೆ ಆಪಲ್ಗಳು ಎಲ್ಲಿವೆ ಎಂಬುದನ್ನು ಇನ್ನೂ ಚೆನ್ನಾಗಿ ತಿಳಿಯದು.
- **ಕಲಿತಂತೆ ಮಾರ್ಗದ ಉದ್ದ ಕಡಿಮೆಯಾಗುತ್ತದೆ**. ನಾವು ಸಾಕಷ್ಟು ಕಲಿತ ನಂತರ, ಏಜೆಂಟ್ ಗುರಿಯನ್ನು ಸಾಧಿಸುವುದು ಸುಲಭವಾಗುತ್ತದೆ, ಮತ್ತು ಮಾರ್ಗದ ಉದ್ದ ಕಡಿಮೆಯಾಗಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನಾವು ಇನ್ನೂ ಅನ್ವೇಷಣೆಗೆ ತೆರೆಯಲಾಗಿದ್ದು, ನಾವು ಉತ್ತಮ ಮಾರ್ಗದಿಂದ ದೂರ ಹೋಗಿ ಹೊಸ ಆಯ್ಕೆಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದರಿಂದ ಮಾರ್ಗವು ಅತ್ಯುತ್ತಮಕ್ಕಿಂತ ಹೆಚ್ಚು ಉದ್ದವಾಗಬಹುದು.
- **ಉದ್ದವು ಅಕಸ್ಮಾತ್ ಹೆಚ್ಚಾಗುತ್ತದೆ**. ಈ ಗ್ರಾಫ್‌ನಲ್ಲಿ ನಾವು ಮತ್ತೊಂದು ಗಮನಿಸುವುದು, ಕೆಲ ಸಮಯದಲ್ಲಿ ಉದ್ದವು ಅಕಸ್ಮಾತ್ ಹೆಚ್ಚಾಗಿದೆ. ಇದು ಪ್ರಕ್ರಿಯೆಯ ಸಾಂಖ್ಯಿಕ ಸ್ವಭಾವವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು ನಾವು ಕೆಲ ಸಮಯದಲ್ಲಿ Q-ಟೇಬಲ್ ಗುಣಾಂಕಗಳನ್ನು ಹೊಸ ಮೌಲ್ಯಗಳಿಂದ ಮರುಬರೆಯುವ ಮೂಲಕ "ಹಾಳು" ಮಾಡಬಹುದು. ಇದನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಕಲಿಕೆಯ ದರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು (ಉದಾಹರಣೆಗೆ, ತರಬೇತಿಯ ಕೊನೆಯಲ್ಲಿ, ನಾವು Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳನ್ನು ಸಣ್ಣ ಮೌಲ್ಯದಿಂದ ಮಾತ್ರ ಸರಿಪಡಿಸುತ್ತೇವೆ) ಸೂಕ್ತ.
ಒಟ್ಟಾರೆ, ಕಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆಯ ಯಶಸ್ಸು ಮತ್ತು ಗುಣಮಟ್ಟವು ಕಲಿಕೆಯ ದರ, ಕಲಿಕೆಯ ದರ ಕುಸಿತ, ಮತ್ತು ಡಿಸ್ಕೌಂಟ್ ಫ್ಯಾಕ್ಟರ್ ಮುಂತಾದ ಪರಿಮಾಣಗಳ ಮೇಲೆ ಬಹುಮಟ್ಟಿಗೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಅವುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ **ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು** ಎಂದು ಕರೆಯುತ್ತಾರೆ, ಮತ್ತು ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ನಾವು ಸುಧಾರಿಸುವ **ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು** (ಉದಾಹರಣೆಗೆ, Q-ಟೇಬಲ್ ಗುಣಾಂಕಗಳು) ಇಂದ ವಿಭಿನ್ನವಾಗಿವೆ. ಉತ್ತಮ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯಗಳನ್ನು ಹುಡುಕುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು **ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಆಪ್ಟಿಮೈಜೆಷನ್** ಎಂದು ಕರೆಯುತ್ತಾರೆ, ಮತ್ತು ಇದು ಪ್ರತ್ಯೇಕ ವಿಷಯಕ್ಕೆ ಅರ್ಹವಾಗಿದೆ.
## [ಪೋಸ್ಟ್-ಲೆಕ್ಚರ್ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ಅಸೈನ್‌ಮೆಂಟ್
[ಹೆಚ್ಚು ವಾಸ್ತವಿಕ ಜಗತ್ತು](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

41
translations/kn/8-Reinforcement/1-QLearning/assignment.md
Unescape View File

@ -0,0 +1,41 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "68394b2102d3503882e5e914bd0ff5c1",
"translation_date": "2025-12-19T15:53:15+00:00",
"source_file": "8-Reinforcement/1-QLearning/assignment.md",
"language_code": "kn"
}
-->
# ಹೆಚ್ಚು ವಾಸ್ತವಿಕ ಜಗತ್ತು
ನಮ್ಮ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಪೀಟರ್ ಬಹಳಷ್ಟು ದಣಿವಾಗದೆ ಅಥವಾ ಹಸಿವಾಗದೆ ಸುತ್ತಾಡಲು ಸಾಧ್ಯವಾಯಿತು. ಹೆಚ್ಚು ವಾಸ್ತವಿಕ ಜಗತ್ತಿನಲ್ಲಿ, ನಾವು ಸಮಯಕಾಲಕ್ಕೆ ಕುಳಿತು ವಿಶ್ರಾಂತಿ ಪಡೆಯಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ತಾನೇ ಆಹಾರ ಸೇವಿಸಬೇಕಾಗುತ್ತದೆ. ಕೆಳಗಿನ ನಿಯಮಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವ ಮೂಲಕ ನಮ್ಮ ಜಗತ್ತನ್ನು ಹೆಚ್ಚು ವಾಸ್ತವಿಕವಾಗಿಸೋಣ:
1. ಒಂದು ಸ್ಥಳದಿಂದ ಮತ್ತೊಂದು ಸ್ಥಳಕ್ಕೆ ಚಲಿಸುವ ಮೂಲಕ, ಪೀಟರ್ **ಶಕ್ತಿ** ಕಳೆದುಕೊಳ್ಳುತ್ತಾನೆ ಮತ್ತು ಕೆಲವು **ದಣಿವು** ಗಳಿಸುತ್ತಾನೆ.
2. ಪೀಟರ್ ಸೇಬುಗಳನ್ನು ತಿಂದರೆ ಹೆಚ್ಚು ಶಕ್ತಿ ಗಳಿಸಬಹುದು.
3. ಪೀಟರ್ ಮರದ ಕೆಳಗೆ ಅಥವಾ ಹುಲ್ಲಿನ ಮೇಲೆ ವಿಶ್ರಾಂತಿ ತೆಗೆದುಕೊಂಡರೆ (ಅಂದರೆ ಮರ ಅಥವಾ ಹುಲ್ಲು ಇರುವ ಬೋರ್ಡ್ ಸ್ಥಳಕ್ಕೆ ನಡೆಯುವ ಮೂಲಕ) ದಣಿವು ಕಡಿಮೆಯಾಗುತ್ತದೆ.
4. ಪೀಟರ್ ನಾಯಿ ಹತ್ಯೆ ಮಾಡಬೇಕಾಗಿದೆ.
5. ನಾಯಿ ಹತ್ಯೆ ಮಾಡಲು, ಪೀಟರ್ ಗೆ ನಿರ್ದಿಷ್ಟ ಮಟ್ಟದ ಶಕ್ತಿ ಮತ್ತು ದಣಿವು ಇರಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಅವನು ಯುದ್ಧವನ್ನು ಸೋಲುತ್ತಾನೆ.
## ಸೂಚನೆಗಳು
ನಿಮ್ಮ ಪರಿಹಾರಕ್ಕಾಗಿ ಮೂಲ [notebook.ipynb](notebook.ipynb) ನೋಟ್ಬುಕ್ ಅನ್ನು ಪ್ರಾರಂಭಿಕ ಬಿಂದುವಾಗಿ ಬಳಸಿ.
ಮೇಲಿನ ಆಟದ ನಿಯಮಗಳ ಪ್ರಕಾರ ಬಹುಮಾನ ಕಾರ್ಯವನ್ನು ತಿದ್ದುಪಡಿ ಮಾಡಿ, reinforcement learning ಆಲ್ಗಾರಿದಮ್ ಅನ್ನು ಚಲಾಯಿಸಿ ಆಟವನ್ನು ಗೆಲ್ಲಲು ಉತ್ತಮ ತಂತ್ರವನ್ನು ಕಲಿಯಿರಿ, ಮತ್ತು ಯಾದೃಚ್ಛಿಕ ನಡಿಗೆ ಮತ್ತು ನಿಮ್ಮ ಆಲ್ಗಾರಿದಮ್ ಫಲಿತಾಂಶಗಳನ್ನು ಗೆಲುವಿನ ಮತ್ತು ಸೋಲಿನ ಆಟಗಳ ಸಂಖ್ಯೆಯ ದೃಷ್ಟಿಯಿಂದ ಹೋಲಿಸಿ.
> **ಗಮನಿಸಿ**: ನಿಮ್ಮ ಹೊಸ ಜಗತ್ತಿನಲ್ಲಿ, ಸ್ಥಿತಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ, ಮತ್ತು ಮಾನವ ಸ್ಥಾನಕ್ಕೆ ಜೊತೆಗೆ ದಣಿವು ಮತ್ತು ಶಕ್ತಿ ಮಟ್ಟಗಳೂ ಸೇರಿವೆ. ನೀವು ಸ್ಥಿತಿಯನ್ನು (Board,energy,fatigue) ಎಂಬ ಟ್ಯೂಪಲ್ ಆಗಿ ಪ್ರತಿನಿಧಿಸಬಹುದು, ಅಥವಾ ಸ್ಥಿತಿಗಾಗಿ ಒಂದು ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು (ನೀವು ಅದನ್ನು `Board` ನಿಂದ ವಂಶಪಾರಂಪರ್ಯವಾಗಿ ಪಡೆಯಬಹುದು), ಅಥವಾ ಮೂಲ `Board` ವರ್ಗವನ್ನು [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py) ಒಳಗೆ ತಿದ್ದುಪಡಿ ಮಾಡಬಹುದು.
ನಿಮ್ಮ ಪರಿಹಾರದಲ್ಲಿ, ದಯವಿಟ್ಟು ಯಾದೃಚ್ಛಿಕ ನಡಿಗೆ ತಂತ್ರಕ್ಕಾಗಿ ಜವಾಬ್ದಾರಿಯಿರುವ ಕೋಡ್ ಅನ್ನು ಉಳಿಸಿ, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ನಿಮ್ಮ ಆಲ್ಗಾರಿದಮ್ ಫಲಿತಾಂಶಗಳನ್ನು ಯಾದೃಚ್ಛಿಕ ನಡಿಗೆಯೊಂದಿಗೆ ಹೋಲಿಸಿ.
> **ಗಮನಿಸಿ**: ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀವು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿಸಬೇಕಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಎಪೋಕ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು. ಯಾಕಂದರೆ ಆಟದ ಯಶಸ್ಸು (ನಾಯಿಯನ್ನು ಹೋರಾಡುವುದು) ಅಪರೂಪದ ಘಟನೆ, ನೀವು ಬಹಳ ಹೆಚ್ಚು ತರಬೇತಿ ಸಮಯವನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು.
## ಮೌಲ್ಯಮಾಪನ
| ಮಾನದಂಡಗಳು | ಉದಾಹರಣೀಯ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆಯ ಅಗತ್ಯವಿದೆ |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| | ಹೊಸ ಜಗತ್ತಿನ ನಿಯಮಗಳ ವ್ಯಾಖ್ಯಾನ, Q-ಲರ್ನಿಂಗ್ ಆಲ್ಗಾರಿದಮ್ ಮತ್ತು ಕೆಲವು ಪಠ್ಯ ವಿವರಣೆಗಳೊಂದಿಗೆ ನೋಟ್ಬುಕ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ. Q-ಲರ್ನಿಂಗ್ ಯಾದೃಚ್ಛಿಕ ನಡಿಗೆಯೊಂದಿಗೆ ಹೋಲಿಸಿದಾಗ ಫಲಿತಾಂಶಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. | ನೋಟ್ಬುಕ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ, Q-ಲರ್ನಿಂಗ್ ಅನುಷ್ಠಾನಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಯಾದೃಚ್ಛಿಕ ನಡಿಗೆಯೊಂದಿಗೆ ಹೋಲಿಸಿದಾಗ ಫಲಿತಾಂಶಗಳನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಆದರೆ ಗಮನಾರ್ಹವಾಗಿ ಅಲ್ಲ; ಅಥವಾ ನೋಟ್ಬುಕ್ ಕಡಿಮೆ ದಾಖಲೆಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಕೋಡ್ ಚೆನ್ನಾಗಿ ರಚಿಸಲ್ಪಟ್ಟಿಲ್ಲ | ಜಗತ್ತಿನ ನಿಯಮಗಳನ್ನು ಮರು ವ್ಯಾಖ್ಯಾನಿಸಲು ಕೆಲವು ಪ್ರಯತ್ನಗಳು ಮಾಡಲಾಗಿದೆ, ಆದರೆ Q-ಲರ್ನಿಂಗ್ ಆಲ್ಗಾರಿದಮ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ, ಅಥವಾ ಬಹುಮಾನ ಕಾರ್ಯ ಸಂಪೂರ್ಣವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲ್ಪಟ್ಟಿಲ್ಲ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

413
translations/kn/8-Reinforcement/1-QLearning/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

17
translations/kn/8-Reinforcement/1-QLearning/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:54:59+00:00",
"source_file": "8-Reinforcement/1-QLearning/solution/Julia/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/8-Reinforcement/1-QLearning/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T15:55:31+00:00",
"source_file": "8-Reinforcement/1-QLearning/solution/R/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

426
translations/kn/8-Reinforcement/1-QLearning/solution/assignment-solution.ipynb
View File

File diff suppressed because one or more lines are too long

579
translations/kn/8-Reinforcement/1-QLearning/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

356
translations/kn/8-Reinforcement/2-Gym/README.md
Unescape View File

@ -0,0 +1,356 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "107d5bb29da8a562e7ae72262d251a75",
"translation_date": "2025-12-19T15:40:37+00:00",
"source_file": "8-Reinforcement/2-Gym/README.md",
"language_code": "kn"
}
-->
# ಕಾರ್ಟ್‌ಪೋಲ್ ಸ್ಕೇಟಿಂಗ್
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ನಾವು ಪರಿಹರಿಸುತ್ತಿದ್ದ ಸಮಸ್ಯೆ ಆಟದ ಸಮಸ್ಯೆಯಂತೆ ಕಾಣಬಹುದು, ನಿಜವಾದ ಜೀವನದ ಸಂದರ್ಭಗಳಿಗೆ ಅನ್ವಯಿಸುವುದಿಲ್ಲ ಎಂದು ಭಾಸವಾಗಬಹುದು. ಆದರೆ ಇದು ಸತ್ಯವಲ್ಲ, ಏಕೆಂದರೆ ಅನೇಕ ನಿಜವಾದ ಜಗತ್ತಿನ ಸಮಸ್ಯೆಗಳು ಕೂಡ ಈ ದೃಶ್ಯವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ - ಚೆಸ್ ಅಥವಾ ಗೋ ಆಟವನ್ನೂ ಸೇರಿಸಿ. ಅವುಗಳು ಸಮಾನವಾಗಿವೆ, ಏಕೆಂದರೆ ನಮಗೂ ನಿಯಮಗಳೊಂದಿಗೆ ಒಂದು ಬೋರ್ಡ್ ಇದೆ ಮತ್ತು **ವಿಭಜಿತ ಸ್ಥಿತಿ** ಇದೆ.
## [ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ಪರಿಚಯ
ಈ ಪಾಠದಲ್ಲಿ ನಾವು Q-ಲರ್ನಿಂಗ್‌ನ ಅದೇ ತತ್ವಗಳನ್ನು **ನಿರಂತರ ಸ್ಥಿತಿ** ಹೊಂದಿರುವ ಸಮಸ್ಯೆಗೆ ಅನ್ವಯಿಸುವೆವು, ಅಂದರೆ ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ನಿಜವಾದ ಸಂಖ್ಯೆಗಳ ಮೂಲಕ ನೀಡಲ್ಪಡುವ ಸ್ಥಿತಿ. ನಾವು ಕೆಳಗಿನ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುವೆವು:
> **ಸಮಸ್ಯೆ**: ಪೀಟರ್ ನಾಯಿ ಹಂದಿಯಿಂದ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು, ಅವನು ವೇಗವಾಗಿ ಚಲಿಸಲು ಸಾಧ್ಯವಾಗಬೇಕು. ನಾವು ನೋಡೋಣ ಪೀಟರ್ ಹೇಗೆ ಸ್ಕೇಟ್ ಮಾಡುವುದು ಕಲಿಯಬಹುದು, ವಿಶೇಷವಾಗಿ, ಸಮತೋಲನವನ್ನು ಕಾಯ್ದುಕೊಳ್ಳಲು, Q-ಲರ್ನಿಂಗ್ ಬಳಸಿ.
![ದ ಗ್ರೇಟ್ ಎಸ್ಕೇಪ್!](../../../../translated_images/escape.18862db9930337e3fce23a9b6a76a06445f229dadea2268e12a6f0a1fde12115.kn.png)
> ಪೀಟರ್ ಮತ್ತು ಅವನ ಸ್ನೇಹಿತರು ನಾಯಿ ಹಂದಿಯಿಂದ ತಪ್ಪಿಸಲು ಸೃಜನಶೀಲರಾಗುತ್ತಾರೆ! ಚಿತ್ರ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ಅವರಿಂದ
ನಾವು ಸಮತೋಲನದ ಸರಳೀಕೃತ ಆವೃತ್ತಿಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದನ್ನು **ಕಾರ್ಟ್‌ಪೋಲ್** ಸಮಸ್ಯೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಕಾರ್ಟ್‌ಪೋಲ್ ಜಗತ್ತಿನಲ್ಲಿ, ನಮಗೆ ಎಡಕ್ಕೆ ಅಥವಾ ಬಲಕ್ಕೆ ಚಲಿಸುವ ಹೋರಿಜಾಂಟಲ್ ಸ್ಲೈಡರ್ ಇದೆ, ಮತ್ತು ಗುರಿ ಸ್ಲೈಡರ್ ಮೇಲಿನ ಲಂಬ ಕಂಬವನ್ನು ಸಮತೋಲನದಲ್ಲಿಡುವುದು.
<img alt="a cartpole" src="../../../../translated_images/cartpole.b5609cc0494a14f75d121299495ae24fd8f1c30465e7b40961af94ecda2e1cd0.kn.png" width="200"/>
## ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು
ಈ ಪಾಠದಲ್ಲಿ, ನಾವು **OpenAI Gym** ಎಂಬ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುತ್ತೇವೆ ವಿವಿಧ **ಪರಿಸರಗಳನ್ನು** ಅನುಕರಿಸಲು. ನೀವು ಈ ಪಾಠದ ಕೋಡ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ (ಉದಾ. Visual Studio Code ನಿಂದ) ಚಾಲನೆ ಮಾಡಬಹುದು, ಆ ಸಂದರ್ಭದಲ್ಲಿ ಅನುಕರಣ ಹೊಸ ವಿಂಡೋದಲ್ಲಿ ತೆರೆಯುತ್ತದೆ. ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಕೋಡ್ ಚಾಲನೆ ಮಾಡುವಾಗ, ನೀವು ಕೆಲವು ತಿದ್ದುಪಡಿ ಮಾಡಬೇಕಾಗಬಹುದು, ಇದನ್ನು ಇಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ [ಇಲ್ಲಿ](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
## OpenAI Gym
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ಆಟದ ನಿಯಮಗಳು ಮತ್ತು ಸ್ಥಿತಿಯನ್ನು ನಾವು ಸ್ವತಃ ವ್ಯಾಖ್ಯಾನಿಸಿದ `Board` ವರ್ಗದಿಂದ ನೀಡಲಾಗಿತ್ತು. ಇಲ್ಲಿ ನಾವು ಸಮತೋಲನದ ಕಂಬದ ಭೌತಶಾಸ್ತ್ರವನ್ನು ಅನುಕರಿಸುವ ವಿಶೇಷ **ಅನುಕರಣ ಪರಿಸರ** ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಬಲವರ್ಧನೆ ಕಲಿಕೆ ಆಲ್ಗಾರಿದಮ್ಗಳ ತರಬೇತಿಗೆ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಅನುಕರಣ ಪರಿಸರಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ [Gym](https://gym.openai.com/), ಇದು [OpenAI](https://openai.com/) ಮೂಲಕ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಈ ಜಿಮ್ ಬಳಸಿ ನಾವು ಕಾರ್ಟ್‌ಪೋಲ್ ಅನುಕರಣದಿಂದ ಅಟಾರಿ ಆಟಗಳವರೆಗೆ ವಿಭಿನ್ನ **ಪರಿಸರಗಳನ್ನು** ರಚಿಸಬಹುದು.
> **ಗಮನಿಸಿ**: OpenAI Gym ನಿಂದ ಲಭ್ಯವಿರುವ ಇತರ ಪರಿಸರಗಳನ್ನು ನೀವು [ಇಲ್ಲಿ](https://gym.openai.com/envs/#classic_control) ನೋಡಬಹುದು.
ಮೊದಲು, ಜಿಮ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಅಗತ್ಯ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳೋಣ (ಕೋಡ್ ಬ್ಲಾಕ್ 1):
```python
import sys
!{sys.executable} -m pip install gym
import gym
import matplotlib.pyplot as plt
import numpy as np
import random
```
## ಅಭ್ಯಾಸ - ಕಾರ್ಟ್‌ಪೋಲ್ ಪರಿಸರವನ್ನು ಪ್ರಾರಂಭಿಸಿ
ಕಾರ್ಟ್‌ಪೋಲ್ ಸಮತೋಲನ ಸಮಸ್ಯೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು, ನಾವು ಸಂಬಂಧಿಸಿದ ಪರಿಸರವನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು. ಪ್ರತಿ ಪರಿಸರವು ಕೆಳಗಿನೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದೆ:
- **ನಿರೀಕ್ಷಣಾ ಸ್ಥಳ** ಇದು ಪರಿಸರದಿಂದ ನಾವು ಪಡೆಯುವ ಮಾಹಿತಿಯ ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಕಾರ್ಟ್‌ಪೋಲ್ ಸಮಸ್ಯೆಗೆ, ನಾವು ಕಂಬದ ಸ್ಥಾನ, ವೇಗ ಮತ್ತು ಕೆಲವು ಇತರ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ.
- **ಕ್ರಿಯೆ ಸ್ಥಳ** ಇದು ಸಾಧ್ಯವಾದ ಕ್ರಿಯೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಕ್ರಿಯೆ ಸ್ಥಳವು ವಿಭಜಿತವಾಗಿದೆ, ಮತ್ತು ಎರಡು ಕ್ರಿಯೆಗಳಿವೆ - **ಎಡ** ಮತ್ತು **ಬಲ**. (ಕೋಡ್ ಬ್ಲಾಕ್ 2)
1. ಪ್ರಾರಂಭಿಸಲು, ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ:
```python
env = gym.make("CartPole-v1")
print(env.action_space)
print(env.observation_space)
print(env.action_space.sample())
```
ಪರಿಸರ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೋಡಲು, 100 ಹಂತಗಳ ಸಣ್ಣ ಅನುಕರಣವನ್ನು ನಡೆಸೋಣ. ಪ್ರತಿ ಹಂತದಲ್ಲಿ, ನಾವು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಕ್ರಿಯೆಯೊಂದನ್ನು ನೀಡುತ್ತೇವೆ - ಈ ಅನುಕರಣದಲ್ಲಿ ನಾವು `action_space` ನಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ.
1. ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ ಮತ್ತು ಅದು ಏನಾಗುತ್ತದೆ ನೋಡಿ.
✅ ನೆನಪಿಡಿ, ಈ ಕೋಡ್ ಅನ್ನು ಸ್ಥಳೀಯ Python ಸ್ಥಾಪನೆಯಲ್ಲಿ ಚಾಲನೆ ಮಾಡುವುದು ಆದ್ಯತೆ! (ಕೋಡ್ ಬ್ಲಾಕ್ 3)
```python
env.reset()
for i in range(100):
env.render()
env.step(env.action_space.sample())
env.close()
```
ನೀವು ಈ ಚಿತ್ರಕ್ಕೆ ಸಮಾನವಾದುದನ್ನು ನೋಡಬಹುದು:
![ನಾನ್-ಬ್ಯಾಲನ್ಸಿಂಗ್ ಕಾರ್ಟ್‌ಪೋಲ್](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)
1. ಅನುಕರಣದ ಸಮಯದಲ್ಲಿ, ನಾವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು ನಿರೀಕ್ಷಣೆಗಳನ್ನು ಪಡೆಯಬೇಕಾಗುತ್ತದೆ. ವಾಸ್ತವದಲ್ಲಿ, ಸ್ಟೆಪ್ ಫಂಕ್ಷನ್ ಪ್ರಸ್ತುತ ನಿರೀಕ್ಷಣೆಗಳನ್ನು, ಬಹುಮಾನ ಕಾರ್ಯವನ್ನು ಮತ್ತು ಅನುಕರಣವನ್ನು ಮುಂದುವರಿಸಲು ಅರ್ಥವಿರುವುದೇ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಸೂಚಿಸುವ ಡನ್ ಫ್ಲಾಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ: (ಕೋಡ್ ಬ್ಲಾಕ್ 4)
```python
env.reset()
done = False
while not done:
env.render()
obs, rew, done, info = env.step(env.action_space.sample())
print(f"{obs} -> {rew}")
env.close()
```
ನೀವು ನೋಟ್ಬುಕ್ ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಈ ರೀತಿಯುದನ್ನು ನೋಡುತ್ತೀರಿ:
```text
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0
[ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0
[ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0
[ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0
[ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0
...
[ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0
[ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0
```
ಅನುಕರಣದ ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಹಿಂತಿರುಗಿಸುವ ನಿರೀಕ್ಷಣಾ ವೆಕ್ಟರ್ ಕೆಳಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ:
- ಕಾರ್ಟ್‌ನ ಸ್ಥಾನ
- ಕಾರ್ಟ್‌ನ ವೇಗ
- ಕಂಬದ ಕೋನ
- ಕಂಬದ ತಿರುಗುವ ದರ
1. ಆ ಸಂಖ್ಯೆಗಳ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಿರಿ: (ಕೋಡ್ ಬ್ಲಾಕ್ 5)
```python
print(env.observation_space.low)
print(env.observation_space.high)
```
ನೀವು ಗಮನಿಸಬಹುದು ಪ್ರತಿ ಅನುಕರಣ ಹಂತದಲ್ಲಿ ಬಹುಮಾನ ಮೌಲ್ಯವು ಸದಾ 1 ಆಗಿರುತ್ತದೆ. ಇದಕ್ಕೆ ಕಾರಣ ನಮ್ಮ ಗುರಿ ಸಾಧ್ಯವಾದಷ್ಟು ದೀರ್ಘಕಾಲ ಜೀವಿಸುವುದು, ಅಂದರೆ ಕಂಬವನ್ನು ಸಮತೋಲನದಲ್ಲಿಡುವುದು.
✅ ವಾಸ್ತವದಲ್ಲಿ, ಕಾರ್ಟ್‌ಪೋಲ್ ಅನುಕರಣವನ್ನು 100連続 ಪ್ರಯೋಗಗಳಲ್ಲಿ ಸರಾಸರಿ 195 ಬಹುಮಾನವನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಾದರೆ ಅದು ಪರಿಹರಿಸಲಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.
## ಸ್ಥಿತಿ ವಿಭಜನೆ
Q-ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಸ್ಥಿತಿಯಲ್ಲಿ ಏನು ಮಾಡಬೇಕೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುವ Q-ಟೇಬಲ್ ನಿರ್ಮಿಸಬೇಕಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಸ್ಥಿತಿಯು **ವಿಭಜಿತ** ಆಗಿರಬೇಕು, ಅಂದರೆ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ವಿಭಜಿತ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರಬೇಕು. ಆದ್ದರಿಂದ, ನಾವು ನಮ್ಮ ನಿರೀಕ್ಷಣೆಗಳನ್ನು ಹೇಗೆಂದರೆ **ವಿಭಜಿಸಬೇಕು**, ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಗಳ ಸಮೂಹಕ್ಕೆ ನಕ್ಷೆ ಮಾಡಬೇಕು.
ಇದಕ್ಕೆ ಕೆಲವು ವಿಧಾನಗಳಿವೆ:
- **ಬಿನ್‌ಗಳಿಗೆ ವಿಭಜನೆ**. ನಾವು ಒಂದು ಮೌಲ್ಯದ ಅಂತರವನ್ನು ತಿಳಿದಿದ್ದರೆ, ಆ ಅಂತರವನ್ನು ಹಲವಾರು **ಬಿನ್‌ಗಳಾಗಿ** ವಿಭಜಿಸಬಹುದು, ನಂತರ ಮೌಲ್ಯವನ್ನು ಅದು ಸೇರಿದ ಬಿನ್ ಸಂಖ್ಯೆಯಿಂದ ಬದಲಾಯಿಸಬಹುದು. ಇದನ್ನು numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html) ವಿಧಾನ ಬಳಸಿ ಮಾಡಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನಿಖರವಾಗಿ ಸ್ಥಿತಿಯ ಗಾತ್ರವನ್ನು ತಿಳಿದುಕೊಳ್ಳುತ್ತೇವೆ, ಏಕೆಂದರೆ ಅದು ನಾವು ಆಯ್ಕೆಮಾಡಿದ ಬಿನ್‌ಗಳ ಸಂಖ್ಯೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ.
✅ ನಾವು ರೇಖೀಯ ಇಂಟರ್‌ಪೋಲೇಶನ್ ಬಳಸಿ ಮೌಲ್ಯಗಳನ್ನು ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಅಂತರಕ್ಕೆ (ಉದಾ. -20 ರಿಂದ 20) ತಂದು, ನಂತರ ಸಂಖ್ಯೆಗಳನ್ನೂ ಸುತ್ತುವರಿದಂತೆ ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಪರಿವರ್ತಿಸಬಹುದು. ಇದು ಸ್ಥಿತಿಯ ಗಾತ್ರದ ಮೇಲೆ ಸ್ವಲ್ಪ ಕಡಿಮೆ ನಿಯಂತ್ರಣ ನೀಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ನಮಗೆ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯಗಳ ನಿಖರ ಶ್ರೇಣಿಗಳು ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ. ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ 4 ಮೌಲ್ಯಗಳಲ್ಲಿ 2 ಕ್ಕೆ ಮೇಲ್ಭಾಗ/ಕೆಳಭಾಗ ಮಿತಿ ಇಲ್ಲ, ಇದು ಅನಂತ ಸಂಖ್ಯೆಯ ಸ್ಥಿತಿಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಎರಡನೇ ವಿಧಾನವನ್ನು ಅನುಸರಿಸುವೆವು. ನೀವು ನಂತರ ಗಮನಿಸಬಹುದು, ನಿರ್ದಿಷ್ಟ ಮೇಲ್ಭಾಗ/ಕೆಳಭಾಗ ಮಿತಿಗಳಿಲ್ಲದಿದ್ದರೂ, ಆ ಮೌಲ್ಯಗಳು ಅಪರೂಪವಾಗಿ ನಿರ್ದಿಷ್ಟ ನಿರ್ದಿಷ್ಟ ಅಂತರದ ಹೊರಗೆ ಹೋಗುತ್ತವೆ, ಆದ್ದರಿಂದ ಅತಿ ಮಿತಿಯ ಸ್ಥಿತಿಗಳು ಬಹಳ ಅಪರೂಪವಾಗಿರುತ್ತವೆ.
1. ಇಲ್ಲಿ ನಮ್ಮ ಮಾದರಿಯಿಂದ ನಿರೀಕ್ಷಣೆಯನ್ನು ತೆಗೆದು 4 ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಗಳ ಟ್ಯೂಪಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಫಂಕ್ಷನ್ ಇದೆ: (ಕೋಡ್ ಬ್ಲಾಕ್ 6)
```python
def discretize(x):
return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
```
1. ಇನ್ನೊಂದು ವಿಭಜನೆ ವಿಧಾನವನ್ನು ಬಿನ್‌ಗಳ ಬಳಕೆ ಮೂಲಕ ಅನ್ವೇಷಿಸೋಣ: (ಕೋಡ್ ಬ್ಲಾಕ್ 7)
```python
def create_bins(i,num):
return np.arange(num+1)*(i[1]-i[0])/num+i[0]
print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))
ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # ಪ್ರತಿ ಪರಿಮಾಣದ ಮೌಲ್ಯಗಳ ಮಧ್ಯಂತರಗಳು
nbins = [20,20,10,10] # ಪ್ರತಿ ಪರಿಮಾಣದ ಬಿನ್‌ಗಳ ಸಂಖ್ಯೆ
bins = [create_bins(ints[i],nbins[i]) for i in range(4)]
def discretize_bins(x):
return tuple(np.digitize(x[i],bins[i]) for i in range(4))
```
1. ಈಗ ಸಣ್ಣ ಅನುಕರಣವನ್ನು ನಡೆಸಿ ಆ ವಿಭಜಿತ ಪರಿಸರ ಮೌಲ್ಯಗಳನ್ನು ಗಮನಿಸೋಣ. ನೀವು `discretize` ಮತ್ತು `discretize_bins` ಎರಡನ್ನೂ ಪ್ರಯತ್ನಿಸಿ ವ್ಯತ್ಯಾಸವಿದೆಯೇ ಎಂದು ನೋಡಿ.
✅ `discretize_bins` ಬಿನ್ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು 0-ಆಧಾರಿತವಾಗಿದೆ. ಆದ್ದರಿಂದ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯದ ಸುತ್ತಲೂ 0 ಇರುವ ಮೌಲ್ಯಗಳಿಗೆ ಇದು ಅಂತರದ ಮಧ್ಯಭಾಗದ ಸಂಖ್ಯೆಯನ್ನು (10) ಹಿಂತಿರುಗಿಸುತ್ತದೆ. `discretize` ನಲ್ಲಿ, ನಾವು ಔಟ್‌ಪುಟ್ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಪರಿಗಣಿಸಿಲ್ಲ, ಅವು ನೆಗೆಟಿವ್ ಆಗಿರಬಹುದು, ಆದ್ದರಿಂದ ಸ್ಥಿತಿ ಮೌಲ್ಯಗಳು ಸರಿದೂಗಿಲ್ಲ, ಮತ್ತು 0 0 ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. (ಕೋಡ್ ಬ್ಲಾಕ್ 8)
```python
env.reset()
done = False
while not done:
#env.render()
obs, rew, done, info = env.step(env.action_space.sample())
#print(discretize_bins(obs))
print(discretize(obs))
env.close()
```
✅ ನೀವು ಪರಿಸರ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೋಡಲು `env.render` ಆರಂಭವಾಗುವ ಸಾಲನ್ನು ಅನ್ಕಮೆಂಟ್ ಮಾಡಬಹುದು. ಇಲ್ಲದಿದ್ದರೆ ನೀವು ಅದನ್ನು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಇದು ವೇಗವಾಗಿದೆ. ನಾವು ನಮ್ಮ Q-ಲರ್ನಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಈ "ಅದೃಶ್ಯ" ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.
## Q-ಟೇಬಲ್ ರಚನೆ
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ಸ್ಥಿತಿ 0 ರಿಂದ 8 ರವರೆಗೆ ಸರಳ ಸಂಖ್ಯೆಗಳ ಜೋಡಿ ಆಗಿತ್ತು, ಆದ್ದರಿಂದ Q-ಟೇಬಲ್ ಅನ್ನು 8x8x2 ಆಕಾರದ numpy ಟೆನ್ಸರ್ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸುವುದು ಅನುಕೂಲಕರವಾಗಿತ್ತು. ನಾವು ಬಿನ್‌ಗಳ ವಿಭಜನೆ ಬಳಸಿದರೆ, ಸ್ಥಿತಿ ವೆಕ್ಟರ್ ಗಾತ್ರವೂ ತಿಳಿದಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದೇ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಸ್ಥಿತಿಯನ್ನು 20x20x10x10x2 ಆಕಾರದ ಅರೇ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸಬಹುದು (ಇಲ್ಲಿ 2 ಕ್ರಿಯೆ ಸ್ಥಳದ ಆಯಾಮ, ಮತ್ತು ಮೊದಲ ಆಯಾಮಗಳು ನಿರೀಕ್ಷಣಾ ಸ್ಥಳದ ಪ್ರತಿ ಪರಿಮಾಣಕ್ಕೆ ನಾವು ಆಯ್ಕೆಮಾಡಿದ ಬಿನ್‌ಗಳ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಕೆಯಾಗಿವೆ).
ಆದರೆ, ಕೆಲವೊಮ್ಮೆ ನಿರೀಕ್ಷಣಾ ಸ್ಥಳದ ನಿಖರ ಆಯಾಮಗಳು ತಿಳಿದಿರಲಾರವು. `discretize` ಫಂಕ್ಷನ್‌ನ ಸಂದರ್ಭದಲ್ಲಿ, ನಮ್ಮ ಸ್ಥಿತಿ ನಿರ್ದಿಷ್ಟ ಮಿತಿಗಳೊಳಗಿರುತ್ತದೆ ಎಂದು ನಾವು ಎಂದಿಗೂ ಖಚಿತವಾಗಿರಲಾರವು, ಏಕೆಂದರೆ ಕೆಲವು ಮೂಲ ಮೌಲ್ಯಗಳಿಗೆ ಮಿತಿ ಇಲ್ಲ. ಆದ್ದರಿಂದ, ನಾವು ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು Q-ಟೇಬಲ್ ಅನ್ನು ಡಿಕ್ಷನರಿ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸುತ್ತೇವೆ.
1. *(ಸ್ಥಿತಿ, ಕ್ರಿಯೆ)* ಜೋಡಿಯನ್ನು ಡಿಕ್ಷನರಿ ಕೀ ಆಗಿ ಬಳಸಿ, ಮತ್ತು ಮೌಲ್ಯವು Q-ಟೇಬಲ್ ಎಂಟ್ರಿ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. (ಕೋಡ್ ಬ್ಲಾಕ್ 9)
```python
Q = {}
actions = (0,1)
def qvalues(state):
return [Q.get((state,a),0) for a in actions]
```
ಇಲ್ಲಿ ನಾವು `qvalues()` ಎಂಬ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಇದು ನೀಡಲಾದ ಸ್ಥಿತಿಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಸಾಧ್ಯ ಕ್ರಿಯೆಗಳಿಗಾಗಿ Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಎಂಟ್ರಿ Q-ಟೇಬಲ್‌ನಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಡೀಫಾಲ್ಟ್ ಆಗಿ 0 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.
## Q-ಲರ್ನಿಂಗ್ ಪ್ರಾರಂಭಿಸೋಣ
ಈಗ ನಾವು ಪೀಟರ್‌ಗೆ ಸಮತೋಲನ ಕಲಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದೇವೆ!
1. ಮೊದಲು, ಕೆಲವು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸೆಟ್ ಮಾಡೋಣ: (ಕೋಡ್ ಬ್ಲಾಕ್ 10)
```python
# ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು
alpha = 0.3
gamma = 0.9
epsilon = 0.90
```
ಇಲ್ಲಿ, `alpha` ಎಂಬುದು **ಕಲಿಕೆಯ ದರ** ಆಗಿದ್ದು, ಪ್ರತಿ ಹಂತದಲ್ಲಿ Q-ಟೇಬಲ್‌ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯಗಳನ್ನು ಎಷ್ಟು ಮಟ್ಟಿಗೆ ಸರಿಪಡಿಸಬೇಕೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ನಾವು 1 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ, ನಂತರ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ `alpha` ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿದ್ದೇವೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಸರಳತೆಗೆ ನಾವು ಅದನ್ನು ಸ್ಥಿರವಾಗಿರಿಸುವೆವು, ಮತ್ತು ನೀವು ನಂತರ `alpha` ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯೋಗ ಮಾಡಬಹುದು.
`gamma` ಎಂಬುದು **ರಿಯಾಯಿತಿ ಕಡಿತಾಂಶ** ಆಗಿದ್ದು, ಭವಿಷ್ಯದ ಬಹುಮಾನವನ್ನು ಪ್ರಸ್ತುತ ಬಹುಮಾನಕ್ಕಿಂತ ಎಷ್ಟು ಆದ್ಯತೆ ನೀಡಬೇಕೆಂದು ತೋರಿಸುತ್ತದೆ.
`epsilon` ಎಂಬುದು **ಅನ್ವೇಷಣೆ/ಶೋಷಣೆ ಅಂಶ** ಆಗಿದ್ದು, ನಾವು ಅನ್ವೇಷಣೆಗೆ ಆದ್ಯತೆ ನೀಡಬೇಕೇ ಅಥವಾ ಶೋಷಣೆಗೆ ನೀಡಬೇಕೇ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ. ನಮ್ಮ ಆಲ್ಗಾರಿದಮ್ನಲ್ಲಿ, ನಾವು `epsilon` ಶೇಕಡಾವಾರು ಸಂದರ್ಭಗಳಲ್ಲಿ Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರ ಮುಂದಿನ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತೇವೆ, ಉಳಿದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತೇವೆ. ಇದು ನಮಗೆ ಹಿಂದೆ ನೋಡದ ಹುಡುಕಾಟ ಪ್ರದೇಶಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.
✅ ಸಮತೋಲನದ ದೃಷ್ಟಿಯಿಂದ - ಯಾದೃಚ್ಛಿಕ ಕ್ರಿಯೆ ಆಯ್ಕೆಮಾಡುವುದು (ಅನ್ವೇಷಣೆ) ತಪ್ಪು ದಿಕ್ಕಿನಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಹೊಡೆತದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಮತ್ತು ಕಂಬವು ಆ "ತಪ್ಪುಗಳಿಂದ" ಸಮತೋಲನವನ್ನು ಹೇಗೆ ಮರುಸ್ಥಾಪಿಸಿಕೊಳ್ಳಬೇಕೆಂದು ಕಲಿಯಬೇಕು.
### ಆಲ್ಗಾರಿದಮ್ನ ಸುಧಾರಣೆ
ಹಿಂದಿನ ಪಾಠದಿಂದ ನಮ್ಮ ಆಲ್ಗಾರಿದಮ್ನಲ್ಲಿ ಎರಡು ಸುಧಾರಣೆಗಳನ್ನು ಮಾಡಬಹುದು:
- **ಸರಾಸರಿ ಸಂಗ್ರಹಿತ ಬಹುಮಾನವನ್ನು ಲೆಕ್ಕಿಸು**, ಹಲವಾರು ಅನುಕರಣಗಳ ಮೇಲೆ. ನಾವು ಪ್ರಗತಿಯನ್ನು ಪ್ರತಿ 5000 ಪುನರಾವೃತ್ತಿಗಳಲ್ಲಿ ಮುದ್ರಿಸುವೆವು, ಮತ್ತು ಆ ಅವಧಿಯಲ್ಲಿ ನಮ್ಮ ಸಂಗ್ರಹಿತ ಬಹುಮಾನವನ್ನು ಸರಾಸರಿ ಮಾಡುತ್ತೇವೆ. ಅಂದರೆ, ನಾವು 195 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಂಕಗಳನ್ನು ಪಡೆಯುತ್ತಿದ್ದರೆ - ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು, ಅಗತ್ಯಕ್ಕಿಂತಲೂ ಉತ್ತಮ ಗುಣಮಟ್ಟದೊಂದಿಗೆ.
- **ಗರಿಷ್ಠ ಸರಾಸರಿ ಸಂಗ್ರಹಿತ ಫಲಿತಾಂಶ** `Qmax` ಅನ್ನು ಲೆಕ್ಕಿಸು, ಮತ್ತು ಆ ಫಲಿತಾಂಶಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ Q-ಟೇಬಲ್ ಅನ್ನು ಸಂಗ್ರಹಿಸೋಣ. ತರಬೇತಿ ನಡೆಸುವಾಗ ನೀವು ಗಮನಿಸುವಿರಿ ಕೆಲವೊಮ್ಮೆ ಸರಾಸರಿ ಸಂಗ್ರಹಿತ ಫಲಿತಾಂಶ ಕುಸಿಯಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಮತ್ತು ನಾವು ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಗಮನಿಸಿದ ಅತ್ಯುತ್ತಮ ಮಾದರಿಯ Q-ಟೇಬಲ್ ಮೌಲ್ಯಗಳನ್ನು ಕಾಯ್ದುಕೊಳ್ಳಲು ಬಯಸುತ್ತೇವೆ.
1. ಮುಂದಿನ ಚಿತ್ರಣಕ್ಕಾಗಿ ಪ್ರತಿ ಅನುಕರಣದಲ್ಲಿ ಎಲ್ಲಾ ಸಂಗ್ರಹಿತ ಬಹುಮಾನಗಳನ್ನು `rewards` ವೆಕ್ಟರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸೋಣ. (ಕೋಡ್ ಬ್ಲಾಕ್ 11)
```python
def probs(v,eps=1e-4):
v = v-v.min()+eps
v = v/v.sum()
return v
Qmax = 0
cum_rewards = []
rewards = []
for epoch in range(100000):
obs = env.reset()
done = False
cum_reward=0
# == ಅನುಕರಣೆ ನಡೆಸಿ ==
while not done:
s = discretize(obs)
if random.random()<epsilon:
# ಶೋಷಣೆ - Q-ಟೇಬಲ್ ಪ್ರಾಬಬಿಲಿಟಿಗಳ ಪ್ರಕಾರ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ
v = probs(np.array(qvalues(s)))
a = random.choices(actions,weights=v)[0]
else:
# ಅನ್ವೇಷಣೆ - ಯಾದೃಚ್ಛಿಕವಾಗಿ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ
a = np.random.randint(env.action_space.n)
obs, rew, done, info = env.step(a)
cum_reward+=rew
ns = discretize(obs)
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
cum_rewards.append(cum_reward)
rewards.append(cum_reward)
# == ನಿಯಮಿತವಾಗಿ ಫಲಿತಾಂಶಗಳನ್ನು ಮುದ್ರಿಸಿ ಮತ್ತು ಸರಾಸರಿ ಬಹುಮಾನವನ್ನು ಲೆಕ್ಕಹಾಕಿ ==
if epoch%5000==0:
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
if np.average(cum_rewards) > Qmax:
Qmax = np.average(cum_rewards)
Qbest = Q
cum_rewards=[]
```
ನೀವು ಆ ಫಲಿತಾಂಶಗಳಿಂದ ಗಮನಿಸಬಹುದಾದವು:
- **ನಮ್ಮ ಗುರಿಗೆ ಹತ್ತಿರ**. ನಾವು 100+連続 ಅನುಕರಣಗಳಲ್ಲಿ 195 ಸಂಗ್ರಹಿತ ಬಹುಮಾನಗಳನ್ನು ಪಡೆಯುವ ಗುರಿಗೆ ಬಹಳ ಹತ್ತಿರವಿದ್ದೇವೆ, ಅಥವಾ ನಾವು ಅದನ್ನು ನಿಜವಾಗಿಯೂ ಸಾಧಿಸಿದ್ದೇವೆ! ಕಡಿಮೆ ಅಂಕಗಳನ್ನು ಪಡೆದರೂ, ನಾವು ಖಚಿತವಾಗಿಲ್ಲ, ಏಕೆಂದರೆ ನಾವು 5000 ಪ್ರಯೋಗಗಳ ಸರಾಸರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಮತ್ತು ಅಧಿಕೃತ ಮಾನದಂಡದಲ್ಲಿ ಕೇವಲ 100 ಪ್ರಯೋಗಗಳು ಬೇಕಾಗಿವೆ.
- **ಬಹುಮಾನ ಕುಸಿಯಲು ಪ್ರಾರಂಭ**. ಕೆಲವೊಮ್ಮೆ ಬಹುಮಾನ ಕುಸಿಯಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಅಂದರೆ ನಾವು ಈಗಾಗಲೇ ಕಲಿತ ಮೌಲ್ಯಗಳನ್ನು Q-ಟೇಬಲ್‌ನಲ್ಲಿ ಹಾಳುಮಾಡಬಹುದು, ಅದು ಪರಿಸ್ಥಿತಿಯನ್ನು ಕೆಟ್ಟದಾಗಿಸುತ್ತದೆ.
ಈ ಗಮನಿಕೆ ತರಬೇತಿ ಪ್ರಗತಿಯನ್ನು ಚಿತ್ರಿಸುವಾಗ ಸ್ಪಷ್ಟವಾಗಿ ಕಾಣುತ್ತದೆ.
## ತರಬೇತಿ ಪ್ರಗತಿ ಚಿತ್ರಣ
ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಪುನರಾವೃತ್ತಿಯಲ್ಲಿ ಸಂಗ್ರಹಿತ ಬಹುಮಾನ ಮೌಲ್ಯವನ್ನು `rewards` ವೆಕ್ಟರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ್ದೇವೆ. ಇದನ್ನು ಪುನರಾವೃತ್ತಿ ಸಂಖ್ಯೆಯ ವಿರುದ್ಧ ಚಿತ್ರಿಸಿದಾಗ ಇದು ಹೀಗೆ ಕಾಣುತ್ತದೆ:
```python
plt.plot(rewards)
```
![ಕಚ್ಚಾ ಪ್ರಗತಿ](../../../../translated_images/train_progress_raw.2adfdf2daea09c596fc786fa347a23e9aceffe1b463e2257d20a9505794823ec.kn.png)
ಈ ಗ್ರಾಫ್‌ನಿಂದ ಏನನ್ನೂ ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಸಾಂಖ್ಯಿಕ ತರಬೇತಿ ಪ್ರಕ್ರಿಯೆಯ ಸ್ವಭಾವದಿಂದ ತರಬೇತಿ ಅವಧಿಗಳ ಉದ್ದ ಬಹಳ ಬದಲಾಗುತ್ತದೆ. ಈ ಗ್ರಾಫ್‌ಗೆ ಹೆಚ್ಚು ಅರ್ಥ ನೀಡಲು, ನಾವು ಸರಣಿಯ 100 ಪ್ರಯೋಗಗಳ ಮೇಲೆ **ಚಲಿಸುವ ಸರಾಸರಿ** ಲೆಕ್ಕಿಸಬಹುದು. ಇದನ್ನು `np.convolve` ಬಳಸಿ ಸುಲಭವಾಗಿ ಮಾಡಬಹುದು: (ಕೋಡ್ ಬ್ಲಾಕ್ 12)
```python
def running_average(x,window):
return np.convolve(x,np.ones(window)/window,mode='valid')
plt.plot(running_average(rewards,100))
```
![ತರಬೇತಿ ಪ್ರಗತಿ](../../../../translated_images/train_progress_runav.c71694a8fa9ab35935aff6f109e5ecdfdbdf1b0ae265da49479a81b5fae8f0aa.kn.png)
## ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಬದಲಾವಣೆ
ಕಲಿಕೆಯನ್ನು ಹೆಚ್ಚು ಸ್ಥಿರಗೊಳಿಸಲು, ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಕೆಲವು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿಸುವುದು ಅರ್ಥಪೂರ್ಣ. ವಿಶೇಷವಾಗಿ:
- **ಕಲಿಕೆಯ ದರ** `alpha` ಗೆ, ನಾವು 1 ಗೆ ಹತ್ತಿರದ ಮೌಲ್ಯಗಳಿಂದ ಪ್ರಾರಂಭಿಸಿ, ನಂತರ ಆ ಪರಿಮಾಣವನ್ನು ನಿಧಾನವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು. ಸಮಯದೊಂದಿಗೆ, ನಾವು Q-ಟೇಬಲ್‌ನಲ್ಲಿ ಉತ್ತಮ ಪ್ರಾಬಬಿಲಿಟಿ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಸ್ವಲ್ಪ ಸರಿಪಡಿಸಬೇಕು, ಸಂಪೂರ್ಣವಾಗಿ ಹೊಸ ಮೌಲ್ಯಗಳಿಂದ ಮರುಬರೆಯಬಾರದು.
- **ಎಪ್ಸಿಲಾನ್ ಹೆಚ್ಚಿಸಿ**. ನಾವು `epsilon` ಅನ್ನು ನಿಧಾನವಾಗಿ ಹೆಚ್ಚಿಸಲು ಬಯಸಬಹುದು, ಅನ್ವೇಷಣೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಶೋಷಣೆಯನ್ನು ಹೆಚ್ಚು ಮಾಡಲು. ಇದು ಕಡಿಮೆ ಮೌಲ್ಯದಿಂದ ಪ್ರಾರಂಭಿಸಿ 1 ರವರೆಗೆ ಹಾದುಹೋಗುವುದು ಅರ್ಥಪೂರ್ಣ.
> **ಕಾರ್ಯ 1**: ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಆಟವಾಡಿ ಮತ್ತು ನೀವು ಹೆಚ್ಚು ಸಂಗ್ರಹಿತ ಬಹುಮಾನವನ್ನು ಸಾಧಿಸಬಹುದೇ ಎಂದು ನೋಡಿ. ನೀವು 195 ಕ್ಕಿಂತ ಮೇಲಾಗುತ್ತೀರಾ?
> **ಕಾರ್ಯ 2**: ಸಮಸ್ಯೆಯನ್ನು ಅಧಿಕೃತವಾಗಿ ಪರಿಹರಿಸಲು, ನೀವು 100連続 ರನ್‌ಗಳಲ್ಲಿ ಸರಾಸರಿ 195 ಬಹುಮಾನವನ್ನು ಪಡೆಯಬೇಕು. ತರಬೇತಿ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ಅಳೆಯಿರಿ ಮತ್ತು ನೀವು ಅಧಿಕೃತವಾಗಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ!
## ಪರಿಣಾಮವನ್ನು ಕ್ರಿಯೆಯಲ್ಲಿ ನೋಡುವುದು
ತರಬೇತಿಗೊಂಡ ಮಾದರಿ ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ ಎಂದು ವಾಸ್ತವವಾಗಿ ನೋಡುವುದು ಆಸಕ್ತಿದಾಯಕವಾಗಿರುತ್ತದೆ. ಸಿಮ್ಯುಲೇಶನ್ ಅನ್ನು ನಡೆಸಿ ಮತ್ತು ತರಬೇತಿ ಸಮಯದಲ್ಲಿ ಬಳಸಿದಂತೆ ಕ್ರಿಯೆ ಆಯ್ಕೆ ತಂತ್ರವನ್ನು ಅನುಸರಿಸಿ, Q-ಟೇಬಲ್‌ನ ಪ್ರಾಬಬಿಲಿಟಿ ವಿತರಣೆ ಪ್ರಕಾರ ಮಾದರಿಯನ್ನು ಸ್ಯಾಂಪಲ್ ಮಾಡಿ: (ಕೋಡ್ ಬ್ಲಾಕ್ 13)
```python
obs = env.reset()
done = False
while not done:
s = discretize(obs)
env.render()
v = probs(np.array(qvalues(s)))
a = random.choices(actions,weights=v)[0]
obs,_,done,_ = env.step(a)
env.close()
```
ನೀವು ಈ ರೀತಿಯ ಏನಾದರೂ ನೋಡಬಹುದು:
![a balancing cartpole](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif)
---
## 🚀ಸವಾಲು
> **ಕಾರ್ಯ 3**: ಇಲ್ಲಿ, ನಾವು Q-ಟೇಬಲ್‌ನ ಅಂತಿಮ ನಕಲನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ, ಅದು ಅತ್ಯುತ್ತಮವಾಗಿರದಿರಬಹುದು. ನಾವು ಅತ್ಯುತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯ Q-ಟೇಬಲ್ ಅನ್ನು `Qbest` ವ್ಯತ್ಯಯದಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ್ದೇವೆ ಎಂದು ನೆನಪಿಡಿ! `Qbest` ಅನ್ನು `Q` ಗೆ ನಕಲಿಸಿ ಅದೇ ಉದಾಹರಣೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ವ್ಯತ್ಯಾಸವನ್ನು ಗಮನಿಸಿ.
> **ಕಾರ್ಯ 4**: ಇಲ್ಲಿ ನಾವು ಪ್ರತಿ ಹಂತದಲ್ಲಿಯೂ ಅತ್ಯುತ್ತಮ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಿರಲಿಲ್ಲ, ಬದಲಿಗೆ ಸಂಬಂಧಿತ ಪ್ರಾಬಬಿಲಿಟಿ ವಿತರಣೆ ಪ್ರಕಾರ ಸ್ಯಾಂಪಲ್ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಯಾವಾಗಲೂ ಅತ್ಯುತ್ತಮ Q-ಟೇಬಲ್ ಮೌಲ್ಯ ಹೊಂದಿರುವ ಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಹೆಚ್ಚು ಅರ್ಥಪೂರ್ಣವಾಗುತ್ತದೆಯೇ? ಇದನ್ನು `np.argmax` ಫಂಕ್ಷನ್ ಬಳಸಿ ಅತ್ಯಧಿಕ Q-ಟೇಬಲ್ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿರುವ ಕ್ರಿಯೆ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು. ಈ ತಂತ್ರವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ ಮತ್ತು ಅದು ಸಮತೋಲನವನ್ನು ಸುಧಾರಿಸುತ್ತದೆಯೇ ಎಂದು ನೋಡಿ.
## [ಪೋಸ್ಟ್-ಲೆಕ್ಚರ್ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ನಿಯೋಜನೆ
[ಮೌಂಟನ್ ಕಾರ್ ತರಬೇತಿ](assignment.md)
## ಸಮಾರೋಪ
ನಾವು ಈಗಾಗಲೇ ಏಜೆಂಟ್‌ಗಳನ್ನು ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಲು ತರಬೇತಿಗೊಳಿಸುವುದನ್ನು ಕಲಿತಿದ್ದೇವೆ, ಅದು ಆಟದ ಇಚ್ಛಿತ ಸ್ಥಿತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಬಹುಮಾನ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಮತ್ತು ಹುಡುಕಾಟ ಸ್ಥಳವನ್ನು ಬುದ್ಧಿವಂತಿಕೆಯಿಂದ ಅನ್ವೇಷಿಸಲು ಅವಕಾಶ ನೀಡುವ ಮೂಲಕ. ನಾವು ಡಿಸ್ಕ್ರೀಟ್ ಮತ್ತು ನಿರಂತರ ಪರಿಸರಗಳ ಪ್ರಕರಣಗಳಲ್ಲಿ Q-ಲರ್ನಿಂಗ್ ಆಲ್ಗಾರಿಥಮ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಅನ್ವಯಿಸಿದ್ದೇವೆ, ಆದರೆ ಡಿಸ್ಕ್ರೀಟ್ ಕ್ರಿಯೆಗಳೊಂದಿಗೆ.
ಕ್ರಿಯಾ ಸ್ಥಿತಿಯೂ ನಿರಂತರವಾಗಿರುವ ಮತ್ತು ಅವಲೋಕನ ಸ್ಥಳವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿರುವ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವುದು ಕೂಡ ಮುಖ್ಯ, ಉದಾಹರಣೆಗೆ ಅಟಾರಿ ಆಟದ ಪರದೆ ಚಿತ್ರ. ಆ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಲು ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳಂತಹ ಶಕ್ತಿಶಾಲಿ ಯಂತ್ರ ಕಲಿಕೆ ತಂತ್ರಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಆ ಹೆಚ್ಚು ಪ್ರಗತಿಶೀಲ ವಿಷಯಗಳು ನಮ್ಮ ಮುಂದಿನ ಹೆಚ್ಚಿನ ಪ್ರಗತಿಶೀಲ AI ಕೋರ್ಸ್‌ನ ವಿಷಯವಾಗಿವೆ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

61
translations/kn/8-Reinforcement/2-Gym/assignment.md
Unescape View File

@ -0,0 +1,61 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1f2b7441745eb52e25745423b247016b",
"translation_date": "2025-12-19T15:43:19+00:00",
"source_file": "8-Reinforcement/2-Gym/assignment.md",
"language_code": "kn"
}
-->
# ಪರ್ವತ ಕಾರ್ ತರಬೇತಿ
[OpenAI Gym](http://gym.openai.com) ಅನ್ನು ಎಲ್ಲಾ ಪರಿಸರಗಳು ಒಂದೇ API ಒದಗಿಸುವಂತೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ - ಅಂದರೆ ಒಂದೇ ವಿಧಾನಗಳು `reset`, `step` ಮತ್ತು `render`, ಮತ್ತು **ಕ್ರಿಯೆ ಸ್ಥಳ** ಮತ್ತು **ನಿರೀಕ್ಷಣಾ ಸ್ಥಳ** ಎಂಬ ಒಂದೇ ಅವಧಾರಣೆಗಳು. ಆದ್ದರಿಂದ, ಕಡಿಮೆ ಕೋಡ್ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ವಿಭಿನ್ನ ಪರಿಸರಗಳಿಗೆ ಒಂದೇ ಬಲವರ್ಧಿತ ಕಲಿಕೆ ಆಲ್ಗಾರಿದಮ್ಗಳನ್ನು ಹೊಂದಿಸಲು ಸಾಧ್ಯವಾಗಬೇಕು.
## ಪರ್ವತ ಕಾರ್ ಪರಿಸರ
[ಪರ್ವತ ಕಾರ್ ಪರಿಸರ](https://gym.openai.com/envs/MountainCar-v0/) ಒಂದು ಕಣಿವೆಗೆ ಸಿಲುಕಿದ ಕಾರನ್ನು ಹೊಂದಿದೆ:
<img src="../../../../translated_images/mountaincar.43d56e588ce581c2d035f28cf038a9af112bec043b2ef8da40ac86119b1e3a93.kn.png" width="300"/>
ಗುರಿ ಕಾರ್ ಅನ್ನು ಕಣಿವೆಯಿಂದ ಹೊರತೆಗೆದು ಧ್ವಜವನ್ನು ಹಿಡಿಯುವುದು, ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಕೆಳಗಿನ ಕ್ರಿಯೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಮಾಡುವುದು:
| ಮೌಲ್ಯ | ಅರ್ಥ |
|---|---|
| 0 | ಎಡಕ್ಕೆ ವೇಗ ಹೆಚ್ಚಿಸು |
| 1 | ವೇಗ ಹೆಚ್ಚಿಸಬೇಡಿ |
| 2 | ಬಲಕ್ಕೆ ವೇಗ ಹೆಚ್ಚಿಸು |
ಈ ಸಮಸ್ಯೆಯ ಮುಖ್ಯ ತಂತ್ರವೆಂದರೆ, ಕಾರಿನ ಎಂಜಿನ್ ಪರ್ವತವನ್ನು ಒಂದೇ ಬಾರಿ ಏರುವಷ್ಟು ಶಕ್ತಿಶಾಲಿ ಅಲ್ಲ. ಆದ್ದರಿಂದ, ಯಶಸ್ವಿಯಾಗಲು ಏಕಮಾರ್ಗದಲ್ಲಿ ಹೋದರೆ ಆಗುವುದಿಲ್ಲ, ಬದಲಾಗಿ ಹಿಂದಕ್ಕೆ ಮುಂದೆ ಚಲಿಸಿ ವೇಗವನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು.
ನಿರೀಕ್ಷಣಾ ಸ್ಥಳದಲ್ಲಿ ಕೇವಲ ಎರಡು ಮೌಲ್ಯಗಳಿವೆ:
| ಸಂಖ್ಯೆ | ನಿರೀಕ್ಷಣೆ | ಕನಿಷ್ಠ | ಗರಿಷ್ಠ |
|-----|--------------|-----|-----|
| 0 | ಕಾರ್ ಸ್ಥಾನ | -1.2| 0.6 |
| 1 | ಕಾರ್ ವೇಗ | -0.07 | 0.07 |
ಪರ್ವತ ಕಾರ್ ಗೆ ಬಹುಶಃ ಕಷ್ಟಕರವಾದ ಬಹುಮಾನ ವ್ಯವಸ್ಥೆ ಇದೆ:
* ಕಾರ್ ಪರ್ವತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಧ್ವಜವನ್ನು ತಲುಪಿದರೆ (ಸ್ಥಾನ = 0.5) 0 ಬಹುಮಾನ ನೀಡಲಾಗುತ್ತದೆ.
* ಕಾರ್ ಸ್ಥಾನ 0.5 ಕಿಂತ ಕಡಿಮೆ ಇದ್ದರೆ -1 ಬಹುಮಾನ ನೀಡಲಾಗುತ್ತದೆ.
ಕಾರ್ ಸ್ಥಾನ 0.5 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಥವಾ ಎಪಿಸೋಡ್ ಉದ್ದ 200 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಆಗಿದ್ರೆ ಎಪಿಸೋಡ್ ಮುಗಿಯುತ್ತದೆ.
## ಸೂಚನೆಗಳು
ನಮ್ಮ ಬಲವರ್ಧಿತ ಕಲಿಕೆ ಆಲ್ಗಾರಿದಮ್ನ್ನು ಪರ್ವತ ಕಾರ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಹೊಂದಿಸಿ. ಇತ್ತೀಚಿನ [notebook.ipynb](notebook.ipynb) ಕೋಡ್ ನಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಹೊಸ ಪರಿಸರವನ್ನು ಬದಲಿಸಿ, ಸ್ಥಿತಿ ವಿಭಜನೆ ಕಾರ್ಯಗಳನ್ನು ಬದಲಿಸಿ, ಮತ್ತು ಕಡಿಮೆ ಕೋಡ್ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಅಲ್ಗಾರಿದಮ್ನ್ನು ತರಬೇತಿಗೆ ಪ್ರಯತ್ನಿಸಿ. ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿಸಿ ಫಲಿತಾಂಶವನ್ನು ಉತ್ತಮಗೊಳಿಸಿ.
> **ಗಮನಿಸಿ**: ಅಲ್ಗಾರಿದಮ್ನ್ನು ಸಮನ್ವಯಗೊಳಿಸಲು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಹೊಂದಾಣಿಕೆ ಅಗತ್ಯವಾಗಬಹುದು.
## ಮೌಲ್ಯಮಾಪನ
| ಮಾನದಂಡ | ಉದಾಹರಣೀಯ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆ ಅಗತ್ಯವಿದೆ |
| -------- | --------- | -------- | ----------------- |
| | Q-ಲರ್ನಿಂಗ್ ಆಲ್ಗಾರಿದಮ್ನ್ನು CartPole ಉದಾಹರಣೆಯಿಂದ ಯಶಸ್ವಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ, ಕಡಿಮೆ ಕೋಡ್ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ, 200 ಹಂತಗಳೊಳಗೆ ಧ್ವಜ ಹಿಡಿಯುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಾಧ್ಯವಾಗಿದೆ. | ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಹೊಸ Q-ಲರ್ನಿಂಗ್ ಆಲ್ಗಾರಿದಮ್ನ್ನು ಸ್ವೀಕರಿಸಲಾಗಿದೆ, ಆದರೆ ಚೆನ್ನಾಗಿ ದಾಖಲೆ ಮಾಡಲಾಗಿದೆ; ಅಥವಾ ಇತ್ತೀಚಿನ ಆಲ್ಗಾರಿದಮ್ನ್ನು ಸ್ವೀಕರಿಸಲಾಗಿದೆ, ಆದರೆ ಬಯಸಿದ ಫಲಿತಾಂಶಗಳನ್ನು ತಲುಪಲಿಲ್ಲ | ವಿದ್ಯಾರ್ಥಿ ಯಾವುದೇ ಆಲ್ಗಾರಿದಮ್ನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಹೊಂದಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ, ಆದರೆ ಪರಿಹಾರಕ್ಕೆ ಪ್ರಮುಖ ಹಂತಗಳನ್ನು ಕೈಗೊಂಡಿದ್ದಾರೆ (ಸ್ಥಿತಿ ವಿಭಜನೆ, Q-ಟೇಬಲ್ ಡೇಟಾ ರಚನೆ ಇತ್ಯಾದಿ ಅನುಷ್ಠಾನಗೊಳಿಸಲಾಗಿದೆ) |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

400
translations/kn/8-Reinforcement/2-Gym/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

17
translations/kn/8-Reinforcement/2-Gym/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:53:56+00:00",
"source_file": "8-Reinforcement/2-Gym/solution/Julia/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/kn/8-Reinforcement/2-Gym/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T15:54:28+00:00",
"source_file": "8-Reinforcement/2-Gym/solution/R/README.md",
"language_code": "kn"
}
-->
ಇದು ತಾತ್ಕಾಲಿಕ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

532
translations/kn/8-Reinforcement/2-Gym/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

69
translations/kn/8-Reinforcement/README.md
Unescape View File

@ -0,0 +1,69 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "20ca019012b1725de956681d036d8b18",
"translation_date": "2025-12-19T13:09:11+00:00",
"source_file": "8-Reinforcement/README.md",
"language_code": "kn"
}
-->
# ಬಲವರ್ಧಿತ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ
ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ, RL, ಮೇಲ್ವಿಚಾರಿತ ಅಧ್ಯಯನ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಯಿಲ್ಲದ ಅಧ್ಯಯನದ ಪಕ್ಕದಲ್ಲಿ ಮೂಲ ಯಂತ್ರ ಅಧ್ಯಯನ ಪರಿಕಲ್ಪನೆಗಳಲ್ಲಿ ಒಂದಾಗಿ ಪರಿಗಣಿಸಲಾಗಿದೆ. RL ಎಲ್ಲವೂ ನಿರ್ಧಾರಗಳ ಬಗ್ಗೆ: ಸರಿಯಾದ ನಿರ್ಧಾರಗಳನ್ನು ನೀಡುವುದು ಅಥವಾ ಕನಿಷ್ಠ ಅವುಗಳಿಂದ ಕಲಿಯುವುದು.
ನೀವು ಷೇರು ಮಾರುಕಟ್ಟೆಂತಹ ಅನುಕರಿಸಿದ ಪರಿಸರವನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿ. ನೀವು ನೀಡಿದ ನಿಯಮವನ್ನು ಜಾರಿಗೆ ತಂದರೆ ಏನಾಗುತ್ತದೆ? ಅದು ಧನಾತ್ಮಕ ಅಥವಾ ಋಣಾತ್ಮಕ ಪರಿಣಾಮ ಹೊಂದಿದೆಯೇ? ಏನಾದರೂ ಋಣಾತ್ಮಕವಾದುದು ಸಂಭವಿಸಿದರೆ, ನೀವು ಈ _ಋಣಾತ್ಮಕ ಬಲವರ್ಧನೆ_ ತೆಗೆದುಕೊಳ್ಳಬೇಕು, ಅದರಿಂದ ಕಲಿಯಬೇಕು ಮತ್ತು ದಿಕ್ಕು ಬದಲಾಯಿಸಬೇಕು. ಅದು ಧನಾತ್ಮಕ ಫಲಿತಾಂಶವಾದರೆ, ನೀವು ಆ _ಧನಾತ್ಮಕ ಬಲವರ್ಧನೆ_ ಮೇಲೆ ನಿರ್ಮಿಸಬೇಕು.
![peter and the wolf](../../../translated_images/peter.779730f9ba3a8a8d9290600dcf55f2e491c0640c785af7ac0d64f583c49b8864.kn.png)
> ಪೀಟರ್ ಮತ್ತು ಅವನ ಸ್ನೇಹಿತರು ಹಸಿವಿನ ನರಿ ತಪ್ಪಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ! ಚಿತ್ರವನ್ನು [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ನೀಡಿದ್ದಾರೆ
## ಪ್ರಾದೇಶಿಕ ವಿಷಯ: ಪೀಟರ್ ಮತ್ತು ನರಿ (ರಷ್ಯಾ)
[ಪೀಟರ್ ಮತ್ತು ನರಿ](https://en.wikipedia.org/wiki/Peter_and_the_Wolf) ರಷ್ಯಾದ ಸಂಗೀತ ರಚನೆಗಾರ [ಸೆರ್ಗೇ ಪ್ರೊಕೊಫಿಯೆವ್](https://en.wikipedia.org/wiki/Sergei_Prokofiev) ರಚಿಸಿದ ಸಂಗೀತ ಕಥೆ. ಇದು ಯುವ ಪಯನಿಯರ್ ಪೀಟರ್ ಬಗ್ಗೆ ಕಥೆ, ಅವನು ಧೈರ್ಯವಾಗಿ ತನ್ನ ಮನೆಯಿಂದ ಕಾಡಿನ ತೆರೆಯ ಕಡೆಗೆ ಹೋಗಿ ನರಿಯನ್ನು ಹಿಂಬಾಲಿಸುತ್ತಾನೆ. ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಪೀಟರ್‌ಗೆ ಸಹಾಯ ಮಾಡುವ ಯಂತ್ರ ಅಧ್ಯಯನ ಆಲ್ಗಾರಿದಮ್ಗಳನ್ನು ತರಬೇತಿಮಾಡುತ್ತೇವೆ:
- **ಸುತ್ತಲೂ ಇರುವ ಪ್ರದೇಶವನ್ನು ಅನ್ವೇಷಿಸಿ** ಮತ್ತು ಅತ್ಯುತ್ತಮ ನ್ಯಾವಿಗೇಶನ್ ನಕ್ಷೆಯನ್ನು ನಿರ್ಮಿಸಿ
- **ಸ್ಕೇಟ್ಬೋರ್ಡ್ ಬಳಸುವುದು ಮತ್ತು ಅದರಲ್ಲಿ ಸಮತೋಲನ ಸಾಧಿಸುವುದನ್ನು ಕಲಿಯಿರಿ**, ವೇಗವಾಗಿ ಸುತ್ತಾಡಲು.
[![Peter and the Wolf](https://img.youtube.com/vi/Fmi5zHg4QSM/0.jpg)](https://www.youtube.com/watch?v=Fmi5zHg4QSM)
> 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ಪ್ರೊಕೊಫಿಯೆವ್ ಅವರ ಪೀಟರ್ ಮತ್ತು ನರಿ ಕೇಳಿ
## ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ
ಹಿಂದಿನ ವಿಭಾಗಗಳಲ್ಲಿ, ನೀವು ಯಂತ್ರ ಅಧ್ಯಯನ ಸಮಸ್ಯೆಗಳ ಎರಡು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಿದ್ದೀರಿ:
- **ಮೇಲ್ವಿಚಾರಿತ**, ಇಲ್ಲಿ ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಮಾದರಿ ಪರಿಹಾರಗಳನ್ನು ಸೂಚಿಸುವ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. [ವರ್ಗೀಕರಣ](../4-Classification/README.md) ಮತ್ತು [ರಿಗ್ರೆಶನ್](../2-Regression/README.md) ಮೇಲ್ವಿಚಾರಿತ ಅಧ್ಯಯನ ಕಾರ್ಯಗಳಾಗಿವೆ.
- **ಮೇಲ್ವಿಚಾರಣೆಯಿಲ್ಲದ**, ಇಲ್ಲಿ ನಮಗೆ ಲೇಬಲ್ ಮಾಡಲಾದ ತರಬೇತಿ ಡೇಟಾ ಇಲ್ಲ. ಮೇಲ್ವಿಚಾರಣೆಯಿಲ್ಲದ ಅಧ್ಯಯನದ ಮುಖ್ಯ ಉದಾಹರಣೆ [ಗುಚ್ಛೀಕರಣ](../5-Clustering/README.md).
ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಲೇಬಲ್ ಮಾಡಲಾದ ತರಬೇತಿ ಡೇಟಾ ಅಗತ್ಯವಿಲ್ಲದ ಹೊಸ ತರದ ಅಧ್ಯಯನ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಚಯಿಸುವೆವು. ಇಂತಹ ಸಮಸ್ಯೆಗಳ ಹಲವು ವಿಧಗಳಿವೆ:
- **[ಅರ್ಧ-ಮೇಲ್ವಿಚಾರಿತ ಅಧ್ಯಯನ](https://wikipedia.org/wiki/Semi-supervised_learning)**, ಇಲ್ಲಿ ನಮಗೆ ಪೂರ್ವ-ತರಬೇತಿಗಾಗಿ ಬಳಸಬಹುದಾದ ಅನೇಕ ಲೇಬಲ್ ಮಾಡದ ಡೇಟಾ ಇರುತ್ತದೆ.
- **[ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ](https://wikipedia.org/wiki/Reinforcement_learning)**, ಇದರಲ್ಲಿ ಏಜೆಂಟ್ ಕೆಲವು ಅನುಕರಿಸಿದ ಪರಿಸರದಲ್ಲಿ ಪ್ರಯೋಗಗಳನ್ನು ನಡೆಸಿ ಹೇಗೆ ವರ್ತಿಸಬೇಕೆಂದು ಕಲಿಯುತ್ತಾನೆ.
### ಉದಾಹರಣೆ - ಕಂಪ್ಯೂಟರ್ ಆಟ
ನೀವು ಕಂಪ್ಯೂಟರ್‌ಗೆ ಚೆಸ್ ಅಥವಾ [ಸೂಪರ್ ಮಾರಿಯೋ](https://wikipedia.org/wiki/Super_Mario) ಆಟವನ್ನು ಆಡಿಸಲು ಕಲಿಸಲು ಬಯಸಿದರೆ. ಕಂಪ್ಯೂಟರ್ ಆಟ ಆಡಲು, ನಾವು ಪ್ರತಿ ಆಟದ ಸ್ಥಿತಿಯಲ್ಲಿ ಯಾವ ಚಲನೆ ಮಾಡಬೇಕೆಂದು ಊಹಿಸಬೇಕಾಗುತ್ತದೆ. ಇದು ವರ್ಗೀಕರಣ ಸಮಸ್ಯೆಯಂತೆ ತೋರುತ್ತದೆ, ಆದರೆ ಅಲ್ಲ - ಏಕೆಂದರೆ ನಮಗೆ ಸ್ಥಿತಿಗಳು ಮತ್ತು ಸಂಬಂಧಿತ ಕ್ರಿಯೆಗಳ ಡೇಟಾಸೆಟ್ ಇಲ್ಲ. ನಾವು ಕೆಲವು ಡೇಟಾ ಹೊಂದಿದ್ದರೂ, ಉದಾಹರಣೆಗೆ ಇತ್ತೀಚಿನ ಚೆಸ್ ಪಂದ್ಯಗಳು ಅಥವಾ ಸೂಪರ್ ಮಾರಿಯೋ ಆಟಗಾರರ ರೆಕಾರ್ಡಿಂಗ್, ಆ ಡೇಟಾ ಸಾಕಷ್ಟು ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಸಾಧ್ಯ ಸ್ಥಿತಿಗಳನ್ನು ಒಳಗೊಂಡಿರಲಾರದು.
ಇದಕ್ಕೆ ಬದಲಾಗಿ, **ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ** (RL) ಆಲೋಚನೆ ಆಧಾರಿತವಾಗಿದೆ *ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ಅನೇಕ ಬಾರಿ ಆಟ ಆಡಿಸುವುದು ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಗಮನಿಸುವುದು*. ಆದ್ದರಿಂದ, ಬಲವರ್ಧಿತ ಅಧ್ಯಯನವನ್ನು ಅನ್ವಯಿಸಲು, ನಮಗೆ ಎರಡು ವಸ್ತುಗಳು ಬೇಕಾಗಿವೆ:
- **ಒಂದು ಪರಿಸರ** ಮತ್ತು **ಒಂದು ಅನುಕರಣೆ**, ಇದು ನಮಗೆ ಆಟವನ್ನು ಅನೇಕ ಬಾರಿ ಆಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಅನುಕರಣೆ ಎಲ್ಲಾ ಆಟದ ನಿಯಮಗಳು ಮತ್ತು ಸಾಧ್ಯ ಸ್ಥಿತಿಗಳು ಮತ್ತು ಕ್ರಿಯೆಗಳನ್ನೂ ನಿರ್ಧರಿಸುತ್ತದೆ.
- **ಒಂದು ಬಹುಮಾನ ಕಾರ್ಯ**, ಇದು ಪ್ರತಿ ಚಲನೆ ಅಥವಾ ಆಟದ ಸಮಯದಲ್ಲಿ ನಾವು ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಮಾಡಿದ್ದೇವೆ ಎಂದು ಹೇಳುತ್ತದೆ.
ಇತರ ಯಂತ್ರ ಅಧ್ಯಯನ ವಿಧಗಳಿಗಿಂತ RL ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ, RL ನಲ್ಲಿ ನಾವು ಆಟ ಮುಗಿಯುವವರೆಗೆ ನಾವು ಗೆಲುವು ಅಥವಾ ಸೋಲು ತಿಳಿಯುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಚಲನೆ ಒಳ್ಳೆಯದೋ ಇಲ್ಲವೋ ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ - ನಾವು ಆಟದ ಕೊನೆಯಲ್ಲಿ ಮಾತ್ರ ಬಹುಮಾನ ಪಡೆಯುತ್ತೇವೆ. ಮತ್ತು ನಮ್ಮ ಗುರಿ ಅಸ್ಪಷ್ಟ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಲು ಆಲ್ಗಾರಿದಮ್ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು. ನಾವು **Q-ಅಧ್ಯಯನ** ಎಂಬ ಒಂದು RL ಆಲ್ಗಾರಿದಮ್ನ ಬಗ್ಗೆ ಕಲಿಯುತ್ತೇವೆ.
## ಪಾಠಗಳು
1. [ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ ಮತ್ತು Q-ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ](1-QLearning/README.md)
2. [ಜಿಮ್ ಅನುಕರಣೆ ಪರಿಸರವನ್ನು ಬಳಸುವುದು](2-Gym/README.md)
## ಕ್ರೆಡಿಟ್ಸ್
"ಬಲವರ್ಧಿತ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ" ಅನ್ನು ♥️ ಸಹಿತ [ಡ್ಮಿತ್ರಿ ಸೋಶ್ನಿಕೋವ್](http://soshnikov.com) ರಚಿಸಿದ್ದಾರೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

161
translations/kn/9-Real-World/1-Applications/README.md
Unescape View File

@ -0,0 +1,161 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "83320d6b6994909e35d830cebf214039",
"translation_date": "2025-12-19T15:08:34+00:00",
"source_file": "9-Real-World/1-Applications/README.md",
"language_code": "kn"
}
-->
# ಪೋಸ್ಟ್‌ಸ್ಕ್ರಿಪ್ಟ್: ನೈಜ ಜಗತ್ತಿನಲ್ಲಿ ಯಂತ್ರ ಅಧ್ಯಯನ
![ನೈಜ ಜಗತ್ತಿನಲ್ಲಿ ಯಂತ್ರ ಅಧ್ಯಯನದ ಸಾರಾಂಶವನ್ನು ಸ್ಕೆಚ್‌ನೋಟ್‌ನಲ್ಲಿ](../../../../translated_images/ml-realworld.26ee2746716155771f8076598b6145e6533fe4a9e2e465ea745f46648cbf1b84.kn.png)
> ಸ್ಕೆಚ್‌ನೋಟ್: [ಟೊಮೊಮಿ ಇಮುರು](https://www.twitter.com/girlie_mac)
ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ, ನೀವು ತರಬೇತಿಗಾಗಿ ಡೇಟಾವನ್ನು ಸಿದ್ಧಪಡಿಸುವ ಮತ್ತು ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ರಚಿಸುವ ಅನೇಕ ವಿಧಾನಗಳನ್ನು ಕಲಿತಿದ್ದೀರಿ. ನೀವು ಶ್ರೇಣೀಕರಣ, ಗುಂಪುಬದ್ಧತೆ, ವರ್ಗೀಕರಣ, ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ ಮತ್ತು ಕಾಲ ಸರಣಿ ಮಾದರಿಗಳ ಸರಣಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ. ಅಭಿನಂದನೆಗಳು! ಈಗ, ನೀವು ಇದಕ್ಕೆ ಏನು ಉಪಯೋಗವಿದೆ ಎಂದು ಆಶ್ಚರ್ಯಪಡಬಹುದು... ಈ ಮಾದರಿಗಳ ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳು ಯಾವುವು?
ಕಂಪನಿಗಳಲ್ಲಿ ಹೆಚ್ಚಿನ ಆಸಕ್ತಿ ಆಕರ್ಷಿಸಿರುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಡೀಪ್ ಲರ್ನಿಂಗ್ ಬಳಸುವ AI ಆಗಿದ್ದರೂ, ಶ್ರೇಣೀಕರಣ ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳಿಗೆ ಇನ್ನೂ ಮೌಲ್ಯಯುತ ಅನ್ವಯಿಕೆಗಳಿವೆ. ನೀವು ಇವುಗಳಲ್ಲಿ ಕೆಲವು ಅನ್ವಯಿಕೆಗಳನ್ನು ಇಂದೇ ಬಳಸಬಹುದು! ಈ ಪಾಠದಲ್ಲಿ, ಎಂಟು ವಿಭಿನ್ನ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ವಿಷಯ ಕ್ಷೇತ್ರಗಳು ಈ ಮಾದರಿಗಳನ್ನು ತಮ್ಮ ಅನ್ವಯಿಕೆಗಳನ್ನು ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮ, ನಂಬಿಕಯೋಗ್ಯ, ಬುದ್ಧಿವಂತ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಮೌಲ್ಯಯುತವಾಗಿಸಲು ಹೇಗೆ ಬಳಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೀವು ಅನ್ವೇಷಿಸುವಿರಿ.
## [ಪೂರ್ವ-ಪಾಠ ಪರೀಕ್ಷೆ](https://ff-quizzes.netlify.app/en/ml/)
## 💰 ಹಣಕಾಸು
ಹಣಕಾಸು ಕ್ಷೇತ್ರವು ಯಂತ್ರ ಅಧ್ಯಯನಕ್ಕೆ ಅನೇಕ ಅವಕಾಶಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಕ್ಷೇತ್ರದ ಅನೇಕ ಸಮಸ್ಯೆಗಳು ಯಂತ್ರ ಅಧ್ಯಯನ ಬಳಸಿ ಮಾದರೀಕರಿಸಿ ಪರಿಹರಿಸಬಹುದಾಗಿದೆ.
### ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಮೋಸ ಪತ್ತೆ
ನಾವು ಈ ಕೋರ್ಸ್‌ನಲ್ಲಿ ಮೊದಲು [ಕೆ-ಮೀನ್ಸ್ ಗುಂಪುಬದ್ಧತೆ](../../5-Clustering/2-K-Means/README.md) ಬಗ್ಗೆ ಕಲಿತಿದ್ದೇವೆ, ಆದರೆ ಇದನ್ನು ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಮೋಸ ಸಂಬಂಧಿತ ಸಮಸ್ಯೆಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಲು ಬಳಸಬಹುದು?
ಕೆ-ಮೀನ್ಸ್ ಗುಂಪುಬದ್ಧತೆ ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಮೋಸ ಪತ್ತೆ ತಂತ್ರದಲ್ಲಿ **ಔಟ್‌ಲೈಯರ್ ಪತ್ತೆ** ಎಂದು ಕರೆಯಲ್ಪಡುವ ತಂತ್ರದಲ್ಲಿ ಸಹಾಯಕವಾಗುತ್ತದೆ. ಔಟ್‌ಲೈಯರ್‌ಗಳು ಅಥವಾ ಡೇಟಾ ಸೆಟ್‌ನ ವೀಕ್ಷಣೆಗಳಲ್ಲಿ ವ್ಯತ್ಯಾಸಗಳು, ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತಿದೆಯೇ ಅಥವಾ ಏನಾದರೂ ಅಸಾಮಾನ್ಯವಾಗುತ್ತಿದೆಯೇ ಎಂದು ತಿಳಿಸುವುದಕ್ಕೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಕೆಳಗಿನ ಕಾಗದದಲ್ಲಿ ತೋರಿಸಿದಂತೆ, ನೀವು ಕೆ-ಮೀನ್ಸ್ ಗುಂಪುಬದ್ಧತೆ ಆಲ್ಗಾರಿದಮ್ ಬಳಸಿ ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸಿ, ಪ್ರತಿ ವ್ಯವಹಾರವನ್ನು ಅದು ಎಷ್ಟು ಔಟ್‌ಲೈಯರ್ ಆಗಿದೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಗುಂಪಿಗೆ ನಿಯೋಜಿಸಬಹುದು. ನಂತರ, ಮೋಸ ಮತ್ತು ಕಾನೂನುಬದ್ಧ ವ್ಯವಹಾರಗಳಿಗಾಗಿ ಅತಿ ಅಪಾಯಕಾರಿಯಾದ ಗುಂಪುಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಬಹುದು.
[ಉಲ್ಲೇಖ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.680.1195&rep=rep1&type=pdf)
### ಸಂಪತ್ತು ನಿರ್ವಹಣೆ
ಸಂಪತ್ತು ನಿರ್ವಹಣೆಯಲ್ಲಿ, ವ್ಯಕ್ತಿ ಅಥವಾ ಸಂಸ್ಥೆ ತಮ್ಮ ಗ್ರಾಹಕರ ಪರವಾಗಿ ಹೂಡಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಾರೆ. ಅವರ ಕೆಲಸವು ದೀರ್ಘಕಾಲಿಕವಾಗಿ ಸಂಪತ್ತನ್ನು ಉಳಿಸಿ ಬೆಳೆಯಿಸುವುದಾಗಿದೆ, ಆದ್ದರಿಂದ ಉತ್ತಮ ಪ್ರದರ್ಶನ ನೀಡುವ ಹೂಡಿಕೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಅತ್ಯಾವಶ್ಯಕ.
ನಿರ್ದಿಷ್ಟ ಹೂಡಿಕೆಯು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅಂದಾಜಿಸಲು ಒಂದು ವಿಧಾನವು ಸಾಂಖ್ಯಿಕ ಶ್ರೇಣೀಕರಣ. [ರೇಖೀಯ ಶ್ರೇಣೀಕರಣ](../../2-Regression/1-Tools/README.md) ಒಂದು ಉಪಯುಕ್ತ ಸಾಧನವಾಗಿದೆ, ಇದು ನಿಧಿಯು ಕೆಲವು ಮಾನದಂಡದ ಹೋಲಿಕೆಯಲ್ಲಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಾವು ಶ್ರೇಣೀಕರಣದ ಫಲಿತಾಂಶಗಳು ಸಾಂಖ್ಯಿಕವಾಗಿ ಮಹತ್ವಪೂರ್ಣವೋ ಅಥವಾ ಗ್ರಾಹಕರ ಹೂಡಿಕೆಗಳಿಗೆ ಎಷ್ಟು ಪರಿಣಾಮ ಬೀರುತ್ತವೋ ಎಂದು ನಿರ್ಧರಿಸಬಹುದು. ನೀವು ಬಹುಶ್ರೇಣೀಕರಣ ಬಳಸಿ ನಿಮ್ಮ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಇನ್ನಷ್ಟು ವಿಸ್ತರಿಸಬಹುದು, ಅಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಅಪಾಯ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಬಹುದು. ನಿರ್ದಿಷ್ಟ ನಿಧಿಗೆ ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬ ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಕಾಗದವನ್ನು ನೋಡಿ, ಇದು ಶ್ರೇಣೀಕರಣ ಬಳಸಿ ನಿಧಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.
[ಉಲ್ಲೇಖ](http://www.brightwoodventures.com/evaluating-fund-performance-using-regression/)
## 🎓 ಶಿಕ್ಷಣ
ಶಿಕ್ಷಣ ಕ್ಷೇತ್ರವೂ ಯಂತ್ರ ಅಧ್ಯಯನ ಅನ್ವಯಿಸಲು ಬಹಳ ಆಸಕ್ತಿದಾಯಕ ಕ್ಷೇತ್ರವಾಗಿದೆ. ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಅಥವಾ ಪ್ರಬಂಧಗಳಲ್ಲಿ ನಕಲಿ ಪತ್ತೆ ಮಾಡುವುದು ಅಥವಾ ತಿದ್ದುಪಡಿ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಅನೈಚ್ಛಿಕ ಅಥವಾ ಉದ್ದೇಶಿತ ಪಕ್ಷಪಾತವನ್ನು ನಿರ್ವಹಿಸುವಂತಹ ಸಮಸ್ಯೆಗಳು ಇವೆ.
### ವಿದ್ಯಾರ್ಥಿ ವರ್ತನೆ ಭವಿಷ್ಯವಾಣಿ
[ಕೋರ್ಸೆರಾ](https://coursera.com), ಒಂದು ಆನ್‌ಲೈನ್ ಮುಕ್ತ ಕೋರ್ಸ್ ಪೂರೈಕೆದಾರ, ತಮ್ಮ ತಂತ್ರಜ್ಞಾನ ಬ್ಲಾಗ್‌ನಲ್ಲಿ ಅನೇಕ ಎಂಜಿನಿಯರಿಂಗ್ ನಿರ್ಧಾರಗಳನ್ನು ಚರ್ಚಿಸುತ್ತಾರೆ. ಈ ಪ್ರಕರಣ ಅಧ್ಯಯನದಲ್ಲಿ, ಅವರು ಕಡಿಮೆ NPS (ನೆಟ್ ಪ್ರೊಮೋಟರ್ ಸ್ಕೋರ್) ರೇಟಿಂಗ್ ಮತ್ತು ಕೋರ್ಸ್ ಉಳಿಸುವಿಕೆ ಅಥವಾ ಬಿಟ್ಟುಹೋಗುವಿಕೆಗೆ ಯಾವುದೇ ಸಂಬಂಧವಿದೆಯೇ ಎಂದು ಅನ್ವೇಷಿಸಲು ಶ್ರೇಣೀಕರಣ ರೇಖೆಯನ್ನು ಚಿತ್ರಿಸಿದ್ದಾರೆ.
[ಉಲ್ಲೇಖ](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a)
### ಪಕ್ಷಪಾತ ಕಡಿಮೆ ಮಾಡುವುದು
[ಗ್ರಾಮ್ಮರ್ಲಿ](https://grammarly.com), ಒಂದು ಬರವಣಿಗೆ ಸಹಾಯಕ, ತನ್ನ ಉತ್ಪನ್ನಗಳಲ್ಲಿ ಸುಧಾರಿತ [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ ವ್ಯವಸ್ಥೆಗಳನ್ನು](../../6-NLP/README.md) ಬಳಸುತ್ತದೆ. ಅವರು ತಮ್ಮ ತಂತ್ರಜ್ಞಾನ ಬ್ಲಾಗ್‌ನಲ್ಲಿ ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ಲಿಂಗ ಪಕ್ಷಪಾತವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಿದರೋ ಎಂಬುದರ ಬಗ್ಗೆ ಆಸಕ್ತಿದಾಯಕ ಪ್ರಕರಣ ಅಧ್ಯಯನವನ್ನು ಪ್ರಕಟಿಸಿದ್ದಾರೆ, ಇದು ನಮ್ಮ [ಪರಿಚಯಾತ್ಮಕ ನ್ಯಾಯತೆಯ ಪಾಠದಲ್ಲಿ](../../1-Introduction/3-fairness/README.md) ನೀವು ಕಲಿತಿದ್ದೀರಿ.
[ಉಲ್ಲೇಖ](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/)
## 👜 ಚಿಲ್ಲರೆ ವ್ಯಾಪಾರ
ಚಿಲ್ಲರೆ ವ್ಯಾಪಾರ ಕ್ಷೇತ್ರವು ಯಂತ್ರ ಅಧ್ಯಯನದಿಂದ ಬಹುಮಾನ ಪಡೆಯಬಹುದು, ಉತ್ತಮ ಗ್ರಾಹಕ ಪ್ರಯಾಣವನ್ನು ರಚಿಸುವುದರಿಂದ ಹಿಡಿದು ಸರಕಿನ ಸಂಗ್ರಹಣೆಯನ್ನು ಸೂಕ್ತ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸುವವರೆಗೆ.
### ಗ್ರಾಹಕ ಪ್ರಯಾಣ ವೈಯಕ್ತೀಕರಣ
ವೇಫೇರ್‌ನಲ್ಲಿ, ಮನೆ ಸಾಮಗ್ರಿಗಳನ್ನು ಮಾರುವ ಕಂಪನಿಯಲ್ಲಿ, ಗ್ರಾಹಕರಿಗೆ ಅವರ ರುಚಿ ಮತ್ತು ಅಗತ್ಯಗಳಿಗೆ ತಕ್ಕ ಸರಿಯಾದ ಉತ್ಪನ್ನಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುವುದು ಅತ್ಯಂತ ಮುಖ್ಯ. ಈ ಲೇಖನದಲ್ಲಿ, ಕಂಪನಿಯ ಎಂಜಿನಿಯರ್‌ಗಳು ಯಂತ್ರ ಅಧ್ಯಯನ ಮತ್ತು NLP ಅನ್ನು "ಗ್ರಾಹಕರಿಗೆ ಸರಿಯಾದ ಫಲಿತಾಂಶಗಳನ್ನು ತಲುಪಿಸಲು" ಹೇಗೆ ಬಳಸುತ್ತಾರೆ ಎಂದು ವಿವರಿಸಿದ್ದಾರೆ. ವಿಶೇಷವಾಗಿ, ಅವರ ಕ್ವೇರಿ ಇಂಟೆಂಟ್ ಎಂಜಿನ್ ಎಂಟಿಟಿ ಎಕ್ಸ್ಟ್ರಾಕ್ಷನ್, ವರ್ಗೀಕರಣ ತರಬೇತಿ, ಆಸ್ತಿ ಮತ್ತು ಅಭಿಪ್ರಾಯ ಎಕ್ಸ್ಟ್ರಾಕ್ಷನ್, ಮತ್ತು ಗ್ರಾಹಕ ವಿಮರ್ಶೆಗಳಲ್ಲಿ ಭಾವನೆ ಟ್ಯಾಗಿಂಗ್ ಅನ್ನು ಬಳಸುವಂತೆ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಇದು ಆನ್‌ಲೈನ್ ಚಿಲ್ಲರೆ ವ್ಯಾಪಾರದಲ್ಲಿ NLP ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬ ಕ್ಲಾಸಿಕ್ ಉದಾಹರಣೆ.
[ಉಲ್ಲೇಖ](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search)
### ಸರಕಿನ ನಿರ್ವಹಣೆ
[ಸ್ಟಿಚ್ಫಿಕ್ಸ್](https://stitchfix.com) ಎಂಬ, ಗ್ರಾಹಕರಿಗೆ ಬಟ್ಟೆಗಳನ್ನು ಕಳುಹಿಸುವ ಬಾಕ್ಸ್ ಸೇವೆ, ಶಿಫಾರಸುಗಳು ಮತ್ತು ಸರಕಿನ ನಿರ್ವಹಣೆಗೆ ಯಂತ್ರ ಅಧ್ಯಯನವನ್ನು ಬಹಳಷ್ಟು ಅವಲಂಬಿಸಿದೆ. ಅವರ ಶೈಲಿಯ ತಂಡಗಳು ಮಾರಾಟ ತಂಡಗಳೊಂದಿಗೆ ಸಹಕರಿಸುತ್ತವೆ: "ನಮ್ಮ ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳಲ್ಲಿ ಒಬ್ಬರು ಜನ್ಯ ಆಲ್ಗಾರಿದಮ್‌ನೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಿ, ಇಂದಿನ ದಿನದಲ್ಲಿ ಇಲ್ಲದ ಯಶಸ್ವಿ ಬಟ್ಟೆಯನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಅದನ್ನು ಬಟ್ಟೆಗಳಿಗೆ ಅನ್ವಯಿಸಿದರು. ನಾವು ಅದನ್ನು ಮಾರಾಟ ತಂಡಕ್ಕೆ ತಂದುಕೊಟ್ಟಿದ್ದೇವೆ ಮತ್ತು ಈಗ ಅವರು ಅದನ್ನು ಉಪಕರಣವಾಗಿ ಬಳಸಬಹುದು."
[ಉಲ್ಲೇಖ](https://www.zdnet.com/article/how-stitch-fix-uses-machine-learning-to-master-the-science-of-styling/)
## 🏥 ಆರೋಗ್ಯ ಸೇವೆ
ಆರೋಗ್ಯ ಸೇವೆ ಕ್ಷೇತ್ರವು ಸಂಶೋಧನಾ ಕಾರ್ಯಗಳನ್ನು ಮತ್ತು ರೋಗಿಗಳನ್ನು ಮರುಪ್ರವೇಶಿಸುವಂತಹ ಲಾಜಿಸ್ಟಿಕ್ ಸಮಸ್ಯೆಗಳನ್ನು ಸುಧಾರಿಸಲು ಯಂತ್ರ ಅಧ್ಯಯನವನ್ನು ಬಳಸಬಹುದು.
### ಕ್ಲಿನಿಕಲ್ ಟ್ರಯಲ್‌ಗಳ ನಿರ್ವಹಣೆ
ಕ್ಲಿನಿಕಲ್ ಟ್ರಯಲ್‌ಗಳಲ್ಲಿ ವಿಷಕಾರಕತೆ ಔಷಧಿ ತಯಾರಕರಿಗೆ ಪ್ರಮುಖ ಚಿಂತೆ. ಎಷ್ಟು ವಿಷಕಾರಕತೆ ಸಹಿಸಬಹುದೆ? ಈ ಅಧ್ಯಯನದಲ್ಲಿ, ವಿವಿಧ ಕ್ಲಿನಿಕಲ್ ಟ್ರಯಲ್ ವಿಧಾನಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ಕ್ಲಿನಿಕಲ್ ಟ್ರಯಲ್ ಫಲಿತಾಂಶಗಳ ಸಾಧ್ಯತೆಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಹೊಸ ವಿಧಾನವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ. ವಿಶೇಷವಾಗಿ, ಅವರು ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್ ಬಳಸಿ [ವರ್ಗೀಕರಣ](../../4-Classification/README.md) ಮಾಡಬಹುದಾದ ಮಾದರಿಯನ್ನು ರಚಿಸಿದ್ದಾರೆ, ಇದು ಔಷಧಿ ಗುಂಪುಗಳನ್ನು ವಿಭಜಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
[ಉಲ್ಲೇಖ](https://www.sciencedirect.com/science/article/pii/S2451945616302914)
### ಆಸ್ಪತ್ರೆ ಮರುಪ್ರವೇಶ ನಿರ್ವಹಣೆ
ಆಸ್ಪತ್ರೆ ಸೇವೆ ದುಬಾರಿ, ವಿಶೇಷವಾಗಿ ರೋಗಿಗಳನ್ನು ಮರುಪ್ರವೇಶಿಸಬೇಕಾದಾಗ. ಈ ಕಾಗದವು ಯಂತ್ರ ಅಧ್ಯಯನ ಬಳಸಿ ಮರುಪ್ರವೇಶ ಸಾಧ್ಯತೆಯನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವ ಕಂಪನಿಯ ಬಗ್ಗೆ ಚರ್ಚಿಸುತ್ತದೆ, [ಗುಂಪುಬದ್ಧತೆ](../../5-Clustering/README.md) ಆಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು. ಈ ಗುಂಪುಗಳು ವಿಶ್ಲೇಷಕರಿಗೆ "ಸಾಮಾನ್ಯ ಕಾರಣವನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದಾದ ಮರುಪ್ರವೇಶ ಗುಂಪುಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು" ಸಹಾಯ ಮಾಡುತ್ತವೆ.
[ಉಲ್ಲೇಖ](https://healthmanagement.org/c/healthmanagement/issuearticle/hospital-readmissions-and-machine-learning)
### ರೋಗ ನಿರ್ವಹಣೆ
ಇತ್ತೀಚಿನ ಮಹಾಮಾರಿ ಯಂತ್ರ ಅಧ್ಯಯನವು ರೋಗ ಹರಡುವಿಕೆಯನ್ನು ತಡೆಯಲು ಹೇಗೆ ಸಹಾಯ ಮಾಡಬಹುದು ಎಂಬುದರ ಮೇಲೆ ಬೆಳಕು ಚೆಲ್ಲಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ನೀವು ARIMA, ಲಾಜಿಸ್ಟಿಕ್ ವಕ್ರಗಳು, ರೇಖೀಯ ಶ್ರೇಣೀಕರಣ ಮತ್ತು SARIMA ಬಳಕೆಯನ್ನು ಗುರುತಿಸಬಹುದು. "ಈ ಕೆಲಸವು ಈ ವೈರಸ್ ಹರಡುವಿಕೆಯನ್ನು ಲೆಕ್ಕಹಾಕಲು ಮತ್ತು ಹೀಗಾಗಿ ಸಾವುಗಳು, ಗುಣಮುಖತೆಗಳು ಮತ್ತು ದೃಢೀಕೃತ ಪ್ರಕರಣಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಪ್ರಯತ್ನವಾಗಿದೆ, ಇದರಿಂದ ನಾವು ಉತ್ತಮವಾಗಿ ಸಿದ್ಧರಾಗಲು ಮತ್ತು ಬದುಕಲು ಸಹಾಯವಾಗುತ್ತದೆ."
[ಉಲ್ಲೇಖ](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7979218/)
## 🌲 ಪರಿಸರ ಮತ್ತು ಹಸಿರು ತಂತ್ರಜ್ಞಾನ
ಪ್ರಕೃತಿ ಮತ್ತು ಪರಿಸರವು ಅನೇಕ ಸಂವೇದನಾಶೀಲ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಒಳಗೊಂಡಿವೆ, ಅಲ್ಲಿ ಪ್ರಾಣಿಗಳು ಮತ್ತು ಪ್ರಕೃತಿಯ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆ ಮುಖ್ಯವಾಗುತ್ತದೆ. ಈ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿಖರವಾಗಿ ಅಳೆಯುವುದು ಮತ್ತು ಏನಾದರೂ ಸಂಭವಿಸಿದರೆ, ಉದಾಹರಣೆಗೆ ಕಾಡು ಬೆಂಕಿ ಅಥವಾ ಪ್ರಾಣಿ ಜನಸಂಖ್ಯೆಯ ಕುಸಿತ, ಸೂಕ್ತವಾಗಿ ಕ್ರಮ ಕೈಗೊಳ್ಳುವುದು ಮುಖ್ಯ.
### ಕಾಡು ನಿರ್ವಹಣೆ
ನೀವು ಹಿಂದಿನ ಪಾಠಗಳಲ್ಲಿ [ರೀಇನ್ಫೋರ್ಸ್ಮೆಂಟ್ ಲರ್ನಿಂಗ್](../../8-Reinforcement/README.md) ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ. ಇದು ಪ್ರಕೃತಿಯಲ್ಲಿ ಮಾದರಿಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಹಳ ಉಪಯುಕ್ತವಾಗಬಹುದು. ವಿಶೇಷವಾಗಿ, ಇದು ಕಾಡು ಬೆಂಕಿ ಮತ್ತು ಆಕ್ರಮಣಕಾರಿ ಪ್ರಭೇದಗಳ ಹರಡುವಿಕೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಳಸಬಹುದು. ಕೆನಡಾದಲ್ಲಿ, ಸಂಶೋಧಕರ ಗುಂಪು ರೀಇನ್ಫೋರ್ಸ್ಮೆಂಟ್ ಲರ್ನಿಂಗ್ ಬಳಸಿ ಉಪಗ್ರಹ ಚಿತ್ರಗಳಿಂದ ಕಾಡು ಬೆಂಕಿ ಗತಿಶೀಲತೆ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಿದ್ದಾರೆ. "ಸ್ಥಳೀಯವಾಗಿ ಹರಡುವ ಪ್ರಕ್ರಿಯೆ (SSP)" ಎಂಬ ನವೀನ ವಿಧಾನವನ್ನು ಬಳಸಿ, ಅವರು ಕಾಡು ಬೆಂಕಿಯನ್ನು "ಭೂದೃಶ್ಯದಲ್ಲಿ ಯಾವುದೇ ಸೆಲ್‌ನಲ್ಲಿ ಏಜೆಂಟ್" ಎಂದು ಕಲ್ಪಿಸಿದ್ದಾರೆ. "ಬೆಂಕಿ ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಉತ್ತರ, ದಕ್ಷಿಣ, ಪೂರ್ವ ಅಥವಾ ಪಶ್ಚಿಮಕ್ಕೆ ಹರಡಬಹುದು ಅಥವಾ ಹರಡದಿರಬಹುದು."
ಈ ವಿಧಾನವು ಸಾಮಾನ್ಯ RL ವ್ಯವಸ್ಥೆಯನ್ನು ತಿರುಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಸಂಬಂಧಿತ ಮಾರ್ಕೋವ್ ನಿರ್ಧಾರ ಪ್ರಕ್ರಿಯೆಯ (MDP) ಗತಿಶೀಲತೆ ತಕ್ಷಣದ ಕಾಡು ಬೆಂಕಿ ಹರಡುವಿಕೆಗೆ ತಿಳಿದಿರುವ ಕಾರ್ಯವಾಗಿದೆ." ಈ ಗುಂಪು ಬಳಸಿದ ಕ್ಲಾಸಿಕ್ ಆಲ್ಗಾರಿದಮ್‌ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ಕೆಳಗಿನ ಲಿಂಕ್ ನೋಡಿ.
[ಉಲ್ಲೇಖ](https://www.frontiersin.org/articles/10.3389/fict.2018.00006/full)
### ಪ್ರಾಣಿಗಳ ಚಲನೆ ಸಂವೇದನೆ
ಡೀಪ್ ಲರ್ನಿಂಗ್ ಪ್ರಾಣಿಗಳ ಚಲನೆಗಳನ್ನು ದೃಶ್ಯವಾಗಿ ಟ್ರ್ಯಾಕ್ ಮಾಡುವಲ್ಲಿ ಕ್ರಾಂತಿ ತಂದಿದ್ದರೂ (ನೀವು ನಿಮ್ಮದೇ [ಪೋಲರ್ ಬೆರ್ ಟ್ರ್ಯಾಕರ್](https://docs.microsoft.com/learn/modules/build-ml-model-with-azure-stream-analytics/?WT.mc_id=academic-77952-leestott) ಅನ್ನು ಇಲ್ಲಿ ನಿರ್ಮಿಸಬಹುದು), ಕ್ಲಾಸಿಕ್ ಯಂತ್ರ ಅಧ್ಯಯನ ಈ ಕಾರ್ಯದಲ್ಲಿ ಇನ್ನೂ ಸ್ಥಾನ ಹೊಂದಿದೆ.
ಕೃಷಿ ಪ್ರಾಣಿಗಳ ಚಲನೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಸೆನ್ಸಾರ್‌ಗಳು ಮತ್ತು IoT ಈ ರೀತಿಯ ದೃಶ್ಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸುತ್ತವೆ, ಆದರೆ ಮೂಲಭೂತ ಯಂತ್ರ ಅಧ್ಯಯನ ತಂತ್ರಗಳು ಡೇಟಾ ಪೂರ್ವಸಿದ್ಧತೆಗೆ ಉಪಯುಕ್ತವಾಗಿವೆ. ಉದಾಹರಣೆಗೆ, ಈ ಕಾಗದದಲ್ಲಿ ಕುರಿಗಳ ಸ್ಥಿತಿಗಳನ್ನು ವಿವಿಧ ವರ್ಗೀಕರಣ ಆಲ್ಗಾರಿದಮ್‌ಗಳ ಬಳಕೆಯಿಂದ ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆ ಮಾಡಲಾಗಿದೆ. ನೀವು ಪುಟ 335 ರಲ್ಲಿ ROC ವಕ್ರವನ್ನು ಗುರುತಿಸಬಹುದು.
[ಉಲ್ಲೇಖ](https://druckhaus-hofmann.de/gallery/31-wj-feb-2020.pdf)
### ⚡️ ಶಕ್ತಿ ನಿರ್ವಹಣೆ
ನಮ್ಮ [ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ](../../7-TimeSeries/README.md) ಪಾಠಗಳಲ್ಲಿ, ನಾವು ಸರಬರಾಜು ಮತ್ತು ಬೇಡಿಕೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಪಟ್ಟಣಕ್ಕೆ ಆದಾಯ ತರುವ ಸ್ಮಾರ್ಟ್ ಪಾರ್ಕಿಂಗ್ ಮೀಟರ್‌ಗಳ ಕಲ್ಪನೆಯನ್ನು ಉಲ್ಲೇಖಿಸಿದ್ದೇವೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಐರ್ಲೆಂಡ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಮೀಟರಿಂಗ್ ಆಧಾರಿತ ಭವಿಷ್ಯದ ಶಕ್ತಿ ಬಳಕೆಯನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಗುಂಪುಬದ್ಧತೆ, ಶ್ರೇಣೀಕರಣ ಮತ್ತು ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ ಹೇಗೆ ಸಂಯೋಜಿತವಾಗಿವೆ ಎಂಬುದನ್ನು ವಿವರಿಸಲಾಗಿದೆ.
[ಉಲ್ಲೇಖ](https://www-cdn.knime.com/sites/default/files/inline-images/knime_bigdata_energy_timeseries_whitepaper.pdf)
## 💼 ವಿಮೆ
ವಿಮೆ ಕ್ಷೇತ್ರವು ಸಹ ಯಂತ್ರ ಅಧ್ಯಯನವನ್ನು ಬಳಸಿಕೊಂಡು ಆರ್ಥಿಕ ಮತ್ತು ಅಕ್ಟ್ಯೂರಿಯಲ್ ಮಾದರಿಗಳನ್ನು ರಚಿಸಿ ಸುಧಾರಿಸುತ್ತದೆ.
### ಅಸ್ಥಿರತೆ ನಿರ್ವಹಣೆ
ಮೆಟ್‌ಲೈಫ್, ಒಂದು ಜೀವ ವಿಮೆ ಪೂರೈಕೆದಾರ, ತಮ್ಮ ಆರ್ಥಿಕ ಮಾದರಿಗಳಲ್ಲಿನ ಅಸ್ಥಿರತೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಕಡಿಮೆ ಮಾಡುವ ವಿಧಾನವನ್ನು ಮುಕ್ತವಾಗಿ ಹಂಚಿಕೊಳ್ಳುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ ನೀವು ದ್ವಿಮೂಲಕ ಮತ್ತು ಕ್ರಮಬದ್ಧ ವರ್ಗೀಕರಣದ ದೃಶ್ಯೀಕರಣಗಳನ್ನು ಗಮನಿಸಬಹುದು. ನೀವು ಭವಿಷ್ಯವಾಣಿ ದೃಶ್ಯೀಕರಣಗಳನ್ನು ಕೂಡ ಕಂಡುಹಿಡಿಯುತ್ತೀರಿ.
[ಉಲ್ಲೇಖ](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf)
## 🎨 ಕಲೆ, ಸಂಸ್ಕೃತಿ ಮತ್ತು ಸಾಹಿತ್ಯ
ಕಲೆಯಲ್ಲಿಯೂ, ಉದಾಹರಣೆಗೆ ಪತ್ರಿಕೋದ್ಯಮದಲ್ಲಿ, ಅನೇಕ ಆಸಕ್ತಿದಾಯಕ ಸಮಸ್ಯೆಗಳಿವೆ. ನಕಲಿ ಸುದ್ದಿಯನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ದೊಡ್ಡ ಸಮಸ್ಯೆ, ಏಕೆಂದರೆ ಇದು ಜನರ ಅಭಿಪ್ರಾಯವನ್ನು ಪ್ರಭಾವಿತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರಜಾಪ್ರಭುತ್ವಗಳನ್ನು ಕುಸಿತಗೊಳಿಸಬಹುದು. ಸಂಗ್ರಹಾಲಯಗಳು ಕೂಡ ವಸ್ತುಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದರಿಂದ ಸಂಪನ್ಮೂಲ ಯೋಜನೆಗೆ ಯಂತ್ರ ಅಧ್ಯಯನದಿಂದ ಲಾಭ ಪಡೆಯಬಹುದು.
### ನಕಲಿ ಸುದ್ದಿ ಪತ್ತೆ
ಇಂದಿನ ಮಾಧ್ಯಮದಲ್ಲಿ ನಕಲಿ ಸುದ್ದಿಯನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ಬೆಕ್ಕು ಮತ್ತು ಇಲಿ ಆಟವಾಗಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಸಂಶೋಧಕರು ನಾವು ಕಲಿತ ಯಂತ್ರ ಅಧ್ಯಯನ ತಂತ್ರಗಳನ್ನು ಸಂಯೋಜಿಸಿ ಪರೀಕ್ಷಿಸಿ ಉತ್ತಮ ಮಾದರಿಯನ್ನು ನಿಯೋಜಿಸಬಹುದು ಎಂದು ಸೂಚಿಸಿದ್ದಾರೆ: "ಈ ವ್ಯವಸ್ಥೆ ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ ಆಧಾರಿತವಾಗಿದ್ದು, ಡೇಟಾದಿಂದ ಲಕ್ಷಣಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ನಂತರ ಈ ಲಕ್ಷಣಗಳನ್ನು ನೈವ್ ಬೇಯ್ಸ್, ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ಮಷೀನ್ (SVM), ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್ (RF), ಸ್ಟೋಚಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ (SGD), ಮತ್ತು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಷನ್ (LR) ಮುಂತಾದ ಯಂತ್ರ ಅಧ್ಯಯನ ವರ್ಗೀಕರಣಗಳ ತರಬೇತಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ."
[ಉಲ್ಲೇಖ](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf)
ಈ ಲೇಖನವು ವಿಭಿನ್ನ ಯಂತ್ರ ಅಧ್ಯಯನ ಕ್ಷೇತ್ರಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ನಕಲಿ ಸುದ್ದಿಯ ಹರಡುವಿಕೆಯನ್ನು ತಡೆಯಲು ಮತ್ತು ನಿಜವಾದ ಹಾನಿಯನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುವ ಆಸಕ್ತಿದಾಯಕ ಫಲಿತಾಂಶಗಳನ್ನು ತರುತ್ತದೆ; ಈ ಸಂದರ್ಭದಲ್ಲಿ, COVID ಚಿಕಿತ್ಸೆಗಳ ಬಗ್ಗೆ ಹರಡುವ ಗಾಸಿಪ್‌ಗಳು ಹಿಂಸಾಚಾರಕ್ಕೆ ಪ್ರೇರಣೆ ನೀಡಿದವು.
### ಸಂಗ್ರಹಾಲಯ ಯಂತ್ರ ಅಧ್ಯಯನ
ಸಂಗ್ರಹಾಲಯಗಳು AI ಕ್ರಾಂತಿಯ ಮುಂಭಾಗದಲ್ಲಿವೆ, ಅಲ್ಲಿ ಸಂಗ್ರಹಗಳನ್ನು ವರ್ಗೀಕರಿಸುವುದು ಮತ್ತು ಡಿಜಿಟೈಸ್ ಮಾಡುವುದರಿಂದ ವಸ್ತುಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ತಂತ್ರಜ್ಞಾನ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ ಸುಲಭವಾಗುತ್ತಿದೆ. [ಇನ್ ಕೋಡಿಸೆ ರೇಷಿಯೋ](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) ಮುಂತಾದ ಯೋಜನೆಗಳು ವಾಟಿಕನ್ ಆರ್ಕೈವ್ಸ್ ಮುಂತಾದ ಅಪ್ರಾಪ್ಯ ಸಂಗ್ರಹಗಳ ರಹಸ್ಯಗಳನ್ನು ಅನಾವರಣಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತಿವೆ. ಆದರೆ, ಸಂಗ್ರಹಾಲಯಗಳ ವ್ಯಾಪಾರ ಭಾಗವೂ ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳಿಂದ ಲಾಭ ಪಡೆಯುತ್ತಿದೆ.
ಉದಾಹರಣೆಗೆ, ಚಿಕಾಗೋ ಆರ್ಟ್ ಇನ್ಸ್ಟಿಟ್ಯೂಟ್ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಿ ಪ್ರೇಕ್ಷಕರ ಆಸಕ್ತಿಯನ್ನು ಮತ್ತು ಅವರು ಪ್ರದರ್ಶನಗಳಿಗೆ ಯಾವಾಗ ಹಾಜರಾಗುತ್ತಾರೆ ಎಂಬುದನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡುತ್ತದೆ. ಗುರಿಯು ಪ್ರತಿ ಬಾರಿ ಬಳಕೆದಾರರು ಸಂಗ್ರಹಾಲಯಕ್ಕೆ ಭೇಟಿ ನೀಡುವಾಗ ವೈಯಕ್ತಿಕ ಮತ್ತು ಸುಧಾರಿತ ಭೇಟಿ ಅನುಭವಗಳನ್ನು ಸೃಷ್ಟಿಸುವುದು. "2017 ಹಣಕಾಸು ವರ್ಷದಲ್ಲಿ, ಮಾದರಿ ಹಾಜರಾತಿ ಮತ್ತು ಪ್ರವೇಶಗಳನ್ನು 1 ಶೇಕಡಾ ನಿಖರತೆಯೊಳಗೆ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿತು ಎಂದು ಆಂಡ್ರ್ಯೂ ಸಿಮ್ನಿಕ್, ಚಿಕಾಗೋ ಆರ್ಟ್ ಇನ್ಸ್ಟಿಟ್ಯೂಟ್‌ನ ಹಿರಿಯ ಉಪಾಧ್ಯಕ್ಷರು ಹೇಳಿದ್ದಾರೆ."
[ಉಲ್ಲೇಖ](https://www.chicagobusiness.com/article/20180518/ISSUE01/180519840/art-institute-of-chicago-uses-data-to-make-exhibit-choices)
## 🏷 ಮಾರುಕಟ್ಟೆ
### ಗ್ರಾಹಕ ವಿಭಾಗೀಕರಣ
ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಮಾರುಕಟ್ಟೆ ತಂತ್ರಗಳು ವಿವಿಧ ಗುಂಪುಗಳ ಆಧಾರದ ಮೇಲೆ ಗ್ರಾಹಕರನ್ನು ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ಗುರಿಯಾಗಿಸುತ್ತವೆ. ಈ ಲೇಖನದಲ್ಲಿ, ವಿಭಜಿತ ಮಾರುಕಟ್ಟೆಗೆ ಬೆಂಬಲ ನೀಡಲು ಗುಂಪುಬದ್ಧತೆ ಆಲ್ಗಾರಿದಮ್‌ಗಳ ಬಳಕೆಯನ್ನು ಚರ್ಚಿಸಲಾಗಿದೆ. ವಿಭಜಿತ ಮಾರುಕಟ್ಟೆ ಕಂಪನಿಗಳಿಗೆ ಬ್ರ್ಯಾಂಡ್ ಗುರುತನ್ನು ಸುಧಾರಿಸಲು, ಹೆಚ್ಚು ಗ್ರಾಹಕರಿಗೆ ತಲುಪಲು ಮತ್ತು ಹೆಚ್ಚು ಹಣ ಗಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
[ಉಲ್ಲೇಖ](https://ai.inqline.com/machine-learning-for-marketing-customer-segmentation/)
## 🚀 ಸವಾಲು
ನೀವು ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ಕಲಿತ ಕೆಲವು ತಂತ್ರಗಳನ್ನು ಉಪಯೋಗಿಸುವ ಮತ್ತೊಂದು ಕ್ಷೇತ್ರವನ್ನು ಗುರುತಿಸಿ, ಅದು ಯಂತ್ರ ಅಧ್ಯಯನವನ್ನು ಹೇಗೆ ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ.
## [ಪೋಸ್ಟ್-ಲೆಕ್ಚರ್ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ವೇಫೇರ್ ಡೇಟಾ ಸೈನ್ಸ್ ತಂಡವು ತಮ್ಮ ಕಂಪನಿಯಲ್ಲಿ ಎಂಎಲ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುತ್ತಾರೆ ಎಂಬುದರ ಬಗ್ಗೆ ಹಲವಾರು ಆಸಕ್ತಿದಾಯಕ ವೀಡಿಯೊಗಳನ್ನು ಹೊಂದಿದೆ. ಅದನ್ನು [ನೋಡುವುದು](https://www.youtube.com/channel/UCe2PjkQXqOuwkW1gw6Ameuw/videos) ಮೌಲ್ಯವಿದೆ!
## ನಿಯೋಜನೆ
[ಎಂಎಲ್ ಸ್ಕ್ಯಾವೆಂಜರ್ ಹಂಟ್](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

29
translations/kn/9-Real-World/1-Applications/assignment.md
Unescape View File

@ -0,0 +1,29 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fdebfcd0a3f12c9e2b436ded1aa79885",
"translation_date": "2025-12-19T15:10:43+00:00",
"source_file": "9-Real-World/1-Applications/assignment.md",
"language_code": "kn"
}
-->
# ಎಂಎಲ್ ಸ್ಕ್ಯಾವೆಂಜರ್ ಹಂಟ್
## ಸೂಚನೆಗಳು
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಕ್ಲಾಸಿಕಲ್ ಎಂಎಲ್ ಬಳಸಿ ಪರಿಹರಿಸಲಾದ ಅನೇಕ ನೈಜ ಜೀವನದ ಬಳಕೆ ಪ್ರಕರಣಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ. ಆಳವಾದ ಕಲಿಕೆ, ಎಐಯಲ್ಲಿ ಹೊಸ ತಂತ್ರಗಳು ಮತ್ತು ಸಾಧನಗಳ ಬಳಕೆ, ಮತ್ತು ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ಉಪಯೋಗಿಸುವುದರಿಂದ ಈ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಸಹಾಯ ಮಾಡುವ ಸಾಧನಗಳ ಉತ್ಪಾದನೆ ವೇಗವಾಗಿ ನಡೆಯುತ್ತಿದೆ, ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿನ ತಂತ್ರಗಳನ್ನು ಬಳಸುವ ಕ್ಲಾಸಿಕ್ ಎಂಎಲ್ ಇನ್ನೂ ಮಹತ್ವವನ್ನು ಹೊಂದಿದೆ.
ಈ ನಿಯೋಜನೆಯಲ್ಲಿ, ನೀವು ಹ್ಯಾಕಾಥಾನ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿ. ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ಕಲಿತದ್ದನ್ನು ಬಳಸಿ ಕ್ಲಾಸಿಕ್ ಎಂಎಲ್ ಉಪಯೋಗಿಸಿ ಈ ಪಾಠದಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪರಿಹಾರವನ್ನು ಪ್ರಸ್ತಾಪಿಸಿ. ನಿಮ್ಮ ಆಲೋಚನೆಯನ್ನು ಹೇಗೆ ಅನುಷ್ಠಾನಗೊಳಿಸುವಿರಿ ಎಂಬುದನ್ನು ಚರ್ಚಿಸುವ ಪ್ರಸ್ತುತಿಯನ್ನು ರಚಿಸಿ. ನಿಮ್ಮ ಕಲ್ಪನೆಯನ್ನು ಬೆಂಬಲಿಸಲು ಮಾದರಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ ಎಂಎಲ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದರೆ ಹೆಚ್ಚುವರಿ ಅಂಕಗಳು!
## ರೂಬ್ರಿಕ್
| ಮಾನದಂಡಗಳು | ಉದಾಹರಣೀಯ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆ ಅಗತ್ಯವಿದೆ |
| -------- | ------------------------------------------------------------------- | ------------------------------------------------- | ---------------------- |
| | ಪವರ್‌ಪಾಯಿಂಟ್ ಪ್ರಸ್ತುತಿ ನೀಡಲಾಗಿದೆ - ಮಾದರಿ ನಿರ್ಮಾಣಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಅಂಕಗಳು | ನವೀನತೆ ಇಲ್ಲದ, ಮೂಲಭೂತ ಪ್ರಸ್ತುತಿ ನೀಡಲಾಗಿದೆ | ಕೆಲಸ ಅಪೂರ್ಣವಾಗಿದೆ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

185
translations/kn/9-Real-World/2-Debugging-ML-Models/README.md
Unescape View File

@ -0,0 +1,185 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "df2b538e8fbb3e91cf0419ae2f858675",
"translation_date": "2025-12-19T15:13:41+00:00",
"source_file": "9-Real-World/2-Debugging-ML-Models/README.md",
"language_code": "kn"
}
-->
# ಪೋಸ್ಟ್‌ಸ್ಕ್ರಿಪ್ಟ್: ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳನ್ನು ಬಳಸಿ ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ಮಾದರಿ ಡಿಬಗಿಂಗ್
## [ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ಪರಿಚಯ
ಯಂತ್ರ ಅಧ್ಯಯನವು ನಮ್ಮ ದೈನಂದಿನ ಜೀವನವನ್ನು ಪ್ರಭಾವಿಸುತ್ತದೆ. AI ನಮ್ಮನ್ನು ವ್ಯಕ್ತಿಗಳಾಗಿ ಮತ್ತು ಸಮಾಜವಾಗಿ ಪ್ರಭಾವಿಸುವ ಆರೋಗ್ಯಸೇವೆ, ಹಣಕಾಸು, ಶಿಕ್ಷಣ ಮತ್ತು ಉದ್ಯೋಗದಂತಹ ಕೆಲವು ಅತ್ಯಂತ ಪ್ರಮುಖ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ತನ್ನ ಮಾರ್ಗವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತಿದೆ. ಉದಾಹರಣೆಗೆ, ವ್ಯವಸ್ಥೆಗಳು ಮತ್ತು ಮಾದರಿಗಳು ದೈನಂದಿನ ನಿರ್ಧಾರ-ಮೇಕಿಂಗ್ ಕಾರ್ಯಗಳಲ್ಲಿ ಭಾಗವಹಿಸುತ್ತವೆ, ಉದಾಹರಣೆಗೆ ಆರೋಗ್ಯ ನಿರ್ಣಯಗಳು ಅಥವಾ ಮೋಸ ಪತ್ತೆ. ಪರಿಣಾಮವಾಗಿ, AI ಯಲ್ಲಿ ಪ್ರಗತಿಗಳು ಮತ್ತು ವೇಗವಾಗಿ ಸ್ವೀಕಾರವು ಬೆಳೆಯುತ್ತಿರುವ ಸಾಮಾಜಿಕ ನಿರೀಕ್ಷೆಗಳು ಮತ್ತು ನಿಯಂತ್ರಣಗಳೊಂದಿಗೆ ಎದುರಿಸುತ್ತಿವೆ. ನಾವು ನಿರಂತರವಾಗಿ AI ವ್ಯವಸ್ಥೆಗಳು ನಿರೀಕ್ಷೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತಿರುವ ಪ್ರದೇಶಗಳನ್ನು ನೋಡುತ್ತೇವೆ; ಅವು ಹೊಸ ಸವಾಲುಗಳನ್ನು ಹೊರತರುತ್ತವೆ; ಮತ್ತು ಸರ್ಕಾರಗಳು AI ಪರಿಹಾರಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತಿವೆ. ಆದ್ದರಿಂದ, ಈ ಮಾದರಿಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಎಲ್ಲರಿಗೂ ನ್ಯಾಯಸಮ್ಮತ, ನಂಬಿಕಯೋಗ್ಯ, ಒಳಗೊಂಡ, ಪಾರದರ್ಶಕ ಮತ್ತು ಹೊಣೆಗಾರಿಕೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಒದಗಿಸುವುದು ಮುಖ್ಯ.
ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ, ನಾವು ಮಾದರಿಯಲ್ಲಿ ಜವಾಬ್ದಾರಿಯುತ AI ಸಮಸ್ಯೆಗಳಿದ್ದರೆ ಅವುಗಳನ್ನು ಅಳೆಯಲು ಬಳಸಬಹುದಾದ ಪ್ರಾಯೋಗಿಕ ಸಾಧನಗಳನ್ನು ನೋಡುತ್ತೇವೆ. ಪರಂಪರাগত ಯಂತ್ರ ಅಧ್ಯಯನ ಡಿಬಗಿಂಗ್ ತಂತ್ರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಗ್ರಹಿತ ಶುದ್ಧತೆ ಅಥವಾ ಸರಾಸರಿ ದೋಷ ನಷ್ಟದಂತಹ ಪ್ರಮಾಣಾತ್ಮಕ ಲೆಕ್ಕಾಚಾರಗಳ ಮೇಲೆ ಆಧಾರಿತವಾಗಿರುತ್ತವೆ. ನೀವು ಈ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸುತ್ತಿರುವ ಡೇಟಾದಲ್ಲಿ ಜಾತಿ, ಲಿಂಗ, ರಾಜಕೀಯ ದೃಷ್ಟಿಕೋನ, ಧರ್ಮ ಅಥವಾ ಇಂತಹ ಜನಾಂಗಗಳನ್ನು ಅಸಮಾನವಾಗಿ ಪ್ರತಿನಿಧಿಸುವಂತಹ ಕೆಲವು ಜನಾಂಗಗಳು ಇಲ್ಲದಿದ್ದರೆ ಏನಾಗಬಹುದು ಎಂದು ಕಲ್ಪಿಸಿ ನೋಡಿ. ಮಾದರಿಯ ಔಟ್‌ಪುಟ್ ಕೆಲವು ಜನಾಂಗವನ್ನು ಪ್ರಾಧಾನ್ಯ ನೀಡುವಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ? ಇದು ಈ ಸಂವೇದನಾಶೀಲ ಲಕ್ಷಣ ಗುಂಪುಗಳ ಅತಿವ್ಯಕ್ತ ಅಥವಾ ಅಲ್ಪಪ್ರತಿನಿಧಾನವನ್ನು ಪರಿಚಯಿಸಬಹುದು, ಇದರಿಂದ ಮಾದರಿಯಿಂದ ನ್ಯಾಯ, ಒಳಗೊಂಡಿಕೆ ಅಥವಾ ನಂಬಿಕಯೋಗ್ಯತೆ ಸಮಸ್ಯೆಗಳು ಉಂಟಾಗಬಹುದು. ಮತ್ತೊಂದು ಕಾರಣವೆಂದರೆ, ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ಕಪ್ಪು ಪೆಟ್ಟಿಗೆಗಳು ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಇದು ಮಾದರಿಯ ಭವಿಷ್ಯವಾಣಿ ಏಕೆ ಆಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ವಿವರಿಸಲು ಕಷ್ಟವಾಗುತ್ತದೆ. ಈ ಎಲ್ಲವುಗಳು ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಮತ್ತು AI ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರು ಸಮರ್ಪಕ ಸಾಧನಗಳಿಲ್ಲದೆ ಮಾದರಿಯ ನ್ಯಾಯತೆ ಅಥವಾ ನಂಬಿಕಯೋಗ್ಯತೆಯನ್ನು ಡಿಬಗ್ ಮತ್ತು ಅಳೆಯುವಾಗ ಎದುರಿಸುವ ಸವಾಲುಗಳಾಗಿವೆ.
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ಮಾದರಿಗಳನ್ನು ಡಿಬಗ್ ಮಾಡಲು ಕಲಿಯುತ್ತೀರಿ:
- **ದೋಷ ವಿಶ್ಲೇಷಣೆ**: ನಿಮ್ಮ ಡೇಟಾ ವಿತರಣದಲ್ಲಿ ಮಾದರಿಯು ಎಲ್ಲಿ ಹೆಚ್ಚಿನ ದೋಷ ದರಗಳನ್ನು ಹೊಂದಿದೆ ಎಂದು ಗುರುತಿಸಿ.
- **ಮಾದರಿ ಅವಲೋಕನ**: ವಿವಿಧ ಡೇಟಾ ಗುಂಪುಗಳ ನಡುವೆ ಹೋಲಿಕೆ ವಿಶ್ಲೇಷಣೆ ಮಾಡಿ ನಿಮ್ಮ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆ ಅಳತೆಗಳಲ್ಲಿ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ.
- **ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ**: ನಿಮ್ಮ ಡೇಟಾದಲ್ಲಿ ಅತಿವ್ಯಕ್ತ ಅಥವಾ ಅಲ್ಪಪ್ರತಿನಿಧಾನ ಇರುವ ಸ್ಥಳಗಳನ್ನು ಪರಿಶೀಲಿಸಿ, ಇದು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಒಂದು ಡೇಟಾ ಜನಾಂಗವನ್ನು ಇತರರಿಗಿಂತ ಪ್ರಾಧಾನ್ಯ ನೀಡಲು ತಿರುಗಿಸಬಹುದು.
- **ಲಕ್ಷಣ ಮಹತ್ವ**: ಜಾಗತಿಕ ಮಟ್ಟದಲ್ಲಿ ಅಥವಾ ಸ್ಥಳೀಯ ಮಟ್ಟದಲ್ಲಿ ನಿಮ್ಮ ಮಾದರಿಯ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಯಾವ ಲಕ್ಷಣಗಳು ಚಾಲನೆ ಮಾಡುತ್ತವೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ.
## ಪೂರ್ವಾಪೇಕ್ಷಿತ
ಪೂರ್ವಾಪೇಕ್ಷಿತವಾಗಿ, ದಯವಿಟ್ಟು [ಜವಾಬ್ದಾರಿಯುತ AI ಸಾಧನಗಳು ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರಿಗೆ](https://www.microsoft.com/ai/ai-lab-responsible-ai-dashboard) ಎಂಬ ವಿಮರ್ಶೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ
> ![ಜವಾಬ್ದಾರಿಯುತ AI ಸಾಧನಗಳ ಗಿಫ್](../../../../9-Real-World/2-Debugging-ML-Models/images/rai-overview.gif)
## ದೋಷ ವಿಶ್ಲೇಷಣೆ
ಸರಾಸರಿ ಶುದ್ಧತೆ ಅಥವಾ ತಪ್ಪು ಭವಿಷ್ಯವಾಣಿಗಳ ಮೇಲೆ ಆಧಾರಿತ ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆ ಅಳತೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸರಿಯಾದ ಮತ್ತು ತಪ್ಪಾದ ಭವಿಷ್ಯವಾಣಿಗಳ ಲೆಕ್ಕಾಚಾರಗಳಾಗಿವೆ. ಉದಾಹರಣೆಗೆ, 0.001 ದೋಷ ನಷ್ಟದೊಂದಿಗೆ 89% ಶುದ್ಧತೆ ಹೊಂದಿರುವ ಮಾದರಿಯನ್ನು ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು. ದೋಷಗಳು ನಿಮ್ಮ ಮೂಲ ಡೇಟಾ ಸೆಟ್‌ನಲ್ಲಿ ಸಮಾನವಾಗಿ ವಿತರಿಸಲ್ಪಡುವುದಿಲ್ಲ. ನೀವು 89% ಮಾದರಿ ಶುದ್ಧತೆ ಅಂಕೆಯನ್ನು ಪಡೆಯಬಹುದು ಆದರೆ ಮಾದರಿ 42% ಸಮಯದಲ್ಲಿ ವಿಫಲವಾಗುತ್ತಿರುವ ಡೇಟಾದ ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು. ಈ ವಿಫಲತೆ ಮಾದರಿಯ ನ್ಯಾಯತೆ ಅಥವಾ ನಂಬಿಕಯೋಗ್ಯತೆ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಮಾದರಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ಅಥವಾ ಇಲ್ಲದಿರುವ ಪ್ರದೇಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಾವಶ್ಯಕ. ನಿಮ್ಮ ಮಾದರಿಯಲ್ಲಿ ಹೆಚ್ಚಿನ ತಪ್ಪುಗಳಿರುವ ಡೇಟಾ ಪ್ರದೇಶವು ಪ್ರಮುಖ ಡೇಟಾ ಜನಾಂಗವಾಗಬಹುದು.
![ಮಾದರಿ ದೋಷಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಮತ್ತು ಡಿಬಗ್ ಮಾಡಿ](../../../../translated_images/ea-error-distribution.117452e1177c1dd84fab2369967a68bcde787c76c6ea7fdb92fcf15d1fce8206.kn.png)
RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ದೋಷ ವಿಶ್ಲೇಷಣೆ ಘಟಕವು ವಿವಿಧ ಗುಂಪುಗಳಲ್ಲಿ ಮಾದರಿ ವಿಫಲತೆ ಹೇಗೆ ವಿತರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಮರದ ದೃಶ್ಯೀಕರಣದೊಂದಿಗೆ ತೋರಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಡೇಟಾ ಸೆಟ್‌ನಲ್ಲಿ ಹೆಚ್ಚಿನ ದೋಷ ದರ ಇರುವ ಲಕ್ಷಣಗಳು ಅಥವಾ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ. ಹೆಚ್ಚಿನ ದೋಷಗಳು ಎಲ್ಲಿಂದ ಬರುತ್ತಿವೆ ಎಂದು ನೋಡಿಕೊಂಡು, ನೀವು ಮೂಲ ಕಾರಣವನ್ನು ಪರಿಶೀಲಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು. ನೀವು ವಿಶ್ಲೇಷಣೆ ಮಾಡಲು ಡೇಟಾ ಗುಂಪುಗಳನ್ನು ರಚಿಸಬಹುದು. ಈ ಡೇಟಾ ಗುಂಪುಗಳು ಡಿಬಗಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಸಹಾಯ ಮಾಡುತ್ತವೆ, ಏಕೆಂದರೆ ಒಂದು ಗುಂಪಿನಲ್ಲಿ ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆ ಉತ್ತಮವಾಗಿದ್ದರೆ ಮತ್ತೊಂದರಲ್ಲಿ ತಪ್ಪುಗಳಾಗಿರುವುದನ್ನು ತಿಳಿಯಲು.
![ದೋಷ ವಿಶ್ಲೇಷಣೆ](../../../../translated_images/ea-error-cohort.6886209ea5d438c4daa8bfbf5ce3a7042586364dd3eccda4a4e3d05623ac702a.kn.png)
ಮರ ನಕ್ಷೆಯ ದೃಶ್ಯ ಸೂಚಕಗಳು ಸಮಸ್ಯೆ ಪ್ರದೇಶಗಳನ್ನು ವೇಗವಾಗಿ ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಮರದ ನೋಡ್‌ಗೆ ಹೆಚ್ಚು ಕಪ್ಪು ಕೆಂಪು ಬಣ್ಣ ಇದ್ದರೆ, ದೋಷ ದರ ಹೆಚ್ಚು ಇದೆ.
ಹೀಟ್ ಮ್ಯಾಪ್ ಮತ್ತೊಂದು ದೃಶ್ಯೀಕರಣ ಕಾರ್ಯಕ್ಷಮತೆ, ಬಳಕೆದಾರರು ಒಂದು ಅಥವಾ ಎರಡು ಲಕ್ಷಣಗಳನ್ನು ಬಳಸಿ ದೋಷ ದರವನ್ನು ಪರಿಶೀಲಿಸಲು ಬಳಸಬಹುದು, ಇದು ಸಂಪೂರ್ಣ ಡೇಟಾ ಸೆಟ್ ಅಥವಾ ಗುಂಪುಗಳಲ್ಲಿ ಮಾದರಿ ದೋಷಗಳಿಗೆ ಕಾರಣವಾದ ಅಂಶವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
![ದೋಷ ವಿಶ್ಲೇಷಣೆ ಹೀಟ್‌ಮ್ಯಾಪ್](../../../../translated_images/ea-heatmap.8d27185e28cee3830c85e1b2e9df9d2d5e5c8c940f41678efdb68753f2f7e56c.kn.png)
ನೀವು ದೋಷ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಬಳಸಬೇಕಾಗಿರುವಾಗ:
* ಮಾದರಿ ವಿಫಲತೆಗಳು ಡೇಟಾ ಸೆಟ್ ಮತ್ತು ವಿವಿಧ ಇನ್‌ಪುಟ್ ಮತ್ತು ಲಕ್ಷಣ ಆಯಾಮಗಳಲ್ಲಿ ಹೇಗೆ ವಿತರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಆಳವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ.
* ಸಂಗ್ರಹಿತ ಕಾರ್ಯಕ್ಷಮತೆ ಅಳತೆಗಳನ್ನು ವಿಭಜಿಸಿ ತಪ್ಪು ಗುಂಪುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಂಡುಹಿಡಿದು ನಿಮ್ಮ ಗುರಿತಗೊಂಡ ಪರಿಹಾರ ಕ್ರಮಗಳನ್ನು ತಿಳಿಸಿ.
## ಮಾದರಿ ಅವಲೋಕನ
ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಅದರ ವರ್ತನೆಯನ್ನು ಸಮಗ್ರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅಗತ್ಯ. ಇದು ದೋಷ ದರ, ಶುದ್ಧತೆ, ರಿಕಾಲ್, ಪ್ರೆಸಿಷನ್ ಅಥವಾ MAE (ಸರಾಸರಿ ಪರಮಾಣು ದೋಷ) ಮುಂತಾದ metrics ಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಸಾಧ್ಯ. ಒಂದು ಕಾರ್ಯಕ್ಷಮತೆ ಅಳತೆ ಉತ್ತಮವಾಗಿದ್ದರೂ, ಮತ್ತೊಂದು ಅಳತೆಯಲ್ಲಿ ತಪ್ಪುಗಳು ಬಹಿರಂಗವಾಗಬಹುದು. ಜೊತೆಗೆ, ಸಂಪೂರ್ಣ ಡೇಟಾ ಸೆಟ್ ಅಥವಾ ಗುಂಪುಗಳಲ್ಲಿ metrics ಗಳ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೋಲಿಸುವುದು ಮಾದರಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ಅಥವಾ ಇಲ್ಲದಿರುವ ಸ್ಥಳಗಳನ್ನು ಬೆಳಗಿಸುತ್ತದೆ. ಇದು ವಿಶೇಷವಾಗಿ ಸಂವೇದನಾಶೀಲ ಮತ್ತು ಅಸಂವೇದನಾಶೀಲ ಲಕ್ಷಣಗಳ (ಉದಾ: ರೋಗಿಯ ಜಾತಿ, ಲಿಂಗ ಅಥವಾ ವಯಸ್ಸು) ನಡುವೆ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೋಡಲು ಮುಖ್ಯ, ಏಕೆಂದರೆ ಇದು ಮಾದರಿಯ ಅನ್ಯಾಯವನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಸಂವೇದನಾಶೀಲ ಲಕ್ಷಣಗಳಿರುವ ಗುಂಪಿನಲ್ಲಿ ಮಾದರಿ ಹೆಚ್ಚು ತಪ್ಪುಗಳನ್ನು ಮಾಡುತ್ತಿರುವುದು ಕಂಡುಬಂದರೆ, ಇದು ಮಾದರಿಯ ಅನ್ಯಾಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಮಾದರಿ ಅವಲೋಕನ ಘಟಕವು ಡೇಟಾ ಪ್ರತಿನಿಧಾನದ ಕಾರ್ಯಕ್ಷಮತೆ metrics ಗಳ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ, ಬಳಕೆದಾರರಿಗೆ ವಿವಿಧ ಗುಂಪುಗಳ ನಡುವೆ ಮಾದರಿಯ ವರ್ತನೆಯನ್ನು ಹೋಲಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
![ಡೇಟಾ ಗುಂಪುಗಳು - RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಮಾದರಿ ಅವಲೋಕನ](../../../../translated_images/model-overview-dataset-cohorts.dfa463fb527a35a0afc01b7b012fc87bf2cad756763f3652bbd810cac5d6cf33.kn.png)
ಘಟಕದ ಲಕ್ಷಣ ಆಧಾರಿತ ವಿಶ್ಲೇಷಣೆ ಕಾರ್ಯಕ್ಷಮತೆ ಬಳಕೆದಾರರಿಗೆ ನಿರ್ದಿಷ್ಟ ಲಕ್ಷಣದ ಒಳಗಿನ ಡೇಟಾ ಉಪಗುಂಪುಗಳನ್ನು ಸಣ್ಣ ಮಟ್ಟದಲ್ಲಿ ಅನಾಮಲಿಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬಳಕೆದಾರರು ಆಯ್ಕೆಮಾಡಿದ ಲಕ್ಷಣಕ್ಕೆ (ಉದಾ: *"time_in_hospital < 3"* ಅಥವಾ *"time_in_hospital >= 7"*) ಗುಂಪುಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ಬಳಕೆದಾರರಿಗೆ ದೊಡ್ಡ ಡೇಟಾ ಗುಂಪಿನಿಂದ ನಿರ್ದಿಷ್ಟ ಲಕ್ಷಣವನ್ನು ವಿಭಜಿಸಿ, ಅದು ಮಾದರಿಯ ತಪ್ಪು ಫಲಿತಾಂಶಗಳಿಗೆ ಪ್ರಮುಖ ಕಾರಣವಾಗಿದೆಯೇ ಎಂದು ನೋಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
![ಲಕ್ಷಣ ಗುಂಪುಗಳು - RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಮಾದರಿ ಅವಲೋಕನ](../../../../translated_images/model-overview-feature-cohorts.c5104d575ffd0c80b7ad8ede7703fab6166bfc6f9125dd395dcc4ace2f522f70.kn.png)
ಮಾದರಿ ಅವಲೋಕನ ಘಟಕವು ಎರಡು ವರ್ಗದ ವ್ಯತ್ಯಾಸ metrics ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ:
**ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯಲ್ಲಿ ವ್ಯತ್ಯಾಸ**: ಈ metrics ಗಳ ಸೆಟ್ ಆಯ್ಕೆಮಾಡಲಾದ ಕಾರ್ಯಕ್ಷಮತೆ ಅಳತೆಯ ಮೌಲ್ಯಗಳಲ್ಲಿ ಉಪಗುಂಪುಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸ (ತಾರತಮ್ಯ) ಲೆಕ್ಕಹಾಕುತ್ತದೆ. ಕೆಲವು ಉದಾಹರಣೆಗಳು:
* ಶುದ್ಧತೆ ದರದಲ್ಲಿ ವ್ಯತ್ಯಾಸ
* ದೋಷ ದರದಲ್ಲಿ ವ್ಯತ್ಯಾಸ
* ಪ್ರೆಸಿಷನ್‌ನಲ್ಲಿ ವ್ಯತ್ಯಾಸ
* ರಿಕಾಲ್‌ನಲ್ಲಿ ವ್ಯತ್ಯಾಸ
* ಸರಾಸರಿ ಪರಮಾಣು ದೋಷ (MAE) ನಲ್ಲಿ ವ್ಯತ್ಯಾಸ
**ಆಯ್ಕೆ ದರದಲ್ಲಿ ವ್ಯತ್ಯಾಸ**: ಈ metric ಉಪಗುಂಪುಗಳ ನಡುವೆ ಆಯ್ಕೆ ದರ (ಅನುಕೂಲ ಭವಿಷ್ಯವಾಣಿ) ಯ ವ್ಯತ್ಯಾಸವನ್ನು ಹೊಂದಿದೆ. ಉದಾಹರಣೆಗೆ ಸಾಲ ಮಂಜೂರಾತಿ ದರಗಳಲ್ಲಿ ವ್ಯತ್ಯಾಸ. ಆಯ್ಕೆ ದರ ಎಂದರೆ ಪ್ರತಿ ವರ್ಗದಲ್ಲಿ 1 (ದ್ವಿಪದ ವರ್ಗೀಕರಣದಲ್ಲಿ) ಎಂದು ವರ್ಗೀಕರಿಸಲ್ಪಟ್ಟ ಡೇಟಾ ಅಂಶಗಳ ಭಾಗ ಅಥವಾ ಭವಿಷ್ಯವಾಣಿ ಮೌಲ್ಯಗಳ ವಿತರಣೆ (ರೆಗ್ರೆಷನ್‌ನಲ್ಲಿ).
## ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ
> "ನೀವು ಡೇಟಾವನ್ನು ಸಾಕಷ್ಟು ಕಾಲ ಹಿಂಸಿಸಿದರೆ, ಅದು ಯಾವುದಕ್ಕೂ ಒಪ್ಪಿಕೊಳ್ಳುತ್ತದೆ" - ರೋನಾಲ್ಡ್ ಕೋಸ್
ಈ ಹೇಳಿಕೆ ತೀವ್ರವಾಗಿದ್ದರೂ, ಡೇಟಾವನ್ನು ಯಾವುದೇ ನಿರ್ಣಯವನ್ನು ಬೆಂಬಲಿಸಲು ಮರುರೂಪಗೊಳಿಸಬಹುದು ಎಂಬುದು ಸತ್ಯ. ಇಂತಹ ಮರುರೂಪಣೆಯು ಕೆಲವೊಮ್ಮೆ ಅನೈಚ್ಛಿಕವಾಗಿ ಸಂಭವಿಸಬಹುದು. ನಾವು ಮಾನವರಾಗಿ ಎಲ್ಲರೂ ಪೂರ್ವಗ್ರಹ ಹೊಂದಿದ್ದೇವೆ, ಮತ್ತು ನೀವು ಡೇಟಾದಲ್ಲಿ ಪೂರ್ವಗ್ರಹವನ್ನು ಪರಿಚಯಿಸುತ್ತಿದ್ದೀರಾ ಎಂದು ಜಾಗೃತಿಯಿಂದ ತಿಳಿದುಕೊಳ್ಳುವುದು ಕಷ್ಟ. AI ಮತ್ತು ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ನ್ಯಾಯತೆಯನ್ನು ಖಚಿತಪಡಿಸುವುದು ಸಂಕೀರ್ಣ ಸವಾಲಾಗಿದೆ.
ಡೇಟಾ ಪರಂಪರাগত ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆ metrics ಗಾಗಿ ದೊಡ್ಡ ಅಂಧ ಪ್ರದೇಶವಾಗಿದೆ. ನೀವು ಹೆಚ್ಚಿನ ಶುದ್ಧತೆ ಅಂಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಆದರೆ ಇದು ನಿಮ್ಮ ಡೇಟಾ ಸೆಟ್‌ನಲ್ಲಿ ಇರುವ ಅಡಗಿದ ಪೂರ್ವಗ್ರಹವನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಕಂಪನಿಯ ಉದ್ಯೋಗಿಗಳ ಡೇಟಾ ಸೆಟ್‌ನಲ್ಲಿ 27% ಮಹಿಳೆಯರು ಕಾರ್ಯನಿರ್ವಹಣಾ ಹುದ್ದೆಗಳಲ್ಲಿ ಇದ್ದರೆ ಮತ್ತು 73% ಪುರುಷರು ಅದೇ ಹುದ್ದೆಯಲ್ಲಿ ಇದ್ದರೆ, ಈ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತಿಗೊಂಡ ಉದ್ಯೋಗ ಜಾಹೀರಾತು AI ಮಾದರಿ ಹಿರಿಯ ಹುದ್ದೆಗಳಿಗಾಗಿ ಮುಖ್ಯವಾಗಿ ಪುರುಷರನ್ನು ಗುರಿಯಾಗಿಸಬಹುದು. ಈ ಅಸಮಾನತೆ ಮಾದರಿಯ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಒಂದು ಲಿಂಗಕ್ಕೆ ಪ್ರಾಧಾನ್ಯ ನೀಡುವಂತೆ ತಿರುಗಿಸಿದೆ. ಇದು AI ಮಾದರಿಯಲ್ಲಿ ಲಿಂಗ ಪೂರ್ವಗ್ರಹದ ನ್ಯಾಯತೆ ಸಮಸ್ಯೆಯನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ.
RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಘಟಕವು ಡೇಟಾ ಸೆಟ್‌ನಲ್ಲಿ ಅತಿವ್ಯಕ್ತ ಮತ್ತು ಅಲ್ಪಪ್ರತಿನಿಧಾನ ಇರುವ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಬಳಕೆದಾರರಿಗೆ ದೋಷಗಳು ಮತ್ತು ನ್ಯಾಯತೆ ಸಮಸ್ಯೆಗಳ ಮೂಲ ಕಾರಣವನ್ನು ಡೇಟಾ ಅಸಮಾನತೆಗಳಿಂದ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಗುಂಪಿನ ಪ್ರತಿನಿಧಾನದ ಕೊರತೆಯಿಂದ ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಭವಿಷ್ಯವಾಣಿ ಮತ್ತು ನಿಜವಾದ ಫಲಿತಾಂಶಗಳ ಆಧಾರದ ಮೇಲೆ, ದೋಷ ಗುಂಪುಗಳು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಲಕ್ಷಣಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾ ಸೆಟ್‌ಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಬಳಕೆದಾರರಿಗೆ ಸಾಮರ್ಥ್ಯ ನೀಡುತ್ತದೆ. ಕೆಲವೊಮ್ಮೆ ಅಲ್ಪಪ್ರತಿನಿಧಿತ ಡೇಟಾ ಗುಂಪನ್ನು ಕಂಡುಹಿಡಿಯುವುದರಿಂದ ಮಾದರಿ ಚೆನ್ನಾಗಿ ಕಲಿಯುತ್ತಿಲ್ಲ ಎಂದು ಬಹಿರಂಗವಾಗಬಹುದು, ಆದ್ದರಿಂದ ಹೆಚ್ಚಿನ ದೋಷಗಳು. ಡೇಟಾ ಪೂರ್ವಗ್ರಹ ಹೊಂದಿರುವ ಮಾದರಿ ಕೇವಲ ನ್ಯಾಯತೆ ಸಮಸ್ಯೆಯಲ್ಲ, ಅದು ಒಳಗೊಂಡ ಅಥವಾ ನಂಬಿಕಯೋಗ್ಯವಲ್ಲದ ಮಾದರಿಯನ್ನೂ ತೋರಿಸುತ್ತದೆ.
![RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಘಟಕ](../../../../translated_images/dataanalysis-cover.8d6d0683a70a5c1e274e5a94b27a71137e3d0a3b707761d7170eb340dd07f11d.kn.png)
ನೀವು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಬಳಸಬೇಕಾಗಿರುವಾಗ:
* ವಿಭಿನ್ನ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ವಿಭಿನ್ನ ಆಯಾಮಗಳಲ್ಲಿ (ಗುಂಪುಗಳಾಗಿ) ವಿಭಜಿಸಿ ನಿಮ್ಮ ಡೇಟಾ ಅಂಕಿಅಂಶಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.
* ವಿಭಿನ್ನ ಗುಂಪುಗಳು ಮತ್ತು ಲಕ್ಷಣ ಗುಂಪುಗಳ ಮೂಲಕ ನಿಮ್ಮ ಡೇಟಾ ವಿತರಣೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ.
* ನ್ಯಾಯತೆ, ದೋಷ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಕಾರಣಾತ್ಮಕತೆ (ಇತರ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳಿಂದ ಪಡೆದ) ಸಂಬಂಧಿತ ನಿಮ್ಮ ಕಂಡುಹಿಡಿತಗಳು ನಿಮ್ಮ ಡೇಟಾ ವಿತರಣೆಯ ಫಲಿತಾಂಶವಾಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸಿ.
* ಪ್ರತಿನಿಧಾನ ಸಮಸ್ಯೆಗಳು, ಲೇಬಲ್ ಶಬ್ದ, ಲಕ್ಷಣ ಶಬ್ದ, ಲೇಬಲ್ ಪೂರ್ವಗ್ರಹ ಮತ್ತು ಇತರ ಕಾರಣಗಳಿಂದ ಉಂಟಾಗುವ ದೋಷಗಳನ್ನು ತಗ್ಗಿಸಲು ಹೆಚ್ಚಿನ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಪ್ರದೇಶಗಳನ್ನು ನಿರ್ಧರಿಸಿ.
## ಮಾದರಿ ವಿವರಣೆ
ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕಪ್ಪು ಪೆಟ್ಟಿಗೆಗಳಾಗಿವೆ. ಯಾವ ಪ್ರಮುಖ ಡೇಟಾ ಲಕ್ಷಣಗಳು ಮಾದರಿಯ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸವಾಲಾಗಿರುತ್ತದೆ. ಮಾದರಿ ಏಕೆ ನಿರ್ದಿಷ್ಟ ಭವಿಷ್ಯವಾಣಿ ಮಾಡುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಪಾರದರ್ಶಕತೆ ಒದಗಿಸುವುದು ಮುಖ್ಯ. ಉದಾಹರಣೆಗೆ, AI ವ್ಯವಸ್ಥೆ ಒಂದು ಮಧುಮೇಹ ರೋಗಿಯು 30 ದಿನಗಳಲ್ಲಿ ಆಸ್ಪತ್ರೆಗೆ ಮರುಪ್ರವೇಶಿಸುವ ಅಪಾಯದಲ್ಲಿದ್ದಾನೆ ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ, ಅದರ ಭವಿಷ್ಯವಾಣಿಗೆ ಕಾರಣವಾದ ಬೆಂಬಲಿಸುವ ಡೇಟಾವನ್ನು ಒದಗಿಸಬೇಕು. ಬೆಂಬಲಿಸುವ ಡೇಟಾ ಸೂಚಕಗಳು ಪಾರದರ್ಶಕತೆಯನ್ನು ತರಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ, ಇದರಿಂದ ವೈದ್ಯರು ಅಥವಾ ಆಸ್ಪತ್ರೆಗಳು ಚೆನ್ನಾಗಿ ತಿಳಿದ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಜೊತೆಗೆ, ವ್ಯಕ್ತಿಗತ ರೋಗಿಗೆ ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಕಾರಣವನ್ನು ವಿವರಿಸುವುದು ಆರೋಗ್ಯ ನಿಯಮಾವಳಿಗಳೊಂದಿಗೆ ಹೊಣೆಗಾರಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಜನರ ಜೀವನವನ್ನು ಪ್ರಭಾವಿಸುವ ರೀತಿಯಲ್ಲಿ ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ಬಳಸುವಾಗ, ಮಾದರಿಯ ವರ್ತನೆಯನ್ನು ಏನು ಪ್ರಭಾವಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ವಿವರಿಸುವುದು ಅತ್ಯಂತ ಮುಖ್ಯ. ಮಾದರಿ ವಿವರಣೆ ಮತ್ತು ವ್ಯಾಖ್ಯಾನವು ಕೆಳಗಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರ ನೀಡುತ್ತದೆ:
* ಮಾದರಿ ಡಿಬಗಿಂಗ್: ನನ್ನ ಮಾದರಿ ಈ ತಪ್ಪು ಮಾಡಿದ್ದು ಏಕೆ? ನಾನು ನನ್ನ ಮಾದರಿಯನ್ನು ಹೇಗೆ ಸುಧಾರಿಸಬಹುದು?
* ಮಾನವ-AI ಸಹಕಾರ: ನಾನು ಮಾದರಿಯ ನಿರ್ಧಾರಗಳನ್ನು ಹೇಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ ಮತ್ತು ನಂಬಬಹುದು?
* ನಿಯಂತ್ರಣ ಅನುಕೂಲತೆ: ನನ್ನ ಮಾದರಿ ಕಾನೂನು ಅಗತ್ಯಗಳನ್ನು ಪೂರೈಸುತ್ತದೆಯೇ?
RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಲಕ್ಷಣ ಮಹತ್ವ ಘಟಕವು ನಿಮ್ಮನ್ನು ಡಿಬಗ್ ಮಾಡಲು ಮತ್ತು ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಹೇಗೆ ಮಾಡುತ್ತದೆ ಎಂಬುದರ ಸಮಗ್ರ ಅರ್ಥವನ್ನು ಪಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಯಂತ್ರ ಅಧ್ಯಯನ ವೃತ್ತಿಪರರು ಮತ್ತು ನಿರ್ಧಾರಗಾರರಿಗೆ ನಿಯಂತ್ರಣ ಅನುಕೂಲತೆಯಿಗಾಗಿ ಮಾದರಿಯ ವರ್ತನೆಯನ್ನು ಪ್ರಭಾವಿಸುವ ಲಕ್ಷಣಗಳನ್ನು ವಿವರಿಸಲು ಮತ್ತು ಸಾಕ್ಷ್ಯವನ್ನು ತೋರಿಸಲು ಉಪಯುಕ್ತ ಸಾಧನವಾಗಿದೆ. ನಂತರ, ಬಳಕೆದಾರರು ಜಾಗತಿಕ ಮತ್ತು ಸ್ಥಳೀಯ ವಿವರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸಿ ಯಾವ ಲಕ್ಷಣಗಳು ಮಾದರಿಯ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತವೆ ಎಂದು ಪರಿಶೀಲಿಸಬಹುದು. ಜಾಗತಿಕ ವಿವರಣೆಗಳು ಮಾದರಿಯ ಒಟ್ಟು ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಪ್ರಭಾವಿಸಿದ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತವೆ. ಸ್ಥಳೀಯ ವಿವರಣೆಗಳು ವ್ಯಕ್ತಿಗತ ಪ್ರಕರಣಕ್ಕೆ ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಲಕ್ಷಣಗಳನ್ನು ತೋರಿಸುತ್ತವೆ. ಸ್ಥಳೀಯ ವಿವರಣೆಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣವನ್ನು ಡಿಬಗ್ ಅಥವಾ ಪರಿಶೀಲಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಮಾದರಿ ಸರಿಯಾದ ಅಥವಾ ತಪ್ಪು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಕಾರಣವನ್ನು ಉತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
![RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಲಕ್ಷಣ ಮಹತ್ವ ಘಟಕ](../../../../translated_images/9-feature-importance.cd3193b4bba3fd4bccd415f566c2437fb3298c4824a3dabbcab15270d783606e.kn.png)
* ಜಾಗತಿಕ ವಿವರಣೆಗಳು: ಉದಾಹರಣೆಗೆ, ಮಧುಮೇಹ ಆಸ್ಪತ್ರೆ ಮರುಪ್ರವೇಶ ಮಾದರಿಯ ಒಟ್ಟು ವರ್ತನೆಯನ್ನು ಯಾವ ಲಕ್ಷಣಗಳು ಪ್ರಭಾವಿಸುತ್ತವೆ?
* ಸ್ಥಳೀಯ ವಿವರಣೆಗಳು: ಉದಾಹರಣೆಗೆ, 60 ವರ್ಷಕ್ಕಿಂತ ಮೇಲ್ಪಟ್ಟ ಮಧುಮೇಹ ರೋಗಿಯು 30 ದಿನಗಳಲ್ಲಿ ಮರುಪ್ರವೇಶಿಸುವ ಅಥವಾ ಮರುಪ್ರವೇಶಿಸದಿರುವ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ್ದು ಏಕೆ?
ವಿಭಿನ್ನ ಗುಂಪುಗಳಲ್ಲಿನ ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಶೀಲಿಸುವ ಡಿಬಗಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಲಕ್ಷಣ ಮಹತ್ವವು ಗುಂಪುಗಳಲ್ಲಿ ಲಕ್ಷಣದ ಪ್ರಭಾವದ ಮಟ್ಟವನ್ನು ತೋರಿಸುತ್ತದೆ. ಇದು ಮಾದರಿಯ ತಪ್ಪು ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಚಾಲನೆ ಮಾಡುವ ಲಕ್ಷಣದ ಪ್ರಭಾವದ ಮಟ್ಟವನ್ನು ಹೋಲಿಸುವಾಗ ಅನಾಮಲಿಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಲಕ್ಷಣ ಮಹತ್ವ ಘಟಕವು ಲಕ್ಷಣದ ಮೌಲ್ಯಗಳು ಮಾದರಿಯ ಫಲಿತಾಂಶವನ್ನು ಧನಾತ್ಮಕ ಅಥವಾ ಋಣಾತ್ಮಕವಾಗಿ ಪ್ರಭಾವಿಸಿದವು ಎಂದು ತೋರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಮಾದರಿ ತಪ್ಪು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ, ಈ ಘಟಕವು ನೀವು ಆ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಚಾಲನೆ ಮಾಡಿದ ಲಕ್ಷಣಗಳು ಅಥವಾ ಲಕ್ಷಣ ಮೌಲ್ಯಗಳನ್ನು ವಿವರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಮಟ್ಟದ ವಿವರವು ಡಿಬಗಿಂಗ್ ಮಾತ್ರವಲ್ಲದೆ ಪರಿಶೀಲನೆ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಪಾರದರ್ಶಕತೆ ಮತ್ತು ಹೊಣೆಗಾರಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕೊನೆಗೆ, ಈ ಘಟಕವು ನ್ಯಾಯತೆ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಜಾತಿ ಅಥವಾ ಲಿಂಗದಂತಹ ಸಂವೇದನಾಶೀಲ ಲಕ್ಷಣವು ಮಾದರಿಯ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಹೆಚ್ಚು ಪ್ರಭಾವಿಸಿದರೆ, ಇದು ಮಾದರಿಯಲ್ಲಿ ಜಾತಿ ಅಥವಾ ಲಿಂಗ ಪೂರ್ವಗ್ರಹದ ಸೂಚನೆ ಆಗಬಹುದು.
![ಲಕ್ಷಣ ಮಹತ್ವ](../../../../translated_images/9-features-influence.3ead3d3f68a84029f1e40d3eba82107445d3d3b6975d4682b23d8acc905da6d0.kn.png)
ನೀವು ವಿವರಣಾತ್ಮಕತೆಯನ್ನು ಬಳಸಬೇಕಾಗಿರುವಾಗ:
* ನಿಮ್ಮ AI ವ್ಯವಸ್ಥೆಯ ಭವಿಷ್ಯವಾಣಿಗಳು ಎಷ್ಟು ನಂಬಿಕಯೋಗ್ಯವೋ ತಿಳಿದುಕೊಳ್ಳಲು ಯಾವ ಲಕ್ಷಣಗಳು ಭವಿಷ್ಯವಾಣಿಗೆ ಅತ್ಯಂತ ಮುಖ್ಯವೋ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ.
* ಮೊದಲು ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಡಿಬಗ್ ಮಾಡಲು, ಮಾದರಿ ಆರೋಗ್ಯಕರ ಲಕ್ಷಣಗಳನ್ನು ಬಳಸುತ್ತಿದೆಯೇ ಅಥವಾ ತಪ್ಪು ಸಂಬಂಧಗಳನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತಿದೆಯೇ ಎಂದು ಗುರುತಿಸಿ.
* ಸಂವೇದನಾಶೀಲ ಲಕ್ಷಣಗಳ ಮೇಲೆ ಅಥವಾ ಅವುಗಳಿಗೆ ಹೆಚ್ಚು ಸಂಬಂಧಿಸಿದ ಲಕ್ಷಣಗಳ ಮೇಲೆ ಆಧಾರಿತ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡುತ್ತಿರುವುದರಿಂದ ಅನ್ಯಾಯದ ಮೂಲಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಿ.
* ಸ್ಥಳೀಯ ವಿವರಣೆಗಳನ್ನು ರಚಿಸಿ ನಿಮ್ಮ ಮಾದರಿಯ ನಿರ್ಧಾರಗಳಲ್ಲಿ ಬಳಕೆದಾರರ ನಂಬಿಕೆಯನ್ನು ನಿರ್ಮಿಸಿ.
* AI ವ್ಯವಸ್ಥೆಯ ನಿಯಂತ್ರಣ ಪರಿಶೀಲನೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ, ಮಾದರಿಗಳನ್ನು ಮಾನವರ ಮೇಲೆ ಮಾದರಿ ನಿರ್ಧಾರಗಳ ಪ್ರಭಾವವನ್ನು ಪರಿಶೀಲಿಸಿ.
## ಸಮಾರೋಪ
ಎಲ್ಲಾ RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳು ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ಸಮಾಜಕ್ಕೆ ಕಡಿಮೆ ಹಾನಿಕರ ಮತ್ತು ಹೆಚ್ಚು ನಂಬಿಕಯೋಗ್ಯವಾಗುವಂತೆ ನಿರ್ಮಿಸಲು ಸಹಾಯ ಮಾಡುವ ಪ್ರಾಯೋಗಿಕ ಸಾಧನಗಳಾಗಿವೆ. ಇದು ಮಾನವ ಹಕ್ಕುಗಳಿಗೆ ಹಾನಿ ತಡೆಯಲು; ಕೆಲವು ಗುಂಪುಗಳನ್ನು ಜೀವನಾವಕಾಶಗಳಿಂದ ಭೇದಭಾವ ಅಥವಾ ಹೊರತುಪಡಿಸುವುದನ್ನು ತಡೆಯಲು; ಮತ್ತು ದೈಹಿಕ ಅಥವಾ ಮಾನಸಿಕ ಗಾಯದ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಸ್ಥಳೀಯ ವಿವರಣೆಗಳನ್ನು ರಚಿಸಿ ನಿಮ್ಮ ಮಾದರಿಯ ನಿರ್ಧಾರಗಳಲ್ಲಿ ನಂಬಿಕೆಯನ್ನು ನಿರ್ಮಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಕೆಲವು ಸಾಧ್ಯ ಹಾನಿಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವರ್ಗೀಕರಿಸಬಹುದು:
- **ಹಂಚಿಕೆ**, ಉದಾಹರಣೆಗೆ ಲಿಂಗ ಅಥವಾ ಜಾತಿ ಒಂದರಿಗಿಂತ ಮತ್ತೊಂದರಿಗಿಂತ ಪ್ರಾಧಾನ್ಯ ನೀಡಿದರೆ.
- **ಸೇವೆಯ ಗುಣಮಟ್ಟ**. ನೀವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭಕ್ಕಾಗಿ ಡೇಟಾವನ್ನು ತರಬೇತಿಗೊಳಿಸಿದರೆ ಆದರೆ ವಾಸ್ತವಿಕತೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೆ, ಅದು ದೌರ್ಬಲ್ಯಪೂರ್ಣ ಸೇವೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
- **ಸ್ಟೀರಿಯೋಟೈಪಿಂಗ್**. ನಿರ್ದಿಷ್ಟ ಗುಂಪನ್ನು ಪೂರ್ವನಿಯೋಜಿತ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು.
- **ನಿಂದನೆ**. ಅನ್ಯಾಯವಾಗಿ ವಿಮರ್ಶೆ ಮಾಡುವುದು ಮತ್ತು ಏನಾದರೂ ಅಥವಾ ಯಾರಾದರೂ ಲೇಬಲ್ ಮಾಡುವುದು.
- **ಅತಿಯಾದ ಅಥವಾ ಕಡಿಮೆ ಪ್ರತಿನಿಧಾನ**. ಒಂದು ನಿರ್ದಿಷ್ಟ ಗುಂಪು ನಿರ್ದಿಷ್ಟ ವೃತ್ತಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂಬ ಕಲ್ಪನೆ, ಮತ್ತು ಅದನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುವ ಯಾವುದೇ ಸೇವೆ ಅಥವಾ ಕಾರ್ಯವು ಹಾನಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
### ಅಜೂರ್ RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್
[ಅಜೂರ್ RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್](https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu) ಮುಕ್ತ ಮೂಲ ಸಾಧನಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಇದನ್ನು ಪ್ರಮುಖ ಶೈಕ್ಷಣಿಕ ಸಂಸ್ಥೆಗಳು ಮತ್ತು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಸೇರಿದಂತೆ ಸಂಸ್ಥೆಗಳು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ್ದವು, ಮತ್ತು ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಮತ್ತು AI ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರು ಮಾದರಿ ವರ್ತನೆಯನ್ನು ಉತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, AI ಮಾದರಿಗಳಿಂದ ಅಕಾಮ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಕಂಡುಹಿಡಿದು ನಿವಾರಿಸಲು ಸಹಾಯಕವಾಗಿವೆ.
- RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ [ಡಾಕ್ಯುಮೆಂಟೇಶನ್](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu) ಪರಿಶೀಲಿಸಿ ವಿಭಿನ್ನ ಘಟಕಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ತಿಳಿಯಿರಿ.
- ಅಜೂರ್ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ ಹೆಚ್ಚು ಜವಾಬ್ದಾರಿಯುತ AI ದೃಶ್ಯಾವಳಿಗಳನ್ನು ಡಿಬಗ್ ಮಾಡಲು ಕೆಲವು RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ [ನಮೂನಾ ನೋಟ್ಬುಕ್‌ಗಳು](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) ಪರಿಶೀಲಿಸಿ.
---
## 🚀 ಸವಾಲು
ಸಾಂಖ್ಯಿಕ ಅಥವಾ ಡೇಟಾ ಪಾಕ್ಷಿಕತೆಗಳನ್ನು ಮೊದಲಿನಿಂದಲೇ ಪರಿಹರಿಸಲು, ನಾವು:
- ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಜನರ ನಡುವೆ ವೈವಿಧ್ಯಮಯ ಹಿನ್ನೆಲೆ ಮತ್ತು ದೃಷ್ಟಿಕೋನಗಳನ್ನು ಹೊಂದಿರಬೇಕು
- ನಮ್ಮ ಸಮಾಜದ ವೈವಿಧ್ಯತೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ಹೂಡಿಕೆ ಮಾಡಬೇಕು
- ಪಾಕ್ಷಿಕತೆ ಸಂಭವಿಸಿದಾಗ ಅದನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ಉತ್ತಮ ವಿಧಾನಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಬೇಕು
ಮಾದರಿ ನಿರ್ಮಾಣ ಮತ್ತು ಬಳಕೆಯಲ್ಲಿ ಅನ್ಯಾಯ ಸ್ಪಷ್ಟವಾಗಿರುವ ನೈಜ ಜೀವನದ ದೃಶ್ಯಾವಳಿಗಳನ್ನು ಯೋಚಿಸಿ. ಇನ್ನೇನು ಪರಿಗಣಿಸಬೇಕು?
## [ಪಾಠೋತ್ತರ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಜವಾಬ್ದಾರಿಯುತ AI ಅನ್ನು ಮೆಷಿನ್ ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ ಸೇರಿಸುವ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಸಾಧನಗಳನ್ನು ಕಲಿತಿದ್ದೀರಿ.
ಈ ವಿಷಯಗಳಲ್ಲಿ ಇನ್ನಷ್ಟು ಆಳವಾಗಿ ತಿಳಿಯಲು ಈ ಕಾರ್ಯಾಗಾರವನ್ನು ವೀಕ್ಷಿಸಿ:
- ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್: Besmira Nushi ಮತ್ತು Mehrnoosh Sameki ಅವರಿಂದ RAI ಅನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಒಟ್ಟು ಪರಿಹಾರ
[![ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್: Besmira Nushi ಮತ್ತು Mehrnoosh Sameki ಅವರಿಂದ RAI ಅನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಒಟ್ಟು ಪರಿಹಾರ](https://img.youtube.com/vi/f1oaDNl3djg/0.jpg)](https://www.youtube.com/watch?v=f1oaDNl3djg "ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್: Besmira Nushi ಮತ್ತು Mehrnoosh Sameki ಅವರಿಂದ RAI ಅನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಒಟ್ಟು ಪರಿಹಾರ")
> 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ವೀಡಿಯೋ ನೋಡಲು: Besmira Nushi ಮತ್ತು Mehrnoosh Sameki ಅವರಿಂದ ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್: RAI ಅನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಒಟ್ಟು ಪರಿಹಾರ
ಜವಾಬ್ದಾರಿಯುತ AI ಮತ್ತು ಹೆಚ್ಚು ನಂಬಿಗಸ್ತ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿಯಲು ಕೆಳಗಿನ ವಸ್ತುಗಳನ್ನು ಉಲ್ಲೇಖಿಸಿ:
- ಮೈಕ್ರೋಸಾಫ್ಟ್‌ನ RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಸಾಧನಗಳು ML ಮಾದರಿಗಳನ್ನು ಡಿಬಗ್ ಮಾಡಲು: [Responsible AI tools resources](https://aka.ms/rai-dashboard)
- ಜವಾಬ್ದಾರಿಯುತ AI ಟೂಲ್‌ಕಿಟ್ ಅನ್ವೇಷಿಸಿ: [Github](https://github.com/microsoft/responsible-ai-toolbox)
- ಮೈಕ್ರೋಸಾಫ್ಟ್‌ನ RAI ಸಂಪನ್ಮೂಲ ಕೇಂದ್ರ: [Responsible AI Resources – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- ಮೈಕ್ರೋಸಾಫ್ಟ್‌ನ FATE ಸಂಶೋಧನಾ ಗುಂಪು: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
## ನಿಯೋಜನೆ
[RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ವೇಷಿಸಿ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/kn/9-Real-World/2-Debugging-ML-Models/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "91c6a180ef08e20cc15acfd2d6d6e164",
"translation_date": "2025-12-19T15:15:57+00:00",
"source_file": "9-Real-World/2-Debugging-ML-Models/assignment.md",
"language_code": "kn"
}
-->
# ಜವಾಬ್ದಾರಿಯುತ AI (RAI) ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ವೇಷಣೆ
## ಸೂಚನೆಗಳು
ಈ ಪಾಠದಲ್ಲಿ ನೀವು RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಬಗ್ಗೆ ಕಲಿತಿರಿ, ಇದು "ಮುಕ್ತ ಮೂಲ" ಸಾಧನಗಳ ಮೇಲೆ ನಿರ್ಮಿತ ಘಟಕಗಳ ಸರಣಿ ಆಗಿದ್ದು, ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳಿಗೆ AI ವ್ಯವಸ್ಥೆಗಳ ಮೇಲೆ ದೋಷ ವಿಶ್ಲೇಷಣೆ, ಡೇಟಾ ಅನ್ವೇಷಣೆ, ನ್ಯಾಯತೀರ್ಮಾನ ಮೌಲ್ಯಮಾಪನ, ಮಾದರಿ ವಿವರಣೆ, ಪ್ರತಿಕೂಲ/ಯಾವುದಾದರೂ-ಆಯ್ಕೆ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ಕಾರಣಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ ನಡೆಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ." ಈ ಕಾರ್ಯಕ್ಕಾಗಿ, RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಕೆಲವು ಮಾದರಿ [ನೋಟ್ಬುಕ್‌ಗಳು](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) ಅನ್ವೇಷಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಕಂಡುಹಿಡಿತಗಳನ್ನು ಒಂದು ಪತ್ರಿಕೆ ಅಥವಾ ಪ್ರಸ್ತುತಿಯಲ್ಲಿ ವರದಿ ಮಾಡಿ.
## ಮೌಲ್ಯಮಾಪನ ಮಾನದಂಡ
| ಮಾನದಂಡ | ಉದಾತ್ತ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆಯ ಅಗತ್ಯವಿದೆ |
| -------- | --------- | -------- | ----------------- |
| | RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಘಟಕಗಳು, ಚಾಲನೆಯಲ್ಲಿದ್ದ ನೋಟ್ಬುಕ್ ಮತ್ತು ಅದನ್ನು ಚಾಲನೆ ಮಾಡಿದ ನಂತರ ಪಡೆದ ನಿರ್ಣಯಗಳನ್ನು ಚರ್ಚಿಸುವ ಪತ್ರಿಕೆ ಅಥವಾ ಪವರ್‌ಪಾಯಿಂಟ್ ಪ್ರಸ್ತುತಿ ನೀಡಲಾಗಿದೆ | ನಿರ್ಣಯಗಳಿಲ್ಲದೆ ಪತ್ರಿಕೆ ನೀಡಲಾಗಿದೆ | ಯಾವುದೇ ಪತ್ರಿಕೆ ನೀಡಲಾಗಿಲ್ಲ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

34
translations/kn/9-Real-World/README.md
Unescape View File

@ -0,0 +1,34 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5e069a0ac02a9606a69946c2b3c574a9",
"translation_date": "2025-12-19T13:06:11+00:00",
"source_file": "9-Real-World/README.md",
"language_code": "kn"
}
-->
# ಪೋಸ್ಟ್‌ಸ್ಕ್ರಿಪ್ಟ್: ಕ್ಲಾಸಿಕ್ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್‌ನ ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳು
ಪಠ್ಯಕ್ರಮದ ಈ ವಿಭಾಗದಲ್ಲಿ, ನೀವು ಶ್ರೇಷ್ಟ ML ನ ಕೆಲವು ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳನ್ನು ಪರಿಚಯಿಸಿಕೊಳ್ಳುತ್ತೀರಿ. ನಾವು ಇಂಟರ್ನೆಟ್ ಅನ್ನು ಹುಡುಕಿ ಈ ತಂತ್ರಗಳನ್ನು ಬಳಸಿದ ಅನ್ವಯಿಕೆಗಳ ಬಗ್ಗೆ ಶ್ವೇತಪತ್ರಗಳು ಮತ್ತು ಲೇಖನಗಳನ್ನು ಕಂಡುಹಿಡಿದಿದ್ದೇವೆ, ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳು, ಡೀಪ್ ಲರ್ನಿಂಗ್ ಮತ್ತು AI ಅನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ತಪ್ಪಿಸಿ. ವ್ಯವಹಾರ ವ್ಯವಸ್ಥೆಗಳು, ಪರಿಸರ ಅನ್ವಯಿಕೆಗಳು, ಹಣಕಾಸು, ಕಲೆ ಮತ್ತು ಸಂಸ್ಕೃತಿ ಮತ್ತು ಇನ್ನಷ್ಟು ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ML ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯಿರಿ.
![chess](../../../translated_images/chess.e704a268781bdad85d1876b6c2295742fa0d856e7dcf3659147052df9d3db205.kn.jpg)
> ಫೋಟೋ <a href="https://unsplash.com/@childeye?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Alexis Fauvet</a> ಅವರಿಂದ <a href="https://unsplash.com/s/photos/artificial-intelligence?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a> ನಲ್ಲಿ
## ಪಾಠ
1. [ML ಗಾಗಿ ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳು](1-Applications/README.md)
2. [ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮೆಷಿನ್ ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ ಮಾದರಿ ಡಿಬಗಿಂಗ್](2-Debugging-ML-Models/README.md)
## ಕ್ರೆಡಿಟ್‌ಗಳು
"ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳು" ಅನ್ನು [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ಮತ್ತು [ಒರ್ನೆಲ್ಲಾ ಅಲ್ಟುನ್ಯಾನ್](https://twitter.com/ornelladotcom) ಸೇರಿದಂತೆ ತಂಡದವರು ಬರೆಯಲಾಗಿದೆ.
"ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮೆಷಿನ್ ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ ಮಾದರಿ ಡಿಬಗಿಂಗ್" ಅನ್ನು [ರೂತ್ ಯಾಕುಬು](https://twitter.com/ruthieyakubu) ಬರೆಯಲಾಗಿದೆ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

347
translations/kn/AGENTS.md
Unescape View File

@ -0,0 +1,347 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "93fdaa0fd38836e50c4793e2f2f25e8b",
"translation_date": "2025-12-19T12:42:40+00:00",
"source_file": "AGENTS.md",
"language_code": "kn"
}
-->
# AGENTS.md
## Project Overview
ಇದು **ಆರಂಭಿಕರಿಗಾಗಿ ಯಂತ್ರ ಅಧ್ಯಯನ**, ಪೈಥಾನ್ (ಮುಖ್ಯವಾಗಿ ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಬಳಸಿ) ಮತ್ತು R ಬಳಸಿ ಕ್ಲಾಸಿಕ್ ಯಂತ್ರ ಅಧ್ಯಯನ ತತ್ವಗಳನ್ನು ಒಳಗೊಂಡ 12 ವಾರಗಳ, 26 ಪಾಠಗಳ ಸಮಗ್ರ ಪಠ್ಯಕ್ರಮವಾಗಿದೆ. ಈ ರೆಪೊಸಿಟರಿ ಸ್ವಯಂ-ಗತಿಗತ ಅಧ್ಯಯನ ಸಂಪನ್ಮೂಲವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಕೈಯಿಂದ ಮಾಡುವ ಯೋಜನೆಗಳು, ಪ್ರಶ್ನೋತ್ತರಗಳು ಮತ್ತು ನಿಯೋಜನೆಗಳೊಂದಿಗೆ. ಪ್ರತಿ ಪಾಠವು ವಿಶ್ವದ ವಿವಿಧ ಸಂಸ್ಕೃತಿಗಳು ಮತ್ತು ಪ್ರದೇಶಗಳಿಂದ ನೈಜ-ಜಗತ್ತಿನ ಡೇಟಾ ಮೂಲಕ ಯಂತ್ರ ಅಧ್ಯಯನ ತತ್ವಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.
ಮುಖ್ಯ ಅಂಶಗಳು:
- **ಶೈಕ್ಷಣಿಕ ವಿಷಯ**: ಯಂತ್ರ ಅಧ್ಯಯನ ಪರಿಚಯ, ರಿಗ್ರೆಶನ್, ವರ್ಗೀಕರಣ, ಗುಂಪುಬದ್ಧತೆ, NLP, ಕಾಲ ಸರಣಿ, ಮತ್ತು ಬಲವರ್ಧಿತ ಅಧ್ಯಯನವನ್ನು ಒಳಗೊಂಡ 26 ಪಾಠಗಳು
- **ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್**: ಪೂರ್ವ ಮತ್ತು ನಂತರದ ಪಾಠ ಮೌಲ್ಯಮಾಪನಗಳೊಂದಿಗೆ Vue.js ಆಧಾರಿತ ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್
- **ಬಹುಭಾಷಾ ಬೆಂಬಲ**: GitHub Actions ಮೂಲಕ 40+ ಭಾಷೆಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳು
- **ದ್ವಿಭಾಷಾ ಬೆಂಬಲ**: ಪಾಠಗಳು ಪೈಥಾನ್ (ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್‌ಗಳು) ಮತ್ತು R (R ಮಾರ್ಕ್‌ಡೌನ್ ಫೈಲ್‌ಗಳು) ಎರಡಲ್ಲಿಯೂ ಲಭ್ಯವಿವೆ
- **ಯೋಜನೆ ಆಧಾರಿತ ಅಧ್ಯಯನ**: ಪ್ರತಿ ವಿಷಯದಲ್ಲಿ ಪ್ರಾಯೋಗಿಕ ಯೋಜನೆಗಳು ಮತ್ತು ನಿಯೋಜನೆಗಳಿವೆ
## Repository Structure
```
ML-For-Beginners/
├── 1-Introduction/ # ML basics, history, fairness, techniques
├── 2-Regression/ # Regression models with Python/R
├── 3-Web-App/ # Flask web app for ML model deployment
├── 4-Classification/ # Classification algorithms
├── 5-Clustering/ # Clustering techniques
├── 6-NLP/ # Natural Language Processing
├── 7-TimeSeries/ # Time series forecasting
├── 8-Reinforcement/ # Reinforcement learning
├── 9-Real-World/ # Real-world ML applications
├── quiz-app/ # Vue.js quiz application
├── translations/ # Auto-generated translations
└── sketchnotes/ # Visual learning aids
```
ಪ್ರತಿ ಪಾಠ ಫೋಲ್ಡರ್ ಸಾಮಾನ್ಯವಾಗಿ ಒಳಗೊಂಡಿರುತ್ತದೆ:
- `README.md` - ಮುಖ್ಯ ಪಾಠ ವಿಷಯ
- `notebook.ipynb` - ಪೈಥಾನ್ ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್
- `solution/` - ಪರಿಹಾರ ಕೋಡ್ (ಪೈಥಾನ್ ಮತ್ತು R ಆವೃತ್ತಿಗಳು)
- `assignment.md` - ಅಭ್ಯಾಸ ವ್ಯಾಯಾಮಗಳು
- `images/` - ದೃಶ್ಯ ಸಂಪನ್ಮೂಲಗಳು
## Setup Commands
### For Python Lessons
ಬಹುತೇಕ ಪಾಠಗಳು ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಅಗತ್ಯವಿರುವ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿ:
```bash
# ಈಗಾಗಲೇ ಸ್ಥಾಪಿಸಲಾಗದಿದ್ದರೆ Python 3.8+ ಅನ್ನು ಸ್ಥಾಪಿಸಿ
python --version
# Jupyter ಅನ್ನು ಸ್ಥಾಪಿಸಿ
pip install jupyter
# ಸಾಮಾನ್ಯ ML ಗ್ರಂಥಾಲಯಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
pip install scikit-learn pandas numpy matplotlib seaborn
# ನಿರ್ದಿಷ್ಟ ಪಾಠಗಳಿಗೆ, ಪಾಠ-ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಿ
# ಉದಾಹರಣೆ: ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಪಾಠ
pip install flask
```
### For R Lessons
R ಪಾಠಗಳು `solution/R/` ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ `.rmd` ಅಥವಾ `.ipynb` ಫೈಲ್‌ಗಳಾಗಿ ಇರುತ್ತವೆ:
```bash
# R ಮತ್ತು ಅಗತ್ಯ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
# R ಕಾನ್ಸೋಲ್‌ನಲ್ಲಿ:
install.packages(c("tidyverse", "tidymodels", "caret"))
```
### For Quiz Application
ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್ `quiz-app/` ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಇರುವ Vue.js ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ:
```bash
cd quiz-app
npm install
```
### For Documentation Site
ದಾಖಲೆಗಳನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಚಾಲನೆ ಮಾಡಲು:
```bash
# ಡಾಕ್ಸಿಫೈ ಅನ್ನು ಸ್ಥಾಪಿಸಿ
npm install -g docsify-cli
# ರೆಪೊಸಿಟರಿ ರೂಟ್‌ನಿಂದ ಸೇವೆ ನೀಡಿ
docsify serve
# http://localhost:3000 ನಲ್ಲಿ ಪ್ರವೇಶಿಸಿ
```
## Development Workflow
### Working with Lesson Notebooks
1. ಪಾಠ ಡೈರೆಕ್ಟರಿಗೆ ನಾವಿಗೇಟ್ ಮಾಡಿ (ಉದಾ: `2-Regression/1-Tools/`)
2. ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್ ತೆರೆಯಿರಿ:
```bash
jupyter notebook notebook.ipynb
```
3. ಪಾಠ ವಿಷಯ ಮತ್ತು ವ್ಯಾಯಾಮಗಳನ್ನು ಮಾಡಿ
4. ಅಗತ್ಯವಿದ್ದರೆ `solution/` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಪರಿಹಾರಗಳನ್ನು ಪರಿಶೀಲಿಸಿ
### Python Development
- ಪಾಠಗಳು ಸಾಮಾನ್ಯ ಪೈಥಾನ್ ಡೇಟಾ ಸೈನ್ಸ್ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುತ್ತವೆ
- ಸಂವಹನಾತ್ಮಕ ಅಧ್ಯಯನಕ್ಕಾಗಿ ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್‌ಗಳು
- ಪ್ರತಿ ಪಾಠದ `solution/` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಪರಿಹಾರ ಕೋಡ್ ಲಭ್ಯವಿದೆ
### R Development
- R ಪಾಠಗಳು `.rmd` ಫಾರ್ಮ್ಯಾಟ್ (R ಮಾರ್ಕ್‌ಡೌನ್)
- ಪರಿಹಾರಗಳು `solution/R/` ಉಪಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ ಇರುತ್ತವೆ
- R ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಚಾಲನೆ ಮಾಡಲು RStudio ಅಥವಾ R ಕರ್ಣಲ್ ಹೊಂದಿರುವ ಜುಪಿಟರ್ ಬಳಸಿ
### Quiz Application Development
```bash
cd quiz-app
# ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್ ಪ್ರಾರಂಭಿಸಿ
npm run serve
# http://localhost:8080 ನಲ್ಲಿ ಪ್ರವೇಶಿಸಿ
# ಉತ್ಪಾದನೆಗಾಗಿ ನಿರ್ಮಿಸಿ
npm run build
# ಲಿಂಟ್ ಮಾಡಿ ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ಸರಿಪಡಿಸಿ
npm run lint
```
## Testing Instructions
### Quiz Application Testing
```bash
cd quiz-app
# ಕೋಡ್ ಲಿಂಟ್ ಮಾಡಿ
npm run lint
# ದೋಷಗಳಿಲ್ಲದಿರುವುದನ್ನು ಪರಿಶೀಲಿಸಲು ನಿರ್ಮಿಸಿ
npm run build
```
**ಗಮನಿಸಿ**: ಇದು ಮುಖ್ಯವಾಗಿ ಶೈಕ್ಷಣಿಕ ಪಠ್ಯಕ್ರಮ ರೆಪೊಸಿಟರಿ. ಪಾಠ ವಿಷಯಕ್ಕೆ ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆಗಳು ಇಲ್ಲ. ಮಾನ್ಯತೆ ಈ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ:
- ಪಾಠ ವ್ಯಾಯಾಮಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ಮೂಲಕ
- ನೋಟ್ಬುಕ್ ಸೆಲ್‌ಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಚಾಲನೆ ಮಾಡುವ ಮೂಲಕ
- ಪರಿಹಾರಗಳಲ್ಲಿ ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಔಟ್‌ಪುಟ್ ಪರಿಶೀಲಿಸುವ ಮೂಲಕ
## Code Style Guidelines
### Python Code
- PEP 8 ಶೈಲಿ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ಅನುಸರಿಸಿ
- ಸ್ಪಷ್ಟ, ವಿವರಣಾತ್ಮಕ ಚರ ನಾಮಗಳನ್ನು ಬಳಸಿ
- ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸಿ
- ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್‌ಗಳಲ್ಲಿ ತತ್ವಗಳನ್ನು ವಿವರಿಸುವ ಮಾರ್ಕ್‌ಡೌನ್ ಸೆಲ್‌ಗಳು ಇರಬೇಕು
### JavaScript/Vue.js (Quiz App)
- Vue.js ಶೈಲಿ ಮಾರ್ಗಸೂಚಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ
- `quiz-app/package.json` ನಲ್ಲಿ ESLint ಸಂರಚನೆ
- ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸರಿಪಡಿಸಲು `npm run lint` ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ
### Documentation
- ಮಾರ್ಕ್‌ಡೌನ್ ಫೈಲ್‌ಗಳು ಸ್ಪಷ್ಟ ಮತ್ತು ಚೆನ್ನಾಗಿ ರಚಿಸಲ್ಪಟ್ಟಿರಬೇಕು
- ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಫೆನ್ಸ್ಡ್ ಕೋಡ್ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಸೇರಿಸಿ
- ಆಂತರಿಕ ಉಲ್ಲೇಖಗಳಿಗೆ ಸಂಬಂಧಿತ ಲಿಂಕ್‌ಗಳನ್ನು ಬಳಸಿ
- ಇತ್ತೀಚಿನ ಸ್ವರೂಪಣಾ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸಿ
## Build and Deployment
### Quiz Application Deployment
ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು Azure Static Web Apps ಗೆ ನಿಯೋಜಿಸಬಹುದು:
1. **ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು**:
- Azure ಖಾತೆ
- GitHub ರೆಪೊಸಿಟರಿ (ಹಾಗೂ ಫೋರ್ಕ್ ಮಾಡಲಾಗಿದೆ)
2. **Azure ಗೆ ನಿಯೋಜಿಸಿ**:
- Azure Static Web App ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಿ
- GitHub ರೆಪೊಸಿಟರಿಯನ್ನು ಸಂಪರ್ಕಿಸಿ
- ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಳವನ್ನು ಸೆಟ್ ಮಾಡಿ: `/quiz-app`
- ಔಟ್‌ಪುಟ್ ಸ್ಥಳವನ್ನು ಸೆಟ್ ಮಾಡಿ: `dist`
- Azure ಸ್ವಯಂಚಾಲಿತವಾಗಿ GitHub Actions ವರ್ಕ್‌ಫ್ಲೋ ರಚಿಸುತ್ತದೆ
3. **GitHub Actions Workflow**:
- `.github/workflows/azure-static-web-apps-*.yml` ನಲ್ಲಿ ವರ್ಕ್‌ಫ್ಲೋ ಫೈಲ್ ರಚಿಸಲಾಗಿದೆ
- ಮುಖ್ಯ ಶಾಖೆಗೆ ಪುಷ್ ಮಾಡಿದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ಮಿಸಿ ನಿಯೋಜಿಸುತ್ತದೆ
### Documentation PDF
ದಾಖಲೆಗಳಿಂದ PDF ರಚಿಸಿ:
```bash
npm install
npm run convert
```
## Translation Workflow
**ಮುಖ್ಯ**: ಅನುವಾದಗಳು GitHub Actions ಮೂಲಕ Co-op Translator ಬಳಸಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿವೆ.
- `main` ಶಾಖೆಗೆ ಬದಲಾವಣೆಗಳು ಪುಷ್ ಮಾಡಿದಾಗ ಅನುವಾದಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತವೆ
- **ವಿಷಯವನ್ನು ಕೈಯಿಂದ ಅನುವಾದಿಸಬೇಡಿ** - ವ್ಯವಸ್ಥೆ ಇದನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ
- `.github/workflows/co-op-translator.yml` ನಲ್ಲಿ ವರ್ಕ್‌ಫ್ಲೋ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
- ಅನುವಾದಕ್ಕೆ Azure AI/OpenAI ಸೇವೆಗಳನ್ನು ಬಳಸುತ್ತದೆ
- 40+ ಭಾಷೆಗಳಿಗೆ ಬೆಂಬಲ ನೀಡುತ್ತದೆ
## Contributing Guidelines
### For Content Contributors
1. **ರೆಪೊಸಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ** ಮತ್ತು ಫೀಚರ್ ಶಾಖೆಯನ್ನು ರಚಿಸಿ
2. **ಪಾಠ ವಿಷಯದಲ್ಲಿ ಬದಲಾವಣೆ ಮಾಡಿ** - ಹೊಸ ಪಾಠಗಳನ್ನು ಸೇರಿಸುವಾಗ ಅಥವಾ ನವೀಕರಿಸುವಾಗ
3. **ಅನುವಾದಿತ ಫೈಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಬೇಡಿ** - ಅವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲ್ಪಟ್ಟಿವೆ
4. **ನಿಮ್ಮ ಕೋಡ್ ಪರೀಕ್ಷಿಸಿ** - ಎಲ್ಲಾ ನೋಟ್ಬುಕ್ ಸೆಲ್‌ಗಳು ಯಶಸ್ವಿಯಾಗಿ ಚಾಲನೆ ಆಗುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
5. **ಲಿಂಕ್‌ಗಳು ಮತ್ತು ಚಿತ್ರಗಳು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ**
6. **ಸ್ಪಷ್ಟ ವಿವರಣೆಯೊಂದಿಗೆ ಪುಲ್ ರಿಕ್ವೆಸ್ಟ್ ಸಲ್ಲಿಸಿ**
### Pull Request Guidelines
- **ಶೀರ್ಷಿಕೆ ಸ್ವರೂಪ**: `[ವಿಭಾಗ] ಬದಲಾವಣೆಗಳ ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆ`
- ಉದಾ: `[Regression] ಪಾಠ 5 ರಲ್ಲಿ ಟೈಪೋ ಸರಿಪಡಿಸಿ`
- ಉದಾ: `[Quiz-App] ಅವಲಂಬನೆಗಳನ್ನು ನವೀಕರಿಸಿ`
- **ಸಲ್ಲಿಸುವ ಮೊದಲು**:
- ಎಲ್ಲಾ ನೋಟ್ಬುಕ್ ಸೆಲ್‌ಗಳು ದೋಷರಹಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
- ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್ ಬದಲಾಯಿಸಿದರೆ `npm run lint` ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ
- ಮಾರ್ಕ್‌ಡೌನ್ ಸ್ವರೂಪಣೆಯನ್ನು ಪರಿಶೀಲಿಸಿ
- ಯಾವುದೇ ಹೊಸ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ
- **PR ನಲ್ಲಿ ಇರಬೇಕಾದವು**:
- ಬದಲಾವಣೆಗಳ ವಿವರಣೆ
- ಬದಲಾವಣೆಗಳ ಕಾರಣ
- UI ಬದಲಾವಣೆಗಳಿದ್ದರೆ ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ಗಳು
- **ನಡವಳಿಕೆ ನಿಯಮಾವಳಿ**: [Microsoft Open Source Code of Conduct](CODE_OF_CONDUCT.md) ಅನುಸರಿಸಿ
- **CLA**: ನೀವು ಕೊಡುಗೆದಾರರ ಪರವಾನಗಿ ಒಪ್ಪಂದವನ್ನು ಸಹಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ
## Lesson Structure
ಪ್ರತಿ ಪಾಠವು ಸुसಂಯೋಜಿತ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ:
1. **ಪೂರ್ವ-ವಕ್ತೃತ್ವ ಪ್ರಶ್ನೋತ್ತರ** - ಮೂಲಭೂತ ಜ್ಞಾನವನ್ನು ಪರೀಕ್ಷಿಸಿ
2. **ಪಾಠ ವಿಷಯ** - ಬರಹದ ಸೂಚನೆಗಳು ಮತ್ತು ವಿವರಣೆಗಳು
3. **ಕೋಡ್ ಪ್ರದರ್ಶನಗಳು** - ನೋಟ್ಬುಕ್‌ಗಳಲ್ಲಿ ಕೈಯಿಂದ ಮಾಡುವ ಉದಾಹರಣೆಗಳು
4. **ಜ್ಞಾನ ಪರಿಶೀಲನೆಗಳು** - ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಪರಿಶೀಲನೆ
5. **ಸವಾಲು** - ತತ್ವಗಳನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಅನ್ವಯಿಸಿ
6. **ನಿಯೋಜನೆ** - ವಿಸ್ತೃತ ಅಭ್ಯಾಸ
7. **ಪೋಸ್ಟ್-ವಕ್ತೃತ್ವ ಪ್ರಶ್ನೋತ್ತರ** - ಅಧ್ಯಯನ ಫಲಿತಾಂಶಗಳನ್ನು ಅಳೆಯಿರಿ
## Common Commands Reference
```bash
# ಪೈಥಾನ್/ಜುಪಿಟರ್
jupyter notebook # ಜುಪಿಟರ್ ಸರ್ವರ್ ಪ್ರಾರಂಭಿಸಿ
jupyter notebook notebook.ipynb # ನಿರ್ದಿಷ್ಟ ನೋಟ್ಬುಕ್ ತೆರೆಯಿರಿ
pip install -r requirements.txt # ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿ (ಲಭ್ಯವಿದ್ದಲ್ಲಿ)
# ಕ್ವಿಜ್ ಅಪ್ಲಿಕೇಶನ್
cd quiz-app
npm install # ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
npm run serve # ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್
npm run build # ಉತ್ಪಾದನಾ ನಿರ್ಮಾಣ
npm run lint # ಲಿಂಟ್ ಮಾಡಿ ಮತ್ತು ಸರಿಪಡಿಸಿ
# ಡಾಕ್ಯುಮೆಂಟೇಶನ್
docsify serve # ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಸೇವೆ ಮಾಡಿ
npm run convert # PDF ರಚಿಸಿ
# ಗಿಟ್ ವರ್ಕ್‌ಫ್ಲೋ
git checkout -b feature/my-change # ವೈಶಿಷ್ಟ್ಯ ಶಾಖೆಯನ್ನು ರಚಿಸಿ
git add . # ಬದಲಾವಣೆಗಳನ್ನು ಹಂತಗೊಳಿಸಿ
git commit -m "Description" # ಬದಲಾವಣೆಗಳನ್ನು ಕಮಿಟ್ ಮಾಡಿ
git push origin feature/my-change # ರಿಮೋಟ್‌ಗೆ ಪುಷ್ ಮಾಡಿ
```
## Additional Resources
- **Microsoft Learn Collection**: [ML for Beginners modules](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
- **Quiz App**: [Online quizzes](https://ff-quizzes.netlify.app/en/ml/)
- **Discussion Board**: [GitHub Discussions](https://github.com/microsoft/ML-For-Beginners/discussions)
- **Video Walkthroughs**: [YouTube Playlist](https://aka.ms/ml-beginners-videos)
## Key Technologies
- **Python**: ಯಂತ್ರ ಅಧ್ಯಯನ ಪಾಠಗಳ ಪ್ರಮುಖ ಭಾಷೆ (ಸ್ಕಿಕಿಟ್-ಲರ್ನ್, ಪಾಂಡಾಸ್, ನಂಪೈ, ಮ್ಯಾಟ್‌ಪ್ಲಾಟ್‌ಲಿಬ್)
- **R**: tidyverse, tidymodels, caret ಬಳಸಿ ಪರ್ಯಾಯ ಅನುಷ್ಠಾನ
- **Jupyter**: ಪೈಥಾನ್ ಪಾಠಗಳಿಗಾಗಿ ಸಂವಹನಾತ್ಮಕ ನೋಟ್ಬುಕ್‌ಗಳು
- **R Markdown**: R ಪಾಠಗಳಿಗಾಗಿ ದಾಖಲೆಗಳು
- **Vue.js 3**: ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್ ಫ್ರೇಮ್ವರ್ಕ್
- **Flask**: ಯಂತ್ರ ಮಾದರಿ ನಿಯೋಜನೆಗಾಗಿ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಫ್ರೇಮ್ವರ್ಕ್
- **Docsify**: ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಸೈಟ್ ಜನರೇಟರ್
- **GitHub Actions**: ಸಿಐ/ಸಿಡಿ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳು
## Security Considerations
- **ಕೋಡ್‌ನಲ್ಲಿ ಯಾವುದೇ ರಹಸ್ಯಗಳಿಲ್ಲ**: API ಕೀಗಳು ಅಥವಾ ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ಎಂದಿಗೂ ಕಮಿಟ್ ಮಾಡಬೇಡಿ
- **ಅವಲಂಬನೆಗಳು**: npm ಮತ್ತು pip ಪ್ಯಾಕೇಜುಗಳನ್ನು ನವೀಕರಿಸಿ ಇಡಿ
- **ಬಳಕೆದಾರ ಇನ್‌ಪುಟ್**: Flask ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಮೂಲಭೂತ ಇನ್‌ಪುಟ್ ಮಾನ್ಯತೆ ಇದೆ
- **ಸೂಕ್ಷ್ಮ ಡೇಟಾ**: ಉದಾಹರಣಾ ಡೇಟಾಸೆಟ್‌ಗಳು ಸಾರ್ವಜನಿಕ ಮತ್ತು ಸೂಕ್ಷ್ಮವಲ್ಲ
## Troubleshooting
### Jupyter Notebooks
- **ಕರ್ಣಲ್ ಸಮಸ್ಯೆಗಳು**: ಸೆಲ್‌ಗಳು ಹ್ಯಾಂಗ್ ಆಗಿದ್ದರೆ ಕರ್ಣಲ್ ಮರುಪ್ರಾರಂಭಿಸಿ: Kernel → Restart
- **ಆಮದು ದೋಷಗಳು**: ಎಲ್ಲಾ ಅಗತ್ಯ ಪ್ಯಾಕೇಜುಗಳು pip ಮೂಲಕ ಸ್ಥಾಪಿತವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
- **ಪಥ ಸಮಸ್ಯೆಗಳು**: ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಅವುಗಳ ಒಳಗೊಂಡಿರುವ ಡೈರೆಕ್ಟರಿಯಿಂದ ಚಾಲನೆ ಮಾಡಿ
### Quiz Application
- **npm install ವಿಫಲ**: npm ಕ್ಯಾಶೆ ತೆರವುಗೊಳಿಸಿ: `npm cache clean --force`
- **ಪೋರ್ಟ್ ಸಂಘರ್ಷಗಳು**: ಪೋರ್ಟ್ ಬದಲಾಯಿಸಲು: `npm run serve -- --port 8081`
- **ನಿರ್ಮಾಣ ದೋಷಗಳು**: `node_modules` ಅಳಿಸಿ ಮತ್ತು ಮರುಸ್ಥಾಪಿಸಿ: `rm -rf node_modules && npm install`
### R Lessons
- **ಪ್ಯಾಕೇಜ್ ಸಿಗಲಿಲ್ಲ**: ಸ್ಥಾಪಿಸಲು: `install.packages("package-name")`
- **RMarkdown ರೆಂಡರಿಂಗ್**: rmarkdown ಪ್ಯಾಕೇಜ್ ಸ್ಥಾಪಿತವಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
- **ಕರ್ಣಲ್ ಸಮಸ್ಯೆಗಳು**: ಜುಪಿಟರ್‌ಗೆ IRkernel ಸ್ಥಾಪಿಸಬೇಕಾಗಬಹುದು
## Project-Specific Notes
- ಇದು ಮುಖ್ಯವಾಗಿ **ಅಧ್ಯಯನ ಪಠ್ಯಕ್ರಮ**, ಉತ್ಪಾದನಾ ಕೋಡ್ ಅಲ್ಲ
- ಕೈಯಿಂದ ಮಾಡುವ ಅಭ್ಯಾಸದ ಮೂಲಕ **ಯಂತ್ರ ಅಧ್ಯಯನ ತತ್ವಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ** ಮೇಲೆ ಗಮನ
- ಕೋಡ್ ಉದಾಹರಣೆಗಳು **ಸ್ಪಷ್ಟತೆಗಾಗಿ ಆದ್ಯತೆ ನೀಡಲಾಗಿದೆ**
- ಬಹುತೇಕ ಪಾಠಗಳು **ಸ್ವತಂತ್ರವಾಗಿವೆ** ಮತ್ತು ಸ್ವತಃ ಪೂರ್ಣಗೊಳ್ಳಬಹುದು
- **ಪರಿಹಾರಗಳು ಲಭ್ಯವಿವೆ**, ಆದರೆ ಕಲಿಯುವವರು ಮೊದಲು ವ್ಯಾಯಾಮಗಳನ್ನು ಪ್ರಯತ್ನಿಸಬೇಕು
- ರೆಪೊಸಿಟರಿ **Docsify** ಬಳಸಿ ವೆಬ್ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಹೊಂದಿದೆ, ನಿರ್ಮಾಣ ಹಂತವಿಲ್ಲದೆ
- **ಸ್ಕೆಚ್‌ನೋಟ್ಸ್** ತತ್ವಗಳ ದೃಶ್ಯ ಸಾರಾಂಶಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ
- **ಬಹುಭಾಷಾ ಬೆಂಬಲ** ವಿಷಯವನ್ನು ಜಾಗತಿಕವಾಗಿ ಲಭ್ಯವನ್ನಾಗಿಸುತ್ತದೆ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/kn/CODE_OF_CONDUCT.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
"translation_date": "2025-12-19T12:44:19+00:00",
"source_file": "CODE_OF_CONDUCT.md",
"language_code": "kn"
}
-->
# ಮೈಕ್ರೋಸಾಫ್ಟ್ ಓಪನ್ ಸೋರ್ಸ್ ನಡವಳಿಕೆ ಸಂಹಿತೆ
ಈ ಯೋಜನೆ [ಮೈಕ್ರೋಸಾಫ್ಟ್ ಓಪನ್ ಸೋರ್ಸ್ ನಡವಳಿಕೆ ಸಂಹಿತೆ](https://opensource.microsoft.com/codeofconduct/) ಅನ್ನು ಅಂಗೀಕರಿಸಿದೆ.
ಸಂಪನ್ಮೂಲಗಳು:
- [ಮೈಕ್ರೋಸಾಫ್ಟ್ ಓಪನ್ ಸೋರ್ಸ್ ನಡವಳಿಕೆ ಸಂಹಿತೆ](https://opensource.microsoft.com/codeofconduct/)
- [ಮೈಕ್ರೋಸಾಫ್ಟ್ ನಡವಳಿಕೆ ಸಂಹಿತೆ FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
- ಪ್ರಶ್ನೆಗಳು ಅಥವಾ ಚಿಂತೆಗಳಿಗಾಗಿ [opencode@microsoft.com](mailto:opencode@microsoft.com) ಸಂಪರ್ಕಿಸಿ
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

29
translations/kn/CONTRIBUTING.md
Unescape View File

@ -0,0 +1,29 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
"translation_date": "2025-12-19T12:28:04+00:00",
"source_file": "CONTRIBUTING.md",
"language_code": "kn"
}
-->
# ಕೊಡುಗೆ ನೀಡುವುದು
ಈ ಯೋಜನೆ ಕೊಡುಗೆಗಳು ಮತ್ತು ಸಲಹೆಗಳನ್ನು ಸ್ವಾಗತಿಸುತ್ತದೆ. ಬಹುತೇಕ ಕೊಡುಗೆಗಳಿಗೆ ನೀವು ಒಪ್ಪಿಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ
ನೀವು ನಿಮ್ಮ ಕೊಡುಗೆಯನ್ನು ಬಳಸಲು ಹಕ್ಕು ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ನಿಜವಾಗಿಯೂ ಹಕ್ಕುಗಳನ್ನು ನಮಗೆ ನೀಡುತ್ತೀರಿ ಎಂದು ಘೋಷಿಸುವ ಕೊಡುಗೆದಾರರ ಪರವಾನಗಿ ಒಪ್ಪಂದ (CLA). ವಿವರಗಳಿಗೆ ಭೇಟಿ ನೀಡಿ
https://cla.microsoft.com.
> ಮಹತ್ವದ ಮಾಹಿತಿ: ಈ ರೆಪೊದಲ್ಲಿ ಪಠ್ಯವನ್ನು ಅನುವಾದಿಸುವಾಗ, ದಯವಿಟ್ಟು ಯಂತ್ರ ಅನುವಾದವನ್ನು ಬಳಸಬೇಡಿ. ನಾವು ಸಮುದಾಯದ ಮೂಲಕ ಅನುವಾದಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದರಿಂದ, ದಯವಿಟ್ಟು ನೀವು ಪರಿಣತಿ ಹೊಂದಿರುವ ಭಾಷೆಗಳಲ್ಲಿ ಮಾತ್ರ ಅನುವಾದಗಳಿಗೆ ಸ್ವಯಂಸೇವಕನಾಗಿ ಸೇರಿ.
ನೀವು ಪುಲ್ ರಿಕ್ವೆಸ್ಟ್ ಸಲ್ಲಿಸಿದಾಗ, CLA-ಬಾಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನೀವು CLA ಒದಗಿಸಬೇಕೇ ಎಂದು ನಿರ್ಧರಿಸಿ PR ಅನ್ನು ಸೂಕ್ತವಾಗಿ ಅಲಂಕರಿಸುತ್ತದೆ (ಉದಾ: ಲೇಬಲ್, ಕಾಮೆಂಟ್). ಬಾಟ್ ನೀಡುವ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ. ನಮ್ಮ CLA ಬಳಸುವ ಎಲ್ಲಾ ರೆಪೊಗಳಲ್ಲಿಯೂ ನೀವು ಇದನ್ನು ಒಂದೇ ಬಾರಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಈ ಯೋಜನೆ [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/) ಅನ್ನು ಅಂಗೀಕರಿಸಿದೆ.
ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) ಅನ್ನು ನೋಡಿ
ಅಥವಾ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಪ್ರಶ್ನೆಗಳು ಅಥವಾ ಕಾಮೆಂಟ್‌ಗಳಿಗೆ [opencode@microsoft.com](mailto:opencode@microsoft.com) ಸಂಪರ್ಕಿಸಿ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

2840
translations/kn/PyTorch_Fundamentals.ipynb
View File

File diff suppressed because it is too large Load Diff

223
translations/kn/README.md
Unescape View File

@ -0,0 +1,223 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c300f2380d9da91b7de8c707f69ce99b",
"translation_date": "2025-12-19T12:54:04+00:00",
"source_file": "README.md",
"language_code": "kn"
}
-->
[![GitHub license](https://img.shields.io/github/license/microsoft/ML-For-Beginners.svg)](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)
[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)
[![GitHub issues](https://img.shields.io/github/issues/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/issues/)
[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/ML-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)
[![GitHub forks](https://img.shields.io/github/forks/microsoft/ML-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/ML-For-Beginners/network/)
[![GitHub stars](https://img.shields.io/github/stars/microsoft/ML-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
### 🌐 ಬಹುಭಾಷಾ ಬೆಂಬಲ
#### GitHub ಕ್ರಿಯೆಯಿಂದ ಬೆಂಬಲಿಸಲಾಗಿದೆ (ಸ್ವಯಂಚಾಲಿತ ಮತ್ತು ಸದಾ ನವೀಕರಿಸಲಾಗುತ್ತದೆ)
<!-- CO-OP TRANSLATOR LANGUAGES TABLE START -->
[Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh/README.md) | [Chinese (Traditional, Hong Kong)](../hk/README.md) | [Chinese (Traditional, Macau)](../mo/README.md) | [Chinese (Traditional, Taiwan)](../tw/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](../fr/README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](./README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](../ml/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../br/README.md) | [Portuguese (Portugal)](../pt/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](../te/README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md)
<!-- CO-OP TRANSLATOR LANGUAGES TABLE END -->
#### ನಮ್ಮ ಸಮುದಾಯದಲ್ಲಿ ಸೇರಿ
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
ನಾವು ಡಿಸ್ಕಾರ್ಡ್‌ನಲ್ಲಿ AI ಸರಣಿಯನ್ನು ನಡೆಸುತ್ತಿದ್ದೇವೆ, ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ಮತ್ತು ಸೇರಲು [Learn with AI Series](https://aka.ms/learnwithai/discord) ಗೆ 18 - 30 ಸೆಪ್ಟೆಂಬರ್, 2025 ರಂದು ಭೇಟಿ ನೀಡಿ. ನೀವು GitHub Copilot ಅನ್ನು ಡೇಟಾ ಸೈನ್ಸ್‌ಗಾಗಿ ಬಳಸುವ ಸಲಹೆಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ.
![Learn with AI series](../../translated_images/3.9b58fd8d6c373c20c588c5070c4948a826ab074426c28ceb5889641294373dfc.kn.png)
# ಆರಂಭಿಕರಿಗಾಗಿ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ - ಒಂದು ಪಠ್ಯಕ್ರಮ
> 🌍 ವಿಶ್ವದ ಸಾಂಸ್ಕೃತಿಕಗಳ ಮೂಲಕ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ಅನ್ನು ಅನ್ವೇಷಿಸುವಾಗ ಜಗತ್ತನ್ನು ಸುತ್ತಿ ಪ್ರಯಾಣ ಮಾಡಿ 🌍
Microsoft ನ ಕ್ಲೌಡ್ ಅಡ್ವೊಕೇಟ್ಸ್ 12 ವಾರಗಳ, 26 ಪಾಠಗಳ ಪಠ್ಯಕ್ರಮವನ್ನು **ಮೆಷಿನ್ ಲರ್ನಿಂಗ್** ಬಗ್ಗೆ ನೀಡಲು ಸಂತೋಷಪಡುತ್ತಾರೆ. ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ನೀವು ಕೆಲವೊಮ್ಮೆ **ಕ್ಲಾಸಿಕ್ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್** ಎಂದು ಕರೆಯಲ್ಪಡುವುದನ್ನು ಕಲಿಯುತ್ತೀರಿ, ಮುಖ್ಯವಾಗಿ Scikit-learn ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮತ್ತು ಡೀಪ್ ಲರ್ನಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸಿ, ಅದು ನಮ್ಮ [AI for Beginners' curriculum](https://aka.ms/ai4beginners) ನಲ್ಲಿ ಒಳಗೊಂಡಿದೆ. ಈ ಪಾಠಗಳನ್ನು ನಮ್ಮ ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners) ಜೊತೆಗೆ ಜೋಡಿಸಬಹುದು.
ನಮ್ಮೊಂದಿಗೆ ಜಗತ್ತಿನ ವಿವಿಧ ಭಾಗಗಳ ಡೇಟಾಗೆ ಈ ಕ್ಲಾಸಿಕ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸಿ ಪ್ರಯಾಣ ಮಾಡಿ. ಪ್ರತಿ ಪಾಠದಲ್ಲಿ ಪೂರ್ವ ಮತ್ತು ನಂತರದ ಪ್ರಶ್ನೋತ್ತರಗಳು, ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಬರಹದ ಸೂಚನೆಗಳು, ಪರಿಹಾರ, ನಿಯೋಜನೆ ಮತ್ತು ಇನ್ನಷ್ಟು ಒಳಗೊಂಡಿವೆ. ನಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಆಧಾರಿತ ಪಾಠಶೈಲಿ ನಿಮಗೆ ಕಲಿಯುವಾಗ ನಿರ್ಮಿಸುವ ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಇದು ಹೊಸ ಕೌಶಲ್ಯಗಳನ್ನು 'ಸ್ಥಿರ'ಗೊಳಿಸುವುದಕ್ಕೆ ಸಾಬೀತಾದ ವಿಧಾನವಾಗಿದೆ.
**✍️ ನಮ್ಮ ಲೇಖಕರಿಗೆ ಹೃತ್ಪೂರ್ವಕ ಧನ್ಯವಾದಗಳು** ಜೆನ್ ಲೂಪರ್, ಸ್ಟೀಫನ್ ಹೌವೆಲ್, ಫ್ರಾನ್ಸೆಸ್ಕಾ ಲಾಜ್ಜೇರಿ, ಟೊಮೊಮಿ ಇಮುರಾ, ಕ್ಯಾಸ್ ಬ್ರೇವಿಯು, ಡ್ಮಿತ್ರಿ ಸೋಶ್ನಿಕೋವ್, ಕ್ರಿಸ್ ನೋರಿಂಗ್, ಅನಿರ್ಬಾನ್ ಮುಖರ್ಜಿ, ಓರ್ನೆಲ್ಲಾ ಅಲ್ಟುನ್ಯಾನ್, ರೂತ್ ಯಾಕುಬು ಮತ್ತು ಎಮಿ ಬಾಯ್ಡ್
**🎨 ನಮ್ಮ ಚಿತ್ರಕಾರರಿಗೆ ಸಹ ಧನ್ಯವಾದಗಳು** ಟೊಮೊಮಿ ಇಮುರಾ, ದಾಸನಿ ಮಡಿಪಳ್ಳಿ, ಮತ್ತು ಜೆನ್ ಲೂಪರ್
**🙏 ವಿಶೇಷ ಧನ್ಯವಾದಗಳು 🙏 ನಮ್ಮ Microsoft ವಿದ್ಯಾರ್ಥಿ ಅಂಬಾಸಿಡರ್ ಲೇಖಕರು, ವಿಮರ್ಶಕರು ಮತ್ತು ವಿಷಯದ ಸಹಾಯಕರಿಗೆ**, ವಿಶೇಷವಾಗಿ ರಿಷಿತ್ ದಾಗ್ಲಿ, ಮುಹಮ್ಮದ್ ಸಕಿಬ್ ಖಾನ್ ಇನಾನ್, ರೋಹನ್ ರಾಜ್, ಅಲೆಕ್ಸಾಂಡ್ರು ಪೆಟ್ರೆಸ್ಕು, ಅಭಿಷೇಕ್ ಜೈಸ್ವಾಲ್, ನವ್ರಿನ್ ತಬಸ್ಸುಮ್, ಇವಾನ್ ಸಮುಯಿಲಾ, ಮತ್ತು ಸ್ನಿಗ್ಧಾ ಅಗರ್ವಾಲ್
**🤩 Microsoft ವಿದ್ಯಾರ್ಥಿ ಅಂಬಾಸಿಡರ್‌ಗಳು ಎರಿಕ್ ವಾಂಜೌ, ಜಸ್ಲೀನ್ ಸೊಂಡಿ, ಮತ್ತು ವಿದ್ಯುಷಿ ಗುಪ್ತ ಅವರಿಗೆ ನಮ್ಮ R ಪಾಠಗಳಿಗೆ ಹೆಚ್ಚುವರಿ ಕೃತಜ್ಞತೆ!**
# ಪ್ರಾರಂಭಿಸುವುದು
ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:
1. **ರಿಪೊಸಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ**: ಈ ಪುಟದ ಮೇಲ್ಭಾಗದ ಬಲಭಾಗದಲ್ಲಿರುವ "Fork" ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ.
2. **ರಿಪೊಸಿಟರಿಯನ್ನು ಕ್ಲೋನ್ ಮಾಡಿ**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
> [ಈ ಕೋರ್ಸ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಮ್ಮ Microsoft Learn ಸಂಗ್ರಹದಲ್ಲಿ ಕಂಡುಹಿಡಿಯಿರಿ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> 🔧 **ಸಹಾಯ ಬೇಕೇ?** ಸ್ಥಾಪನೆ, ಸೆಟಪ್ ಮತ್ತು ಪಾಠಗಳನ್ನು ನಡೆಸುವ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳ ಪರಿಹಾರಕ್ಕಾಗಿ ನಮ್ಮ [Troubleshooting Guide](TROUBLESHOOTING.md) ಅನ್ನು ಪರಿಶೀಲಿಸಿ.
**[ವಿದ್ಯಾರ್ಥಿಗಳು](https://aka.ms/student-page)**, ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ಬಳಸಲು, ಸಂಪೂರ್ಣ ರಿಪೊಸಿಟರಿಯನ್ನು ನಿಮ್ಮ GitHub ಖಾತೆಗೆ ಫೋರ್ಕ್ ಮಾಡಿ ಮತ್ತು ಸ್ವತಃ ಅಥವಾ ಗುಂಪಿನಲ್ಲಿ ವ್ಯಾಯಾಮಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ:
- ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರದಿಂದ ಪ್ರಾರಂಭಿಸಿ.
- ಪಾಠವನ್ನು ಓದಿ ಮತ್ತು ಚಟುವಟಿಕೆಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ, ಪ್ರತಿ ಜ್ಞಾನ ಪರಿಶೀಲನೆಯಲ್ಲಿ ನಿಲ್ಲಿಸಿ ಮತ್ತು ಪರಿಗಣಿಸಿ.
- ಪರಿಹಾರ ಕೋಡ್ ಅನ್ನು ನಡಿಸುವುದಕ್ಕಿಂತ ಪಾಠಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಪ್ರಾಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಪ್ರಯತ್ನಿಸಿ; ಆದಾಗ್ಯೂ ಆ ಕೋಡ್ ಪ್ರತಿ ಪ್ರಾಜೆಕ್ಟ್-ಆಧಾರಿತ ಪಾಠದ `/solution` ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ ಲಭ್ಯವಿದೆ.
- ಪಾಠದ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರವನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ.
- ಸವಾಲನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ.
- ನಿಯೋಜನೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ.
- ಪಾಠ ಗುಂಪನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, [ಚರ್ಚಾ ಮಂಡಳಿ](https://github.com/microsoft/ML-For-Beginners/discussions) ಗೆ ಭೇಟಿ ನೀಡಿ ಮತ್ತು ಸೂಕ್ತ PAT ರೂಬ್ರಿಕ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡಿ "ಮೌನವಾಗಿ ಕಲಿಯಿರಿ". 'PAT' ಎಂದರೆ ಪ್ರಗತಿ ಮೌಲ್ಯಮಾಪನ ಸಾಧನ, ಇದು ನಿಮ್ಮ ಕಲಿಕೆಯನ್ನು ಮುಂದುವರಿಸಲು ನೀವು ಭರ್ತಿ ಮಾಡುವ ರೂಬ್ರಿಕ್ ಆಗಿದೆ. ನೀವು ಇತರ PAT ಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆ ನೀಡಬಹುದು, ಹೀಗೆ ನಾವು ಒಟ್ಟಿಗೆ ಕಲಿಯಬಹುದು.
> ಹೆಚ್ಚಿನ ಅಧ್ಯಯನಕ್ಕಾಗಿ, ಈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) ಮಾಯಾಜಾಲಗಳು ಮತ್ತು ಕಲಿಕೆ ಮಾರ್ಗಗಳನ್ನು ಅನುಸರಿಸುವುದನ್ನು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.
**ಶಿಕ್ಷಕರು**, ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಬಗ್ಗೆ ನಾವು [ಕೆಲವು ಸಲಹೆಗಳನ್ನು](for-teachers.md) ಸೇರಿಸಿದ್ದೇವೆ.
---
## ವೀಡಿಯೋ ವಾಕ್ತ್ರೂಗಳು
ಕೆಲವು ಪಾಠಗಳು ಚಿಕ್ಕ ವೀಡಿಯೋ ರೂಪದಲ್ಲಿ ಲಭ್ಯವಿವೆ. ನೀವು ಈ ಎಲ್ಲವನ್ನು ಪಾಠಗಳಲ್ಲಿ ನೇರವಾಗಿ ಅಥವಾ [Microsoft Developer YouTube ಚಾನೆಲ್‌ನ ML for Beginners ಪ್ಲೇಲಿಸ್ಟ್](https://aka.ms/ml-beginners-videos) ನಲ್ಲಿ ಕೆಳಗಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ನೋಡಬಹುದು.
[![ML for beginners banner](../../translated_images/ml-for-beginners-video-banner.63f694a100034bc6251134294459696e070a3a9a04632e9fe6a24aa0de4a7384.kn.png)](https://aka.ms/ml-beginners-videos)
---
## ತಂಡವನ್ನು ಪರಿಚಯಿಸಿ
[![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)
**ಗಿಫ್** [ಮೊಹಿತ್ ಜೈಸಾಲ್](https://linkedin.com/in/mohitjaisal)
> 🎥 ಯೋಜನೆ ಮತ್ತು ಅದನ್ನು ರಚಿಸಿದ ಜನರ ಬಗ್ಗೆ ವೀಡಿಯೋಗಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ!
---
## ಪಾಠಶೈಲಿ
ನಾವು ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ರಚಿಸುವಾಗ ಎರಡು ಪಾಠಶೈಲಿ ತತ್ವಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿದ್ದೇವೆ: ಕೈಯಲ್ಲಿ ಮಾಡಬಹುದಾದ **ಪ್ರಾಜೆಕ್ಟ್ ಆಧಾರಿತ** ಮತ್ತು **ನಿರಂತರ ಪ್ರಶ್ನೋತ್ತರಗಳು**. ಜೊತೆಗೆ, ಈ ಪಠ್ಯಕ್ರಮಕ್ಕೆ ಸಾಮಾನ್ಯ **ಥೀಮ್** ಇದೆ, ಇದು ಅದಕ್ಕೆ ಸಮ್ಮಿಲನ ನೀಡುತ್ತದೆ.
ವಿಷಯವು ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವಂತೆ ನೋಡಿಕೊಳ್ಳುವುದರಿಂದ, ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಪ್ರಕ್ರಿಯೆ ಹೆಚ್ಚು ಆಕರ್ಷಕವಾಗುತ್ತದೆ ಮತ್ತು ಕಲಿಕೆಯ ಅರ್ಥಗಳು ಹೆಚ್ಚು ನೆನಪಿನಲ್ಲಿ ಉಳಿಯುತ್ತವೆ. ತರಗತಿಯ ಮುಂಚೆ ಕಡಿಮೆ ಒತ್ತಡದ ಪ್ರಶ್ನೋತ್ತರವು ವಿದ್ಯಾರ್ಥಿಯ ಕಲಿಕೆಯ ಉದ್ದೇಶವನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಮತ್ತು ತರಗತಿಯ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರವು ಇನ್ನಷ್ಟು ನೆನಪನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ಲವಚಿಕ ಮತ್ತು ಮನರಂಜನೀಯವಾಗಿರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಅಥವಾ ಭಾಗವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಸಣ್ಣದಾಗಿ ಪ್ರಾರಂಭಿಸಿ 12 ವಾರಗಳ ಅವಧಿಯ ಕೊನೆಯಲ್ಲಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗುತ್ತವೆ. ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ML ನ ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳ ಬಗ್ಗೆ ಒಂದು ಪೋಷಕ ಲೇಖನವೂ ಇದೆ, ಇದನ್ನು ಹೆಚ್ಚುವರಿ ಕ್ರೆಡಿಟ್ ಅಥವಾ ಚರ್ಚೆಯ ಆಧಾರವಾಗಿ ಬಳಸಬಹುದು.
> ನಮ್ಮ [ನಡವಳಿಕೆ ಸಂಹಿತೆ](CODE_OF_CONDUCT.md), [ಸಹಾಯ](CONTRIBUTING.md), [ಅನುವಾದ](TRANSLATIONS.md), ಮತ್ತು [ಸಮಸ್ಯೆ ಪರಿಹಾರ](TROUBLESHOOTING.md) ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ನೋಡಿ. ನಿಮ್ಮ ರಚನಾತ್ಮಕ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನಾವು ಸ್ವಾಗತಿಸುತ್ತೇವೆ!
## ಪ್ರತಿ ಪಾಠದಲ್ಲಿ ಒಳಗೊಂಡಿದೆ
- ಐಚ್ಛಿಕ ಸ್ಕೆಚ್ ನೋಟ್
- ಐಚ್ಛಿಕ ಪೂರಕ ವೀಡಿಯೋ
- ವೀಡಿಯೋ ವಾಕ್ತ್ರೂ (ಕೆಲವು ಪಾಠಗಳಿಗೆ ಮಾತ್ರ)
- [ಪೂರ್ವ-ಪಾಠ ತಯಾರಿ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
- ಬರಹದ ಪಾಠ
- ಪ್ರಾಜೆಕ್ಟ್ ಆಧಾರಿತ ಪಾಠಗಳಿಗೆ, ಪ್ರಾಜೆಕ್ಟ್ ನಿರ್ಮಿಸುವ ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿಗಳು
- ಜ್ಞಾನ ಪರಿಶೀಲನೆಗಳು
- ಸವಾಲು
- ಪೂರಕ ಓದು
- ನಿಯೋಜನೆ
- [ಪೋಸ್ಟ್-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
> **ಭಾಷೆಗಳ ಬಗ್ಗೆ ಟಿಪ್ಪಣಿ**: ಈ ಪಾಠಗಳು ಮುಖ್ಯವಾಗಿ Python ನಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿವೆ, ಆದರೆ ಅನೇಕವು R ನಲ್ಲಿ ಸಹ ಲಭ್ಯವಿವೆ. R ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು, `/solution` ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ R ಪಾಠಗಳನ್ನು ಹುಡುಕಿ. ಅವು .rmd ವಿಸ್ತರಣೆ ಹೊಂದಿವೆ, ಇದು **R Markdown** ಫೈಲ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು `code chunks` (R ಅಥವಾ ಇತರ ಭಾಷೆಗಳ) ಮತ್ತು `YAML header` (PDF ಮುಂತಾದ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಹೇಗೆ ರೂಪಿಸಬೇಕೆಂದು ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ) ಅನ್ನು Markdown ಡಾಕ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ಸಂಯೋಜಿಸುವುದಾಗಿದೆ. ಇದರಿಂದ ನೀವು ನಿಮ್ಮ ಕೋಡ್, ಅದರ ಔಟ್‌ಪುಟ್ ಮತ್ತು ನಿಮ್ಮ ಆಲೋಚನೆಗಳನ್ನು Markdown ನಲ್ಲಿ ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಜೊತೆಗೆ, R Markdown ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು PDF, HTML ಅಥವಾ Word ಮುಂತಾದ ಔಟ್‌ಪುಟ್‌ಗಳಿಗೆ ರೆಂಡರ್ ಮಾಡಬಹುದು.
> **ಪ್ರಶ್ನೋತ್ತರಗಳ ಬಗ್ಗೆ ಟಿಪ್ಪಣಿ**: ಎಲ್ಲಾ ಪ್ರಶ್ನೋತ್ತರಗಳು [Quiz App ಫೋಲ್ಡರ್](../../quiz-app) ನಲ್ಲಿ ಇವೆ, ಒಟ್ಟು 52 ಪ್ರಶ್ನೋತ್ತರಗಳಿವೆ, ಪ್ರತಿ ಒಂದು ಮೂರು ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ. ಅವು ಪಾಠಗಳಲ್ಲಿ ಲಿಂಕ್ ಮಾಡಲ್ಪಟ್ಟಿವೆ ಆದರೆ ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ನಡೆಸಬಹುದು; ಸ್ಥಳೀಯವಾಗಿ ಹೋಸ್ಟ್ ಮಾಡಲು ಅಥವಾ Azure ಗೆ ನಿಯೋಜಿಸಲು `quiz-app` ಫೋಲ್ಡರ್‌ನ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ.
| ಪಾಠ ಸಂಖ್ಯೆ | ವಿಷಯ | ಪಾಠ ಗುಂಪು | ಕಲಿಕೆಯ ಉದ್ದೇಶಗಳು | ಲಿಂಕ್ ಮಾಡಲಾದ ಪಾಠ | ಲೇಖಕ |
| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
| 01 | ಯಂತ್ರ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ | [Introduction](1-Introduction/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನದ ಮೂಲಭೂತ ತತ್ವಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ | [Lesson](1-Introduction/1-intro-to-ML/README.md) | ಮುಹಮ್ಮದ್ |
| 02 | ಯಂತ್ರ ಅಧ್ಯಯನದ ಇತಿಹಾಸ | [Introduction](1-Introduction/README.md) | ಈ ಕ್ಷೇತ್ರದ ಇತಿಹಾಸವನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ | [Lesson](1-Introduction/2-history-of-ML/README.md) | ಜೆನ್ ಮತ್ತು ಎಮಿ |
| 03 | ನ್ಯಾಯ ಮತ್ತು ಯಂತ್ರ ಅಧ್ಯಯನ | [Introduction](1-Introduction/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಮತ್ತು ಅನ್ವಯಿಸುವಾಗ ವಿದ್ಯಾರ್ಥಿಗಳು ಪರಿಗಣಿಸಬೇಕಾದ ನ್ಯಾಯದ ಪ್ರಮುಖ ತತ್ವಶಾಸ್ತ್ರೀಯ ವಿಷಯಗಳು ಯಾವುವು? | [Lesson](1-Introduction/3-fairness/README.md) | ಟೊಮೊಮಿ |
| 04 | ಯಂತ್ರ ಅಧ್ಯಯನ ತಂತ್ರಗಳು | [Introduction](1-Introduction/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನ ಸಂಶೋಧಕರು ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು ಯಾವ ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತಾರೆ? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | ಕ್ರಿಸ್ ಮತ್ತು ಜೆನ್ |
| 05 | ರಿಗ್ರೆಶನ್‌ಗೆ ಪರಿಚಯ | [Regression](2-Regression/README.md) | ರಿಗ್ರೆಶನ್ ಮಾದರಿಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಮತ್ತು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಬಳಸಿ ಪ್ರಾರಂಭಿಸಿ | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜೌ |
| 06 | ಉತ್ತರ ಅಮೆರಿಕದ ಕಂಬಳಿಯ ಬೆಲೆಗಳು 🎃 | [Regression](2-Regression/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನಕ್ಕೆ ಸಿದ್ಧತೆಗಾಗಿ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿ ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸಿ | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜೌ |
| 07 | ಉತ್ತರ ಅಮೆರಿಕದ ಕಂಬಳಿಯ ಬೆಲೆಗಳು 🎃 | [Regression](2-Regression/README.md) | ರೇಖೀಯ ಮತ್ತು ಬಹುಪದ ರಿಗ್ರೆಶನ್ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಿ | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | ಜೆನ್ ಮತ್ತು ಡ್ಮಿಟ್ರಿ • ಎರಿಕ್ ವಾಂಜೌ |
| 08 | ಉತ್ತರ ಅಮೆರಿಕದ ಕಂಬಳಿಯ ಬೆಲೆಗಳು 🎃 | [Regression](2-Regression/README.md) | ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜೌ |
| 09 | ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ 🔌 | [Web App](3-Web-App/README.md) | ನಿಮ್ಮ ತರಬೇತುಗೊಂಡ ಮಾದರಿಯನ್ನು ಬಳಸಲು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ | [Python](3-Web-App/1-Web-App/README.md) | ಜೆನ್ |
| 10 | ವರ್ಗೀಕರಣಕ್ಕೆ ಪರಿಚಯ | [Classification](4-Classification/README.md) | ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ, ಸಿದ್ಧಪಡಿಸಿ ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ; ವರ್ಗೀಕರಣಕ್ಕೆ ಪರಿಚಯ | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಶಿ • ಎರಿಕ್ ವಾಂಜೌ |
| 11 | ರುಚಿಕರ ಏಷ್ಯನ್ ಮತ್ತು ಭಾರತೀಯ ಆಹಾರಗಳು 🍜 | [Classification](4-Classification/README.md) | ವರ್ಗೀಕರಣಗಳ ಪರಿಚಯ | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಶಿ • ಎರಿಕ್ ವಾಂಜೌ |
| 12 | ರುಚಿಕರ ಏಷ್ಯನ್ ಮತ್ತು ಭಾರತೀಯ ಆಹಾರಗಳು 🍜 | [Classification](4-Classification/README.md) | ಇನ್ನಷ್ಟು ವರ್ಗೀಕರಣಗಳು | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಶಿ • ಎರಿಕ್ ವಾಂಜೌ |
| 13 | ರುಚಿಕರ ಏಷ್ಯನ್ ಮತ್ತು ಭಾರತೀಯ ಆಹಾರಗಳು 🍜 | [Classification](4-Classification/README.md) | ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಬಳಸಿ ಶಿಫಾರಸು ಮಾಡುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ | [Python](4-Classification/4-Applied/README.md) | ಜೆನ್ |
| 14 | ಕ್ಲಸ್ಟರಿಂಗ್‌ಗೆ ಪರಿಚಯ | [Clustering](5-Clustering/README.md) | ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ, ಸಿದ್ಧಪಡಿಸಿ ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ; ಕ್ಲಸ್ಟರಿಂಗ್‌ಗೆ ಪರಿಚಯ | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜೌ |
| 15 | ನೈಜೀರಿಯನ್ ಸಂಗೀತ ರುಚಿಗಳನ್ನು ಅನ್ವೇಷಣೆ 🎧 | [Clustering](5-Clustering/README.md) | ಕೆ-ಮೀನ್ಸ್ ಕ್ಲಸ್ಟರಿಂಗ್ ವಿಧಾನವನ್ನು ಅನ್ವೇಷಿಸಿ | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜೌ |
| 16 | ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆಗೆ ಪರಿಚಯ ☕️ | [Natural language processing](6-NLP/README.md) | ಸರಳ ಬಾಟ್ ನಿರ್ಮಿಸುವ ಮೂಲಕ NLP ಮೂಲಭೂತಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ | [Python](6-NLP/1-Introduction-to-NLP/README.md) | ಸ್ಟೀಫನ್ |
| 17 | ಸಾಮಾನ್ಯ NLP ಕಾರ್ಯಗಳು ☕️ | [Natural language processing](6-NLP/README.md) | ಭಾಷಾ ರಚನೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಅಗತ್ಯವಿರುವ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ನಿಮ್ಮ NLP ಜ್ಞಾನವನ್ನು ಗಾಢಗೊಳಿಸಿ | [Python](6-NLP/2-Tasks/README.md) | ಸ್ಟೀಫನ್ |
| 18 | ಅನುವಾದ ಮತ್ತು ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ ♥️ | [Natural language processing](6-NLP/README.md) | ಜೆನ್ ಆಸ್ಟಿನ್ ಅವರೊಂದಿಗೆ ಅನುವಾದ ಮತ್ತು ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ | [Python](6-NLP/3-Translation-Sentiment/README.md) | ಸ್ಟೀಫನ್ |
| 19 | ಯುರೋಪಿನ ರೋಮ್ಯಾಂಟಿಕ್ ಹೋಟೆಲ್ಗಳು ♥️ | [Natural language processing](6-NLP/README.md) | ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳೊಂದಿಗೆ ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | ಸ್ಟೀಫನ್ |
| 20 | ಯುರೋಪಿನ ರೋಮ್ಯಾಂಟಿಕ್ ಹೋಟೆಲ್ಗಳು ♥️ | [Natural language processing](6-NLP/README.md) | ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳೊಂದಿಗೆ ಭಾವನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | ಸ್ಟೀಫನ್ |
| 21 | ಕಾಲ ಸರಣಿಯ ಪೂರ್ವಾನುಮಾನಕ್ಕೆ ಪರಿಚಯ | [Time series](7-TimeSeries/README.md) | ಕಾಲ ಸರಣಿಯ ಪೂರ್ವಾನುಮಾನಕ್ಕೆ ಪರಿಚಯ | [Python](7-TimeSeries/1-Introduction/README.md) | ಫ್ರಾನ್ಸೆಸ್ಕಾ |
| 22 | ⚡️ ವಿಶ್ವ ವಿದ್ಯುತ್ ಬಳಕೆ ⚡️ - ARIMA ಬಳಸಿ ಕಾಲ ಸರಣಿ ಪೂರ್ವಾನುಮಾನ | [Time series](7-TimeSeries/README.md) | ARIMA ಬಳಸಿ ಕಾಲ ಸರಣಿ ಪೂರ್ವಾನುಮಾನ | [Python](7-TimeSeries/2-ARIMA/README.md) | ಫ್ರಾನ್ಸೆಸ್ಕಾ |
| 23 | ⚡️ ವಿಶ್ವ ವಿದ್ಯುತ್ ಬಳಕೆ ⚡️ - SVR ಬಳಸಿ ಕಾಲ ಸರಣಿ ಪೂರ್ವಾನುಮಾನ | [Time series](7-TimeSeries/README.md) | ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ರಿಗ್ರೆಶರ್ ಬಳಸಿ ಕಾಲ ಸರಣಿ ಪೂರ್ವಾನುಮಾನ | [Python](7-TimeSeries/3-SVR/README.md) | ಅನಿರ್ಬಾನ್ |
| 24 | ಬಲವರ್ಧನೆ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ | [Reinforcement learning](8-Reinforcement/README.md) | Q-ಲರ್ನಿಂಗ್ ಬಳಸಿ ಬಲವರ್ಧನೆ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ | [Python](8-Reinforcement/1-QLearning/README.md) | ಡ್ಮಿಟ್ರಿ |
| 25 | ಪೀಟರ್‌ನ್ನು ನರಿ ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡಿ! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | ಬಲವರ್ಧನೆ ಅಧ್ಯಯನ ಜಿಮ್ | [Python](8-Reinforcement/2-Gym/README.md) | ಡ್ಮಿಟ್ರಿ |
| Postscript | ನೈಜ ಜಗತ್ತಿನ ಯಂತ್ರ ಅಧ್ಯಯನ ದೃಶ್ಯಗಳು ಮತ್ತು ಅನ್ವಯಿಕೆಗಳು | [ML in the Wild](9-Real-World/README.md) | ಶ್ರೇಷ್ಟ ಯಂತ್ರ ಅಧ್ಯಯನದ ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಬಹಿರಂಗ ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳು | [Lesson](9-Real-World/1-Applications/README.md) | ತಂಡ |
| Postscript | RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಬಳಸಿ ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ಮಾದರಿ ಡಿಬಗಿಂಗ್ | [ML in the Wild](9-Real-World/README.md) | ಜವಾಬ್ದಾರಿಯುತ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳನ್ನು ಬಳಸಿ ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ಮಾದರಿ ಡಿಬಗಿಂಗ್ | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | ರುತ್ ಯಾಕುಬು |
> [ಈ ಕೋರ್ಸ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಮ್ಮ Microsoft Learn ಸಂಗ್ರಹದಲ್ಲಿ ಹುಡುಕಿ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## ಆಫ್‌ಲೈನ್ ಪ್ರವೇಶ
ನೀವು [Docsify](https://docsify.js.org/#/) ಬಳಸಿ ಈ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ಓಡಿಸಬಹುದು. ಈ ರೆಪೊವನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ, ನಿಮ್ಮ ಸ್ಥಳೀಯ ಯಂತ್ರದಲ್ಲಿ [Docsify ಅನ್ನು ಸ್ಥಾಪಿಸಿ](https://docsify.js.org/#/quickstart), ನಂತರ ಈ ರೆಪೊನ ರೂಟ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ `docsify serve` ಟೈಪ್ ಮಾಡಿ. ವೆಬ್‌ಸೈಟ್ ನಿಮ್ಮ ಲೋಕಲ್‌ಹೋಸ್ಟ್‌ನಲ್ಲಿ 3000 ಪೋರ್ಟ್‌ನಲ್ಲಿ ಸರ್ವ್ ಆಗುತ್ತದೆ: `localhost:3000`.
## PDF ಗಳು
ಲಿಂಕ್‌ಗಳೊಂದಿಗೆ ಪಠ್ಯಕ್ರಮದ PDF ಅನ್ನು [ಇಲ್ಲಿ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf) ಹುಡುಕಿ.
## 🎒 ಇತರೆ ಕೋರ್ಸ್‌ಗಳು
ನಮ್ಮ ತಂಡ ಇತರೆ ಕೋರ್ಸ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ! ಪರಿಶೀಲಿಸಿ:
<!-- CO-OP TRANSLATOR OTHER COURSES START -->
### ಲಾಂಗ್‌ಚೈನ್
[![LangChain4j for Beginners](https://img.shields.io/badge/LangChain4j%20for%20Beginners-22C55E?style=for-the-badge&&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchain4j-for-beginners)
[![LangChain.js for Beginners](https://img.shields.io/badge/LangChain.js%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
---
### ಅಜೂರ್ / ಎಡ್ಜ್ / MCP / ಏಜೆಂಟ್ಸ್
[![AZD for Beginners](https://img.shields.io/badge/AZD%20for%20Beginners-0078D4?style=for-the-badge&labelColor=E5E7EB&color=0078D4)](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Edge AI for Beginners](https://img.shields.io/badge/Edge%20AI%20for%20Beginners-00B8E4?style=for-the-badge&labelColor=E5E7EB&color=00B8E4)](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![MCP for Beginners](https://img.shields.io/badge/MCP%20for%20Beginners-009688?style=for-the-badge&labelColor=E5E7EB&color=009688)](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[![AI Agents for Beginners](https://img.shields.io/badge/AI%20Agents%20for%20Beginners-00C49A?style=for-the-badge&labelColor=E5E7EB&color=00C49A)](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### ಜನರೇಟಿವ್ AI ಸರಣಿ
[![Generative AI for Beginners](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Generative AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
[![ಜನರೇಟಿವ್ AI (ಜಾವಾ)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
[![ಜನರೇಟಿವ್ AI (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್)](https://img.shields.io/badge/Generative%20AI%20(JavaScript)-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
---
### ಮೂಲ ಅಧ್ಯಯನ
[![ಆರಂಭಿಕರಿಗಾಗಿ ಎಂಎಲ್](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[![ಆರಂಭಿಕರಿಗಾಗಿ ಡೇಟಾ ಸೈನ್ಸ್](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[![ಆರಂಭಿಕರಿಗಾಗಿ AI](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
[![ಆರಂಭಿಕರಿಗಾಗಿ ಸೈಬರ್‌ಸುರಕ್ಷತೆ](https://img.shields.io/badge/Cybersecurity%20for%20Beginners-F97316?style=for-the-badge&labelColor=E5E7EB&color=F97316)](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
[![ಆರಂಭಿಕರಿಗಾಗಿ ವೆಬ್ ಡೆವ್](https://img.shields.io/badge/Web%20Dev%20for%20Beginners-EC4899?style=for-the-badge&labelColor=E5E7EB&color=EC4899)](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
[![ಆರಂಭಿಕರಿಗಾಗಿ ಐಒಟಿ](https://img.shields.io/badge/IoT%20for%20Beginners-14B8A6?style=for-the-badge&labelColor=E5E7EB&color=14B8A6)](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
[![ಆರಂಭಿಕರಿಗಾಗಿ XR ಅಭಿವೃದ್ಧಿ](https://img.shields.io/badge/XR%20Development%20for%20Beginners-38BDF8?style=for-the-badge&labelColor=E5E7EB&color=38BDF8)](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### ಕೋಪೈಲಟ್ ಸರಣಿ
[![AI ಜೋಡಣೆಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ ಕೋಪೈಲಟ್](https://img.shields.io/badge/Copilot%20for%20AI%20Paired%20Programming-FACC15?style=for-the-badge&labelColor=E5E7EB&color=FACC15)](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[![C#/.NETಗಾಗಿ ಕೋಪೈಲಟ್](https://img.shields.io/badge/Copilot%20for%20C%23/.NET-FBBF24?style=for-the-badge&labelColor=E5E7EB&color=FBBF24)](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst)
[![ಕೋಪೈಲಟ್ ಸಾಹಸ](https://img.shields.io/badge/Copilot%20Adventure-FDE68A?style=for-the-badge&labelColor=E5E7EB&color=FDE68A)](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst)
<!-- CO-OP TRANSLATOR OTHER COURSES END -->
## ಸಹಾಯ ಪಡೆಯುವುದು
ನೀವು ಅಡಚಣೆಗೆ ಸಿಲುಕಿದರೆ ಅಥವಾ AI ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳಿದ್ದರೆ. MCP ಬಗ್ಗೆ ಚರ್ಚೆಗಳಲ್ಲಿ ಸಹಪಾಠಿಗಳು ಮತ್ತು ಅನುಭವಜ್ಞ ಡೆವಲಪರ್‌ಗಳೊಂದಿಗೆ ಸೇರಿ. ಇದು ಪ್ರಶ್ನೆಗಳಿಗೆ ಸ್ವಾಗತ ನೀಡುವ ಮತ್ತು ಜ್ಞಾನವನ್ನು ಮುಕ್ತವಾಗಿ ಹಂಚಿಕೊಳ್ಳುವ ಬೆಂಬಲದ ಸಮುದಾಯವಾಗಿದೆ.
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
ನೀವು ಉತ್ಪನ್ನ ಪ್ರತಿಕ್ರಿಯೆ ಅಥವಾ ನಿರ್ಮಾಣದ ವೇಳೆ ದೋಷಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಭೇಟಿ ನೀಡಿ:
[![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

53
translations/kn/SECURITY.md
Unescape View File

@ -0,0 +1,53 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
"translation_date": "2025-12-19T12:44:55+00:00",
"source_file": "SECURITY.md",
"language_code": "kn"
}
-->
## ಭದ್ರತೆ
ಮೈಕ್ರೋಸಾಫ್ಟ್ ನಮ್ಮ ಸಾಫ್ಟ್‌ವೇರ್ ಉತ್ಪನ್ನಗಳು ಮತ್ತು ಸೇವೆಗಳ ಭದ್ರತೆಯನ್ನು ಗಂಭೀರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಇದರಲ್ಲಿ ನಮ್ಮ GitHub ಸಂಸ್ಥೆಗಳ ಮೂಲಕ ನಿರ್ವಹಿಸಲಾದ ಎಲ್ಲಾ ಮೂಲ ಕೋಡ್ ಸಂಗ್ರಹಣೆಗಳು ಸೇರಿವೆ, ಅವುಗಳಲ್ಲಿ [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), ಮತ್ತು [ನಮ್ಮ GitHub ಸಂಸ್ಥೆಗಳು](https://opensource.microsoft.com/) ಸೇರಿವೆ.
ನೀವು ಯಾವುದೇ ಮೈಕ್ರೋಸಾಫ್ಟ್-ಸ್ವಂತ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ [ಮೈಕ್ರೋಸಾಫ್ಟ್ ಭದ್ರತಾ ದುರ್ಬಲತೆಯ ವ್ಯಾಖ್ಯಾನ](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott) ಪೂರೈಸುವ ಭದ್ರತಾ ದುರ್ಬಲತೆಯನ್ನು ಕಂಡುಹಿಡಿದಿದ್ದೀರಿ ಎಂದು ನಂಬಿದರೆ, ದಯವಿಟ್ಟು ಕೆಳಗಿನಂತೆ ನಮಗೆ ವರದಿ ಮಾಡಿ.
## ಭದ್ರತಾ ಸಮಸ್ಯೆಗಳ ವರದಿ
**ದಯವಿಟ್ಟು ಸಾರ್ವಜನಿಕ GitHub ಸಮಸ್ಯೆಗಳ ಮೂಲಕ ಭದ್ರತಾ ದುರ್ಬಲತೆಗಳನ್ನು ವರದಿ ಮಾಡಬೇಡಿ.**
ಬದಲಿಗೆ, ದಯವಿಟ್ಟು ಅವುಗಳನ್ನು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಭದ್ರತಾ ಪ್ರತಿಕ್ರಿಯಾ ಕೇಂದ್ರಕ್ಕೆ (MSRC) [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report) ನಲ್ಲಿ ವರದಿ ಮಾಡಿ.
ನೀವು ಲಾಗಿನ್ ಮಾಡದೆ ಸಲ್ಲಿಸಲು ಇಚ್ಛಿಸಿದರೆ, [secure@microsoft.com](mailto:secure@microsoft.com) ಗೆ ಇಮೇಲ್ ಕಳುಹಿಸಿ. ಸಾಧ್ಯವಾದರೆ, ನಮ್ಮ PGP ಕೀ ಬಳಸಿ ನಿಮ್ಮ ಸಂದೇಶವನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿ; ದಯವಿಟ್ಟು ಅದನ್ನು [Microsoft Security Response Center PGP Key ಪುಟ](https://www.microsoft.com/en-us/msrc/pgp-key-msrc) ನಿಂದ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.
ನೀವು 24 ಗಂಟೆಗಳ ಒಳಗೆ ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆಯಬೇಕು. ಯಾವುದೋ ಕಾರಣಕ್ಕಾಗಿ ನೀವು ಪಡೆಯದಿದ್ದರೆ, ದಯವಿಟ್ಟು ನಿಮ್ಮ ಮೂಲ ಸಂದೇಶವನ್ನು ನಾವು ಪಡೆದಿದ್ದೇವೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಇಮೇಲ್ ಮೂಲಕ ಅನುಸರಿಸಿ. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು [microsoft.com/msrc](https://www.microsoft.com/msrc) ನಲ್ಲಿ ಕಾಣಬಹುದು.
ದಯವಿಟ್ಟು ಕೆಳಗಿನ ವಿನಂತಿಸಿದ ಮಾಹಿತಿಯನ್ನು (ನೀವು ನೀಡಬಹುದಾದಷ್ಟು) ಸೇರಿಸಿ, ಇದರಿಂದ ನಾವು ಸಾಧ್ಯವಾದ ಸಮಸ್ಯೆಯ ಸ್ವಭಾವ ಮತ್ತು ವ್ಯಾಪ್ತಿಯನ್ನು ಉತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯವಾಗುತ್ತದೆ:
* ಸಮಸ್ಯೆಯ ಪ್ರಕಾರ (ಉದಾ. ಬಫರ್ ಓವರ್‌ಫ್ಲೋ, SQL ಇಂಜೆಕ್ಷನ್, ಕ್ರಾಸ್-ಸೈಟ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್, ಇತ್ಯಾದಿ)
* ಸಮಸ್ಯೆಯ ಪ್ರತ್ಯಕ್ಷತೆಯೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಮೂಲ ಫೈಲ್‌ಗಳ ಸಂಪೂರ್ಣ ಮಾರ್ಗಗಳು
* ಪ್ರಭಾವಿತ ಮೂಲ ಕೋಡ್‌ನ ಸ್ಥಳ (ಟ್ಯಾಗ್/ಬ್ರಾಂಚ್/ಕಮಿಟ್ ಅಥವಾ ನೇರ URL)
* ಸಮಸ್ಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಲು ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ವಿಶೇಷ ಸಂರಚನೆ
* ಸಮಸ್ಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಲು ಹಂತ ಹಂತದ ಸೂಚನೆಗಳು
* ಸಾಬೀತು-ಆಫ್-ಕಾನ್ಸೆಪ್ಟ್ ಅಥವಾ ಎಕ್ಸ್‌ಪ್ಲಾಯಿಟ್ ಕೋಡ್ (ಸಾಧ್ಯವಾದರೆ)
* ಸಮಸ್ಯೆಯ ಪ್ರಭಾವ, ಮತ್ತು ಹೇಗೆ ಹ್ಯಾಕರ್ ಅದನ್ನು ದುರುಪಯೋಗ ಮಾಡಬಹುದು ಎಂಬುದು
ಈ ಮಾಹಿತಿ ನಿಮ್ಮ ವರದಿಯನ್ನು ವೇಗವಾಗಿ ಪರಿಶೀಲಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ನೀವು ಬಗ್ ಬೌಂಟಿಗಾಗಿ ವರದಿ ಮಾಡುತ್ತಿದ್ದರೆ, ಹೆಚ್ಚಿನ ಸಂಪೂರ್ಣ ವರದಿಗಳು ಹೆಚ್ಚಿನ ಬೌಂಟಿ ಬಹುಮಾನಕ್ಕೆ ಸಹಾಯ ಮಾಡಬಹುದು. ದಯವಿಟ್ಟು ನಮ್ಮ [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) ಪುಟವನ್ನು ನಮ್ಮ ಸಕ್ರಿಯ ಕಾರ್ಯಕ್ರಮಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗೆ ಭೇಟಿ ನೀಡಿ.
## ಇಚ್ಛಿತ ಭಾಷೆಗಳು
ನಾವು ಎಲ್ಲಾ ಸಂವಹನಗಳು ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಇರಬೇಕೆಂದು ಇಚ್ಛಿಸುತ್ತೇವೆ.
## ನೀತಿ
ಮೈಕ್ರೋಸಾಫ್ಟ್ [ಸಂಯೋಜಿತ ದುರ್ಬಲತೆ ಬಹಿರಂಗಪಡಿಸುವಿಕೆ](https://www.microsoft.com/en-us/msrc/cvd) ತತ್ವವನ್ನು ಅನುಸರಿಸುತ್ತದೆ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

31
translations/kn/SUPPORT.md
Unescape View File

@ -0,0 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "09623d7343ff1c26ff4f198c1b2d3176",
"translation_date": "2025-12-19T12:27:38+00:00",
"source_file": "SUPPORT.md",
"language_code": "kn"
}
-->
# ಬೆಂಬಲ
## ಸಮಸ್ಯೆಗಳನ್ನು ದಾಖಲಿಸುವುದು ಮತ್ತು ಸಹಾಯ ಪಡೆಯುವುದು ಹೇಗೆ
ಸಮಸ್ಯೆಯನ್ನು ದಾಖಲಿಸುವ ಮೊದಲು, ದಯವಿಟ್ಟು ನಮ್ಮ [ತೊಂದರೆ ಪರಿಹಾರ ಮಾರ್ಗದರ್ಶಿ](TROUBLESHOOTING.md) ಅನ್ನು ಪರಿಶೀಲಿಸಿ, ಸ್ಥಾಪನೆ, ಸೆಟ್‌ಅಪ್ ಮತ್ತು ಪಾಠಗಳನ್ನು ನಡೆಸುವ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳ ಪರಿಹಾರಗಳಿಗಾಗಿ.
ಈ ಯೋಜನೆ ಬಗ್‌ಗಳು ಮತ್ತು ವೈಶಿಷ್ಟ್ಯ ವಿನಂತಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು GitHub Issues ಅನ್ನು ಬಳಸುತ್ತದೆ. ನಕಲು ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ದಯವಿಟ್ಟು ಹೊಸ ಸಮಸ್ಯೆಗಳನ್ನು ದಾಖಲಿಸುವ ಮೊದಲು ಇತ್ತೀಚಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಹುಡುಕಿ. ಹೊಸ ಸಮಸ್ಯೆಗಳಿಗೆ, ನಿಮ್ಮ ಬಗ್ ಅಥವಾ ವೈಶಿಷ್ಟ್ಯ ವಿನಂತಿಯನ್ನು ಹೊಸ ಸಮಸ್ಯೆಯಾಗಿ ದಾಖಲಿಸಿ.
ಈ ಯೋಜನೆಯನ್ನು ಬಳಸುವ ಬಗ್ಗೆ ಸಹಾಯ ಮತ್ತು ಪ್ರಶ್ನೆಗಳಿಗಾಗಿ, ನೀವು ಕೂಡಾ:
- [ತೊಂದರೆ ಪರಿಹಾರ ಮಾರ್ಗದರ್ಶಿ](TROUBLESHOOTING.md) ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು
- ನಮ್ಮ [Discord ಚರ್ಚೆಗಳು #ml-for-beginners ಚಾನೆಲ್](https://aka.ms/foundry/discord) ಗೆ ಭೇಟಿ ನೀಡಿ
- ಸಮಸ್ಯೆಯನ್ನು ದಾಖಲಿಸಿ
## ಮೈಕ್ರೋಸಾಫ್ಟ್ ಬೆಂಬಲ ನೀತಿ
ಈ ಸಂಗ್ರಹಣೆಗೆ ಬೆಂಬಲವು ಮೇಲ್ಕಂಡ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಮಾತ್ರ ಸೀಮಿತವಾಗಿದೆ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

612
translations/kn/TROUBLESHOOTING.md
Unescape View File

@ -0,0 +1,612 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "134d8759f0e2ab886e9aa4f62362c201",
"translation_date": "2025-12-19T12:36:23+00:00",
"source_file": "TROUBLESHOOTING.md",
"language_code": "kn"
}
-->
# ಸಮಸ್ಯೆ ಪರಿಹಾರ ಮಾರ್ಗದರ್ಶಿ
ಈ ಮಾರ್ಗದರ್ಶಿ ಯಂತ್ರ ಅಧ್ಯಯನ ಆರಂಭಿಕರ ಪಠ್ಯಕ್ರಮದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನೀವು ಇಲ್ಲಿ ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಳ್ಳದಿದ್ದರೆ, ದಯವಿಟ್ಟು ನಮ್ಮ [Discord ಚರ್ಚೆಗಳು](https://aka.ms/foundry/discord) ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಅಥವಾ [ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ತೆರೆಯಿರಿ](https://github.com/microsoft/ML-For-Beginners/issues).
## ವಿಷಯಗಳ ಪಟ್ಟಿಕೆ
- [ಸ್ಥಾಪನೆ ಸಮಸ್ಯೆಗಳು](../..)
- [ಜುಪೈಟರ್ ನೋಟ್ಬುಕ್ ಸಮಸ್ಯೆಗಳು](../..)
- [ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಸಮಸ್ಯೆಗಳು](../..)
- [R ಪರಿಸರ ಸಮಸ್ಯೆಗಳು](../..)
- [ಕ್ವಿಜ್ ಅಪ್ಲಿಕೇಶನ್ ಸಮಸ್ಯೆಗಳು](../..)
- [ಡೇಟಾ ಮತ್ತು ಫೈಲ್ ಪಥ ಸಮಸ್ಯೆಗಳು](../..)
- [ಸಾಮಾನ್ಯ ದೋಷ ಸಂದೇಶಗಳು](../..)
- [ಕಾರ್ಯಕ್ಷಮತೆ ಸಮಸ್ಯೆಗಳು](../..)
- [ಪರಿಸರ ಮತ್ತು ಸಂರಚನೆ](../..)
---
## ಸ್ಥಾಪನೆ ಸಮಸ್ಯೆಗಳು
### ಪೈಥಾನ್ ಸ್ಥಾಪನೆ
**ಸಮಸ್ಯೆ**: `python: command not found`
**ಪರಿಹಾರ**:
1. [python.org](https://www.python.org/downloads/) ನಿಂದ Python 3.8 ಅಥವಾ ಹೆಚ್ಚಿನ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸಿ
2. ಸ್ಥಾಪನೆ ಪರಿಶೀಲಿಸಿ: `python --version` ಅಥವಾ `python3 --version`
3. macOS/Linux ನಲ್ಲಿ, `python` ಬದಲು `python3` ಬಳಸಬೇಕಾಗಬಹುದು
**ಸಮಸ್ಯೆ**: ಬಹು ಪೈಥಾನ್ ಆವೃತ್ತಿಗಳು ಸಂಘರ್ಷ ಉಂಟುಮಾಡುತ್ತಿವೆ
**ಪರಿಹಾರ**:
```bash
# ಪ್ರಾಜೆಕ್ಟ್‌ಗಳನ್ನು ವಿಭಜಿಸಲು ವರ್ಚುವಲ್ ಪರಿಸರಗಳನ್ನು ಬಳಸಿ
python -m venv ml-env
# ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ
# ವಿಂಡೋಸ್‌ನಲ್ಲಿ:
ml-env\Scripts\activate
# ಮ್ಯಾಕ್‌ಒಎಸ್/ಲಿನಕ್ಸ್ನಲ್ಲಿ:
source ml-env/bin/activate
```
### ಜುಪೈಟರ್ ಸ್ಥಾಪನೆ
**ಸಮಸ್ಯೆ**: `jupyter: command not found`
**ಪರಿಹಾರ**:
```bash
# ಜುಪೈಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ
pip install jupyter
# ಅಥವಾ pip3 ಬಳಸಿ
pip3 install jupyter
# ಸ್ಥಾಪನೆಯನ್ನು ಪರಿಶೀಲಿಸಿ
jupyter --version
```
**ಸಮಸ್ಯೆ**: ಜುಪೈಟರ್ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```bash
# ಬ್ರೌಸರ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಿ
jupyter notebook --browser=chrome
# ಅಥವಾ ಟರ್ಮಿನಲ್‌ನಿಂದ ಟೋಕನ್ ಹೊಂದಿರುವ URL ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಕೈಯಿಂದ ಅಂಟಿಸಿ
# ಹುಡುಕಿ: http://localhost:8888/?token=...
```
### R ಸ್ಥಾಪನೆ
**ಸಮಸ್ಯೆ**: R ಪ್ಯಾಕೇಜ್‌ಗಳು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```r
# ನೀವು ಇತ್ತೀಚಿನ R ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
# ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
install.packages(c("tidyverse", "tidymodels", "caret"), dependencies = TRUE)
# ಸಂಯೋಜನೆ ವಿಫಲವಾದರೆ, ಬೈನರಿ ಆವೃತ್ತಿಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಪ್ರಯತ್ನಿಸಿ
install.packages("package-name", type = "binary")
```
**ಸಮಸ್ಯೆ**: IRkernel ಜುಪೈಟರ್‌ನಲ್ಲಿ ಲಭ್ಯವಿಲ್ಲ
**ಪರಿಹಾರ**:
```r
# R ಕಾನ್ಸೋಲ್‌ನಲ್ಲಿ
install.packages('IRkernel')
IRkernel::installspec(user = TRUE)
```
---
## ಜುಪೈಟರ್ ನೋಟ್ಬುಕ್ ಸಮಸ್ಯೆಗಳು
### ಕರ್ಣಲ್ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: ಕರ್ಣಲ್ ನಿರಂತರವಾಗಿ ಸಾಯುತ್ತಿದೆ ಅಥವಾ ಮರುಪ್ರಾರಂಭವಾಗುತ್ತಿದೆ
**ಪರಿಹಾರ**:
1. ಕರ್ಣಲ್ ಮರುಪ್ರಾರಂಭಿಸಿ: `Kernel → Restart`
2. ಔಟ್‌ಪುಟ್ ತೆರವುಗೊಳಿಸಿ ಮತ್ತು ಮರುಪ್ರಾರಂಭಿಸಿ: `Kernel → Restart & Clear Output`
3. ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ([ಕಾರ್ಯಕ್ಷಮತೆ ಸಮಸ್ಯೆಗಳು](../..) ನೋಡಿ)
4. ಸಮಸ್ಯೆ ಇರುವ ಕೋಡ್ ಗುರುತಿಸಲು ಸೆಲ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಚಾಲನೆ ಮಾಡಿ
**ಸಮಸ್ಯೆ**: ತಪ್ಪು ಪೈಥಾನ್ ಕರ್ಣಲ್ ಆಯ್ಕೆಮಾಡಲಾಗಿದೆ
**ಪರಿಹಾರ**:
1. ಪ್ರಸ್ತುತ ಕರ್ಣಲ್ ಪರಿಶೀಲಿಸಿ: `Kernel → Change Kernel`
2. ಸರಿಯಾದ ಪೈಥಾನ್ ಆವೃತ್ತಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ
3. ಕರ್ಣಲ್ ಇಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ರಚಿಸಿ:
```bash
python -m ipykernel install --user --name=ml-env
```
**ಸಮಸ್ಯೆ**: ಕರ್ಣಲ್ ಪ್ರಾರಂಭವಾಗುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```bash
# ipykernel ಅನ್ನು ಮರುಸ್ಥಾಪಿಸಿ
pip uninstall ipykernel
pip install ipykernel
# ಕರ್ಣಲ್ ಅನ್ನು ಮತ್ತೆ ನೋಂದಣಿ ಮಾಡಿ
python -m ipykernel install --user
```
### ನೋಟ್ಬುಕ್ ಸೆಲ್ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: ಸೆಲ್‌ಗಳು ಚಾಲನೆ ಆಗುತ್ತಿವೆ ಆದರೆ ಔಟ್‌ಪುಟ್ ತೋರಿಸುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
1. ಸೆಲ್ ಇನ್ನೂ ಚಾಲನೆ ಆಗುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ (`[*]` ಸೂಚಕ ನೋಡಿ)
2. ಕರ್ಣಲ್ ಮರುಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಎಲ್ಲಾ ಸೆಲ್‌ಗಳನ್ನು ಚಾಲನೆ ಮಾಡಿ: `Kernel → Restart & Run All`
3. ಬ್ರೌಸರ್ ಕಾನ್ಸೋಲ್‌ನಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳನ್ನು ಪರಿಶೀಲಿಸಿ (F12)
**ಸಮಸ್ಯೆ**: ಸೆಲ್‌ಗಳನ್ನು ಚಾಲನೆ ಮಾಡಲಾಗುತ್ತಿಲ್ಲ - "Run" ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಪ್ರತಿಕ್ರಿಯೆ ಇಲ್ಲ
**ಪರಿಹಾರ**:
1. ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಜುಪೈಟರ್ ಸರ್ವರ್ ಇನ್ನೂ ಚಾಲನೆ ಆಗುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
2. ಬ್ರೌಸರ್ ಪುಟವನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡಿ
3. ನೋಟ್ಬುಕ್ ಅನ್ನು ಮುಚ್ಚಿ ಮತ್ತೆ ತೆರೆಯಿರಿ
4. ಜುಪೈಟರ್ ಸರ್ವರ್ ಮರುಪ್ರಾರಂಭಿಸಿ
---
## ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಸಮಸ್ಯೆಗಳು
### ಆಮದು ದೋಷಗಳು
**ಸಮಸ್ಯೆ**: `ModuleNotFoundError: No module named 'sklearn'`
**ಪರಿಹಾರ**:
```bash
pip install scikit-learn
# ಈ ಕೋರ್ಸ್‌ಗೆ ಸಾಮಾನ್ಯ ML ಪ್ಯಾಕೇಜುಗಳು
pip install scikit-learn pandas numpy matplotlib seaborn
```
**ಸಮಸ್ಯೆ**: `ImportError: cannot import name 'X' from 'sklearn'`
**ಪರಿಹಾರ**:
```bash
# scikit-learn ಅನ್ನು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗೆ ನವೀಕರಿಸಿ
pip install --upgrade scikit-learn
# ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
python -c "import sklearn; print(sklearn.__version__)"
```
### ಆವೃತ್ತಿ ಸಂಘರ್ಷಗಳು
**ಸಮಸ್ಯೆ**: ಪ್ಯಾಕೇಜ್ ಆವೃತ್ತಿ ಅಸಂಗತ ದೋಷಗಳು
**ಪರಿಹಾರ**:
```bash
# ಹೊಸ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಿ
python -m venv fresh-env
source fresh-env/bin/activate # ಅಥವಾ Windows ನಲ್ಲಿ fresh-env\Scripts\activate
# ಪ್ಯಾಕೇಜುಗಳನ್ನು ಹೊಸದಾಗಿ ಸ್ಥಾಪಿಸಿ
pip install jupyter scikit-learn pandas numpy matplotlib seaborn
# ನಿರ್ದಿಷ್ಟ ಆವೃತ್ತಿ ಬೇಕಾದರೆ
pip install scikit-learn==1.3.0
```
**ಸಮಸ್ಯೆ**: `pip install` ಅನುಮತಿ ದೋಷಗಳೊಂದಿಗೆ ವಿಫಲವಾಗಿದೆ
**ಪರಿಹಾರ**:
```bash
# ಪ್ರಸ್ತುತ ಬಳಕೆದಾರನಿಗಾಗಿ ಮಾತ್ರ ಸ್ಥಾಪಿಸಿ
pip install --user package-name
# ಅಥವಾ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಬಳಸಿ (ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ)
python -m venv venv
source venv/bin/activate
pip install package-name
```
### ಡೇಟಾ ಲೋಡಿಂಗ್ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: CSV ಫೈಲ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ `FileNotFoundError`
**ಪರಿಹಾರ**:
```python
import os
# ಪ್ರಸ್ತುತ ಕಾರ್ಯನಿರ್ವಹಣಾ ಡೈರೆಕ್ಟರಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
print(os.getcwd())
# ನೋಟ್ಬುಕ್ ಸ್ಥಳದಿಂದ ಸಂಬಂಧಿತ ಮಾರ್ಗಗಳನ್ನು ಬಳಸಿ
df = pd.read_csv('../../data/filename.csv')
# ಅಥವಾ ಪೂರ್ಣ ಮಾರ್ಗಗಳನ್ನು ಬಳಸಿ
df = pd.read_csv('/full/path/to/data/filename.csv')
```
---
## R ಪರಿಸರ ಸಮಸ್ಯೆಗಳು
### ಪ್ಯಾಕೇಜ್ ಸ್ಥಾಪನೆ
**ಸಮಸ್ಯೆ**: ಸಂಯೋಜನೆ ದೋಷಗಳೊಂದಿಗೆ ಪ್ಯಾಕೇಜ್ ಸ್ಥಾಪನೆ ವಿಫಲವಾಗಿದೆ
**ಪರಿಹಾರ**:
```r
# ಬೈನರಿ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸಿ (Windows/macOS)
install.packages("package-name", type = "binary")
# ಪ್ಯಾಕೇಜುಗಳು ಅಗತ್ಯವಿದ್ದರೆ R ಅನ್ನು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗೆ ನವೀಕರಿಸಿ
# R ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
R.version.string
# ಸಿಸ್ಟಮ್ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿ (Linux)
# Ubuntu/Debian ಗಾಗಿ, ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ:
# sudo apt-get install r-base-dev
```
**ಸಮಸ್ಯೆ**: `tidyverse` ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```r
# ಮೊದಲು ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
install.packages(c("rlang", "vctrs", "pillar"))
# ನಂತರ tidyverse ಅನ್ನು ಸ್ಥಾಪಿಸಿ
install.packages("tidyverse")
# ಅಥವಾ ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಸ್ಥಾಪಿಸಿ
install.packages(c("dplyr", "ggplot2", "tidyr", "readr"))
```
### RMarkdown ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: RMarkdown ರೆಂಡರ್ ಆಗುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```r
# rmarkdown ಅನ್ನು ಸ್ಥಾಪಿಸಿ/ನವೀಕರಿಸಿ
install.packages("rmarkdown")
# ಅಗತ್ಯವಿದ್ದರೆ pandoc ಅನ್ನು ಸ್ಥಾಪಿಸಿ
install.packages("pandoc")
# PDF ಔಟ್‌ಪುಟ್‌ಗಾಗಿ, tinytex ಅನ್ನು ಸ್ಥಾಪಿಸಿ
install.packages("tinytex")
tinytex::install_tinytex()
```
---
## ಕ್ವಿಜ್ ಅಪ್ಲಿಕೇಶನ್ ಸಮಸ್ಯೆಗಳು
### ನಿರ್ಮಾಣ ಮತ್ತು ಸ್ಥಾಪನೆ
**ಸಮಸ್ಯೆ**: `npm install` ವಿಫಲವಾಗಿದೆ
**ಪರಿಹಾರ**:
```bash
# npm ಕ್ಯಾಶೆ ತೆರವುಗೊಳಿಸಿ
npm cache clean --force
# node_modules ಮತ್ತು package-lock.json ತೆಗೆದುಹಾಕಿ
rm -rf node_modules package-lock.json
# ಮರುಸ್ಥಾಪಿಸಿ
npm install
# ಇನ್ನೂ ವಿಫಲವಾದರೆ, legacy peer deps ಜೊತೆಗೆ ಪ್ರಯತ್ನಿಸಿ
npm install --legacy-peer-deps
```
**ಸಮಸ್ಯೆ**: ಪೋರ್ಟ್ 8080 ಈಗಾಗಲೇ ಬಳಕೆಯಲ್ಲಿದೆ
**ಪರಿಹಾರ**:
```bash
# ವಿಭಿನ್ನ ಪೋರ್ಟ್ ಬಳಸಿ
npm run serve -- --port 8081
# ಅಥವಾ ಪೋರ್ಟ್ 8080 ಬಳಸುತ್ತಿರುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹುಡುಕಿ ಮತ್ತು ಕೊಲ್ಲಿರಿ
# ಲಿನಕ್ಸ್ನಲ್ಲಿ/ಮ್ಯಾಕ್‌ಒಎಸ್‌ನಲ್ಲಿ:
lsof -ti:8080 | xargs kill -9
# ವಿಂಡೋಸ್‌ನಲ್ಲಿ:
netstat -ano | findstr :8080
taskkill /PID <PID> /F
```
### ನಿರ್ಮಾಣ ದೋಷಗಳು
**ಸಮಸ್ಯೆ**: `npm run build` ವಿಫಲವಾಗಿದೆ
**ಪರಿಹಾರ**:
```bash
# ನೋಡ್.js ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ (14+ ಆಗಿರಬೇಕು)
node --version
# ಅಗತ್ಯವಿದ್ದರೆ ನೋಡ್.js ಅನ್ನು ನವೀಕರಿಸಿ
# ನಂತರ ಸ್ವಚ್ಛ ಸ್ಥಾಪನೆ ಮಾಡಿ
rm -rf node_modules package-lock.json
npm install
npm run build
```
**ಸಮಸ್ಯೆ**: ಲಿಂಟಿಂಗ್ ದೋಷಗಳು ನಿರ್ಮಾಣವನ್ನು ತಡೆಯುತ್ತಿವೆ
**ಪರಿಹಾರ**:
```bash
# ಸ್ವಯಂ ಸರಿಪಡಿಸಬಹುದಾದ ಸಮಸ್ಯೆಗಳನ್ನು ಸರಿಪಡಿಸಿ
npm run lint -- --fix
# ಅಥವಾ ತಾತ್ಕಾಲಿಕವಾಗಿ ನಿರ್ಮಾಣದಲ್ಲಿ ಲಿಂಟಿಂಗ್ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ
# (ಉತ್ಪಾದನೆಗಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾಗುವುದಿಲ್ಲ)
```
---
## ಡೇಟಾ ಮತ್ತು ಫೈಲ್ ಪಥ ಸಮಸ್ಯೆಗಳು
### ಪಥ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ ಡೇಟಾ ಫೈಲ್‌ಗಳು ಕಂಡುಬರುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
1. **ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಯಾವ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿದ್ದರೂ ಅದರಿಂದಲೇ ಚಾಲನೆ ಮಾಡಿರಿ**
```bash
cd /path/to/lesson/folder
jupyter notebook
```
2. **ಕೋಡ್‌ನಲ್ಲಿ ಸಂಬಂಧಿತ ಪಥಗಳನ್ನು ಪರಿಶೀಲಿಸಿ**
```python
# ನೋಟ್ಬುಕ್ ಸ್ಥಳದಿಂದ ಸರಿಯಾದ ಮಾರ್ಗ
df = pd.read_csv('../data/filename.csv')
# ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಸ್ಥಳದಿಂದ ಅಲ್ಲ
```
3. **ಅವಶ್ಯಕತೆ ಇದ್ದರೆ ಪೂರ್ಣ ಪಥಗಳನ್ನು ಬಳಸಿ**
```python
import os
base_path = os.path.dirname(os.path.abspath(__file__))
data_path = os.path.join(base_path, 'data', 'filename.csv')
```
### ಡೇಟಾ ಫೈಲ್‌ಗಳು ಕಾಣೆಯಾದವು
**ಸಮಸ್ಯೆ**: ಡೇಟಾಸೆಟ್ ಫೈಲ್‌ಗಳು ಕಾಣೆಯಾಗಿದೆ
**ಪರಿಹಾರ**:
1. ಡೇಟಾ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇರಬೇಕೇ ಎಂದು ಪರಿಶೀಲಿಸಿ - ಬಹುತೇಕ ಡೇಟಾಸೆಟ್‌ಗಳು ಸೇರಿವೆ
2. ಕೆಲವು ಪಾಠಗಳಿಗೆ ಡೇಟಾ ಡೌನ್‌ಲೋಡ್ ಅಗತ್ಯವಿರಬಹುದು - ಪಾಠ README ಪರಿಶೀಲಿಸಿ
3. ನೀವು ಇತ್ತೀಚಿನ ಬದಲಾವಣೆಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿಕೊಂಡಿದ್ದೀರಾ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:
```bash
git pull origin main
```
---
## ಸಾಮಾನ್ಯ ದೋಷ ಸಂದೇಶಗಳು
### ಮೆಮೊರಿ ದೋಷಗಳು
**ದೋಷ**: `MemoryError` ಅಥವಾ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ ಮಾಡುವಾಗ ಕರ್ಣಲ್ ಸಾಯುತ್ತದೆ
**ಪರಿಹಾರ**:
```python
# ಡೇಟಾವನ್ನು ತುಂಡುಗಳಾಗಿ ಲೋಡ್ ಮಾಡಿ
for chunk in pd.read_csv('large_file.csv', chunksize=10000):
process(chunk)
# ಅಥವಾ ಅಗತ್ಯವಿರುವ ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಓದಿ
df = pd.read_csv('file.csv', usecols=['col1', 'col2'])
# ಮುಗಿದ ಮೇಲೆ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿ
del large_dataframe
import gc
gc.collect()
```
### ಸಮಾಗಮ ಎಚ್ಚರಿಕೆಗಳು
**ಎಚ್ಚರಿಕೆ**: `ConvergenceWarning: Maximum number of iterations reached`
**ಪರಿಹಾರ**:
```python
from sklearn.linear_model import LogisticRegression
# ಗರಿಷ್ಠ ಪುನರಾವೃತ್ತಿಗಳನ್ನು ಹೆಚ್ಚಿಸಿ
model = LogisticRegression(max_iter=1000)
# ಅಥವಾ ಮೊದಲು ನಿಮ್ಮ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಮಾಪನ ಮಾಡಿ
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
```
### ಚಿತ್ರಣ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: ಜುಪೈಟರ್‌ನಲ್ಲಿ ಚಿತ್ರಣಗಳು ತೋರಿಸುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```python
# ಇನ್‌ಲೈನ್ ಪ್ಲಾಟಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ
%matplotlib inline
# ಪೈಪ್ಲಾಟ್ ಅನ್ನು ಆಮದುಮಾಡಿ
import matplotlib.pyplot as plt
# ಪ್ಲಾಟ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತೋರಿಸಿ
plt.plot(data)
plt.show()
```
**ಸಮಸ್ಯೆ**: ಸೀಬೋನ್ ಚಿತ್ರಣಗಳು ವಿಭಿನ್ನವಾಗಿ ಕಾಣುತ್ತಿವೆ ಅಥವಾ ದೋಷಗಳನ್ನು ತೋರಿಸುತ್ತಿವೆ
**ಪರಿಹಾರ**:
```python
import warnings
warnings.filterwarnings('ignore', category=UserWarning)
# ಹೊಂದಾಣಿಕೆಯ ಆವೃತ್ತಿಗೆ ನವೀಕರಿಸಿ
# pip install --upgrade seaborn matplotlib
```
### ಯುನಿಕೋಡ್/ಎನ್‌ಕೋಡಿಂಗ್ ದೋಷಗಳು
**ಸಮಸ್ಯೆ**: ಫೈಲ್ ಓದುವಾಗ `UnicodeDecodeError`
**ಪರಿಹಾರ**:
```python
# ಎನ್‌ಕೋಡಿಂಗ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸಿ
df = pd.read_csv('file.csv', encoding='utf-8')
# ಅಥವಾ ವಿಭಿನ್ನ ಎನ್‌ಕೋಡಿಂಗ್ ಪ್ರಯತ್ನಿಸಿ
df = pd.read_csv('file.csv', encoding='latin-1')
# ಸಮಸ್ಯೆಯಾದ ಅಕ್ಷರಗಳನ್ನು ತಪ್ಪಿಸಲು errors='ignore' ಬಳಸಿರಿ
df = pd.read_csv('file.csv', encoding='utf-8', errors='ignore')
```
---
## ಕಾರ್ಯಕ್ಷಮತೆ ಸಮಸ್ಯೆಗಳು
### ನಿಧಾನ ನೋಟ್ಬುಕ್ ಚಾಲನೆ
**ಸಮಸ್ಯೆ**: ನೋಟ್ಬುಕ್‌ಗಳು ಬಹಳ ನಿಧಾನವಾಗಿ ಚಾಲನೆ ಆಗುತ್ತಿವೆ
**ಪರಿಹಾರ**:
1. **ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಕರ್ಣಲ್ ಮರುಪ್ರಾರಂಭಿಸಿ**: `Kernel → Restart`
2. **ಬಳಸದ ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಮುಚ್ಚಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಿ**
3. **ಪರೀಕ್ಷೆಗಾಗಿ ಸಣ್ಣ ಡೇಟಾ ಮಾದರಿಗಳನ್ನು ಬಳಸಿ**:
```python
# ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ಉಪಸಮೂಹದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ
df_sample = df.sample(n=1000)
```
4. **ನಿಮ್ಮ ಕೋಡ್‌ನ ಬಾಟಲ್‌ನೆಕ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರೊಫೈಲ್ ಮಾಡಿ**:
```python
%time operation() # ಸಮಯ ಏಕೈಕ ಕಾರ್ಯಾಚರಣೆ
%timeit operation() # ಬಹು ಬಾರಿ ಚಾಲನೆಗಳೊಂದಿಗೆ ಸಮಯ
```
### ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ಬಳಕೆ
**ಸಮಸ್ಯೆ**: ಸಿಸ್ಟಮ್ ಮೆಮೊರಿ ಮುಗಿಯುತ್ತಿದೆ
**ಪರಿಹಾರ**:
```python
# ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಪರಿಶೀಲಿಸಿ
df.info(memory_usage='deep')
# ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಸುಧಾರಿಸಿ
df['column'] = df['column'].astype('int32') # int64 ಬದಲು
# ಅನಾವಶ್ಯಕ ಕಾಲಮ್ಗಳನ್ನು ತೆಗೆದುಹಾಕಿ
df = df[['col1', 'col2']] # ಅಗತ್ಯವಿರುವ ಕಾಲಮ್ಗಳನ್ನು ಮಾತ್ರ ಇಡಿ
# ಬ್ಯಾಚ್‌ಗಳಲ್ಲಿ ಪ್ರಕ್ರಿಯೆ ಮಾಡಿ
for batch in np.array_split(df, 10):
process(batch)
```
---
## ಪರಿಸರ ಮತ್ತು ಸಂರಚನೆ
### ವರ್ಚುವಲ್ ಪರಿಸರ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: ವರ್ಚುವಲ್ ಪರಿಸರ ಸಕ್ರಿಯವಾಗುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```bash
# ವಿಂಡೋಸ್
python -m venv venv
venv\Scripts\activate.bat
# ಮ್ಯಾಕ್‌ಒಎಸ್/ಲಿನಕ್ಸ
python3 -m venv venv
source venv/bin/activate
# ಸಕ್ರಿಯಗೊಂಡಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ (ಪ್ರಾಂಪ್ಟ್‌ನಲ್ಲಿ venv ಹೆಸರು ತೋರಿಸಬೇಕು)
which python # venv ಪೈಥಾನ್‌ಗೆ ಸೂಚಿಸಬೇಕು
```
**ಸಮಸ್ಯೆ**: ಪ್ಯಾಕೇಜ್‌ಗಳು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಆದರೆ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಕಂಡುಬರುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
```bash
# ನೋಟ್ಬುಕ್ ಸರಿಯಾದ ಕರ್ಣಲ್ ಬಳಸುತ್ತಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
# ನಿಮ್ಮ ವಿ.ಎನ್.ಇ.ವಿ.ನಲ್ಲಿ ipykernel ಅನ್ನು ಸ್ಥಾಪಿಸಿ
pip install ipykernel
python -m ipykernel install --user --name=ml-env --display-name="Python (ml-env)"
# ಜುಪಿಟರ್‌ನಲ್ಲಿ: ಕರ್ಣಲ್ → ಕರ್ಣಲ್ ಬದಲಿಸಿ → ಪೈಥಾನ್ (ml-env)
```
### ಗಿಟ್ ಸಮಸ್ಯೆಗಳು
**ಸಮಸ್ಯೆ**: ಇತ್ತೀಚಿನ ಬದಲಾವಣೆಗಳನ್ನು ಪುಲ್ ಮಾಡಲಾಗುತ್ತಿಲ್ಲ - ಮರ್ಜ್ ಸಂಘರ್ಷಗಳು
**ಪರಿಹಾರ**:
```bash
# ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ಸ್ಟ್ಯಾಶ್ ಮಾಡಿ
git stash
# ಇತ್ತೀಚಿನದನ್ನು ಪುಲ್ ಮಾಡಿ
git pull origin main
# ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ಮರು ಅನ್ವಯಿಸಿ
git stash pop
# ಸಂಘರ್ಷಗಳಿದ್ದರೆ, ಕೈಯಿಂದ ಪರಿಹರಿಸಿ ಅಥವಾ:
git checkout --theirs path/to/file # ರಿಮೋಟ್ ಆವೃತ್ತಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ
git checkout --ours path/to/file # ನಿಮ್ಮ ಆವೃತ್ತಿಯನ್ನು ಉಳಿಸಿ
```
### VS ಕೋಡ್ ಏಕೀಕರಣ
**ಸಮಸ್ಯೆ**: ಜುಪೈಟರ್ ನೋಟ್ಬುಕ್‌ಗಳು VS ಕೋಡ್‌ನಲ್ಲಿ ತೆರೆಯುತ್ತಿಲ್ಲ
**ಪರಿಹಾರ**:
1. VS ಕೋಡ್‌ನಲ್ಲಿ ಪೈಥಾನ್ ವಿಸ್ತರಣೆ ಸ್ಥಾಪಿಸಿ
2. VS ಕೋಡ್‌ನಲ್ಲಿ ಜುಪೈಟರ್ ವಿಸ್ತರಣೆ ಸ್ಥಾಪಿಸಿ
3. ಸರಿಯಾದ ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರೀಟರ್ ಆಯ್ಕೆಮಾಡಿ: `Ctrl+Shift+P` → "Python: Select Interpreter"
4. VS ಕೋಡ್ ಮರುಪ್ರಾರಂಭಿಸಿ
---
## ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು
- **Discord ಚರ್ಚೆಗಳು**: [#ml-for-beginners ಚಾನೆಲ್‌ನಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿ ಮತ್ತು ಪರಿಹಾರಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಿ](https://aka.ms/foundry/discord)
- **Microsoft Learn**: [ML for Beginners ಘಟಕಗಳು](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
- **ವೀಡಿಯೊ ಪಾಠಗಳು**: [YouTube ಪ್ಲೇಲಿಸ್ಟ್](https://aka.ms/ml-beginners-videos)
- **ಸಮಸ್ಯೆ ಟ್ರ್ಯಾಕರ್**: [ದೋಷಗಳನ್ನು ವರದಿ ಮಾಡಿ](https://github.com/microsoft/ML-For-Beginners/issues)
---
## ಇನ್ನೂ ಸಮಸ್ಯೆಗಳಿವೆಯೇ?
ಮೇಲಿನ ಪರಿಹಾರಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿದರೂ ಸಮಸ್ಯೆಗಳು ಮುಂದುವರೆದರೆ:
1. **ಇದೀಗಿರುವ ಸಮಸ್ಯೆಗಳನ್ನು ಹುಡುಕಿ**: [GitHub Issues](https://github.com/microsoft/ML-For-Beginners/issues)
2. **Discord ಚರ್ಚೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ**: [Discord Discussions](https://aka.ms/foundry/discord)
3. **ಹೊಸ ಸಮಸ್ಯೆಯನ್ನು ತೆರೆಯಿರಿ**: ಒಳಗೊಂಡಿರಲಿ:
- ನಿಮ್ಮ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಮತ್ತು ಆವೃತ್ತಿ
- ಪೈಥಾನ್/R ಆವೃತ್ತಿ
- ದೋಷ ಸಂದೇಶ (ಪೂರ್ಣ ಟ್ರೇಸ್‌ಬ್ಯಾಕ್)
- ಸಮಸ್ಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವ ಹಂತಗಳು
- ನೀವು ಈಗಾಗಲೇ ಪ್ರಯತ್ನಿಸಿದವು
ನಾವು ಸಹಾಯ ಮಾಡಲು ಇಲ್ಲಿ ಇದ್ದೇವೆ! 🚀
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

59
translations/kn/docs/_sidebar.md
Unescape View File

@ -0,0 +1,59 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "68dd06c685f6ce840e0acfa313352e7c",
"translation_date": "2025-12-19T13:10:39+00:00",
"source_file": "docs/_sidebar.md",
"language_code": "kn"
}
-->
- ಪರಿಚಯ
- [ಯಂತ್ರ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ](../1-Introduction/1-intro-to-ML/README.md)
- [ಯಂತ್ರ ಅಧ್ಯಯನದ ಇತಿಹಾಸ](../1-Introduction/2-history-of-ML/README.md)
- [ಯಂತ್ರ ಅಧ್ಯಯನ ಮತ್ತು ನ್ಯಾಯತತೆ](../1-Introduction/3-fairness/README.md)
- [ಯಂತ್ರ ಅಧ್ಯಯನದ ತಂತ್ರಗಳು](../1-Introduction/4-techniques-of-ML/README.md)
- ರಿಗ್ರೆಶನ್
- [ವ್ಯವಹಾರದ ಸಾಧನಗಳು](../2-Regression/1-Tools/README.md)
- [ಡೇಟಾ](../2-Regression/2-Data/README.md)
- [ರೇಖೀಯ ರಿಗ್ರೆಶನ್](../2-Regression/3-Linear/README.md)
- [ಲಾಗಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್](../2-Regression/4-Logistic/README.md)
- ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ
- [ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್](../3-Web-App/1-Web-App/README.md)
- ವರ್ಗೀಕರಣ
- [ವರ್ಗೀಕರಣಕ್ಕೆ ಪರಿಚಯ](../4-Classification/1-Introduction/README.md)
- [ವರ್ಗೀಕರಣಗಳು 1](../4-Classification/2-Classifiers-1/README.md)
- [ವರ್ಗೀಕರಣಗಳು 2](../4-Classification/3-Classifiers-2/README.md)
- [ಅನ್ವಯಿಸಿದ ಯಂತ್ರ ಅಧ್ಯಯನ](../4-Classification/4-Applied/README.md)
- ಗುಂಪುಮಾಡುವಿಕೆ
- [ನಿಮ್ಮ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿ](../5-Clustering/1-Visualize/README.md)
- [ಕೆ-ಮೀನ್ಸ್](../5-Clustering/2-K-Means/README.md)
- ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆ
- [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆಗೆ ಪರಿಚಯ](../6-NLP/1-Introduction-to-NLP/README.md)
- [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಪ್ರಕ್ರಿಯೆಯ ಕಾರ್ಯಗಳು](../6-NLP/2-Tasks/README.md)
- [ಅನುವಾದ ಮತ್ತು ಭಾವನೆ](../6-NLP/3-Translation-Sentiment/README.md)
- [ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳು 1](../6-NLP/4-Hotel-Reviews-1/README.md)
- [ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳು 2](../6-NLP/5-Hotel-Reviews-2/README.md)
- ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿ
- [ಕಾಲ ಸರಣಿ ಭವಿಷ್ಯವಾಣಿಗೆ ಪರಿಚಯ](../7-TimeSeries/1-Introduction/README.md)
- [ಎರಿಮಾ](../7-TimeSeries/2-ARIMA/README.md)
- [ಎಸ್‌ವಿಆರ್](../7-TimeSeries/3-SVR/README.md)
- ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ
- [ಕ್ಯೂ-ಅಧ್ಯಯನ](../8-Reinforcement/1-QLearning/README.md)
- [ಜಿಮ್](../8-Reinforcement/2-Gym/README.md)
- ನೈಜ ಜಗತ್ತಿನ ಯಂತ್ರ ಅಧ್ಯಯನ
- [ಅನ್ವಯಗಳು](../9-Real-World/1-Applications/README.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

39
translations/kn/for-teachers.md
Unescape View File

@ -0,0 +1,39 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
"translation_date": "2025-12-19T12:27:07+00:00",
"source_file": "for-teachers.md",
"language_code": "kn"
}
-->
## ಶಿಕ್ಷಕರಿಗಾಗಿ
ನೀವು ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ನಿಮ್ಮ ತರಗತಿಯಲ್ಲಿ ಬಳಸಲು ಇಚ್ಛಿಸುತ್ತೀರಾ? ದಯವಿಟ್ಟು ಮುಕ್ತವಾಗಿ ಬಳಸಿಕೊಳ್ಳಿ!
ವಾಸ್ತವದಲ್ಲಿ, ನೀವು GitHub Classroom ಬಳಸಿ GitHub ನೊಳಗೆ ಇದನ್ನು ಬಳಸಬಹುದು.
ಅದಕ್ಕಾಗಿ, ಈ ರೆಪೊವನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ. ಪ್ರತಿಯೊಂದು ಪಾಠಕ್ಕಾಗಿ ನೀವು ಒಂದು ರೆಪೊ ಸೃಷ್ಟಿಸಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಪ್ರತಿಯೊಂದು ಫೋಲ್ಡರ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ರೆಪೊಗೆ ಹೊರತೆಗೆಯಬೇಕಾಗುತ್ತದೆ. ಆ ರೀತಿಯಲ್ಲಿ, [GitHub Classroom](https://classroom.github.com/classrooms) ಪ್ರತಿ ಪಾಠವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಹಿಡಿಯಬಹುದು.
ಈ [ಪೂರ್ಣ ಸೂಚನೆಗಳು](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) ನಿಮ್ಮ ತರಗತಿಯನ್ನು ಹೇಗೆ ಸೆಟ್ ಅಪ್ ಮಾಡಬೇಕೆಂದು ನಿಮಗೆ ತಿಳಿಸುವುದು.
## ರೆಪೊವನ್ನು ಹಾಗೆ ಬಳಸುವುದು
ನೀವು GitHub Classroom ಬಳಸದೆ ಈ ರೆಪೊವನ್ನು ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಳಸಲು ಇಚ್ಛಿಸಿದರೆ, ಅದು ಸಹ ಸಾಧ್ಯ. ನೀವು ನಿಮ್ಮ ವಿದ್ಯಾರ್ಥಿಗಳೊಂದಿಗೆ ಯಾವ ಪಾಠವನ್ನು ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ಸಂವಹನ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಆನ್ಲೈನ್ ಫಾರ್ಮ್ಯಾಟ್ (Zoom, Teams, ಅಥವಾ ಇತರೆ) ನಲ್ಲಿ ನೀವು ಕ್ವಿಜ್‌ಗಳಿಗಾಗಿ ಬ್ರೇಕ್‌ಔಟ್ ರೂಮ್ಗಳನ್ನು ರೂಪಿಸಬಹುದು ಮತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ಕಲಿಯಲು ಸಿದ್ಧರಾಗಲು ಮಾರ್ಗದರ್ಶನ ಮಾಡಬಹುದು. ನಂತರ ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ಕ್ವಿಜ್‌ಗಳಿಗೆ ಆಹ್ವಾನಿಸಿ, ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ 'issues' ಆಗಿ ಉತ್ತರಗಳನ್ನು ಸಲ್ಲಿಸಲು ಹೇಳಬಹುದು. ನೀವು ಬಯಸಿದರೆ, ವಿದ್ಯಾರ್ಥಿಗಳು ಸಹಕಾರದಿಂದ ಹೊರಗೆ ಕೆಲಸ ಮಾಡಲು, ಅಸೈನ್ಮೆಂಟ್‌ಗಳಿಗೂ ಇದೇ ರೀತಿಯ ವ್ಯವಸ್ಥೆ ಮಾಡಬಹುದು.
ನೀವು ಹೆಚ್ಚು ಖಾಸಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಇಚ್ಛಿಸಿದರೆ, ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ಪಠ್ಯಕ್ರಮವನ್ನು ಪಾಠದ ಮೂಲಕ ಫೋರ್ಕ್ ಮಾಡಿ ತಮ್ಮ ಸ್ವಂತ GitHub ರೆಪೊಗಳಲ್ಲಿ ಖಾಸಗಿ ರೆಪೊಗಳಾಗಿ ಇಟ್ಟುಕೊಳ್ಳಲು ಹೇಳಿ, ಮತ್ತು ನಿಮಗೆ ಪ್ರವೇಶ ನೀಡಲು ಹೇಳಿ. ನಂತರ ಅವರು ಖಾಸಗಿ ರೀತಿಯಲ್ಲಿ ಕ್ವಿಜ್‌ಗಳು ಮತ್ತು ಅಸೈನ್ಮೆಂಟ್‌ಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ, ನಿಮ್ಮ ತರಗತಿ ರೆಪೊದಲ್ಲಿ issues ಮೂಲಕ ನಿಮಗೆ ಸಲ್ಲಿಸಬಹುದು.
ಆನ್ಲೈನ್ ತರಗತಿ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅನೇಕ ಮಾರ್ಗಗಳಿವೆ. ದಯವಿಟ್ಟು ನಿಮಗೆ ಯಾವುದು ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿಸಿ!
## ದಯವಿಟ್ಟು ನಿಮ್ಮ ಅಭಿಪ್ರಾಯವನ್ನು ನೀಡಿ!
ನಾವು ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ನಿಮಗೂ ನಿಮ್ಮ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೂ ಉಪಯುಕ್ತವಾಗಿಸಲು ಬಯಸುತ್ತೇವೆ. ದಯವಿಟ್ಟು ನಮಗೆ [ಪ್ರತಿಕ್ರಿಯೆ](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u) ನೀಡಿ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

128
translations/kn/quiz-app/README.md
Unescape View File

@ -0,0 +1,128 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
"translation_date": "2025-12-19T13:01:43+00:00",
"source_file": "quiz-app/README.md",
"language_code": "kn"
}
-->
# ಪ್ರಶ್ನೋತ್ತರಗಳು
ಈ ಪ್ರಶ್ನೋತ್ತರಗಳು https://aka.ms/ml-beginners ನಲ್ಲಿ ML ಪಠ್ಯಕ್ರಮದ ಪೂರ್ವ ಮತ್ತು ನಂತರದ ಪ್ರಶ್ನೋತ್ತರಗಳಾಗಿವೆ
## ಪ್ರಾಜೆಕ್ಟ್ ಸೆಟಪ್
```
npm install
```
### ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸಂಯೋಜನೆ ಮತ್ತು ಹಾಟ್-ರಿಲೋಡ್
```
npm run serve
```
### ಉತ್ಪಾದನೆಗಾಗಿ ಸಂಯೋಜನೆ ಮತ್ತು ಮಿನಿಫೈ
```
npm run build
```
### ಫೈಲ್‌ಗಳನ್ನು ಲಿಂಟ್ ಮಾಡಿ ಮತ್ತು ಸರಿಪಡಿಸಿ
```
npm run lint
```
### ಸಂರಚನೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಿ
[Configuration Reference](https://cli.vuejs.org/config/) ಅನ್ನು ನೋಡಿ.
ಕ್ರೆಡಿಟ್ಸ್: ಈ ಪ್ರಶ್ನೋತ್ತರ ಅಪ್ಲಿಕೇಶನ್‌ನ ಮೂಲ ಆವೃತ್ತಿಗೆ ಧನ್ಯವಾದಗಳು: https://github.com/arpan45/simple-quiz-vue
## ಅಜೂರ್‌ಗೆ ನಿಯೋಜನೆ
ನಿಮಗೆ ಪ್ರಾರಂಭಿಸಲು ಸಹಾಯ ಮಾಡುವ ಹಂತ ಹಂತದ ಮಾರ್ಗದರ್ಶಿ ಇಲ್ಲಿದೆ:
1. GitHub ರೆಪೊಸಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ
ನಿಮ್ಮ ಸ್ಥಿರ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ನಿಮ್ಮ GitHub ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇರಬೇಕು. ಈ ರೆಪೊಸಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ.
2. ಅಜೂರ್ ಸ್ಥಿರ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ
- [ಅಜೂರ್ ಖಾತೆ](http://azure.microsoft.com) ರಚಿಸಿ
- [ಅಜೂರ್ ಪೋರ್ಟಲ್](https://portal.azure.com) ಗೆ ಹೋಗಿ
- "Create a resource" ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು "Static Web App" ಅನ್ನು ಹುಡುಕಿ.
- "Create" ಕ್ಲಿಕ್ ಮಾಡಿ.
3. ಸ್ಥಿರ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಂರಚಿಸಿ
- ಮೂಲಭೂತಗಳು: ಸಬ್ಸ್ಕ್ರಿಪ್ಷನ್: ನಿಮ್ಮ ಅಜೂರ್ ಸಬ್ಸ್ಕ್ರಿಪ್ಷನ್ ಆಯ್ಕೆಮಾಡಿ.
- ರಿಸೋರ್ಸ್ ಗ್ರೂಪ್: ಹೊಸ ರಿಸೋರ್ಸ್ ಗ್ರೂಪ್ ರಚಿಸಿ ಅಥವಾ ಇತ್ತೀಚಿನದನ್ನು ಬಳಸಿ.
- ಹೆಸರು: ನಿಮ್ಮ ಸ್ಥಿರ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹೆಸರು ನೀಡಿ.
- ಪ್ರದೇಶ: ನಿಮ್ಮ ಬಳಕೆದಾರರಿಗೆ ಸಮೀಪದ ಪ್ರದೇಶವನ್ನು ಆಯ್ಕೆಮಾಡಿ.
- #### ನಿಯೋಜನೆ ವಿವರಗಳು:
- ಮೂಲ: "GitHub" ಆಯ್ಕೆಮಾಡಿ.
- GitHub ಖಾತೆ: ಅಜೂರ್‌ಗೆ ನಿಮ್ಮ GitHub ಖಾತೆಗೆ ಪ್ರವೇಶ ನೀಡಿರಿ.
- ಸಂಸ್ಥೆ: ನಿಮ್ಮ GitHub ಸಂಸ್ಥೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ.
- ರೆಪೊಸಿಟರಿ: ನಿಮ್ಮ ಸ್ಥಿರ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಹೊಂದಿರುವ ರೆಪೊಸಿಟರಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ.
- ಶಾಖೆ: ನೀವು ನಿಯೋಜಿಸಲು ಬಯಸುವ ಶಾಖೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ.
- #### ನಿರ್ಮಾಣ ವಿವರಗಳು:
- ನಿರ್ಮಾಣ ಪೂರ್ವನಿಯೋಜನೆಗಳು: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿತವಾಗಿರುವ ಫ್ರೇಮ್ವರ್ಕ್ ಆಯ್ಕೆಮಾಡಿ (ಉದಾ: React, Angular, Vue, ಇತ್ಯಾದಿ).
- ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಳ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಇರುವ ಫೋಲ್ಡರ್ ಸೂಚಿಸಿ (ಉದಾ: / ಮೂಲದಲ್ಲಿ ಇದ್ದರೆ).
- API ಸ್ಥಳ: ನೀವು API ಹೊಂದಿದ್ದರೆ, ಅದರ ಸ್ಥಳವನ್ನು ಸೂಚಿಸಿ (ಐಚ್ಛಿಕ).
- ಔಟ್‌ಪುಟ್ ಸ್ಥಳ: ನಿರ್ಮಾಣ ಔಟ್‌ಪುಟ್ ಉತ್ಪಾದನೆಯಾಗುವ ಫೋಲ್ಡರ್ ಸೂಚಿಸಿ (ಉದಾ: build ಅಥವಾ dist).
4. ಪರಿಶೀಲಿಸಿ ಮತ್ತು ರಚಿಸಿ
ನಿಮ್ಮ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು "Create" ಕ್ಲಿಕ್ ಮಾಡಿ. ಅಜೂರ್ ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಿದ್ಧಪಡಿಸಿ ಮತ್ತು ನಿಮ್ಮ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ GitHub Actions ವರ್ಕ್‌ಫ್ಲೋವನ್ನು ರಚಿಸುತ್ತದೆ.
5. GitHub Actions ವರ್ಕ್‌ಫ್ಲೋ
ಅಜೂರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಮ್ಮ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ GitHub Actions ವರ್ಕ್‌ಫ್ಲೋ ಫೈಲ್ (.github/workflows/azure-static-web-apps-<name>.yml) ರಚಿಸುತ್ತದೆ. ಈ ವರ್ಕ್‌ಫ್ಲೋ ನಿರ್ಮಾಣ ಮತ್ತು ನಿಯೋಜನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
6. ನಿಯೋಜನೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ
ನಿಮ್ಮ GitHub ರೆಪೊಸಿಟರಿಯ "Actions" ಟ್ಯಾಬ್‌ಗೆ ಹೋಗಿ.
ನೀವು ಒಂದು ವರ್ಕ್‌ಫ್ಲೋ ಚಲಿಸುತ್ತಿರುವುದನ್ನು ನೋಡಬಹುದು. ಈ ವರ್ಕ್‌ಫ್ಲೋ ನಿಮ್ಮ ಸ್ಥಿರ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅಜೂರ್‌ಗೆ ನಿರ್ಮಿಸಿ ನಿಯೋಜಿಸುತ್ತದೆ.
ವರ್ಕ್‌ಫ್ಲೋ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ನೀಡಲಾದ ಅಜೂರ್ URL ನಲ್ಲಿ ಲೈವ್ ಆಗಿರುತ್ತದೆ.
### ಉದಾಹರಣೆಯ ವರ್ಕ್‌ಫ್ಲೋ ಫೈಲ್
GitHub Actions ವರ್ಕ್‌ಫ್ಲೋ ಫೈಲ್ ಹೇಗಿರಬಹುದು ಎಂಬ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
name: Azure Static Web Apps CI/CD
```
on:
push:
branches:
- main
pull_request:
types: [opened, synchronize, reopened, closed]
branches:
- main
jobs:
build_and_deploy_job:
runs-on: ubuntu-latest
name: Build and Deploy Job
steps:
- uses: actions/checkout@v2
- name: Build And Deploy
id: builddeploy
uses: Azure/static-web-apps-deploy@v1
with:
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
repo_token: ${{ secrets.GITHUB_TOKEN }}
action: "upload"
app_location: "/quiz-app" # App source code path
api_location: ""API source code path optional
output_location: "dist" #Built app content directory - optional
```
### ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು
- [Azure Static Web Apps Documentation](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [GitHub Actions Documentation](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

247
translations/kn/sketchnotes/LICENSE.md
Unescape View File

@ -0,0 +1,247 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
"translation_date": "2025-12-19T13:19:52+00:00",
"source_file": "sketchnotes/LICENSE.md",
"language_code": "kn"
}
-->
ಅಟ್ರಿಬ್ಯೂಷನ್-ಶೇರ್ ಅಲೈಕ್ 4.0 ಇಂಟರ್‌ನ್ಯಾಷನಲ್
=======================================================================
ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಕಾರ್ಪೊರೇಶನ್ ("ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್") ಒಂದು ಕಾನೂನು ಸಂಸ್ಥೆ ಅಲ್ಲ ಮತ್ತು
ಕಾನೂನು ಸೇವೆಗಳು ಅಥವಾ ಕಾನೂನು ಸಲಹೆಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ. ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳನ್ನು ಹಂಚಿಕೆ ಮಾಡುವುದು ವಕೀಲ-ಗ್ರಾಹಕ ಅಥವಾ
ಇತರ ಸಂಬಂಧವನ್ನು ಸೃಷ್ಟಿಸುವುದಿಲ್ಲ. ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ತನ್ನ ಪರವಾನಗಿಗಳನ್ನು ಮತ್ತು ಸಂಬಂಧಿತ
ಮಾಹಿತಿಯನ್ನು "ಹಾಗೇ ಇದೆ" ಆಧಾರದ ಮೇಲೆ ಲಭ್ಯವಿದೆ. ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ತನ್ನ ಪರವಾನಗಿಗಳ ಬಗ್ಗೆ ಯಾವುದೇ
ಹೆಚ್ಚುವರಿ ಭರವಸೆಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ, ಅವುಗಳ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಯಾವುದೇ ವಸ್ತುಗಳ ಬಗ್ಗೆ ಅಥವಾ ಯಾವುದೇ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯ ಬಗ್ಗೆ. ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್
ಅವುಗಳ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಹಾನಿಗಳ ಬಗ್ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಜವಾಬ್ದಾರಿಯನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ.
ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳನ್ನು ಬಳಸುವುದು
ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳು ಸೃಷ್ಟಿಕರ್ತರು ಮತ್ತು ಇತರ ಹಕ್ಕುಧಾರಕರು ಮೂಲ
ರಚನೆಗಳ ಮತ್ತು ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಕೆಳಗಿನ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕೆಲವು ಇತರ ಹಕ್ಕುಗಳಿಗೆ ಒಳಪಟ್ಟ ವಸ್ತುಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಬಳಸಬಹುದಾದ
ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳ ಸಾಮಾನ್ಯ ಸೆಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ. ಕೆಳಗಿನ ಪರಿಗಣನೆಗಳು ಮಾಹಿತಿ ಉದ್ದೇಶಕ್ಕಾಗಿ ಮಾತ್ರ, ಸಂಪೂರ್ಣವಲ್ಲ, ಮತ್ತು ನಮ್ಮ ಪರವಾನಗಿಗಳ ಭಾಗವಲ್ಲ.
ಪರವಾನಗಿ ನೀಡುವವರ ಪರಿಗಣನೆಗಳು: ನಮ್ಮ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳು
ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಕೆಲವು ಇತರ ಹಕ್ಕುಗಳಿಂದ ನಿಯಂತ್ರಿತವಾಗಿರುವ
ವಸ್ತುಗಳನ್ನು ಸಾರ್ವಜನಿಕರಿಗೆ ಬಳಸಲು ಅನುಮತಿ ನೀಡಲು ಅಧಿಕಾರ ಹೊಂದಿರುವವರ ಬಳಕೆಗಾಗಿ ಉದ್ದೇಶಿಸಲಾಗಿದೆ.
ನಮ್ಮ ಪರವಾನಗಿಗಳು ರದ್ದುಗೊಳಿಸಲಾಗದವು. ಪರವಾನಗಿ ನೀಡುವವರು ಆಯ್ಕೆಮಾಡಿದ ಪರವಾನಗಿ
ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೊದಲು ಓದಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.
ಪರವಾನಗಿ ನೀಡುವವರು ಸಾರ್ವಜನಿಕರು ನಿರೀಕ್ಷಿಸುವಂತೆ ವಸ್ತುವನ್ನು ಮರುಬಳಕೆ ಮಾಡಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಹಕ್ಕುಗಳನ್ನು
ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಪರವಾನಗಿ ಅನ್ವಯಿಸದ ಯಾವುದೇ ವಸ್ತುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಗುರುತಿಸಬೇಕು.
ಇದರಲ್ಲಿ ಇತರ CC-ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುಗಳು ಅಥವಾ ಪ್ರತಿಕೃತಿ ಹಕ್ಕಿಗೆ ಹೊರತಾಗಿಯೂ
ವಿನಾಯಿತಿ ಅಥವಾ ಮಿತಿಯಡಿ ಬಳಸಲಾಗುವ ವಸ್ತುಗಳು ಸೇರಿವೆ. ಪರವಾನಗಿ ನೀಡುವವರ ಹೆಚ್ಚಿನ ಪರಿಗಣನೆಗಳು:
wiki.creativecommons.org/Considerations_for_licensors
ಸಾರ್ವಜನಿಕರ ಪರಿಗಣನೆಗಳು: ನಮ್ಮ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸುವ ಮೂಲಕ,
ಪರವಾನಗಿ ನೀಡುವವರು ಸಾರ್ವಜನಿಕರಿಗೆ ನಿರ್ದಿಷ್ಟ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಬಳಸಲು ಅನುಮತಿ ನೀಡುತ್ತಾರೆ.
ಪರವಾನಗಿ ನೀಡುವವರ ಅನುಮತಿ ಯಾವುದೇ ಕಾರಣಕ್ಕಾಗಿ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ—for
ಉದಾಹರಣೆಗೆ, ಯಾವುದೇ ಅನ್ವಯಿಸುವ ವಿನಾಯಿತಿ ಅಥವಾ ಮಿತಿಯ ಕಾರಣದಿಂದ—ಆ ಬಳಕೆ ಪರವಾನಗಿಯಿಂದ ನಿಯಂತ್ರಿತವಾಗುವುದಿಲ್ಲ.
ನಮ್ಮ ಪರವಾನಗಿಗಳು ಪರವಾನಗಿ ನೀಡುವವರಿಗೆ ನೀಡಲು ಅಧಿಕಾರವಿರುವ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಕೆಲವು ಇತರ ಹಕ್ಕುಗಳ ಅಡಿಯಲ್ಲಿ ಮಾತ್ರ ಅನುಮತಿಗಳನ್ನು ನೀಡುತ್ತವೆ.
ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಬಳಕೆ ಇನ್ನೂ ಇತರ ಕಾರಣಗಳಿಂದ ನಿಯಂತ್ರಿತವಾಗಿರಬಹುದು, ಉದಾಹರಣೆಗೆ ಇತರರಿಗೆ ಆ ವಸ್ತುವಿನ ಮೇಲೆ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಅಥವಾ ಇತರ ಹಕ್ಕುಗಳಿದ್ದರೆ.
ಪರವಾನಗಿ ನೀಡುವವರು ವಿಶೇಷ ವಿನಂತಿಗಳನ್ನು ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಅಥವಾ ವರ್ಣಿಸಲು ಕೇಳಬಹುದು.
ನಮ್ಮ ಪರವಾನಗಿಗಳಿಂದ ಅವಶ್ಯಕವಿಲ್ಲದಿದ್ದರೂ, ನೀವು ಆ ವಿನಂತಿಗಳನ್ನು ಯುಕ್ತಿಯುತವಾಗಿದ್ದಲ್ಲಿ ಗೌರವಿಸುವಂತೆ ಪ್ರೋತ್ಸಾಹಿಸಲಾಗುತ್ತದೆ.
ಸಾರ್ವಜನಿಕರ ಹೆಚ್ಚಿನ ಪರಿಗಣನೆಗಳು:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಅಟ್ರಿಬ್ಯೂಷನ್-ಶೇರ್ ಅಲೈಕ್ 4.0 ಇಂಟರ್‌ನ್ಯಾಷನಲ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ
ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು (ಕೆಳಗಿನಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ) ಬಳಸುವ ಮೂಲಕ, ನೀವು ಈ ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್
ಅಟ್ರಿಬ್ಯೂಷನ್-ಶೇರ್ ಅಲೈಕ್ 4.0 ಇಂಟರ್‌ನ್ಯಾಷನಲ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ("ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ") ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳಿಗೆ ಬದ್ಧರಾಗಲು ಒಪ್ಪಿಕೊಳ್ಳುತ್ತೀರಿ.
ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಒಪ್ಪಂದವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲ್ಪಟ್ಟರೆ, ನೀವು ಈ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಒಪ್ಪಿಕೊಂಡಿರುವುದಕ್ಕಾಗಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ,
ಮತ್ತು ಪರವಾನಗಿ ನೀಡುವವರು ಈ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಲಭ್ಯವಿರುವ ಮೂಲಕ ಲಾಭಗಳನ್ನು ಪಡೆಯುತ್ತಾರೆ.
ಅಧ್ಯಾಯ 1 -- ವ್ಯಾಖ್ಯಾನಗಳು.
a. ಹೊಂದಿಸಿದ ವಸ್ತು ಎಂದರೆ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನಿಂದ ಉತ್ಪನ್ನವಾಗಿರುವ ಅಥವಾ ಆಧಾರಿತವಾಗಿರುವ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳಿಗೆ ಒಳಪಟ್ಟ ವಸ್ತು,
ಮತ್ತು ಅದರಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಅನುವಾದಿಸಲಾಗುತ್ತದೆ, ಬದಲಿಸಲಾಗುತ್ತದೆ,
ವ್ಯವಸ್ಥಿತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ ಅಥವಾ ಇತರ ರೀತಿಯಲ್ಲಿ ಪರವಾನಗಿ ನೀಡುವವರ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳ ಅಡಿಯಲ್ಲಿ ಅನುಮತಿ ಅಗತ್ಯವಿರುವ ರೀತಿಯಲ್ಲಿ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.
ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಾಗಿ, ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತು ಸಂಗೀತ ಕೃತಿ, ಪ್ರದರ್ಶನ ಅಥವಾ ಧ್ವನಿ ದಾಖಲೆಯಾದರೆ,
ಹೊಂದಿಸಿದ ವಸ್ತು ಎಂದರೆ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತು ಚಲಿಸುವ ಚಿತ್ರದೊಂದಿಗೆ ಕಾಲಮಾನದಲ್ಲಿ ಸಿಂಕ್ ಮಾಡಲ್ಪಟ್ಟಾಗ ಮಾತ್ರ ಉತ್ಪನ್ನವಾಗುತ್ತದೆ.
b. ಹೊಂದಿಸುವವರ ಪರವಾನಗಿ ಎಂದರೆ ನೀವು ಹೊಂದಿಸಿದ ವಸ್ತುಗಳಿಗೆ ನಿಮ್ಮ ಕೊಡುಗೆಗಳಲ್ಲಿ ನಿಮ್ಮ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳಿಗೆ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳ ಪ್ರಕಾರ ನೀವು ಅನ್ವಯಿಸುವ ಪರವಾನಗಿ.
c. BY-SA ಹೊಂದಾಣಿಕೆಯ ಪರವಾನಗಿ ಎಂದರೆ creativecommons.org/compatiblelicenses ನಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾದ, ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಸಮಾನವಾದ ಪರವಾನಗಿ ಎಂದು ಅಂಗೀಕರಿಸಿದ ಪರವಾನಗಿ.
d. ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳು ಎಂದರೆ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು/ಅಥವಾ ಪ್ರತಿಕೃತಿ ಹಕ್ಕಿಗೆ ಹತ್ತಿರದ ಹಕ್ಕುಗಳು, ಉದಾಹರಣೆಗೆ ಪ್ರದರ್ಶನ, ಪ್ರಸಾರ, ಧ್ವನಿ ದಾಖಲೆ ಮತ್ತು ಸುವಿ ಜನೆರಿಸ್ ಡೇಟಾಬೇಸ್ ಹಕ್ಕುಗಳು, ಹಕ್ಕುಗಳನ್ನು ಹೇಗೆ ಲೇಬಲ್ ಮಾಡಲಾಗಿದೆ ಅಥವಾ ವರ್ಗೀಕರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಪರಿಗಣಿಸದೆ. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಾಗಿ, ಅಧ್ಯಾಯ 2(b)(1)-(2) ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹಕ್ಕುಗಳು ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳಲ್ಲ.
e. ಪರಿಣಾಮಕಾರಿ ತಂತ್ರಜ್ಞಾನ ಕ್ರಮಗಳು ಎಂದರೆ ಸರಿಯಾದ ಅಧಿಕಾರವಿಲ್ಲದೆ ತಿರಸ್ಕರಿಸಲಾಗದ ಕ್ರಮಗಳು, 1996 ಡಿಸೆಂಬರ್ 20 ರಂದು ಅಂಗೀಕೃತ WIPO ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಒಪ್ಪಂದದ ಕಲಂ 11 ಅಡಿಯಲ್ಲಿ ಕಾನೂನುಗಳು ಪೂರ್ಣಗೊಳಿಸುವ ಬಾಧ್ಯತೆಗಳನ್ನು ಹೊಂದಿವೆ ಮತ್ತು/ಅಥವಾ ಸಮಾನ ಅಂತಾರಾಷ್ಟ್ರೀಯ ಒಪ್ಪಂದಗಳು.
f. ವಿನಾಯಿತಿಗಳು ಮತ್ತು ಮಿತಿಗಳು ಎಂದರೆ ನ್ಯಾಯಸಮ್ಮತ ಬಳಕೆ, ನ್ಯಾಯಸಮ್ಮತ ವ್ಯವಹಾರ ಮತ್ತು/ಅಥವಾ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳಿಗೆ ಅನ್ವಯಿಸುವ ಯಾವುದೇ ಇತರ ವಿನಾಯಿತಿ ಅಥವಾ ಮಿತಿ, ಇದು ನಿಮ್ಮ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಬಳಕೆಗೆ ಅನ್ವಯಿಸುತ್ತದೆ.
g. ಪರವಾನಗಿ ಅಂಶಗಳು ಎಂದರೆ ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಹೆಸರಿನಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾದ ಪರವಾನಗಿ ಗುಣಲಕ್ಷಣಗಳು. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಪರವಾನಗಿ ಅಂಶಗಳು ಅಟ್ರಿಬ್ಯೂಷನ್ ಮತ್ತು ಶೇರ್ ಅಲೈಕ್.
h. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತು ಎಂದರೆ ಕಲಾತ್ಮಕ ಅಥವಾ ಸಾಹಿತ್ಯ ಕೃತಿ, ಡೇಟಾಬೇಸ್ ಅಥವಾ ಇತರ ವಸ್ತು, ಇದಕ್ಕೆ ಪರವಾನಗಿ ನೀಡುವವರು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯನ್ನು ಅನ್ವಯಿಸಿದ್ದಾರೆ.
i. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳು ಎಂದರೆ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳಿಗೆ ಒಳಪಟ್ಟ ನಿಮ್ಮ ಬಳಕೆಗೆ ಅನ್ವಯಿಸುವ ಎಲ್ಲಾ ಪ್ರತಿಕೃತಿ ಹಕ್ಕು ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳು, ಮತ್ತು ಪರವಾನಗಿ ನೀಡುವವರಿಗೆ ಪರವಾನಗಿ ನೀಡಲು ಅಧಿಕಾರವಿರುವ ಹಕ್ಕುಗಳು.
j. ಪರವಾನಗಿ ನೀಡುವವರು ಎಂದರೆ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಅಡಿಯಲ್ಲಿ ಹಕ್ಕುಗಳನ್ನು ನೀಡುವ ವ್ಯಕ್ತಿಗಳು ಅಥವಾ ಸಂಸ್ಥೆಗಳು.
k. ಹಂಚಿಕೆ ಎಂದರೆ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳ ಅಡಿಯಲ್ಲಿ ಅನುಮತಿ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ವಿಧಾನ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಸಾರ್ವಜನಿಕರಿಗೆ ವಸ್ತು ಒದಗಿಸುವುದು, ಉದಾಹರಣೆಗೆ ಪುನರುತ್ಪಾದನೆ, ಸಾರ್ವಜನಿಕ ಪ್ರದರ್ಶನ, ಸಾರ್ವಜನಿಕ ಪ್ರದರ್ಶನ, ವಿತರಣೆ, ಪ್ರಸಾರ, ಸಂವಹನ ಅಥವಾ ಆಮದು, ಮತ್ತು ಸಾರ್ವಜನಿಕರಿಗೆ ವಸ್ತುವನ್ನು ಲಭ್ಯವಿರುವಂತೆ ಮಾಡುವುದು, ಇದರಲ್ಲಿ ಸಾರ್ವಜನಿಕ ಸದಸ್ಯರು ತಮ್ಮ ಆಯ್ಕೆಮಾಡಿದ ಸ್ಥಳ ಮತ್ತು ಸಮಯದಲ್ಲಿ ವಸ್ತುವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
l. ಸುವಿ ಜನೆರಿಸ್ ಡೇಟಾಬೇಸ್ ಹಕ್ಕುಗಳು ಎಂದರೆ 1996 ಮಾರ್ಚ್ 11 ರಂದು ಯುರೋಪಿಯನ್ ಸಂಸತ್ತು ಮತ್ತು ಕೌನ್ಸಿಲ್‌ನ ನಿರ್ದೇಶನ 96/9/EC ಅಡಿಯಲ್ಲಿ ಡೇಟಾಬೇಸ್‌ಗಳ ಕಾನೂನು ರಕ್ಷಣೆಯ ಕುರಿತು ಹಕ್ಕುಗಳು, ತಿದ್ದುಪಡಿ ಮತ್ತು/ಅಥವಾ ಮುಂದುವರಿದ, ಮತ್ತು ಜಾಗತಿಕವಾಗಿ ಸಮಾನ ಹಕ್ಕುಗಳು.
m. ನೀವು ಎಂದರೆ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸುವ ವ್ಯಕ್ತಿ ಅಥವಾ ಸಂಸ್ಥೆ. ನಿಮ್ಮಿಗೆ ಹೊಂದುವ ಅರ್ಥವಿದೆ.
ಅಧ್ಯಾಯ 2 -- ವ್ಯಾಪ್ತಿ.
a. ಪರವಾನಗಿ ನೀಡುವುದು.
1. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳಿಗೆ ಒಳಪಟ್ಟಂತೆ,
ಪರವಾನಗಿ ನೀಡುವವರು ನಿಮಗೆ ಜಾಗತಿಕ, ರಾಯಲ್ಟಿ-ರಹಿತ,
ಉಪಪರವಾನಗಿ ನೀಡಲಾಗದ, ಅನನ್ಯವಲ್ಲದ, ರದ್ದುಗೊಳಿಸಲಾಗದ ಪರವಾನಗಿಯನ್ನು ನೀಡುತ್ತಾರೆ
ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಲು:
a. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಸಂಪೂರ್ಣ ಅಥವಾ ಭಾಗಶಃ ಪುನರುತ್ಪಾದನೆ ಮತ್ತು ಹಂಚಿಕೆ ಮಾಡುವುದು; ಮತ್ತು
b. ಹೊಂದಿಸಿದ ವಸ್ತುವನ್ನು ಉತ್ಪಾದನೆ, ಪುನರುತ್ಪಾದನೆ ಮತ್ತು ಹಂಚಿಕೆ ಮಾಡುವುದು.
2. ವಿನಾಯಿತಿಗಳು ಮತ್ತು ಮಿತಿಗಳು. ಸ್ಪಷ್ಟತೆಗಾಗಿ, ನಿಮ್ಮ ಬಳಕೆಗೆ ವಿನಾಯಿತಿಗಳು ಮತ್ತು ಮಿತಿಗಳು ಅನ್ವಯಿಸಿದಲ್ಲಿ,
ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಅನ್ವಯಿಸುವುದಿಲ್ಲ, ಮತ್ತು ನೀವು ಅದರ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಪಾಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
3. ಅವಧಿ. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಅವಧಿ ಅಧ್ಯಾಯ 6(a) ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ.
4. ಮಾಧ್ಯಮಗಳು ಮತ್ತು ಸ್ವರೂಪಗಳು; ತಾಂತ್ರಿಕ ಬದಲಾವಣೆಗಳಿಗೆ ಅನುಮತಿ. ಪರವಾನಗಿ ನೀಡುವವರು ನಿಮಗೆ ಎಲ್ಲಾ ಮಾಧ್ಯಮಗಳು ಮತ್ತು ಸ್ವರೂಪಗಳಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಲು ಅಧಿಕಾರ ನೀಡುತ್ತಾರೆ,
ಈಗ ತಿಳಿದಿರುವ ಅಥವಾ ಭವಿಷ್ಯದಲ್ಲಿ ಸೃಷ್ಟಿಯಾಗುವ, ಮತ್ತು ಅದನ್ನು ಮಾಡಲು ಅಗತ್ಯವಿರುವ ತಾಂತ್ರಿಕ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಅನುಮತಿಸುತ್ತಾರೆ.
ಪರವಾನಗಿ ನೀಡುವವರು ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಲು ಅಗತ್ಯವಿರುವ ತಾಂತ್ರಿಕ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ನಿಮ್ಮನ್ನು ನಿಷೇಧಿಸುವ ಯಾವುದೇ ಹಕ್ಕು ಅಥವಾ ಅಧಿಕಾರವನ್ನು ತಿರಸ್ಕರಿಸುತ್ತಾರೆ ಮತ್ತು/ಅಥವಾ ಒಪ್ಪಿಕೊಳ್ಳುತ್ತಾರೆ.
ಪರಿಣಾಮಕಾರಿ ತಂತ್ರಜ್ಞಾನ ಕ್ರಮಗಳನ್ನು ತಿರಸ್ಕರಿಸಲು ಅಗತ್ಯವಿರುವ ತಾಂತ್ರಿಕ ಬದಲಾವಣೆಗಳನ್ನು ಸಹ ಸೇರಿವೆ.
ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಉದ್ದೇಶಕ್ಕಾಗಿ, ಈ ಅಧ್ಯಾಯ 2(a)(4) ರಲ್ಲಿ ಅನುಮತಿಸಲಾದ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು ಎಂದಿಗೂ ಹೊಂದಿಸಿದ ವಸ್ತುವನ್ನು ಉತ್ಪಾದಿಸುವುದಿಲ್ಲ.
5. ಕೆಳಮಟ್ಟದ ಸ್ವೀಕರಿಸುವವರು.
a. ಪರವಾನಗಿ ನೀಡುವವರಿಂದ ಆಫರ್ -- ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತು. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಪ್ರತಿಯೊಂದು ಸ್ವೀಕರಿಸುವವರು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ನಿಯಮಗಳು ಮತ್ತು ಷರತ್ತುಗಳ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಲು ಪರವಾನಗಿ ನೀಡುವವರಿಂದ ಆಫರ್ ಪಡೆಯುತ್ತಾರೆ.
b. ಪರವಾನಗಿ ನೀಡುವವರಿಂದ ಹೆಚ್ಚುವರಿ ಆಫರ್ -- ಹೊಂದಿಸಿದ ವಸ್ತು. ನಿಮ್ಮಿಂದ ಹೊಂದಿಸಿದ ವಸ್ತುವಿನ ಪ್ರತಿಯೊಂದು ಸ್ವೀಕರಿಸುವವರು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪರವಾನಗಿ ನೀಡುವವರಿಂದ ಹೊಂದಿಸಿದ ವಸ್ತುವಿನಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಲು ಆಫರ್ ಪಡೆಯುತ್ತಾರೆ, ನೀವು ಅನ್ವಯಿಸುವ ಹೊಂದಿಸುವವರ ಪರವಾನಗಿಯ ಷರತ್ತುಗಳ ಅಡಿಯಲ್ಲಿ.
c. ಕೆಳಮಟ್ಟದ ನಿರ್ಬಂಧಗಳಿಲ್ಲ. ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಯಾವುದೇ ಸ್ವೀಕರಿಸುವವರ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳ ಬಳಕೆಯನ್ನು ನಿರ್ಬಂಧಿಸುವ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಅಥವಾ ವಿಭಿನ್ನ ನಿಯಮಗಳು ಅಥವಾ ಷರತ್ತುಗಳನ್ನು ನೀಡಲು ಅಥವಾ ಪರಿಣಾಮಕಾರಿ ತಂತ್ರಜ್ಞಾನ ಕ್ರಮಗಳನ್ನು ಅನ್ವಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
6. ಯಾವುದೇ ಅನುಮೋದನೆ ಇಲ್ಲ. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯಲ್ಲಿ ಯಾವುದೂ ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಬಳಕೆ ಪರವಾನಗಿ ನೀಡುವವರು ಅಥವಾ ಇತರರು, ಅಧ್ಯಾಯ 3(a)(1)(A)(i) ನಲ್ಲಿ ನೀಡಲಾದ ಅಟ್ರಿಬ್ಯೂಷನ್ ಪಡೆಯುವವರಾಗಿ, ಸಂಪರ್ಕ ಹೊಂದಿರುವುದು, ಪ್ರಾಯೋಜಿತ ಅಥವಾ ಅಧಿಕೃತ ಸ್ಥಾನಮಾನ ಪಡೆದಿರುವುದು ಎಂದು ಹೇಳಲು ಅಥವಾ ಸೂಚಿಸಲು ಪರವಾನತಿ ನೀಡುವುದಿಲ್ಲ.
b. ಇತರ ಹಕ್ಕುಗಳು.
1. ನೈತಿಕ ಹಕ್ಕುಗಳು, ಉದಾಹರಣೆಗೆ ಅಖಂಡತೆ ಹಕ್ಕು, ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲ್ಪಟ್ಟಿಲ್ಲ, ಹಾಗೆಯೇ ಪ್ರಸಿದ್ಧಿ, ಗೌಪ್ಯತೆ ಮತ್ತು/ಅಥವಾ ಇತರ ಸಮಾನ ವ್ಯಕ್ತಿತ್ವ ಹಕ್ಕುಗಳು; ಆದಾಗ್ಯೂ, ಸಾಧ್ಯವಾದಷ್ಟು, ಪರವಾನಗಿ ನೀಡುವವರು ಈ ಹಕ್ಕುಗಳನ್ನು ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಲು ಅವಕಾಶ ನೀಡಲು ಅಗತ್ಯವಿರುವ ಮಟ್ಟಿಗೆ ತಿರಸ್ಕರಿಸುತ್ತಾರೆ ಮತ್ತು/ಅಥವಾ ಒಪ್ಪಿಕೊಳ್ಳುತ್ತಾರೆ, ಆದರೆ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಅಲ್ಲ.
2. ಪೇಟೆಂಟ್ ಮತ್ತು ಟ್ರೇಡ್‌ಮಾರ್ಕ್ ಹಕ್ಕುಗಳು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲ್ಪಟ್ಟಿಲ್ಲ.
3. ಸಾಧ್ಯವಾದಷ್ಟು, ಪರವಾನಗಿ ನೀಡುವವರು ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸಿದಕ್ಕಾಗಿ ನೇರವಾಗಿ ಅಥವಾ ಸ್ವಯಂಸೇವಕ ಸಂಘದ ಮೂಲಕ ಯಾವುದೇ ಸ್ವಯಂಸೇವಕ ಅಥವಾ ತ್ಯಜಿಸಬಹುದಾದ ಕಾನೂನು ಅಥವಾ ಬಾಧ್ಯ ಪರವಾನಗಿ ಯೋಜನೆಯಡಿ ರಾಯಲ್ಟಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಹಕ್ಕನ್ನು ತಿರಸ್ಕರಿಸುತ್ತಾರೆ. ಇತರ ಎಲ್ಲಾ ಪ್ರಕರಣಗಳಲ್ಲಿ ಪರವಾನಗಿ ನೀಡುವವರು ಸ್ಪಷ್ಟವಾಗಿ ಆ ರಾಯಲ್ಟಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಹಕ್ಕನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತಾರೆ.
ಅಧ್ಯಾಯ 3 -- ಪರವಾನಗಿ ಷರತ್ತುಗಳು.
ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳನ್ನು ಬಳಸುವುದು ಕೆಳಗಿನ ಷರತ್ತುಗಳಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಒಳಪಟ್ಟಿದೆ.
a. ಅಟ್ರಿಬ್ಯೂಷನ್.
1. ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಹಂಚಿದರೆ (ಬದಲಿಸಿದ ರೂಪದಲ್ಲಿಯೂ ಸೇರಿ), ನೀವು:
a. ಪರವಾನಗಿ ನೀಡುವವರು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನೊಂದಿಗೆ ಒದಗಿಸಿದ ಕೆಳಗಿನವುಗಳನ್ನು ಉಳಿಸಬೇಕು:
i. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಸೃಷ್ಟಿಕರ್ತ(ಗಳು) ಮತ್ತು ಅಟ್ರಿಬ್ಯೂಷನ್ ಪಡೆಯಲು ನಿಯೋಜಿಸಲಾದ ಇತರರ ಗುರುತಿನ ಮಾಹಿತಿ, ಪರವಾನಗಿ ನೀಡುವವರು ಕೇಳಿದ ಯಾವುದೇ ಯುಕ್ತಿಯುತ ರೀತಿಯಲ್ಲಿ (ನಾಮವಾಚಕ ಬಳಕೆ ಸಹ ಸೇರಿ);
ii. ಪ್ರತಿಕೃತಿ ಸೂಚನೆ;
iii. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗೆ ಉಲ್ಲೇಖಿಸುವ ಸೂಚನೆ;
iv. ಭರವಸೆಗಳ ನಿರಾಕರಣೆಯ ಸೂಚನೆ;
v. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿಗೆ ಯುಆರ್‌ಐ ಅಥವಾ ಹೈಪರ್‌ಲಿಂಕ್, ಯುಕ್ತಿಯುತವಾಗಿ ಸಾಧ್ಯವಾದಷ್ಟು;
b. ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಬದಲಿಸಿದರೆ ಸೂಚಿಸಬೇಕು ಮತ್ತು ಯಾವುದೇ ಹಿಂದಿನ ಬದಲಾವಣೆಗಳ ಸೂಚನೆಯನ್ನು ಉಳಿಸಬೇಕು; ಮತ್ತು
c. ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಲ್ಪಟ್ಟಿದೆ ಎಂದು ಸೂಚಿಸಿ, ಮತ್ತು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಪಠ್ಯ ಅಥವಾ ಯುಆರ್‌ಐ ಅಥವಾ ಹೈಪರ್‌ಲಿಂಕ್ ಅನ್ನು ಸೇರಿಸಬೇಕು.
2. ನೀವು ಅಧ್ಯಾಯ 3(a)(1) ರ ಷರತ್ತುಗಳನ್ನು ಯಾವುದೇ ಯುಕ್ತಿಯುತ ರೀತಿಯಲ್ಲಿ ಪೂರೈಸಬಹುದು, ಮಾಧ್ಯಮ, ವಿಧಾನ ಮತ್ತು ಸನ್ನಿವೇಶವನ್ನು ಆಧರಿಸಿ, ನೀವು ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವನ್ನು ಹಂಚುವಾಗ. ಉದಾಹರಣೆಗೆ, ಅಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಸಂಪನ್ಮೂಲಕ್ಕೆ ಯುಆರ್‌ಐ ಅಥವಾ ಹೈಪರ್‌ಲಿಂಕ್ ಒದಗಿಸುವ ಮೂಲಕ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಬಹುದು.
3. ಪರವಾನಗಿ ನೀಡುವವರ ವಿನಂತಿಯಿಂದ, ನೀವು ಅಧ್ಯಾಯ 3(a)(1)(A) ರಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಮಾಹಿತಿಯನ್ನು ಯುಕ್ತಿಯುತವಾಗಿ ಸಾಧ್ಯವಾದಷ್ಟು ತೆಗೆದುಹಾಕಬೇಕು.
b. ಶೇರ್ ಅಲೈಕ್.
ಅಧ್ಯಾಯ 3(a) ರ ಷರತ್ತುಗಳಿಗೆ ಹೆಚ್ಚುವರಿ, ನೀವು ಹೊಂದಿಸಿದ ವಸ್ತುವನ್ನು ಹಂಚಿದರೆ, ಕೆಳಗಿನ ಷರತ್ತುಗಳು ಅನ್ವಯಿಸುತ್ತವೆ.
1. ನೀವು ಅನ್ವಯಿಸುವ ಹೊಂದಿಸುವವರ ಪರವಾನಗಿ ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಪರವಾನಗಿ ಆಗಿರಬೇಕು, ಅದೇ ಪರವಾನಗಿ ಅಂಶಗಳೊಂದಿಗೆ, ಈ ಆವೃತ್ತಿ ಅಥವಾ ನಂತರದ ಆವೃತ್ತಿ, ಅಥವಾ BY-SA ಹೊಂದಾಣಿಕೆಯ ಪರವಾನಗಿ.
2. ನೀವು ಅನ್ವಯಿಸುವ ಹೊಂದಿಸುವವರ ಪರವಾನಗಿಯ ಪಠ್ಯ ಅಥವಾ ಯುಆರ್‌ಐ ಅಥವಾ ಹೈಪರ್‌ಲಿಂಕ್ ಅನ್ನು ಸೇರಿಸಬೇಕು. ನೀವು ಈ ಷರತ್ತನ್ನು ಯಾವುದೇ ಯುಕ್ತಿಯುತ ರೀತಿಯಲ್ಲಿ ಪೂರೈಸಬಹುದು, ಮಾಧ್ಯಮ, ವಿಧಾನ ಮತ್ತು ಸನ್ನಿವೇಶವನ್ನು ಆಧರಿಸಿ ನೀವು ಹೊಂದಿಸಿದ ವಸ್ತುವನ್ನು ಹಂಚುವಾಗ.
3. ನೀವು ಹೊಂದಿಸಿದ ವಸ್ತುವಿನ ಮೇಲೆ ನೀವು ಅನ್ವಯಿಸುವ ಹೊಂದಿಸುವವರ ಪರವಾನಗಿಯ ಅಡಿಯಲ್ಲಿ ನೀಡಲಾದ ಹಕ್ಕುಗಳ ಬಳಕೆಯನ್ನು ನಿರ್ಬಂಧಿಸುವ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಅಥವಾ ವಿಭಿನ್ನ ನಿಯಮಗಳು ಅಥವಾ ಪರಿಣಾಮಕಾರಿ ತಂತ್ರಜ್ಞಾನ ಕ್ರಮಗಳನ್ನು ಅನ್ವಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಅಧ್ಯಾಯ 4 -- ಸುವಿ ಜನೆರಿಸ್ ಡೇಟಾಬೇಸ್ ಹಕ್ಕುಗಳು.
ಪರವಾನಗಿಗೊಳಿಸಲಾದ ಹಕ್ಕುಗಳಲ್ಲಿ ನಿಮ್ಮ ಪರವಾನಗಿಗೊಳಿಸಲಾದ ವಸ್ತುವಿನ ಬಳಕೆಗೆ ಅನ್ವಯಿಸುವ ಸುವಿ ಜನೆರಿಸ್ ಡೇಟಾಬೇಸ್ ಹಕ್ಕುಗಳು ಇದ್ದಲ್ಲಿ:
a. ಸ್ಪಷ್ಟತೆಗಾಗಿ, ಅಧ್ಯಾಯ 2(a)(1) ನಿಮಗೆ ಡೇಟಾಬೇಸ್‌ನ ಎಲ್ಲಾ ಅಥವಾ ಪ್ರಮುಖ ಭಾಗದ ವಿಷಯವನ್ನು ಹೊರತೆಗೆಯಲು, ಮರುಬಳಕೆ ಮಾಡಲು, ಪುನರುತ್ಪಾದನೆ ಮಾಡಲು ಮತ್ತು ಹಂಚಿಕೆ ಮಾಡಲು ಹಕ್ಕು ನೀಡುತ್ತದೆ;
b. ನೀವು ಡೇಟಾಬೇಸ್‌ನ ಎಲ್ಲಾ ಅಥವಾ ಪ್ರಮುಖ ಭಾಗವನ್ನು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸೇರಿಸಿದರೆ, ನೀವು ಸುವಿ ಜನೆರಿಸ್ ಡೇಟಾಬೇಸ್
ಹಕ್ಕುಗಳು, ನಂತರ ನೀವು ಹೊಂದಿರುವ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ Sui Generis ಡೇಟಾಬೇಸ್
ಹಕ್ಕುಗಳು (ಆದರೆ ಅದರ ವೈಯಕ್ತಿಕ ವಿಷಯಗಳು ಅಲ್ಲ) ಹೊಂದಿರುವ ಅಡಾಪ್ಟೆಡ್ ಮೆಟೀರಿಯಲ್,
ಸೆಕ್ಷನ್ 3(b) ಉದ್ದೇಶಗಳಿಗಾಗಿ ಸಹ ಸೇರಿದೆ; ಮತ್ತು
c. ನೀವು ಡೇಟಾಬೇಸ್‌ನ ಎಲ್ಲಾ ಅಥವಾ ಪ್ರಮುಖ ಭಾಗವನ್ನು ಹಂಚಿಕೊಳ್ಳುವಾಗ ಸೆಕ್ಷನ್ 3(a) ರಲ್ಲಿ ನೀಡಲಾದ ಶರತ್ತುಗಳನ್ನು ನೀವು ಪಾಲಿಸಬೇಕು.
ಸಂದೇಹ ನಿವಾರಣೆಗೆ, ಈ ಸೆಕ್ಷನ್ 4 ನಿಮ್ಮ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ಇರುವ ಬಾಧ್ಯತೆಗಳನ್ನು ಪೂರಕವಾಗಿದ್ದು, ಪರವಾನಗಿಯ ಹಕ್ಕುಗಳು ಇತರ ಕಾಪಿರೈಟ್ ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದಲ್ಲಿ ಅವುಗಳನ್ನು ಬದಲಿಸುವುದಿಲ್ಲ.
ಸೆಕ್ಷನ್ 5 -- ಜವಾಬ್ದಾರಿಗಳ ನಿರಾಕರಣೆ ಮತ್ತು ಹೊಣೆಗಾರಿಕೆಯ ಮಿತಿ.
a. ಪರವಾನಗಿ ನೀಡುವವರು ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಪ್ರತ್ಯೇಕವಾಗಿ ಒಪ್ಪಿಕೊಂಡಿಲ್ಲದಿದ್ದರೆ, ಸಾಧ್ಯವಾದಷ್ಟು, ಪರವಾನಗಿ ನೀಡುವವರು ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವನ್ನು ಹಾಗೆಯೇ ಮತ್ತು ಲಭ್ಯವಿರುವಂತೆ ನೀಡುತ್ತಾರೆ ಮತ್ತು ಯಾವುದೇ ರೀತಿಯ ಪ್ರತಿನಿಧಾನಗಳು ಅಥವಾ ಜವಾಬ್ದಾರಿಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ, ಸ್ಪಷ್ಟ, ಅರ್ಥೈಸಿದ, ಕಾನೂನಾತ್ಮಕ ಅಥವಾ ಇತರ. ಇದರಲ್ಲಿ, ಯಾವುದೇ ಮಿತಿ ಇಲ್ಲದೆ, ಶೀರ್ಷಿಕೆ, ವ್ಯಾಪಾರಿಕತೆ, ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶಕ್ಕೆ ಹೊಂದಿಕೊಳ್ಳುವಿಕೆ, ಉಲ್ಲಂಘನೆ ಇಲ್ಲದಿರುವಿಕೆ, ಅಡಗಿದ ಅಥವಾ ಇತರ ದೋಷಗಳ ಇಲ್ಲದಿರುವಿಕೆ, ನಿಖರತೆ, ಅಥವಾ ದೋಷಗಳ ಇರುವಿಕೆ ಅಥವಾ ಇಲ್ಲದಿರುವಿಕೆ, ತಿಳಿದಿರುವ ಅಥವಾ ಕಂಡುಹಿಡಿಯಬಹುದಾದುದೇ ಆಗಿರಲಿ, ಜವಾಬ್ದಾರಿಗಳು ಸೇರಿವೆ. ಜವಾಬ್ದಾರಿಗಳ ನಿರಾಕರಣೆಗಳು ಸಂಪೂರ್ಣ ಅಥವಾ ಭಾಗಶಃ ಅನುಮತಿಸಲಾಗದಿದ್ದಲ್ಲಿ, ಈ ನಿರಾಕರಣೆ ನಿಮ್ಮ ಮೇಲೆ ಅನ್ವಯಿಸದಿರಬಹುದು.
b. ಸಾಧ್ಯವಾದಷ್ಟು, ಯಾವುದೇ ಕಾನೂನಾತ್ಮಕ ಸಿದ್ಧಾಂತದ (ಮೂಲತಃ, ನಿರ್ಲಕ್ಷ್ಯ ಸೇರಿದಂತೆ) ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿ ನೀಡುವವರು ನಿಮಗೆ ಯಾವುದೇ ನೇರ, ವಿಶೇಷ, ಪರೋಕ್ಷ, ಅನೈಚ್ಛಿಕ, ಪರಿಣಾಮಕಾರಿ, ಶಿಕ್ಷಾತ್ಮಕ, ಉದಾಹರಣಾತ್ಮಕ ಅಥವಾ ಇತರ ನಷ್ಟಗಳು, ವೆಚ್ಚಗಳು, ಖರ್ಚುಗಳು ಅಥವಾ ಹಾನಿಗಳಿಗಾಗಿ ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ, ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಅಥವಾ ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವಿನ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವವು, ಪರವಾನಗಿ ನೀಡುವವರು ಇಂತಹ ನಷ್ಟಗಳು, ವೆಚ್ಚಗಳು, ಖರ್ಚುಗಳು ಅಥವಾ ಹಾನಿಗಳ ಸಾಧ್ಯತೆಯನ್ನು ತಿಳಿಸಿದ್ದರೂ ಸಹ. ಹೊಣೆಗಾರಿಕೆಯ ಮಿತಿ ಸಂಪೂರ್ಣ ಅಥವಾ ಭಾಗಶಃ ಅನುಮತಿಸಲಾಗದಿದ್ದಲ್ಲಿ, ಈ ಮಿತಿ ನಿಮ್ಮ ಮೇಲೆ ಅನ್ವಯಿಸದಿರಬಹುದು.
c. ಮೇಲ್ಕಂಡ ಜವಾಬ್ದಾರಿಗಳ ನಿರಾಕರಣೆ ಮತ್ತು ಹೊಣೆಗಾರಿಕೆಯ ಮಿತಿಯನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು, ಸಂಪೂರ್ಣ ನಿರಾಕರಣೆ ಮತ್ತು ಎಲ್ಲಾ ಹೊಣೆಗಾರಿಕೆಗಳ ತ್ಯಾಗದಂತೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.
ಸೆಕ್ಷನ್ 6 -- ಅವಧಿ ಮತ್ತು ರದ್ದುಪಡಿಸುವಿಕೆ.
a. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಇಲ್ಲಿ ಪರವಾನಗಿಗೊಳಿಸಿದ ಕಾಪಿರೈಟ್ ಮತ್ತು ಸಮಾನ ಹಕ್ಕುಗಳ ಅವಧಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ಆದರೆ, ನೀವು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯನ್ನು ಪಾಲಿಸದಿದ್ದರೆ, ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ನಿಮ್ಮ ಹಕ್ಕುಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರದ್ದುಪಡಿಸಲಾಗುತ್ತದೆ.
b. ಸೆಕ್ಷನ್ 6(a) ಅಡಿಯಲ್ಲಿ ನಿಮ್ಮ ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವಿನ ಬಳಕೆಯ ಹಕ್ಕು ರದ್ದುಪಡಿಸಿದಾಗ, ಅದು ಪುನಃಸ್ಥಾಪಿತವಾಗುತ್ತದೆ:
1. ಉಲ್ಲಂಘನೆ ಪರಿಹಾರವಾದ ದಿನಾಂಕದಿಂದ ಸ್ವಯಂಚಾಲಿತವಾಗಿ, ಅದು ನಿಮ್ಮ ಉಲ್ಲಂಘನೆಯನ್ನು ಕಂಡುಹಿಡಿದ 30 ದಿನಗಳ ಒಳಗೆ ಪರಿಹಾರವಾದರೆ; ಅಥವಾ
2. ಪರವಾನಗಿ ನೀಡುವವರ ಸ್ಪಷ್ಟ ಪುನಃಸ್ಥಾಪನೆಯ ಮೂಲಕ.
ಸಂದೇಹ ನಿವಾರಣೆಗೆ, ಈ ಸೆಕ್ಷನ್ 6(b) ನಿಮ್ಮ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಉಲ್ಲಂಘನೆಗಳಿಗೆ ಪರಿಹಾರಗಳನ್ನು ಹುಡುಕಲು ಪರವಾನಗಿ ನೀಡುವವರ ಹಕ್ಕನ್ನು ಪ್ರಭಾವಿತಗೊಳಿಸುವುದಿಲ್ಲ.
c. ಸಂದೇಹ ನಿವಾರಣೆಗೆ, ಪರವಾನಗಿ ನೀಡುವವರು ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವನ್ನು ವಿಭಿನ್ನ ಶರತ್ತುಗಳು ಅಥವಾ ನಿಯಮಗಳ ಅಡಿಯಲ್ಲಿ ನೀಡಬಹುದು ಅಥವಾ ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ವಿತರಣೆ ನಿಲ್ಲಿಸಬಹುದು; ಆದರೆ, ಇದರಿಂದ ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ರದ್ದುಪಡಿಸುವುದಿಲ್ಲ.
d. ಸೆಕ್ಷನ್ 1, 5, 6, 7, ಮತ್ತು 8 ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ರದ್ದುಪಡಿಸಿದ ನಂತರವೂ ಜಾರಿಯಲ್ಲಿರುತ್ತವೆ.
ಸೆಕ್ಷನ್ 7 -- ಇತರ ಶರತ್ತುಗಳು ಮತ್ತು ನಿಯಮಗಳು.
a. ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಒಪ್ಪಿಕೊಳ್ಳದಿದ್ದರೆ, ಪರವಾನಗಿ ನೀಡುವವರು ನಿಮ್ಮಿಂದ ಸಂವಹನಗೊಂಡ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಅಥವಾ ವಿಭಿನ್ನ ಶರತ್ತುಗಳು ಅಥವಾ ನಿಯಮಗಳಿಗೆ ಬದ್ಧರಾಗುವುದಿಲ್ಲ.
b. ಇಲ್ಲಿ ಹೇಳದಿರುವ ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವಿನ ಬಗ್ಗೆ ಯಾವುದೇ ವ್ಯವಸ್ಥೆಗಳು, ಅರ್ಥಮಾಡಿಕೆಗಳು ಅಥವಾ ಒಪ್ಪಂದಗಳು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ನಿಯಮಗಳು ಮತ್ತು ಶರತ್ತುಗಳಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿದ್ದು ಸ್ವತಂತ್ರವಾಗಿವೆ.
ಸೆಕ್ಷನ್ 8 -- ವ್ಯಾಖ್ಯಾನ.
a. ಸಂದೇಹ ನಿವಾರಣೆಗೆ, ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವಿನ ಯಾವುದೇ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು, ಮಿತಿ ಹಾಕುವುದು, ನಿಯಮಗಳನ್ನು ವಿಧಿಸುವುದು ಅಥವಾ ನಿಯಂತ್ರಿಸುವುದಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಾರದು, ಅದು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ಅನುಮತಿಸದ ಬಳಕೆಯಾಗಿರಬಹುದು.
b. ಸಾಧ್ಯವಾದಷ್ಟು, ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಯಾವುದೇ ವಿಧಿ ಅನ್ವಯಿಸದಿದ್ದರೆ, ಅದನ್ನು ಕನಿಷ್ಠ ಅಗತ್ಯವಿರುವ ಮಟ್ಟಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುರೂಪಗೊಳಿಸಲಾಗುತ್ತದೆ. ಮರುರೂಪಗೊಳಿಸಲಾಗದಿದ್ದರೆ, ಅದನ್ನು ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯಿಂದ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ, ಉಳಿದ ನಿಯಮಗಳು ಮತ್ತು ಶರತ್ತುಗಳ ಅನ್ವಯತೆಯನ್ನು ಪ್ರಭಾವಿತಗೊಳಿಸುವುದಿಲ್ಲ.
c. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಯ ಯಾವುದೇ ನಿಯಮ ಅಥವಾ ಶರತ್ತು ತ್ಯಜಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಅನುಸರಿಸಲು ವಿಫಲವಾದುದಕ್ಕೆ ಒಪ್ಪಿಗೆಯಿಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ ಪರವಾನಗಿ ನೀಡುವವರ ಸ್ಪಷ್ಟ ಒಪ್ಪಿಗೆಯಿದ್ದಾಗ ಮಾತ್ರ ಅನುಮತಿಸಲಾಗುತ್ತದೆ.
d. ಈ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಪರವಾನಗಿ ನೀಡುವವರ ಅಥವಾ ನಿಮ್ಮ ಮೇಲೆ ಅನ್ವಯಿಸುವ ಯಾವುದೇ ವಿಶೇಷ ಹಕ್ಕುಗಳು ಮತ್ತು ರಕ್ಷಣೆಗಳನ್ನು ಮಿತಿಗೊಳಿಸುವುದಾಗಿ ಅಥವಾ ತ್ಯಜಿಸುವುದಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಾರದು, ಇದರಲ್ಲಿ ಯಾವುದೇ ನ್ಯಾಯಾಂಗ ಅಥವಾ ಅಧಿಕಾರಿಗಳ ಕಾನೂನಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆಗಳು ಸೇರಿವೆ.
=======================================================================
ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ತನ್ನ ಸಾರ್ವಜನಿಕ
ಪರವಾನಗಿಗಳ ಪಕ್ಷವಲ್ಲ. ಆದಾಗ್ಯೂ, ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ತನ್ನ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳಲ್ಲಿ ಒಂದನ್ನು ತನ್ನ ಪ್ರಕಟಿಸುವ ವಸ್ತುಗಳಿಗೆ ಅನ್ವಯಿಸಲು ಆಯ್ಕೆಮಾಡಬಹುದು ಮತ್ತು ಆ ಸಂದರ್ಭಗಳಲ್ಲಿ "ಪರವಾನಗಿ ನೀಡುವವರು" ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳ ಪಠ್ಯವನ್ನು CC0 ಸಾರ್ವಜನಿಕ
ಡೊಮೇನ್ ಸಮರ್ಪಣೆಯಡಿ ಸಾರ್ವಜನಿಕ ಡೊಮೇನ್‌ಗೆ ಮೀಸಲಿಟ್ಟಿದೆ. ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ವಸ್ತು ಹಂಚಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುವ ಸೀಮಿತ ಉದ್ದೇಶವನ್ನು ಹೊರತುಪಡಿಸಿ ಅಥವಾcreativecommons.org/policies ನಲ್ಲಿ ಪ್ರಕಟಿಸಿರುವ ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ನೀತಿಗಳ ಪ್ರಕಾರ, ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ "ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್" ಎಂಬ ಟ್ರೇಡ್‌ಮಾರ್ಕ್ ಅಥವಾ ಯಾವುದೇ ಇತರ ಟ್ರೇಡ್‌ಮಾರ್ಕ್ ಅಥವಾ ಲೋಗೋವನ್ನು ತನ್ನ ಪೂರ್ವ ಲಿಖಿತ ಅನುಮತಿಯಿಲ್ಲದೆ ಬಳಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ, ಇದರಲ್ಲಿ ಯಾವುದೇ ಅನಧಿಕೃತ ಬದಲಾವಣೆಗಳು ಅಥವಾ ಯಾವುದೇ ಇತರ ವ್ಯವಸ್ಥೆಗಳು, ಅರ್ಥಮಾಡಿಕೆಗಳು ಅಥವಾ ಪರವಾನಗಿಗೊಳಿಸಿದ ವಸ್ತುವಿನ ಬಳಕೆಯ ಬಗ್ಗೆ ಒಪ್ಪಂದಗಳು ಸೇರಿವೆ. ಸಂದೇಹ ನಿವಾರಣೆಗೆ, ಈ ಪ್ಯಾರಾಗ್ರಾಫ್ ಸಾರ್ವಜನಿಕ ಪರವಾನಗಿಗಳ ಭಾಗವಲ್ಲ.
ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಅನ್ನು creativecommons.org ನಲ್ಲಿ ಸಂಪರ್ಕಿಸಬಹುದು.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

23
translations/kn/sketchnotes/README.md
Unescape View File

@ -0,0 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a88d5918c1b9da69a40d917a0840c497",
"translation_date": "2025-12-19T13:12:40+00:00",
"source_file": "sketchnotes/README.md",
"language_code": "kn"
}
-->
ಎಲ್ಲಾ ಪಠ್ಯಕ್ರಮದ ಸ್ಕೆಚ್‌ನೋಟ್ಗಳನ್ನು ಇಲ್ಲಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು.
🖨 ಉನ್ನತ-ರಿಜಲ್ಯೂಶನ್‌ನಲ್ಲಿ ಮುದ್ರಣಕ್ಕಾಗಿ, TIFF ಆವೃತ್ತಿಗಳು [ಈ ರೆಪೋ](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff) ನಲ್ಲಿ ಲಭ್ಯವಿವೆ.
🎨 ರಚಿಸಿದವರು: [Tomomi Imura](https://github.com/girliemac) (ಟ್ವಿಟ್ಟರ್: [@girlie_mac](https://twitter.com/girlie_mac))
[![CC BY-SA 4.0](https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-sa/4.0/)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

161
translations/ml/1-Introduction/1-intro-to-ML/README.md
Unescape View File

@ -0,0 +1,161 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "69389392fa6346e0dfa30f664b7b6fec",
"translation_date": "2025-12-19T13:24:00+00:00",
"source_file": "1-Introduction/1-intro-to-ML/README.md",
"language_code": "ml"
}
-->
# മെഷീൻ ലേണിങ്ങിലേക്ക് പരിചയം
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
---
[![ML for beginners - Introduction to Machine Learning for Beginners](https://img.youtube.com/vi/6mSx_KJxcHI/0.jpg)](https://youtu.be/6mSx_KJxcHI "ML for beginners - Introduction to Machine Learning for Beginners")
> 🎥 ഈ പാഠം വിശദീകരിക്കുന്ന ഒരു ചെറിയ വീഡിയോക്കായി മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്യുക.
മെഷീൻ ലേണിങ്ങിന്റെ ക്ലാസിക്കൽ കോഴ്സിലേക്ക് സ്വാഗതം! നിങ്ങൾ ഈ വിഷയത്തിൽ പൂർണ്ണമായും പുതുതായി ആണോ, അല്ലെങ്കിൽ ഒരു പരിചയസമ്പന്നനായ ML പ്രാക്ടീഷണറായിട്ടുണ്ടോ, ഞങ്ങൾ നിങ്ങളെ ഇവിടെ കാണാൻ സന്തോഷിക്കുന്നു! നിങ്ങളുടെ ML പഠനത്തിന് സൗഹൃദപരമായ ഒരു തുടക്കമിടാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, കൂടാതെ നിങ്ങളുടെ [പ്രതികരണങ്ങൾ](https://github.com/microsoft/ML-For-Beginners/discussions) വിലയിരുത്താനും, മറുപടി നൽകാനും, ഉൾപ്പെടുത്താനും ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
[![Introduction to ML](https://img.youtube.com/vi/h0e2HAPTGF4/0.jpg)](https://youtu.be/h0e2HAPTGF4 "Introduction to ML")
> 🎥 മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്യുക: MIT-യുടെ ജോൺ ഗുട്ടാഗ് മെഷീൻ ലേണിങ്ങിനെ പരിചയപ്പെടുത്തുന്നു
---
## മെഷീൻ ലേണിങ്ങ് ആരംഭിക്കുന്നത്
ഈ പാഠ്യപദ്ധതിയുമായി തുടങ്ങുന്നതിന് മുമ്പ്, നിങ്ങളുടെ കമ്പ്യൂട്ടർ സജ്ജമാക്കി, ലോക്കലായി നോട്ട്‌ബുക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ തയ്യാറാക്കേണ്ടതാണ്.
- **ഈ വീഡിയോകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ മെഷീൻ ക്രമീകരിക്കുക**. നിങ്ങളുടെ സിസ്റ്റത്തിൽ [Python ഇൻസ്റ്റാൾ ചെയ്യുന്നത്](https://youtu.be/CXZYvNRIAKM) എങ്ങനെ എന്നതും, വികസനത്തിനായി [ടെക്സ്റ്റ് എഡിറ്റർ സജ്ജമാക്കുന്നത്](https://youtu.be/EU8eayHWoZg) എങ്ങനെ എന്നതും പഠിക്കാൻ താഴെ കൊടുത്ത ലിങ്കുകൾ ഉപയോഗിക്കുക.
- **Python പഠിക്കുക**. ഈ കോഴ്സിൽ ഉപയോഗിക്കുന്ന, ഡാറ്റാ സയന്റിസ്റ്റുകൾക്ക് ഉപകാരപ്രദമായ പ്രോഗ്രാമിംഗ് ഭാഷയായ [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott) അടിസ്ഥാനമായി അറിയുന്നത് ശുപാർശ ചെയ്യുന്നു.
- **Node.js, JavaScript പഠിക്കുക**. വെബ് ആപ്പുകൾ നിർമ്മിക്കുമ്പോൾ ഈ കോഴ്സിൽ JavaScript ചിലപ്പോൾ ഉപയോഗിക്കുന്നു, അതിനാൽ [node](https://nodejs.org)യും [npm](https://www.npmjs.com/)യും ഇൻസ്റ്റാൾ ചെയ്തിരിക്കണം, കൂടാതെ Python, JavaScript വികസനത്തിനായി [Visual Studio Code](https://code.visualstudio.com/) ലഭ്യമാകണം.
- **GitHub അക്കൗണ്ട് സൃഷ്ടിക്കുക**. നിങ്ങൾ ഇവിടെ [GitHub](https://github.com) വഴി എത്തിയതിനാൽ, നിങ്ങൾക്ക് അക്കൗണ്ട് ഉണ്ടാകാം, ഇല്ലെങ്കിൽ ഒരു അക്കൗണ്ട് സൃഷ്ടിച്ച് ഈ പാഠ്യപദ്ധതി ഫോർക്ക് ചെയ്ത് നിങ്ങളുടെ സ്വന്തം ഉപയോഗത്തിനായി ഉപയോഗിക്കുക. (നമുക്ക് ഒരു സ്റ്റാർ നൽകാനും മടിക്കേണ്ട 😊)
- **Scikit-learn പരിചയപ്പെടുക**. ഈ പാഠങ്ങളിൽ പരാമർശിക്കുന്ന ML ലൈബ്രറികളായ [Scikit-learn](https://scikit-learn.org/stable/user_guide.html) പരിചയപ്പെടുക.
---
## മെഷീൻ ലേണിങ്ങ് എന്താണ്?
'മെഷീൻ ലേണിങ്' എന്ന പദം ഇന്നത്തെ ഏറ്റവും ജനപ്രിയവും വ്യാപകമായി ഉപയോഗിക്കുന്ന പദങ്ങളിലൊന്നാണ്. നിങ്ങൾക്ക് സാങ്കേതികവിദ്യയിൽ ഏതെങ്കിലും പരിചയം ഉണ്ടെങ്കിൽ, ഈ പദം ഒരിക്കൽക്കെങ്കിലും കേട്ടിട്ടുണ്ടാകാനുള്ള സാധ്യത വളരെ കൂടുതലാണ്, നിങ്ങൾ ഏത് മേഖലയിലായാലും. എന്നാൽ മെഷീൻ ലേണിങ്ങിന്റെ യന്ത്രശാസ്ത്രം പലർക്കും രഹസ്യമാണ്. ഒരു മെഷീൻ ലേണിങ് തുടക്കക്കാരനായി, വിഷയം ചിലപ്പോൾ ഭീതിജനകമായിരിക്കാം. അതിനാൽ, മെഷീൻ ലേണിങ് എന്താണെന്ന് മനസ്സിലാക്കുകയും, പ്രായോഗിക ഉദാഹരണങ്ങളിലൂടെ ഘട്ടം ഘട്ടമായി പഠിക്കുകയും ചെയ്യുന്നത് പ്രധാനമാണ്.
---
## ഹൈപ്പ് കർവ്
![ml hype curve](../../../../translated_images/hype.07183d711a17aafe70915909a0e45aa286ede136ee9424d418026ab00fec344c.ml.png)
> 'machine learning' എന്ന പദത്തിന്റെ പുതിയ 'ഹൈപ്പ് കർവ്' Google ട്രെൻഡ്സ് കാണിക്കുന്നു
---
## ഒരു രഹസ്യമായ ബ്രഹ്മാണ്ഡം
നാം രഹസ്യങ്ങളാൽ നിറഞ്ഞ ഒരു ബ്രഹ്മാണ്ഡത്തിൽ ജീവിക്കുന്നു. സ്റ്റീഫൻ ഹോക്കിംഗ്, ആൽബർട്ട് ഐൻസ്റ്റൈൻ തുടങ്ങിയ മഹാനായ ശാസ്ത്രജ്ഞർ ലോകത്തെ ചുറ്റിപ്പറ്റിയിരിക്കുന്ന രഹസ്യങ്ങൾ കണ്ടെത്താൻ അവരുടെ ജീവിതം സമർപ്പിച്ചിട്ടുണ്ട്. ഇത് മനുഷ്യന്റെ പഠനാവസ്ഥയാണ്: ഒരു മനുഷ്യശിശു പുതിയ കാര്യങ്ങൾ പഠിച്ച്, വളർന്ന് മുതിർന്നവനാകുമ്പോൾ അവരുടെ ലോകത്തിന്റെ ഘടന കണ്ടെത്തുന്നു.
---
## കുട്ടിയുടെ മസ്തിഷ്കം
ഒരു കുട്ടിയുടെ മസ്തിഷ്കവും ഇന്ദ്രിയങ്ങളും അവരുടെ ചുറ്റുപാടുകളിലെ വാസ്തവങ്ങൾ ഗ്രഹിച്ച്, ജീവിതത്തിലെ മറഞ്ഞിരിക്കുന്ന മാതൃകകൾ പഠിച്ച്, പഠിച്ച മാതൃകകൾ തിരിച്ചറിയാൻ തർക്കസഹിതമായ നിയമങ്ങൾ രൂപപ്പെടുത്താൻ സഹായിക്കുന്നു. മനുഷ്യ മസ്തിഷ്കത്തിന്റെ പഠന പ്രക്രിയ മനുഷ്യരെ ഈ ലോകത്തിലെ ഏറ്റവും സങ്കീർണ്ണമായ ജീവികളാക്കുന്നു. മറഞ്ഞിരിക്കുന്ന മാതൃകകൾ കണ്ടെത്തി തുടർച്ചയായി പഠിക്കുകയും, ആ മാതൃകകളിൽ നവീകരണം നടത്തുകയും ചെയ്യുന്നത് ജീവിതകാലം മുഴുവൻ നമ്മെ മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്നു. ഈ പഠന ശേഷിയും വികസന ശേഷിയും [ബ്രെയിൻ പ്ലാസ്റ്റിസിറ്റി](https://www.simplypsychology.org/brain-plasticity.html) എന്ന ആശയവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ഉപരിതലമായി, മനുഷ്യ മസ്തിഷ്കത്തിന്റെ പഠന പ്രക്രിയക്കും മെഷീൻ ലേണിങ്ങിന്റെ ആശയങ്ങൾക്കും ചില പ്രചോദനാത്മക സാമ്യമുണ്ട്.
---
## മനുഷ്യ മസ്തിഷ്കം
[മനുഷ്യ മസ്തിഷ്കം](https://www.livescience.com/29365-human-brain.html) യഥാർത്ഥ ലോകത്തിൽ നിന്നുള്ള കാര്യങ്ങൾ ഗ്രഹിച്ച്, ഗ്രഹിച്ച വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്ത്, യുക്തിപരമായ തീരുമാനങ്ങൾ എടുക്കുകയും, സാഹചര്യങ്ങൾ അനുസരിച്ച് ചില പ്രവർത്തനങ്ങൾ നടത്തുകയും ചെയ്യുന്നു. ഇതാണ് നാം ബുദ്ധിമുട്ടോടെ പെരുമാറുന്നത് എന്ന് വിളിക്കുന്നത്. ബുദ്ധിമുട്ടോടെ പെരുമാറുന്ന പ്രക്രിയയുടെ ഒരു പകർപ്പ് യന്ത്രത്തിൽ പ്രോഗ്രാം ചെയ്യുമ്പോൾ, അതിനെ കൃത്രിമ ബുദ്ധിമുട്ട് (AI) എന്ന് വിളിക്കുന്നു.
---
## ചില പദങ്ങൾ
പദങ്ങൾ ചിലപ്പോൾ ആശയക്കുഴപ്പമുണ്ടാക്കാം, എന്നാൽ മെഷീൻ ലേണിങ് (ML) കൃത്രിമ ബുദ്ധിമുട്ടിന്റെ ഒരു പ്രധാന ഉപവിഭാഗമാണ്. **ML പ്രത്യേക ആൽഗോരിതങ്ങൾ ഉപയോഗിച്ച് ഗ്രഹിച്ച ഡാറ്റയിൽ നിന്ന് അർത്ഥപൂർണമായ വിവരങ്ങൾ കണ്ടെത്തുകയും മറഞ്ഞിരിക്കുന്ന മാതൃകകൾ കണ്ടെത്തി യുക്തിപരമായ തീരുമാനമെടുക്കൽ പ്രക്രിയയെ സഹായിക്കുകയും ചെയ്യുന്നതാണ്**.
---
## AI, ML, ഡീപ് ലേണിങ്
![AI, ML, deep learning, data science](../../../../translated_images/ai-ml-ds.537ea441b124ebf69c144a52c0eb13a7af63c4355c2f92f440979380a2fb08b8.ml.png)
> AI, ML, ഡീപ് ലേണിങ്, ഡാറ്റാ സയൻസ് എന്നിവയുടെ ബന്ധം കാണിക്കുന്ന ഒരു രേഖാചിത്രം. [Jen Looper](https://twitter.com/jenlooper) ഒരുക്കിയ ഇൻഫോഗ്രാഫിക്, [ഈ ഗ്രാഫിക്](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining) പ്രചോദനമായി.
---
## പഠിക്കേണ്ട ആശയങ്ങൾ
ഈ പാഠ്യപദ്ധതിയിൽ, ഒരു തുടക്കക്കാരൻ അറിയേണ്ട മെഷീൻ ലേണിങ്ങിന്റെ പ്രധാന ആശയങ്ങൾ മാത്രമേ ഉൾക്കൊള്ളൂ. നാം 'ക്ലാസിക്കൽ മെഷീൻ ലേണിങ്' എന്ന് വിളിക്കുന്നതിൽ പ്രധാനമായും Scikit-learn ഉപയോഗിക്കുന്നു, ഇത് അടിസ്ഥാനങ്ങൾ പഠിക്കാൻ വിദ്യാർത്ഥികൾക്ക് മികച്ച ലൈബ്രറിയാണ്. കൃത്രിമ ബുദ്ധിമുട്ട് അല്ലെങ്കിൽ ഡീപ് ലേണിങ്ങിന്റെ വ്യാപക ആശയങ്ങൾ മനസ്സിലാക്കാൻ, മെഷീൻ ലേണിങ്ങിന്റെ ശക്തമായ അടിസ്ഥാന അറിവ് അനിവാര്യമാണ്, അതിനാൽ ഞങ്ങൾ അത് ഇവിടെ നൽകാൻ ആഗ്രഹിക്കുന്നു.
---
## ഈ കോഴ്സിൽ നിങ്ങൾ പഠിക്കേണ്ടത്:
- മെഷീൻ ലേണിങ്ങിന്റെ പ്രധാന ആശയങ്ങൾ
- ML-ന്റെ ചരിത്രം
- ML-നും നീതിക്കും
- റെഗ്രഷൻ ML സാങ്കേതികവിദ്യകൾ
- ക്ലാസിഫിക്കേഷൻ ML സാങ്കേതികവിദ്യകൾ
- ക്ലസ്റ്ററിംഗ് ML സാങ്കേതികവിദ്യകൾ
- നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗ് ML സാങ്കേതികവിദ്യകൾ
- ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗ് ML സാങ്കേതികവിദ്യകൾ
- റീ ഇൻഫോഴ്‌സ്‌മെന്റ് ലേണിങ്
- ML-ന്റെ യഥാർത്ഥ ലോക പ്രയോഗങ്ങൾ
---
## നാം ഉൾക്കൊള്ളാത്തത്
- ഡീപ് ലേണിങ്
- ന്യൂറൽ നെറ്റ്വർക്കുകൾ
- AI
മികച്ച പഠനാനുഭവത്തിനായി, ന്യൂറൽ നെറ്റ്വർക്കുകൾ, 'ഡീപ് ലേണിങ്' - ന്യൂറൽ നെറ്റ്വർക്കുകൾ ഉപയോഗിച്ച് പലതവണ മodel നിർമ്മാണം - എന്നിവയുടെ സങ്കീർണ്ണതകൾ ഒഴിവാക്കും, AI-യും മറ്റൊരു പാഠ്യപദ്ധതിയിൽ ചർച്ച ചെയ്യും. ഈ വലിയ മേഖലയിലെ മറ്റൊരു ഭാഗമായ ഡാറ്റാ സയൻസ് പാഠ്യപദ്ധതി വരാനിരിക്കുകയാണ്.
---
## മെഷീൻ ലേണിങ് പഠിക്കേണ്ടത് എന്തുകൊണ്ട്?
സിസ്റ്റംസ് കാഴ്ചപ്പാടിൽ, മെഷീൻ ലേണിങ് എന്നത് ഡാറ്റയിൽ നിന്ന് മറഞ്ഞിരിക്കുന്ന മാതൃകകൾ പഠിച്ച് ബുദ്ധിമുട്ടുള്ള തീരുമാനങ്ങൾ എടുക്കാൻ സഹായിക്കുന്ന സ്വയം പ്രവർത്തിക്കുന്ന സിസ്റ്റങ്ങൾ സൃഷ്ടിക്കലായി നിർവചിക്കപ്പെടുന്നു.
ഈ പ്രചോദനം മനുഷ്യ മസ്തിഷ്കം പുറത്തുള്ള ലോകത്തിൽ നിന്നുള്ള ഡാറ്റയിൽ നിന്ന് ചില കാര്യങ്ങൾ എങ്ങനെ പഠിക്കുന്നു എന്നതിൽ നിന്നാണ് സ്വതന്ത്രമായി പ്രചോദനം ലഭിക്കുന്നത്.
✅ ഒരു ബിസിനസ്സ് മെഷീൻ ലേണിങ് തന്ത്രങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നതിന്റെ കാരണം എന്തെന്ന് ഒരു നിമിഷം ചിന്തിക്കുക, ഹാർഡ്-കോഡഡ് നിയമങ്ങൾ അടിസ്ഥാനമാക്കിയുള്ള എഞ്ചിൻ സൃഷ്ടിക്കുന്നതിനേക്കാൾ.
---
## മെഷീൻ ലേണിങ്ങിന്റെ പ്രയോഗങ്ങൾ
ഇപ്പോൾ മെഷീൻ ലേണിങ്ങിന്റെ പ്രയോഗങ്ങൾ എല്ലായിടത്തും കാണപ്പെടുന്നു, നമ്മുടെ സമൂഹങ്ങളിൽ സ്മാർട്ട് ഫോണുകൾ, കണക്ടഡ് ഉപകരണങ്ങൾ, മറ്റ് സിസ്റ്റങ്ങൾ എന്നിവ വഴി സൃഷ്ടിക്കപ്പെടുന്ന ഡാറ്റ പോലെ വ്യാപകമാണ്. അത്യാധുനിക മെഷീൻ ലേണിങ് ആൽഗോരിതങ്ങളുടെ വലിയ സാധ്യത പരിഗണിച്ച്, ഗവേഷകർ ബഹുമാനമായ, ബഹുമുഖ, ബഹുവിഭാഗീയ യഥാർത്ഥ ജീവിത പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ അവരുടെ കഴിവ് പരിശോധിച്ചു.
---
## പ്രയോഗിച്ച ML-ന്റെ ഉദാഹരണങ്ങൾ
**മെഷീൻ ലേണിങ് പലവിധത്തിൽ ഉപയോഗിക്കാം**:
- രോഗിയുടെ മെഡിക്കൽ ചരിത്രം അല്ലെങ്കിൽ റിപ്പോർട്ടുകളിൽ നിന്നുള്ള രോഗ സാധ്യത പ്രവചിക്കാൻ.
- കാലാവസ്ഥാ ഡാറ്റ ഉപയോഗിച്ച് കാലാവസ്ഥാ സംഭവങ്ങൾ പ്രവചിക്കാൻ.
- ഒരു എഴുത്തിന്റെ മനോഭാവം മനസ്സിലാക്കാൻ.
- പ്രചാരണം തടയാൻ വ്യാജ വാർത്തകൾ കണ്ടെത്താൻ.
ഫിനാൻസ്, സാമ്പത്തികം, ഭൂമിശാസ്ത്രം, ബഹിരാകാശ ഗവേഷണം, ബയോമെഡിക്കൽ എഞ്ചിനീയറിംഗ്, കോഗ്നിറ്റീവ് സയൻസ്, മനുഷ്യശാസ്ത്രം തുടങ്ങിയ മേഖലകൾ അവരുടെ കഠിനമായ, ഡാറ്റാ പ്രോസസ്സിംഗ് ഭാരമുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ മെഷീൻ ലേണിങ് സ്വീകരിച്ചിട്ടുണ്ട്.
---
## സമാപനം
മെഷീൻ ലേണിങ് യഥാർത്ഥ ലോകം അല്ലെങ്കിൽ സൃഷ്ടിച്ച ഡാറ്റയിൽ നിന്ന് അർത്ഥപൂർണമായ洞察ങ്ങൾ കണ്ടെത്തി മാതൃകകൾ കണ്ടെത്തുന്ന പ്രക്രിയ സ്വയം പ്രവർത്തിപ്പിക്കുന്നു. ബിസിനസ്സ്, ആരോഗ്യ, സാമ്പത്തിക പ്രയോഗങ്ങളിൽ അതിന്റെ മൂല്യം തെളിയിച്ചിട്ടുണ്ട്.
സമീപഭാവിയിൽ, മെഷീൻ ലേണിങ്ങിന്റെ അടിസ്ഥാനങ്ങൾ മനസ്സിലാക്കുന്നത് ഏത് മേഖലയിലുള്ളവർക്കും അനിവാര്യമായിരിക്കും, അതിന്റെ വ്യാപകമായ സ്വീകരണത്തെ തുടർന്ന്.
---
# 🚀 ചലഞ്ച്
കാഗിതത്തിൽ അല്ലെങ്കിൽ [Excalidraw](https://excalidraw.com/) പോലുള്ള ഓൺലൈൻ ആപ്പ് ഉപയോഗിച്ച് AI, ML, ഡീപ് ലേണിങ്, ഡാറ്റാ സയൻസ് എന്നിവയുടെ വ്യത്യാസങ്ങൾ നിങ്ങൾ എങ്ങനെ മനസ്സിലാക്കുന്നു എന്ന് രേഖപ്പെടുത്തുക. ഓരോ സാങ്കേതികവിദ്യയും പരിഹരിക്കാൻ നല്ല പ്രശ്നങ്ങളുടെ ചില ആശയങ്ങളും ചേർക്കുക.
# [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
---
# അവലോകനം & സ്വയം പഠനം
ക്ലൗഡിൽ ML ആൽഗോരിതങ്ങളുമായി എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് കൂടുതൽ അറിയാൻ, ഈ [Learning Path](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott) പിന്തുടരുക.
ML അടിസ്ഥാനങ്ങളെക്കുറിച്ച് പഠിക്കാൻ ഒരു [Learning Path](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) സ്വീകരിക്കുക.
---
# അസൈൻമെന്റ്
[Get up and running](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ പ്രാമാണികമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/ml/1-Introduction/1-intro-to-ML/assignment.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
"translation_date": "2025-12-19T13:26:20+00:00",
"source_file": "1-Introduction/1-intro-to-ML/assignment.md",
"language_code": "ml"
}
-->
# ആരംഭിച്ച് പ്രവർത്തിക്കുക
## നിർദ്ദേശങ്ങൾ
ഈ ഗ്രേഡ് ഇല്ലാത്ത അസൈൻമെന്റിൽ, നിങ്ങൾ പൈത്തൺ പുനഃപരിശോധിച്ച് നിങ്ങളുടെ പരിസ്ഥിതി പ്രവർത്തനക്ഷമമാക്കി നോട്ട്‌ബുക്കുകൾ ഓടിക്കാൻ കഴിയുന്ന നിലയിൽ എത്തിക്കണം.
ഈ [Python Learning Path](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott) സ്വീകരിച്ച്, തുടർന്ന് ഈ പരിചയപരമായ വീഡിയോകൾ വഴി നിങ്ങളുടെ സിസ്റ്റങ്ങൾ സജ്ജമാക്കുക:
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

167
translations/ml/1-Introduction/2-history-of-ML/README.md
Unescape View File

@ -0,0 +1,167 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "6a05fec147e734c3e6bfa54505648e2b",
"translation_date": "2025-12-19T13:29:04+00:00",
"source_file": "1-Introduction/2-history-of-ML/README.md",
"language_code": "ml"
}
-->
# മെഷീൻ ലേണിങ്ങിന്റെ ചരിത്രം
![മെഷീൻ ലേണിങ്ങിന്റെ ചരിത്രത്തിന്റെ സംഗ്രഹം ഒരു സ്കെച്ച്നോട്ടിൽ](../../../../translated_images/ml-history.a1bdfd4ce1f464d9a0502f38d355ffda384c95cd5278297a46c9a391b5053bc4.ml.png)
> സ്കെച്ച്നോട്ട്: [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
---
[![ML for beginners - History of Machine Learning](https://img.youtube.com/vi/N6wxM4wZ7V0/0.jpg)](https://youtu.be/N6wxM4wZ7V0 "ML for beginners - History of Machine Learning")
> 🎥 ഈ പാഠം വിശദീകരിക്കുന്ന ഒരു ചെറിയ വീഡിയോയ്ക്ക് മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്യുക.
ഈ പാഠത്തിൽ, മെഷീൻ ലേണിങ്ങിന്റെയും കൃത്രിമ ബുദ്ധിമുട്ടിന്റെയും ചരിത്രത്തിലെ പ്രധാന മൈൽസ്റ്റോണുകൾ നാം പരിശോധിക്കും.
കൃത്രിമ ബുദ്ധിമുട്ട് (AI) എന്ന മേഖലയുടെയും മെഷീൻ ലേണിങ്ങിന്റെയും ചരിത്രം പരസ്പരം ബന്ധപ്പെട്ടിരിക്കുന്നു, കാരണം ML-നെ അടിസ്ഥാനമാക്കിയുള്ള ആൽഗോരിതങ്ങളും കംപ്യൂട്ടേഷണൽ പുരോഗതികളും AI-യുടെ വികസനത്തിന് സഹായകമായിട്ടുണ്ട്. ഈ മേഖലകൾ 1950-കളിൽ വ്യക്തമായ അന്വേഷണ മേഖലകളായി രൂപപ്പെട്ടെങ്കിലും, [ആൽഗോരിത്മിക്, സാങ്കേതിക, ഗണിത, കംപ്യൂട്ടേഷണൽ, സാങ്കേതിക കണ്ടെത്തലുകൾ](https://wikipedia.org/wiki/Timeline_of_machine_learning) ഈ കാലഘട്ടത്തിന് മുമ്പും അതിനിടയിലും ഉണ്ടായിരുന്നുവെന്ന് ഓർക്കുന്നത് പ്രയോജനകരമാണ്. വാസ്തവത്തിൽ, ഈ ചോദ്യങ്ങളെക്കുറിച്ച് ആളുകൾ [നൂറുകണക്കിന് വർഷങ്ങളായി](https://wikipedia.org/wiki/History_of_artificial_intelligence) ചിന്തിച്ചുവരുന്നു: ഈ ലേഖനം 'ചിന്തിക്കുന്ന യന്ത്രം' എന്ന ആശയത്തിന്റെ ചരിത്ര ബൗദ്ധിക അടിസ്ഥാനങ്ങളെക്കുറിച്ചാണ്.
---
## ശ്രദ്ധേയമായ കണ്ടെത്തലുകൾ
- 1763, 1812 [ബേസ് തിയറിം](https://wikipedia.org/wiki/Bayes%27_theorem)യും അതിന്റെ മുൻപുള്ളവയും. ഈ തിയറിവും അതിന്റെ പ്രയോഗങ്ങളും മുൻ അറിവിന്റെ അടിസ്ഥാനത്തിൽ ഒരു സംഭവത്തിന്റെ സംഭവിക്കാനുള്ള സാധ്യത വിവരിക്കുന്നു.
- 1805 ഫ്രഞ്ച് ഗണിതജ്ഞൻ Adrien-Marie Legendre നിർമിച്ച [ലീസ്റ്റ് സ്ക്വയർ തിയറി](https://wikipedia.org/wiki/Least_squares). ഈ തിയറി, ഞങ്ങളുടെ Regression യൂണിറ്റിൽ പഠിക്കപ്പെടും, ഡാറ്റ ഫിറ്റിംഗിൽ സഹായിക്കുന്നു.
- 1913 റഷ്യൻ ഗണിതജ്ഞൻ Andrey Markov-ന്റെ പേരിലുള്ള [മാർക്കോവ് ചെയിൻസ്](https://wikipedia.org/wiki/Markov_chain), മുൻസ്ഥിതിയുടെ അടിസ്ഥാനത്തിൽ സംഭവങ്ങളുടെ സീക്വൻസ് വിവരിക്കാൻ ഉപയോഗിക്കുന്നു.
- 1957 അമേരിക്കൻ മനശാസ്ത്രജ്ഞൻ Frank Rosenblatt കണ്ടുപിടിച്ച [പേഴ്സെപ്ട്രോൺ](https://wikipedia.org/wiki/Perceptron) എന്ന ലീനിയർ ക്ലാസിഫയർ, ഡീപ്പ് ലേണിങ്ങിലെ പുരോഗതിക്ക് അടിസ്ഥാനം.
---
- 1967 [നീറസ്റ്റ് നെബർ](https://wikipedia.org/wiki/Nearest_neighbor) ഒരു ആൽഗോരിതം, ആദ്യം റൂട്ടുകൾ മാപ്പ് ചെയ്യാൻ രൂപകൽപ്പന ചെയ്തതായിരുന്നു. ML-ൽ ഇത് പാറ്റേണുകൾ കണ്ടെത്താൻ ഉപയോഗിക്കുന്നു.
- 1970 [ബാക്ക്‌പ്രൊപ്പഗേഷൻ](https://wikipedia.org/wiki/Backpropagation) [ഫീഡ്‌ഫോർവേഡ് ന്യൂറൽ നെറ്റ്വർക്കുകൾ](https://wikipedia.org/wiki/Feedforward_neural_network) പരിശീലിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു.
- 1982 [റികറന്റ് ന്യൂറൽ നെറ്റ്വർക്കുകൾ](https://wikipedia.org/wiki/Recurrent_neural_network) ഫീഡ്‌ഫോർവേഡ് ന്യൂറൽ നെറ്റ്വർക്കുകളിൽ നിന്നുള്ള കൃത്രിമ ന്യൂറൽ നെറ്റ്വർക്കുകൾ ആണ്, അവ താൽക്കാലിക ഗ്രാഫുകൾ സൃഷ്ടിക്കുന്നു.
✅ ചെറിയൊരു ഗവേഷണം നടത്തുക. ML-നും AI-നും ചരിത്രത്തിൽ മറ്റേതെങ്കിലും നിർണായക തീയതികൾ എന്തെല്ലാമാണ്?
---
## 1950: ചിന്തിക്കുന്ന യന്ത്രങ്ങൾ
അലൻ ട്യൂറിംഗ്, 2019-ൽ [പൊതുജനങ്ങൾ വോട്ടെഴുതിയ](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) 20-ആം നൂറ്റാണ്ടിലെ ഏറ്റവും വലിയ ശാസ്ത്രജ്ഞനായി തിരഞ്ഞെടുക്കപ്പെട്ട ഒരു അത്ഭുതകരനായ വ്യക്തി, 'ചിന്തിക്കാൻ കഴിയുന്ന യന്ത്രം' എന്ന ആശയത്തിന് അടിസ്ഥാനം ഒരുക്കുന്നതിൽ സഹായിച്ചതായി കണക്കാക്കപ്പെടുന്നു. ഈ ആശയത്തിന് empirical തെളിവ് ആവശ്യമായതിനാൽ അദ്ദേഹം [ട്യൂറിംഗ് ടെസ്റ്റ്](https://www.bbc.com/news/technology-18475646) സൃഷ്ടിച്ചു, ഇത് ഞങ്ങളുടെ NLP പാഠങ്ങളിൽ നിങ്ങൾ പരിശോധിക്കും.
---
## 1956: ഡാർട്മൗത്ത് സമ്മർ റിസർച്ച് പ്രോജക്ട്
"കൃത്രിമ ബുദ്ധിമുട്ട് എന്ന മേഖലയായി ഡാർട്മൗത്ത് സമ്മർ റിസർച്ച് പ്രോജക്ട് ഒരു സുപ്രധാന സംഭവമായിരുന്നു," ഇവിടെ 'കൃത്രിമ ബുദ്ധിമുട്ട്' എന്ന പദം ആദ്യമായി ഉപയോഗിക്കപ്പെട്ടു ([സ്രോതസ്സ്](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
> പഠനത്തിന്റെ എല്ലാ ഘടകങ്ങളും ബുദ്ധിമുട്ടിന്റെ മറ്റ് എല്ലാ സവിശേഷതകളും യന്ത്രം അനുകരിക്കാൻ കഴിയുന്ന വിധം കൃത്യമായി വിവരണം ചെയ്യാവുന്നതാണ്.
---
മുൻനിര ഗവേഷകൻ, ഗണിതശാസ്ത്ര പ്രൊഫസർ ജോൺ മക്കാർത്തി, "പഠനത്തിന്റെ എല്ലാ ഘടകങ്ങളും ബുദ്ധിമുട്ടിന്റെ മറ്റ് സവിശേഷതകളും യന്ത്രം അനുകരിക്കാൻ കഴിയുന്ന വിധം കൃത്യമായി വിവരണം ചെയ്യാവുന്നതാണ്" എന്ന കണക്കുകൂട്ടലിന്റെ അടിസ്ഥാനത്തിൽ മുന്നോട്ട് പോകാൻ ആഗ്രഹിച്ചു. ഈ സമ്മേളനത്തിൽ Marvin Minsky എന്ന മറ്റൊരു പ്രമുഖനും പങ്കെടുത്തു.
ഈ വർക്ക്‌ഷോപ്പ് "സിംബോളിക് രീതികളുടെ ഉയർച്ച, പരിമിത മേഖലകളിൽ കേന്ദ്രീകൃത സിസ്റ്റങ്ങൾ (ആദ്യ വിദഗ്ധ സിസ്റ്റങ്ങൾ), ഡെഡക്ടീവ് സിസ്റ്റങ്ങൾ എതിരായ ഇൻഡക്ടീവ് സിസ്റ്റങ്ങൾ" തുടങ്ങിയ ചർച്ചകൾ ആരംഭിക്കുകയും പ്രോത്സാഹിപ്പിക്കുകയും ചെയ്തതായി കണക്കാക്കപ്പെടുന്നു ([സ്രോതസ്സ്](https://wikipedia.org/wiki/Dartmouth_workshop)).
---
## 1956 - 1974: "സ്വർണകാലം"
1950-കളിൽ നിന്ന് 1970-കളുടെ മധ്യകാലം വരെ, AI പല പ്രശ്നങ്ങളും പരിഹരിക്കുമെന്ന് വലിയ പ്രതീക്ഷ ഉണ്ടായിരുന്നു. 1967-ൽ Marvin Minsky ആത്മവിശ്വാസത്തോടെ പറഞ്ഞു: "ഒരു തലമുറക്കുള്ളിൽ ... 'കൃത്രിമ ബുദ്ധിമുട്ട്' സൃഷ്ടിക്കുന്ന പ്രശ്നം പ്രധാനമായും പരിഹരിക്കപ്പെടും." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
പ്രകൃതിഭാഷാ പ്രോസസ്സിംഗ് ഗവേഷണം വളർന്നു, തിരച്ചിൽ മെച്ചപ്പെടുത്തി ശക്തിപ്പെടുത്തി, 'മൈക്രോ-വേൾഡ്' എന്ന ആശയം സൃഷ്ടിച്ചു, എളുപ്പം plain language നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ലളിതമായ പ്രവർത്തനങ്ങൾ പൂർത്തിയാക്കാൻ.
---
ഗവൺമെന്റ് ഏജൻസികൾ ഗവേഷണത്തിന് ധനസഹായം നൽകി, കംപ്യൂട്ടേഷൻ, ആൽഗോരിതങ്ങളിൽ പുരോഗതി ഉണ്ടായി, ബുദ്ധിമുട്ടുള്ള യന്ത്രങ്ങളുടെ പ്രോട്ടോടൈപ്പുകൾ നിർമ്മിച്ചു. ചില യന്ത്രങ്ങൾ:
* [ഷേക്കി ദി റോബോട്ട്](https://wikipedia.org/wiki/Shakey_the_robot), 'ബുദ്ധിമുട്ടോടെ' പ്രവർത്തനങ്ങൾ നിർവഹിക്കാൻ കഴിവുള്ളത്.
![ഷേക്കി, ഒരു ബുദ്ധിമുട്ടുള്ള റോബോട്ട്](../../../../translated_images/shakey.4dc17819c447c05bf4b52f76da0bdd28817d056fdb906252ec20124dd4cfa55e.ml.jpg)
> 1972-ലെ ഷേക്കി
---
* എലൈസ, ഒരു പ്രാരംഭ 'ചാറ്റർബോട്ട്', ആളുകളുമായി സംവദിക്കുകയും പ്രാഥമിക 'തെറാപ്പിസ്റ്റ്' ആയി പ്രവർത്തിക്കുകയും ചെയ്തു. NLP പാഠങ്ങളിൽ എലൈസയെക്കുറിച്ച് കൂടുതൽ പഠിക്കും.
![എലൈസ, ഒരു ബോട്ട്](../../../../translated_images/eliza.84397454cda9559bb5ec296b5b8fff067571c0cccc5405f9c1ab1c3f105c075c.ml.png)
> എലൈസയുടെ ഒരു പതിപ്പ്, ഒരു ചാറ്റ്ബോട്ട്
---
* "ബ്ലോക്ക്സ് വേൾഡ്" ഒരു മൈക്രോ-വേൾഡ് ഉദാഹരണമായിരുന്നു, ഇവിടെ ബ്ലോക്കുകൾ തട്ടി ക്രമീകരിക്കാനും യന്ത്രങ്ങളെ തീരുമാനമെടുക്കാൻ പഠിപ്പിക്കാനും പരീക്ഷണങ്ങൾ നടത്താമായിരുന്നു. [SHRDLU](https://wikipedia.org/wiki/SHRDLU) പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിച്ച് ഭാഷാ പ്രോസസ്സിംഗ് മുന്നോട്ട് കൊണ്ടുപോയി.
[![SHRDLU ഉപയോഗിച്ചുള്ള ബ്ലോക്ക്സ് വേൾഡ്](https://img.youtube.com/vi/QAJz4YKUwqw/0.jpg)](https://www.youtube.com/watch?v=QAJz4YKUwqw "blocks world with SHRDLU")
> 🎥 മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്ത് വീഡിയോ കാണുക: SHRDLU ഉപയോഗിച്ചുള്ള ബ്ലോക്ക്സ് വേൾഡ്
---
## 1974 - 1980: "AI ശീതകാലം"
1970-കളുടെ മധ്യത്തിൽ, 'ബുദ്ധിമുട്ടുള്ള യന്ത്രങ്ങൾ' നിർമ്മിക്കുന്നതിന്റെ സങ്കീർണ്ണത കുറവായി കണക്കാക്കിയതും, ലഭ്യമായ കംപ്യൂട്ട് ശക്തി പരിഗണിച്ചാൽ വാഗ്ദാനം അത്ര വലിയതല്ലെന്ന് വ്യക്തമായിരുന്നു. ധനസഹായം കുറഞ്ഞു, മേഖലയിലെ ആത്മവിശ്വാസം മന്ദഗതിയിലായി. ആത്മവിശ്വാസത്തെ ബാധിച്ച ചില പ്രശ്നങ്ങൾ:
---
- **പരിമിതികൾ**. കംപ്യൂട്ട് ശക്തി വളരെ പരിമിതമായിരുന്നു.
- **കമ്പിനേറ്റോറിയൽ എക്സ്പ്ലോഷൻ**. കംപ്യൂട്ടറുകളിൽ കൂടുതൽ ആവശ്യങ്ങൾ വന്നപ്പോൾ പരിശീലിക്കേണ്ട പാരാമീറ്ററുകളുടെ എണ്ണം വൻപരിധിയിലേയ്ക്ക് വളർന്നു, കംപ്യൂട്ട് ശക്തിയും കഴിവും അതുപോലെ വളർന്നില്ല.
- **ഡാറ്റയുടെ കുറവ്**. പരീക്ഷണങ്ങൾ, വികസനം, ആൽഗോരിതം മെച്ചപ്പെടുത്തൽ എന്നിവയ്ക്ക് ആവശ്യമായ ഡാറ്റ കുറവായിരുന്നു.
- **നാം ശരിയായ ചോദ്യങ്ങൾ ചോദിക്കുന്നുണ്ടോ?**. ചോദിക്കുന്ന ചോദ്യങ്ങൾ തന്നെ സംശയാസ്പദമായി മാറി. ഗവേഷകർക്ക് അവരുടെ സമീപനങ്ങളെക്കുറിച്ച് വിമർശനങ്ങൾ നേരിടേണ്ടി വന്നു:
- ട്യൂറിംഗ് ടെസ്റ്റുകൾ 'ചൈനീസ് റൂം തിയറി' പോലുള്ള ആശയങ്ങളാൽ ചോദ്യം ചെയ്യപ്പെട്ടു, ഇതിൽ "ഡിജിറ്റൽ കംപ്യൂട്ടർ പ്രോഗ്രാമിംഗ് ഭാഷ മനസ്സിലാക്കുന്ന പോലെ തോന്നിക്കാമെങ്കിലും യഥാർത്ഥ മനസ്സിലാക്കൽ ഉണ്ടാകില്ല" എന്ന് വാദിച്ചു. ([സ്രോതസ്സ്](https://plato.stanford.edu/entries/chinese-room/))
- "തെറാപ്പിസ്റ്റ്" എലൈസ പോലുള്ള കൃത്രിമ ബുദ്ധിമുട്ടുകൾ സമൂഹത്തിൽ പരിചയപ്പെടുത്തുന്നതിന്റെ നൈതികത ചോദ്യം ചെയ്യപ്പെട്ടു.
---
അതേസമയം, വിവിധ AI ചിന്താശാഖകൾ രൂപപ്പെട്ടു. ["സ്ക്രഫി" vs. "നീറ്റ് AI"](https://wikipedia.org/wiki/Neats_and_scruffies) എന്ന വ്യത്യാസം സ്ഥാപിച്ചു. _സ്ക്രഫി_ ലാബുകൾ മണിക്കൂറുകൾക്കായി പ്രോഗ്രാമുകൾ തിരുത്തി ആവശ്യമായ ഫലങ്ങൾ നേടാൻ ശ്രമിച്ചു. _നീറ്റ്_ ലാബുകൾ "ലോജിക്, ഔപചാരിക പ്രശ്നപരിഹാരത്തിൽ" കേന്ദ്രീകരിച്ചു. എലൈസയും SHRDLUയും പ്രശസ്തമായ _സ്ക്രഫി_ സിസ്റ്റങ്ങളായിരുന്നു. 1980-കളിൽ ML സിസ്റ്റങ്ങൾ പുനരുത്പാദനയോഗ്യമാക്കേണ്ട ആവശ്യം ഉയർന്നപ്പോൾ, _നീറ്റ്_ സമീപനം മുൻപന്തിയിലായി, കാരണം അതിന്റെ ഫലങ്ങൾ കൂടുതൽ വിശദീകരിക്കാവുന്നതായിരുന്നു.
---
## 1980-കൾ വിദഗ്ധ സിസ്റ്റങ്ങൾ
മേഖല വളർന്നതോടെ, ബിസിനസിന് ഇതിന്റെ പ്രയോജനം വ്യക്തമായി, 1980-കളിൽ 'വിദഗ്ധ സിസ്റ്റങ്ങൾ' വ്യാപിച്ചു. "വിദഗ്ധ സിസ്റ്റങ്ങൾ കൃത്രിമ ബുദ്ധിമുട്ടിന്റെ ആദ്യത്തെ വിജയകരമായ സോഫ്റ്റ്‌വെയർ രൂപങ്ങളിലൊന്നായിരുന്നു." ([സ്രോതസ്സ്](https://wikipedia.org/wiki/Expert_system)).
ഈ സിസ്റ്റങ്ങൾ ഭാഗികമായി നിയമങ്ങൾ നിർവചിക്കുന്ന ഒരു റൂൾസ് എഞ്ചിനും, പുതിയ വസ്തുതകൾ കണ്ടെത്താൻ റൂൾസ് സിസ്റ്റം ഉപയോഗിക്കുന്ന ഇൻഫറൻസ് എഞ്ചിനും ചേർന്ന _ഹൈബ്രിഡ്_ ആണ്.
ഈ കാലഘട്ടത്തിൽ ന്യൂറൽ നെറ്റ്വർക്കുകൾക്ക് കൂടുതൽ ശ്രദ്ധ ലഭിച്ചു.
---
## 1987 - 1993: AI 'ചില്ല്'
വിദഗ്ധ സിസ്റ്റങ്ങൾക്കായുള്ള പ്രത്യേക ഹാർഡ്‌വെയർ വളരെ പ്രത്യേകതയുള്ളതായതിനാൽ അതിന്റെ വ്യാപനം കുറവായി. പേഴ്സണൽ കംപ്യൂട്ടറുകളുടെ ഉയർച്ചയും ഈ വലിയ, പ്രത്യേക, കേന്ദ്രകൃത സിസ്റ്റങ്ങളുമായി മത്സരം നടത്തി. കംപ്യൂട്ടിങ്ങിന്റെ ജനാധിപത്യവൽക്കരണം ആരംഭിച്ചു, ഇത് പിന്നീട് ബിഗ് ഡാറ്റയുടെ ആധുനിക പൊട്ടിപ്പുറത്തലിന് വഴിതെളിച്ചു.
---
## 1993 - 2011
ഈ കാലഘട്ടം ML-നും AI-നും മുമ്പ് ഡാറ്റയും കംപ്യൂട്ട് ശക്തിയും കുറവായതിനാൽ ഉണ്ടായ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ പുതിയ കാലഘട്ടമായി. ഡാറ്റയുടെ അളവ് വേഗത്തിൽ വർദ്ധിച്ചു, പ്രത്യേകിച്ച് 2007-ൽ സ്മാർട്ട്ഫോൺ വന്നതോടെ കൂടുതൽ ലഭ്യമായി. കംപ്യൂട്ട് ശക്തി വൻപരിധിയിലേയ്ക്ക് വളർന്നു, ആൽഗോരിതങ്ങളും അതിനൊപ്പം വികസിച്ചു. ഈ മേഖല വളർച്ചയുടെ പാതയിൽ കടന്നു, മുൻകാല സ്വതന്ത്രമായ കാലങ്ങൾ ഒരു സത്യമായ ശാസ്ത്രശാഖയായി രൂപപ്പെട്ടു.
---
## ഇപ്പോൾ
ഇന്ന് മെഷീൻ ലേണിങ്ങും AI-യും നമ്മുടെ ജീവിതത്തിന്റെ എല്ലാ ഭാഗത്തും സ്പർശിക്കുന്നു. ഈ കാലഘട്ടം ഈ ആൽഗോരിതങ്ങൾ മനുഷ്യജീവിതങ്ങളിൽ ഉണ്ടാക്കുന്ന അപകടങ്ങളും സാധ്യതകളും സൂക്ഷ്മമായി മനസ്സിലാക്കേണ്ടതാണ്. മൈക്രോസോഫ്റ്റിന്റെ ബ്രാഡ് സ്മിത്ത് പറഞ്ഞതുപോലെ, "ഇൻഫർമേഷൻ ടെക്നോളജി സ്വകാര്യതയും അഭിപ്രായ സ്വാതന്ത്ര്യവും പോലുള്ള അടിസ്ഥാന മനുഷ്യാവകാശ സംരക്ഷണങ്ങളുടെ ഹൃദയത്തെ ബാധിക്കുന്ന പ്രശ്നങ്ങൾ ഉയർത്തുന്നു. ഈ ഉൽപ്പന്നങ്ങൾ സൃഷ്ടിക്കുന്ന ടെക് കമ്പനികൾക്ക് കൂടുതൽ ഉത്തരവാദിത്വം ഉണ്ട്. ഞങ്ങളുടെ കാഴ്ചപ്പാടിൽ, ഇത് ചിന്താപൂർവ്വകമായ സർക്കാർ നിയന്ത്രണവും അംഗീകരിക്കാവുന്ന ഉപയോഗങ്ങൾക്കുള്ള മാനദണ്ഡങ്ങളുടെ വികസനവും ആവശ്യമാണ്" ([സ്രോതസ്സ്](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
---
ഭാവി എന്ത് കൊണ്ടുവരുമെന്ന് കാണേണ്ടതാണ്, എന്നാൽ ഈ കംപ്യൂട്ടർ സിസ്റ്റങ്ങളും അവ പ്രവർത്തിപ്പിക്കുന്ന സോഫ്റ്റ്‌വെയറും ആൽഗോരിതങ്ങളും മനസ്സിലാക്കുന്നത് പ്രധാനമാണ്. നിങ്ങൾക്ക് മികച്ച മനസ്സിലാക്കൽ നേടാൻ ഈ പാഠ്യപദ്ധതി സഹായിക്കുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.
[![ഡീപ്പ് ലേണിങ്ങിന്റെ ചരിത്രം](https://img.youtube.com/vi/mTtDfKgLm54/0.jpg)](https://www.youtube.com/watch?v=mTtDfKgLm54 "The history of deep learning")
> 🎥 മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്ത് വീഡിയോ കാണുക: ഈ ലെക്ചറിൽ Yann LeCun ഡീപ്പ് ലേണിങ്ങിന്റെ ചരിത്രം വിശദീകരിക്കുന്നു
---
## 🚀ചലഞ്ച്
ഈ ചരിത്രപരമായ ഒരു ഘട്ടത്തിൽ കൂടുതൽ പഠിച്ച് അവയുടെ പിന്നിലെ ആളുകളെക്കുറിച്ച് അറിയുക. അത്ഭുതകരമായ കഥാപാത്രങ്ങളുണ്ട്, ശാസ്ത്രീയ കണ്ടെത്തലുകൾ സാംസ്കാരിക ശൂന്യതയിൽ സൃഷ്ടിക്കപ്പെട്ടിട്ടില്ല. നിങ്ങൾ എന്ത് കണ്ടെത്തുന്നു?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
---
## അവലോകനം & സ്വയം പഠനം
കാണാനും കേൾക്കാനും ഉള്ളവ:
[AI-യുടെ വികാസത്തെക്കുറിച്ച് Amy Boyd സംസാരിക്കുന്ന പോഡ്കാസ്റ്റ്](http://runasradio.com/Shows/Show/739)
[![Amy Boyd-യുടെ AI ചരിത്രം](https://img.youtube.com/vi/EJt3_bFYKss/0.jpg)](https://www.youtube.com/watch?v=EJt3_bFYKss "The history of AI by Amy Boyd")
---
## അസൈൻമെന്റ്
[ടൈംലൈൻ സൃഷ്ടിക്കുക](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/ml/1-Introduction/2-history-of-ML/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "eb6e4d5afd1b21a57d2b9e6d0aac3969",
"translation_date": "2025-12-19T13:32:59+00:00",
"source_file": "1-Introduction/2-history-of-ML/assignment.md",
"language_code": "ml"
}
-->
# ഒരു ടൈംലൈൻ സൃഷ്ടിക്കുക
## നിർദ്ദേശങ്ങൾ
[ഈ റിപോ](https://github.com/Digital-Humanities-Toolkit/timeline-builder) ഉപയോഗിച്ച് ആൽഗോരിതങ്ങൾ, ഗണിതം, സ്ഥിതിവിവരശാസ്ത്രം, എഐ, അല്ലെങ്കിൽ എംഎൽ എന്നിവയുടെ ചരിത്രത്തിലെ ഏതെങ്കിലും ഒരു വശത്തിന്റെ ടൈംലൈൻ സൃഷ്ടിക്കുക, അല്ലെങ്കിൽ ഇവയുടെ സംയോജനം. നിങ്ങൾക്ക് ഒരു വ്യക്തിയെയോ, ഒരു ആശയത്തെയോ, അല്ലെങ്കിൽ ദീർഘകാല ചിന്താവിഷയത്തെയോ കേന്ദ്രീകരിക്കാം. മൾട്ടിമീഡിയ ഘടകങ്ങൾ ചേർക്കാൻ ശ്രദ്ധിക്കുക.
## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണാർത്ഥം | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------- | ------------------------------------------------- | --------------------------------------- | ---------------------------------------------------------------- |
| | GitHub പേജായി വിന്യസിച്ച ടൈംലൈൻ അവതരിപ്പിച്ചിരിക്കുന്നു | കോഡ് അപൂർണ്ണമാണ്, വിന്യസിച്ചിട്ടില്ല | ടൈംലൈൻ അപൂർണ്ണമാണ്, നന്നായി ഗവേഷണം ചെയ്തിട്ടില്ല, വിന്യസിച്ചിട്ടില്ല |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

172
translations/ml/1-Introduction/3-fairness/README.md
Unescape View File

@ -0,0 +1,172 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
"translation_date": "2025-12-19T13:40:51+00:00",
"source_file": "1-Introduction/3-fairness/README.md",
"language_code": "ml"
}
-->
# ഉത്തരവാദിത്വമുള്ള AI ഉപയോഗിച്ച് മെഷീൻ ലേണിംഗ് പരിഹാരങ്ങൾ നിർമ്മിക്കൽ
![Summary of responsible AI in Machine Learning in a sketchnote](../../../../translated_images/ml-fairness.ef296ebec6afc98a44566d7b6c1ed18dc2bf1115c13ec679bb626028e852fa1d.ml.png)
> സ്കെച്ച്നോട്ട്: [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## പരിചയം
ഈ പാഠ്യപദ്ധതിയിൽ, മെഷീൻ ലേണിംഗ് എങ്ങനെ നമ്മുടെ ദൈനംദിന ജീവിതത്തെ ബാധിക്കുന്നു എന്ന് നിങ്ങൾ കണ്ടെത്താൻ തുടങ്ങും. ഇപ്പോഴും, ആരോഗ്യപരിശോധനകൾ, വായ്പാ അംഗീകാരം, തട്ടിപ്പ് കണ്ടെത്തൽ തുടങ്ങിയ ദൈനംദിന തീരുമാനങ്ങളിൽ സിസ്റ്റങ്ങളും മോഡലുകളും പങ്കാളികളാണ്. അതിനാൽ, ഈ മോഡലുകൾ വിശ്വസനീയമായ ഫലങ്ങൾ നൽകാൻ നല്ല രീതിയിൽ പ്രവർത്തിക്കണം. ഏതൊരു സോഫ്റ്റ്‌വെയർ ആപ്ലിക്കേഷനുപോലെ, AI സിസ്റ്റങ്ങൾ പ്രതീക്ഷകൾ പാലിക്കാതിരിക്കുകയോ അനിഷ്ടഫലങ്ങൾ ഉണ്ടാകുകയോ ചെയ്യാം. അതുകൊണ്ടുതന്നെ AI മോഡലിന്റെ പെരുമാറ്റം മനസ്സിലാക്കാനും വിശദീകരിക്കാനും കഴിയുന്നത് അനിവാര്യമാണ്.
നിങ്ങൾ ഈ മോഡലുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ഡാറ്റയിൽ ജാതി, ലിംഗം, രാഷ്ട്രീയ കാഴ്ചപ്പാട്, മതം പോലുള്ള ചില ജനസംഖ്യാ വിഭാഗങ്ങൾ ഇല്ലാതിരുന്നാൽ എന്ത് സംഭവിക്കും എന്ന് കണക്കാക്കുക. മോഡലിന്റെ ഫലം ചില ജനസംഖ്യാ വിഭാഗങ്ങളെ അനുകൂലിക്കുന്നതായി വ്യാഖ്യാനിക്കപ്പെടുമ്പോൾ എന്ത് സംഭവിക്കും? ആപ്ലിക്കേഷനിൽ അതിന്റെ പ്രത്യാഘാതം എന്താകും? കൂടാതെ, മോഡലിന് അനിഷ്ടഫലം ഉണ്ടാകുകയും അത് ആളുകൾക്ക് ഹാനികരമായിരിക്കുകയുമെങ്കിൽ എന്ത് സംഭവിക്കും? AI സിസ്റ്റത്തിന്റെ പെരുമാറ്റത്തിന് ആരാണ് ഉത്തരവാദി? ഈ പാഠ്യപദ്ധതിയിൽ നാം ഈ ചോദ്യങ്ങൾ പരിശോധിക്കും.
ഈ പാഠത്തിൽ നിങ്ങൾ:
- മെഷീൻ ലേണിംഗിൽ നീതിയുടെ പ്രാധാന്യവും നീതിയുമായി ബന്ധപ്പെട്ട ഹാനികരമായ കാര്യങ്ങളും മനസ്സിലാക്കും.
- വിശ്വാസ്യതയും സുരക്ഷയും ഉറപ്പാക്കാൻ അസാധാരണ സാഹചര്യങ്ങളും ഔട്ട്‌ലൈയർമാരും പരിശോധിക്കുന്ന പ്രക്രിയയെ പരിചയപ്പെടും.
- ഉൾക്കൊള്ളുന്ന സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്ത് എല്ലാവരെയും ശക്തിപ്പെടുത്തേണ്ടതിന്റെ ആവശ്യകത മനസ്സിലാക്കും.
- ഡാറ്റയുടെയും ആളുകളുടെയും സ്വകാര്യതയും സുരക്ഷയും സംരക്ഷിക്കുന്നതിന്റെ പ്രാധാന്യം അന്വേഷിക്കും.
- AI മോഡലുകളുടെ പെരുമാറ്റം വിശദീകരിക്കാൻ ഗ്ലാസ് ബോക്സ് സമീപനത്തിന്റെ പ്രാധാന്യം കാണും.
- AI സിസ്റ്റങ്ങളിൽ വിശ്വാസം സൃഷ്ടിക്കാൻ ഉത്തരവാദിത്വം അനിവാര്യമാണെന്ന് ശ്രദ്ധിക്കും.
## മുൻകൂട്ടി അറിയേണ്ടത്
മുൻകൂട്ടി, "ഉത്തരവാദിത്വമുള്ള AI സിദ്ധാന്തങ്ങൾ" എന്ന ലേണിംഗ് പാത പിന്തുടർന്ന് താഴെ കൊടുത്തിരിക്കുന്ന വീഡിയോ കാണുക:
ഉത്തരവാദിത്വമുള്ള AIയെക്കുറിച്ച് കൂടുതൽ അറിയാൻ ഈ [Learning Path](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott) പിന്തുടരുക
[![Microsoft's Approach to Responsible AI](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Microsoft's Approach to Responsible AI")
> 🎥 മുകളിൽ കാണുന്ന ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക: Microsoft's Approach to Responsible AI
## നീതി
AI സിസ്റ്റങ്ങൾ എല്ലാവരോടും നീതിപൂർവ്വം പെരുമാറണം, സമാനമായ ജനസംഖ്യാ വിഭാഗങ്ങളെ വ്യത്യസ്തമായി ബാധിക്കരുത്. ഉദാഹരണത്തിന്, മെഡിക്കൽ ചികിത്സ, വായ്പാ അപേക്ഷകൾ, തൊഴിൽ സംബന്ധിച്ച നിർദ്ദേശങ്ങൾ നൽകുമ്പോൾ, സമാന ലക്ഷണങ്ങൾ, സാമ്പത്തിക സാഹചര്യങ്ങൾ, പ്രൊഫഷണൽ യോഗ്യതകൾ ഉള്ള എല്ലാവർക്കും ഒരേ നിർദ്ദേശങ്ങൾ നൽകണം. ഓരോ മനുഷ്യനും അവന്റെ തീരുമാനങ്ങളിലും പ്രവർത്തനങ്ങളിലും സ്വാധീനം ചെലുത്തുന്ന പാരമ്പര്യ പൂർവ്വഗതമായ മുൻഗണനകൾ (ബയാസുകൾ) ഉണ്ട്. ഈ ബയാസുകൾ AI സിസ്റ്റങ്ങൾ പരിശീലിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഡാറ്റയിൽ പ്രത്യക്ഷപ്പെടാം. ചിലപ്പോൾ ഇത് അനായാസം സംഭവിക്കാം. ഡാറ്റയിൽ ബയാസ് ചേർക്കുമ്പോൾ അത് മനസ്സിലാക്കുക പ്രയാസമാണ്.
**“അനീതിയുള്ളത്”** എന്നത് ഒരു ജനസംഖ്യാ വിഭാഗത്തിന് (ജാതി, ലിംഗം, പ്രായം, അശക്തി നില തുടങ്ങിയ അടിസ്ഥാനത്തിൽ) ഉണ്ടാകുന്ന നെഗറ്റീവ് പ്രഭാവങ്ങളെയോ “ഹാനികളെയോ” ഉൾക്കൊള്ളുന്നു. പ്രധാന നീതി സംബന്ധമായ ഹാനികൾ താഴെപ്പറയുന്നവയായി വർഗ്ഗീകരിക്കാം:
- **വിതരണം**: ഉദാഹരണത്തിന്, ഒരു ലിംഗം അല്ലെങ്കിൽ ജാതി മറ്റൊരാളേക്കാൾ മുൻഗണന ലഭിക്കുന്നത്.
- **സേവന ഗുണമേന്മ**: ഒരു പ്രത്യേക സാഹചര്യത്തിനായി ഡാറ്റ പരിശീലിപ്പിച്ചാൽ, യാഥാർത്ഥ്യം കൂടുതൽ സങ്കീർണ്ണമായിരിക്കുമ്പോൾ, സേവനം മോശമായി പ്രവർത്തിക്കും. ഉദാഹരണത്തിന്, കറുത്ത ത്വക്കുള്ള ആളുകളെ തിരിച്ചറിയാൻ കഴിയാത്ത കൈ സോപ്പ് ഡിസ്പെൻസർ. [Reference](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **അവമാനനം**: അനീതിയായി വിമർശിക്കുകയും ലേബൽ ചെയ്യുകയും ചെയ്യുക. ഉദാഹരണത്തിന്, കറുത്ത ത്വക്കുള്ള ആളുകളുടെ ചിത്രങ്ങളെ ഗൊറില്ലകളായി തെറ്റായി ലേബൽ ചെയ്ത ചിത്രം തിരിച്ചറിയൽ സാങ്കേതികവിദ്യ.
- **അധികം അല്ലെങ്കിൽ കുറവ് പ്രതിനിധാനം**: ഒരു പ്രത്യേക വിഭാഗം ഒരു തൊഴിൽ മേഖലയിൽ കാണപ്പെടാത്തത്, അതുപോലെ സേവനങ്ങൾ അതിനെ പ്രോത്സാഹിപ്പിക്കുന്നത് ഹാനികരമാണ്.
- **സ്റ്റീരിയോടൈപ്പിംഗ്**: ഒരു വിഭാഗത്തെ മുൻകൂട്ടി നിശ്ചയിച്ച ഗുണങ്ങളുമായി ബന്ധിപ്പിക്കൽ. ഉദാഹരണത്തിന്, ഇംഗ്ലീഷ്-ടർക്കിഷ് ഭാഷാ പരിഭാഷാ സിസ്റ്റത്തിൽ ലിംഗത്തോട് ബന്ധപ്പെട്ട സ്റ്റീരിയോടൈപ്പിക്കൽ വാക്കുകൾ മൂലം തെറ്റുകൾ ഉണ്ടാകാം.
![translation to Turkish](../../../../translated_images/gender-bias-translate-en-tr.f185fd8822c2d4372912f2b690f6aaddd306ffbb49d795ad8d12a4bf141e7af0.ml.png)
> ടർക്കിഷിലേക്ക് വിവർത്തനം
![translation back to English](../../../../translated_images/gender-bias-translate-tr-en.4eee7e3cecb8c70e13a8abbc379209bc8032714169e585bdeac75af09b1752aa.ml.png)
> ഇംഗ്ലീഷിലേക്ക് തിരിച്ചുവിവർത്തനം
AI സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്യുമ്പോഴും പരീക്ഷിക്കുമ്പോഴും, AI നീതിപൂർവ്വം പ്രവർത്തിക്കുന്നതും ബയാസോ വിവേചനപരമായ തീരുമാനങ്ങൾ എടുക്കാതിരിക്കുകയുമാണ് ഉറപ്പാക്കേണ്ടത്, മനുഷ്യർക്കും ഇത് ചെയ്യാൻ അനുവദനീയമല്ല. AI-യിലും മെഷീൻ ലേണിംഗിലും നീതി ഉറപ്പാക്കൽ ഒരു സങ്കീർണ്ണമായ സാമൂഹ്യ സാങ്കേതിക വെല്ലുവിളിയാണ്.
### വിശ്വാസ്യതയും സുരക്ഷയും
വിശ്വാസം സൃഷ്ടിക്കാൻ, AI സിസ്റ്റങ്ങൾ സാധാരണവും അപ്രതീക്ഷിതവുമായ സാഹചര്യങ്ങളിൽ വിശ്വസനീയവും സുരക്ഷിതവുമായിരിക്കണം. AI സിസ്റ്റുകൾ വ്യത്യസ്ത സാഹചര്യങ്ങളിൽ എങ്ങനെ പെരുമാറും എന്ന് അറിയുന്നത് പ്രധാനമാണ്, പ്രത്യേകിച്ച് അവ ഔട്ട്‌ലൈയർമാരായപ്പോൾ. AI പരിഹാരങ്ങൾ നിർമ്മിക്കുമ്പോൾ, AI പരിഹാരങ്ങൾ നേരിടുന്ന വ്യത്യസ്ത സാഹചര്യങ്ങളെ കൈകാര്യം ചെയ്യുന്നതിൽ വലിയ ശ്രദ്ധ വേണം. ഉദാഹരണത്തിന്, സ്വയം ഓടുന്ന കാറിന് ആളുകളുടെ സുരക്ഷ മുൻഗണനയായി വേണം. അതിനാൽ, കാറിന്റെ AI എല്ലാ സാധ്യതയുള്ള സാഹചര്യങ്ങളും പരിഗണിക്കണം: രാത്രി, മിന്നൽമേഘങ്ങൾ, മഞ്ഞുവീഴ്ച, കുട്ടികൾ റോഡിൽ ഓടുന്നത്, മൃഗങ്ങൾ, റോഡ് നിർമ്മാണം തുടങ്ങിയവ. ഒരു AI സിസ്റ്റം എത്രത്തോളം വിശ്വസനീയവും സുരക്ഷിതവുമായും വ്യത്യസ്ത സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നു എന്നത് ഡാറ്റ സയന്റിസ്റ്റും AI ഡെവലപ്പറും ഡിസൈൻ അല്ലെങ്കിൽ ടെസ്റ്റിംഗിൽ എത്രത്തോളം മുൻകൂട്ടി കണക്കാക്കിയതിന്റെ സൂചകമാണ്.
> [🎥 വീഡിയോക്കായി ഇവിടെ ക്ലിക്ക് ചെയ്യുക: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
### ഉൾക്കൊള്ളൽ
AI സിസ്റ്റങ്ങൾ എല്ലാവരെയും ഉൾക്കൊള്ളുകയും ശക്തിപ്പെടുത്തുകയും ചെയ്യുന്നതായി രൂപകൽപ്പന ചെയ്യണം. AI സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്യുമ്പോൾ, ഡാറ്റ സയന്റിസ്റ്റുകളും AI ഡെവലപ്പർമാരും അനായാസം ആളുകളെ ഒഴിവാക്കാൻ ഇടയുണ്ടാകുന്ന തടസ്സങ്ങൾ കണ്ടെത്തി പരിഹരിക്കും. ഉദാഹരണത്തിന്, ലോകത്ത് 1 ബില്യൺ അശക്തരുണ്ട്. AI പുരോഗമനത്തോടെ, അവർക്ക് അവരുടെ ദൈനംദിന ജീവിതത്തിൽ കൂടുതൽ എളുപ്പത്തിൽ വിവരങ്ങളും അവസരങ്ങളും ലഭിക്കും. തടസ്സങ്ങൾ പരിഹരിക്കുന്നത് എല്ലാവർക്കും ഗുണകരമായ മികച്ച അനുഭവങ്ങളുള്ള AI ഉൽപ്പന്നങ്ങൾ വികസിപ്പിക്കാൻ അവസരം സൃഷ്ടിക്കുന്നു.
> [🎥 വീഡിയോക്കായി ഇവിടെ ക്ലിക്ക് ചെയ്യുക: inclusiveness in AI](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
### സുരക്ഷയും സ്വകാര്യതയും
AI സിസ്റ്റങ്ങൾ സുരക്ഷിതവും ആളുകളുടെ സ്വകാര്യത മാനിക്കുന്നതുമായിരിക്കണം. ആളുകൾ അവരുടെ സ്വകാര്യത, വിവരങ്ങൾ, ജീവൻ അപകടത്തിലാക്കുന്ന സിസ്റ്റങ്ങളിൽ കുറവ് വിശ്വാസം കാണിക്കുന്നു. മെഷീൻ ലേണിംഗ് മോഡലുകൾ പരിശീലിപ്പിക്കുമ്പോൾ, മികച്ച ഫലങ്ങൾ ലഭിക്കാൻ ഡാറ്റയിൽ ആശ്രയിക്കുന്നു. അതിനാൽ, ഡാറ്റയുടെ ഉറവിടവും അഖണ്ഡതയും പരിഗണിക്കണം. ഉദാഹരണത്തിന്, ഡാറ്റ ഉപയോക്താവ് സമർപ്പിച്ചതാണോ പൊതുവായി ലഭ്യമായതാണോ? തുടർന്ന്, ഡാറ്റ ഉപയോഗിക്കുമ്പോൾ, രഹസ്യ വിവരങ്ങൾ സംരക്ഷിക്കുകയും ആക്രമണങ്ങൾ പ്രതിരോധിക്കുകയും ചെയ്യുന്ന AI സിസ്റ്റങ്ങൾ വികസിപ്പിക്കുന്നത് അനിവാര്യമാണ്. AI വ്യാപകമാകുമ്പോൾ, സ്വകാര്യത സംരക്ഷിക്കുകയും വ്യക്തിഗതവും ബിസിനസ്സ് വിവരങ്ങളും സുരക്ഷിതമാക്കുകയും ചെയ്യുന്നത് കൂടുതൽ പ്രധാനവും സങ്കീർണ്ണവുമാണ്. AI-യ്ക്ക് ഡാറ്റ ലഭ്യമാകുന്നത് കൃത്യമായ പ്രവചനങ്ങളും തീരുമാനങ്ങളും എടുക്കാൻ അനിവാര്യമായതിനാൽ, സ്വകാര്യതയും ഡാറ്റ സുരക്ഷയും പ്രത്യേക ശ്രദ്ധ ആവശ്യമാണ്.
> [🎥 വീഡിയോക്കായി ഇവിടെ ക്ലിക്ക് ചെയ്യുക: security in AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- വ്യവസായമായി, GDPR പോലുള്ള നിയമങ്ങൾ മൂലം സ്വകാര്യതയും സുരക്ഷയും മേഖലയിൽ വലിയ പുരോഗതി ഉണ്ടായി.
- AI സിസ്റ്റങ്ങളിൽ, വ്യക്തിഗത ഡാറ്റ കൂടുതൽ ആവശ്യമായതിനും സ്വകാര്യതയ്ക്കും ഇടയിലുള്ള സംഘർഷം അംഗീകരിക്കണം.
- ഇന്റർനെറ്റുമായി കണക്ടഡ് കമ്പ്യൂട്ടറുകളുടെ ഉദയം പോലെ, AI-യുമായി ബന്ധപ്പെട്ട സുരക്ഷാ പ്രശ്നങ്ങളും വർധിക്കുന്നു.
- അതേസമയം, സുരക്ഷ മെച്ചപ്പെടുത്താൻ AI ഉപയോഗിക്കുന്നതും കാണുന്നു. ഉദാഹരണത്തിന്, ഇന്ന് മിക്ക ആധുനിക ആന്റി-വൈറസ് സ്കാനറുകളും AI ഹ്യൂറിസ്റ്റിക്സിൽ പ്രവർത്തിക്കുന്നു.
- ഡാറ്റ സയൻസ് പ്രക്രിയകൾ ഏറ്റവും പുതിയ സ്വകാര്യതയും സുരക്ഷാ പ്രാക്ടീസുകളും ചേർന്ന് പ്രവർത്തിക്കണം.
### പാരദർശിത്വം
AI സിസ്റ്റങ്ങൾ മനസ്സിലാക്കാവുന്നതായിരിക്കണം. പാരദർശിത്വത്തിന്റെ പ്രധാന ഭാഗം AI സിസ്റ്റങ്ങളുടെ പെരുമാറ്റവും അവയുടെ ഘടകങ്ങളും വിശദീകരിക്കലാണ്. AI സിസ്റ്റങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു, എന്തുകൊണ്ട് പ്രവർത്തിക്കുന്നു എന്ന് പങ്കാളികൾ മനസ്സിലാക്കണം, അതിലൂടെ പ്രകടന പ്രശ്നങ്ങൾ, സുരക്ഷാ, സ്വകാര്യതാ ആശങ്കകൾ, ബയാസുകൾ, ഒഴിവാക്കൽ പ്രക്രിയകൾ, അനിഷ്ടഫലങ്ങൾ തിരിച്ചറിയാൻ കഴിയും. AI സിസ്റ്റങ്ങൾ ഉപയോഗിക്കുന്നവർ അവ എപ്പോൾ, എന്തുകൊണ്ട്, എങ്ങനെ ഉപയോഗിക്കുന്നു എന്ന് സത്യസന്ധമായി അറിയിക്കണം. ഉപയോഗിക്കുന്ന സിസ്റ്റങ്ങളുടെ പരിമിതികളും വ്യക്തമാക്കണം. ഉദാഹരണത്തിന്, ഒരു ബാങ്ക് ഉപഭോക്തൃ വായ്പാ തീരുമാനങ്ങൾക്ക് AI സിസ്റ്റം ഉപയോഗിക്കുമ്പോൾ, ഫലങ്ങൾ പരിശോധിച്ച് ഏത് ഡാറ്റ സിസ്റ്റത്തിന്റെ നിർദ്ദേശങ്ങളെ സ്വാധീനിക്കുന്നു എന്ന് മനസ്സിലാക്കണം. സർക്കാർ വ്യവസായങ്ങളിൽ AI നിയന്ത്രിക്കാൻ തുടങ്ങുന്നു, അതിനാൽ ഡാറ്റ സയന്റിസ്റ്റുകളും സംഘടനകളും AI സിസ്റ്റം നിയമാനുസൃതമാണോ എന്ന് വിശദീകരിക്കണം, പ്രത്യേകിച്ച് അനിഷ്ടഫലം ഉണ്ടാകുമ്പോൾ.
> [🎥 വീഡിയോക്കായി ഇവിടെ ക്ലിക്ക് ചെയ്യുക: transparency in AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- AI സിസ്റ്റങ്ങൾ വളരെ സങ്കീർണ്ണമായതിനാൽ അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാനും ഫലങ്ങൾ വ്യാഖ്യാനിക്കാനും ബുദ്ധിമുട്ടാണ്.
- ഈ മനസ്സിലാക്കൽക്കുറവ് സിസ്റ്റങ്ങൾ എങ്ങനെ നിയന്ത്രിക്കപ്പെടുന്നു, പ്രവർത്തിപ്പിക്കുന്നു, രേഖപ്പെടുത്തുന്നു എന്നതിനെ ബാധിക്കുന്നു.
- ഏറ്റവും പ്രധാനമായി, ഈ മനസ്സിലാക്കൽക്കുറവ് സിസ്റ്റങ്ങൾ ഉൽപ്പാദിപ്പിക്കുന്ന ഫലങ്ങൾ ഉപയോഗിച്ച് എടുക്കുന്ന തീരുമാനങ്ങളെ ബാധിക്കുന്നു.
### ഉത്തരവാദിത്വം
AI സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്ത് വിനിയോഗിക്കുന്നവർ അവരുടെ സിസ്റ്റങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന് ഉത്തരവാദിത്വം വഹിക്കണം. മുഖം തിരിച്ചറിയൽ പോലുള്ള സങ്കീർണ്ണ സാങ്കേതികവിദ്യകളിൽ ഉത്തരവാദിത്വം പ്രത്യേകിച്ച് പ്രധാനമാണ്. അടുത്തിടെ, മുഖം തിരിച്ചറിയൽ സാങ്കേതികവിദ്യക്ക് വളരെയധികം ആവശ്യകതയുണ്ട്, പ്രത്യേകിച്ച് കാണാതായ കുട്ടികളെ കണ്ടെത്തുന്നതിൽ നിയമപ്രവർത്തക സംഘടനകൾക്ക് ഇത് സഹായകരമെന്ന് കാണുന്നു. എന്നാൽ, ഈ സാങ്കേതികവിദ്യകൾ സർക്കാർ അവരുടെ പൗരന്മാരുടെ അടിസ്ഥാന സ്വാതന്ത്ര്യങ്ങളെ അപകടത്തിലാക്കാൻ ഉപയോഗിക്കാമെന്ന ഭീഷണി ഉണ്ട്, ഉദാഹരണത്തിന്, ചില വ്യക്തികളുടെ നിരന്തര നിരീക്ഷണം സാധ്യമാക്കുക. അതിനാൽ, ഡാറ്റ സയന്റിസ്റ്റുകളും സംഘടനകളും അവരുടെ AI സിസ്റ്റം വ്യക്തികളെയും സമൂഹത്തെയും എങ്ങനെ ബാധിക്കുന്നു എന്നതിന് ഉത്തരവാദിത്വം വഹിക്കണം.
[![Leading AI Researcher Warns of Mass Surveillance Through Facial Recognition](../../../../translated_images/accountability.41d8c0f4b85b6231301d97f17a450a805b7a07aaeb56b34015d71c757cad142e.ml.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Microsoft's Approach to Responsible AI")
> 🎥 മുകളിൽ കാണുന്ന ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക: മുഖം തിരിച്ചറിയൽ വഴി വ്യാപക നിരീക്ഷണത്തിന്റെ മുന്നറിയിപ്പുകൾ
അവസാനമായി, AI സമൂഹത്തിലേക്ക് കൊണ്ടുവരുന്ന ആദ്യ തലമുറയായ നമ്മുടെ തലമുറയ്ക്ക് ഏറ്റവും വലിയ ചോദ്യങ്ങളിൽ ഒന്നാണ്, കമ്പ്യൂട്ടറുകൾ ആളുകൾക്ക് ഉത്തരവാദിത്വം വഹിക്കുമോ, കമ്പ്യൂട്ടറുകൾ രൂപകൽപ്പന ചെയ്യുന്നവർ എല്ലാവർക്കും ഉത്തരവാദിത്വം വഹിക്കുമോ എന്നത് എങ്ങനെ ഉറപ്പാക്കാം എന്നത്.
## പ്രഭാവം വിലയിരുത്തൽ
മെഷീൻ ലേണിംഗ് മോഡൽ പരിശീലിപ്പിക്കുന്നതിന് മുമ്പ്, AI സിസ്റ്റത്തിന്റെ ഉദ്ദേശ്യം, ഉപയോഗം, വിനിയോഗ സ്ഥലം, സിസ്റ്റം ഉപയോഗിക്കുന്നവർ എന്നിവ മനസ്സിലാക്കാൻ പ്രഭാവം വിലയിരുത്തൽ നടത്തുന്നത് പ്രധാനമാണ്. ഇത് സിസ്റ്റം വിലയിരുത്തുന്നവർക്കും ടെസ്റ്റർമാർക്കും സാധ്യതയുള്ള അപകടങ്ങളും പ്രതീക്ഷിക്കുന്ന ഫലങ്ങളും തിരിച്ചറിയാൻ സഹായിക്കും.
പ്രഭാവം വിലയിരുത്തുമ്പോൾ ശ്രദ്ധിക്കേണ്ട മേഖലകൾ:
* **വ്യക്തികൾക്ക് ഹാനികരമായ പ്രഭാവം**: സിസ്റ്റത്തിന്റെ പ്രകടനം തടയുന്ന നിയന്ത്രണങ്ങൾ, ആവശ്യങ്ങൾ, അനധികൃത ഉപയോഗം, പരിചിതമായ പരിമിതികൾ എന്നിവ അറിയുക, വ്യക്തികൾക്ക് ഹാനി ഉണ്ടാകാതിരിക്കാനുള്ള ഉറപ്പാക്കൽ.
* **ഡാറ്റ ആവശ്യകതകൾ**: സിസ്റ്റം എങ്ങനെ എവിടെ ഡാറ്റ ഉപയോഗിക്കും എന്ന് മനസ്സിലാക്കുക, അവലോകനക്കാർക്ക് GDPR, HIPAA പോലുള്ള ഡാറ്റ നിയമങ്ങൾ പരിഗണിക്കാൻ സഹായിക്കും. കൂടാതെ, പരിശീലനത്തിന് ഡാറ്റയുടെ ഉറവിടം, അളവ് മതിയായതാണോ എന്ന് പരിശോധിക്കുക.
* **പ്രഭാവത്തിന്റെ സംക്ഷേപം**: സിസ്റ്റം ഉപയോഗിച്ച് ഉണ്ടാകാവുന്ന ഹാനികളുടെ പട്ടിക ശേഖരിക്കുക. ML ജീവിതചക്രത്തിൽ കണ്ടെത്തിയ പ്രശ്നങ്ങൾ പരിഹരിക്കപ്പെട്ടിട്ടുണ്ടോ എന്ന് നിരീക്ഷിക്കുക.
* **ആവശ്യമായ ലക്ഷ്യങ്ങൾ**: ആറ് പ്രധാന സിദ്ധാന്തങ്ങളിൽ ഓരോന്നിനും ലക്ഷ്യങ്ങൾ പാലിക്കപ്പെട്ടിട്ടുണ്ടോ, ഇടവേളകളുണ്ടോ എന്ന് വിലയിരുത്തുക.
## ഉത്തരവാദിത്വമുള്ള AI ഉപയോഗിച്ച് ഡീബഗ്ഗിംഗ്
സോഫ്റ്റ്‌വെയർ ആപ്ലിക്കേഷൻ ഡീബഗ്ഗിംഗിനുപോലെ, AI സിസ്റ്റം ഡീബഗ്ഗിംഗ് സിസ്റ്റത്തിലെ പ്രശ്നങ്ങൾ കണ്ടെത്തി പരിഹരിക്കുന്ന അനിവാര്യ പ്രക്രിയയാണ്. മോഡൽ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കാത്തതിനു പല കാരണങ്ങൾ ഉണ്ടാകാം. പരമ്പരാഗത മോഡൽ പ്രകടന സൂചകങ്ങൾ ഒരു മോഡലിന്റെ പ്രകടനത്തിന്റെ കണക്കുകൂട്ടലുകളാണ്, എന്നാൽ അവ ഉത്തരവാദിത്വമുള്ള AI സിദ്ധാന്തങ്ങൾ ലംഘിക്കുന്ന വിധം വിശകലനം ചെയ്യാൻ പോരാ. കൂടാതെ, മെഷീൻ ലേണിംഗ് മോഡൽ ഒരു ബ്ലാക്ക് ബോക്സാണ്, അതിന്റെ ഫലം എന്തുകൊണ്ട് ഉണ്ടാകുന്നു എന്ന് മനസ്സിലാക്കാനും തെറ്റുകൾ സംഭവിച്ചപ്പോൾ വിശദീകരിക്കാനും ബുദ്ധിമുട്ടാണ്. ഈ കോഴ്സിന്റെ പിന്നീട് ഭാഗങ്ങളിൽ, AI സിസ്റ്റങ്ങൾ ഡീബഗ് ചെയ്യാൻ ഉത്തരവാദിത്വമുള്ള AI ഡാഷ്ബോർഡ് ഉപയോഗിക്കുന്നത് പഠിക്കും. ഡാഷ്ബോർഡ് ഡാറ്റ സയന്റിസ്റ്റുകൾക്കും AI ഡെവലപ്പർമാർക്കും താഴെപ്പറയുന്നവ ചെയ്യാൻ സഹായിക്കുന്ന സമഗ്ര ഉപകരണമാണ്:
* **പിശക് വിശകലനം**: സിസ്റ്റത്തിന്റെ നീതിയിലും വിശ്വാസ്യതയിലും ബാധിക്കുന്ന മോഡലിന്റെ പിശക് വിതരണങ്ങൾ തിരിച്ചറിയാൻ.
* **മോഡൽ അവലോകനം**: ഡാറ്റ കോഹോർട്ടുകളിൽ മോഡലിന്റെ പ്രകടന വ്യത്യാസങ്ങൾ കണ്ടെത്താൻ.
* **ഡാറ്റ വിശകലനം**: ഡാറ്റയുടെ വിതരണവും ബയാസുകൾ തിരിച്ചറിയാനും, നീതി, ഉൾക്കൊള്ളൽ, വിശ്വാസ്യത പ്രശ്നങ്ങൾ കണ്ടെത്താനും.
* **മോഡൽ വ്യാഖ്യാനം**: മോഡലിന്റെ പ്രവചനങ്ങളെ സ്വാധീനിക്കുന്ന ഘടകങ്ങൾ മനസ്സിലാക്കാൻ. ഇത് പാരദർശിത്വത്തിനും ഉത്തരവാദിത്വത്തിനും പ്രധാനമാണ്.
## 🚀 ചലഞ്ച്
ഹാനികൾ ആദ്യഘട്ടത്തിൽ തന്നെ ഉണ്ടാകാതിരിക്കാൻ, നാം:
- സിസ്റ്റങ്ങളിൽ ജോലി ചെയ്യുന്നവരിൽ വ്യത്യസ്ത പശ്ചാത്തലങ്ങളും കാഴ്ചപ്പാടുകളും ഉണ്ടായിരിക്കണം
- നമ്മുടെ സമൂഹത്തിന്റെ വൈവിധ്യം പ്രതിഫലിപ്പിക്കുന്ന ഡാറ്റാസെറ്റുകളിൽ നിക്ഷേപം നടത്തണം
- ഉത്തരവാദിത്വമുള്ള AI കണ്ടെത്താനും ശരിയാക്കാനും മെഷീൻ ലേണിംഗ് ജീവിതചക്രത്തിൽ മികച്ച രീതികൾ വികസിപ്പിക്കണം
മോഡൽ നിർമ്മാണത്തിലും ഉപയോഗത്തിലും മോഡലിന്റെ വിശ്വസനീയത ഇല്ലായ്മ വ്യക്തമായ യാഥാർത്ഥ്യ സാഹചര്യങ്ങളെക്കുറിച്ച് ചിന്തിക്കുക. മറ്റെന്തെല്ലാം പരിഗണിക്കണം?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ഈ പാഠത്തിൽ, മെഷീൻ ലേണിങ്ങിൽ നീതിയും അനീതിയും എന്ന ആശയങ്ങളുടെ ചില അടിസ്ഥാനങ്ങൾ നിങ്ങൾ പഠിച്ചു.
ഈ വിഷയങ്ങളിൽ കൂടുതൽ ആഴത്തിൽ പ്രവേശിക്കാൻ ഈ വർക്ക്‌ഷോപ്പ് കാണുക:
- ഉത്തരവാദിത്വമുള്ള AI ന്റെ പിന്തുടർച്ചയിൽ: Besmira Nushi, Mehrnoosh Sameki, Amit Sharma എന്നിവരാൽ സിദ്ധാന്തങ്ങളെ പ്രായോഗികതയിലേക്ക് കൊണ്ടുവരുന്നു
[![Responsible AI Toolbox: An open-source framework for building responsible AI](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: An open-source framework for building responsible AI")
> 🎥 വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക: Besmira Nushi, Mehrnoosh Sameki, Amit Sharma എന്നിവരാൽ RAI Toolbox: An open-source framework for building responsible AI
ഇതും വായിക്കുക:
- Microsoft ന്റെ RAI റിസോഴ്‌സ് സെന്റർ: [Responsible AI Resources – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Microsoft ന്റെ FATE ഗവേഷണ സംഘം: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
RAI Toolbox:
- [Responsible AI Toolbox GitHub repository](https://github.com/microsoft/responsible-ai-toolbox)
നീതിയുണ്ടാക്കാൻ Azure Machine Learning ന്റെ ഉപകരണങ്ങളെക്കുറിച്ച് വായിക്കുക:
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
## അസൈൻമെന്റ്
[RAI Toolbox പരിശോധിക്കുക](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/ml/1-Introduction/3-fairness/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "dbda60e7b1fe5f18974e7858eff0004e",
"translation_date": "2025-12-19T13:43:38+00:00",
"source_file": "1-Introduction/3-fairness/assignment.md",
"language_code": "ml"
}
-->
# ഉത്തരവാദിത്വമുള്ള AI ടൂൾബോക്സ് അന്വേഷിക്കുക
## നിർദ്ദേശങ്ങൾ
ഈ പാഠത്തിൽ നിങ്ങൾ ഉത്തരവാദിത്വമുള്ള AI ടൂൾബോക്സ് എന്നതിനെക്കുറിച്ച് പഠിച്ചു, ഇത് "ഡാറ്റാ സയന്റിസ്റ്റുകൾക്ക് AI സിസ്റ്റങ്ങൾ വിശകലനം ചെയ്ത് മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്ന ഒരു ഓപ്പൺ-സോഴ്‌സ്, കമ്മ്യൂണിറ്റി-നയിച്ച പ്രോജക്ട്" ആണ്. ഈ അസൈൻമെന്റിനായി, RAI Toolbox-ന്റെ [നോട്ട്ബുക്കുകളിൽ](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) ഒന്നിനെ അന്വേഷിച്ച്, അതിൽ നിന്നുള്ള കണ്ടെത്തലുകൾ ഒരു പേപ്പറിൽ അല്ലെങ്കിൽ പ്രეზന്റേഷനിൽ റിപ്പോർട്ട് ചെയ്യുക.
## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണമായത് | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------- | --------- | -------- | ----------------- |
| | Fairlearn-ന്റെ സിസ്റ്റങ്ങൾ, പ്രവർത്തിപ്പിച്ച നോട്ട്ബുക്ക്, പ്രവർത്തിപ്പിച്ചതിൽ നിന്നുള്ള നിഗമനങ്ങൾ ചർച്ച ചെയ്യുന്ന ഒരു പേപ്പർ അല്ലെങ്കിൽ പവർപോയിന്റ് പ്രეზന്റേഷൻ അവതരിപ്പിക്കുന്നു | നിഗമനങ്ങളില്ലാതെ ഒരു പേപ്പർ അവതരിപ്പിക്കുന്നു | ഒരു പേപ്പർ അവതരിപ്പിക്കുന്നില്ല |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

134
translations/ml/1-Introduction/4-techniques-of-ML/README.md
Unescape View File

@ -0,0 +1,134 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9d91f3af3758fdd4569fb410575995ef",
"translation_date": "2025-12-19T13:36:10+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
"language_code": "ml"
}
-->
# മെഷീൻ ലേണിങ്ങിന്റെ സാങ്കേതിക വിദ്യകൾ
മെഷീൻ ലേണിംഗ് മോഡലുകൾ നിർമ്മിക്കുന്നതും ഉപയോഗിക്കുന്നതും പരിപാലിക്കുന്നതും, അവ ഉപയോഗിക്കുന്ന ഡാറ്റയും, മറ്റ് പല വികസന പ്രവൃത്തികളിൽ നിന്നുള്ളവയിൽ നിന്ന് വളരെ വ്യത്യസ്തമായ പ്രക്രിയയാണ്. ഈ പാഠത്തിൽ, നാം ഈ പ്രക്രിയയെ വിശദീകരിക്കുകയും നിങ്ങൾ അറിയേണ്ട പ്രധാന സാങ്കേതിക വിദ്യകൾ രേഖപ്പെടുത്തുകയും ചെയ്യും. നിങ്ങൾക്ക്:
- മെഷീൻ ലേണിംഗിന്റെ അടിസ്ഥാന പ്രക്രിയകൾ ഉയർന്ന തലത്തിൽ മനസ്സിലാക്കാം.
- 'മോഡലുകൾ', 'ഭാവനകൾ', 'പരിശീലന ഡാറ്റ' പോലുള്ള അടിസ്ഥാന ആശയങ്ങൾ അന്വേഷിക്കാം.
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
[![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) പ്രക്രിയകൾ സൃഷ്ടിക്കുന്ന കലയിൽ പല ഘട്ടങ്ങൾ ഉൾപ്പെടുന്നു:
1. **ചോദ്യമൊരുക്കുക**. മിക്ക ML പ്രക്രിയകളും ഒരു ലളിതമായ നിബന്ധനാപരമായ പ്രോഗ്രാമോ നിയമങ്ങൾ അടിസ്ഥാനമാക്കിയ എഞ്ചിനോ മറുപടി നൽകാൻ കഴിയാത്ത ഒരു ചോദ്യമൊരുക്കുന്നതിൽ ആരംഭിക്കുന്നു. ഈ ചോദ്യങ്ങൾ സാധാരണയായി ഡാറ്റാ ശേഖരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള പ്രവചനങ്ങളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.
2. **ഡാറ്റ ശേഖരിക്കുകയും തയ്യാറാക്കുകയും ചെയ്യുക**. നിങ്ങളുടെ ചോദ്യത്തിന് മറുപടി നൽകാൻ, നിങ്ങൾക്ക് ഡാറ്റ ആവശ്യമുണ്ട്. നിങ്ങളുടെ ഡാറ്റയുടെ ഗുണമേന്മയും, ചിലപ്പോൾ, അളവും, നിങ്ങളുടെ പ്രാഥമിക ചോദ്യത്തിന് എത്രത്തോളം നല്ല മറുപടി നൽകാമെന്ന് നിർണ്ണയിക്കും. ഡാറ്റ ദൃശ്യവൽക്കരണം ഈ ഘട്ടത്തിന്റെ ഒരു പ്രധാന ഭാഗമാണ്. ഈ ഘട്ടത്തിൽ ഡാറ്റയെ പരിശീലനവും പരിശോധനയും എന്നിങ്ങനെ വിഭജിച്ച് മോഡൽ നിർമ്മിക്കാനും ഉൾപ്പെടുന്നു.
3. **പരിശീലന രീതി തിരഞ്ഞെടുക്കുക**. നിങ്ങളുടെ ചോദ്യത്തിനും ഡാറ്റയുടെ സ്വഭാവത്തിനും അനുസരിച്ച്, ഡാറ്റയെ മികച്ച രീതിയിൽ പ്രതിഫലിപ്പിക്കുകയും അതിനെതിരെ കൃത്യമായ പ്രവചനങ്ങൾ നടത്തുകയും ചെയ്യാൻ മോഡൽ പരിശീലിപ്പിക്കാൻ നിങ്ങൾ എങ്ങനെ പരിശീലനം നൽകണമെന്ന് തിരഞ്ഞെടുക്കണം. ഇത് നിങ്ങളുടെ ML പ്രക്രിയയിലെ പ്രത്യേക വിദഗ്ധത ആവശ്യമായ ഭാഗമാണ്, കൂടാതെ പലപ്പോഴും വലിയ പരീക്ഷണങ്ങൾ നടത്തേണ്ടതും.
4. **മോഡൽ പരിശീലിപ്പിക്കുക**. നിങ്ങളുടെ പരിശീലന ഡാറ്റ ഉപയോഗിച്ച്, ഡാറ്റയിലെ മാതൃകകൾ തിരിച്ചറിയാൻ വിവിധ ആൽഗോരിതങ്ങൾ ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കും. മോഡൽ ചില ഭാഗങ്ങളിൽ കൂടുതൽ പ്രാധാന്യം നൽകാൻ ക്രമീകരിക്കാവുന്ന ആന്തരിക ഭാരങ്ങൾ ഉപയോഗിക്കാം.
5. **മോഡൽ വിലയിരുത്തുക**. നിങ്ങൾ ശേഖരിച്ച ഡാറ്റയിൽ നിന്ന് മുമ്പ് കാണാത്ത ഡാറ്റ (പരിശോധന ഡാറ്റ) ഉപയോഗിച്ച് മോഡൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് പരിശോധിക്കും.
6. **പരാമീറ്റർ ട്യൂണിംഗ്**. മോഡലിന്റെ പ്രകടനത്തെ അടിസ്ഥാനമാക്കി, മോഡൽ പരിശീലിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ആൽഗോരിതങ്ങളുടെ പെരുമാറ്റം നിയന്ത്രിക്കുന്ന വ്യത്യസ്ത പരാമീറ്ററുകൾ ഉപയോഗിച്ച് പ്രക്രിയ വീണ്ടും നടത്താം.
7. **പ്രവചനം നടത്തുക**. പുതിയ ഇൻപുട്ടുകൾ ഉപയോഗിച്ച് മോഡലിന്റെ കൃത്യത പരിശോധിക്കുക.
## ഏത് ചോദ്യമാണ് ചോദിക്കേണ്ടത്
കമ്പ്യൂട്ടറുകൾ ഡാറ്റയിൽ മറഞ്ഞിരിക്കുന്ന മാതൃകകൾ കണ്ടെത്തുന്നതിൽ പ്രത്യേകമായി നൈപുണ്യമുള്ളവയാണ്. നിബന്ധനാപരമായ നിയമങ്ങൾ അടിസ്ഥാനമാക്കിയ എഞ്ചിൻ സൃഷ്ടിച്ച് എളുപ്പത്തിൽ മറുപടി നൽകാൻ കഴിയാത്ത ഒരു ഡൊമെയ്ൻ സംബന്ധിച്ച ചോദ്യങ്ങൾ ഗവേഷകർക്ക് ഇത് വളരെ സഹായകരമാണ്. ഉദാഹരണത്തിന്, ഒരു ആക്ച്വറിയൽ ജോലി നൽകിയാൽ, ഒരു ഡാറ്റാ സയന്റിസ്റ്റ് പുകവലി ചെയ്യുന്നവരും പുകവലി ചെയ്യാത്തവരും മരണനിരക്കുകൾക്കായി കൈകൊണ്ട നിയമങ്ങൾ നിർമ്മിക്കാൻ കഴിയും.
എന്നാൽ, പല മറ്റ് വ്യത്യസ്ത ഘടകങ്ങൾ പരിഗണിക്കുമ്പോൾ, ഒരു ML മോഡൽ മുൻകാല ആരോഗ്യ ചരിത്രത്തെ അടിസ്ഥാനമാക്കി ഭാവിയിലെ മരണനിരക്കുകൾ പ്രവചിക്കാൻ കൂടുതൽ കാര്യക്ഷമമാകാം. ഒരു സന്തോഷകരമായ ഉദാഹരണം, ഒരു നിശ്ചിത സ്ഥലത്ത് ഏപ്രിൽ മാസത്തെ കാലാവസ്ഥ പ്രവചനങ്ങൾ latitude, longitude, കാലാവസ്ഥ മാറ്റം, സമുദ്രത്തിന് സമീപം, ജെറ്റ് സ്ട്രീം മാതൃകകൾ എന്നിവ ഉൾപ്പെടുന്ന ഡാറ്റയുടെ അടിസ്ഥാനത്തിൽ നിർമിക്കുന്നത് ആകാം.
✅ കാലാവസ്ഥ മോഡലുകളെക്കുറിച്ചുള്ള ഈ [സ്ലൈഡ് ഡെക്ക്](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) കാലാവസ്ഥ വിശകലനത്തിൽ ML ഉപയോഗിക്കുന്നതിനുള്ള ചരിത്രപരമായ കാഴ്ചപ്പാട് നൽകുന്നു.
## നിർമ്മാണത്തിന് മുമ്പുള്ള പ്രവർത്തനങ്ങൾ
നിങ്ങളുടെ മോഡൽ നിർമ്മിക്കാൻ തുടങ്ങുന്നതിന് മുമ്പ്, നിങ്ങൾ പൂർത്തിയാക്കേണ്ട നിരവധി പ്രവർത്തനങ്ങൾ ഉണ്ട്. നിങ്ങളുടെ ചോദ്യത്തെ പരീക്ഷിക്കുകയും മോഡലിന്റെ പ്രവചനങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു ഹിപോത്തസിസ് രൂപപ്പെടുത്തുകയും ചെയ്യാൻ, നിങ്ങൾക്ക് പല ഘടകങ്ങളും തിരിച്ചറിയുകയും ക്രമീകരിക്കുകയും വേണം.
### ഡാറ്റ
നിങ്ങളുടെ ചോദ്യത്തിന് ഏതെങ്കിലും ഉറപ്പോടെ മറുപടി നൽകാൻ, ശരിയായ തരം ഡാറ്റയുടെ നല്ല അളവ് ആവശ്യമാണ്. ഈ ഘട്ടത്തിൽ നിങ്ങൾ ചെയ്യേണ്ട രണ്ട് കാര്യങ്ങളുണ്ട്:
- **ഡാറ്റ ശേഖരിക്കുക**. മുമ്പത്തെ പാഠത്തിൽ ഡാറ്റ വിശകലനത്തിൽ നീതിയുള്ളതിനെക്കുറിച്ച് പഠിച്ചതു ഓർക്കുക, ശ്രദ്ധയോടെ ഡാറ്റ ശേഖരിക്കുക. ഈ ഡാറ്റയുടെ ഉറവിടങ്ങളെക്കുറിച്ച്, അതിൽ ഉള്ള സ്വാഭാവിക പാകങ്ങൾക്കുറിച്ച് ജാഗ്രത പുലർത്തുക, അതിന്റെ ഉറവിടം രേഖപ്പെടുത്തുക.
- **ഡാറ്റ തയ്യാറാക്കുക**. ഡാറ്റ തയ്യാറാക്കൽ പ്രക്രിയയിൽ പല ഘട്ടങ്ങളുണ്ട്. വ്യത്യസ്ത ഉറവിടങ്ങളിൽ നിന്നുള്ള ഡാറ്റ സംയോജിപ്പിക്കുകയും സാധാരണവത്കരിക്കുകയും ചെയ്യേണ്ടതുണ്ടാകാം. ഡാറ്റയുടെ ഗുണമേന്മയും അളവും മെച്ചപ്പെടുത്താൻ സ്ട്രിംഗുകൾ നമ്പറുകളായി മാറ്റൽ പോലുള്ള വിവിധ രീതികൾ ഉപയോഗിക്കാം ([Clustering](../../5-Clustering/1-Visualize/README.md) പാഠത്തിൽ ചെയ്തതുപോലെ). നിങ്ങൾക്ക് പുതിയ ഡാറ്റ സൃഷ്ടിക്കേണ്ടതും ഉണ്ടാകാം, മൗലിക ഡാറ്റയെ അടിസ്ഥാനമാക്കി ([Classification](../../4-Classification/1-Introduction/README.md) പാഠത്തിൽ ചെയ്തതുപോലെ). ഡാറ്റ ശുദ്ധീകരിക്കുകയും തിരുത്തുകയും ചെയ്യാം ([Web App](../../3-Web-App/README.md) പാഠത്തിന് മുമ്പ് ചെയ്യുന്നതുപോലെ). അവസാനം, നിങ്ങളുടെ പരിശീലന സാങ്കേതിക വിദ്യകൾ അനുസരിച്ച് ഡാറ്റയെ യാദൃച്ഛികമാക്കുകയും ഷഫിൾ ചെയ്യുകയും ചെയ്യേണ്ടതുണ്ടാകാം.
✅ ഡാറ്റ ശേഖരിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്ത ശേഷം, അതിന്റെ രൂപം നിങ്ങളുടെ ഉദ്ദേശിച്ച ചോദ്യത്തിന് മറുപടി നൽകാൻ അനുയോജ്യമാണോ എന്ന് പരിശോധിക്കാൻ ഒരു നിമിഷം എടുത്തു നോക്കുക. നിങ്ങളുടെ നൽകിയ ജോലിയിൽ ഡാറ്റ നല്ല പ്രകടനം കാണിക്കില്ലായിരുന്നോ എന്ന് ഞങ്ങൾ [Clustering](../../5-Clustering/1-Visualize/README.md) പാഠങ്ങളിൽ കണ്ടെത്തുന്നു!
### ഫീച്ചറുകളും ലക്ഷ്യവും
ഒരു [ഫീച്ചർ](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) നിങ്ങളുടെ ഡാറ്റയുടെ അളക്കാവുന്ന സ്വഭാവമാണ്. പല ഡാറ്റാസെറ്റുകളിലും ഇത് 'തീയതി', 'വലിപ്പം', 'നിറം' പോലുള്ള കോളം തലക്കെട്ടായി പ്രകടിപ്പിക്കപ്പെടുന്നു. നിങ്ങളുടെ ഫീച്ചർ വേരിയബിൾ, സാധാരണയായി കോഡിൽ `X` ആയി പ്രതിനിധീകരിക്കപ്പെടുന്നു, മോഡൽ പരിശീലിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഇൻപുട്ട് വേരിയബിൾ ആണ്.
ലക്ഷ്യം നിങ്ങൾ പ്രവചിക്കാൻ ശ്രമിക്കുന്ന വസ്തുവാണ്. ലക്ഷ്യം സാധാരണയായി കോഡിൽ `y` ആയി പ്രതിനിധീകരിക്കപ്പെടുന്നു, ഇത് നിങ്ങളുടെ ഡാറ്റയിൽ നിന്നുള്ള ചോദ്യത്തിന് നിങ്ങൾ ചോദിക്കുന്ന മറുപടിയാണ്: ഡിസംബർ മാസത്തിൽ, ഏത് **നിറത്തിലുള്ള** പംപ്കിനുകൾ ഏറ്റവും വിലകുറഞ്ഞവ ആയിരിക്കും? സാൻ ഫ്രാൻസിസ്കോയിൽ, ഏത് പ്രദേശങ്ങളിൽ മികച്ച റിയൽ എസ്റ്റേറ്റ് **വില** ഉണ്ടാകും? ചിലപ്പോൾ ലക്ഷ്യം ലേബൽ ആട്രിബ്യൂട്ട് എന്നും വിളിക്കുന്നു.
### നിങ്ങളുടെ ഫീച്ചർ വേരിയബിൾ തിരഞ്ഞെടുക്കൽ
🎓 **ഫീച്ചർ സെലക്ഷനും ഫീച്ചർ എക്സ്ട്രാക്ഷനും** മോഡൽ നിർമ്മിക്കുമ്പോൾ ഏത് വേരിയബിൾ തിരഞ്ഞെടുക്കണമെന്ന് നിങ്ങൾ എങ്ങനെ അറിയും? ഏറ്റവും മികച്ച പ്രകടനം നൽകുന്ന മോഡലിനായി ശരിയായ വേരിയബിളുകൾ തിരഞ്ഞെടുക്കാൻ നിങ്ങൾ ഫീച്ചർ സെലക്ഷൻ അല്ലെങ്കിൽ ഫീച്ചർ എക്സ്ട്രാക്ഷൻ പ്രക്രിയയിലൂടെ പോകും. ഇവ ഒരേ കാര്യമല്ല: "ഫീച്ചർ എക്സ്ട്രാക്ഷൻ മൗലിക ഫീച്ചറുകളുടെ ഫംഗ്ഷനുകളിൽ നിന്നുള്ള പുതിയ ഫീച്ചറുകൾ സൃഷ്ടിക്കുന്നു, എന്നാൽ ഫീച്ചർ സെലക്ഷൻ ഫീച്ചറുകളുടെ ഒരു ഉപസമൂഹം തിരികെ നൽകുന്നു." ([സ്രോതസ്സ്](https://wikipedia.org/wiki/Feature_selection))
### നിങ്ങളുടെ ഡാറ്റ ദൃശ്യവൽക്കരിക്കുക
ഡാറ്റാ സയന്റിസ്റ്റിന്റെ ഉപകരണസഞ്ചിയിൽ ഒരു പ്രധാന ഘടകം സീബോൺ അല്ലെങ്കിൽ മാട്പ്ലോട്ട്‌ലിബ് പോലുള്ള മികച്ച ലൈബ്രറികൾ ഉപയോഗിച്ച് ഡാറ്റ ദൃശ്യവൽക്കരിക്കുന്ന ശേഷിയാണ്. നിങ്ങളുടെ ഡാറ്റ ദൃശ്യമായി പ്രതിനിധീകരിക്കുന്നത് മറഞ്ഞിരിക്കുന്ന ബന്ധങ്ങൾ കണ്ടെത്താൻ സഹായിക്കാം. നിങ്ങളുടെ ദൃശ്യവൽക്കരണങ്ങൾ പാകം അല്ലാത്തതോ അസമതുലിതമായ ഡാറ്റയോ കണ്ടെത്താൻ സഹായിക്കാം ([Classification](../../4-Classification/2-Classifiers-1/README.md) പാഠത്തിൽ കണ്ടെത്തുന്നതുപോലെ).
### നിങ്ങളുടെ ഡാറ്റാസെറ്റ് വിഭജിക്കുക
പരിശീലനത്തിന് മുമ്പ്, നിങ്ങളുടെ ഡാറ്റാസെറ്റ് രണ്ട് അല്ലെങ്കിൽ അതിലധികം അസമാനമായ വലുപ്പമുള്ള ഭാഗങ്ങളായി വിഭജിക്കണം, എന്നാൽ ഡാറ്റയെ നന്നായി പ്രതിനിധീകരിക്കണം.
- **പരിശീലനം**. ഡാറ്റാസെറ്റിന്റെ ഈ ഭാഗം മോഡലിന് അനുയോജ്യമായ രീതിയിൽ പരിശീലിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. ഇത് മൗലിക ഡാറ്റാസെറ്റിന്റെ ഭൂരിഭാഗമാണ്.
- **പരിശോധന**. ഒരു ടെസ്റ്റ് ഡാറ്റാസെറ്റ് സ്വതന്ത്രമായ ഡാറ്റാ ഗ്രൂപ്പാണ്, സാധാരണയായി മൗലിക ഡാറ്റയിൽ നിന്നാണ് ശേഖരിക്കുന്നത്, ഇത് നിർമ്മിച്ച മോഡലിന്റെ പ്രകടനം സ്ഥിരീകരിക്കാൻ ഉപയോഗിക്കുന്നു.
- **സാധൂകരിക്കൽ**. സാധൂകരിക്കൽ സെറ്റ് ഒരു ചെറിയ സ്വതന്ത്ര ഉദാഹരണ ഗ്രൂപ്പാണ്, ഇത് മോഡലിന്റെ ഹൈപ്പർപാരാമീറ്ററുകൾ അല്ലെങ്കിൽ ഘടന മെച്ചപ്പെടുത്താൻ ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ ഡാറ്റയുടെ വലുപ്പത്തിനും ചോദിക്കുന്ന ചോദ്യത്തിനും അനുസരിച്ച്, ഈ മൂന്നാം സെറ്റ് നിർമ്മിക്കേണ്ടതില്ലായിരിക്കാം ([Time Series Forecasting](../../7-TimeSeries/1-Introduction/README.md) പാഠത്തിൽ ഞങ്ങൾ കാണിക്കുന്നു).
## മോഡൽ നിർമ്മിക്കൽ
നിങ്ങളുടെ പരിശീലന ഡാറ്റ ഉപയോഗിച്ച്, നിങ്ങളുടെ ലക്ഷ്യം മോഡൽ നിർമ്മിക്കുകയോ, അല്ലെങ്കിൽ നിങ്ങളുടെ ഡാറ്റയുടെ സാംഖ്യിക പ്രതിനിധാനം സൃഷ്ടിക്കുകയോ ചെയ്യുകയാണ്, വിവിധ ആൽഗോരിതങ്ങൾ ഉപയോഗിച്ച് അതിനെ **പരിശീലിപ്പിക്കുക**. മോഡൽ പരിശീലിപ്പിക്കുന്നത് ഡാറ്റയ്ക്ക് പരിചയപ്പെടാൻ അനുവദിക്കുകയും കണ്ടെത്തിയ മാതൃകകളെക്കുറിച്ച് അനുമാനങ്ങൾ നടത്തുകയും, അവ സ്ഥിരീകരിക്കുകയും, അംഗീകരിക്കുകയും അല്ലെങ്കിൽ നിരസിക്കുകയും ചെയ്യാൻ സഹായിക്കുന്നു.
### പരിശീലന രീതി തീരുമാനിക്കുക
നിങ്ങളുടെ ചോദ്യത്തിനും ഡാറ്റയുടെ സ്വഭാവത്തിനും അനുസരിച്ച്, നിങ്ങൾ അത് പരിശീലിപ്പിക്കാൻ ഒരു രീതി തിരഞ്ഞെടുക്കും. ഈ കോഴ്സിൽ ഉപയോഗിക്കുന്ന [Scikit-learn ന്റെ ഡോക്യുമെന്റേഷൻ](https://scikit-learn.org/stable/user_guide.html) വഴി നിങ്ങൾ മോഡൽ പരിശീലിപ്പിക്കാൻ നിരവധി മാർഗങ്ങൾ അന്വേഷിക്കാം. നിങ്ങളുടെ അനുഭവം അനുസരിച്ച്, മികച്ച മോഡൽ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് പല വ്യത്യസ്ത രീതി പരീക്ഷിക്കേണ്ടിവരും. ഡാറ്റാ സയന്റിസ്റ്റുകൾ ഒരു മോഡലിന്റെ പ്രകടനം വിലയിരുത്താൻ മുമ്പ് കാണാത്ത ഡാറ്റ നൽകുകയും കൃത്യത, പാകം, മറ്റ് ഗുണനിലവാര കുറയ്ക്കുന്ന പ്രശ്നങ്ങൾ പരിശോധിക്കുകയും, ജോലിക്ക് ഏറ്റവും അനുയോജ്യമായ പരിശീലന രീതി തിരഞ്ഞെടുക്കുകയും ചെയ്യുന്ന പ്രക്രിയയിലൂടെ നിങ്ങൾ കടന്നുപോകും.
### മോഡൽ പരിശീലിപ്പിക്കുക
നിങ്ങളുടെ പരിശീലന ഡാറ്റ ഉപയോഗിച്ച്, മോഡൽ സൃഷ്ടിക്കാൻ 'ഫിറ്റ്' ചെയ്യാൻ തയ്യാറാകുക. പല ML ലൈബ്രറികളിലും 'model.fit' എന്ന കോഡ് കാണും - ഈ സമയത്ത് നിങ്ങൾ നിങ്ങളുടെ ഫീച്ചർ വേരിയബിൾ മൂല്യങ്ങളുടെ ഒരു അറേ (സാധാരണയായി 'X')യും ലക്ഷ്യ വേരിയബിൾ (സാധാരണയായി 'y')യും അയയ്ക്കും.
### മോഡൽ വിലയിരുത്തുക
പരിശീലന പ്രക്രിയ പൂർത്തിയായ ശേഷം (വലിയ മോഡൽ പരിശീലിപ്പിക്കാൻ പല ആവർത്തനങ്ങൾ അല്ലെങ്കിൽ 'എപ്പോക്കുകൾ' ആവാം), ടെസ്റ്റ് ഡാറ്റ ഉപയോഗിച്ച് മോഡലിന്റെ ഗുണമേന്മ വിലയിരുത്താൻ കഴിയും. ഈ ഡാറ്റ മോഡൽ മുമ്പ് വിശകലനം ചെയ്തിട്ടില്ലാത്ത മൗലിക ഡാറ്റയുടെ ഒരു ഉപസമൂഹമാണ്. മോഡലിന്റെ ഗുണമേന്മയെക്കുറിച്ചുള്ള മെട്രിക്‌സ് പട്ടിക പ്രിന്റ് ചെയ്യാം.
🎓 **മോഡൽ ഫിറ്റിംഗ്**
മെഷീൻ ലേണിംഗിന്റെ സാന്ദർഭ്യത്തിൽ, മോഡൽ ഫിറ്റിംഗ് എന്നത് മോഡലിന്റെ അടിസ്ഥാന ഫംഗ്ഷന്റെ കൃത്യതയെ സൂചിപ്പിക്കുന്നു, അത് പരിചയമില്ലാത്ത ഡാറ്റ വിശകലനം ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ.
🎓 **അണ്ടർഫിറ്റിംഗ്** (കുറഞ്ഞ ഫിറ്റ്)യും **ഓവർഫിറ്റിംഗ്** (അധിക ഫിറ്റ്)യും മോഡലിന്റെ ഗുണമേന്മ കുറയ്ക്കുന്ന സാധാരണ പ്രശ്നങ്ങളാണ്, മോഡൽ ശരിയായി ഫിറ്റ് ചെയ്യാത്തതോ വളരെ അധികം ഫിറ്റ് ചെയ്തതോ ആയിരിക്കുമ്പോൾ. ഇത് മോഡൽ പരിശീലന ഡാറ്റയുമായി വളരെ അടുത്തോ വളരെ ദൂരമായോ പ്രവചനങ്ങൾ നടത്താൻ കാരണമാകും. ഒരു ഓവർഫിറ്റ് മോഡൽ പരിശീലന ഡാറ്റ വളരെ നന്നായി പ്രവചിക്കുന്നു, കാരണം അത് ഡാറ്റയുടെ വിശദാംശങ്ങളും ശബ്ദവും വളരെ നന്നായി പഠിച്ചിട്ടുണ്ട്. ഒരു അണ്ടർഫിറ്റ് മോഡൽ കൃത്യമായില്ല, കാരണം അത് പരിശീലന ഡാറ്റയും മുമ്പ് 'കണ്ടിട്ടില്ലാത്ത' ഡാറ്റയും കൃത്യമായി വിശകലനം ചെയ്യാൻ കഴിയുന്നില്ല.
![overfitting model](../../../../translated_images/overfitting.1c132d92bfd93cb63240baf63ebdf82c30e30a0a44e1ad49861b82ff600c2b5c.ml.png)
> ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
## പരാമീറ്റർ ട്യൂണിംഗ്
നിങ്ങളുടെ പ്രാഥമിക പരിശീലനം പൂർത്തിയായ ശേഷം, മോഡലിന്റെ ഗുണമേന്മ നിരീക്ഷിച്ച് അതിന്റെ 'ഹൈപ്പർപാരാമീറ്ററുകൾ' ക്രമീകരിച്ച് മെച്ചപ്പെടുത്താൻ പരിഗണിക്കുക. പ്രക്രിയയെക്കുറിച്ച് കൂടുതൽ വായിക്കുക [ഡോക്യുമെന്റേഷനിൽ](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
## പ്രവചനം
ഇത് നിങ്ങൾക്ക് പൂർണ്ണമായും പുതിയ ഡാറ്റ ഉപയോഗിച്ച് മോഡലിന്റെ കൃത്യത പരിശോധിക്കാനുള്ള നിമിഷമാണ്. 'പ്രയോഗത്തിൽ' ഉള്ള ML സജ്ജീകരണത്തിൽ, നിങ്ങൾ മോഡൽ പ്രൊഡക്ഷനിൽ ഉപയോഗിക്കാൻ വെബ് ആസറ്റുകൾ നിർമ്മിക്കുമ്പോൾ, ഈ പ്രക്രിയയിൽ ഉപയോക്തൃ ഇൻപുട്ട് (ഉദാഹരണത്തിന് ബട്ടൺ അമർത്തൽ) ശേഖരിച്ച് ഒരു വേരിയബിൾ സജ്ജമാക്കി മോഡലിലേക്ക് ഇൻഫറൻസ് അല്ലെങ്കിൽ വിലയിരുത്തലിനായി അയയ്ക്കുന്നതും ഉൾപ്പെടാം.
ഈ പാഠങ്ങളിൽ, നിങ്ങൾ ഈ ഘട്ടങ്ങൾ ഉപയോഗിച്ച് ഡാറ്റാ സയന്റിസ്റ്റിന്റെ എല്ലാ പ്രവർത്തനങ്ങളും, കൂടാതെ കൂടുതൽ, തയ്യാറാക്കാനും, നിർമ്മിക്കാനും, പരീക്ഷിക്കാനും, വിലയിരുത്താനും, പ്രവചിക്കാനും പഠിക്കും, 'ഫുൾ സ്റ്റാക്ക്' ML എഞ്ചിനീയറായി നിങ്ങളുടെ യാത്രയിൽ മുന്നേറുമ്പോൾ.
---
## 🚀ചലഞ്ച്
ഒരു ML പ്രാക്ടീഷണറുടെ ഘട്ടങ്ങൾ പ്രതിഫലിപ്പിക്കുന്ന ഒരു ഫ്ലോ ചാർട്ട് വരയ്ക്കുക. നിങ്ങൾ ഇപ്പോൾ പ്രക്രിയയിൽ എവിടെയാണ്? നിങ്ങൾക്ക് എവിടെ ബുദ്ധിമുട്ട് ഉണ്ടാകുമെന്ന് പ്രവചിക്കുന്നു? നിങ്ങൾക്ക് എവിടെ എളുപ്പമാണ്?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ഡാറ്റാ സയന്റിസ്റ്റുകൾ അവരുടെ ദൈനംദിന ജോലി ചർച്ച ചെയ്യുന്ന അഭിമുഖങ്ങൾ ഓൺലൈനിൽ തിരയുക. ഇതാ [ഒരു ഉദാഹരണം](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
## അസൈൻമെന്റ്
[ഒരു ഡാറ്റാ സയന്റിസ്റ്റിനെ അഭിമുഖം ചെയ്യുക](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/ml/1-Introduction/4-techniques-of-ML/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "70d65aeddc06170bc1aed5b27805f930",
"translation_date": "2025-12-19T13:39:12+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/assignment.md",
"language_code": "ml"
}
-->
# ഒരു ഡാറ്റ സയന്റിസ്റ്റിനെ അഭിമുഖം
## നിർദ്ദേശങ്ങൾ
നിങ്ങളുടെ കമ്പനിയിലോ, ഒരു ഉപയോക്തൃ ഗ്രൂപ്പിലോ, അല്ലെങ്കിൽ നിങ്ങളുടെ സുഹൃത്തുക്കളിലോ സഹപാഠികളിലോ ഡാറ്റ സയന്റിസ്റ്റായി പ്രൊഫഷണലായി ജോലി ചെയ്യുന്ന ആരെയെങ്കിലും സംസാരിക്കുക. അവരുടെ ദൈനംദിന ജോലികൾക്കുറിച്ച് ഒരു ചെറിയ പ്രബന്ധം (500 വാക്കുകൾ) എഴുതുക. അവർ വിദഗ്ധരാണോ, അല്ലെങ്കിൽ 'ഫുൾ സ്റ്റാക്ക്' ആയി പ്രവർത്തിക്കുന്നവരാണോ?
## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണപരമായത് | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------ | --------------------- |
| | ശരിയായ നീളമുള്ള, ഉറവിടങ്ങൾ വ്യക്തമാക്കിയ പ്രബന്ധം .doc ഫയലായി സമർപ്പിച്ചിരിക്കുന്നു | പ്രബന്ധം ഉറവിടങ്ങൾ വ്യക്തമാക്കാത്തതോ ആവശ്യമായ നീളത്തിൽ കുറവായതോ ആണ് | പ്രബന്ധം സമർപ്പിച്ചിട്ടില്ല |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

38
translations/ml/1-Introduction/README.md
Unescape View File

@ -0,0 +1,38 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "cf8ecc83f28e5b98051d2179eca08e08",
"translation_date": "2025-12-19T12:56:37+00:00",
"source_file": "1-Introduction/README.md",
"language_code": "ml"
}
-->
# മെഷീൻ ലേണിങ്ങിലേക്ക് പരിചയം
പാഠ്യപദ്ധതിയുടെ ഈ ഭാഗത്തിൽ, മെഷീൻ ലേണിങ്ങ് എന്ന മേഖലയെ അടിസ്ഥാനമാക്കിയുള്ള ആശയങ്ങൾ, അതെന്താണെന്ന്, അതിന്റെ ചരിത്രം, ഗവേഷകർ അതുമായി പ്രവർത്തിക്കാൻ ഉപയോഗിക്കുന്ന സാങ്കേതിക വിദ്യകൾ എന്നിവയെക്കുറിച്ച് നിങ്ങൾക്ക് പരിചയപ്പെടുത്തും. ഈ പുതിയ ML ലോകത്തെ നമുക്ക് ഒരുമിച്ച് അന്വേഷിക്കാം!
![globe](../../../translated_images/globe.59f26379ceb40428672b4d9a568044618a2bf6292ecd53a5c481b90e3fa805eb.ml.jpg)
> ഫോട്ടോ <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">ബിൽ ഓക്സ്ഫോർഡ്</a> എന്നവരിൽ നിന്നാണ് <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">അൺസ്പ്ലാഷിൽ</a>
### പാഠങ്ങൾ
1. [മെഷീൻ ലേണിങ്ങിലേക്ക് പരിചയം](1-intro-to-ML/README.md)
1. [മെഷീൻ ലേണിങ്ങിന്റെയും AI യുടെയും ചരിത്രം](2-history-of-ML/README.md)
1. [ന്യായത്വവും മെഷീൻ ലേണിങ്ങും](3-fairness/README.md)
1. [മെഷീൻ ലേണിങ്ങിന്റെ സാങ്കേതിക വിദ്യകൾ](4-techniques-of-ML/README.md)
### ക്രെഡിറ്റുകൾ
"Introduction to Machine Learning" എന്നത് ♥️ ഉള്ളടക്കത്തോടെ [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan), [Ornella Altunyan](https://twitter.com/ornelladotcom) എന്നിവരടങ്ങിയ സംഘത്താൽ എഴുതപ്പെട്ടതാണ്.
"The History of Machine Learning" ♥️ ഉള്ളടക്കത്തോടെ [Jen Looper](https://twitter.com/jenlooper)യും [Amy Boyd](https://twitter.com/AmyKateNicho)യും ചേർന്ന് എഴുതിയതാണ്.
"Fairness and Machine Learning" ♥️ ഉള്ളടക്കത്തോടെ [Tomomi Imura](https://twitter.com/girliemac) എഴുതിയതാണ്.
"Techniques of Machine Learning" ♥️ ഉള്ളടക്കത്തോടെ [Jen Looper](https://twitter.com/jenlooper)യും [Chris Noring](https://twitter.com/softchris)യും ചേർന്ന് എഴുതിയതാണ്.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

241
translations/ml/2-Regression/1-Tools/README.md
Unescape View File

@ -0,0 +1,241 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
"translation_date": "2025-12-19T13:55:07+00:00",
"source_file": "2-Regression/1-Tools/README.md",
"language_code": "ml"
}
-->
# Python ഉം Scikit-learn ഉം ഉപയോഗിച്ച് regression മോഡലുകൾ ആരംഭിക്കുക
![Summary of regressions in a sketchnote](../../../../translated_images/ml-regression.4e4f70e3b3ed446e3ace348dec973e133fa5d3680fbc8412b61879507369b98d.ml.png)
> Sketchnote by [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
> ### [ഈ പാഠം R-ൽ ലഭ്യമാണ്!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
## പരിചയം
ഈ നാല് പാഠങ്ങളിൽ, നിങ്ങൾ regression മോഡലുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് കണ്ടെത്തും. ഇവ എന്തിനാണെന്ന് നമുക്ക് ഉടൻ ചർച്ച ചെയ്യാം. എന്നാൽ എന്തെങ്കിലും ചെയ്യുന്നതിന് മുമ്പ്, പ്രക്രിയ ആരംഭിക്കാൻ ആവശ്യമായ ശരിയായ ഉപകരണങ്ങൾ നിങ്ങൾക്കുണ്ടെന്ന് ഉറപ്പാക്കുക!
ഈ പാഠത്തിൽ, നിങ്ങൾ പഠിക്കാനിരിക്കുന്നതെന്തെന്നാൽ:
- ലൊക്കൽ മെഷീൻ ലേണിംഗ് ടാസ്കുകൾക്കായി നിങ്ങളുടെ കമ്പ്യൂട്ടർ ക്രമീകരിക്കുക.
- Jupyter നോട്ട്‌ബുക്കുകളുമായി പ്രവർത്തിക്കുക.
- Scikit-learn ഉപയോഗിക്കുക, ഇൻസ്റ്റാളേഷൻ ഉൾപ്പെടെ.
- ലീനിയർ regression ഒരു ഹാൻഡ്‌സ്-ഓൺ വ്യായാമത്തോടെ പരിശോധിക്കുക.
## ഇൻസ്റ്റാളേഷനുകളും ക്രമീകരണങ്ങളും
[![ML for beginners - Setup your tools ready to build Machine Learning models](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML for beginners -Setup your tools ready to build Machine Learning models")
> 🎥 ML ക്രമീകരണത്തിനായി നിങ്ങളുടെ കമ്പ്യൂട്ടർ ക്രമീകരിക്കുന്നതിനുള്ള ഒരു ചെറിയ വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
1. **Python ഇൻസ്റ്റാൾ ചെയ്യുക**. നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ [Python](https://www.python.org/downloads/) ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ഡാറ്റാ സയൻസ്, മെഷീൻ ലേണിംഗ് ടാസ്കുകൾക്കായി Python ഉപയോഗിക്കും. പല കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങളിലുമുണ്ട് Python ഇൻസ്റ്റാളേഷൻ. ചില ഉപയോക്താക്കൾക്ക് ക്രമീകരണം എളുപ്പമാക്കാൻ ഉപയോഗപ്രദമായ [Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) ലഭ്യമാണ്.
Python-ന്റെ ചില ഉപയോഗങ്ങൾ ഒരു സോഫ്റ്റ്‌വെയറിന്റെ ഒരു വേർഷൻ ആവശ്യപ്പെടുമ്പോൾ, മറ്റുള്ളവയ്ക്ക് വ്യത്യസ്ത വേർഷൻ ആവശ്യമായേക്കാം. അതിനാൽ, [virtual environment](https://docs.python.org/3/library/venv.html) ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ഉപകാരപ്രദമാണ്.
2. **Visual Studio Code ഇൻസ്റ്റാൾ ചെയ്യുക**. നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ Visual Studio Code ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. അടിസ്ഥാന ഇൻസ്റ്റാളേഷനായി [Visual Studio Code ഇൻസ്റ്റാൾ ചെയ്യാനുള്ള നിർദ്ദേശങ്ങൾ](https://code.visualstudio.com/) പിന്തുടരുക. ഈ കോഴ്സിൽ Python Visual Studio Code-ൽ ഉപയോഗിക്കും, അതിനാൽ Python ഡെവലപ്പ്മെന്റിനായി [Visual Studio Code ക്രമീകരിക്കുന്നതെങ്ങനെ](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) എന്നത് അറിയാൻ നിങ്ങൾ ആഗ്രഹിക്കാം.
> Python-നൊപ്പം പരിചയപ്പെടാൻ ഈ [Learn modules](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott) ശേഖരം വഴി പ്രവർത്തിക്കുക
>
> [![Setup Python with Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Setup Python with Visual Studio Code")
>
> 🎥 VS Code-ൽ Python ഉപയോഗിക്കുന്നതിനുള്ള വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
3. **Scikit-learn ഇൻസ്റ്റാൾ ചെയ്യുക**, [ഈ നിർദ്ദേശങ്ങൾ](https://scikit-learn.org/stable/install.html) പിന്തുടർന്ന്. Python 3 ഉപയോഗിക്കുന്നതെന്ന് ഉറപ്പാക്കേണ്ടതിനാൽ, virtual environment ഉപയോഗിക്കുന്നത് ശുപാർശ ചെയ്യുന്നു. M1 Mac-ൽ ഈ ലൈബ്രറി ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ പ്രത്യേക നിർദ്ദേശങ്ങൾ ഉണ്ട്, മുകളിൽ നൽകിയ ലിങ്കിൽ കാണാം.
1. **Jupyter Notebook ഇൻസ്റ്റാൾ ചെയ്യുക**. [Jupyter പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്](https://pypi.org/project/jupyter/).
## നിങ്ങളുടെ ML എഴുത്ത് പരിസ്ഥിതി
Python കോഡ് വികസിപ്പിക്കുകയും മെഷീൻ ലേണിംഗ് മോഡലുകൾ സൃഷ്ടിക്കുകയും ചെയ്യാൻ നിങ്ങൾ **നോട്ട്‌ബുക്കുകൾ** ഉപയോഗിക്കും. ഈ തരത്തിലുള്ള ഫയൽ ഡാറ്റാ സയന്റിസ്റ്റുകൾക്കുള്ള സാധാരണ ഉപകരണമാണ്, അവയുടെ സഫിക്സ് അല്ലെങ്കിൽ എക്സ്റ്റൻഷൻ `.ipynb` ആണ്.
നോട്ട്‌ബുക്കുകൾ ഒരു ഇന്ററാക്ടീവ് പരിസ്ഥിതിയാണ്, ഡെവലപ്പർക്ക് കോഡ് ചെയ്യാനും കുറിപ്പുകൾ ചേർക്കാനും, കോഡിന്റെ ചുറ്റുപാടിൽ ഡോക്യുമെന്റേഷൻ എഴുതാനും അനുവദിക്കുന്നു, ഇത് പരീക്ഷണാത്മക അല്ലെങ്കിൽ ഗവേഷണ-കേന്ദ്രിത പദ്ധതികൾക്ക് വളരെ സഹായകരമാണ്.
[![ML for beginners - Set up Jupyter Notebooks to start building regression models](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML for beginners - Set up Jupyter Notebooks to start building regression models")
> 🎥 ഈ വ്യായാമം ചെയ്യുന്നതിനുള്ള ചെറിയ വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
### വ്യായാമം - ഒരു നോട്ട്‌ബുക്കുമായി പ്രവർത്തിക്കുക
ഈ ഫോൾഡറിൽ, നിങ്ങൾക്ക് _notebook.ipynb_ ഫയൽ കാണാം.
1. Visual Studio Code-ൽ _notebook.ipynb_ തുറക്കുക.
Python 3+ ഉപയോഗിച്ച് Jupyter സെർവർ ആരംഭിക്കും. നോട്ട്‌ബുക്കിന്റെ ഭാഗങ്ങൾ `run` ചെയ്യാവുന്നതാണ്, കോഡ് ഭാഗങ്ങൾ. പ്ലേ ബട്ടൺ പോലുള്ള ഐക്കൺ തിരഞ്ഞെടുക്കുന്നതിലൂടെ കോഡ് ബ്ലോക്ക് റൺ ചെയ്യാം.
1. `md` ഐക്കൺ തിരഞ്ഞെടുക്കുക, കുറച്ച് markdown ചേർക്കുക, താഴെ കാണുന്ന വാചകം **# Welcome to your notebook** ചേർക്കുക.
തുടർന്ന്, Python കോഡ് ചേർക്കുക.
1. കോഡ് ബ്ലോക്കിൽ **print('hello notebook')** ടൈപ്പ് ചെയ്യുക.
1. കോഡ് റൺ ചെയ്യാൻ അമ്പ് ഐക്കൺ തിരഞ്ഞെടുക്കുക.
നിങ്ങൾക്ക് പ്രിന്റ് ചെയ്ത പ്രസ്താവന കാണാം:
```output
hello notebook
```
![VS Code with a notebook open](../../../../translated_images/notebook.4a3ee31f396b88325607afda33cadcc6368de98040ff33942424260aa84d75f2.ml.jpg)
നിങ്ങളുടെ കോഡിനൊപ്പം കുറിപ്പുകൾ ചേർത്ത് നോട്ട്‌ബുക്ക് സ്വയം ഡോക്യുമെന്റ് ചെയ്യാം.
✅ വെബ് ഡെവലപ്പറുടെ പ്രവർത്തന പരിസ്ഥിതിയും ഡാറ്റാ സയന്റിസ്റ്റിന്റെ പ്രവർത്തന പരിസ്ഥിതിയും എത്ര വ്യത്യസ്തമാണെന്ന് ഒരു നിമിഷം ചിന്തിക്കുക.
## Scikit-learn ഉപയോഗിച്ച് പ്രവർത്തനം ആരംഭിക്കുക
ഇപ്പോൾ Python നിങ്ങളുടെ ലൊക്കൽ പരിസ്ഥിതിയിൽ ക്രമീകരിച്ചിരിക്കുന്നു, Jupyter നോട്ട്‌ബുക്കുകളുമായി നിങ്ങൾ പരിചിതരാണ്, Scikit-learn-നോടും സമാനമായി പരിചിതരാകാം (`sci` എന്ന് ഉച്ചരിക്കാം, `science` പോലെ). Scikit-learn ML ടാസ്കുകൾ ചെയ്യാൻ സഹായിക്കുന്ന [വ്യാപകമായ API](https://scikit-learn.org/stable/modules/classes.html#api-ref) നൽകുന്നു.
അവരുടെ [വെബ്സൈറ്റ്](https://scikit-learn.org/stable/getting_started.html) പ്രകാരം, "Scikit-learn ഒരു ഓപ്പൺ സോഴ്‌സ് മെഷീൻ ലേണിംഗ് ലൈബ്രറിയാണ്, ഇത് supervised, unsupervised ലേണിംഗ് പിന്തുണയ്ക്കുന്നു. മോഡൽ ഫിറ്റിംഗ്, ഡാറ്റ പ്രീപ്രോസസ്സിംഗ്, മോഡൽ സെലക്ഷൻ, മൂല്യനിർണ്ണയം, മറ്റ് പല ഉപകരണങ്ങളും ഇത് നൽകുന്നു."
ഈ കോഴ്സിൽ, നിങ്ങൾ Scikit-learn ഉൾപ്പെടെയുള്ള ഉപകരണങ്ങൾ ഉപയോഗിച്ച് 'പരമ്പരാഗത മെഷീൻ ലേണിംഗ്' ടാസ്കുകൾ നിർവഹിക്കുന്ന മോഡലുകൾ നിർമ്മിക്കും. നാം ന്യുറൽ നെറ്റ്വർക്കുകളും ഡീപ്പ് ലേണിംഗും ഒഴിവാക്കിയിട്ടുണ്ട്, കാരണം അവ 'AI for Beginners' പാഠ്യപദ്ധതിയിൽ കൂടുതൽ വിശദമായി ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.
Scikit-learn മോഡലുകൾ നിർമ്മിക്കുകയും അവ വിലയിരുത്തുകയും ചെയ്യാൻ എളുപ്പമാണ്. ഇത് പ്രധാനമായും സംഖ്യാത്മക ഡാറ്റ ഉപയോഗിക്കുന്നതിനാണ്, പഠന ഉപകരണങ്ങളായി ഉപയോഗിക്കാൻ നിരവധി റെഡി-മെയ്ഡ് ഡാറ്റാസെറ്റുകൾ ഉൾക്കൊള്ളുന്നു. വിദ്യാർത്ഥികൾക്ക് പരീക്ഷിക്കാൻ മുൻകൂട്ടി നിർമ്മിച്ച മോഡലുകളും ഇതിൽ ഉൾപ്പെടുന്നു. ആദ്യം, പാക്കേജ് ചെയ്ത ഡാറ്റ ലോഡ് ചെയ്യുകയും Scikit-learn-ന്റെ ബിൽറ്റ്-ഇൻ എസ്റ്റിമേറ്റർ ഉപയോഗിച്ച് അടിസ്ഥാന ML മോഡൽ നിർമ്മിക്കലും പരിശോധിക്കാം.
## വ്യായാമം - നിങ്ങളുടെ ആദ്യ Scikit-learn നോട്ട്‌ബുക്ക്
> ഈ ട്യൂട്ടോറിയൽ Scikit-learn വെബ്സൈറ്റിലെ [linear regression ഉദാഹരണത്തിൽ](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) നിന്നാണ് പ്രചോദനം ലഭിച്ചത്.
[![ML for beginners - Your First Linear Regression Project in Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML for beginners - Your First Linear Regression Project in Python")
> 🎥 ഈ വ്യായാമം ചെയ്യുന്നതിനുള്ള ചെറിയ വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
ഈ പാഠവുമായി ബന്ധപ്പെട്ട _notebook.ipynb_ ഫയലിൽ, എല്ലാ സെല്ലുകളും 'trash can' ഐക്കൺ അമർത്തി ക്ലിയർ ചെയ്യുക.
ഈ വിഭാഗത്തിൽ, Scikit-learn-ൽ പഠനത്തിനായി ഉൾപ്പെടുത്തിയ ചെറിയ ഡയബറ്റീസ് ഡാറ്റാസെറ്റ് ഉപയോഗിച്ച് പ്രവർത്തിക്കും. ഡയബറ്റിക് രോഗികൾക്കായി ഒരു ചികിത്സ പരീക്ഷിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നതായി കരുതുക. മെഷീൻ ലേണിംഗ് മോഡലുകൾ, വ്യത്യസ്ത വേരിയബിളുകളുടെ സംയോജനങ്ങളുടെ അടിസ്ഥാനത്തിൽ, ഏത് രോഗികൾ ചികിത്സയ്ക്ക് മികച്ച പ്രതികരണം നൽകുമെന്ന് നിർണ്ണയിക്കാൻ സഹായിക്കാം. വളരെ അടിസ്ഥാന regression മോഡൽ പോലും, ദൃശ്യവൽക്കരിച്ചാൽ, സിദ്ധാന്തപരമായ ക്ലിനിക്കൽ ട്രയലുകൾ ക്രമീകരിക്കാൻ സഹായിക്കുന്ന വേരിയബിളുകളെക്കുറിച്ച് വിവരങ്ങൾ കാണിക്കാം.
✅ regression രീതികളുടെ പല തരങ്ങളും ഉണ്ട്, നിങ്ങൾ തിരഞ്ഞെടുക്കുന്നത് നിങ്ങൾ അന്വേഷിക്കുന്ന ഉത്തരത്തിന്റെ അടിസ്ഥാനത്തിലാണ്. ഒരു വ്യക്തിയുടെ പ്രായം നൽകിയാൽ അവന്റെ സാധ്യതയുള്ള ഉയരം പ്രവചിക്കാൻ linear regression ഉപയോഗിക്കും, കാരണം നിങ്ങൾ **സംഖ്യാത്മക മൂല്യം** തേടുകയാണ്. ഒരു ഭക്ഷണരീതിയെ വെഗൻ ആണോ അല്ലയോ എന്ന് കണ്ടെത്താൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ **വർഗ്ഗം നിശ്ചയിക്കൽ** അന്വേഷിക്കുന്നതാണ്, അതിനാൽ logistic regression ഉപയോഗിക്കും. logistic regression പിന്നീട് പഠിക്കും. ഡാറ്റയിൽ നിന്ന് ചോദിക്കാവുന്ന ചില ചോദ്യങ്ങളെ കുറിച്ച് ചിന്തിക്കുക, ഏത് രീതികൾ കൂടുതൽ അനുയോജ്യമാണ് എന്ന്.
ഈ ടാസ്ക് ആരംഭിക്കാം.
### ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക
ഈ ടാസ്കിനായി ചില ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യാം:
- **matplotlib**. ഇത് ഒരു ഉപകാരപ്രദമായ [ഗ്രാഫിംഗ് ടൂൾ](https://matplotlib.org/) ആണ്, ലൈന്പ്ലോട്ട് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കും.
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) Python-ൽ സംഖ്യാത്മക ഡാറ്റ കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്ന ലൈബ്രറിയാണ്.
- **sklearn**. ഇത് [Scikit-learn](https://scikit-learn.org/stable/user_guide.html) ലൈബ്രറിയാണ്.
നിങ്ങളുടെ ടാസ്കുകൾക്ക് സഹായം നൽകാൻ ചില ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക.
1. താഴെ കാണുന്ന കോഡ് ടൈപ്പ് ചെയ്ത് ഇറക്കുമതി ചേർക്കുക:
```python
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, model_selection
```
മുകളിൽ നിങ്ങൾ `matplotlib`, `numpy` ഇറക്കുമതി ചെയ്യുന്നു, കൂടാതെ `sklearn`-ൽ നിന്ന് `datasets`, `linear_model`, `model_selection` ഇറക്കുമതി ചെയ്യുന്നു. `model_selection` ഡാറ്റ പരിശീലനവും ടെസ്റ്റ് സെറ്റുകളിലായി വിഭജിക്കാൻ ഉപയോഗിക്കുന്നു.
### ഡയബറ്റീസ് ഡാറ്റാസെറ്റ്
ഇൻബിൽറ്റ് [ഡയബറ്റീസ് ഡാറ്റാസെറ്റ്](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) 442 സാമ്പിളുകൾ ഉൾക്കൊള്ളുന്നു, 10 ഫീച്ചർ വേരിയബിളുകളോടെ, ചിലത്:
- പ്രായം: വയസ്സിൽ
- bmi: ബോഡി മാസ്സ് ഇൻഡക്സ്
- bp: ശരാശരി രക്തസമ്മർദ്ദം
- s1 tc: ടി-സെല്ലുകൾ (വെളുത്ത രക്തകോശങ്ങളുടെ ഒരു തരം)
✅ ഈ ഡാറ്റാസെറ്റിൽ 'sex' എന്ന binary ക്ലാസിഫിക്കേഷൻ ഫീച്ചർ വേരിയബിൾ ഉൾക്കൊള്ളുന്നു, ഡയബറ്റീസ് ഗവേഷണത്തിന് പ്രധാനമാണ്. പല മെഡിക്കൽ ഡാറ്റാസെറ്റുകളും ഇത്തരത്തിലുള്ള binary ക്ലാസിഫിക്കേഷൻ ഉൾക്കൊള്ളുന്നു. ഇത്തരത്തിലുള്ള വർഗ്ഗീകരണങ്ങൾ ജനസംഖ്യയുടെ ചില ഭാഗങ്ങളെ ചികിത്സകളിൽ നിന്ന് ഒഴിവാക്കാമെന്ന് ചിന്തിക്കുക.
ഇപ്പോൾ, X, y ഡാറ്റ ലോഡ് ചെയ്യുക.
> 🎓 ഓർമ്മിക്കുക, ഇത് supervised learning ആണ്, അതിനാൽ 'y' എന്ന ലക്ഷ്യ വേരിയബിൾ ആവശ്യമാണ്.
പുതിയ കോഡ് സെല്ലിൽ, `load_diabetes()` വിളിച്ച് ഡയബറ്റീസ് ഡാറ്റാസെറ്റ് ലോഡ് ചെയ്യുക. `return_X_y=True` നൽകുന്നത് `X` ഡാറ്റാ മാട്രിക്സ് ആകും, `y` regression ലക്ഷ്യം ആകും എന്ന് സൂചിപ്പിക്കുന്നു.
1. ഡാറ്റാ മാട്രിക്സിന്റെ ആകൃതി (shape)യും ആദ്യ ഘടകവും പ്രിന്റ് ചെയ്യാൻ ചില print കമാൻഡുകൾ ചേർക്കുക:
```python
X, y = datasets.load_diabetes(return_X_y=True)
print(X.shape)
print(X[0])
```
നിങ്ങൾക്ക് ലഭിക്കുന്നത് ഒരു ട്യൂപ്പിൾ ആണ്. ട്യൂപ്പിളിന്റെ ആദ്യ രണ്ട് മൂല്യങ്ങൾ `X`ക്കും `y`ക്കും നിയോഗിക്കുന്നു. [ട്യൂപ്പിളുകൾക്കുറിച്ച് കൂടുതൽ](https://wikipedia.org/wiki/Tuple) പഠിക്കുക.
ഈ ഡാറ്റ 442 ഇനങ്ങൾ 10 ഘടകങ്ങളുള്ള അറേകളായി രൂപപ്പെടുത്തിയിട്ടുണ്ട്:
```text
(442, 10)
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
✅ ഡാറ്റയും regression ലക്ഷ്യവും തമ്മിലുള്ള ബന്ധത്തെ കുറിച്ച് ചിന്തിക്കുക. ലീനിയർ regression ഫീച്ചർ X-നും ലക്ഷ്യ വേരിയബിൾ y-നും ഇടയിലുള്ള ബന്ധം പ്രവചിക്കുന്നു. ഡയബറ്റീസ് ഡാറ്റാസെറ്റിന്റെ [ലക്ഷ്യം](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) ഡോക്യുമെന്റേഷനിൽ കണ്ടെത്താമോ? ഈ ഡാറ്റാസെറ്റ് എന്ത് പ്രദർശിപ്പിക്കുന്നു, ആ ലക്ഷ്യം പരിഗണിച്ച്?
2. ഡാറ്റാസെറ്റിന്റെ 3-ആം കോളം തിരഞ്ഞെടുക്കുക, പ്ലോട്ട് ചെയ്യാൻ. എല്ലാ വരികളും തിരഞ്ഞെടുക്കാൻ `:` ഓപ്പറേറ്റർ ഉപയോഗിച്ച്, പിന്നീട് 3-ആം കോളം (ഇൻഡക്സ് 2) തിരഞ്ഞെടുക്കുക. പ്ലോട്ടിംഗിന് ആവശ്യമായ 2D അറേ ആയി രൂപപ്പെടുത്താൻ `reshape(n_rows, n_columns)` ഉപയോഗിക്കാം. ഒരു പാരാമീറ്റർ -1 ആണെങ്കിൽ, ആ ഡൈമെൻഷൻ സ്വയം കണക്കാക്കും.
```python
X = X[:, 2]
X = X.reshape((-1,1))
```
✅ ഏപ്പോൾ വേണമെങ്കിലും ഡാറ്റയുടെ ആകൃതി പരിശോധിക്കാൻ പ്രിന്റ് ചെയ്യുക.
3. ഇപ്പോൾ ഡാറ്റ പ്ലോട്ട് ചെയ്യാൻ തയ്യാറാണ്, ഈ ഡാറ്റാസെറ്റിലെ സംഖ്യകളിൽ ലജിക്കൽ സ്പ്ലിറ്റ് കണ്ടെത്താൻ മെഷീൻ സഹായിക്കുമോ എന്ന് നോക്കാം. അതിനായി, ഡാറ്റ (X)യും ലക്ഷ്യം (y) ടെസ്റ്റ്, പരിശീലന സെറ്റുകളായി വിഭജിക്കണം. Scikit-learn ഇതിന് എളുപ്പമുള്ള മാർഗം നൽകുന്നു; നിങ്ങൾക്ക് ടെസ്റ്റ് ഡാറ്റ ഒരു നിശ്ചിത പോയിന്റിൽ വിഭജിക്കാം.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. ഇപ്പോൾ മോഡൽ പരിശീലിപ്പിക്കാൻ തയ്യാറാണ്! ലീനിയർ regression മോഡൽ ലോഡ് ചെയ്ത് `model.fit()` ഉപയോഗിച്ച് X, y പരിശീലന സെറ്റുകൾ ഉപയോഗിച്ച് പരിശീലിപ്പിക്കുക:
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
✅ `model.fit()` TensorFlow പോലുള്ള പല ML ലൈബ്രറികളിലും കാണുന്ന ഒരു ഫംഗ്ഷനാണ്
5. തുടർന്ന്, ടെസ്റ്റ് ഡാറ്റ ഉപയോഗിച്ച് പ്രവചനം സൃഷ്ടിക്കാൻ `predict()` ഫംഗ്ഷൻ ഉപയോഗിക്കുക. ഇത് ഡാറ്റ ഗ്രൂപ്പുകൾക്കിടയിലെ വര വരയ്ക്കാൻ ഉപയോഗിക്കും
```python
y_pred = model.predict(X_test)
```
6. ഇപ്പോൾ matplotlib ഉപയോഗിച്ച് ഡാറ്റ പ്ലോട്ട് ചെയ്യാം. matplotlib ഈ ടാസ്കിന് വളരെ ഉപകാരപ്രദമാണ്. X, y ടെസ്റ്റ് ഡാറ്റയുടെ സ്കാറ്റർപ്ലോട്ട് സൃഷ്ടിച്ച്, മോഡലിന്റെ ഡാറ്റ ഗ്രൂപ്പിംഗുകൾക്കിടയിൽ ഏറ്റവും അനുയോജ്യമായ സ്ഥലത്ത് prediction ഉപയോഗിച്ച് ഒരു വര വരയ്ക്കുക.
```python
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xlabel('Scaled BMIs')
plt.ylabel('Disease Progression')
plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
plt.show()
```
![a scatterplot showing datapoints around diabetes](../../../../translated_images/scatterplot.ad8b356bcbb33be68d54050e09b9b7bfc03e94fde7371f2609ae43f4c563b2d7.ml.png)
✅ ഇവിടെ എന്ത് നടക്കുകയാണ് എന്ന് കുറച്ച് ചിന്തിക്കുക. ഒരു നേരിയ രേഖ നിരവധി ചെറിയ ഡാറ്റാ പോയിന്റുകളിലൂടെ കടന്നുപോകുന്നു, പക്ഷേ അത് ശരിക്കും എന്ത് ചെയ്യുകയാണ്? ഈ രേഖ ഉപയോഗിച്ച് ഒരു പുതിയ, കാണാത്ത ഡാറ്റാ പോയിന്റ് പ്ലോട്ടിന്റെ y അക്ഷത്തോട് എങ്ങനെ പൊരുത്തപ്പെടണം എന്ന് പ്രവചിക്കാൻ കഴിയുമെന്ന് നിങ്ങൾക്ക് കാണാമോ? ഈ മോഡലിന്റെ പ്രായോഗിക ഉപയോഗം വാക്കുകളിൽ വെക്കാൻ ശ്രമിക്കുക.
അഭിനന്ദനങ്ങൾ, നിങ്ങൾ നിങ്ങളുടെ ആദ്യ ലീനിയർ റെഗ്രഷൻ മോഡൽ നിർമ്മിച്ചു, അതുമായി ഒരു പ്രവചനം സൃഷ്ടിച്ചു, അത് ഒരു പ്ലോട്ടിൽ പ്രദർശിപ്പിച്ചു!
---
## 🚀ചലഞ്ച്
ഈ ഡാറ്റാസെറ്റിൽ നിന്നുള്ള മറ്റൊരു വ്യത്യസ്ത വേരിയബിൾ പ്ലോട്ട് ചെയ്യുക. സൂചന: ഈ വരി എഡിറ്റ് ചെയ്യുക: `X = X[:,2]`. ഈ ഡാറ്റാസെറ്റിന്റെ ലക്ഷ്യം പരിഗണിച്ച്, ഡയബറ്റീസിന്റെ രോഗമായി പുരോഗതിയെക്കുറിച്ച് നിങ്ങൾ എന്ത് കണ്ടെത്താൻ കഴിയും?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ഈ ട്യൂട്ടോറിയലിൽ, നിങ്ങൾ സിംപിൾ ലീനിയർ റെഗ്രഷനുമായി പ്രവർത്തിച്ചു, യൂണിവേറിയറ്റ് അല്ലെങ്കിൽ മൾട്ടിപ്പിൾ ലീനിയർ റെഗ്രഷൻ അല്ല. ഈ രീതികളുടെ വ്യത്യാസങ്ങളെ കുറിച്ച് കുറച്ച് വായിക്കുക, അല്ലെങ്കിൽ [ഈ വീഡിയോ](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef) കാണുക.
റെഗ്രഷൻ എന്ന ആശയത്തെക്കുറിച്ച് കൂടുതൽ വായിച്ച് ഈ സാങ്കേതിക വിദ്യ ഉപയോഗിച്ച് എങ്ങനെ ചോദ്യങ്ങൾക്ക് ഉത്തരം കണ്ടെത്താമെന്ന് ചിന്തിക്കുക. നിങ്ങളുടെ മനസ്സിലാക്കൽ കൂടുതൽ ആഴത്തിൽ ആക്കാൻ ഈ [ട്യൂട്ടോറിയൽ](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) സ്വീകരിക്കുക.
## അസൈൻമെന്റ്
[മറ്റൊരു ഡാറ്റാസെറ്റ്](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ വ്യാഖ്യാനക്കേടുകൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

29
translations/ml/2-Regression/1-Tools/assignment.md
Unescape View File

@ -0,0 +1,29 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "74a5cf83e4ebc302afbcbc4f418afd0a",
"translation_date": "2025-12-19T13:57:25+00:00",
"source_file": "2-Regression/1-Tools/assignment.md",
"language_code": "ml"
}
-->
# Scikit-learn ഉപയോഗിച്ച് റിഗ്രഷൻ
## നിർദ്ദേശങ്ങൾ
Scikit-learn-ൽ ഉള്ള [Linnerud dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) നോക്കുക. ഈ ഡാറ്റാസെറ്റിൽ നിരവധി [ലക്ഷ്യങ്ങൾ](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset) ഉണ്ട്: 'ഇത് ഒരു ഫിറ്റ്നസ് ക്ലബിൽ നിന്നുള്ള ഇരുപത് മധ്യവയസ്ക പുരുഷന്മാരിൽ നിന്നുള്ള മൂന്ന് വ്യായാമ (ഡാറ്റ) മൂല്യങ്ങളും മൂന്ന് ശാരീരിക (ലക്ഷ്യ) മൂല്യങ്ങളും ഉൾക്കൊള്ളുന്നു'.
താങ്കളുടെ സ്വന്തം വാക്കുകളിൽ, വയസ്‌റ്റ്ലൈൻ (waistline) എത്ര സിറ്റപ്പുകൾ (situps) പൂർത്തിയാക്കിയതുമായി ബന്ധിപ്പിക്കുന്ന ഒരു Regression മോഡൽ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് വിവരിക്കുക. ഈ ഡാറ്റാസെറ്റിലെ മറ്റ് ഡാറ്റാപോയിന്റുകൾക്കും അതേ രീതിയിൽ ചെയ്യുക.
## റൂബ്രിക്
| മാനദണ്ഡം | ഉത്തമം | മതിയായ | മെച്ചപ്പെടുത്തേണ്ടത് |
| ------------------------------ | ----------------------------------- | ----------------------------- | -------------------------- |
| വിവരണാത്മക പാരഗ്രാഫ് സമർപ്പിക്കുക | നന്നായി എഴുതിയ പാരഗ്രാഫ് സമർപ്പിച്ചിരിക്കുന്നു | കുറച്ച് വാക്യങ്ങൾ സമർപ്പിച്ചിരിക്കുന്നു | വിവരണം നൽകിയിട്ടില്ല |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ പ്രാമാണികമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

0
translations/ml/2-Regression/1-Tools/notebook.ipynb
Unescape View File

17
translations/ml/2-Regression/1-Tools/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:09:17+00:00",
"source_file": "2-Regression/1-Tools/solution/Julia/README.md",
"language_code": "ml"
}
-->
ഇത് താൽക്കാലിക പ്ലേസ്ഹോൾഡറാണ്
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

454
translations/ml/2-Regression/1-Tools/solution/R/lesson_1-R.ipynb
Unescape View File

@ -0,0 +1,454 @@
{
"nbformat": 4,
"nbformat_minor": 2,
"metadata": {
"colab": {
"name": "lesson_1-R.ipynb",
"provenance": [],
"collapsed_sections": [],
"toc_visible": true
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "c18d3bd0bd8ae3878597e89dcd1fa5c1",
"translation_date": "2025-12-19T16:30:34+00:00",
"source_file": "2-Regression/1-Tools/solution/R/lesson_1-R.ipynb",
"language_code": "ml"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# ഒരു റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: R ഉം Tidymodels ഉം ഉപയോഗിച്ച് റെഗ്രഷൻ മോഡലുകൾ ആരംഭിക്കുക\n"
],
"metadata": {
"id": "YJUHCXqK57yz"
}
},
{
"cell_type": "markdown",
"source": [
"## റിഗ്രഷനിലേക്ക് പരിചയം - പാഠം 1\n",
"\n",
"#### പശ്ചാത്തലത്തിൽ വെക്കുക\n",
"\n",
"✅ റിഗ്രഷൻ രീതികളുടെ പല തരങ്ങളും ഉണ്ട്, നിങ്ങൾ തിരഞ്ഞെടുക്കുന്നത് നിങ്ങൾ അന്വേഷിക്കുന്ന ഉത്തരത്തിന്റെ അടിസ്ഥാനത്തിലാണ്. ഒരു വ്യക്തിയുടെ നിശ്ചിത പ്രായത്തിന് സാധ്യതയുള്ള ഉയരം പ്രവചിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ `linear regression` ഉപയോഗിക്കും, കാരണം നിങ്ങൾ ഒരു **സംഖ്യാത്മക മൂല്യം** അന്വേഷിക്കുന്നു. ഒരു ഭക്ഷണശൈലി വെഗൻ ആണോ അല്ലയോ എന്ന് കണ്ടെത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ ഒരു **വർഗ്ഗനിർണ്ണയം** അന്വേഷിക്കുന്നു, അതിനാൽ നിങ്ങൾ `logistic regression` ഉപയോഗിക്കും. ലൊജിസ്റ്റിക് റിഗ്രഷൻ കുറച്ച് പിന്നീട് പഠിക്കും. ഡാറ്റയിൽ നിന്ന് നിങ്ങൾ ചോദിക്കാവുന്ന ചില ചോദ്യങ്ങളെ കുറിച്ച് ചിന്തിക്കുക, ഈ രീതികളിൽ ഏതാണ് കൂടുതൽ അനുയോജ്യം എന്ന്.\n",
"\n",
"ഈ വിഭാഗത്തിൽ, നിങ്ങൾ [ഷുഗർ രോഗത്തെക്കുറിച്ചുള്ള ചെറിയ ഡാറ്റാസെറ്റ്](https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html) ഉപയോഗിച്ച് പ്രവർത്തിക്കും. ഡയബറ്റിക് രോഗികൾക്കുള്ള ഒരു ചികിത്സ പരീക്ഷിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നതായി تصور ചെയ്യുക. മെഷീൻ ലേണിംഗ് മോഡലുകൾ വ്യത്യസ്ത വേരിയബിളുകളുടെ സംയോജനങ്ങളുടെ അടിസ്ഥാനത്തിൽ ഏത് രോഗികൾ ചികിത്സയ്ക്ക് മികച്ച പ്രതികരണം നൽകുമെന്ന് നിർണ്ണയിക്കാൻ സഹായിക്കാം. വളരെ അടിസ്ഥാനപരമായ ഒരു റിഗ്രഷൻ മോഡലും, ദൃശ്യവൽക്കരിച്ചാൽ, നിങ്ങളുടെ സിദ്ധാന്തപരമായ ക്ലിനിക്കൽ പരീക്ഷണങ്ങൾ ക്രമീകരിക്കാൻ സഹായിക്കുന്ന വേരിയബിളുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ കാണിക്കാം.\n",
"\n",
"അങ്ങനെ, ഈ പ്രവർത്തനം ആരംഭിക്കാം!\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/encouRage.e75d5fe0367fb9136b78104baf4e2032a7622bc42a2bc34c0ad36c294eeb83f5.ml.jpg\"\n",
" width=\"630\"/>\n",
" <figcaption>@allison_horst രചിച്ച കലാസൃഷ്ടി</figcaption>\n",
"\n",
"<!--![Artwork by \\@allison_horst](../../../../../../translated_images/encouRage.e75d5fe0367fb9136b78104baf4e2032a7622bc42a2bc34c0ad36c294eeb83f5.ml.jpg)<br>Artwork by @allison_horst-->\n"
],
"metadata": {
"id": "LWNNzfqd6feZ"
}
},
{
"cell_type": "markdown",
"source": [
"## 1. നമ്മുടെ ടൂൾ സെറ്റ് ലോഡ് ചെയ്യുന്നു\n",
"\n",
"ഈ ടാസ്കിനായി, നമുക്ക് താഴെപ്പറയുന്ന പാക്കേജുകൾ ആവശ്യമുണ്ട്:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) ഒരു [R പാക്കേജുകളുടെ ശേഖരം](https://www.tidyverse.org/packages) ആണ്, ഡാറ്റാ സയൻസ് വേഗത്തിൽ, എളുപ്പത്തിൽ, കൂടുതൽ രസകരമായി നടത്താൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു!\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) ഫ്രെയിംവർക്ക് മോഡലിംഗ്, മെഷീൻ ലേണിങ്ങിനുള്ള [പാക്കേജുകളുടെ ശേഖരം](https://www.tidymodels.org/packages/) ആണ്.\n",
"\n",
"നിങ്ങൾക്ക് ഇവ ഇന്സ്റ്റാൾ ചെയ്യാം:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\"))`\n",
"\n",
"താഴെ കൊടുത്തിരിക്കുന്ന സ്ക്രിപ്റ്റ് ഈ മോഡ്യൂൾ പൂർത്തിയാക്കാൻ ആവശ്യമായ പാക്കേജുകൾ നിങ്ങൾക്കുണ്ടോ എന്ന് പരിശോധിച്ച്, കുറവുണ്ടെങ്കിൽ അവ ഇൻസ്റ്റാൾ ചെയ്യും.\n"
],
"metadata": {
"id": "FIo2YhO26wI9"
}
},
{
"cell_type": "code",
"execution_count": 2,
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
"pacman::p_load(tidyverse, tidymodels)"
],
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"Loading required package: pacman\n",
"\n"
]
}
],
"metadata": {
"id": "cIA9fz9v7Dss",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "2df7073b-86b2-4b32-cb86-0da605a0dc11"
}
},
{
"cell_type": "markdown",
"source": [
"ഇപ്പോൾ, ഈ അത്ഭുതകരമായ പാക്കേജുകൾ ലോഡ് ചെയ്ത് നമ്മുടെ നിലവിലെ R സെഷനിൽ ലഭ്യമാക്കാം.(ഇത് വെറും ഉദാഹരണത്തിന് ആണ്, `pacman::p_load()` ഇതിനായി ഇതിനകം തന്നെ ചെയ്തിട്ടുണ്ട്)\n"
],
"metadata": {
"id": "gpO_P_6f9WUG"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# load the core Tidyverse packages\r\n",
"library(tidyverse)\r\n",
"\r\n",
"# load the core Tidymodels packages\r\n",
"library(tidymodels)\r\n"
],
"outputs": [],
"metadata": {
"id": "NLMycgG-9ezO"
}
},
{
"cell_type": "markdown",
"source": [
"## 2. ഡയബറ്റീസ് ഡാറ്റാസെറ്റ്\n",
"\n",
"ഈ അഭ്യാസത്തിൽ, ഡയബറ്റീസ് ഡാറ്റാസെറ്റിൽ പ്രവചനങ്ങൾ നടത്തിക്കാണിച്ച് നമ്മുടെ റെഗ്രഷൻ കഴിവുകൾ പ്രദർശിപ്പിക്കും. [ഡയബറ്റീസ് ഡാറ്റാസെറ്റ്](https://www4.stat.ncsu.edu/~boos/var.select/diabetes.rwrite1.txt) `442 സാമ്പിളുകൾ` ഉൾക്കൊള്ളുന്നു, 10 പ്രവചന ഫീച്ചർ വേരിയബിളുകളോടുകൂടി, `വയസ്സ്`, `ലിംഗം`, `ശരീര ഭാരം സൂചിക`, `ശരാശരി രക്തസമ്മർദ്ദം`, കൂടാതെ `ആറ് രക്ത സീറം അളവുകൾ` എന്നിവയും ഫലം വേരിയബിൾ ആയ `y`: അടിസ്ഥാന സമയത്തിന് ശേഷം ഒരു വർഷം രോഗ പുരോഗതിയുടെ അളവാണ്.\n",
"\n",
"|പരീക്ഷണങ്ങളുടെ എണ്ണം|442|\n",
"|----------------------|:---|\n",
"|പ്രവചനങ്ങളുടെ എണ്ണം|ആദ്യ 10 കോളങ്ങൾ സംഖ്യാത്മക പ്രവചനങ്ങൾ ആണ്|\n",
"|ഫലം/ലക്ഷ്യം|11-ാം കോളം അടിസ്ഥാന സമയത്തിന് ശേഷം ഒരു വർഷം രോഗ പുരോഗതിയുടെ സംഖ്യാത്മക അളവാണ്|\n",
"|പ്രവചന വിവരങ്ങൾ|- വയസ്സ് വർഷങ്ങളിൽ\n",
"||- ലിംഗം\n",
"||- bmi ശരീര ഭാരം സൂചിക\n",
"||- bp ശരാശരി രക്തസമ്മർദ്ദം\n",
"||- s1 tc, മൊത്തം സീറം കൊളസ്ട്രോൾ\n",
"||- s2 ldl, കുറഞ്ഞ സാന്ദ്രത ലിപോപ്രോട്ടീനുകൾ\n",
"||- s3 hdl, ഉയർന്ന സാന്ദ്രത ലിപോപ്രോട്ടീനുകൾ\n",
"||- s4 tch, മൊത്തം കൊളസ്ട്രോൾ / HDL\n",
"||- s5 ltg, സീറം ട്രൈഗ്ലിസറൈഡുകളുടെ ലോഗ് ആയിരിക്കാം\n",
"||- s6 glu, രക്തത്തിലെ പഞ്ചസാര നില|\n",
"\n",
"\n",
"\n",
"\n",
"> 🎓 ഓർക്കുക, ഇത് സൂപ്പർവൈസ്ഡ് ലേണിംഗ് ആണ്, നമുക്ക് 'y' എന്ന പേരുള്ള ലക്ഷ്യം വേണം.\n",
"\n",
"R ഉപയോഗിച്ച് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിന് മുമ്പ്, ഡാറ്റ R-ന്റെ മെമ്മറിയിലേക്ക് ഇറക്കുകയോ, അല്ലെങ്കിൽ R ഡാറ്റയെ ദൂരസ്ഥമായി ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കാവുന്ന കണക്ഷൻ നിർമ്മിക്കുകയോ വേണം.\n",
"\n",
"> [readr](https://readr.tidyverse.org/) പാക്കേജ്, Tidyverse-ന്റെ ഭാഗമാണ്, R-ലേക്ക് വേഗത്തിലും സൗഹൃദപരവുമായ രീതിയിൽ ചതുരശ്ര ഡാറ്റ വായിക്കാൻ സഹായിക്കുന്നു.\n",
"\n",
"ഇപ്പോൾ, ഈ സ്രോതസ്സ് URL-ൽ നൽകിയ ഡയബറ്റീസ് ഡാറ്റാസെറ്റ് ലോഡ് ചെയ്യാം: <https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html>\n",
"\n",
"കൂടാതെ, `glimpse()` ഉപയോഗിച്ച് നമ്മുടെ ഡാറ്റയുടെ സാനിറ്റി ചെക്ക് നടത്തുകയും `slice()` ഉപയോഗിച്ച് ആദ്യ 5 വരികൾ പ്രദർശിപ്പിക്കുകയും ചെയ്യും.\n",
"\n",
"കൂടുതൽ മുന്നോട്ട് പോകുന്നതിന് മുമ്പ്, R കോഡിൽ നിങ്ങൾക്ക് പലപ്പോഴും കാണാൻ കഴിയുന്ന ഒരു കാര്യം പരിചയപ്പെടുത്താം 🥁🥁: പൈപ്പ് ഓപ്പറേറ്റർ `%>%`\n",
"\n",
"പൈപ്പ് ഓപ്പറേറ്റർ (`%>%`) ഒരു ഓബ്ജക്റ്റ് ഒരു ഫംഗ്ഷനിലേക്കോ കോൾ എക്സ്പ്രഷനിലേക്കോ മുന്നോട്ട് കടത്തിക്കൊണ്ട് ലജിക്കൽ ക്രമത്തിൽ പ്രവർത്തനങ്ങൾ നടത്തുന്നു. നിങ്ങളുടെ കോഡിൽ പൈപ്പ് ഓപ്പറേറ്റർ \"അതിനുശേഷം\" എന്ന് പറയുന്നതുപോലെയാണ്.\n"
],
"metadata": {
"id": "KM6iXLH996Cl"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Import the data set\r\n",
"diabetes <- read_table2(file = \"https://www4.stat.ncsu.edu/~boos/var.select/diabetes.rwrite1.txt\")\r\n",
"\r\n",
"\r\n",
"# Get a glimpse and dimensions of the data\r\n",
"glimpse(diabetes)\r\n",
"\r\n",
"\r\n",
"# Select the first 5 rows of the data\r\n",
"diabetes %>% \r\n",
" slice(1:5)"
],
"outputs": [],
"metadata": {
"id": "Z1geAMhM-bSP"
}
},
{
"cell_type": "markdown",
"source": [
"`glimpse()` നമ്മെ കാണിക്കുന്നു ഈ ഡാറ്റയിൽ 442 വരികളും 11 കോളങ്ങളുമുണ്ട്, എല്ലാ കോളങ്ങളും `double` ഡാറ്റാ ടൈപ്പിലുള്ളവയാണ്\n",
"\n",
"<br>\n",
"\n",
"\n",
"\n",
"> glimpse() ഉം slice() ഉം [`dplyr`](https://dplyr.tidyverse.org/) ലെ ഫംഗ്ഷനുകളാണ്. Tidyverse ന്റെ ഭാഗമായ Dplyr, ഡാറ്റ മാനിപ്പുലേഷന്റെ ഒരു വ്യാകരണം ആണ്, ഇത് സാധാരണ ഡാറ്റ മാനിപ്പുലേഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ സഹായിക്കുന്ന സ്ഥിരമായ ക്രിയാപദങ്ങളുടെ ഒരു സെറ്റ് നൽകുന്നു\n",
"\n",
"<br>\n",
"\n",
"ഇപ്പോൾ ഡാറ്റ ലഭിച്ചിരിക്കുന്നു, ഈ അഭ്യാസത്തിന് ലക്ഷ്യമിടാൻ ഒരു ഫീച്ചർ (`bmi`) നിശ്ചയിക്കാം. ഇതിന് ആവശ്യമായ കോളങ്ങൾ തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. എങ്ങനെ ഇത് ചെയ്യാം?\n",
"\n",
"[`dplyr::select()`](https://dplyr.tidyverse.org/reference/select.html) നമുക്ക് ഡാറ്റാ ഫ്രെയിമിലെ കോളങ്ങൾ *തിരഞ്ഞെടുക്കാനും* (ആവശ്യമായാൽ പുനർനാമകരണം ചെയ്യാനും) അനുവദിക്കുന്നു.\n"
],
"metadata": {
"id": "UwjVT1Hz-c3Z"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Select predictor feature `bmi` and outcome `y`\r\n",
"diabetes_select <- diabetes %>% \r\n",
" select(c(bmi, y))\r\n",
"\r\n",
"# Print the first 5 rows\r\n",
"diabetes_select %>% \r\n",
" slice(1:10)"
],
"outputs": [],
"metadata": {
"id": "RDY1oAKI-m80"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. പരിശീലനവും പരിശോധനാ ഡാറ്റയും\n",
"\n",
"പരിശീലിത പഠനത്തിൽ ഡാറ്റയെ രണ്ട് ഉപസമൂഹങ്ങളായി *പിരിച്ചുവിടുക* എന്നത് സാധാരണ പ്രക്രിയയാണ്; മോഡൽ പരിശീലിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന (സാധാരണയായി വലിയ) ഒരു സെറ്റ്, മോഡലിന്റെ പ്രകടനം കാണാൻ ഉപയോഗിക്കുന്ന ചെറിയ \"ഹോൾഡ്-ബാക്ക്\" സെറ്റ്.\n",
"\n",
"ഇപ്പോൾ ഡാറ്റ തയ്യാറായതിനാൽ, ഈ ഡാറ്റാസെറ്റിലെ സംഖ്യകളിൽ ലജിക്കൽ സ്പ്ലിറ്റ് നിർണ്ണയിക്കാൻ യന്ത്രം സഹായിക്കുമോ എന്ന് നോക്കാം. ഡാറ്റ പിരിക്കാൻ *എങ്ങനെ* എന്ന വിവരങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ, Tidymodels ഫ്രെയിംവർകിന്റെ ഭാഗമായ [rsample](https://tidymodels.github.io/rsample/) പാക്കേജ് ഉപയോഗിക്കാം, തുടർന്ന് സൃഷ്ടിച്ച പരിശീലനവും പരിശോധനാ സെറ്റുകളും എടുക്കാൻ രണ്ട് rsample ഫംഗ്ഷനുകൾ ഉപയോഗിക്കാം:\n"
],
"metadata": {
"id": "SDk668xK-tc3"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"set.seed(2056)\r\n",
"# Split 67% of the data for training and the rest for tesing\r\n",
"diabetes_split <- diabetes_select %>% \r\n",
" initial_split(prop = 0.67)\r\n",
"\r\n",
"# Extract the resulting train and test sets\r\n",
"diabetes_train <- training(diabetes_split)\r\n",
"diabetes_test <- testing(diabetes_split)\r\n",
"\r\n",
"# Print the first 3 rows of the training set\r\n",
"diabetes_train %>% \r\n",
" slice(1:10)"
],
"outputs": [],
"metadata": {
"id": "EqtHx129-1h-"
}
},
{
"cell_type": "markdown",
"source": [
"## 4. Tidymodels ഉപയോഗിച്ച് ഒരു ലീനിയർ റെഗ്രഷൻ മോഡൽ ട്രെയിൻ ചെയ്യുക\n",
"\n",
"ഇപ്പോൾ നാം നമ്മുടെ മോഡൽ ട്രെയിൻ ചെയ്യാൻ തയ്യാറാണ്!\n",
"\n",
"Tidymodels-ൽ, നിങ്ങൾ `parsnip()` ഉപയോഗിച്ച് മോഡലുകൾ നിർവചിക്കുമ്പോൾ മൂന്ന് ആശയങ്ങൾ വ്യക്തമാക്കുന്നു:\n",
"\n",
"- മോഡൽ **തരം** ലീനിയർ റെഗ്രഷൻ, ലോജിസ്റ്റിക് റെഗ്രഷൻ, ഡിസിഷൻ ട്രീ മോഡലുകൾ തുടങ്ങിയവയെ വ്യത്യസ്തമാക്കുന്നു.\n",
"\n",
"- മോഡൽ **മോഡ്** റെഗ്രഷനും ക്ലാസിഫിക്കേഷനും പോലുള്ള പൊതുവായ ഓപ്ഷനുകൾ ഉൾക്കൊള്ളുന്നു; ചില മോഡൽ തരം ഇവയിൽ ഏതെങ്കിലും ഒന്ന് പിന്തുണയ്ക്കും, ചിലത് ഒരു മോഡിൽ മാത്രമേ ഉണ്ടാകൂ.\n",
"\n",
"- മോഡൽ **എഞ്ചിൻ** മോഡൽ ഫിറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന കംപ്യൂട്ടേഷണൽ ഉപകരണം ആണ്. സാധാരണയായി ഇവ R പാക്കേജുകൾ ആണ്, ഉദാഹരണത്തിന് **`\"lm\"`** അല്ലെങ്കിൽ **`\"ranger\"`**\n",
"\n",
"ഈ മോഡലിംഗ് വിവരങ്ങൾ ഒരു മോഡൽ സ്പെസിഫിക്കേഷനിൽ പകർത്തപ്പെടുന്നു, അതിനാൽ നമുക്ക് ഒരു മോഡൽ നിർമ്മിക്കാം!\n"
],
"metadata": {
"id": "sBOS-XhB-6v7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Build a linear model specification\r\n",
"lm_spec <- \r\n",
" # Type\r\n",
" linear_reg() %>% \r\n",
" # Engine\r\n",
" set_engine(\"lm\") %>% \r\n",
" # Mode\r\n",
" set_mode(\"regression\")\r\n",
"\r\n",
"\r\n",
"# Print the model specification\r\n",
"lm_spec"
],
"outputs": [],
"metadata": {
"id": "20OwEw20--t3"
}
},
{
"cell_type": "markdown",
"source": [
"ഒരു മോഡൽ *നിർവചിച്ചശേഷം*, മോഡൽ `estimated` അല്ലെങ്കിൽ `trained` ചെയ്യാൻ സാധിക്കും, സാധാരണയായി ഒരു ഫോർമുലയും ചില ഡാറ്റയും ഉപയോഗിച്ച് [`fit()`](https://parsnip.tidymodels.org/reference/fit.html) ഫംഗ്ഷൻ ഉപയോഗിച്ച്.\n",
"\n",
"`y ~ .` എന്നത് `y` നാം പ്രവചിക്കപ്പെടുന്ന അളവായി/ലക്ഷ്യമായി ഫിറ്റ് ചെയ്യുമെന്ന് അർത്ഥം, എല്ലാ പ്രവചകങ്ങളാൽ/ഫീച്ചറുകളാൽ വിശദീകരിക്കപ്പെടുന്നു, അഥവാ `.` (ഈ കേസിൽ, നമുക്ക് ഒരു പ്രവചകൻ മാത്രമേ ഉള്ളൂ: `bmi`)\n"
],
"metadata": {
"id": "_oDHs89k_CJj"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Build a linear model specification\r\n",
"lm_spec <- linear_reg() %>% \r\n",
" set_engine(\"lm\") %>%\r\n",
" set_mode(\"regression\")\r\n",
"\r\n",
"\r\n",
"# Train a linear regression model\r\n",
"lm_mod <- lm_spec %>% \r\n",
" fit(y ~ ., data = diabetes_train)\r\n",
"\r\n",
"# Print the model\r\n",
"lm_mod"
],
"outputs": [],
"metadata": {
"id": "YlsHqd-q_GJQ"
}
},
{
"cell_type": "markdown",
"source": [
"From the model output, we can see the coefficients learned during training. They represent the coefficients of the line of best fit that gives us the lowest overall error between the actual and predicted variable.\n",
"<br>\n",
"\n",
"## 5. Make predictions on the test set\n",
"\n",
"Now that we've trained a model, we can use it to predict the disease progression y for the test dataset using [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html). This will be used to draw the line between data groups.\n"
],
"metadata": {
"id": "kGZ22RQj_Olu"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Make predictions for the test set\r\n",
"predictions <- lm_mod %>% \r\n",
" predict(new_data = diabetes_test)\r\n",
"\r\n",
"# Print out some of the predictions\r\n",
"predictions %>% \r\n",
" slice(1:5)"
],
"outputs": [],
"metadata": {
"id": "nXHbY7M2_aao"
}
},
{
"cell_type": "markdown",
"source": [
"വൂഹൂ! 💃🕺 നാം ഒരു മോഡൽ പരിശീലിപ്പിച്ച് അത് ഉപയോഗിച്ച് പ്രവചനങ്ങൾ നടത്തി!\n",
"\n",
"പ്രവചനങ്ങൾ നടത്തുമ്പോൾ, tidymodels പരമ്പരാഗതം എപ്പോഴും ഫലങ്ങളുടെ ഒരു ടിബിൾ/ഡാറ്റാ ഫ്രെയിം സ്റ്റാൻഡർഡൈസ്ഡ് കോളം പേരുകളോടെ ഉത്പാദിപ്പിക്കുകയാണ്. ഇത് മിക്കവാറും plotting പോലുള്ള തുടര്‍ന്നുള്ള പ്രവർത്തനങ്ങൾക്ക് ഉപയോഗയോഗ്യമായ ഫോർമാറ്റിൽ യഥാർത്ഥ ഡാറ്റയും പ്രവചനങ്ങളും സംയോജിപ്പിക്കാൻ എളുപ്പമാക്കുന്നു.\n",
"\n",
"`dplyr::bind_cols()` പല ഡാറ്റാ ഫ്രെയിമുകളും കാര്യക്ഷമമായി കോളം അടിസ്ഥാനത്തിൽ ബന്ധിപ്പിക്കുന്നു.\n"
],
"metadata": {
"id": "R_JstwUY_bIs"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Combine the predictions and the original test set\r\n",
"results <- diabetes_test %>% \r\n",
" bind_cols(predictions)\r\n",
"\r\n",
"\r\n",
"results %>% \r\n",
" slice(1:5)"
],
"outputs": [],
"metadata": {
"id": "RybsMJR7_iI8"
}
},
{
"cell_type": "markdown",
"source": [
"## 6. മോഡലിംഗ് ഫലങ്ങൾ പ്ലോട്ട് ചെയ്യുക\n",
"\n",
"ഇപ്പോൾ, ഇത് ദൃശ്യമായി കാണാനുള്ള സമയം 📈. ടെസ്റ്റ് സെറ്റിലെ എല്ലാ `y` ഉം `bmi` മൂല്യങ്ങളും സ്കാറ്റർ പ്ലോട്ട് ആയി സൃഷ്ടിക്കും, പിന്നീട് മോഡലിന്റെ ഡാറ്റ ഗ്രൂപ്പിംഗുകൾക്കിടയിൽ ഏറ്റവും അനുയോജ്യമായ സ്ഥലത്ത് വര വരച്ചെടുക്കാൻ പ്രവചനങ്ങൾ ഉപയോഗിക്കും.\n",
"\n",
"R-ന് ഗ്രാഫുകൾ സൃഷ്ടിക്കാൻ നിരവധി സിസ്റ്റങ്ങൾ ഉണ്ട്, പക്ഷേ `ggplot2` ഏറ്റവും സുന്ദരവും ഏറ്റവും ബഹുമുഖവുമാണ്. ഇത് **സ്വതന്ത്ര ഘടകങ്ങൾ സംയോജിപ്പിച്ച്** ഗ്രാഫുകൾ രൂപകൽപ്പന ചെയ്യാൻ അനുവദിക്കുന്നു.\n"
],
"metadata": {
"id": "XJbYbMZW_n_s"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Set a theme for the plot\r\n",
"theme_set(theme_light())\r\n",
"# Create a scatter plot\r\n",
"results %>% \r\n",
" ggplot(aes(x = bmi)) +\r\n",
" # Add a scatter plot\r\n",
" geom_point(aes(y = y), size = 1.6) +\r\n",
" # Add a line plot\r\n",
" geom_line(aes(y = .pred), color = \"blue\", size = 1.5)"
],
"outputs": [],
"metadata": {
"id": "R9tYp3VW_sTn"
}
},
{
"cell_type": "markdown",
"source": [
"> ✅ ഇവിടെ എന്ത് നടക്കുകയാണ് എന്ന് കുറച്ച് ചിന്തിക്കൂ. ഒരു നേരിയ രേഖ നിരവധി ചെറിയ ഡാറ്റാ പോയിന്റുകളിലൂടെ കടന്നുപോകുന്നു, പക്ഷേ അത് ശരിക്കും എന്ത് ചെയ്യുകയാണ്? ഈ രേഖ ഉപയോഗിച്ച് ഒരു പുതിയ, കാണാത്ത ഡാറ്റാ പോയിന്റ് പ്ലോട്ടിന്റെ y അക്ഷത്തോട് എങ്ങനെ ബന്ധപ്പെടണം എന്ന് പ്രവചിക്കാൻ കഴിയുമെന്ന് നിങ്ങൾക്ക് കാണാമോ? ഈ മോഡലിന്റെ പ്രായോഗിക ഉപയോഗം വാക്കുകളിൽ വെക്കാൻ ശ്രമിക്കൂ.\n",
"\n",
"അഭിനന്ദനങ്ങൾ, നിങ്ങൾ നിങ്ങളുടെ ആദ്യ ലീനിയർ റെഗ്രഷൻ മോഡൽ നിർമ്മിച്ചു, അതുപയോഗിച്ച് ഒരു പ്രവചനം സൃഷ്ടിച്ചു, അത് ഒരു പ്ലോട്ടിൽ പ്രദർശിപ്പിച്ചു!\n"
],
"metadata": {
"id": "zrPtHIxx_tNI"
}
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

677
translations/ml/2-Regression/1-Tools/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

228
translations/ml/2-Regression/2-Data/README.md
Unescape View File

@ -0,0 +1,228 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7c077988328ebfe33b24d07945f16eca",
"translation_date": "2025-12-19T14:00:13+00:00",
"source_file": "2-Regression/2-Data/README.md",
"language_code": "ml"
}
-->
# Scikit-learn ഉപയോഗിച്ച് ഒരു റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: ഡാറ്റ തയ്യാറാക്കൽ மற்றும் ദൃശ്യവൽക്കരണം
![ഡാറ്റ ദൃശ്യവൽക്കരണ ഇൻഫോഗ്രാഫിക്](../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.ml.png)
ഇൻഫോഗ്രാഫിക് [ദസാനി മടിപള്ളി](https://twitter.com/dasani_decoded) tarafından
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
> ### [ഈ പാഠം R-ൽ ലഭ്യമാണ്!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
## പരിചയം
Scikit-learn ഉപയോഗിച്ച് മെഷീൻ ലേണിംഗ് മോഡൽ നിർമ്മാണം ആരംഭിക്കാൻ ആവശ്യമായ ഉപകരണങ്ങൾ നിങ്ങൾക്കുണ്ടായതിനുശേഷം, നിങ്ങളുടെ ഡാറ്റയെക്കുറിച്ച് ചോദ്യങ്ങൾ ചോദിക്കാൻ നിങ്ങൾ തയ്യാറാണ്. ഡാറ്റയുമായി പ്രവർത്തിക്കുമ്പോഴും ML പരിഹാരങ്ങൾ പ്രയോഗിക്കുമ്പോഴും, നിങ്ങളുടെ ഡാറ്റാസെറ്റിന്റെ സാധ്യതകൾ ശരിയായി തുറക്കാൻ ശരിയായ ചോദ്യങ്ങൾ ചോദിക്കുന്നതിന്റെ പ്രാധാന്യം വളരെ കൂടുതലാണ്.
ഈ പാഠത്തിൽ, നിങ്ങൾ പഠിക്കും:
- മോഡൽ നിർമ്മാണത്തിനായി നിങ്ങളുടെ ഡാറ്റ എങ്ങനെ തയ്യാറാക്കാം.
- ഡാറ്റ ദൃശ്യവൽക്കരണത്തിന് Matplotlib എങ്ങനെ ഉപയോഗിക്കാം.
## നിങ്ങളുടെ ഡാറ്റയിൽ നിന്ന് ശരിയായ ചോദ്യങ്ങൾ ചോദിക്കുക
നിങ്ങൾക്ക് ഉത്തരം വേണമെന്ന ചോദ്യമാണ് നിങ്ങൾ ഉപയോഗിക്കേണ്ട ML ആൽഗോരിതങ്ങൾ നിർണ്ണയിക്കുന്നത്. നിങ്ങൾക്ക് ലഭിക്കുന്ന ഉത്തരം ലഭിക്കുന്നതിന്റെ ഗുണമേന്മ ഡാറ്റയുടെ സ്വഭാവത്തെ ആശ്രയിച്ചിരിക്കും.
ഈ പാഠത്തിനായി നൽകിയ [ഡാറ്റ](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) നോക്കുക. ഈ .csv ഫയൽ VS Code-ൽ തുറക്കാം. ഒരു വേഗത്തിലുള്ള നിരീക്ഷണം കാണിക്കുന്നു, ചില സ്ഥലങ്ങളിൽ ശൂന്യങ്ങൾ ഉണ്ട്, സ്ട്രിംഗുകളും സംഖ്യകളും മിശ്രിതമാണ്. 'Package' എന്ന ഒരു അസാധാരണ കോളം ഉണ്ട്, അതിൽ 'sacks', 'bins' എന്നിവയും മറ്റ് മൂല്യങ്ങളും മിശ്രിതമാണ്. ഡാറ്റ യഥാർത്ഥത്തിൽ അല്പം കലക്കമാണ്.
[![ML for beginners - How to Analyze and Clean a Dataset](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML for beginners - How to Analyze and Clean a Dataset")
> 🎥 ഈ പാഠത്തിനായി ഡാറ്റ തയ്യാറാക്കുന്നതിനെക്കുറിച്ച് ഒരു ചെറിയ വീഡിയോ കാണാൻ മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
യഥാർത്ഥത്തിൽ, ഒരു ML മോഡൽ സൃഷ്ടിക്കാൻ പൂർണ്ണമായും ഉപയോഗിക്കാൻ തയ്യാറായ ഒരു ഡാറ്റാസെറ്റ് ലഭിക്കുന്നത് സാധാരണമല്ല. ഈ പാഠത്തിൽ, നിങ്ങൾ സ്റ്റാൻഡേർഡ് Python ലൈബ്രറികൾ ഉപയോഗിച്ച് ഒരു റോ ഡാറ്റാസെറ്റ് എങ്ങനെ തയ്യാറാക്കാമെന്ന് പഠിക്കും. കൂടാതെ, ഡാറ്റ ദൃശ്യവൽക്കരിക്കാൻ വിവിധ സാങ്കേതിക വിദ്യകളും പഠിക്കും.
## കേസ് സ്റ്റഡി: 'പംപ്കിൻ മാർക്കറ്റ്'
ഈ ഫോൾഡറിൽ, റൂട്ട് `data` ഫോൾഡറിൽ [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) എന്ന .csv ഫയൽ കാണാം, ഇത് 1757 വരികളുള്ള പംപ്കിൻ മാർക്കറ്റിനെക്കുറിച്ചുള്ള ഡാറ്റ ഉൾക്കൊള്ളുന്നു, നഗരങ്ങളായി ഗ്രൂപ്പുചെയ്തിരിക്കുന്നു. ഇത് യുണൈറ്റഡ് സ്റ്റേറ്റ്സ് ഡിപ്പാർട്ട്മെന്റ് ഓഫ് അഗ്രിക്കൾച്ചർ വിതരണം ചെയ്യുന്ന [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) നിന്നുള്ള റോ ഡാറ്റയാണ്.
### ഡാറ്റ തയ്യാറാക്കൽ
ഈ ഡാറ്റ പബ്ലിക് ഡൊമെയ്‌നിലാണ്. ഇത് USDA വെബ്‌സൈറ്റിൽ നിന്ന് ഓരോ നഗരത്തിനും വേർതിരിച്ച ഫയലുകളായി ഡൗൺലോഡ് ചെയ്യാം. വളരെ അധികം വേർതിരിച്ച ഫയലുകൾ ഒഴിവാക്കാൻ, എല്ലാ നഗര ഡാറ്റയും ഒരു സ്പ്രെഡ്‌ഷീറ്റിൽ ചേർത്തിട്ടുണ്ട്, അതിനാൽ ഡാറ്റ കുറച്ച് _തയ്യാറാക്കിയതാണ്_. ഇനി, ഡാറ്റയെ കൂടുതൽ നന്നായി പരിശോധിക്കാം.
### പംപ്കിൻ ഡാറ്റ - പ്രാഥമിക നിഗമനങ്ങൾ
ഈ ഡാറ്റയിൽ നിങ്ങൾ എന്ത് ശ്രദ്ധിക്കുന്നു? നിങ്ങൾ ഇതിനകം കണ്ടിട്ടുണ്ട്, സ്ട്രിംഗുകളും സംഖ്യകളും, ശൂന്യങ്ങളും, അസാധാരണ മൂല്യങ്ങളും മിശ്രിതമാണ്.
Regression സാങ്കേതിക വിദ്യ ഉപയോഗിച്ച് ഈ ഡാറ്റയിൽ നിങ്ങൾ എന്ത് ചോദ്യങ്ങൾ ചോദിക്കാം? "നൽകിയ മാസത്തിൽ വിൽപ്പനയ്ക്കുള്ള പംപ്കിന്റെ വില പ്രവചിക്കുക" എന്നത് എങ്ങനെയാണ്? ഡാറ്റ വീണ്ടും നോക്കുമ്പോൾ, ഈ ടാസ്കിനായി ആവശ്യമായ ഡാറ്റ ഘടന സൃഷ്ടിക്കാൻ ചില മാറ്റങ്ങൾ ചെയ്യേണ്ടതുണ്ട്.
## അഭ്യാസം - പംപ്കിൻ ഡാറ്റ വിശകലനം ചെയ്യുക
ഡാറ്റ രൂപപ്പെടുത്താനും വിശകലനം ചെയ്യാനും വളരെ ഉപകാരപ്രദമായ ഒരു ഉപകരണം ആയ [Pandas](https://pandas.pydata.org/) (Python Data Analysis എന്നതിന് ചുരുക്കം) ഉപയോഗിക്കാം.
### ആദ്യം, നഷ്ടപ്പെട്ട തീയതികൾ പരിശോധിക്കുക
നഷ്ടപ്പെട്ട തീയതികൾ പരിശോധിക്കാൻ നിങ്ങൾ ആദ്യം ചില നടപടികൾ സ്വീകരിക്കണം:
1. തീയതികളെ മാസ ഫോർമാറ്റിലേക്ക് മാറ്റുക (ഇവ US തീയതികളാണ്, അതിനാൽ ഫോർമാറ്റ് `MM/DD/YYYY` ആണ്).
2. മാസത്തെ പുതിയ ഒരു കോളമായി എടുക്കുക.
Visual Studio Code-ൽ _notebook.ipynb_ ഫയൽ തുറന്ന് സ്പ്രെഡ്‌ഷീറ്റ് പുതിയ Pandas ഡാറ്റാഫ്രെയിമിലേക്ക് ഇറക്കുമതി ചെയ്യുക.
1. ആദ്യ അഞ്ചു വരികൾ കാണാൻ `head()` ഫംഗ്ഷൻ ഉപയോഗിക്കുക.
```python
import pandas as pd
pumpkins = pd.read_csv('../data/US-pumpkins.csv')
pumpkins.head()
```
✅ അവസാന അഞ്ചു വരികൾ കാണാൻ നിങ്ങൾ ഏത് ഫംഗ്ഷൻ ഉപയോഗിക്കും?
1. നിലവിലുള്ള ഡാറ്റാഫ്രെയിമിൽ നഷ്ടപ്പെട്ട ഡാറ്റയുണ്ടോ എന്ന് പരിശോധിക്കുക:
```python
pumpkins.isnull().sum()
```
നഷ്ടപ്പെട്ട ഡാറ്റയുണ്ട്, പക്ഷേ ഈ ടാസ്കിനായി അത് പ്രശ്നമാകില്ല.
1. നിങ്ങളുടെ ഡാറ്റാഫ്രെയിമിൽ പ്രവർത്തിക്കാൻ എളുപ്പമാക്കാൻ, നിങ്ങൾക്ക് ആവശ്യമായ കോളങ്ങൾ മാത്രം `loc` ഫംഗ്ഷൻ ഉപയോഗിച്ച് തിരഞ്ഞെടുക്കുക, ഇത് ആദ്യ പാരാമീറ്ററായി പാസ്സാക്കിയ വരികളും രണ്ടാം പാരാമീറ്ററായി പാസ്സാക്കിയ കോളങ്ങളും ഒറിജിനൽ ഡാറ്റാഫ്രെയിമിൽ നിന്ന് എടുക്കുന്നു. താഴെ കാണുന്ന `:` എന്നത് "എല്ലാ വരികളും" എന്നർത്ഥം.
```python
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
pumpkins = pumpkins.loc[:, columns_to_select]
```
### രണ്ടാംത്, പംപ്കിന്റെ ശരാശരി വില നിർണ്ണയിക്കുക
നൽകിയ മാസത്തിൽ പംപ്കിന്റെ ശരാശരി വില എങ്ങനെ നിർണ്ണയിക്കാമെന്ന് ചിന്തിക്കുക. ഈ ടാസ്കിനായി നിങ്ങൾ ഏത് കോളങ്ങൾ തിരഞ്ഞെടുക്കും? സൂചന: 3 കോളങ്ങൾ ആവശ്യമാണ്.
പരിഹാരം: `Low Price` ഉം `High Price` ഉം കോളങ്ങൾ ശരാശരി എടുത്ത് പുതിയ Price കോളം പൂരിപ്പിക്കുക, Date കോളം മാസമാത്രം കാണിക്കുന്ന വിധം മാറ്റുക. ഭാഗ്യവശാൽ, മുകളിൽ നടത്തിയ പരിശോധന പ്രകാരം, തീയതികൾക്കും വിലകൾക്കും നഷ്ടപ്പെട്ട ഡാറ്റ ഇല്ല.
1. ശരാശരി കണക്കാക്കാൻ താഴെ കൊടുത്ത കോഡ് ചേർക്കുക:
```python
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
month = pd.DatetimeIndex(pumpkins['Date']).month
```
✅ `print(month)` ഉപയോഗിച്ച് നിങ്ങൾക്ക് പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്ന ഡാറ്റ പ്രിന്റ് ചെയ്യാം.
2. ഇപ്പോൾ, നിങ്ങളുടെ മാറ്റിയ ഡാറ്റ പുതിയ Pandas ഡാറ്റാഫ്രെയിമിലേക്ക് പകർത്തുക:
```python
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
നിങ്ങളുടെ ഡാറ്റാഫ്രെയിം പ്രിന്റ് ചെയ്താൽ നിങ്ങൾക്ക് ഒരു ശുചിത്വമുള്ള, ക്രമീകരിച്ച ഡാറ്റാസെറ്റ് കാണാം, ഇതിൽ നിങ്ങൾ പുതിയ റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കാം.
### പക്ഷേ കാത്തിരിക്കുക! ഇവിടെ ഒരു അസാധാരണതയുണ്ട്
`Package` കോളം നോക്കിയാൽ, പംപ്കിനുകൾ പലവിധ കോൺഫിഗറേഷനുകളിൽ വിൽക്കുന്നു. ചിലത് '1 1/9 ബുഷെൽ' അളവിൽ, ചിലത് '1/2 ബുഷെൽ' അളവിൽ, ചിലത് ഓരോ പംപ്കിനായി, ചിലത് പൗണ്ടിന്, ചിലത് വ്യത്യസ്ത വീതികളുള്ള വലിയ ബോക്സുകളിൽ.
> പംപ്കിനുകൾ സ്ഥിരമായി തൂക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്
ഓറിജിനൽ ഡാറ്റയിൽ നോക്കുമ്പോൾ, `Unit of Sale` 'EACH' അല്ലെങ്കിൽ 'PER BIN' ആയവയ്ക്ക് `Package` തരം ഇഞ്ച്, ബിൻ, അല്ലെങ്കിൽ 'each' ആണ്. പംപ്കിനുകൾ സ്ഥിരമായി തൂക്കാൻ ബുദ്ധിമുട്ടാണ്, അതിനാൽ `Package` കോളത്തിൽ 'bushel' എന്ന സ്ട്രിംഗ് ഉള്ള പംപ്കിനുകൾ മാത്രം തിരഞ്ഞെടുക്കാം.
1. ഫയലിന്റെ മുകളിൽ, ആദ്യ .csv ഇറക്കുമതിക്ക് താഴെ ഒരു ഫിൽട്ടർ ചേർക്കുക:
```python
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
ഇപ്പോൾ ഡാറ്റ പ്രിന്റ് ചെയ്താൽ, ബുഷെൽ പ്രകാരം പംപ്കിനുകൾ ഉള്ള ഏകദേശം 415 വരികൾ മാത്രം കാണാം.
### പക്ഷേ കാത്തിരിക്കുക! മറ്റൊരു കാര്യവും ചെയ്യണം
ബുഷെൽ അളവ് ഓരോ വരിയിലും വ്യത്യസ്തമാണെന്ന് ശ്രദ്ധിച്ചോ? വില ബുഷെൽപ്രകാരം സാധാരണവത്കരിക്കണം, അതിനാൽ ചില ഗണിതം ചെയ്യണം.
1. പുതിയ_pumpkins ഡാറ്റാഫ്രെയിം സൃഷ്ടിക്കുന്ന ബ്ലോക്കിന് ശേഷം ഈ വരികൾ ചേർക്കുക:
```python
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308) പ്രകാരം, ബുഷെലിന്റെ ഭാരം ഉത്പന്നത്തിന്റെ തരം അനുസരിച്ച് വ്യത്യാസപ്പെടുന്നു, കാരണം ഇത് വോളിയം അളവാണ്. "ഉദാഹരണത്തിന്, ടൊമാറ്റോയുടെ ഒരു ബുഷെൽ 56 പൗണ്ട് തൂക്കമുള്ളതാണ്... ഇലകളും പച്ചക്കറികളും കുറവ് ഭാരം ഉള്ളതിനാൽ, സ്പിനാച്ചിന്റെ ഒരു ബുഷെൽ 20 പൗണ്ട് മാത്രമാണ്." ഇത് വളരെ സങ്കീർണ്ണമാണ്! ബുഷെൽ-ടു-പൗണ്ട് പരിവർത്തനം ചെയ്യാതെ, ബുഷെൽപ്രകാരം വില നിശ്ചയിക്കാം. പംപ്കിനുകളുടെ ബുഷെൽ പഠനം, നിങ്ങളുടെ ഡാറ്റയുടെ സ്വഭാവം മനസ്സിലാക്കുന്നതിന്റെ പ്രാധാന്യം കാണിക്കുന്നു!
ഇപ്പോൾ, ബുഷെൽ അളവിന്റെ അടിസ്ഥാനത്തിൽ യൂണിറ്റ് വില വിശകലനം ചെയ്യാം. ഡാറ്റ വീണ്ടും പ്രിന്റ് ചെയ്താൽ ഇത് എങ്ങനെ സാധാരണവത്കരിച്ചിട്ടുള്ളതാണെന്ന് കാണാം.
✅ പംപ്കിനുകൾ അർദ്ധ-ബുഷെൽ പ്രകാരം വിൽക്കുമ്പോൾ വളരെ വിലകൂടിയാണെന്ന് ശ്രദ്ധിച്ചോ? എന്തുകൊണ്ടെന്ന് കണ്ടെത്താമോ? സൂചന: ചെറിയ പംപ്കിനുകൾ വലിയവയെക്കാൾ വിലകൂടിയതാണ്, കാരണം ഒരു വലിയ പൊള്ളയായ പൈ പംപ്കിൻ എടുത്തിടുന്ന ഉപയോഗിക്കാത്ത സ്ഥലത്തെ തുടർന്ന് ബുഷെലിൽ അവയുടെ എണ്ണം വളരെ കൂടുതലാണ്.
## ദൃശ്യവൽക്കരണ തന്ത്രങ്ങൾ
ഡാറ്റ സയന്റിസ്റ്റിന്റെ ഒരു ഭാഗം, അവർ പ്രവർത്തിക്കുന്ന ഡാറ്റയുടെ ഗുണമേന്മയും സ്വഭാവവും പ്രദർശിപ്പിക്കുകയാണ്. ഇതിന്, അവർ പലപ്പോഴും രസകരമായ ദൃശ്യവൽക്കരണങ്ങൾ, പ്ലോട്ടുകൾ, ഗ്രാഫുകൾ, ചാർട്ടുകൾ സൃഷ്ടിക്കുന്നു, ഡാറ്റയുടെ വ്യത്യസ്ത വശങ്ങൾ കാണിക്കുന്നു. ഇതിലൂടെ, അവർ ദൃശ്യമായി ബന്ധങ്ങളും ഇടവേളകളും കാണിക്കാൻ കഴിയും, സാധാരണയായി കണ്ടെത്താൻ ബുദ്ധിമുട്ടുള്ളവ.
[![ML for beginners - How to Visualize Data with Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML for beginners - How to Visualize Data with Matplotlib")
> 🎥 ഈ പാഠത്തിനായി ഡാറ്റ ദൃശ്യവൽക്കരിക്കുന്നതിനെക്കുറിച്ച് ഒരു ചെറിയ വീഡിയോ കാണാൻ മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
ദൃശ്യവൽക്കരണങ്ങൾ ഡാറ്റയ്ക്ക് ഏറ്റവും അനുയോജ്യമായ മെഷീൻ ലേണിംഗ് സാങ്കേതിക വിദ്യ നിർണ്ണയിക്കാനും സഹായിക്കുന്നു. ഒരു സ്കാറ്റർപ്ലോട്ട് ഒരു രേഖ പിന്തുടരുന്ന പോലെ തോന്നിയാൽ, ഡാറ്റ ലീനിയർ റെഗ്രഷൻ അഭ്യാസത്തിന് നല്ല സ്ഥാനാർത്ഥിയാണ്.
Jupyter നോട്ട്‌ബുക്കുകളിൽ നല്ല പ്രവർത്തനം കാണിക്കുന്ന ഒരു ഡാറ്റ ദൃശ്യവൽക്കരണ ലൈബ്രറി [Matplotlib](https://matplotlib.org/) ആണ് (മുൻപത്തെ പാഠത്തിലും നിങ്ങൾ കണ്ടതാണ്).
> [ഈ ട്യൂട്ടോറിയലുകളിൽ](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott) ഡാറ്റ ദൃശ്യവൽക്കരണത്തിൽ കൂടുതൽ പരിചയം നേടുക.
## അഭ്യാസം - Matplotlib ഉപയോഗിച്ച് പരീക്ഷണം നടത്തുക
നിങ്ങൾ ഇപ്പോൾ സൃഷ്ടിച്ച പുതിയ ഡാറ്റാഫ്രെയിം പ്രദർശിപ്പിക്കാൻ ചില അടിസ്ഥാന പ്ലോട്ടുകൾ സൃഷ്ടിക്കാൻ ശ്രമിക്കുക. ഒരു അടിസ്ഥാന ലൈൻ പ്ലോട്ട് എന്ത് കാണിക്കും?
1. ഫയലിന്റെ മുകളിൽ, Pandas ഇറക്കുമതിക്ക് താഴെ Matplotlib ഇറക്കുമതി ചെയ്യുക:
```python
import matplotlib.pyplot as plt
```
1. മുഴുവൻ നോട്ട്‌ബുക്ക് വീണ്ടും റൺ ചെയ്യുക.
1. നോട്ട്‌ബുക്കിന്റെ താഴെ ഭാഗത്ത്, ഡാറ്റ ബോക്സ് ആയി പ്ലോട്ട് ചെയ്യാൻ ഒരു സെൽ ചേർക്കുക:
```python
price = new_pumpkins.Price
month = new_pumpkins.Month
plt.scatter(price, month)
plt.show()
```
![വില-മാസ ബന്ധം കാണിക്കുന്ന സ്കാറ്റർപ്ലോട്ട്](../../../../translated_images/scatterplot.b6868f44cbd2051c6680ccdbb1510697d06a3ff6cd4abda656f5009c0ed4e3fc.ml.png)
ഇത് ഒരു ഉപകാരപ്രദമായ പ്ലോട്ട് ആണോ? ഇതിൽ എന്തെങ്കിലും നിങ്ങൾക്ക് അത്ഭുതം തോന്നുന്നുണ്ടോ?
ഇത് പ്രത്യേകിച്ച് ഉപകാരപ്രദമല്ല, കാരണം ഇത് നിങ്ങളുടെ ഡാറ്റ ഒരു മാസത്തിൽ പോയിന്റുകളുടെ വ്യാപ്തിയായി മാത്രം പ്രദർശിപ്പിക്കുന്നു.
### ഇത് ഉപകാരപ്രദമാക്കുക
ചാർട്ടുകൾ ഉപകാരപ്രദമായ ഡാറ്റ പ്രദർശിപ്പിക്കാൻ, സാധാരണയായി ഡാറ്റയെ ഏതെങ്കിലും വിധത്തിൽ ഗ്രൂപ്പ് ചെയ്യേണ്ടതുണ്ട്. മാസങ്ങൾ y അക്ഷത്തിൽ കാണിക്കുന്ന, ഡാറ്റയുടെ വിതരണത്തെ പ്രദർശിപ്പിക്കുന്ന ഒരു പ്ലോട്ട് സൃഷ്ടിക്കാൻ ശ്രമിക്കാം.
1. ഗ്രൂപ്പുചെയ്ത ബാർ ചാർട്ട് സൃഷ്ടിക്കാൻ ഒരു സെൽ ചേർക്കുക:
```python
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
plt.ylabel("Pumpkin Price")
```
![വില-മാസ ബന്ധം കാണിക്കുന്ന ബാർ ചാർട്ട്](../../../../translated_images/barchart.a833ea9194346d769c77a3a870f7d8aee51574cd1138ca902e5500830a41cbce.ml.png)
ഇത് കൂടുതൽ ഉപകാരപ്രദമായ ഡാറ്റ ദൃശ്യവൽക്കരണമാണ്! പംപ്കിനുകളുടെ ഏറ്റവും ഉയർന്ന വില സെപ്റ്റംബർ, ഒക്ടോബർ മാസങ്ങളിൽ സംഭവിക്കുന്നതായി ഇത് സൂചിപ്പിക്കുന്നു. ഇത് നിങ്ങളുടെ പ്രതീക്ഷയുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ? എന്തുകൊണ്ടോ എന്തുകൊണ്ടല്ല?
---
## 🚀ചലഞ്ച്
Matplotlib നൽകുന്ന വിവിധ ദൃശ്യവൽക്കരണ തരം പരിശോധിക്കുക. റെഗ്രഷൻ പ്രശ്നങ്ങൾക്ക് ഏറ്റവും അനുയോജ്യമായ തരം ഏതാണ്?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ഡാറ്റ ദൃശ്യവൽക്കരിക്കുന്ന നിരവധി മാർഗങ്ങൾ പരിശോധിക്കുക. ലഭ്യമായ വിവിധ ലൈബ്രറികളുടെ പട്ടിക തയ്യാറാക്കുക, പ്രത്യേകിച്ച് 2D ദൃശ്യവൽക്കരണങ്ങൾക്കും 3D ദൃശ്യവൽക്കരണങ്ങൾക്കും ഏത് ലൈബ്രറികൾ ഏറ്റവും അനുയോജ്യമാണ് എന്ന് കുറിക്കുക. നിങ്ങൾ എന്ത് കണ്ടെത്തുന്നു?
## അസൈൻമെന്റ്
[ദൃശ്യവൽക്കരണം അന്വേഷിക്കൽ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/ml/2-Regression/2-Data/assignment.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4485a1ed4dd1b5647365e3d87456515d",
"translation_date": "2025-12-19T14:03:17+00:00",
"source_file": "2-Regression/2-Data/assignment.md",
"language_code": "ml"
}
-->
# ദൃശ്യവത്കരണങ്ങൾ അന്വേഷിക്കൽ
ഡാറ്റാ ദൃശ്യവത്കരണത്തിനായി ലഭ്യമായ വിവിധ ലൈബ്രറികൾ ഉണ്ട്. matplotlib, seaborn എന്നിവ ഉപയോഗിച്ച് ഈ പാഠത്തിലെ Pumpkin ഡാറ്റ ഉപയോഗിച്ച് ചില ദൃശ്യവത്കരണങ്ങൾ ഒരു സാമ്പിൾ നോട്ട്‌ബുക്കിൽ സൃഷ്ടിക്കുക. ഏത് ലൈബ്രറികൾ ഉപയോഗിക്കാൻ എളുപ്പമാണ്?
## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണമായത് | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------- | ------------- | -------- | ----------------- |
| | രണ്ട് അന്വേഷണങ്ങൾ/ദൃശ്യവത്കരണങ്ങൾ ഉള്ള ഒരു നോട്ട്‌ബുക്ക് സമർപ്പിച്ചിരിക്കുന്നു | ഒരു അന്വേഷണം/ദൃശ്യവത്കരണം ഉള്ള ഒരു നോട്ട്‌ബുക്ക് സമർപ്പിച്ചിരിക്കുന്നു | ഒരു നോട്ട്‌ബുക്ക് സമർപ്പിച്ചിട്ടില്ല |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ വ്യാഖ്യാനക്കേടുകൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

46
translations/ml/2-Regression/2-Data/notebook.ipynb
Unescape View File

@ -0,0 +1,46 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3-final"
},
"orig_nbformat": 2,
"kernelspec": {
"name": "python3",
"display_name": "Python 3",
"language": "python"
},
"coopTranslator": {
"original_hash": "1b2ab303ac6c604a34c6ca7a49077fc7",
"translation_date": "2025-12-19T16:18:13+00:00",
"source_file": "2-Regression/2-Data/notebook.ipynb",
"language_code": "ml"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

17
translations/ml/2-Regression/2-Data/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:09:45+00:00",
"source_file": "2-Regression/2-Data/solution/Julia/README.md",
"language_code": "ml"
}
-->
ഇത് ഒരു താൽക്കാലിക പ്ലേസ്ഹോൾഡറാണ്
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് കരുതേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

673
translations/ml/2-Regression/2-Data/solution/R/lesson_2-R.ipynb
Unescape View File

@ -0,0 +1,673 @@
{
"nbformat": 4,
"nbformat_minor": 2,
"metadata": {
"colab": {
"name": "lesson_2-R.ipynb",
"provenance": [],
"collapsed_sections": [],
"toc_visible": true
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "f3c335f9940cfd76528b3ef918b9b342",
"translation_date": "2025-12-19T16:34:58+00:00",
"source_file": "2-Regression/2-Data/solution/R/lesson_2-R.ipynb",
"language_code": "ml"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# ഒരു റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: ഡാറ്റ തയ്യാറാക്കുകയും ദൃശ്യവത്കരിക്കുകയും ചെയ്യുക\n",
"\n",
"## **പമ്പ്കിൻസിനുള്ള ലീനിയർ റെഗ്രഷൻ - പാഠം 2**\n",
"#### പരിചയം\n",
"\n",
"Tidymodels ഉം Tidyverse ഉം ഉപയോഗിച്ച് മെഷീൻ ലേണിംഗ് മോഡൽ നിർമ്മാണം ആരംഭിക്കാൻ ആവശ്യമായ ഉപകരണങ്ങൾ നിങ്ങൾക്കുണ്ടായപ്പോൾ, നിങ്ങളുടെ ഡാറ്റയെക്കുറിച്ച് ചോദ്യങ്ങൾ ചോദിക്കാൻ നിങ്ങൾ തയ്യാറാണ്. ഡാറ്റയുമായി പ്രവർത്തിക്കുമ്പോഴും ML പരിഹാരങ്ങൾ പ്രയോഗിക്കുമ്പോഴും, നിങ്ങളുടെ ഡാറ്റാസെറ്റിന്റെ സാധ്യതകൾ ശരിയായി തുറക്കാൻ ശരിയായ ചോദ്യങ്ങൾ ചോദിക്കുന്നത് വളരെ പ്രധാനമാണ്.\n",
"\n",
"ഈ പാഠത്തിൽ, നിങ്ങൾ പഠിക്കാനിരിക്കുന്നതെന്തെന്നാൽ:\n",
"\n",
"- മോഡൽ നിർമ്മാണത്തിനായി നിങ്ങളുടെ ഡാറ്റ എങ്ങനെ തയ്യാറാക്കാം.\n",
"\n",
"- ഡാറ്റ ദൃശ്യവത്കരണത്തിന് `ggplot2` എങ്ങനെ ഉപയോഗിക്കാം.\n",
"\n",
"നിങ്ങൾക്ക് ഉത്തരം വേണമെന്ന ചോദ്യമാണ് നിങ്ങൾ ഉപയോഗിക്കേണ്ട ML ആൽഗോരിതങ്ങൾ നിർണ്ണയിക്കുന്നത്. നിങ്ങൾക്ക് ലഭിക്കുന്ന ഉത്തരം എത്രത്തോളം ഗുണമേന്മയുള്ളതായിരിക്കും എന്നത് നിങ്ങളുടെ ഡാറ്റയുടെ സ്വഭാവത്തെ ആശ്രയിച്ചിരിക്കും.\n",
"\n",
"പ്രായോഗികമായ ഒരു അഭ്യാസത്തിലൂടെ ഇത് നോക്കാം.\n",
"\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/unruly_data.0eedc7ced92d2d919cf5ea197bfe0fe9a30780c4bf7cdcf14ff4e9dc5a4c7267.ml.jpg\"\n",
" width=\"700\"/>\n",
" <figcaption>@allison_horst രചിച്ച കലാസൃഷ്ടി</figcaption>\n"
],
"metadata": {
"id": "Pg5aexcOPqAZ"
}
},
{
"cell_type": "markdown",
"source": [
"## 1. പംപ്കിൻസ് ഡാറ്റ ഇറക്കുമതി ചെയ്യുകയും ടിഡിവേഴ്സ് വിളിക്കുകയും ചെയ്യുക\n",
"\n",
"ഈ പാഠം കഷണങ്ങളാക്കി വിശകലനം ചെയ്യാൻ താഴെപ്പറയുന്ന പാക്കേജുകൾ ആവശ്യമാണ്:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) ഒരു [R പാക്കേജുകളുടെ സമാഹാരമാണ്](https://www.tidyverse.org/packages) ഇത് ഡാറ്റാ സയൻസ് വേഗത്തിലാക്കാനും, എളുപ്പമാക്കാനും, കൂടുതൽ രസകരമാക്കാനും രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു!\n",
"\n",
"നിങ്ങൾക്ക് ഇവ ഇങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം:\n",
"\n",
"`install.packages(c(\"tidyverse\"))`\n",
"\n",
"താഴെ കൊടുത്തിരിക്കുന്ന സ്ക്രിപ്റ്റ് ഈ മോഡ്യൂൾ പൂർത്തിയാക്കാൻ ആവശ്യമായ പാക്കേജുകൾ നിങ്ങൾക്കുണ്ടോ എന്ന് പരിശോധിച്ച്, കുറവുണ്ടെങ്കിൽ അവ ഇൻസ്റ്റാൾ ചെയ്യുന്നു.\n"
],
"metadata": {
"id": "dc5WhyVdXAjR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
"pacman::p_load(tidyverse)"
],
"outputs": [],
"metadata": {
"id": "GqPYUZgfXOBt"
}
},
{
"cell_type": "markdown",
"source": [
"ഇപ്പോൾ, ചില പാക്കേജുകൾ പ്രവർത്തിപ്പിച്ച് ഈ പാഠത്തിനായി നൽകിയ [ഡാറ്റ](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) ലോഡ് ചെയ്യാം!\n"
],
"metadata": {
"id": "kvjDTPDSXRr2"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load the core Tidyverse packages\n",
"library(tidyverse)\n",
"\n",
"# Import the pumpkins data\n",
"pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\")\n",
"\n",
"\n",
"# Get a glimpse and dimensions of the data\n",
"glimpse(pumpkins)\n",
"\n",
"\n",
"# Print the first 50 rows of the data set\n",
"pumpkins %>% \n",
" slice_head(n =50)"
],
"outputs": [],
"metadata": {
"id": "VMri-t2zXqgD"
}
},
{
"cell_type": "markdown",
"source": [
"A quick `glimpse()` ഉടൻ കാണിക്കുന്നു that there are blanks and a mix of strings (`chr`) and numeric data (`dbl`). The `Date` is of type character and there's also a strange column called `Package` where the data is a mix between `sacks`, `bins` and other values. The data, in fact, is a bit of a mess 😤.\n",
"\n",
"In fact, it is not very common to be gifted a dataset that is completely ready to use to create a ML model out of the box. But worry not, in this lesson, you will learn how to prepare a raw dataset using standard R libraries 🧑‍🔧. You will also learn various techniques to visualize the data.📈📊\n",
"<br>\n",
"\n",
"> A refresher: The pipe operator (`%>%`) performs operations in logical sequence by passing an object forward into a function or call expression. You can think of the pipe operator as saying \"and then\" in your code.\n"
],
"metadata": {
"id": "REWcIv9yX29v"
}
},
{
"cell_type": "markdown",
"source": [
"## 2. നഷ്ടമായ ഡാറ്റ പരിശോധിക്കുക\n",
"\n",
"ഡാറ്റാ സയന്റിസ്റ്റുകൾ നേരിടേണ്ട ഏറ്റവും സാധാരണ പ്രശ്നങ്ങളിൽ ഒന്നാണ് അപൂർണ്ണമായ അല്ലെങ്കിൽ നഷ്ടമായ ഡാറ്റ. R നഷ്ടമായ അല്ലെങ്കിൽ അറിയപ്പെടാത്ത മൂല്യങ്ങളെ പ്രത്യേക സെന്റിനൽ മൂല്യമായ `NA` (Not Available) ഉപയോഗിച്ച് പ്രതിനിധീകരിക്കുന്നു.\n",
"\n",
"അപ്പോൾ ഡാറ്റാ ഫ്രെയിമിൽ നഷ്ടമായ മൂല്യങ്ങൾ ഉണ്ടെന്ന് എങ്ങനെ അറിയാം?\n",
"<br>\n",
"- ഒരു നേരിട്ടുള്ള മാർഗം ബേസ് R ഫംഗ്ഷൻ `anyNA` ഉപയോഗിക്കുകയാണ്, ഇത് ലജിക്കൽ ഒബ്ജക്റ്റുകൾ ആയ `TRUE` അല്ലെങ്കിൽ `FALSE` തിരികെ നൽകുന്നു.\n"
],
"metadata": {
"id": "Zxfb3AM5YbUe"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" anyNA()"
],
"outputs": [],
"metadata": {
"id": "G--DQutAYltj"
}
},
{
"cell_type": "markdown",
"source": [
"ശ്രേഷ്ഠം, ചില ഡാറ്റ നഷ്ടപ്പെട്ടിട്ടുണ്ട് പോലെ തോന്നുന്നു! അത് ആരംഭിക്കാൻ നല്ല സ്ഥലം ആണ്.\n",
"\n",
"- മറ്റൊരു മാർഗം `is.na()` ഫംഗ്ഷൻ ഉപയോഗിക്കുകയാണ്, ഇത് ഏതൊക്കെ വ്യക്തിഗത കോളം ഘടകങ്ങൾ നഷ്ടപ്പെട്ടിട്ടുണ്ടെന്ന് ലജിക്കൽ `TRUE` ആയി സൂചിപ്പിക്കുന്നു.\n"
],
"metadata": {
"id": "mU-7-SB6YokF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" is.na() %>% \n",
" head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "W-DxDOR4YxSW"
}
},
{
"cell_type": "markdown",
"source": [
"ശരി, ജോലി പൂർത്തിയായി, പക്ഷേ ഇതുപോലുള്ള വലിയ ഡാറ്റാ ഫ്രെയിമിനൊപ്പം, ഓരോ വരിയും കോളവും വ്യക്തിഗതമായി പരിശോധിക്കുന്നത് കാര്യക്ഷമമല്ലയും പ്രായോഗികമായി അസാധ്യവുമാകും😴.\n",
"\n",
"- കൂടുതൽ ബോധഗമ്യമായ ഒരു മാർഗം ഓരോ കോളത്തിന്റെയും നഷ്ടപ്പെട്ട മൂല്യങ്ങളുടെ മൊത്തം കണക്കാക്കുക എന്നതാണ്:\n"
],
"metadata": {
"id": "xUWxipKYY0o7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" is.na() %>% \n",
" colSums()"
],
"outputs": [],
"metadata": {
"id": "ZRBWV6P9ZArL"
}
},
{
"cell_type": "markdown",
"source": [
"കൂടുതൽ മെച്ചപ്പെട്ടത്! കുറച്ച് ഡാറ്റ നഷ്ടമായിട്ടുണ്ട്, പക്ഷേ ഇപ്പോഴത്തെ ജോലി ചെയ്യുന്നതിന് അതിന് വലിയ പ്രാധാന്യമുണ്ടാകില്ല. കൂടുതൽ വിശകലനം എന്ത് കണ്ടെത്തും എന്ന് നോക്കാം.\n",
"\n",
"> അതുല്യമായ പാക്കേജുകളും ഫംഗ്ഷനുകളും കൂടാതെ, R-ന് വളരെ നല്ല ഡോക്യുമെന്റേഷൻ ഉണ്ട്. ഉദാഹരണത്തിന്, ഫംഗ്ഷൻ കുറിച്ച് കൂടുതൽ അറിയാൻ `help(colSums)` അല്ലെങ്കിൽ `?colSums` ഉപയോഗിക്കുക.\n"
],
"metadata": {
"id": "9gv-crB6ZD1Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. Dplyr: ഡാറ്റ മാനിപ്പുലേഷന്റെ ഒരു വ്യാകരണം\n",
"\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/dplyr_wrangling.f5f99c64fd4580f1377fee3ea428b6f8fd073845ec0f8409d483cfe148f0984e.ml.png\"\n",
" width=\"569\"/>\n",
" <figcaption>@allison_horst എന്നവരുടെ കലാസൃഷ്ടി</figcaption>\n",
"\n",
"\n",
"<!--![Artwork by \\@allison_horst](../../../../../../translated_images/dplyr_wrangling.f5f99c64fd4580f1377fee3ea428b6f8fd073845ec0f8409d483cfe148f0984e.ml.png)<br/>Artwork by \\@allison_horst-->\n"
],
"metadata": {
"id": "o4jLY5-VZO2C"
}
},
{
"cell_type": "markdown",
"source": [
"[`dplyr`](https://dplyr.tidyverse.org/), Tidyverse-ൽ ഉള്ള ഒരു പാക്കേജ്, ഡാറ്റ മാനിപ്പുലേഷന്റെ ഒരു വ്യാകരണം ആണ്, ഇത് സാധാരണയായി കാണപ്പെടുന്ന ഡാറ്റ മാനിപ്പുലേഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ സഹായിക്കുന്ന സ്ഥിരമായ ക്രിയാപദങ്ങളുടെ ഒരു സെറ്റ് നൽകുന്നു. ഈ വിഭാഗത്തിൽ, നാം dplyr-ന്റെ ചില ക്രിയാപദങ്ങൾ പരിശോധിക്കാം! \n",
"<br>\n"
],
"metadata": {
"id": "i5o33MQBZWWw"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::select()\n",
"\n",
"`select()` എന്നത് `dplyr` പാക്കേജിലുള്ള ഒരു ഫംഗ്ഷനാണ്, ഇത് നിങ്ങൾക്ക് സൂക്ഷിക്കാനോ ഒഴിവാക്കാനോ കോളങ്ങൾ തിരഞ്ഞെടുക്കാൻ സഹായിക്കുന്നു.\n",
"\n",
"നിങ്ങളുടെ ഡാറ്റാ ഫ്രെയിം ഉപയോഗിക്കാൻ എളുപ്പമാക്കാൻ, അതിലെ ചില കോളങ്ങൾ ഒഴിവാക്കുക, `select()` ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ആവശ്യമായ കോളങ്ങൾ മാത്രം സൂക്ഷിക്കുക.\n",
"\n",
"ഉദാഹരണത്തിന്, ഈ അഭ്യാസത്തിൽ, നമ്മുടെ വിശകലനം `Package`, `Low Price`, `High Price` மற்றும் `Date` എന്ന കോളങ്ങൾ ഉൾപ്പെടും. ഈ കോളങ്ങൾ തിരഞ്ഞെടുക്കാം.\n"
],
"metadata": {
"id": "x3VGMAGBZiUr"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Select desired columns\n",
"pumpkins <- pumpkins %>% \n",
" select(Package, `Low Price`, `High Price`, Date)\n",
"\n",
"\n",
"# Print data set\n",
"pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "F_FgxQnVZnM0"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::mutate()\n",
"\n",
"`mutate()` എന്നത് `dplyr` പാക്കേജിലുള്ള ഒരു ഫംഗ്ഷനാണ്, ഇത് നിലവിലുള്ള കോളങ്ങൾ നിലനിർത്തിക്കൊണ്ട് പുതിയ കോളങ്ങൾ സൃഷ്ടിക്കുകയോ മാറ്റം വരുത്തുകയോ ചെയ്യാൻ സഹായിക്കുന്നു.\n",
"\n",
"mutate ന്റെ പൊതുവായ ഘടന:\n",
"\n",
"`data %>% mutate(new_column_name = what_it_contains)`\n",
"\n",
"`Date` കോളം ഉപയോഗിച്ച് `mutate` പരീക്ഷിക്കാം, താഴെ പറയുന്ന പ്രവർത്തനങ്ങൾ ചെയ്യുക:\n",
"\n",
"1. തീയതികൾ (ഇപ്പോൾ character തരം) മാസ ഫോർമാറ്റിലേക്ക് മാറ്റുക (ഇവ US തീയതികളാണ്, അതിനാൽ ഫോർമാറ്റ് `MM/DD/YYYY` ആണ്).\n",
"\n",
"2. തീയതികളിൽ നിന്ന് മാസം പുതിയ കോളത്തിലേക്ക് എടുക്കുക.\n",
"\n",
"R ൽ, [lubridate](https://lubridate.tidyverse.org/) പാക്കേജ് Date-time ഡാറ്റ കൈകാര്യം ചെയ്യാൻ എളുപ്പമാക്കുന്നു. അതിനാൽ, `dplyr::mutate()`, `lubridate::mdy()`, `lubridate::month()` ഉപയോഗിച്ച് മുകളിൽ പറഞ്ഞ ലക്ഷ്യങ്ങൾ എങ്ങനെ നേടാമെന്ന് നോക്കാം. പിന്നീട് പ്രവർത്തനങ്ങളിൽ Date കോളം ആവശ്യമില്ലാത്തതിനാൽ അത് ഒഴിവാക്കാം.\n"
],
"metadata": {
"id": "2KKo0Ed9Z1VB"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load lubridate\n",
"library(lubridate)\n",
"\n",
"pumpkins <- pumpkins %>% \n",
" # Convert the Date column to a date object\n",
" mutate(Date = mdy(Date)) %>% \n",
" # Extract month from Date\n",
" mutate(Month = month(Date)) %>% \n",
" # Drop Date column\n",
" select(-Date)\n",
"\n",
"# View the first few rows\n",
"pumpkins %>% \n",
" slice_head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "5joszIVSZ6xe"
}
},
{
"cell_type": "markdown",
"source": [
"വൂഹൂ! 🤩\n",
"\n",
"അടുത്തതായി, പംപ്കിന്റെ ശരാശരി വില പ്രതിനിധീകരിക്കുന്ന പുതിയ `Price` കോളം സൃഷ്ടിക്കാം. ഇപ്പോൾ, പുതിയ Price കോളം പൂരിപ്പിക്കാൻ `Low Price` ഉം `High Price` ഉം കോളങ്ങളിലെ ശരാശരി എടുക്കാം.\n",
"<br>\n"
],
"metadata": {
"id": "nIgLjNMCZ-6Y"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create a new column Price\n",
"pumpkins <- pumpkins %>% \n",
" mutate(Price = (`Low Price` + `High Price`)/2)\n",
"\n",
"# View the first few rows of the data\n",
"pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "Zo0BsqqtaJw2"
}
},
{
"cell_type": "markdown",
"source": [
"അതെ!💪\n",
"\n",
"\"എങ്കിലും കാത്തിരിക്കുക!\", നിങ്ങൾ `View(pumpkins)` ഉപയോഗിച്ച് മുഴുവൻ ഡാറ്റാ സെറ്റ് സ്കിം ചെയ്ത് നോക്കിയ ശേഷം പറയും, \"ഇവിടെ എന്തോ അസാധാരണമാണ്!\"🤔\n",
"\n",
"`Package` കോളം നോക്കിയാൽ, പംപ്കിനുകൾ പലവിധ കോൺഫിഗറേഷനുകളിൽ വിൽക്കപ്പെടുന്നു. ചിലത് `1 1/9 ബുഷെൽ` അളവിൽ, ചിലത് `1/2 ബുഷെൽ` അളവിൽ, ചിലത് ഓരോ പംപ്കിനും, ചിലത് ഓരോ പൗണ്ടിനും, ചിലത് വ്യത്യസ്ത വീതികളുള്ള വലിയ ബോക്സുകളിൽ വിൽക്കപ്പെടുന്നു.\n",
"\n",
"ഇത് പരിശോധിക്കാം:\n"
],
"metadata": {
"id": "p77WZr-9aQAR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Verify the distinct observations in Package column\n",
"pumpkins %>% \n",
" distinct(Package)"
],
"outputs": [],
"metadata": {
"id": "XISGfh0IaUy6"
}
},
{
"cell_type": "markdown",
"source": [
"അദ്ഭുതം!👏\n",
"\n",
"പമ്പ്കിനുകൾ സ്ഥിരമായി തൂക്കാൻ വളരെ കഠിനമാണെന്ന് തോന്നുന്നു, അതിനാൽ `Package` കോളത്തിൽ *bushel* എന്ന സ്ട്രിംഗ് ഉള്ള പമ്പ്കിനുകൾ മാത്രം തിരഞ്ഞെടുക്കുകയും ഇത് ഒരു പുതിയ ഡാറ്റാ ഫ്രെയിം `new_pumpkins` ആയി വെക്കുകയും ചെയ്യാം.\n",
"<br>\n"
],
"metadata": {
"id": "7sMjiVujaZxY"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::filter() and stringr::str_detect()\n",
"\n",
"[`dplyr::filter()`](https://dplyr.tidyverse.org/reference/filter.html): നിങ്ങളുടെ നിബന്ധനകൾ പാലിക്കുന്ന **പങ്കുകൾ** മാത്രം ഉൾക്കൊള്ളുന്ന ഡാറ്റയുടെ ഒരു ഉപസമൂഹം സൃഷ്ടിക്കുന്നു, ഈ കേസിൽ, `Package` കോളത്തിൽ *bushel* എന്ന സ്ട്രിംഗ് ഉള്ള പംപ്കിനുകൾ.\n",
"\n",
"[stringr::str_detect()](https://stringr.tidyverse.org/reference/str_detect.html): ഒരു സ്ട്രിംഗിൽ ഒരു പാറ്റേൺ ഉള്ളതോ ഇല്ലാതെയോ കണ്ടെത്തുന്നു.\n",
"\n",
"[`stringr`](https://github.com/tidyverse/stringr) പാക്കേജ് സാധാരണ സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾക്ക് ലളിതമായ ഫംഗ്ഷനുകൾ നൽകുന്നു.\n"
],
"metadata": {
"id": "L8Qfcs92ageF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Retain only pumpkins with \"bushel\"\n",
"new_pumpkins <- pumpkins %>% \n",
" filter(str_detect(Package, \"bushel\"))\n",
"\n",
"# Get the dimensions of the new data\n",
"dim(new_pumpkins)\n",
"\n",
"# View a few rows of the new data\n",
"new_pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "hy_SGYREampd"
}
},
{
"cell_type": "markdown",
"source": [
"നാം ബഷെൽ പ്രകാരം പംപ്കിനുകൾ അടങ്ങിയ ഏകദേശം 415 വരി ഡാറ്റയിലേക്ക് ചുരുക്കിയതായി നിങ്ങൾക്ക് കാണാം.🤩\n",
"<br>\n"
],
"metadata": {
"id": "VrDwF031avlR"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::case_when()\n",
"\n",
"**കാത്തിരിക്കുക! ചെയ്യേണ്ട മറ്റൊരു കാര്യം ഉണ്ട്**\n",
"\n",
"ബഷേൽ തുക ഓരോ വരിയിലും വ്യത്യസ്തമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചോ? 1 1/9 അല്ലെങ്കിൽ 1/2 ബഷേൽക്ക് പകരം ബഷേൽക്ക് തുക കാണിക്കാൻ വില സാധാരണമാക്കേണ്ടതുണ്ട്. ഇത് സാധാരണമാക്കാൻ കുറച്ച് ഗണിതം ചെയ്യേണ്ട സമയം.\n",
"\n",
"നാം ചില നിബന്ധനകളുടെ അടിസ്ഥാനത്തിൽ വില കോളം *മ്യൂട്ടേറ്റ്* ചെയ്യാൻ [`case_when()`](https://dplyr.tidyverse.org/reference/case_when.html) ഫംഗ്ഷൻ ഉപയോഗിക്കും. `case_when` നിങ്ങൾക്ക് പല `if_else()` പ്രസ്താവനകളും വെക്ടറൈസ് ചെയ്യാൻ അനുവദിക്കുന്നു.\n"
],
"metadata": {
"id": "mLpw2jH4a0tx"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Convert the price if the Package contains fractional bushel values\n",
"new_pumpkins <- new_pumpkins %>% \n",
" mutate(Price = case_when(\n",
" str_detect(Package, \"1 1/9\") ~ Price/(1 + 1/9),\n",
" str_detect(Package, \"1/2\") ~ Price/(1/2),\n",
" TRUE ~ Price))\n",
"\n",
"# View the first few rows of the data\n",
"new_pumpkins %>% \n",
" slice_head(n = 30)"
],
"outputs": [],
"metadata": {
"id": "P68kLVQmbM6I"
}
},
{
"cell_type": "markdown",
"source": [
"ഇപ്പോൾ, അവയുടെ ബഷെൽ അളവിന്റെ അടിസ്ഥാനത്തിൽ യൂണിറ്റ് വില വിശകലനം ചെയ്യാം. പക്ഷേ, പംപ്കിൻ ബഷെലുകളുടെ ഈ പഠനം, നിങ്ങളുടെ ഡാറ്റയുടെ സ്വഭാവം `അറിയുന്നത്` എത്രത്തോളം `പ്രധാനമാണ്` എന്ന് കാണിക്കുന്നു!\n",
"\n",
"> ✅ [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308) പ്രകാരം, ഒരു ബഷെലിന്റെ ഭാരം ഉൽപ്പന്നത്തിന്റെ തരം അനുസരിച്ച് വ്യത്യാസപ്പെടുന്നു, കാരണം ഇത് ഒരു വോളിയം അളവാണ്. \"ഉദാഹരണത്തിന്, ഒരു ബഷെൽ തക്കാളി 56 പൗണ്ട് ഭാരമുള്ളതായിരിക്കണം... ഇലകളും പച്ചക്കറികളും കുറവ് ഭാരത്തോടെ കൂടുതൽ സ്ഥലം പിടിക്കുന്നു, അതുകൊണ്ട് ഒരു ബഷെൽ സ്പിനാച്ച് വെറും 20 പൗണ്ട് മാത്രമാണ്.\" എല്ലാം വളരെ സങ്കീർണ്ണമാണ്! ബഷെൽ-ടു-പൗണ്ട് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കാതെ, ബഷെൽ അടിസ്ഥാനമാക്കി വില നിശ്ചയിക്കാം. പംപ്കിൻ ബഷെലുകളുടെ ഈ പഠനം, നിങ്ങളുടെ ഡാറ്റയുടെ സ്വഭാവം അറിയുന്നത് എത്രത്തോളം പ്രധാനമാണെന്ന് കാണിക്കുന്നു!\n",
">\n",
"> ✅ പംപ്കിനുകൾ അർദ്ധ-ബഷെൽ അടിസ്ഥാനത്തിൽ വിൽക്കുമ്പോൾ വളരെ വിലകൂടുതലാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചോ? എന്തുകൊണ്ടെന്ന് കണ്ടെത്താമോ? സൂചന: ചെറിയ പംപ്കിനുകൾ വലിയവയെക്കാൾ വളരെ വിലകൂടുതലാണ്, കാരണം ഒരു വലിയ പൊള്ളലുള്ള പൈ പംപ്കിൻ എടുത്തിടുന്ന ഉപയോഗിക്കാത്ത സ്ഥലത്തെ തുടർന്ന് ഒരു ബഷെലിൽ അവയുടെ എണ്ണം വളരെ കൂടുതലായിരിക്കും.\n",
"<br>\n"
],
"metadata": {
"id": "pS2GNPagbSdb"
}
},
{
"cell_type": "markdown",
"source": [
"ഇപ്പോൾ അവസാനം, സാഹസികതയ്ക്കായി 💁‍♀️, നമുക്ക് മാസത്തെ കോളം ആദ്യ സ്ഥാനത്തേക്ക് മാറ്റാം, അതായത് `Package` കോളത്തിന് മുമ്പ്.\n",
"\n",
"കോളം സ്ഥാനങ്ങൾ മാറ്റാൻ `dplyr::relocate()` ഉപയോഗിക്കുന്നു.\n"
],
"metadata": {
"id": "qql1SowfbdnP"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create a new data frame new_pumpkins\n",
"new_pumpkins <- new_pumpkins %>% \n",
" relocate(Month, .before = Package)\n",
"\n",
"new_pumpkins %>% \n",
" slice_head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "JJ1x6kw8bixF"
}
},
{
"cell_type": "markdown",
"source": [
"നല്ല ജോലി!👌 നിങ്ങൾക്ക് ഇപ്പോൾ ഒരു ശുചിത്വം പുലർത്തിയ, ക്രമീകരിച്ച ഡാറ്റാസെറ്റ് ലഭിച്ചു, അതിൽ നിങ്ങൾക്ക് നിങ്ങളുടെ പുതിയ റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കാം!\n",
"<br>\n"
],
"metadata": {
"id": "y8TJ0Za_bn5Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 4. ggplot2 ഉപയോഗിച്ച് ഡാറ്റാ ദൃശ്യീകരണം\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.ml.png\"\n",
" width=\"600\"/>\n",
" <figcaption>ഡസാനി മടിപള്ളി ഒരുക്കിയ ഇൻഫോഗ്രാഫിക്</figcaption>\n",
"\n",
"\n",
"<!--![Infographic by Dasani Madipalli](../../../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.ml.png){width=\"600\"}-->\n",
"\n",
"ഇങ്ങനെ ഒരു *ബുദ്ധിമുട്ടുള്ള* പ്രയോഗമുണ്ട്:\n",
"\n",
"> \"സാധാരണ ഗ്രാഫ് ഡാറ്റാ അനലിസ്റ്റിന്റെ മനസ്സിലേക്ക് മറ്റേതെങ്കിലും ഉപകരണത്തേക്കാൾ കൂടുതൽ വിവരങ്ങൾ കൊണ്ടുവന്നു.\" --- ജോൺ ടുക്കി\n",
"\n",
"ഡാറ്റാ സയന്റിസ്റ്റിന്റെ ഒരു ഭാഗം അവർ പ്രവർത്തിക്കുന്ന ഡാറ്റയുടെ ഗുണമേന്മയും സ്വഭാവവും പ്രദർശിപ്പിക്കുകയാണ്. ഇതിന്, അവർ പലപ്പോഴും രസകരമായ ദൃശ്യീകരണങ്ങൾ, അല്ലെങ്കിൽ പ്ലോട്ടുകൾ, ഗ്രാഫുകൾ, ചാർട്ടുകൾ സൃഷ്ടിക്കുന്നു, ഡാറ്റയുടെ വ്യത്യസ്ത വശങ്ങൾ കാണിക്കുന്ന. ഈ രീതിയിൽ, അവർ ദൃശ്യമായി ബന്ധങ്ങളും ഇടവേളകളും കാണിക്കാൻ കഴിയും, സാധാരണയായി കണ്ടെത്താൻ ബുദ്ധിമുട്ടുള്ളവ.\n",
"\n",
"ദൃശ്യീകരണങ്ങൾ ഡാറ്റയ്ക്ക് ഏറ്റവും അനുയോജ്യമായ മെഷീൻ ലേണിംഗ് സാങ്കേതിക വിദ്യ നിർണ്ണയിക്കുന്നതിനും സഹായിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ലൈനിനെ പിന്തുടരുന്ന പോലെ തോന്നുന്ന സ്കാറ്റർപ്ലോട്ട്, ഡാറ്റ ലീനിയർ റെഗ്രഷൻ അഭ്യാസത്തിന് നല്ല സ്ഥാനാർത്ഥിയാണെന്ന് സൂചിപ്പിക്കുന്നു.\n",
"\n",
"R ഗ്രാഫുകൾ സൃഷ്ടിക്കാൻ നിരവധി സിസ്റ്റങ്ങൾ നൽകുന്നു, പക്ഷേ [`ggplot2`](https://ggplot2.tidyverse.org/index.html) ഏറ്റവും സുന്ദരവും ബഹുമുഖവുമാണ്. `ggplot2` നിങ്ങൾക്ക് **സ്വതന്ത്ര ഘടകങ്ങൾ സംയോജിപ്പിച്ച്** ഗ്രാഫുകൾ രൂപകൽപ്പന ചെയ്യാൻ അനുവദിക്കുന്നു.\n",
"\n",
"Price, Month കോളങ്ങളിലേക്കുള്ള ഒരു ലളിതമായ സ്കാറ്റർ പ്ലോട്ടിൽ നിന്ന് തുടങ്ങാം.\n",
"\n",
"ഇതിനായി, നാം [`ggplot()`](https://ggplot2.tidyverse.org/reference/ggplot.html) ഉപയോഗിച്ച് ഒരു ഡാറ്റാസെറ്റ്, എസ്റ്ററ്റിക് മാപ്പിംഗ് ( [`aes()`](https://ggplot2.tidyverse.org/reference/aes.html) ഉപയോഗിച്ച്) നൽകുകയും, സ്കാറ്റർ പ്ലോട്ടുകൾക്കായി [`geom_point()`](https://ggplot2.tidyverse.org/reference/geom_point.html) പോലുള്ള ലെയറുകൾ ചേർക്കുകയും ചെയ്യും.\n"
],
"metadata": {
"id": "mYSH6-EtbvNa"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Set a theme for the plots\n",
"theme_set(theme_light())\n",
"\n",
"# Create a scatter plot\n",
"p <- ggplot(data = new_pumpkins, aes(x = Price, y = Month))\n",
"p + geom_point()"
],
"outputs": [],
"metadata": {
"id": "g2YjnGeOcLo4"
}
},
{
"cell_type": "markdown",
"source": [
"ഇത് ഒരു ഉപകാരപ്രദമായ പ്ലോട്ട് ആണോ 🤷? ഇതിൽ നിന്നു നിങ്ങൾക്ക് എന്തെങ്കിലും അത്ഭുതം ഉണ്ടോ?\n",
"\n",
"ഇത് പ്രത്യേകിച്ച് ഉപകാരപ്രദമല്ല, കാരണം ഇത് ചെയ്യുന്നത് നിങ്ങളുടെ ഡാറ്റ ഒരു നൽകിയ മാസത്തിലെ പോയിന്റുകളുടെ വ്യാപ്തിയായി പ്രദർശിപ്പിക്കുകയാണ്.\n",
"<br>\n"
],
"metadata": {
"id": "Ml7SDCLQcPvE"
}
},
{
"cell_type": "markdown",
"source": [
"### **നാം ഇത് എങ്ങനെ പ്രയോജനപ്പെടുത്താം?**\n",
"\n",
"ചാർട്ടുകളിൽ പ്രയോജനകരമായ ഡാറ്റ പ്രദർശിപ്പിക്കാൻ, സാധാരണയായി ഡാറ്റയെ ഏതെങ്കിലും വിധത്തിൽ ഗ്രൂപ്പ് ചെയ്യേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, നമ്മുടെ കേസിൽ, ഓരോ മാസത്തിനും പംപ്കിൻസിന്റെ ശരാശരി വില കണ്ടെത്തുന്നത് നമ്മുടെ ഡാറ്റയിലെ അടിസ്ഥിത പാറ്റേണുകൾക്കു കൂടുതൽ洞察ങ്ങൾ നൽകും. ഇത് നമ്മെ മറ്റൊരു **dplyr** ഫ്ലൈബൈയിലേക്ക് നയിക്കുന്നു:\n",
"\n",
"#### `dplyr::group_by() %>% summarize()`\n",
"\n",
"R-ൽ ഗ്രൂപ്പ് ചെയ്ത ആഗ്രിഗേഷൻ എളുപ്പത്തിൽ കണക്കാക്കാൻ കഴിയും\n",
"\n",
"`dplyr::group_by() %>% summarize()`\n",
"\n",
"- `dplyr::group_by()` പൂർണ്ണ ഡാറ്റാസെറ്റിൽ നിന്നുള്ള വിശകലന യൂണിറ്റ് ഓരോ ഗ്രൂപ്പുകളിലേക്കു മാറ്റുന്നു, ഉദാഹരണത്തിന് ഓരോ മാസം.\n",
"\n",
"- `dplyr::summarize()` നിങ്ങൾ നിർദ്ദേശിച്ച സംഗ്രഹ സാങ്കേതികവിദ്യകൾക്കായി ഓരോ ഗ്രൂപ്പിംഗ് വേരിയബിളിനും ഒരു കോളവും ഓരോ സംഗ്രഹ സാങ്കേതികവിദ്യയ്ക്കും ഒരു കോളവും ഉള്ള പുതിയ ഡാറ്റാ ഫ്രെയിം സൃഷ്ടിക്കുന്നു.\n",
"\n",
"ഉദാഹരണത്തിന്, `dplyr::group_by() %>% summarize()` ഉപയോഗിച്ച് പംപ്കിൻസിനെ **മാസം** കോളം അടിസ്ഥാനമാക്കി ഗ്രൂപ്പാക്കി, ഓരോ മാസത്തിനും **ശരാശരി വില** കണ്ടെത്താം.\n"
],
"metadata": {
"id": "jMakvJZIcVkh"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the average price of pumpkins per month\r\n",
"new_pumpkins %>%\r\n",
" group_by(Month) %>% \r\n",
" summarise(mean_price = mean(Price))"
],
"outputs": [],
"metadata": {
"id": "6kVSUa2Bcilf"
}
},
{
"cell_type": "markdown",
"source": [
"സംക്ഷിപ്തം!✨\n",
"\n",
"മാസങ്ങൾ പോലുള്ള വർഗ്ഗീയ സവിശേഷതകൾ ബാർ പ്ലോട്ട് 📊 ഉപയോഗിച്ച് മികച്ച രീതിയിൽ പ്രതിനിധീകരിക്കാം. ബാർ ചാർട്ടുകൾക്ക് ഉത്തരവാദിയായ ലെയറുകൾ `geom_bar()` ഉം `geom_col()` ഉം ആണ്. കൂടുതൽ അറിയാൻ `?geom_bar` കാണുക.\n",
"\n",
"ഒന്ന് തയ്യാറാക്കാം!\n"
],
"metadata": {
"id": "Kds48GUBcj3W"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the average price of pumpkins per month then plot a bar chart\r\n",
"new_pumpkins %>%\r\n",
" group_by(Month) %>% \r\n",
" summarise(mean_price = mean(Price)) %>% \r\n",
" ggplot(aes(x = Month, y = mean_price)) +\r\n",
" geom_col(fill = \"midnightblue\", alpha = 0.7) +\r\n",
" ylab(\"Pumpkin Price\")"
],
"outputs": [],
"metadata": {
"id": "VNbU1S3BcrxO"
}
},
{
"cell_type": "markdown",
"source": [
"🤩🤩ഇത് കൂടുതൽ പ്രയോജനകരമായ ഡാറ്റാ ദൃശ്യീകരണമാണ്! പംപ്കിനുകളുടെ ഏറ്റവും ഉയർന്ന വില സെപ്റ്റംബർ, ഒക്ടോബർ മാസങ്ങളിൽ ഉണ്ടാകുമെന്ന് ഇത് സൂചിപ്പിക്കുന്ന 듯യുണ്ട്. ഇത് നിങ്ങളുടെ പ്രതീക്ഷയ്ക്ക് അനുയോജ്യമാണോ? എന്തുകൊണ്ട് അല്ലെങ്കിൽ എന്തുകൊണ്ട്?\n",
"\n",
"രണ്ടാം പാഠം പൂർത്തിയാക്കിയതിന് അഭിനന്ദനങ്ങൾ 👏! നിങ്ങൾ മോഡൽ നിർമ്മാണത്തിനായി നിങ്ങളുടെ ഡാറ്റ തയ്യാറാക്കി, പിന്നീട് ദൃശ്യീകരണങ്ങൾ ഉപയോഗിച്ച് കൂടുതൽ洞察ങ്ങൾ കണ്ടെത്തി!\n"
],
"metadata": {
"id": "zDm0VOzzcuzR"
}
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

439
translations/ml/2-Regression/2-Data/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

383
translations/ml/2-Regression/3-Linear/README.md
Unescape View File

@ -0,0 +1,383 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
"translation_date": "2025-12-19T13:48:41+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "ml"
}
-->
# Scikit-learn ഉപയോഗിച്ച് ഒരു റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: റെഗ്രഷൻ നാല് രീതികൾ
![Linear vs polynomial regression infographic](../../../../translated_images/linear-polynomial.5523c7cb6576ccab0fecbd0e3505986eb2d191d9378e785f82befcf3a578a6e7.ml.png)
> ഇൻഫോഗ്രാഫിക് [ദസാനി മടിപള്ളി](https://twitter.com/dasani_decoded) tarafından
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
> ### [ഈ പാഠം R-ൽ ലഭ്യമാണ്!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### പരിചയം
ഇതുവരെ നിങ്ങൾ റെഗ്രഷൻ എന്താണെന്ന് പംപ്കിൻ വില നിർണ്ണയ ഡാറ്റാസെറ്റിൽ നിന്നുള്ള സാമ്പിൾ ഡാറ്റ ഉപയോഗിച്ച് പരിശോധിച്ചിട്ടുണ്ട്, ഇത് ഈ പാഠത്തിൽ മുഴുവൻ ഉപയോഗിക്കും. നിങ്ങൾ Matplotlib ഉപയോഗിച്ച് അതിനെ ദൃശ്യവൽക്കരിക്കുകയും ചെയ്തു.
ഇപ്പോൾ നിങ്ങൾ 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")
> 🎥 ലീനിയർ റെഗ്രഷന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
> ഈ പാഠ്യപദ്ധതിയിൽ, ഗണിതത്തിൽ കുറഞ്ഞ പരിജ്ഞാനം ഉള്ളവർക്കും മറ്റ് മേഖലകളിൽ നിന്നുള്ള വിദ്യാർത്ഥികൾക്കും ഇത് സുലഭമാക്കാൻ ശ്രമിക്കുന്നു, അതിനാൽ കുറിപ്പുകൾ, 🧮 വിളിപ്പുകൾ, ചിത്രങ്ങൾ, മറ്റ് പഠന ഉപകരണങ്ങൾ ശ്രദ്ധിക്കുക.
### മുൻപരിചയം
നിങ്ങൾ ഇപ്പോൾ പരിശോധിക്കുന്ന പംപ്കിൻ ഡാറ്റയുടെ ഘടനയിൽ പരിചിതനാകണം. ഈ പാഠത്തിലെ _notebook.ipynb_ ഫയലിൽ ഇത് മുൻകൂട്ടി ലോഡ് ചെയ്ത് ശുദ്ധീകരിച്ചിരിക്കുന്നു. ഫയലിൽ, പംപ്കിൻ വില ബുഷെൽപ്രതി പുതിയ ഡാറ്റാ ഫ്രെയിമിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു. Visual Studio Code-ൽ കർണലുകളിൽ ഈ നോട്ട്‌ബുക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.
### തയ്യാറെടുപ്പ്
ഓർമ്മപ്പെടുത്തലായി, നിങ്ങൾ ഈ ഡാറ്റ ലോഡ് ചെയ്യുന്നത് അതിൽ നിന്ന് ചോദ്യങ്ങൾ ചോദിക്കാൻ ആണ്.
- പംപ്കിനുകൾ വാങ്ങാൻ ഏറ്റവും നല്ല സമയം എപ്പോൾ?
- ഒരു കേസ് മിനിയേച്ചർ പംപ്കിനുകളുടെ വില എത്ര പ്രതീക്ഷിക്കാം?
- അവയെ അർദ്ധ ബുഷെൽ ബാസ്കറ്റുകളിൽ വാങ്ങണോ, 1 1/9 ബുഷെൽ ബോക്സിൽ വാങ്ങണോ?
നാം ഈ ഡാറ്റയിൽ കൂടുതൽ തിരയാം.
മുൻ പാഠത്തിൽ, നിങ്ങൾ ഒരു Pandas ഡാറ്റാ ഫ്രെയിം സൃഷ്ടിച്ച് അതിൽ യഥാർത്ഥ ഡാറ്റാസെറ്റിന്റെ ഭാഗം ഉൾപ്പെടുത്തി, വില ബുഷെൽപ്രതി സ്റ്റാൻഡേർഡൈസ് ചെയ്തു. എന്നാൽ, അങ്ങനെ ചെയ്തപ്പോൾ, ഏകദേശം 400 ഡാറ്റാപോയിന്റുകൾ മാത്രമേ ലഭിച്ചുള്ളൂ, അത് പോലും പകുതിമാസങ്ങളിൽ മാത്രം.
ഈ പാഠത്തിലെ അനുബന്ധ നോട്ട്‌ബുക്കിൽ മുൻകൂട്ടി ലോഡ് ചെയ്ത ഡാറ്റ നോക്കുക. ഡാറ്റ മുൻകൂട്ടി ലോഡ് ചെയ്തിട്ടുണ്ട്, ഒരു പ്രാഥമിക സ്കാറ്റർപ്ലോട്ട് മാസത്തെ ഡാറ്റ കാണിക്കാൻ വരച്ചിട്ടുണ്ട്. ഡാറ്റയുടെ സ്വഭാവത്തെ കുറിച്ച് കൂടുതൽ വിശദാംശങ്ങൾ ലഭിക്കാൻ കൂടുതൽ ശുദ്ധീകരണം നടത്താമോ എന്ന് നോക്കാം.
## ഒരു ലീനിയർ റെഗ്രഷൻ രേഖ
പാഠം 1-ൽ നിങ്ങൾ പഠിച്ച പോലെ, ഒരു ലീനിയർ റെഗ്രഷൻ അഭ്യാസത്തിന്റെ ലക്ഷ്യം ഒരു രേഖ വരയ്ക്കാനാകണം:
- **വേരിയബിൾ ബന്ധങ്ങൾ കാണിക്കുക**. വേരിയബിൾകളുടെ ബന്ധം കാണിക്കുക
- **പ്രവചനങ്ങൾ നടത്തുക**. ആ രേഖയുമായി ബന്ധപ്പെട്ട് പുതിയ ഡാറ്റാപോയിന്റ് എവിടെ വരും എന്ന് കൃത്യമായി പ്രവചിക്കുക.
**ലീസ്റ്റ്-സ്ക്വയർസ് റെഗ്രഷൻ** സാധാരണയായി ഇത്തരത്തിലുള്ള രേഖ വരയ്ക്കുന്നു. 'ലീസ്റ്റ്-സ്ക്വയർസ്' എന്ന പദം അർത്ഥമാക്കുന്നത്, റെഗ്രഷൻ രേഖ ചുറ്റിപ്പറ്റിയ എല്ലാ ഡാറ്റാപോയിന്റുകളും സ്ക്വയർ ചെയ്ത് കൂട്ടിച്ചേർക്കുന്നു എന്നതാണ്. ആകെ തുക όσο ചെറിയതായിരിക്കും, അത്ര നല്ലതാണ്, കാരണം ഞങ്ങൾ കുറവ് പിശകുകൾ (least-squares) ആഗ്രഹിക്കുന്നു.
ഞങ്ങൾ ഒരു രേഖ മോഡൽ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു, അത് എല്ലാ ഡാറ്റാപോയിന്റുകളുടെയും കൂറ്റൻ ദൂരം ഏറ്റവും കുറവായിരിക്കും. കൂടാതെ, ദിശയേക്കാൾ അതിന്റെ വലിപ്പം (മാഗ്നിറ്റ്യൂഡ്) പ്രധാനമാണെന്ന് കണക്കിലെടുത്ത് സ്ക്വയർ ചെയ്യുന്നു.
> **🧮 ഗണിതം കാണിക്കുക**
>
> ഈ രേഖ, _ബെസ്റ്റ് ഫിറ്റ് ലൈന_ എന്ന് വിളിക്കപ്പെടുന്നത്, [ഒരു സമവാക്യത്തിലൂടെ](https://en.wikipedia.org/wiki/Simple_linear_regression) പ്രകടിപ്പിക്കാം:
>
> ```
> Y = a + bX
> ```
>
> `X` 'വ്യാഖ്യാന വേരിയബിൾ' ആണ്. `Y` 'അനുഭവ വേരിയബിൾ' ആണ്. രേഖയുടെ സ്ലോപ്പ് `b` ആണ്, `a` y-ഇന്റർസെപ്റ്റ് ആണ്, അതായത് `X = 0` ആയപ്പോൾ `Y` യുടെ മൂല്യം.
>
>![സ്ലോപ്പ് കണക്കാക്കുക](../../../../translated_images/slope.f3c9d5910ddbfcf9096eb5564254ba22c9a32d7acd7694cab905d29ad8261db3.ml.png)
>
> ആദ്യം സ്ലോപ്പ് `b` കണക്കാക്കുക. ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
>
> മറ്റൊരു വാക്കിൽ, പംപ്കിൻ ഡാറ്റയുടെ യഥാർത്ഥ ചോദ്യത്തെ ആശ്രയിച്ച്: "മാസംപ്രതി പംപ്കിൻ വില പ്രവചിക്കുക", `X` വിലയെ സൂചിപ്പിക്കും, `Y` വിൽപ്പന മാസത്തെ സൂചിപ്പിക്കും.
>
>![സമവാക്യം പൂർത്തിയാക്കുക](../../../../translated_images/calculation.a209813050a1ddb141cdc4bc56f3af31e67157ed499e16a2ecf9837542704c94.ml.png)
>
> Y-യുടെ മൂല്യം കണക്കാക്കുക. നിങ്ങൾ ഏകദേശം $4 നൽകുകയാണെങ്കിൽ, അത് ഏപ്രിൽ ആയിരിക്കണം! ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
>
> രേഖയുടെ സ്ലോപ്പ് കണക്കാക്കുന്ന ഗണിതം, ഇന്റർസെപ്റ്റിനും ആശ്രയിച്ചിരിക്കുന്നു, അതായത് `X = 0` ആയപ്പോൾ `Y` എവിടെയാണ് എന്നതും.
>
> ഈ മൂല്യങ്ങൾ കണക്കാക്കുന്ന രീതി [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) വെബ്സൈറ്റിൽ കാണാം. കൂടാതെ [ഈ Least-squares കാൽക്കുലേറ്റർ](https://www.mathsisfun.com/data/least-squares-calculator.html) സന്ദർശിച്ച് സംഖ്യകളുടെ മൂല്യങ്ങൾ രേഖയെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് കാണാം.
## സഹസംബന്ധം
മറ്റൊരു പദം മനസ്സിലാക്കേണ്ടത് **സഹസംബന്ധ കോഫിഷ്യന്റ്** ആണ്, നൽകിയ X, Y വേരിയബിൾക്കിടയിലെ. സ്കാറ്റർപ്ലോട്ട് ഉപയോഗിച്ച് ഈ കോഫിഷ്യന്റ് എളുപ്പത്തിൽ ദൃശ്യവൽക്കരിക്കാം. ഡാറ്റാപോയിന്റുകൾ ഒരു സുതാര്യമായ രേഖയിൽ പടർന്നാൽ ഉയർന്ന സഹസംബന്ധം ഉണ്ട്, എന്നാൽ ഡാറ്റാപോയിന്റുകൾ 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)
```
ലീനിയർ റെഗ്രഷന്റെ പിന്നിലെ ഗണിതം മനസ്സിലാക്കിയതിനു ശേഷം, പംപ്കിൻ പാക്കേജുകളുടെ വില ഏറ്റവും നല്ലത് ഏതാണ് എന്ന് പ്രവചിക്കാൻ ഒരു റെഗ്രഷൻ മോഡൽ സൃഷ്ടിക്കാം. അവധി പംപ്കിൻ പാച്ചിനായി പംപ്കിനുകൾ വാങ്ങുന്നവർക്ക് ഈ വിവരം അവരുടെ വാങ്ങലുകൾ മെച്ചപ്പെടുത്താൻ സഹായിക്കും.
## സഹസംബന്ധം അന്വേഷിക്കൽ
[![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")
> 🎥 സഹസംബന്ധത്തിന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
മുൻ പാഠത്തിൽ നിങ്ങൾ കണ്ടതുപോലെ, വ്യത്യസ്ത മാസങ്ങളിലെ ശരാശരി വില ഇങ്ങനെ കാണപ്പെടുന്നു:
<img alt="Average price by month" src="../../../../translated_images/barchart.a833ea9194346d769c77a3a870f7d8aee51574cd1138ca902e5500830a41cbce.ml.png" width="50%"/>
ഇത് ചില സഹസംബന്ധം ഉണ്ടാകുമെന്ന് സൂചിപ്പിക്കുന്നു, നാം ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിച്ച് `Month`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം പ്രവചിക്കാം, അല്ലെങ്കിൽ `DayOfYear`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം. താഴെ കാണുന്ന സ്കാറ്റർപ്ലോട്ട് രണ്ടാം ബന്ധം കാണിക്കുന്നു:
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/scatter-dayofyear.bc171c189c9fd553fe93030180b9c00ed123148a577640e4d7481c4c01811972.ml.png" width="50%" />
`corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് സഹസംബന്ധം പരിശോധിക്കാം:
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
സഹസംബന്ധം വളരെ ചെറിയതാണ്, `Month`-നായി -0.15, `DayOfMonth`-നായി -0.17, എന്നാൽ മറ്റൊരു പ്രധാന ബന്ധം ഉണ്ടാകാം. വ്യത്യസ്ത പംപ്കിൻ വർഗ്ഗങ്ങൾക്ക് വ്യത്യസ്ത വില ക്ലസ്റ്ററുകൾ ഉണ്ടെന്ന് തോന്നുന്നു. ഈ സിദ്ധാന്തം സ്ഥിരീകരിക്കാൻ, ഓരോ പംപ്കിൻ വിഭാഗവും വ്യത്യസ്ത നിറത്തിൽ സ്കാറ്റർ പ്ലോട്ട് ചെയ്യാം. `scatter` ഫംഗ്ഷനിൽ `ax` പാരാമീറ്റർ നൽകി എല്ലാ പോയിന്റുകളും ഒരേ ഗ്രാഫിൽ വരയ്ക്കാം:
```python
ax=None
colors = ['red','blue','green','yellow']
for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/scatter-dayofyear-color.65790faefbb9d54fb8f6223c566c445b9fac58a1c15f41f8641c3842af9d548b.ml.png" width="50%" />
നമ്മുടെ പരിശോധന പ്രകാരം, പംപ്കിൻ വർഗ്ഗം വിൽപ്പന തീയതിയേക്കാൾ വിലയിൽ കൂടുതൽ സ്വാധീനം ചെലുത്തുന്നു. ഇത് ഒരു ബാർ ഗ്രാഫിൽ കാണാം:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
<img alt="Bar graph of price vs variety" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb43a9a8c69469ce2520c9524fabfa270b1b2422cc2450d6d11.ml.png" width="50%" />
ഇപ്പോൾ നാം 'പൈ ടൈപ്പ്' എന്ന ഒരു പംപ്കിൻ വർഗ്ഗത്തിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിച്ച്, തീയതി വിലയിൽ എങ്ങനെ സ്വാധീനം ചെലുത്തുന്നു എന്ന് നോക്കാം:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/pie-pumpkins-scatter.d14f9804a53f927e7fe39aa072486f4ed1bdd7f31c8bb08f476855f4b02350c3.ml.png" width="50%" />
`Price`-നും `DayOfYear`-നും ഇടയിലെ സഹസംബന്ധം `corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് കണക്കാക്കുമ്പോൾ, ഏകദേശം `-0.27` കിട്ടും - ഇത് പ്രവചന മോഡൽ പരിശീലിപ്പിക്കുന്നത് യുക്തിയുള്ളതാണെന്ന് സൂചിപ്പിക്കുന്നു.
> ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നതിന് മുമ്പ്, ഡാറ്റ ശുദ്ധമാണെന്ന് ഉറപ്പാക്കുക. ലീനിയർ റെഗ്രഷൻ നഷ്ടപ്പെട്ട മൂല്യങ്ങളോടൊപ്പം നല്ല രീതിയിൽ പ്രവർത്തിക്കാറില്ല, അതിനാൽ എല്ലാ ശൂന്യ സെല്ലുകളും നീക്കം ചെയ്യുന്നത് ഉചിതമാണ്:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
മറ്റൊരു സമീപനം, ആ ശൂന്യ മൂല്യങ്ങളെ അനുയോജ്യമായ കോളത്തിന്റെ ശരാശരി മൂല്യത്തോടെ പൂരിപ്പിക്കലായിരിക്കും.
## ലളിത ലീനിയർ റെഗ്രഷൻ
[![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 ലീനിയർ, പോളിനോമിയൽ റെഗ്രഷൻ എന്നിവയുടെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
നമ്മുടെ ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കാൻ, **Scikit-learn** ലൈബ്രറി ഉപയോഗിക്കും.
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
ആദ്യമായി, ഇൻപുട്ട് മൂല്യങ്ങൾ (ഫീച്ചറുകൾ)യും പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ട് (ലേബൽ)യും വേർതിരിച്ച് numpy അറേകളായി മാറ്റുന്നു:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> ലീനിയർ റെഗ്രഷൻ പാക്കേജ് ശരിയായി മനസ്സിലാക്കാൻ ഇൻപുട്ട് ഡാറ്റയിൽ `reshape` നിർബന്ധമായിരുന്നു. ലീനിയർ റെഗ്രഷൻ 2D അറേയെ ഇൻപുട്ടായി പ്രതീക്ഷിക്കുന്നു, ഓരോ വരിയും ഇൻപുട്ട് ഫീച്ചറുകളുടെ വെക്ടറിനോട് അനുബന്ധിക്കുന്നു. നമ്മുടെ കേസിൽ, ഒരു ഇൻപുട്ട് മാത്രമുണ്ടെങ്കിൽ, N×1 ആകൃതിയിലുള്ള അറേ വേണം, ഇവിടെ N ഡാറ്റാസെറ്റിന്റെ വലുപ്പമാണ്.
അതിനുശേഷം, ഡാറ്റ ട്രെയിൻ, ടെസ്റ്റ് ഡാറ്റാസെറ്റുകളായി വിഭജിക്കണം, മോഡൽ പരിശീലിപ്പിച്ചതിനു ശേഷം അത് പരിശോധിക്കാൻ:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
അവസാനമായി, ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നത് രണ്ട് കോഡ് വരികളിൽ മാത്രമാണ്. `LinearRegression` ഒബ്ജക്റ്റ് നിർവചിച്ച്, `fit` മെത്തഡ് ഉപയോഗിച്ച് ഡാറ്റയിൽ ഫിറ്റ് ചെയ്യുന്നു:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
`fit` ചെയ്ത ശേഷം `LinearRegression` ഒബ്ജക്റ്റിൽ റെഗ്രഷന്റെ എല്ലാ കോഫിഷ്യന്റുകളും `.coef_` പ്രോപ്പർട്ടി വഴി ലഭ്യമാണ്. നമ്മുടെ കേസിൽ, ഏക കോഫിഷ്യന്റ് മാത്രമേ ഉണ്ടാകൂ, ഏകദേശം `-0.017`. ഇത് വിലകൾ സമയം കൂടുമ്പോൾ കുറയുന്നു എന്ന് സൂചിപ്പിക്കുന്നു, ഏകദേശം ദിവസത്തിൽ 2 സെന്റ്. Y-അക്ഷത്തോടുള്ള റെഗ്രഷൻ രേഖയുടെ ഇന്റർസെപ്റ്റ് `lin_reg.intercept_` ഉപയോഗിച്ച് ലഭിക്കും - ഇത് ഏകദേശം `21` ആയിരിക്കും, വർഷം ആരംഭത്തിലെ വില സൂചിപ്പിക്കുന്നു.
നമ്മുടെ മോഡൽ എത്രത്തോളം കൃത്യമാണെന്ന് കാണാൻ, നാം ഒരു ടെസ്റ്റ് ഡാറ്റാസെറ്റിൽ വിലകൾ പ്രവചിച്ച്, പിന്നീട് നമ്മുടെ പ്രവചനങ്ങൾ പ്രതീക്ഷിച്ച മൂല്യങ്ങളോട് എത്രത്തോളം അടുത്തുവെന്ന് അളക്കാം. ഇത് ചെയ്യാൻ സാധിക്കുന്നത് മീൻ സ്ക്വയർ എറർ (MSE) മെട്രിക്‌സ് ഉപയോഗിച്ച് ആണ്, ഇത് പ്രതീക്ഷിച്ച മൂല്യവും പ്രവചിച്ച മൂല്യവും തമ്മിലുള്ള എല്ലാ സ്ക്വയർ ചെയ്ത വ്യത്യാസങ്ങളുടെ ശരാശരിയാണ്.
```python
pred = lin_reg.predict(X_test)
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
```
നമ്മുടെ പിശക് ഏകദേശം 2 പോയിന്റ് ചുറ്റും ആണ്, അത് ~17% ആണ്. വളരെ നല്ലതല്ല. മോഡൽ ഗുണനിലവാരത്തിന്റെ മറ്റൊരു സൂചികയാണ് **നിർണ്ണയ ഘടകം** (coefficient of determination), ഇത് ഇങ്ങനെ ലഭിക്കും:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
മൂല്യം 0 ആണെങ്കിൽ, മോഡൽ ഇൻപുട്ട് ഡാറ്റ പരിഗണിക്കാതെ *ഏറ്റവും മോശം ലീനിയർ പ്രവചകൻ* ആയി പ്രവർത്തിക്കുന്നു, അത് ഫലത്തിന്റെ ശരാശരിയാണ്. മൂല്യം 1 ആണെങ്കിൽ, നാം എല്ലാ പ്രതീക്ഷിച്ച ഔട്ട്പുട്ടുകളും പൂർണ്ണമായി പ്രവചിക്കാനാകും. നമ്മുടെ കേസിൽ, നിർണ്ണയ ഘടകം ഏകദേശം 0.06 ആണ്, ഇത് വളരെ കുറവാണ്.
റിഗ്രഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നന്നായി കാണാൻ, ടെസ്റ്റ് ഡാറ്റയും റിഗ്രഷൻ ലൈനും ചേർന്ന് പ്ലോട്ട് ചെയ്യാം:
```python
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
<img alt="Linear regression" src="../../../../translated_images/linear-results.f7c3552c85b0ed1ce2808276c870656733f6878c8fd37ec220812ee77686c3ef.ml.png" width="50%" />
## പോളിനോമിയൽ റിഗ്രഷൻ
ലീനിയർ റിഗ്രഷന്റെ മറ്റൊരു തരം പോളിനോമിയൽ റിഗ്രഷനാണ്. ചിലപ്പോൾ വേരിയബിളുകൾക്കിടയിൽ ലീനിയർ ബന്ധമുണ്ടാകാം - വോളിയം കൂടുതലായ പംപ്കിൻ വില കൂടുതലായിരിക്കും - എന്നാൽ ചിലപ്പോൾ ഈ ബന്ധങ്ങൾ ഒരു സമതലമോ നേരിയ ലൈനോ ആയി ചിത്രീകരിക്കാൻ കഴിയില്ല.
✅ ഇവിടെ [കൂടുതൽ ഉദാഹരണങ്ങൾ](https://online.stat.psu.edu/stat501/lesson/9/9.8) ഉണ്ട്, പോളിനോമിയൽ റിഗ്രഷൻ ഉപയോഗിക്കാവുന്ന ഡാറ്റയുടെ.
തീയതി (Date)യും വിലയും (Price)യും തമ്മിലുള്ള ബന്ധം വീണ്ടും നോക്കൂ. ഈ സ്കാറ്റർപ്ലോട്ട് ഒരു നേരിയ ലൈനിലൂടെ വിശകലനം ചെയ്യേണ്ടതുണ്ടോ? വിലകൾ മാറാറില്ലേ? ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ പോളിനോമിയൽ റിഗ്രഷൻ പരീക്ഷിക്കാം.
✅ പോളിനോമിയലുകൾ ഒരു അല്ലെങ്കിൽ കൂടുതൽ വേരിയബിളുകളും കോഫിഷ്യന്റുകളും അടങ്ങിയ ഗണിതപരമായ പ്രകടനങ്ങളാണ്.
പോളിനോമിയൽ റിഗ്രഷൻ nonlinear ഡാറ്റയ്ക്ക് മികച്ച അനുയോജ്യമായ വളഞ്ഞ ലൈനുണ്ടാക്കുന്നു. നമ്മുടെ കേസിൽ, `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 സൃഷ്ടിക്കും:
```python
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
`PolynomialFeatures(2)` ഉപയോഗിക്കുന്നത്, ഇൻപുട്ട് ഡാറ്റയിലെ എല്ലാ രണ്ടാം-ഡിഗ്രി പോളിനോമിയലുകളും ഉൾപ്പെടുത്തുമെന്ന് അർത്ഥം. നമ്മുടെ കേസിൽ ഇത് `DayOfYear`<sup>2</sup> മാത്രമാണ്, പക്ഷേ രണ്ട് ഇൻപുട്ട് വേരിയബിളുകൾ X, Y ഉണ്ടെങ്കിൽ, ഇത് X<sup>2</sup>, XY, Y<sup>2</sup> എന്നിവ ചേർക്കും. കൂടുതൽ ഡിഗ്രി പോളിനോമിയലുകളും ഉപയോഗിക്കാം.
Pipeline-കൾ ആദ്യം ഉപയോഗിച്ച `LinearRegression` ഒബ്ജക്റ്റ് പോലെ തന്നെ ഉപയോഗിക്കാം, അഥവാ pipeline-നെ `fit` ചെയ്ത്, പിന്നീട് `predict` ഉപയോഗിച്ച് പ്രവചന ഫലങ്ങൾ നേടാം. ടെസ്റ്റ് ഡാറ്റയും അനുമാന വളഞ്ഞ ലൈനും കാണിക്കുന്ന ഗ്രാഫ് ഇതാ:
<img alt="Polynomial regression" src="../../../../translated_images/poly-results.ee587348f0f1f60bd16c471321b0b2f2457d0eaa99d99ec0ced4affc900fa96c.ml.png" width="50%" />
പോളിനോമിയൽ റിഗ്രഷൻ ഉപയോഗിച്ച്, നാം കുറച്ച് താഴ്ന്ന MSEയും ഉയർന്ന നിർണ്ണയ ഘടകവും നേടാം, പക്ഷേ വലിയ വ്യത്യാസമില്ല. മറ്റ് ഫീച്ചറുകളും പരിഗണിക്കേണ്ടതാണ്!
> നിങ്ങൾക്ക് കാണാം, ഏറ്റവും കുറഞ്ഞ പംപ്കിൻ വില ഹാലോവീൻ സമയത്ത് കാണപ്പെടുന്നു. ഇതെങ്ങനെ വിശദീകരിക്കാം?
🎃 അഭിനന്ദനങ്ങൾ, നിങ്ങൾ പൈ പംപ്കിൻ വില പ്രവചിക്കാൻ സഹായിക്കുന്ന മോഡൽ സൃഷ്ടിച്ചു. എല്ലാ പംപ്കിൻ തരംകൾക്കും ഇതേ പ്രക്രിയ ആവർത്തിക്കാം, പക്ഷേ അത് ബുദ്ധിമുട്ടുള്ളതാണ്. ഇനി നാം പഠിക്കാം, പംപ്കിൻ വൈവിധ്യം നമ്മുടെ മോഡലിൽ എങ്ങനെ പരിഗണിക്കാം!
## വർഗ്ഗീയ ഫീച്ചറുകൾ
ആദർശ ലോകത്ത്, നാം ഒരേ മോഡൽ ഉപയോഗിച്ച് വ്യത്യസ്ത പംപ്കിൻ വൈവിധ്യങ്ങളുടെ വില പ്രവചിക്കാൻ ആഗ്രഹിക്കുന്നു. എന്നാൽ, `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")
> 🎥 വർഗ്ഗീയ ഫീച്ചറുകൾ ഉപയോഗിക്കുന്നതിന്റെ ഒരു ചെറിയ വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
ഇവിടെ നിങ്ങൾക്ക് കാണാം, ശരാശരി വില വൈവിധ്യത്തെ ആശ്രയിച്ചിരിക്കുന്നു:
<img alt="Average price by variety" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb43a9a8c69469ce2520c9524fabfa270b1b2422cc2450d6d11.ml.png" width="50%" />
വൈവിധ്യം പരിഗണിക്കാൻ, ആദ്യം അത് സംഖ്യാത്മക രൂപത്തിലേക്ക് മാറ്റണം, അല്ലെങ്കിൽ **എൻകോഡ്** ചെയ്യണം. ഇത് ചെയ്യാനുള്ള ചില മാർഗ്ഗങ്ങൾ:
* ലളിതമായ **സംഖ്യാത്മക എൻകോഡിംഗ്** വ്യത്യസ്ത വൈവിധ്യങ്ങളുടെ പട്ടിക സൃഷ്ടിച്ച്, ആ പട്ടികയിലെ ഇൻഡക്സ് ഉപയോഗിച്ച് വൈവിധ്യത്തിന്റെ പേര് മാറ്റും. ഇത് ലീനിയർ റിഗ്രഷനിൽ നല്ല ആശയമല്ല, കാരണം ലീനിയർ റിഗ്രഷൻ ഇൻഡക്സ് സംഖ്യയുടെ യഥാർത്ഥ മൂല്യം എടുത്ത് ഫലത്തിൽ കൂട്ടിച്ചേർക്കും, ചില കോഫിഷ്യന്റുകളാൽ ഗുണിച്ച്. നമ്മുടെ കേസിൽ, ഇൻഡക്സ് നമ്പറും വിലയും തമ്മിലുള്ള ബന്ധം വ്യക്തമായി nonlinear ആണ്, ഇൻഡക്സുകൾ പ്രത്യേക ക്രമത്തിൽ ക്രമീകരിച്ചാലും.
* **ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ്** `Variety` കോളം 4 വ്യത്യസ്ത കോളങ്ങളായി മാറ്റും, ഓരോ വൈവിധ്യത്തിനും ഒരു കോളം. ഓരോ കോളവും ആ വരി ആ വൈവിധ്യത്തിനുള്ളതാണെങ്കിൽ `1` അടങ്ങിയിരിക്കും, അല്ലെങ്കിൽ `0`. ഇതിന്റെ അർത്ഥം, ലീനിയർ റിഗ്രഷനിൽ ഓരോ പംപ്കിൻ വൈവിധ്യത്തിനും നാല് കോഫിഷ്യന്റുകൾ ഉണ്ടാകും, ഓരോ വൈവിധ്യത്തിനും "ആരംഭ വില" (അഥവാ "കൂടുതൽ വില") നിർണ്ണയിക്കാൻ.
വൈവിധ്യം ഒന്ന്-ഹോട്ട് എൻകോഡ് ചെയ്യുന്നത് കാണിക്കുന്ന കോഡ് താഴെ:
```python
pd.get_dummies(new_pumpkins['Variety'])
```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
----|-----------|-----------|--------------------------|----------
70 | 0 | 0 | 0 | 1
71 | 0 | 0 | 0 | 1
... | ... | ... | ... | ...
1738 | 0 | 1 | 0 | 0
1739 | 0 | 1 | 0 | 0
1740 | 0 | 1 | 0 | 0
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
ഒന്ന്-ഹോട്ട് എൻകോഡ് ചെയ്ത വൈവിധ്യം ഇൻപുട്ടായി ഉപയോഗിച്ച് ലീനിയർ റിഗ്രഷൻ ട്രെയിൻ ചെയ്യാൻ, `X`യും `y`യും ശരിയായി ഇൻഷിയലൈസ് ചെയ്യണം:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
മറ്റുള്ള കോഡ് മുകളിൽ ലീനിയർ റിഗ്രഷൻ ട്രെയിനിംഗിനായി ഉപയോഗിച്ച കോഡിനോട് സമാനമാണ്. പരീക്ഷിച്ചാൽ, മീൻ സ്ക്വയർ എറർ ഏകദേശം അതേപോലെയാണ്, പക്ഷേ നിർണ്ണയ ഘടകം വളരെ ഉയർന്ന (~77%) ആണ്. കൂടുതൽ കൃത്യമായ പ്രവചനങ്ങൾക്കായി, നാം കൂടുതൽ വർഗ്ഗീയ ഫീച്ചറുകളും സംഖ്യാത്മക ഫീച്ചറുകളും, ഉദാഹരണത്തിന് `Month` അല്ലെങ്കിൽ `DayOfYear` ഉൾപ്പെടുത്താം. വലിയ ഒരു ഫീച്ചർ അറേ ഉണ്ടാക്കാൻ `join` ഉപയോഗിക്കാം:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
ഇവിടെ നാം `City`യും `Package` തരംയും പരിഗണിക്കുന്നു, ഇത് MSE 2.84 (10%)യും നിർണ്ണയ ഘടകം 0.94 ഉം നൽകുന്നു!
## എല്ലാം ചേർത്ത്
മികച്ച മോഡൽ ഉണ്ടാക്കാൻ, മുകളിൽ നൽകിയ സംയുക്ത (ഒന്ന്-ഹോട്ട് എൻകോഡ് ചെയ്ത വർഗ്ഗീയ + സംഖ്യാത്മക) ഡാറ്റ പോളിനോമിയൽ റിഗ്രഷനോടൊപ്പം ഉപയോഗിക്കാം. നിങ്ങളുടെ സൗകര്യത്തിനായി പൂർണ്ണ കോഡ് ഇതാ:
```python
# പരിശീലന ഡാറ്റ സജ്ജമാക്കുക
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# ട്രെയിൻ-ടെസ്റ്റ് വിഭജനം നടത്തുക
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# പൈപ്പ്‌ലൈൻ സജ്ജമാക്കി പരിശീലിപ്പിക്കുക
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# ടെസ്റ്റ് ഡാറ്റയ്ക്ക് ഫലം പ്രവചിക്കുക
pred = pipeline.predict(X_test)
# MSEയും നിർണ്ണയവും കണക്കാക്കുക
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
ഇത് ഏകദേശം 97% നിർണ്ണയ ഘടകവും MSE=2.23 (~8% പ്രവചന പിശക്)യും നൽകും.
| മോഡൽ | MSE | നിർണ്ണയം |
|-------|-----|---------|
| `DayOfYear` ലീനിയർ | 2.77 (17.2%) | 0.07 |
| `DayOfYear` പോളിനോമിയൽ | 2.73 (17.0%) | 0.08 |
| `Variety` ലീനിയർ | 5.24 (19.7%) | 0.77 |
| എല്ലാ ഫീച്ചറുകളും ലീനിയർ | 2.84 (10.5%) | 0.94 |
| എല്ലാ ഫീച്ചറുകളും പോളിനോമിയൽ | 2.23 (8.25%) | 0.97 |
🏆 നന്നായി! നിങ്ങൾ ഒരു പാഠത്തിൽ നാല് റിഗ്രഷൻ മോഡലുകൾ സൃഷ്ടിച്ചു, മോഡൽ ഗുണനിലവാരം 97% വരെ മെച്ചപ്പെടുത്തി. റിഗ്രഷൻ അവസാന ഭാഗത്ത്, നിങ്ങൾക്ക് വിഭാഗങ്ങൾ നിർണ്ണയിക്കാൻ ലൊജിസ്റ്റിക് റിഗ്രഷൻ പഠിക്കാം.
---
## 🚀ചലഞ്ച്
ഈ നോട്ട്‌ബുക്കിൽ വിവിധ വേരിയബിളുകൾ പരീക്ഷിച്ച്, സഹസംബന്ധം മോഡൽ കൃത്യതയുമായി എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന് കാണുക.
## [പാഠം കഴിഞ്ഞുള്ള ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ഈ പാഠത്തിൽ നാം ലീനിയർ റിഗ്രഷൻ പഠിച്ചു. മറ്റ് പ്രധാന റിഗ്രഷൻ തരംകളും ഉണ്ട്. Stepwise, Ridge, Lasso, Elasticnet സാങ്കേതികതകൾക്കുറിച്ച് വായിക്കുക. കൂടുതൽ പഠിക്കാൻ നല്ല കോഴ്സ് [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ആണ്.
## അസൈൻമെന്റ്
[മോഡൽ നിർമ്മിക്കുക](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/ml/2-Regression/3-Linear/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "cc471fa89c293bc735dd3a9a0fb79b1b",
"translation_date": "2025-12-19T13:53:41+00:00",
"source_file": "2-Regression/3-Linear/assignment.md",
"language_code": "ml"
}
-->
# ഒരു റെഗ്രഷൻ മോഡൽ സൃഷ്ടിക്കുക
## നിർദ്ദേശങ്ങൾ
ഈ പാഠത്തിൽ നിങ്ങൾക്ക് ലീനിയർ റെഗ്രഷനും പോളിനോമിയൽ റെഗ്രഷനും ഉപയോഗിച്ച് ഒരു മോഡൽ എങ്ങനെ നിർമ്മിക്കാമെന്ന് കാണിച്ചു. ഈ അറിവ് ഉപയോഗിച്ച്, ഒരു ഡാറ്റാസെറ്റ് കണ്ടെത്തുക അല്ലെങ്കിൽ Scikit-learn-ന്റെ ഇൻബിൽറ്റ് സെറ്റുകളിൽ ഒന്നുപയോഗിച്ച് പുതിയ ഒരു മോഡൽ നിർമ്മിക്കുക. നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന സാങ്കേതിക വിദ്യ എന്തുകൊണ്ടാണെന്ന് നിങ്ങളുടെ നോട്ട്‌ബുക്കിൽ വിശദീകരിക്കുക, കൂടാതെ നിങ്ങളുടെ മോഡലിന്റെ കൃത്യത പ്രദർശിപ്പിക്കുക. അത് കൃത്യമല്ലെങ്കിൽ, എന്തുകൊണ്ടാണെന്ന് വിശദീകരിക്കുക.
## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണാർത്ഥം | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------- | ------------------------------------------------------------ | -------------------------- | ------------------------------- |
| | നന്നായി രേഖപ്പെടുത്തിയ പരിഹാരത്തോടെ പൂർണ്ണമായ ഒരു നോട്ട്‌ബുക്ക് അവതരിപ്പിക്കുന്നു | പരിഹാരം അപൂർണ്ണമാണ് | പരിഹാരം തെറ്റായതോ ബഗ്ഗിയോടെയോ ആണ് |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

128
translations/ml/2-Regression/3-Linear/notebook.ipynb
Unescape View File

@ -0,0 +1,128 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Pumpkin Pricing\n",
"\n",
"ആവശ്യമായ ലൈബ്രറികളും ഡാറ്റാസെറ്റും ലോഡ് ചെയ്യുക. ഡാറ്റയുടെ ഒരു ഉപസമൂഹം അടങ്ങിയ ഡാറ്റാഫ്രെയിമിലേക്ക് ഡാറ്റ മാറ്റുക:\n",
"\n",
"- ബഷെൽ പ്രകാരം വില നിശ്ചയിച്ച പംപ്കിനുകൾ മാത്രം എടുക്കുക\n",
"- തീയതി ഒരു മാസമായി മാറ്റുക\n",
"- ഉയർന്ന വിലയും താഴ്ന്ന വിലയും ശരാശരിയായി വില കണക്കാക്കുക\n",
"- ബഷെൽ അളവിൽ വില പ്രതിഫലിപ്പിക്കാൻ വില മാറ്റുക\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"from datetime import datetime\n",
"\n",
"pumpkins = pd.read_csv('../data/US-pumpkins.csv')\n",
"\n",
"pumpkins.head()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]\n",
"\n",
"columns_to_select = ['Package', 'Variety', 'City Name', 'Low Price', 'High Price', 'Date']\n",
"pumpkins = pumpkins.loc[:, columns_to_select]\n",
"\n",
"price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2\n",
"\n",
"month = pd.DatetimeIndex(pumpkins['Date']).month\n",
"day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)\n",
"\n",
"new_pumpkins = pd.DataFrame(\n",
" {'Month': month, \n",
" 'DayOfYear' : day_of_year, \n",
" 'Variety': pumpkins['Variety'], \n",
" 'City': pumpkins['City Name'], \n",
" 'Package': pumpkins['Package'], \n",
" 'Low Price': pumpkins['Low Price'],\n",
" 'High Price': pumpkins['High Price'], \n",
" 'Price': price})\n",
"\n",
"new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/1.1\n",
"new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price*2\n",
"\n",
"new_pumpkins.head()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ഒരു അടിസ്ഥാന സ്‌കാറ്റർപ്ലോട്ട് നമ്മെ ഓർമ്മിപ്പിക്കുന്നത് ആഗസ്റ്റ് മുതൽ ഡിസംബർ വരെ മാത്രമേ മാസ ഡാറ്റ ഉണ്ടായിരിക്കുകയുള്ളൂ എന്നതാണ്. ലീനിയർ രീതിയിൽ നിഗമനങ്ങൾ വരയ്ക്കാൻ കൂടുതൽ ഡാറ്റ ആവശ്യമുണ്ടാകാം.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"plt.scatter('Month','Price',data=new_pumpkins)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"plt.scatter('DayOfYear','Price',data=new_pumpkins)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3-final"
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "b032d371c75279373507f003439a577e",
"translation_date": "2025-12-19T16:17:35+00:00",
"source_file": "2-Regression/3-Linear/notebook.ipynb",
"language_code": "ml"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

17
translations/ml/2-Regression/3-Linear/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:08:46+00:00",
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
"language_code": "ml"
}
-->
ഇത് ഒരു താൽക്കാലിക പ്ലേസ്ഹോൾഡർ ആണ്
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

1084
translations/ml/2-Regression/3-Linear/solution/R/lesson_3-R.ipynb
View File

File diff suppressed because it is too large Load Diff

1117
translations/ml/2-Regression/3-Linear/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

409
translations/ml/2-Regression/4-Logistic/README.md
Unescape View File

@ -0,0 +1,409 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "abf86d845c84330bce205a46b382ec88",
"translation_date": "2025-12-19T14:05:02+00:00",
"source_file": "2-Regression/4-Logistic/README.md",
"language_code": "ml"
}
-->
# വിഭാഗങ്ങൾ പ്രവചിക്കാൻ ലോജിസ്റ്റിക് റെഗ്രഷൻ
![Logistic vs. linear regression infographic](../../../../translated_images/linear-vs-logistic.ba180bf95e7ee66721ba10ebf2dac2666acbd64a88b003c83928712433a13c7d.ml.png)
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
> ### [ഈ പാഠം R-ൽ ലഭ്യമാണ്!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
## പരിചയം
റെഗ്രഷൻ എന്ന അടിസ്ഥാന _ക്ലാസിക്_ എംഎൽ സാങ്കേതികവിദ്യകളിൽ അവസാന പാഠമായ ഈ പാഠത്തിൽ, നാം ലോജിസ്റ്റിക് റെഗ്രഷൻ പരിശോധിക്കും. ബൈനറി വിഭാഗങ്ങൾ പ്രവചിക്കാൻ ഈ സാങ്കേതികവിദ്യ ഉപയോഗിക്കും. ഈ കാൻഡി ചോക്ലേറ്റ് ആണോ അല്ലയോ? ഈ രോഗം സംക്രമണശീലമാണോ അല്ലയോ? ഈ ഉപഭോക്താവ് ഈ ഉൽപ്പന്നം തിരഞ്ഞെടുക്കുമോ അല്ലയോ?
ഈ പാഠത്തിൽ നിങ്ങൾ പഠിക്കും:
- ഡാറ്റാ ദൃശ്യവത്കരണത്തിനുള്ള പുതിയ ലൈബ്രറി
- ലോജിസ്റ്റിക് റെഗ്രഷനുള്ള സാങ്കേതികവിദ്യകൾ
✅ ഈ [Learn module](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott) വഴി ഈ തരത്തിലുള്ള റെഗ്രഷനിൽ പ്രവർത്തിക്കുന്നതിന്റെ അറിവ് കൂടുതൽ ആഴത്തിൽ നേടുക
## മുൻപരിചയം
പംപ്കിൻ ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിച്ചതിനാൽ, അതിൽ ഒരു ബൈനറി വിഭാഗം ഉണ്ടെന്ന് നമുക്ക് മനസ്സിലായി: `Color`.
ചില വേരിയബിളുകൾ നൽകിയാൽ, ഒരു പംപ്കിൻ ഏത് നിറത്തിൽ ഉണ്ടാകാൻ സാധ്യതയുള്ളതാണെന്ന് പ്രവചിക്കാൻ ഒരു ലോജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കാം (ഓറഞ്ച് 🎃 അല്ലെങ്കിൽ വെളുപ്പ് 👻).
> റെഗ്രഷൻ പാഠങ്ങളുമായി ബന്ധപ്പെട്ട ഒരു ഗ്രൂപ്പിൽ ബൈനറി ക്ലാസിഫിക്കേഷൻ എന്തുകൊണ്ട് ചർച്ച ചെയ്യുന്നു? ഭാഷാശൈലിയുടെ സൗകര്യത്തിനായി മാത്രമാണ്, കാരണം ലോജിസ്റ്റിക് റെഗ്രഷൻ [വാസ്തവത്തിൽ ഒരു ക്ലാസിഫിക്കേഷൻ രീതി ആണ്](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), എന്നാൽ ലീനിയർ അടിസ്ഥാനമാക്കിയുള്ളത്. അടുത്ത പാഠ ഗ്രൂപ്പിൽ ഡാറ്റ ക്ലാസിഫൈ ചെയ്യാനുള്ള മറ്റ് മാർഗങ്ങൾ പഠിക്കാം.
## ചോദ്യ നിർവചനം
നമ്മുടെ ആവശ്യങ്ങൾക്ക്, ഇത് ഒരു ബൈനറിയായി പ്രകടിപ്പിക്കും: 'വെളുപ്പ്' അല്ലെങ്കിൽ 'വെളുപ്പ് അല്ല'. നമ്മുടെ ഡാറ്റാസെറ്റിൽ 'സ്ട്രൈപ്പഡ്' എന്ന ഒരു വിഭാഗവും ഉണ്ട്, പക്ഷേ അതിന്റെ ഉദാഹരണങ്ങൾ കുറവാണ്, അതിനാൽ അത് ഉപയോഗിക്കില്ല. നൾ മൂല്യങ്ങൾ നീക്കം ചെയ്താൽ അത് അപ്രാപ്യമാണ്.
> 🎃 രസകരമായ ഒരു വസ്തുത, വെളുപ്പ് പംപ്കിനുകളെ ചിലപ്പോൾ 'ഗോസ്റ്റ്' പംപ്കിനുകൾ എന്ന് വിളിക്കുന്നു. അവ കട്ടിയുള്ളവയല്ല, അതിനാൽ ഓറഞ്ച് പംപ്കിനുകളെപ്പോലെ ജനപ്രിയമല്ല, പക്ഷേ അവ കൂൾ ആയി കാണപ്പെടുന്നു! അതിനാൽ നാം ചോദ്യത്തെ 'ഗോസ്റ്റ്' അല്ലെങ്കിൽ 'ഗോസ്റ്റ് അല്ല' എന്നായി പുനർനിർവചിക്കാം. 👻
## ലോജിസ്റ്റിക് റെഗ്രഷൻ കുറിച്ച്
ലീനിയർ റെഗ്രഷനിൽ നിന്നുള്ള ലോജിസ്റ്റിക് റെഗ്രഷൻ ചില പ്രധാന വ്യത്യാസങ്ങളുണ്ട്.
[![ML for beginners - Understanding Logistic Regression for Machine Learning Classification](https://img.youtube.com/vi/KpeCT6nEpBY/0.jpg)](https://youtu.be/KpeCT6nEpBY "ML for beginners - Understanding Logistic Regression for Machine Learning Classification")
> 🎥 ലോജിസ്റ്റിക് റെഗ്രഷന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
### ബൈനറി ക്ലാസിഫിക്കേഷൻ
ലോജിസ്റ്റിക് റെഗ്രഷൻ ലീനിയർ റെഗ്രഷനുപോലെ സവിശേഷതകൾ നൽകുന്നില്ല. മുൻപുള്ളത് ബൈനറി വിഭാഗത്തെക്കുറിച്ച് പ്രവചനം നൽകുന്നു ("വെളുപ്പ് അല്ലെങ്കിൽ വെളുപ്പ് അല്ല") എന്നാൽ പിന്നീടുള്ളത് തുടർച്ചയായ മൂല്യങ്ങൾ പ്രവചിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് ഒരു പംപ്കിന്റെ ഉത്ഭവവും വിളവെടുപ്പ് സമയവും നൽകിയാൽ, _അതിന്റ വില എത്ര ഉയരും_ എന്നത്.
![Pumpkin classification Model](../../../../translated_images/pumpkin-classifier.562771f104ad5436b87d1c67bca02a42a17841133556559325c0a0e348e5b774.ml.png)
> ഇൻഫോഗ്രാഫിക്: [ദാസാനി മടിപള്ളി](https://twitter.com/dasani_decoded)
### മറ്റ് ക്ലാസിഫിക്കേഷനുകൾ
മൾട്ടിനോമിയൽ, ഓർഡിനൽ തുടങ്ങിയ മറ്റ് തരത്തിലുള്ള ലോജിസ്റ്റിക് റെഗ്രഷനുകളും ഉണ്ട്:
- **മൾട്ടിനോമിയൽ**: ഒന്നിലധികം വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു - "ഓറഞ്ച്, വെളുപ്പ്, സ്ട്രൈപ്പഡ്".
- **ഓർഡിനൽ**: ക്രമീകരിച്ച വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു, ഉദാഹരണത്തിന് നമ്മുടെ പംപ്കിനുകൾ ചെറിയ, ചെറിയ, മധ്യ, വലിയ, എക്സ്‌എൽ, ഡബ്ല്യു എക്സ്‌എൽ എന്ന ക്രമത്തിൽ ക്രമീകരിച്ചിരിക്കുന്നതുപോലെ.
![Multinomial vs ordinal regression](../../../../translated_images/multinomial-vs-ordinal.36701b4850e37d86c9dd49f7bef93a2f94dbdb8fe03443eb68f0542f97f28f29.ml.png)
### വേരിയബിളുകൾ തമ്മിൽ ബന്ധപ്പെടേണ്ടതില്ല
ലീനിയർ റെഗ്രഷൻ കൂടുതൽ ബന്ധമുള്ള വേരിയബിളുകളുമായി നല്ലതായിരുന്നു, എന്നാൽ ലോജിസ്റ്റിക് റെഗ്രഷൻ അതിന്റെ വിരുദ്ധമാണ് - വേരിയബിളുകൾ പൊരുത്തപ്പെടേണ്ടതില്ല. ഈ ഡാറ്റയ്ക്ക് ഇത് അനുയോജ്യമാണ്, കാരണം ഇതിൽ ബന്ധങ്ങൾ കുറവാണ്.
### നിങ്ങൾക്ക് വളരെ ശുദ്ധമായ ഡാറ്റ ആവശ്യമാണ്
ലോജിസ്റ്റിക് റെഗ്രഷൻ കൂടുതൽ ഡാറ്റ ഉപയോഗിച്ചാൽ കൂടുതൽ കൃത്യമായ ഫലങ്ങൾ നൽകും; നമ്മുടെ ചെറിയ ഡാറ്റാസെറ്റ് ഈ ജോലി ചെയ്യാൻ അനുയോജ്യമല്ല, അതിനാൽ ഇത് മനസ്സിലാക്കുക.
[![ML for beginners - Data Analysis and Preparation for Logistic Regression](https://img.youtube.com/vi/B2X4H9vcXTs/0.jpg)](https://youtu.be/B2X4H9vcXTs "ML for beginners - Data Analysis and Preparation for Logistic Regression")
> 🎥 ലീനിയർ റെഗ്രഷനായി ഡാറ്റ തയ്യാറാക്കലിന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
✅ ലോജിസ്റ്റിക് റെഗ്രഷനുമായി നല്ല അനുയോജ്യമായ ഡാറ്റാ തരം എന്തെല്ലാമാകാമെന്ന് ചിന്തിക്കുക
## അഭ്യാസം - ഡാറ്റ ശുചീകരിക്കുക
ആദ്യം, ഡാറ്റ കുറച്ച് ശുചീകരിക്കുക, നൾ മൂല്യങ്ങൾ ഒഴിവാക്കി ചില കോളങ്ങൾ മാത്രം തിരഞ്ഞെടുക്കുക:
1. താഴെ കൊടുത്ത കോഡ് ചേർക്കുക:
```python
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
pumpkins = full_pumpkins.loc[:, columns_to_select]
pumpkins.dropna(inplace=True)
```
നിങ്ങളുടെ പുതിയ ഡാറ്റാഫ്രെയിം ഒരു നോട്ടം എടുക്കാം:
```python
pumpkins.info
```
### ദൃശ്യവത്കരണം - വർഗ്ഗീയ പ്ലോട്ട്
ഇപ്പോൾ നിങ്ങൾ വീണ്ടും [സ്റ്റാർട്ടർ നോട്ട്‌ബുക്ക്](./notebook.ipynb) പംപ്കിൻ ഡാറ്റ ഉപയോഗിച്ച് ലോഡ് ചെയ്ത്, ചില വേരിയബിളുകൾ ഉൾപ്പെടുന്ന ഡാറ്റാസെറ്റ് സംരക്ഷിക്കാൻ ശുചീകരിച്ചു, അതിൽ `Color` ഉൾപ്പെടുന്നു. നമുക്ക് മറ്റൊരു ലൈബ്രറി ഉപയോഗിച്ച് നോട്ട്‌ബുക്കിൽ ഡാറ്റാഫ്രെയിം ദൃശ്യവത്കരിക്കാം: [Seaborn](https://seaborn.pydata.org/index.html), ഇത് Matplotlib-ന്റെ മേൽനോട്ടത്തിലാണ്, നാം മുമ്പ് ഉപയോഗിച്ചത്.
Seaborn നിങ്ങളുടെ ഡാറ്റ ദൃശ്യവത്കരിക്കാൻ ചില നല്ല മാർഗങ്ങൾ നൽകുന്നു. ഉദാഹരണത്തിന്, ഓരോ `Variety`ക്കും `Color`ക്കും ഉള്ള ഡാറ്റയുടെ വിതരണങ്ങൾ വർഗ്ഗീയ പ്ലോട്ടിൽ താരതമ്യം ചെയ്യാം.
1. `catplot` ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഇത്തരമൊരു പ്ലോട്ട് സൃഷ്ടിക്കുക, നമ്മുടെ പംപ്കിൻ ഡാറ്റ `pumpkins` ഉപയോഗിച്ച്, ഓരോ പംപ്കിൻ വിഭാഗത്തിനും (ഓറഞ്ച് അല്ലെങ്കിൽ വെളുപ്പ്) നിറം നിശ്ചയിച്ച്:
```python
import seaborn as sns
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
sns.catplot(
data=pumpkins, y="Variety", hue="Color", kind="count",
palette=palette,
)
```
![A grid of visualized data](../../../../translated_images/pumpkins_catplot_1.c55c409b71fea2ecc01921e64b91970542101f90bcccfa4aa3a205db8936f48b.ml.png)
ഡാറ്റ നിരീക്ഷിച്ച്, നിറം ഡാറ്റ `Variety`-യുമായി എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന് കാണാം.
✅ ഈ വർഗ്ഗീയ പ്ലോട്ട് നൽകിയാൽ, നിങ്ങൾക്ക് എന്തെല്ലാം രസകരമായ അന്വേഷണങ്ങൾ കാണാനാകും?
### ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ്: ഫീച്ചർ, ലേബൽ എൻകോഡിംഗ്
നമ്മുടെ പംപ്കിൻ ഡാറ്റാസെറ്റിലെ എല്ലാ കോളങ്ങളിലുമുള്ള മൂല്യങ്ങൾ സ്ട്രിംഗ് ആണ്. വർഗ്ഗീയ ഡാറ്റ മനുഷ്യർക്കു മനസ്സിലാക്കാൻ എളുപ്പമാണ്, പക്ഷേ യന്ത്രങ്ങൾക്ക് അല്ല. മെഷീൻ ലേണിംഗ് ആൽഗോരിതങ്ങൾ സംഖ്യകളുമായി നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്നു. അതിനാൽ എൻകോഡിംഗ് ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ് ഘട്ടത്തിൽ വളരെ പ്രധാനമാണ്, കാരണം ഇത് വർഗ്ഗീയ ഡാറ്റ സംഖ്യാത്മക ഡാറ്റയാക്കി മാറ്റാൻ സഹായിക്കുന്നു, വിവരങ്ങൾ നഷ്ടപ്പെടാതെ. നല്ല എൻകോഡിംഗ് നല്ല മോഡൽ നിർമ്മിക്കാൻ സഹായിക്കുന്നു.
ഫീച്ചർ എൻകോഡിംഗിന് രണ്ട് പ്രധാന എൻകോഡർ തരം ഉണ്ട്:
1. ഓർഡിനൽ എൻകോഡർ: ഓർഡിനൽ വേരിയബിളുകൾക്ക് അനുയോജ്യമാണ്, അവ ക്രമീകരിച്ച വർഗ്ഗീയ വേരിയബിളുകളാണ്, ഉദാഹരണത്തിന് നമ്മുടെ ഡാറ്റാസെറ്റിലെ `Item Size` കോളം. ഓരോ വിഭാഗത്തിനും ഒരു സംഖ്യ നൽകുന്ന മാപ്പിംഗ് സൃഷ്ടിക്കുന്നു, അത് കോളത്തിലെ ക്രമം ആണ്.
```python
from sklearn.preprocessing import OrdinalEncoder
item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
ordinal_features = ['Item Size']
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
```
2. വർഗ്ഗീയ എൻകോഡർ: നോമിനൽ വേരിയബിളുകൾക്ക് അനുയോജ്യമാണ്, അവ ക്രമീകരിക്കപ്പെട്ടിട്ടില്ലാത്ത വർഗ്ഗീയ വേരിയബിളുകളാണ്, നമ്മുടെ ഡാറ്റാസെറ്റിലെ `Item Size` ഒഴികെയുള്ള എല്ലാ ഫീച്ചറുകളും. ഇത് ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ് ആണ്, അതായത് ഓരോ വിഭാഗവും ഒരു ബൈനറി കോളമായി പ്രതിനിധീകരിക്കുന്നു: പംപ്കിൻ ആ വിഭാഗത്തിൽപ്പെട്ടാൽ എൻകോഡുചെയ്ത വേരിയബിൾ 1 ആകും, അല്ലെങ്കിൽ 0.
```python
from sklearn.preprocessing import OneHotEncoder
categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
categorical_encoder = OneHotEncoder(sparse_output=False)
```
പിന്നീട്, `ColumnTransformer` ഉപയോഗിച്ച് പല എൻകോഡറുകളും ഒരേ ഘട്ടത്തിൽ ചേർത്ത് അനുയോജ്യമായ കോളങ്ങളിൽ പ്രയോഗിക്കുന്നു.
```python
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer(transformers=[
('ord', ordinal_encoder, ordinal_features),
('cat', categorical_encoder, categorical_features)
])
ct.set_output(transform='pandas')
encoded_features = ct.fit_transform(pumpkins)
```
മറ്റുവശത്ത്, ലേബൽ എൻകോഡിംഗിന് scikit-learn-ന്റെ `LabelEncoder` ക്ലാസ് ഉപയോഗിക്കുന്നു, ഇത് ലേബലുകൾ 0 മുതൽ n_classes-1 (ഇവിടെ 0, 1) വരെയുള്ള മൂല്യങ്ങൾ മാത്രമാകാൻ സാധ്യമാക്കുന്ന ഒരു സഹായക ക്ലാസ്സാണ്.
```python
from sklearn.preprocessing import LabelEncoder
label_encoder = LabelEncoder()
encoded_label = label_encoder.fit_transform(pumpkins['Color'])
```
ഫീച്ചറുകളും ലേബലും എൻകോഡ് ചെയ്ത ശേഷം, അവ `encoded_pumpkins` എന്ന പുതിയ ഡാറ്റാഫ്രെയിമിൽ സംയോജിപ്പിക്കാം.
```python
encoded_pumpkins = encoded_features.assign(Color=encoded_label)
```
✅ `Item Size` കോളത്തിനായി ഓർഡിനൽ എൻകോഡർ ഉപയോഗിക്കുന്നതിന്റെ ഗുണങ്ങൾ എന്തെല്ലാമാണ്?
### വേരിയബിളുകൾ തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്യുക
ഇപ്പോൾ നാം ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ് ചെയ്തു, ഫീച്ചറുകളും ലേബലും തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്ത് മോഡൽ എത്രത്തോളം ലേബൽ പ്രവചിക്കാൻ കഴിയും എന്ന് മനസ്സിലാക്കാം.
ഇത്തരത്തിലുള്ള വിശകലനത്തിന് ഏറ്റവും നല്ല മാർഗം ഡാറ്റ പ്ലോട്ട് ചെയ്യുകയാണ്. നാം വീണ്ടും Seaborn-ന്റെ `catplot` ഫംഗ്ഷൻ ഉപയോഗിച്ച് `Item Size`, `Variety`, `Color` തമ്മിലുള്ള ബന്ധങ്ങൾ വർഗ്ഗീയ പ്ലോട്ടിൽ കാണിക്കും. ഡാറ്റ മികച്ച രീതിയിൽ പ്ലോട്ട് ചെയ്യാൻ എൻകോഡ് ചെയ്ത `Item Size` കോളവും എൻകോഡ് ചെയ്യാത്ത `Variety` കോളവും ഉപയോഗിക്കും.
```python
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
g = sns.catplot(
data=pumpkins,
x="Item Size", y="Color", row='Variety',
kind="box", orient="h",
sharex=False, margin_titles=True,
height=1.8, aspect=4, palette=palette,
)
g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
g.set_titles(row_template="{row_name}")
```
![A catplot of visualized data](../../../../translated_images/pumpkins_catplot_2.87a354447880b3889278155957f8f60dd63db4598de5a6d0fda91c334d31f9f1.ml.png)
### സ്വാർം പ്ലോട്ട് ഉപയോഗിക്കുക
`Color` ഒരു ബൈനറി വിഭാഗമാണ (വെളുപ്പ് അല്ലെങ്കിൽ അല്ല), അതിനാൽ 'ഒരു [പ്രത്യേക സമീപനം](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) ദൃശ്യവത്കരണത്തിന്' ആവശ്യമാണ്. ഈ വിഭാഗത്തിന്റെ മറ്റ് വേരിയബിളുകളുമായുള്ള ബന്ധം കാണിക്കാൻ മറ്റ് മാർഗങ്ങളും ഉണ്ട്.
Seaborn പ്ലോട്ടുകൾ ഉപയോഗിച്ച് വേരിയബിളുകൾ പക്കൽ-പക്കൽ കാണിക്കാം.
1. മൂല്യങ്ങളുടെ വിതരണങ്ങൾ കാണിക്കാൻ 'സ്വാർം' പ്ലോട്ട് പരീക്ഷിക്കുക:
```python
palette = {
0: 'orange',
1: 'wheat'
}
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
```
![A swarm of visualized data](../../../../translated_images/swarm_2.efeacfca536c2b577dc7b5f8891f28926663fbf62d893ab5e1278ae734ca104e.ml.png)
**ശ്രദ്ധിക്കുക**: മുകളിൽ കൊടുത്ത കോഡ് ഒരു മുന്നറിയിപ്പ് ഉണ്ടാക്കാം, കാരണം Seaborn ഈ അളവിലുള്ള ഡാറ്റ പോയിന്റുകൾ സ്വാർം പ്ലോട്ടിൽ പ്രതിനിധീകരിക്കാൻ പരാജയപ്പെടും. ഒരു പരിഹാരമായി 'size' പാരാമീറ്റർ ഉപയോഗിച്ച് മാർക്കറിന്റെ വലിപ്പം കുറയ്ക്കാം. എന്നാൽ ഇത് പ്ലോട്ടിന്റെ വായനാസൗകര്യം ബാധിക്കും.
> **🧮 ഗണിതം കാണിക്കുക**
>
> ലോജിസ്റ്റിക് റെഗ്രഷൻ 'മാക്സിമം ലൈക്ലിഹുഡ്' ആശയത്തെ ആശ്രയിച്ചിരിക്കുന്നു, [സിഗ്മോയ്ഡ് ഫംഗ്ഷനുകൾ](https://wikipedia.org/wiki/Sigmoid_function) ഉപയോഗിച്ച്. ഒരു 'സിഗ്മോയ്ഡ് ഫംഗ്ഷൻ' പ്ലോട്ടിൽ 'S' ആകൃതിയിലാണ് കാണപ്പെടുന്നത്. ഒരു മൂല്യം എടുത്ത് അത് 0നും 1നും ഇടയിലുള്ള ഏതെങ്കിലും സ്ഥാനത്തേക്ക് മാപ്പ് ചെയ്യുന്നു. അതിന്റെ വളവ് 'ലോജിസ്റ്റിക് വളവ്' എന്നും വിളിക്കുന്നു. അതിന്റെ സൂത്രവാക്യം ഇപ്രകാരമാണ്:
>
> ![logistic function](../../../../translated_images/sigmoid.8b7ba9d095c789cf72780675d0d1d44980c3736617329abfc392dfc859799704.ml.png)
>
> ഇവിടെ സിഗ്മോയ്ഡിന്റെ മധ്യബിന്ദു x-ന്റെ 0 പോയിന്റിലാണ്, L വളവിന്റെ പരമാവധി മൂല്യം, k വളവിന്റെ കൂറ്റൻത്വം. ഫംഗ്ഷന്റെ ഫലം 0.5-ൽ കൂടുതലായാൽ, ആ ലേബലിന് ബൈനറി തിരഞ്ഞെടുപ്പിൽ '1' ക്ലാസ് നൽകും. അല്ലെങ്കിൽ '0' ആയി വർഗ്ഗീകരിക്കും.
## നിങ്ങളുടെ മോഡൽ നിർമ്മിക്കുക
ഈ ബൈനറി ക്ലാസിഫിക്കേഷൻ കണ്ടെത്താൻ മോഡൽ നിർമ്മിക്കുന്നത് Scikit-learn-ൽ അത്യന്തം ലളിതമാണ്.
[![ML for beginners - Logistic Regression for classification of data](https://img.youtube.com/vi/MmZS2otPrQ8/0.jpg)](https://youtu.be/MmZS2otPrQ8 "ML for beginners - Logistic Regression for classification of data")
> 🎥 ലീനിയർ റെഗ്രഷൻ മോഡൽ നിർമ്മാണത്തിന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
1. നിങ്ങളുടെ ക്ലാസിഫിക്കേഷൻ മോഡലിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന വേരിയബിളുകൾ തിരഞ്ഞെടുക്കുക, പരിശീലനവും പരിശോധനാ സെറ്റുകളും `train_test_split()` വിളിച്ച് വിഭജിക്കുക:
```python
from sklearn.model_selection import train_test_split
X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
y = encoded_pumpkins['Color']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
2. ഇപ്പോൾ നിങ്ങളുടെ മോഡൽ പരിശീലിപ്പിക്കാൻ, പരിശീലന ഡാറ്റ ഉപയോഗിച്ച് `fit()` വിളിച്ച് ഫലം പ്രിന്റ് ചെയ്യുക:
```python
from sklearn.metrics import f1_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('F1-score: ', f1_score(y_test, predictions))
```
നിങ്ങളുടെ മോഡലിന്റെ സ്കോർബോർഡ് നോക്കൂ. ഏകദേശം 1000 വരി ഡാറ്റ മാത്രമുള്ളതിനാൽ മോശമല്ല:
```output
precision recall f1-score support
0 0.94 0.98 0.96 166
1 0.85 0.67 0.75 33
accuracy 0.92 199
macro avg 0.89 0.82 0.85 199
weighted avg 0.92 0.92 0.92 199
Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 0 0 0 0 1 1]
F1-score: 0.7457627118644068
```
## ഒരു കൺഫ്യൂഷൻ മാട്രിക്സ് വഴി മെച്ചപ്പെട്ട മനസ്സിലാക്കൽ
മുകളിൽ കൊടുത്ത [terms](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) പ്രിന്റ് ചെയ്ത് സ്കോർബോർഡ് റിപ്പോർട്ട് ലഭിക്കാം, പക്ഷേ മോഡൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ [കൺഫ്യൂഷൻ മാട്രിക്സ്](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) ഉപയോഗിക്കുന്നത് സഹായിക്കും.
> 🎓 '[കൺഫ്യൂഷൻ മാട്രിക്സ്](https://wikipedia.org/wiki/Confusion_matrix)' (അഥവാ 'എറർ മാട്രിക്സ്') നിങ്ങളുടെ മോഡലിന്റെ യഥാർത്ഥവും തെറ്റായ പോസിറ്റീവുകളും നെഗറ്റീവുകളും കാണിക്കുന്ന ഒരു പട്ടികയാണ്, പ്രവചനങ്ങളുടെ കൃത്യത അളക്കാൻ.
1. കൺഫ്യൂഷൻ മാട്രിക്സ് ഉപയോഗിക്കാൻ `confusion_matrix()` വിളിക്കുക:
```python
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predictions)
```
നിങ്ങളുടെ മോഡലിന്റെ കൺഫ്യൂഷൻ മാട്രിക്സ് നോക്കൂ:
```output
array([[162, 4],
[ 11, 22]])
```
Scikit-learn-ൽ, കൺഫ്യൂഷൻ മാട്രിക്സിലെ വരികൾ (അക്ഷം 0) യഥാർത്ഥ ലേബലുകളാണ്, കോളങ്ങൾ (അക്ഷം 1) പ്രവചിച്ച ലേബലുകളാണ്.
| | 0 | 1 |
| :---: | :---: | :---: |
| 0 | TN | FP |
| 1 | FN | TP |
ഇവിടെ എന്താണ് സംഭവിക്കുന്നത്? നമുക്ക് മോഡലിന് പംപ്കിനുകളെ രണ്ട് ബൈനറി വിഭാഗങ്ങളായി, 'വെളുപ്പ്' എന്ന വിഭാഗവും 'വെളുപ്പ് അല്ല' എന്ന വിഭാഗവും വേർതിരിക്കാൻ ആവശ്യപ്പെട്ടതായി കരുതാം.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് അല്ല എന്ന് പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'വെളുപ്പ് അല്ല' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ട്രൂ നെഗറ്റീവ് ആണ്, മുകളിൽ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് ആണെന്ന് പ്രവചിച്ചാൽ, എന്നാൽ യഥാർത്ഥത്തിൽ 'വെളുപ്പ് അല്ല' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ഫാൾസ് പോസിറ്റീവ് ആണ്, മുകളിൽ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് അല്ല എന്ന് പ്രവചിച്ചാൽ, എന്നാൽ യഥാർത്ഥത്തിൽ 'വെളുപ്പ്' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ഫാൾസ് നെഗറ്റീവ് ആണ്, താഴെ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് ആണെന്ന് പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'വെളുപ്പ്' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ട്രൂ പോസിറ്റീവ് ആണ്, താഴെ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
നിങ്ങൾക്ക് തോന്നിയതുപോലെ, സത്യം പോസിറ്റീവുകളും സത്യം നെഗറ്റീവുകളും കൂടുതലായിരിക്കണം, തെറ്റായ പോസിറ്റീവുകളും തെറ്റായ നെഗറ്റീവുകളും കുറവായിരിക്കണം, അതായത് മോഡൽ മികച്ച പ്രകടനം നടത്തുന്നു എന്നതാണ്.
കൺഫ്യൂഷൻ മാട്രിക്സ് പ്രിസിഷനും റിക്കോളും എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു? മുകളിൽ പ്രിന്റ് ചെയ്ത ക്ലാസിഫിക്കേഷൻ റിപ്പോർട്ട് പ്രിസിഷൻ (0.85)യും റിക്കോൾ (0.67)യും കാണിച്ചു.
Precision = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
Recall = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
✅ Q: കൺഫ്യൂഷൻ മാട്രിക്സിന്റെ പ്രകാരം മോഡൽ എങ്ങനെ പ്രവർത്തിച്ചു? A: മോശമല്ല; സത്യം നെഗറ്റീവുകളുടെ എണ്ണം നല്ലതാണെങ്കിലും ചില തെറ്റായ നെഗറ്റീവുകളും ഉണ്ട്.
TP/TN, FP/FN എന്നിവയുടെ കൺഫ്യൂഷൻ മാട്രിക്സ് മാപ്പിംഗിന്റെ സഹായത്തോടെ മുമ്പ് കണ്ട പദങ്ങൾ വീണ്ടും പരിശോധിക്കാം:
🎓 Precision: TP/(TP + FP) തിരികെ കിട്ടിയ ഉദാഹരണങ്ങളിൽ പ്രസക്തമായ ഉദാഹരണങ്ങളുടെ അനുപാതം (ഉദാ: ഏത് ലേബലുകൾ ശരിയായി ലേബൽ ചെയ്തിരിക്കുന്നു)
🎓 Recall: TP/(TP + FN) തിരികെ കിട്ടിയ പ്രസക്തമായ ഉദാഹരണങ്ങളുടെ അനുപാതം, ശരിയായി ലേബൽ ചെയ്തിട്ടുണ്ടോ എന്നത് നോക്കാതെ
🎓 f1-score: (2 * precision * recall)/(precision + recall) പ്രിസിഷനും റിക്കോളും തമ്മിലുള്ള ഭാരിത ശരാശരി, ഏറ്റവും നല്ലത് 1, ഏറ്റവും മോശം 0
🎓 Support: തിരികെ കിട്ടിയ ഓരോ ലേബലിന്റെയും സംഭവങ്ങളുടെ എണ്ണം
🎓 Accuracy: (TP + TN)/(TP + TN + FP + FN) ഒരു സാമ്പിളിനായി ശരിയായി പ്രവചിച്ച ലേബലുകളുടെ ശതമാനം
🎓 Macro Avg: ഓരോ ലേബലിനും ലേബൽ അസമത്വം പരിഗണിക്കാതെ ഗണ്യമായ ശരാശരി മെട്രിക്‌സ്
🎓 Weighted Avg: ഓരോ ലേബലിനും ലേബൽ അസമത്വം പരിഗണിച്ച് അവയുടെ സപ്പോർട്ട് (ഓരോ ലേബലിനും സത്യം ഉദാഹരണങ്ങളുടെ എണ്ണം) അനുസരിച്ച് ഭാരിത ശരാശരി
✅ നിങ്ങളുടെ മോഡൽ തെറ്റായ നെഗറ്റീവുകളുടെ എണ്ണം കുറയ്ക്കണമെന്ന് ആഗ്രഹിക്കുന്നുവെങ്കിൽ ഏത് മെട്രിക് ശ്രദ്ധിക്കണം എന്ന് നിങ്ങൾക്ക് തോന്നുന്നുണ്ടോ?
## ഈ മോഡലിന്റെ ROC വക്രം ദൃശ്യവൽക്കരിക്കുക
[![ML for beginners - Analyzing Logistic Regression Performance with ROC Curves](https://img.youtube.com/vi/GApO575jTA0/0.jpg)](https://youtu.be/GApO575jTA0 "ML for beginners - Analyzing Logistic Regression Performance with ROC Curves")
> 🎥 ROC വക്രങ്ങളുടെ ഒരു ചെറിയ വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
'ROC' വക്രം കാണാൻ മറ്റൊരു ദൃശ്യവൽക്കരണം ചെയ്യാം:
```python
from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
y_scores = model.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
fig = plt.figure(figsize=(6, 6))
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()
```
Matplotlib ഉപയോഗിച്ച് മോഡലിന്റെ [Receiving Operating Characteristic](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) അല്ലെങ്കിൽ ROC വരച്ചിടുക. ROC വക്രങ്ങൾ സാധാരണയായി ക്ലാസിഫയറിന്റെ ഔട്ട്പുട്ട് സത്യം പോസിറ്റീവുകളും തെറ്റായ പോസിറ്റീവുകളും എന്ന കാഴ്ചപ്പാടിൽ കാണാൻ ഉപയോഗിക്കുന്നു. "ROC വക്രങ്ങളിൽ സാധാരണയായി Y അക്ഷത്തിൽ സത്യം പോസിറ്റീവ് നിരക്കും X അക്ഷത്തിൽ തെറ്റായ പോസിറ്റീവ് നിരക്കും കാണിക്കുന്നു." അതിനാൽ വക്രത്തിന്റെ കൂറ്റൻതയും മധ്യരേഖയും വക്രത്തിനിടയിലെ ഇടവും പ്രധാനമാണ്: നിങ്ങൾക്ക് വക്രം വേഗത്തിൽ മുകളിൽ കയറി രേഖയെ മറികടക്കുന്നത് വേണം. നമ്മുടെ കേസിൽ, തുടക്കത്തിൽ തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ട്, പിന്നീട് രേഖ ശരിയായി മുകളിൽ കയറി മറികടക്കുന്നു:
![ROC](../../../../translated_images/ROC_2.777f20cdfc4988ca683ade6850ac832cb70c96c12f1b910d294f270ef36e1a1c.ml.png)
അവസാനമായി, Scikit-learn ന്റെ [`roc_auc_score` API](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) ഉപയോഗിച്ച് യഥാർത്ഥ 'Area Under the Curve' (AUC) കണക്കാക്കുക:
```python
auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)
```
ഫലം `0.9749908725812341` ആണ്. AUC 0 മുതൽ 1 വരെ മാറുന്നതുകൊണ്ട്, വലിയ സ്കോർ വേണം, കാരണം 100% ശരിയായ പ്രവചനമുള്ള മോഡലിന് AUC 1 ആയിരിക്കും; ഈ കേസിൽ മോഡൽ _നന്നായിരിക്കുന്നു_.
ഭാവിയിലെ ക്ലാസിഫിക്കേഷൻ പാഠങ്ങളിൽ, നിങ്ങളുടെ മോഡലിന്റെ സ്കോറുകൾ മെച്ചപ്പെടുത്താൻ എങ്ങനെ പുനരാവർത്തനം ചെയ്യാമെന്ന് പഠിക്കും. എന്നാൽ ഇപ്പോൾ, അഭിനന്ദനങ്ങൾ! നിങ്ങൾ ഈ റെഗ്രഷൻ പാഠങ്ങൾ പൂർത്തിയാക്കി!
---
## 🚀ചലഞ്ച്
ലോജിസ്റ്റിക് റെഗ്രഷൻ സംബന്ധിച്ച് പഠിക്കാനുള്ള കാര്യങ്ങൾ വളരെ കൂടുതലുണ്ട്! എന്നാൽ പഠിക്കാൻ ഏറ്റവും നല്ല മാർഗം പരീക്ഷണമാണ്. ഈ തരം വിശകലനത്തിന് അനുയോജ്യമായ ഒരു ഡാറ്റാസെറ്റ് കണ്ടെത്തി അതുമായി ഒരു മോഡൽ നിർമ്മിക്കുക. നിങ്ങൾ എന്ത് പഠിക്കുന്നു? ടിപ്പ്: രസകരമായ ഡാറ്റാസെറ്റുകൾക്കായി [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) പരീക്ഷിക്കുക.
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ലോജിസ്റ്റിക് റെഗ്രഷന്റെ ചില പ്രായോഗിക ഉപയോഗങ്ങളെക്കുറിച്ച് പഠിക്കാൻ [സ്റ്റാൻഫോർഡിന്റെ ഈ പേപ്പറിന്റെ](https://web.stanford.edu/~jurafsky/slp3/5.pdf) ആദ്യ കുറച്ച് പേജുകൾ വായിക്കുക. ഇതുവരെ പഠിച്ചിട്ടുള്ള റെഗ്രഷൻ ടാസ്കുകളിൽ ഏത് ടാസ്കുകൾക്ക് ഏത് തരത്തിലുള്ള റെഗ്രഷൻ അനുയോജ്യമാണ് എന്ന് ചിന്തിക്കുക. ഏത് ഏറ്റവും നല്ലത്?
## അസൈൻമെന്റ്
[ഈ റെഗ്രഷൻ വീണ്ടും ശ്രമിക്കുക](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

26
translations/ml/2-Regression/4-Logistic/assignment.md
Unescape View File

@ -0,0 +1,26 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "8af40209a41494068c1f42b14c0b450d",
"translation_date": "2025-12-19T14:08:04+00:00",
"source_file": "2-Regression/4-Logistic/assignment.md",
"language_code": "ml"
}
-->
# ചില Regression വീണ്ടും ശ്രമിക്കുന്നു
## നിർദ്ദേശങ്ങൾ
പാഠത്തിൽ, നിങ്ങൾ പംപ്കിൻ ഡാറ്റയുടെ ഒരു ഉപസമൂഹം ഉപയോഗിച്ചു. ഇപ്പോൾ, മടക്കം യഥാർത്ഥ ഡാറ്റയിലേക്ക് പോയി, അതിന്റെ മുഴുവൻ ഭാഗവും ശുദ്ധീകരിച്ച് സ്റ്റാൻഡർഡൈസ് ചെയ്ത് Logistic Regression മോഡൽ നിർമ്മിക്കാൻ ശ്രമിക്കുക.
## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണപരമായത് | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------- | ----------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
| | നന്നായി വിശദീകരിച്ചും നന്നായി പ്രവർത്തിക്കുന്ന മോഡലോടുകൂടിയ ഒരു നോട്ട്‌ബുക്ക് അവതരിപ്പിക്കുന്നു | കുറഞ്ഞതും പ്രവർത്തിക്കുന്ന മോഡലോടുകൂടിയ ഒരു നോട്ട്‌ബുക്ക് അവതരിപ്പിക്കുന്നു | കുറഞ്ഞ പ്രകടനമുള്ള മോഡലോ ഒന്നുമില്ലാത്ത നോട്ട്‌ബുക്ക് അവതരിപ്പിക്കുന്നു |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

269
translations/ml/2-Regression/4-Logistic/notebook.ipynb
Unescape View File

@ -0,0 +1,269 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## പംപ്കിൻ വകഭേദങ്ങളും നിറവും\n",
"\n",
"ആവശ്യമായ ലൈബ്രറികളും ഡാറ്റാസെറ്റും ലോഡ് ചെയ്യുക. ഡാറ്റയുടെ ഒരു ഉപസമൂഹം അടങ്ങിയ ഡാറ്റാഫ്രെയിമിലേക്ക് ഡാറ്റ മാറ്റുക:\n",
"\n",
"നിറവും വകഭേദവും തമ്മിലുള്ള ബന്ധം നോക്കാം\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>City Name</th>\n",
" <th>Type</th>\n",
" <th>Package</th>\n",
" <th>Variety</th>\n",
" <th>Sub Variety</th>\n",
" <th>Grade</th>\n",
" <th>Date</th>\n",
" <th>Low Price</th>\n",
" <th>High Price</th>\n",
" <th>Mostly Low</th>\n",
" <th>...</th>\n",
" <th>Unit of Sale</th>\n",
" <th>Quality</th>\n",
" <th>Condition</th>\n",
" <th>Appearance</th>\n",
" <th>Storage</th>\n",
" <th>Crop</th>\n",
" <th>Repack</th>\n",
" <th>Trans Mode</th>\n",
" <th>Unnamed: 24</th>\n",
" <th>Unnamed: 25</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>4/29/17</td>\n",
" <td>270.0</td>\n",
" <td>280.0</td>\n",
" <td>270.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>E</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>5/6/17</td>\n",
" <td>270.0</td>\n",
" <td>280.0</td>\n",
" <td>270.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>E</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>HOWDEN TYPE</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>9/24/16</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>N</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>HOWDEN TYPE</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>9/24/16</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>N</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>HOWDEN TYPE</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>11/5/16</td>\n",
" <td>90.0</td>\n",
" <td>100.0</td>\n",
" <td>90.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>N</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"<p>5 rows × 26 columns</p>\n",
"</div>"
],
"text/plain": [
" City Name Type Package Variety Sub Variety Grade Date \\\n",
"0 BALTIMORE NaN 24 inch bins NaN NaN NaN 4/29/17 \n",
"1 BALTIMORE NaN 24 inch bins NaN NaN NaN 5/6/17 \n",
"2 BALTIMORE NaN 24 inch bins HOWDEN TYPE NaN NaN 9/24/16 \n",
"3 BALTIMORE NaN 24 inch bins HOWDEN TYPE NaN NaN 9/24/16 \n",
"4 BALTIMORE NaN 24 inch bins HOWDEN TYPE NaN NaN 11/5/16 \n",
"\n",
" Low Price High Price Mostly Low ... Unit of Sale Quality Condition \\\n",
"0 270.0 280.0 270.0 ... NaN NaN NaN \n",
"1 270.0 280.0 270.0 ... NaN NaN NaN \n",
"2 160.0 160.0 160.0 ... NaN NaN NaN \n",
"3 160.0 160.0 160.0 ... NaN NaN NaN \n",
"4 90.0 100.0 90.0 ... NaN NaN NaN \n",
"\n",
" Appearance Storage Crop Repack Trans Mode Unnamed: 24 Unnamed: 25 \n",
"0 NaN NaN NaN E NaN NaN NaN \n",
"1 NaN NaN NaN E NaN NaN NaN \n",
"2 NaN NaN NaN N NaN NaN NaN \n",
"3 NaN NaN NaN N NaN NaN NaN \n",
"4 NaN NaN NaN N NaN NaN NaN \n",
"\n",
"[5 rows x 26 columns]"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"full_pumpkins = pd.read_csv('../data/US-pumpkins.csv')\n",
"\n",
"full_pumpkins.head()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.1"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "dee08c2b49057b0de8b6752c4dbca368",
"translation_date": "2025-12-19T16:18:30+00:00",
"source_file": "2-Regression/4-Logistic/notebook.ipynb",
"language_code": "ml"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

17
translations/ml/2-Regression/4-Logistic/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:10:15+00:00",
"source_file": "2-Regression/4-Logistic/solution/Julia/README.md",
"language_code": "ml"
}
-->
ഇത് ഒരു താൽക്കാലിക പ്ലേസ്ഹോൾഡർ ആണ്
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

678
translations/ml/2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb
Unescape View File

@ -0,0 +1,678 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## ലോജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക - പാഠം 4\n",
"\n",
"![Logistic vs. linear regression infographic](../../../../../../translated_images/linear-vs-logistic.ba180bf95e7ee66721ba10ebf2dac2666acbd64a88b003c83928712433a13c7d.ml.png)\n",
"\n",
"#### **[പ്രീ-ലെക്ചർ ക്വിസ്](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)**\n",
"\n",
"#### പരിചയം\n",
"\n",
"റെഗ്രഷൻ എന്ന അടിസ്ഥാന *ക്ലാസിക്* എംഎൽ സാങ്കേതികവിദ്യകളിൽ ഒന്ന് ആയ ലോജിസ്റ്റിക് റെഗ്രഷനെക്കുറിച്ച് ഈ അവസാന പാഠത്തിൽ നാം നോക്കാം. ബൈനറി വിഭാഗങ്ങൾ പ്രവചിക്കാൻ ഈ സാങ്കേതികവിദ്യ ഉപയോഗിക്കും. ഈ കാൻഡി ചോക്ലേറ്റ് ആണോ അല്ലയോ? ഈ രോഗം സംക്രമണശീലമാണോ അല്ലയോ? ഈ ഉപഭോക്താവ് ഈ ഉൽപ്പന്നം തിരഞ്ഞെടുക്കുമോ അല്ലയോ?\n",
"\n",
"ഈ പാഠത്തിൽ നിങ്ങൾ പഠിക്കാനിരിക്കുന്നതെന്തെന്നാൽ:\n",
"\n",
"- ലോജിസ്റ്റിക് റെഗ്രഷനുള്ള സാങ്കേതികവിദ്യകൾ\n",
"\n",
"✅ ഈ തരത്തിലുള്ള റെഗ്രഷനുമായി പ്രവർത്തിക്കുന്നതിൽ നിങ്ങളുടെ മനസ്സിലാക്കൽ കൂടുതൽ ആഴപ്പെടുത്തുക ഈ [Learn module](https://learn.microsoft.com/training/modules/introduction-classification-models/?WT.mc_id=academic-77952-leestott) വഴി\n",
"\n",
"## മുൻപരിചയം\n",
"\n",
"പംപ്കിൻ ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിച്ചതിനാൽ, അതിൽ ഒരു ബൈനറി വിഭാഗം ഉണ്ടെന്ന് നമുക്ക് അറിയാം: `Color`.\n",
"\n",
"ചില വേരിയബിളുകൾ നൽകിയാൽ, *ഒരു പംപ്കിൻ ഏത് നിറത്തിൽ ഉണ്ടാകാൻ സാധ്യതയുള്ളതാണെന്ന്* (ഓറഞ്ച് 🎃 അല്ലെങ്കിൽ വെളുപ്പ് 👻) പ്രവചിക്കാൻ ഒരു ലോജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കാം.\n",
"\n",
"> റെഗ്രഷൻ പാഠം ഗ്രൂപ്പിൽ ബൈനറി ക്ലാസിഫിക്കേഷൻ എന്തുകൊണ്ട് ചർച്ച ചെയ്യുന്നു? ഭാഷാശൈലിയുടെ സൗകര്യത്തിനായി മാത്രമാണ്, കാരണം ലോജിസ്റ്റിക് റെഗ്രഷൻ [വാസ്തവത്തിൽ ഒരു ക്ലാസിഫിക്കേഷൻ രീതി ആണ്](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), എന്നാൽ ലീനിയർ അടിസ്ഥാനമാക്കിയുള്ളത്. അടുത്ത പാഠ ഗ്രൂപ്പിൽ ഡാറ്റ ക്ലാസിഫൈ ചെയ്യാനുള്ള മറ്റ് മാർഗങ്ങൾ പഠിക്കാം.\n",
"\n",
"ഈ പാഠത്തിനായി, താഴെപ്പറയുന്ന പാക്കേജുകൾ ആവശ്യമാണ്:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) ഒരു [R പാക്കേജുകളുടെ ശേഖരം](https://www.tidyverse.org/packages) ആണ്, ഡാറ്റ സയൻസ് വേഗത്തിലും എളുപ്പത്തിലും രസകരവുമാക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു!\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) ഫ്രെയിംവർക്ക് മോഡലിംഗ്, മെഷീൻ ലേണിങ്ങിനുള്ള [പാക്കേജുകളുടെ ശേഖരം](https://www.tidymodels.org/packages/) ആണ്.\n",
"\n",
"- `janitor`: [janitor പാക്കേജ്](https://github.com/sfirke/janitor) മാലിന്യമായ ഡാറ്റ പരിശോധിക്കാനും ശുദ്ധമാക്കാനും ലളിതമായ ഉപകരണങ്ങൾ നൽകുന്നു.\n",
"\n",
"- `ggbeeswarm`: [ggbeeswarm പാക്കേജ്](https://github.com/eclarke/ggbeeswarm) ggplot2 ഉപയോഗിച്ച് ബീസ്വാർം-സ്റ്റൈൽ പ്ലോട്ടുകൾ സൃഷ്ടിക്കാൻ മാർഗങ്ങൾ നൽകുന്നു.\n",
"\n",
"ഇവ ഇൻസ്റ്റാൾ ചെയ്യാൻ:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"ggbeeswarm\"))`\n",
"\n",
"അല്ലെങ്കിൽ, താഴെ കൊടുത്തിരിക്കുന്ന സ്ക്രിപ്റ്റ് ഈ മോഡ്യൂൾ പൂർത്തിയാക്കാൻ ആവശ്യമായ പാക്കേജുകൾ നിങ്ങൾക്കുണ്ടോ എന്ന് പരിശോധിച്ച്, ഇല്ലെങ്കിൽ ഇൻസ്റ്റാൾ ചെയ്യും.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
"\n",
"pacman::p_load(tidyverse, tidymodels, janitor, ggbeeswarm)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## **ചോദ്യം നിർവചിക്കുക**\n",
"\n",
"നമ്മുടെ ആവശ്യങ്ങൾക്കായി, ഇത് ഒരു ബൈനറി ആയി പ്രകടിപ്പിക്കും: 'വെളുത്ത' അല്ലെങ്കിൽ 'വെളുത്ത അല്ല'. നമ്മുടെ ഡാറ്റാസെറ്റിൽ 'സ്ട്രൈപ്പഡ്' എന്ന ഒരു വിഭാഗവും ഉണ്ട്, പക്ഷേ അതിന്റെ ഉദാഹരണങ്ങൾ കുറവാണ്, അതിനാൽ നാം അത് ഉപയോഗിക്കില്ല. ഡാറ്റാസെറ്റിൽ നിന്നുള്ള നൾ മൂല്യങ്ങൾ നീക്കം ചെയ്താൽ അത് അപ്രാപ്തമാകും.\n",
"\n",
"> 🎃 രസകരമായ ഒരു വസ്തുത, നാം ചിലപ്പോൾ വെളുത്ത പംപ്കിനുകളെ 'ഭൂതം' പംപ്കിനുകൾ എന്ന് വിളിക്കുന്നു. അവ കട്ടിയുള്ളവയല്ല, അതിനാൽ ഓറഞ്ച് പംപ്കിനുകളെപ്പോലെ ജനപ്രിയമല്ല, പക്ഷേ അവ കൂൾ കാണപ്പെടുന്നു! അതിനാൽ നാം നമ്മുടെ ചോദ്യം ഇങ്ങനെ പുനരാഖ്യാനം ചെയ്യാം: 'ഭൂതം' അല്ലെങ്കിൽ 'ഭൂതം അല്ല'. 👻\n",
"\n",
"## **ലോജിസ്റ്റിക് റെഗ്രഷൻ കുറിച്ച്**\n",
"\n",
"ലീനിയർ റെഗ്രഷനിൽ നിന്നുള്ള വ്യത്യാസങ്ങൾ ലോജിസ്റ്റിക് റെഗ്രഷനിൽ ചില പ്രധാനപ്പെട്ട രീതികളിൽ കാണാം.\n",
"\n",
"#### **ബൈനറി ക്ലാസിഫിക്കേഷൻ**\n",
"\n",
"ലോജിസ്റ്റിക് റെഗ്രഷൻ ലീനിയർ റെഗ്രഷനിൽ ഉള്ളതുപോലെ സവിശേഷതകൾ നൽകുന്നില്ല. മുൻപുള്ളത് ഒരു `ബൈനറി വിഭാഗം` (\"ഓറഞ്ച് അല്ലെങ്കിൽ ഓറഞ്ച് അല്ല\") സംബന്ധിച്ച പ്രവചനമാണ് നൽകുന്നത്, പിന്നീടുള്ളത് തുടർച്ചയായ മൂല്യങ്ങൾ പ്രവചിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് ഒരു പംപ്കിന്റെ ഉത്ഭവവും വിളവെടുപ്പ് സമയവും നൽകിയാൽ, *അതിന്റ വില എത്ര ഉയരും* എന്നത്.\n",
"\n",
"![Infographic by Dasani Madipalli](../../../../../../translated_images/pumpkin-classifier.562771f104ad5436b87d1c67bca02a42a17841133556559325c0a0e348e5b774.ml.png)\n",
"\n",
"### മറ്റ് ക്ലാസിഫിക്കേഷനുകൾ\n",
"\n",
"മൾട്ടിനോമിയൽ, ഓർഡിനൽ എന്നിവ ഉൾപ്പെടെ മറ്റ് തരത്തിലുള്ള ലോജിസ്റ്റിക് റെഗ്രഷനുകളും ഉണ്ട്:\n",
"\n",
"- **മൾട്ടിനോമിയൽ**, ഇതിൽ ഒന്നിലധികം വിഭാഗങ്ങൾ ഉണ്ടാകാം - \"ഓറഞ്ച്, വെളുത്ത, സ്ട്രൈപ്പഡ്\".\n",
"\n",
"- **ഓർഡിനൽ**, ഇത് ക്രമീകരിച്ച വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു, ഉദാഹരണത്തിന് നമുക്ക് ഫലം ലജിക്കൽ ആയി ക്രമീകരിക്കേണ്ടതുണ്ടെങ്കിൽ, നമ്മുടെ പംപ്കിനുകൾ ചെറിയ, ചെറിയ, മധ്യ, വലിയ, എക്സ് എൽ, ഡബിൾ എക്സ് എൽ എന്നിങ്ങനെ ക്രമീകരിച്ചിരിക്കുന്നതുപോലെ.\n",
"\n",
"![Multinomial vs ordinal regression](../../../../../../translated_images/multinomial-vs-ordinal.36701b4850e37d86c9dd49f7bef93a2f94dbdb8fe03443eb68f0542f97f28f29.ml.png)\n",
"\n",
"#### **വേരിയബിളുകൾ തമ്മിൽ ബന്ധപ്പെടേണ്ടതില്ല**\n",
"\n",
"ലീനിയർ റെഗ്രഷൻ കൂടുതൽ ബന്ധമുള്ള വേരിയബിളുകളുമായി നല്ല ഫലം നൽകുന്നുവെന്ന് ഓർക്കുക? ലോജിസ്റ്റിക് റെഗ്രഷൻ അതിന്റെ വിരുദ്ധമാണ് - വേരിയബിളുകൾ തമ്മിൽ പൊരുത്തപ്പെടേണ്ടതില്ല. ഈ ഡാറ്റയ്ക്ക് ഇത് അനുയോജ്യമാണ്, കാരണം ഇതിൽ ബന്ധങ്ങൾ കുറവാണ്.\n",
"\n",
"#### **നിങ്ങൾക്ക് വളരെ ശുദ്ധമായ ഡാറ്റ ആവശ്യമുണ്ട്**\n",
"\n",
"ലോജിസ്റ്റിക് റെഗ്രഷൻ കൂടുതൽ ഡാറ്റ ഉപയോഗിച്ചാൽ കൂടുതൽ കൃത്യമായ ഫലങ്ങൾ നൽകും; നമ്മുടെ ചെറിയ ഡാറ്റാസെറ്റ് ഈ ജോലി ചെയ്യാൻ അനുയോജ്യമല്ല, അതിനാൽ ഇത് മനസ്സിലാക്കുക.\n",
"\n",
"✅ ലോജിസ്റ്റിക് റെഗ്രഷനുമായി നല്ല അനുയോജ്യമായ ഡാറ്റയുടെ തരം എന്തെല്ലാമാകാമെന്ന് ചിന്തിക്കുക\n",
"\n",
"## അഭ്യാസം - ഡാറ്റ ശുദ്ധമാക്കുക\n",
"\n",
"ആദ്യം, ഡാറ്റ കുറച്ച് ശുദ്ധമാക്കുക, നൾ മൂല്യങ്ങൾ ഒഴിവാക്കി ചില കോളങ്ങൾ മാത്രം തിരഞ്ഞെടുക്കുക:\n",
"\n",
"1. താഴെ കൊടുത്തിരിക്കുന്ന കോഡ് ചേർക്കുക:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Load the core tidyverse packages\n",
"library(tidyverse)\n",
"\n",
"# Import the data and clean column names\n",
"pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\") %>% \n",
" clean_names()\n",
"\n",
"# Select desired columns\n",
"pumpkins_select <- pumpkins %>% \n",
" select(c(city_name, package, variety, origin, item_size, color)) \n",
"\n",
"# Drop rows containing missing values and encode color as factor (category)\n",
"pumpkins_select <- pumpkins_select %>% \n",
" drop_na() %>% \n",
" mutate(color = factor(color))\n",
"\n",
"# View the first few rows\n",
"pumpkins_select %>% \n",
" slice_head(n = 5)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"നിങ്ങളുടെ പുതിയ ഡാറ്റാഫ്രെയിമിൽ ഒരു കാഴ്ച എപ്പോഴും എടുക്കാൻ കഴിയും, താഴെ കാണുന്ന പോലെ [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) ഫംഗ്ഷൻ ഉപയോഗിച്ച്:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"pumpkins_select %>% \n",
" glimpse()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"നാം യഥാർത്ഥത്തിൽ ഒരു ബൈനറി ക്ലാസിഫിക്കേഷൻ പ്രശ്നം ചെയ്യുകയാണെന്ന് നമുക്ക് സ്ഥിരീകരിക്കാം:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Subset distinct observations in outcome column\n",
"pumpkins_select %>% \n",
" distinct(color)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Visualization - categorical plot\n",
"ഇപ്പോൾ നിങ്ങൾ പംപ്കിൻ ഡാറ്റ വീണ്ടും ലോഡ് ചെയ്ത് ചില വേരിയബിളുകൾ ഉൾപ്പെടുന്ന ഒരു ഡാറ്റാസെറ്റ് സംരക്ഷിക്കാൻ ക്ലീൻ ചെയ്തിട്ടുണ്ട്, അതിൽ Color ഉൾപ്പെടുന്നു. നോട്ട്ബുക്കിൽ ggplot ലൈബ്രറി ഉപയോഗിച്ച് ഡാറ്റാഫ്രെയിം ദൃശ്യവൽക്കരിക്കാം.\n",
"\n",
"ggplot ലൈബ്രറി നിങ്ങളുടെ ഡാറ്റ ദൃശ്യവൽക്കരിക്കാൻ ചില നല്ല മാർഗങ്ങൾ നൽകുന്നു. ഉദാഹരണത്തിന്, ഓരോ Variety, Color എന്നിവയുടെ ഡാറ്റയുടെ വിതരണങ്ങൾ categorical plot-ൽ താരതമ്യം ചെയ്യാം.\n",
"\n",
"1. geombar ഫംഗ്ഷൻ ഉപയോഗിച്ച്, നമ്മുടെ പംപ്കിൻ ഡാറ്റ ഉപയോഗിച്ച്, ഓരോ പംപ്കിൻ വിഭാഗത്തിനും (ഓറഞ്ച് അല്ലെങ്കിൽ വൈറ്റ്) കളർ മാപ്പിംഗ് വ്യക്തമാക്കിയാണ് ഇത്തരമൊരു പ്ലോട്ട് സൃഷ്ടിക്കുക:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "python"
}
},
"outputs": [],
"source": [
"# Specify colors for each value of the hue variable\n",
"palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
"\n",
"# Create the bar plot\n",
"ggplot(pumpkins_select, aes(y = variety, fill = color)) +\n",
" geom_bar(position = \"dodge\") +\n",
" scale_fill_manual(values = palette) +\n",
" labs(y = \"Variety\", fill = \"Color\") +\n",
" theme_minimal()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ഡാറ്റ നിരീക്ഷിച്ചാൽ, കളർ ഡാറ്റ വർണ്ണവിവിധത്വവുമായി എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന് കാണാം.\n",
"\n",
"✅ ഈ വർഗ്ഗീയ പ്ലോട്ട് നൽകിയതിനെ അടിസ്ഥാനമാക്കി, നിങ്ങൾക്ക് എന്തെല്ലാം രസകരമായ അന്വേഷണങ്ങൾ കണക്കാക്കാനാകും?\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ്: ഫീച്ചർ എൻകോഡിംഗ്\n",
"\n",
"നമ്മുടെ പംപ്കിൻസ് ഡാറ്റാസെറ്റിൽ എല്ലാ കോളങ്ങളുടെയും സ്ട്രിംഗ് മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു. വർഗ്ഗീകരിച്ച ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നത് മനുഷ്യർക്കു സുലഭമാണ്, പക്ഷേ യന്ത്രങ്ങൾക്ക് അല്ല. മെഷീൻ ലേണിംഗ് ആൽഗോരിതങ്ങൾ സംഖ്യകളുമായി നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്നു. അതുകൊണ്ടുതന്നെ എൻകോഡിംഗ് ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ് ഘട്ടത്തിൽ വളരെ പ്രധാനപ്പെട്ട ഒരു ഘട്ടമാണ്, കാരണം ഇത് വർഗ്ഗീകരിച്ച ഡാറ്റയെ സംഖ്യാത്മക ഡാറ്റയാക്കി മാറ്റാൻ സഹായിക്കുന്നു, വിവരങ്ങൾ നഷ്ടപ്പെടാതെ. നല്ല എൻകോഡിംഗ് നല്ല മോഡൽ നിർമ്മിക്കാൻ സഹായിക്കുന്നു.\n",
"\n",
"ഫീച്ചർ എൻകോഡിംഗിനായി രണ്ട് പ്രധാന തരം എൻകോഡറുകൾ ഉണ്ട്:\n",
"\n",
"1. ഓർഡിനൽ എൻകോഡർ: ഇത് ഓർഡിനൽ വേരിയബിളുകൾക്ക് അനുയോജ്യമാണ്, അവ വർഗ്ഗീകരിച്ച വേരിയബിളുകളാണ്, അവയുടെ ഡാറ്റ ഒരു ലജിക്കൽ ഓർഡറിംഗ് പിന്തുടരുന്നു, ഉദാഹരണത്തിന് നമ്മുടെ ഡാറ്റാസെറ്റിലെ `item_size` കോളം. ഓരോ വർഗ്ഗവും ഒരു സംഖ്യയാൽ പ്രതിനിധീകരിക്കുന്ന ഒരു മാപ്പിംഗ് സൃഷ്ടിക്കുന്നു, അത് കോളത്തിലെ വർഗ്ഗത്തിന്റെ ക്രമമാണ്.\n",
"\n",
"2. വർഗ്ഗീകരിച്ച എൻകോഡർ: ഇത് നോമിനൽ വേരിയബിളുകൾക്ക് അനുയോജ്യമാണ്, അവ വർഗ്ഗീകരിച്ച വേരിയബിളുകളാണ്, അവയുടെ ഡാറ്റ ഒരു ലജിക്കൽ ഓർഡറിംഗ് പിന്തുടരുന്നില്ല, ഉദാഹരണത്തിന് നമ്മുടെ ഡാറ്റാസെറ്റിലെ `item_size` ഒഴികെയുള്ള എല്ലാ ഫീച്ചറുകളും. ഇത് ഒരു വൺ-ഹോട്ട് എൻകോഡിംഗ് ആണ്, അതായത് ഓരോ വർഗ്ഗവും ഒരു ബൈനറി കോളമായി പ്രതിനിധീകരിക്കുന്നു: പംപ്കിൻ ആ വർഗ്ഗത്തിൽപ്പെട്ടാൽ എൻകോഡുചെയ്ത വേരിയബിൾ 1 ആകും, അല്ലെങ്കിൽ 0.\n",
"\n",
"ടിഡിമോഡൽസ് മറ്റൊരു നല്ല പാക്കേജ് നൽകുന്നു: [recipes](https://recipes.tidymodels.org/) - ഡാറ്റ പ്രീപ്രോസസ്സിംഗിനുള്ള ഒരു പാക്കേജ്. എല്ലാ പ്രഡിക്ടർ കോളങ്ങളും സംഖ്യകളായി എൻകോഡ് ചെയ്യപ്പെടണമെന്ന് നിർദ്ദേശിക്കുന്ന ഒരു `recipe` നാം നിർവചിക്കും, അതിനെ `prep` ചെയ്ത് ആവശ്യമായ അളവുകളും സ്ഥിതിവിവരങ്ങളും കണക്കാക്കും, ഒടുവിൽ `bake` ഉപയോഗിച്ച് പുതിയ ഡാറ്റയിൽ കണക്കുകൾ പ്രയോഗിക്കും.\n",
"\n",
"> സാധാരണയായി, recipes മോഡലിംഗിനുള്ള പ്രീപ്രോസസ്സറായി ഉപയോഗിക്കുന്നു, അതിൽ ഡാറ്റ സെറ്റിൽ ഏത് ഘട്ടങ്ങൾ പ്രയോഗിക്കണമെന്ന് നിർവചിക്കുന്നു, മോഡലിംഗിന് തയ്യാറാക്കാൻ. ആ സാഹചര്യത്തിൽ `workflow()` ഉപയോഗിക്കുന്നത് **മികച്ചതാണ്**, പകരം `prep` ഉം `bake` ഉം ഉപയോഗിച്ച് മാനുവലായി ഒരു recipe കണക്കാക്കുന്നതിന്. നാം ഇതെല്ലാം ഉടൻ കാണും.\n",
">\n",
"> എന്നാൽ ഇപ്പോൾ, നാം recipes + prep + bake ഉപയോഗിച്ച് ഡാറ്റാ വിശകലനത്തിന് തയ്യാറാക്കാൻ ഏത് ഘട്ടങ്ങൾ പ്രയോഗിക്കണമെന്ന് നിർദ്ദേശിക്കുകയും, ആ ഘട്ടങ്ങൾ പ്രയോഗിച്ച പ്രീപ്രോസസ്സുചെയ്ത ഡാറ്റ എടുക്കുകയും ചെയ്യുന്നു.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Preprocess and extract data to allow some data analysis\n",
"baked_pumpkins <- recipe(color ~ ., data = pumpkins_select) %>%\n",
" # Define ordering for item_size column\n",
" step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
" # Convert factors to numbers using the order defined above (Ordinal encoding)\n",
" step_integer(item_size, zero_based = F) %>%\n",
" # Encode all other predictors using one hot encoding\n",
" step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE) %>%\n",
" prep(data = pumpkin_select) %>%\n",
" bake(new_data = NULL)\n",
"\n",
"# Display the first few rows of preprocessed data\n",
"baked_pumpkins %>% \n",
" slice_head(n = 5)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"✅ Item Size കോളത്തിനായി ഓർഡിനൽ എൻകോഡർ ഉപയോഗിക്കുന്നതിന്റെ ഗുണങ്ങൾ എന്തെല്ലാം?\n",
"\n",
"### വ്യത്യസ്ത വേരിയബിളുകൾ തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്യുക\n",
"\n",
"ഇപ്പോൾ നാം നമ്മുടെ ഡാറ്റ പ്രീ-പ്രോസസ് ചെയ്തതിനുശേഷം, ഫീച്ചറുകളും ലേബലും തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്ത്, ഫീച്ചറുകൾ നൽകിയാൽ മോഡൽ ലേബൽ എത്രത്തോളം നന്നായി പ്രവചിക്കാനാകും എന്ന് മനസിലാക്കാം. ഈ തരത്തിലുള്ള വിശകലനം നടത്താനുള്ള ഏറ്റവും നല്ല മാർഗം ഡാറ്റ പ്ലോട്ട് ചെയ്യുകയാണ്. \n",
"Item Size, Variety, Color എന്നിവ തമ്മിലുള്ള ബന്ധങ്ങൾ കാറ്റഗോറിയൽ പ്ലോട്ടിൽ കാണിക്കാൻ നാം വീണ്ടും ggplot-ന്റെ geom_boxplot_ ഫംഗ്ഷൻ ഉപയോഗിക്കും. ഡാറ്റയെ കൂടുതൽ നല്ല രീതിയിൽ പ്ലോട്ട് ചെയ്യാൻ, എൻകോഡുചെയ്ത Item Size കോളവും എൻകോഡുചെയ്യാത്ത Variety കോളവും ഉപയോഗിക്കും.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Define the color palette\n",
"palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
"\n",
"# We need the encoded Item Size column to use it as the x-axis values in the plot\n",
"pumpkins_select_plot<-pumpkins_select\n",
"pumpkins_select_plot$item_size <- baked_pumpkins$item_size\n",
"\n",
"# Create the grouped box plot\n",
"ggplot(pumpkins_select_plot, aes(x = `item_size`, y = color, fill = color)) +\n",
" geom_boxplot() +\n",
" facet_grid(variety ~ ., scales = \"free_x\") +\n",
" scale_fill_manual(values = palette) +\n",
" labs(x = \"Item Size\", y = \"\") +\n",
" theme_minimal() +\n",
" theme(strip.text = element_text(size = 12)) +\n",
" theme(axis.text.x = element_text(size = 10)) +\n",
" theme(axis.title.x = element_text(size = 12)) +\n",
" theme(axis.title.y = element_blank()) +\n",
" theme(legend.position = \"bottom\") +\n",
" guides(fill = guide_legend(title = \"Color\")) +\n",
" theme(panel.spacing = unit(0.5, \"lines\"))+\n",
" theme(strip.text.y = element_text(size = 4, hjust = 0)) \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### സ്വാർം പ്ലോട്ട് ഉപയോഗിക്കുക\n",
"\n",
"Color ഒരു ബൈനറി വിഭാഗമാണെന്നതിനാൽ (White അല്ലെങ്കിൽ Not), visualization-ന് 'a [specialized approach](https://github.com/rstudio/cheatsheets/blob/main/data-visualization.pdf)' ആവശ്യമുണ്ട്.\n",
"\n",
"item_size-നോട് ബന്ധപ്പെട്ട് color-ന്റെ വിതരണത്തെ കാണിക്കാൻ `swarm plot` പരീക്ഷിക്കുക.\n",
"\n",
"നാം [ggbeeswarm package](https://github.com/eclarke/ggbeeswarm) ഉപയോഗിക്കും, ഇത് ggplot2 ഉപയോഗിച്ച് beeswarm-ശൈലിയിൽ പ്ലോട്ടുകൾ സൃഷ്ടിക്കാൻ മാർഗങ്ങൾ നൽകുന്നു. Beeswarm പ്ലോട്ടുകൾ സാധാരണയായി ഒതുക്കിയിരിക്കും പോയിന്റുകൾ പരസ്പരം അടുത്ത് വീഴാതെ പക്കൽ വീഴാൻ ഉപയോഗിക്കുന്ന ഒരു രീതിയാണ്.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Create beeswarm plots of color and item_size\n",
"baked_pumpkins %>% \n",
" mutate(color = factor(color)) %>% \n",
" ggplot(mapping = aes(x = color, y = item_size, color = color)) +\n",
" geom_quasirandom() +\n",
" scale_color_brewer(palette = \"Dark2\", direction = -1) +\n",
" theme(legend.position = \"none\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ഇപ്പോൾ നിറത്തിന്റെ ബൈനറി വിഭാഗങ്ങളും വലിപ്പങ്ങളുടെ വലിയ ഗ്രൂപ്പും തമ്മിലുള്ള ബന്ധത്തെക്കുറിച്ച് ഒരു ആശയം ലഭിച്ചതിനുശേഷം, ഒരു നൽകിയ പംപ്കിന്റെ സാധ്യതയുള്ള നിറം നിർണയിക്കാൻ ലോജിസ്റ്റിക് റെഗ്രഷൻ പരിശോധിക്കാം.\n",
"\n",
"## നിങ്ങളുടെ മോഡൽ നിർമ്മിക്കുക\n",
"\n",
"നിങ്ങൾ നിങ്ങളുടെ വർഗ്ഗീകരണ മോഡലിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ചാരങ്ങൾ തിരഞ്ഞെടുക്കുകയും ഡാറ്റ പരിശീലനവും പരിശോധനാ സെറ്റുകളായി വിഭജിക്കുകയും ചെയ്യുക. Tidymodels-ൽ ഉള്ള ഒരു പാക്കേജ് ആയ [rsample](https://rsample.tidymodels.org/) കാര്യക്ഷമമായ ഡാറ്റ വിഭജനം, റീസാമ്പ്ലിംഗ് എന്നിവയ്ക്ക് അടിസ്ഥാന സൗകര്യം നൽകുന്നു:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Split data into 80% for training and 20% for testing\n",
"set.seed(2056)\n",
"pumpkins_split <- pumpkins_select %>% \n",
" initial_split(prop = 0.8)\n",
"\n",
"# Extract the data in each split\n",
"pumpkins_train <- training(pumpkins_split)\n",
"pumpkins_test <- testing(pumpkins_split)\n",
"\n",
"# Print out the first 5 rows of the training set\n",
"pumpkins_train %>% \n",
" slice_head(n = 5)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"🙌 നാം ഇപ്പോൾ ട്രെയിനിംഗ് ഫീച്ചറുകൾ ട്രെയിനിംഗ് ലേബലിനോട് (നിറം) ഫിറ്റ് ചെയ്ത് ഒരു മോഡൽ പരിശീലിപ്പിക്കാൻ തയ്യാറാണ്.\n",
"\n",
"മോഡലിംഗിന് തയ്യാറാക്കുന്നതിനായി നമ്മുടെ ഡാറ്റയിൽ നടത്തേണ്ട പ്രീപ്രോസസ്സിംഗ് ഘട്ടങ്ങൾ വ്യക്തമാക്കുന്ന ഒരു റെസിപ്പി സൃഷ്ടിക്കുന്നതിലൂടെ നാം ആരംഭിക്കും, ഉദാഹരണത്തിന്: വർഗ്ഗീയ ചാരങ്ങളായ വേരിയബിളുകൾ ഒരു ഇന്റിജർ സെറ്റായി എൻകോഡ് ചെയ്യുക. `baked_pumpkins` പോലെ, നാം ഒരു `pumpkins_recipe` സൃഷ്ടിക്കും, പക്ഷേ അത് `prep` ചെയ്യുകയോ `bake` ചെയ്യുകയോ ചെയ്യില്ല, കാരണം അത് ഒരു വർക്ക്‌ഫ്ലോയിൽ പാക്കുചെയ്യപ്പെടും, അത് നിങ്ങൾ അടുത്ത കുറച്ച് ഘട്ടങ്ങളിൽ കാണും.\n",
"\n",
"Tidymodels-ൽ ലൊജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ വ്യക്തമാക്കാനുള്ള നിരവധി മാർഗ്ഗങ്ങളുണ്ട്. `?logistic_reg()` കാണുക. ഇപ്പോൾ, നാം ഡിഫോൾട്ട് `stats::glm()` എഞ്ചിൻ വഴി ഒരു ലൊജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ വ്യക്തമാക്കും.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Create a recipe that specifies preprocessing steps for modelling\n",
"pumpkins_recipe <- recipe(color ~ ., data = pumpkins_train) %>% \n",
" step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
" step_integer(item_size, zero_based = F) %>% \n",
" step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE)\n",
"\n",
"# Create a logistic model specification\n",
"log_reg <- logistic_reg() %>% \n",
" set_engine(\"glm\") %>% \n",
" set_mode(\"classification\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ഇപ്പോൾ ഞങ്ങൾക്ക് ഒരു റെസിപ്പിയും ഒരു മോഡൽ സ്പെസിഫിക്കേഷനും ഉണ്ടാകുമ്പോൾ, അവയെ ഒന്നിച്ച് ബണ്ടിൽ ചെയ്യാനുള്ള ഒരു മാർഗം കണ്ടെത്തേണ്ടതുണ്ട്, ഇത് ആദ്യം ഡാറ്റ പ്രീപ്രോസസ് ചെയ്യും (പ്രീപ്+ബേക്ക് പിന്നിൽ), പ്രീപ്രോസസ് ചെയ്ത ഡാറ്റയിൽ മോഡൽ ഫിറ്റ് ചെയ്യും, കൂടാതെ സാധ്യതയുള്ള പോസ്റ്റ്-പ്രോസസ്സിംഗ് പ്രവർത്തനങ്ങൾക്കും അനുവദിക്കും.\n",
"\n",
"Tidymodels-ൽ, ഈ സൗകര്യപ്രദമായ ഒബ്ജക്റ്റ് ഒരു [`workflow`](https://workflows.tidymodels.org/) എന്ന് വിളിക്കുന്നു, ഇത് നിങ്ങളുടെ മോഡലിംഗ് ഘടകങ്ങൾ സൗകര്യപ്രദമായി കൈവശം വയ്ക്കുന്നു.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Bundle modelling components in a workflow\n",
"log_reg_wf <- workflow() %>% \n",
" add_recipe(pumpkins_recipe) %>% \n",
" add_model(log_reg)\n",
"\n",
"# Print out the workflow\n",
"log_reg_wf\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ഒരു വർക്ക്‌ഫ്ലോ *നിർവചിച്ചശേഷം*, ഒരു മോഡൽ [`fit()`](https://tidymodels.github.io/parsnip/reference/fit.html) ഫംഗ്ഷൻ ഉപയോഗിച്ച് `പരിശീലിപ്പിക്കപ്പെടാം`. പരിശീലനത്തിന് മുമ്പ് വർക്ക്‌ഫ്ലോ ഒരു റെസിപ്പി അളക്കുകയും ഡാറ്റ പ്രീപ്രോസസ് ചെയ്യുകയും ചെയ്യും, അതിനാൽ prep, bake എന്നിവ ഉപയോഗിച്ച് അത് മാനുവലായി ചെയ്യേണ്ടതില്ല.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Train the model\n",
"wf_fit <- log_reg_wf %>% \n",
" fit(data = pumpkins_train)\n",
"\n",
"# Print the trained workflow\n",
"wf_fit\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"മോഡൽ പ്രിന്റ് ഔട്ട് പരിശീലനത്തിനിടെ പഠിച്ച കോഫിഷ്യന്റുകളാണ് കാണിക്കുന്നത്.\n",
"\n",
"ഇപ്പോൾ പരിശീലന ഡാറ്റ ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിച്ചതിനുശേഷം, [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html) ഉപയോഗിച്ച് ടെസ്റ്റ് ഡാറ്റയിൽ പ്രവചനങ്ങൾ നടത്താം. ടെസ്റ്റ് സെറ്റിനുള്ള ലേബലുകളും ഓരോ ലേബലിനും ഉള്ള സാധ്യതകളും പ്രവചിക്കാൻ മോഡൽ ഉപയോഗിച്ച് തുടങ്ങാം. സാധ്യത 0.5-ൽ കൂടുതലായാൽ predict ക്ലാസ് `WHITE` ആകും, അല്ലെങ്കിൽ `ORANGE`.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Make predictions for color and corresponding probabilities\n",
"results <- pumpkins_test %>% select(color) %>% \n",
" bind_cols(wf_fit %>% \n",
" predict(new_data = pumpkins_test)) %>%\n",
" bind_cols(wf_fit %>%\n",
" predict(new_data = pumpkins_test, type = \"prob\"))\n",
"\n",
"# Compare predictions\n",
"results %>% \n",
" slice_head(n = 10)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Translation for chunk 1 of 'lesson_4-R.ipynb' skipped due to timeout.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Confusion matrix for prediction results\n",
"conf_mat(data = results, truth = color, estimate = .pred_class)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"നമുക്ക് കൺഫ്യൂഷൻ മാട്രിക്സ് വ്യാഖ്യാനിക്കാം. നമ്മുടെ മോഡലിന് പംപ്കിനുകളെ രണ്ട് ബൈനറി വിഭാഗങ്ങളായ `white` (വെള്ള) എന്ന വിഭാഗവും `not-white` (വെള്ളയല്ലാത്ത) എന്ന വിഭാഗവും ആയി വർഗ്ഗീകരിക്കാൻ ആവശ്യപ്പെടുന്നു.\n",
"\n",
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'white' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `true positive` (സത്യം പോസിറ്റീവ്) എന്ന് വിളിക്കുന്നു, മുകളിൽ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
"\n",
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയല്ലാത്തതായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'white' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `false negative` (തെറ്റായ നെഗറ്റീവ്) എന്ന് വിളിക്കുന്നു, താഴെ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
"\n",
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'not-white' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `false positive` (തെറ്റായ പോസിറ്റീവ്) എന്ന് വിളിക്കുന്നു, മുകളിൽ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
"\n",
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയല്ലാത്തതായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'not-white' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `true negative` (സത്യം നെഗറ്റീവ്) എന്ന് വിളിക്കുന്നു, താഴെ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
"\n",
"| Truth |\n",
"|:-----:|\n",
"\n",
"\n",
"| | | |\n",
"|---------------|--------|-------|\n",
"| **Predicted** | WHITE | ORANGE |\n",
"| WHITE | TP | FP |\n",
"| ORANGE | FN | TN |\n",
"\n",
"നിങ്ങൾക്ക് തോന്നിയതുപോലെ, സത്യം പോസിറ്റീവുകളും സത്യം നെഗറ്റീവുകളും കൂടുതലായിരിക്കണം, തെറ്റായ പോസിറ്റീവുകളും തെറ്റായ നെഗറ്റീവുകളും കുറവായിരിക്കണം, ഇത് മോഡൽ മികച്ച പ്രകടനം നടത്തുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.\n",
"\n",
"കൺഫ്യൂഷൻ മാട്രിക്സ് സഹായകരമാണ്, കാരണം ഇത് മറ്റുള്ള മെട്രിക്കുകൾക്ക് വഴിതെളിക്കുന്നു, അവ മോഡലിന്റെ പ്രകടനം മെച്ചമായി വിലയിരുത്താൻ സഹായിക്കും. അവയിൽ ചിലത് നോക്കാം:\n",
"\n",
"🎓 Precision: `TP/(TP + FP)` പ്രവചിച്ച പോസിറ്റീവുകളിൽ യഥാർത്ഥ പോസിറ്റീവുകളുടെ അനുപാതം. [positive predictive value](https://en.wikipedia.org/wiki/Positive_predictive_value \"Positive predictive value\") എന്നും വിളിക്കുന്നു.\n",
"\n",
"🎓 Recall: `TP/(TP + FN)` യഥാർത്ഥ പോസിറ്റീവ് സാമ്പിളുകളിൽ നിന്നുള്ള പോസിറ്റീവ് ഫലങ്ങളുടെ അനുപാതം. `sensitivity` എന്നും അറിയപ്പെടുന്നു.\n",
"\n",
"🎓 Specificity: `TN/(TN + FP)` യഥാർത്ഥ നെഗറ്റീവ് സാമ്പിളുകളിൽ നിന്നുള്ള നെഗറ്റീവ് ഫലങ്ങളുടെ അനുപാതം.\n",
"\n",
"🎓 Accuracy: `TP + TN/(TP + TN + FP + FN)` ഒരു സാമ്പിളിനായി ശരിയായി പ്രവചിച്ച ലേബലുകളുടെ ശതമാനം.\n",
"\n",
"🎓 F Measure: Precision ഉം Recall ഉം തമ്മിലുള്ള ഭാരിത ശരാശരി, ഏറ്റവും നല്ലത് 1, ഏറ്റവും മോശം 0.\n",
"\n",
"ഇപ്പോൾ ഈ മെട്രിക്കുകൾ കണക്കാക്കാം!\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Combine metric functions and calculate them all at once\n",
"eval_metrics <- metric_set(ppv, recall, spec, f_meas, accuracy)\n",
"eval_metrics(data = results, truth = color, estimate = .pred_class)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## ഈ മോഡലിന്റെ ROC വളവ് ദൃശ്യവത്കരിക്കുക\n",
"\n",
"നമുക്ക് ഒരു കൂടി ദൃശ്യവത്കരണം ചെയ്യാം, അതായത്所谓的 [`ROC curve`](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) കാണാൻ:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Make a roc_curve\n",
"results %>% \n",
" roc_curve(color, .pred_ORANGE) %>% \n",
" autoplot()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ROC വക്രങ്ങൾ സാധാരണയായി ക്ലാസിഫയറിന്റെ ഔട്ട്പുട്ട് സത്യം എതിരായ പോസിറ്റീവുകളുടെ അടിസ്ഥാനത്തിൽ കാണാൻ ഉപയോഗിക്കുന്നു. ROC വക്രങ്ങൾ സാധാരണയായി Y അക്ഷത്തിൽ `True Positive Rate`/സെൻസിറ്റിവിറ്റി, X അക്ഷത്തിൽ `False Positive Rate`/1-സ്പെസിഫിസിറ്റി കാണിക്കുന്നു. അതിനാൽ, വക്രത്തിന്റെ കൂറ്റൻതയും മധ്യരേഖയും വക്രത്തിനിടയിലെ ഇടവും പ്രധാനമാണ്: നിങ്ങൾക്ക് വക്രം വേഗത്തിൽ മുകളിൽ കയറി രേഖയെ മറികടക്കുന്നത് വേണം. നമ്മുടെ കേസിൽ, തുടക്കത്തിൽ തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ടാകുന്നു, പിന്നീട് രേഖ ശരിയായി മുകളിൽ കയറി മറികടക്കുന്നു.\n",
"\n",
"അവസാനമായി, യഥാർത്ഥ Area Under the Curve കണക്കാക്കാൻ `yardstick::roc_auc()` ഉപയോഗിക്കാം. AUC-യുടെ ഒരു വ്യാഖ്യാനം മോഡൽ ഒരു യാദൃച്ഛിക പോസിറ്റീവ് ഉദാഹരണത്തെ യാദൃച്ഛിക നെഗറ്റീവ് ഉദാഹരണത്തേക്കാൾ ഉയർന്ന റാങ്ക് ചെയ്യാനുള്ള സാധ്യതയായി കാണാം.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Calculate area under curve\n",
"results %>% \n",
" roc_auc(color, .pred_ORANGE)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ഫലം ഏകദേശം `0.975` ആണ്. AUC 0 മുതൽ 1 വരെ വ്യത്യാസപ്പെടുന്നതുകൊണ്ട്, നിങ്ങൾക്ക് വലിയ സ്കോർ വേണം, കാരണം 100% ശരിയായ പ്രവചനങ്ങൾ ചെയ്യുന്ന മോഡലിന് AUC 1 ആയിരിക്കും; ഈ സാഹചര്യത്തിൽ, മോഡൽ *ചെറുതല്ലാത്തത്* ആണ്.\n",
"\n",
"ഭാവിയിലെ ക്ലാസിഫിക്കേഷനുകളിലെ പാഠങ്ങളിൽ, ഈ മോഡലിന്റെ സ്കോറുകൾ മെച്ചപ്പെടുത്താൻ (ഈ കേസിൽ അസമതുല്യമായ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതുപോലുള്ള) നിങ്ങൾ പഠിക്കും.\n",
"\n",
"## 🚀ചലഞ്ച്\n",
"\n",
"ലോജിസ്റ്റിക് റെഗ്രഷൻ സംബന്ധിച്ച് തുറക്കാനുള്ള കാര്യങ്ങൾ വളരെ കൂടുതലുണ്ട്! പക്ഷേ പഠിക്കാൻ ഏറ്റവും നല്ല മാർഗം പരീക്ഷണമാണ്. ഈ തരം വിശകലനത്തിന് അനുയോജ്യമായ ഒരു ഡാറ്റാസെറ്റ് കണ്ടെത്തി അതുമായി ഒരു മോഡൽ നിർമ്മിക്കുക. നിങ്ങൾ എന്ത് പഠിക്കുന്നു? ടിപ്പ്: രസകരമായ ഡാറ്റാസെറ്റുകൾക്കായി [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) പരീക്ഷിക്കുക.\n",
"\n",
"## അവലോകനം & സ്വയം പഠനം\n",
"\n",
"ലോജിസ്റ്റിക് റെഗ്രഷന്റെ ചില പ്രായോഗിക ഉപയോഗങ്ങളെക്കുറിച്ച് [സ്റ്റാൻഫോർഡിൽ നിന്നുള്ള ഈ പേപ്പറിന്റെ](https://web.stanford.edu/~jurafsky/slp3/5.pdf) ആദ്യ കുറച്ച് പേജുകൾ വായിക്കുക. ഇതുവരെ പഠിച്ചിട്ടുള്ള റെഗ്രഷൻ ടാസ്കുകളിൽ ഏതൊക്കെ ടാസ്കുകൾ ഏത് തരത്തിലുള്ള റെഗ്രഷനിനാണ് കൂടുതൽ അനുയോജ്യം എന്ന് ചിന്തിക്കുക. ഏതാണ് ഏറ്റവും നല്ലത്?\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
],
"metadata": {
"anaconda-cloud": "",
"kernelspec": {
"display_name": "R",
"langauge": "R",
"name": "ir"
},
"language_info": {
"codemirror_mode": "r",
"file_extension": ".r",
"mimetype": "text/x-r-source",
"name": "R",
"pygments_lexer": "r",
"version": "3.4.1"
},
"coopTranslator": {
"original_hash": "feaf125f481a89c468fa115bf2aed580",
"translation_date": "2025-12-19T16:46:02+00:00",
"source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
"language_code": "ml"
}
},
"nbformat": 4,
"nbformat_minor": 1
}

1261
translations/ml/2-Regression/4-Logistic/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

56
translations/ml/2-Regression/README.md
Unescape View File

@ -0,0 +1,56 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "508582278dbb8edd2a8a80ac96ef416c",
"translation_date": "2025-12-19T12:58:10+00:00",
"source_file": "2-Regression/README.md",
"language_code": "ml"
}
-->
# മെഷീൻ ലേണിംഗിനുള്ള റെഗ്രഷൻ മോഡലുകൾ
## പ്രാദേശിക വിഷയം: നോർത്ത് അമേരിക്കയിലെ പംപ്കിൻ വിലകൾക്കുള്ള റെഗ്രഷൻ മോഡലുകൾ 🎃
നോർത്ത് അമേരിക്കയിൽ, ഹാലോവീൻക്കായി പംപ്കിനുകൾ ഭയങ്കരമായ മുഖങ്ങളായി മുറിക്കുന്നു. ഈ ആകർഷകമായ പച്ചക്കറികളെ കുറിച്ച് കൂടുതൽ കണ്ടെത്താം!
![jack-o-lanterns](../../../translated_images/jack-o-lanterns.181c661a9212457d7756f37219f660f1358af27554d856e5a991f16b4e15337c.ml.jpg)
> ഫോട്ടോ <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">ബെത്ത് ട്യൂട്ഷ്മാൻ</a> <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">അൺസ്പ്ലാഷിൽ</a>
## നിങ്ങൾ പഠിക്കാനിരിക്കുന്നതെന്ത്
[![Regression പരിചയം](https://img.youtube.com/vi/5QnJtDad4iQ/0.jpg)](https://youtu.be/5QnJtDad4iQ "Regression Introduction video - Click to Watch!")
> 🎥 ഈ പാഠത്തിന് ഒരു വേഗത്തിലുള്ള പരിചയ വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
ഈ വിഭാഗത്തിലെ പാഠങ്ങൾ മെഷീൻ ലേണിംഗിന്റെ സാന്ദർഭ്യത്തിൽ റെഗ്രഷൻ തരംകുറിപ്പുകൾ ഉൾക്കൊള്ളുന്നു. റെഗ്രഷൻ മോഡലുകൾ വ്യത്യസ്ത വേരിയബിളുകൾ തമ്മിലുള്ള _ബന്ധം_ കണ്ടെത്താൻ സഹായിക്കുന്നു. ഈ മോഡൽ തരം നീളം, താപനില, പ്രായം പോലുള്ള മൂല്യങ്ങൾ പ്രവചിക്കാൻ കഴിയും, അതിലൂടെ ഡാറ്റാ പോയിന്റുകൾ വിശകലനം ചെയ്ത് വേരിയബിളുകൾ തമ്മിലുള്ള ബന്ധങ്ങൾ കണ്ടെത്തുന്നു.
ഈ പാഠമാലയിൽ, ലീനിയർ റെഗ്രഷനും ലോജിസ്റ്റിക് റെഗ്രഷനും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ നിങ്ങൾ കണ്ടെത്തും, കൂടാതെ ഒരുപാട് ഒരുപാട് തിരഞ്ഞെടുക്കേണ്ട സമയവും അറിയും.
[![മെഷീൻ ലേണിംഗിനുള്ള റെഗ്രഷൻ മോഡലുകളുടെ പരിചയം - തുടക്കക്കാർക്ക്](https://img.youtube.com/vi/XA3OaoW86R8/0.jpg)](https://youtu.be/XA3OaoW86R8 "ML for beginners - Introduction to Regression models for Machine Learning")
> 🎥 റെഗ്രഷൻ മോഡലുകൾ പരിചയപ്പെടുത്തുന്ന ഒരു ചെറിയ വീഡിയോക്കായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
ഈ പാഠസമൂഹത്തിൽ, നിങ്ങൾ മെഷീൻ ലേണിംഗ് പ്രവർത്തനങ്ങൾ ആരംഭിക്കാൻ സജ്ജമാകും, ഇതിൽ ഡാറ്റാ സയന്റിസ്റ്റുകൾക്കുള്ള സാധാരണ പരിസ്ഥിതി ആയ നോട്ട്‌ബുക്കുകൾ കൈകാര്യം ചെയ്യാൻ വിസ്വൽ സ്റ്റുഡിയോ കോഡ് ക്രമീകരിക്കുന്നതും ഉൾപ്പെടുന്നു. നിങ്ങൾ മെഷീൻ ലേണിംഗിനുള്ള ലൈബ്രറി ആയ Scikit-learn കണ്ടെത്തും, ഈ അധ്യായത്തിൽ റെഗ്രഷൻ മോഡലുകൾക്ക് കേന്ദ്രീകരിച്ച് നിങ്ങളുടെ ആദ്യ മോഡലുകൾ നിർമ്മിക്കും.
> റെഗ്രഷൻ മോഡലുകളുമായി പ്രവർത്തിക്കുന്നത് പഠിക്കാൻ സഹായിക്കുന്ന കുറച്ച് ലൊ-കോഡ് ഉപകരണങ്ങൾ ഉണ്ട്. ഈ പ്രവർത്തനത്തിന് [Azure ML പരീക്ഷിക്കുക](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
### പാഠങ്ങൾ
1. [വ്യാപാര ഉപകരണങ്ങൾ](1-Tools/README.md)
2. [ഡാറ്റാ മാനേജ്മെന്റ്](2-Data/README.md)
3. [ലീനിയർ, പോളിനോമിയൽ റെഗ്രഷൻ](3-Linear/README.md)
4. [ലോജിസ്റ്റിക് റെഗ്രഷൻ](4-Logistic/README.md)
---
### ക്രെഡിറ്റുകൾ
"ML with regression" ♥️ കൊണ്ട് എഴുതിയത് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper)
♥️ ക്വിസ് സംഭാവകർ: [മുഹമ്മദ് സകിബ് ഖാൻ ഇനാൻ](https://twitter.com/Sakibinan) & [ഓർനെല്ല അൾടുന്യൻ](https://twitter.com/ornelladotcom)
പംപ്കിൻ ഡാറ്റാസെറ്റ് [കാഗിൾ上的 ഈ പ്രോജക്ട്](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) നിർദ്ദേശിച്ചതാണ്, അതിന്റെ ഡാറ്റ [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) എന്ന യുഎസ് ഡിപ്പാർട്ട്മെന്റ് ഓഫ് അഗ്രിക്കൾച്ചർ വിതരണം ചെയ്യുന്ന റിപ്പോർട്ടുകളിൽ നിന്നാണ്. വിതരണത്തെ സാധാരണമാക്കാൻ വർണ്ണം അടിസ്ഥാനമാക്കി ചില പോയിന്റുകൾ ചേർത്തിട്ടുണ്ട്. ഈ ഡാറ്റ പബ്ലിക് ഡൊമെയ്‌നിലാണ്.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

361
translations/ml/3-Web-App/1-Web-App/README.md
Unescape View File

@ -0,0 +1,361 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "e0b75f73e4a90d45181dc5581fe2ef5c",
"translation_date": "2025-12-19T14:12:31+00:00",
"source_file": "3-Web-App/1-Web-App/README.md",
"language_code": "ml"
}
-->
# ML മോഡൽ ഉപയോഗിച്ച് ഒരു വെബ് ആപ്പ് നിർമ്മിക്കുക
ഈ പാഠത്തിൽ, നിങ്ങൾ ഒരു ഡാറ്റാ സെറ്റിൽ ML മോഡൽ പരിശീലിപ്പിക്കും, അത് ഈ ലോകത്തിന് പുറത്തുള്ളതാണ്: _കഴിഞ്ഞ നൂറ്റാണ്ടിലെ UFO ദൃശ്യങ്ങൾ_, NUFORC-യുടെ ഡാറ്റാബേസിൽ നിന്നുള്ളത്.
നിങ്ങൾ പഠിക്കാനിരിക്കുന്നവ:
- പരിശീലിപ്പിച്ച മോഡൽ 'pickle' ചെയ്യുന്നത് എങ്ങനെ
- ആ മോഡൽ Flask ആപ്പിൽ എങ്ങനെ ഉപയോഗിക്കാം
ഡാറ്റ ശുദ്ധീകരണത്തിനും മോഡൽ പരിശീലനത്തിനും നോട്ട്ബുക്കുകൾ ഉപയോഗിക്കുന്നതിനെ തുടരും, പക്ഷേ നിങ്ങൾക്ക് ഒരു മോഡൽ 'വൈൽഡിൽ' ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച് അന്വേഷിച്ച് ഒരു പടി മുന്നോട്ട് പോകാം: വെബ് ആപ്പിൽ.
ഇത് ചെയ്യാൻ, Flask ഉപയോഗിച്ച് ഒരു വെബ് ആപ്പ് നിർമ്മിക്കേണ്ടതാണ്.
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## ആപ്പ് നിർമ്മിക്കൽ
മെഷീൻ ലേണിംഗ് മോഡലുകൾ ഉപയോഗിക്കുന്ന വെബ് ആപ്പുകൾ നിർമ്മിക്കാൻ പല വഴികളുണ്ട്. നിങ്ങളുടെ വെബ് ആർക്കിടെക്ചർ മോഡൽ പരിശീലന രീതിയെ ബാധിക്കാം. ഡാറ്റ സയൻസ് ഗ്രൂപ്പ് ഒരു മോഡൽ പരിശീലിപ്പിച്ച് ആ മോഡൽ ആപ്പിൽ ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് നൽകുന്ന ഒരു ബിസിനസ്സിൽ നിങ്ങൾ ജോലി ചെയ്യുന്നു എന്ന് കരുതുക.
### പരിഗണനകൾ
നിങ്ങൾ ചോദിക്കേണ്ട നിരവധി ചോദ്യങ്ങളുണ്ട്:
- **ഇത് വെബ് ആപ്പാണോ മൊബൈൽ ആപ്പാണോ?** നിങ്ങൾ മൊബൈൽ ആപ്പ് നിർമ്മിക്കുന്നുവെങ്കിൽ അല്ലെങ്കിൽ മോഡൽ IoT സാഹചര്യത്തിൽ ഉപയോഗിക്കേണ്ടതുണ്ടെങ്കിൽ, [TensorFlow Lite](https://www.tensorflow.org/lite/) ഉപയോഗിച്ച് ആൻഡ്രോയിഡ് അല്ലെങ്കിൽ iOS ആപ്പിൽ മോഡൽ ഉപയോഗിക്കാം.
- **മോഡൽ എവിടെ നിലനിൽക്കും?** ക്ലൗഡിലോ ലോക്കലിലോ?
- **ഓഫ്ലൈൻ പിന്തുണ.** ആപ്പ് ഓഫ്ലൈനിലും പ്രവർത്തിക്കേണ്ടതുണ്ടോ?
- **മോഡൽ പരിശീലിപ്പിക്കാൻ ഉപയോഗിച്ച സാങ്കേതികവിദ്യ എന്ത്?** തിരഞ്ഞെടുക്കപ്പെട്ട സാങ്കേതികവിദ്യ ഉപയോഗിക്കുന്ന ടൂളുകൾ വ്യത്യസ്തമായിരിക്കും.
- **TensorFlow ഉപയോഗിക്കുന്നത്.** ഉദാഹരണത്തിന് TensorFlow ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കുന്നുവെങ്കിൽ, ആ ഇക്കോസിസ്റ്റം [TensorFlow.js](https://www.tensorflow.org/js/) ഉപയോഗിച്ച് വെബ് ആപ്പിൽ ഉപയോഗിക്കാൻ മോഡൽ മാറ്റാൻ കഴിയും.
- **PyTorch ഉപയോഗിക്കുന്നത്.** [PyTorch](https://pytorch.org/) പോലുള്ള ലൈബ്രറി ഉപയോഗിച്ച് മോഡൽ നിർമ്മിക്കുന്നുവെങ്കിൽ, അത് [ONNX](https://onnx.ai/) (Open Neural Network Exchange) ഫോർമാറ്റിൽ എക്സ്പോർട്ട് ചെയ്ത് ജാവാസ്ക്രിപ്റ്റ് വെബ് ആപ്പുകളിൽ ഉപയോഗിക്കാൻ [Onnx Runtime](https://www.onnxruntime.ai/) ഉപയോഗിക്കാം. ഈ ഓപ്ഷൻ Scikit-learn-ൽ പരിശീലിപ്പിച്ച മോഡലിനായി ഭാവിയിലെ പാഠത്തിൽ പരിശോധിക്കും.
- **Lobe.ai അല്ലെങ്കിൽ Azure Custom Vision ഉപയോഗിക്കുന്നത്.** [Lobe.ai](https://lobe.ai/) അല്ലെങ്കിൽ [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) പോലുള്ള ML SaaS (Software as a Service) സിസ്റ്റം ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കുന്നുവെങ്കിൽ, ഈ സോഫ്റ്റ്‌വെയർ പല പ്ലാറ്റ്ഫോമുകൾക്കായി മോഡൽ എക്സ്പോർട്ട് ചെയ്യാനുള്ള മാർഗങ്ങൾ നൽകുന്നു, കൂടാതെ ക്ലൗഡിൽ ഓൺലൈൻ ആപ്ലിക്കേഷനിലൂടെ ചോദിക്കാവുന്ന ഒരു കസ്റ്റം API നിർമ്മിക്കാനും കഴിയും.
നിങ്ങൾക്ക് ഒരു മുഴുവൻ Flask വെബ് ആപ്പ് നിർമ്മിച്ച് ബ്രൗസറിൽ തന്നെ മോഡൽ പരിശീലിപ്പിക്കാൻ അവസരമുണ്ട്. ഇത് TensorFlow.js ഉപയോഗിച്ച് ജാവാസ്ക്രിപ്റ്റ് സാഹചര്യത്തിലും ചെയ്യാം.
നമ്മുടെ ആവശ്യങ്ങൾക്ക്, Python അടിസ്ഥാനമാക്കിയുള്ള നോട്ട്ബുക്കുകൾ ഉപയോഗിച്ചുകൊണ്ടുള്ളതിനാൽ, ഒരു പരിശീലിപ്പിച്ച മോഡൽ Python-ൽ നിർമ്മിച്ച വെബ് ആപ്പിൽ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റിലേക്ക് എങ്ങനെ എക്സ്പോർട്ട് ചെയ്യാമെന്ന് പരിശോധിക്കാം.
## ടൂൾ
ഈ ടാസ്കിനായി നിങ്ങൾക്ക് രണ്ട് ടൂളുകൾ വേണം: Flask, Pickle, രണ്ടും Python-ൽ പ്രവർത്തിക്കുന്നു.
✅ [Flask](https://palletsprojects.com/p/flask/) എന്താണ്? അതിന്റെ സ്രഷ്ടാക്കൾ 'മൈക്രോ-ഫ്രെയിംവർക്ക്' എന്ന് നിർവചിച്ചിരിക്കുന്ന Flask, Python ഉപയോഗിച്ച് വെബ് ഫ്രെയിംവർക്ക് അടിസ്ഥാന സവിശേഷതകളും വെബ് പേജുകൾ നിർമ്മിക്കാൻ ടെംപ്ലേറ്റിംഗ് എഞ്ചിൻ നൽകുന്നു. Flask ഉപയോഗിച്ച് നിർമ്മാണം അഭ്യസിക്കാൻ [ഈ Learn മോഡ്യൂൾ](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) കാണുക.
✅ [Pickle](https://docs.python.org/3/library/pickle.html) എന്താണ്? Pickle 🥒 Python ഒബ്ജക്റ്റ് ഘടന സീരിയലൈസ് ചെയ്യാനും ഡീ-സീരിയലൈസ് ചെയ്യാനും ഉപയോഗിക്കുന്ന Python മോഡ്യൂളാണ്. മോഡൽ 'pickle' ചെയ്യുമ്പോൾ, അതിന്റെ ഘടന വെബിൽ ഉപയോഗിക്കാൻ സീരിയലൈസ് അല്ലെങ്കിൽ ഫ്ലാറ്റൻ ചെയ്യുന്നു. ശ്രദ്ധിക്കുക: pickle സ്വാഭാവികമായി സുരക്ഷിതമല്ല, അതിനാൽ ഒരു ഫയൽ 'un-pickle' ചെയ്യാൻ ആവശ്യപ്പെട്ടാൽ ജാഗ്രത പാലിക്കുക. ഒരു pickle ചെയ്ത ഫയലിന് `.pkl` എന്ന സഫിക്സ് ഉണ്ട്.
## അഭ്യാസം - നിങ്ങളുടെ ഡാറ്റ ശുദ്ധീകരിക്കുക
ഈ പാഠത്തിൽ നിങ്ങൾ 80,000 UFO ദൃശ്യങ്ങളുടെ ഡാറ്റ ഉപയോഗിക്കും, [NUFORC](https://nuforc.org) (The National UFO Reporting Center) ശേഖരിച്ചിരിക്കുന്നു. ഈ ഡാറ്റയിൽ UFO ദൃശ്യങ്ങളുടെ ചില രസകരമായ വിവരണങ്ങളുണ്ട്, ഉദാഹരണത്തിന്:
- **വലിയ ഉദാഹരണ വിവരണം.** "ഒരു മനുഷ്യൻ രാത്രി ഒരു പുല്ല് നിറഞ്ഞ മൈതാനത്തിൽ പ്രകാശിക്കുന്ന ഒരു ലൈറ്റ് ബീമിൽ നിന്ന് പുറത്തുവരുന്നു, അവൻ ടെക്സാസ് ഇൻസ്ട്രുമെന്റ്സ് പാർക്കിംഗ് ലോട്ടിലേക്ക് ഓടുന്നു".
- **ചെറിയ ഉദാഹരണ വിവരണം.** "ലൈറ്റുകൾ ഞങ്ങളെ പിന്തുടർന്നു".
[ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) സ്പ്രെഡ്‌ഷീറ്റിൽ `city`, `state`, `country` എന്നിവയുടെ കോളങ്ങൾ ഉൾപ്പെടുന്നു, ദൃശ്യമായ വസ്തുവിന്റെ `shape` കൂടാതെ അതിന്റെ `latitude`യും `longitude`യും.
ഈ പാഠത്തിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ശൂന്യമായ [നോട്ട്ബുക്ക്](notebook.ipynb) ൽ:
1. മുൻപത്തെ പാഠങ്ങളിൽ ചെയ്തതുപോലെ `pandas`, `matplotlib`, `numpy` ഇറക്കുമതി ചെയ്ത് ufos സ്പ്രെഡ്‌ഷീറ്റ് ഇറക്കുമതി ചെയ്യുക. ഒരു സാമ്പിൾ ഡാറ്റാ സെറ്റ് കാണാം:
```python
import pandas as pd
import numpy as np
ufos = pd.read_csv('./data/ufos.csv')
ufos.head()
```
1. ufos ഡാറ്റ ഒരു ചെറിയ ഡാറ്റാഫ്രെയിമിലേക്ക് പുതിയ തലക്കെട്ടുകളോടെ മാറ്റുക. `Country` ഫീൽഡിലെ വ്യത്യസ്ത മൂല്യങ്ങൾ പരിശോധിക്കുക.
```python
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
ufos.Country.unique()
```
1. ഇപ്പോൾ, നാം കൈകാര്യം ചെയ്യേണ്ട ഡാറ്റയുടെ അളവ് കുറയ്ക്കാൻ, ഏതെങ്കിലും നൾ മൂല്യങ്ങൾ ഒഴിവാക്കി 1-60 സെക്കൻഡ് ഇടയിലുള്ള ദൃശ്യങ്ങൾ മാത്രം ഇറക്കുമതി ചെയ്യുക:
```python
ufos.dropna(inplace=True)
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
ufos.info()
```
1. രാജ്യങ്ങളുടെ ടെക്സ്റ്റ് മൂല്യങ്ങൾ സംഖ്യയാക്കി മാറ്റാൻ Scikit-learn-ന്റെ `LabelEncoder` ലൈബ്രറി ഇറക്കുമതി ചെയ്യുക:
✅ LabelEncoder ഡാറ്റ അക്ഷരമാലാനുസരിച്ച് എൻകോഡ് ചെയ്യുന്നു
```python
from sklearn.preprocessing import LabelEncoder
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
ufos.head()
```
നിങ്ങളുടെ ഡാറ്റ ഇങ്ങനെ കാണണം:
```output
Seconds Country Latitude Longitude
2 20.0 3 53.200000 -2.916667
3 20.0 4 28.978333 -96.645833
14 30.0 4 35.823889 -80.253611
23 60.0 4 45.582778 -122.352222
24 3.0 3 51.783333 -0.783333
```
## അഭ്യാസം - നിങ്ങളുടെ മോഡൽ നിർമ്മിക്കുക
ഇപ്പോൾ, ഡാറ്റ പരിശീലനവും പരിശോധനയും ഗ്രൂപ്പുകളായി വിഭജിച്ച് മോഡൽ പരിശീലിപ്പിക്കാൻ തയ്യാറാകാം.
1. നിങ്ങൾ പരിശീലിപ്പിക്കാൻ ആഗ്രഹിക്കുന്ന മൂന്ന് ഫീച്ചറുകൾ X വെക്ടറായി തിരഞ്ഞെടുക്കുക, y വെക്ടർ `Country` ആയിരിക്കും. നിങ്ങൾക്ക് `Seconds`, `Latitude`, `Longitude` നൽകുമ്പോൾ ഒരു രാജ്യ ഐഡി ലഭിക്കണം.
```python
from sklearn.model_selection import train_test_split
Selected_features = ['Seconds','Latitude','Longitude']
X = ufos[Selected_features]
y = ufos['Country']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
1. ലോജിസ്റ്റിക് റെഗ്രഷൻ ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കുക:
```python
from sklearn.metrics import accuracy_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('Accuracy: ', accuracy_score(y_test, predictions))
```
ശ്രദ്ധേയമായും, കൃത്യത **(ഏകദേശം 95%)** മോശമല്ല, കാരണം `Country`യും `Latitude/Longitude`യും തമ്മിൽ ബന്ധമുണ്ട്.
നിങ്ങൾ സൃഷ്ടിച്ച മോഡൽ അത്ര വിപ്ലവകരമല്ല, കാരണം `Latitude`യും `Longitude`യും ഉപയോഗിച്ച് ഒരു `Country` നിശ്ചയിക്കാനാകും, പക്ഷേ ഇത് ശുദ്ധീകരിച്ച, എക്സ്പോർട്ട് ചെയ്ത, പിന്നീട് വെബ് ആപ്പിൽ ഉപയോഗിക്കുന്ന മോഡൽ പരിശീലിപ്പിക്കാൻ നല്ല അഭ്യാസമാണ്.
## അഭ്യാസം - മോഡൽ 'pickle' ചെയ്യുക
ഇപ്പോൾ, നിങ്ങളുടെ മോഡൽ _pickle_ ചെയ്യാനുള്ള സമയം! ഇത് കുറച്ച് കോഡ് വരികളിൽ ചെയ്യാം. _pickle_ ചെയ്ത ശേഷം, നിങ്ങളുടെ pickle ചെയ്ത മോഡൽ ലോഡ് ചെയ്ത് സെക്കൻഡ്, latitude, longitude മൂല്യങ്ങൾ അടങ്ങിയ ഒരു സാമ്പിൾ ഡാറ്റാ അറേയിൽ പരീക്ഷിക്കുക,
```python
import pickle
model_filename = 'ufo-model.pkl'
pickle.dump(model, open(model_filename,'wb'))
model = pickle.load(open('ufo-model.pkl','rb'))
print(model.predict([[50,44,-12]]))
```
മോഡൽ **'3'** എന്ന ഫലം നൽകുന്നു, ഇത് യുകെയുടെ രാജ്യ കോഡാണ്. അത്ഭുതം! 👽
## അഭ്യാസം - Flask ആപ്പ് നിർമ്മിക്കുക
ഇപ്പോൾ, നിങ്ങളുടെ മോഡൽ വിളിച്ച് സമാന ഫലങ്ങൾ തിരികെ നൽകുന്ന ഒരു Flask ആപ്പ് നിർമ്മിക്കാം, പക്ഷേ കൂടുതൽ ദൃശ്യപരമായി.
1. _notebook.ipynb_ ഫയലിന് സമീപം **web-app** എന്ന ഫോൾഡർ സൃഷ്ടിക്കുക, അവിടെ നിങ്ങളുടെ _ufo-model.pkl_ ഫയൽ നിലനിൽക്കും.
1. ആ ഫോൾഡറിൽ മൂന്ന് ഫോൾഡറുകൾ കൂടി സൃഷ്ടിക്കുക: **static**, അതിനുള്ളിൽ **css** ഫോൾഡർ, കൂടാതെ **templates**. ഇപ്പോൾ നിങ്ങൾക്കുണ്ടാകേണ്ട ഫയലുകളും ഡയറക്ടറികളും:
```output
web-app/
static/
css/
templates/
notebook.ipynb
ufo-model.pkl
```
✅ പൂർത്തിയായ ആപ്പിന്റെ ദൃശ്യത്തിനായി സൊല്യൂഷൻ ഫോൾഡർ കാണുക
1. _web-app_ ഫോൾഡറിൽ ആദ്യമായി സൃഷ്ടിക്കേണ്ട ഫയൽ **requirements.txt** ആണ്. ജാവാസ്ക്രിപ്റ്റ് ആപ്പിലെ _package.json_ പോലെയാണ് ഇത്, ആപ്പിന് ആവശ്യമായ ഡിപ്പൻഡൻസികൾ പട്ടികപ്പെടുത്തുന്നു. **requirements.txt** ൽ ഈ വരികൾ ചേർക്കുക:
```text
scikit-learn
pandas
numpy
flask
```
1. ഇപ്പോൾ, _web-app_ ലേക്ക് നാവിഗേറ്റ് ചെയ്ത് ഈ ഫയൽ പ്രവർത്തിപ്പിക്കുക:
```bash
cd web-app
```
1. നിങ്ങളുടെ ടെർമിനലിൽ `pip install` ടൈപ്പ് ചെയ്ത് _requirements.txt_ ലിസ്റ്റ് ചെയ്ത ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യുക:
```bash
pip install -r requirements.txt
```
1. ഇപ്പോൾ, ആപ്പ് പൂർത്തിയാക്കാൻ മൂന്ന് ഫയലുകൾ കൂടി സൃഷ്ടിക്കാൻ തയ്യാറാകൂ:
1. റൂട്ടിൽ **app.py** സൃഷ്ടിക്കുക.
2. _templates_ ഡയറക്ടറിയിൽ **index.html** സൃഷ്ടിക്കുക.
3. _static/css_ ഡയറക്ടറിയിൽ **styles.css** സൃഷ്ടിക്കുക.
1. _styles.css_ ഫയൽ കുറച്ച് സ്റ്റൈലുകളോടെ നിർമ്മിക്കുക:
```css
body {
width: 100%;
height: 100%;
font-family: 'Helvetica';
background: black;
color: #fff;
text-align: center;
letter-spacing: 1.4px;
font-size: 30px;
}
input {
min-width: 150px;
}
.grid {
width: 300px;
border: 1px solid #2d2d2d;
display: grid;
justify-content: center;
margin: 20px auto;
}
.box {
color: #fff;
background: #2d2d2d;
padding: 12px;
display: inline-block;
}
```
1. തുടർന്ന്, _index.html_ ഫയൽ നിർമ്മിക്കുക:
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>🛸 UFO Appearance Prediction! 👽</title>
<link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
</head>
<body>
<div class="grid">
<div class="box">
<p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
<form action="{{ url_for('predict')}}" method="post">
<input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
<input type="text" name="latitude" placeholder="Latitude" required="required" />
<input type="text" name="longitude" placeholder="Longitude" required="required" />
<button type="submit" class="btn">Predict country where the UFO is seen</button>
</form>
<p>{{ prediction_text }}</p>
</div>
</div>
</body>
</html>
```
ഈ ഫയലിലെ ടെംപ്ലേറ്റിംഗ് നോക്കുക. ആപ്പ് നൽകുന്ന വേരിയബിളുകൾ ചുറ്റിപ്പറ്റിയുള്ള 'മസ്റ്റാഷ്' സിന്റാക്സ് `{{}}` ശ്രദ്ധിക്കുക, ഉദാഹരണത്തിന് പ്രവചന ടെക്സ്റ്റ്. `/predict` റൂട്ടിലേക്ക് ഒരു ഫോർം പോസ്റ്റ് ചെയ്യുന്നതും കാണാം.
അവസാനം, മോഡൽ ഉപയോഗിച്ച് പ്രവചനങ്ങൾ പ്രദർശിപ്പിക്കുന്ന പൈത്തൺ ഫയൽ നിർമ്മിക്കാൻ തയ്യാറാകൂ:
1. `app.py` ൽ ചേർക്കുക:
```python
import numpy as np
from flask import Flask, request, render_template
import pickle
app = Flask(__name__)
model = pickle.load(open("./ufo-model.pkl", "rb"))
@app.route("/")
def home():
return render_template("index.html")
@app.route("/predict", methods=["POST"])
def predict():
int_features = [int(x) for x in request.form.values()]
final_features = [np.array(int_features)]
prediction = model.predict(final_features)
output = prediction[0]
countries = ["Australia", "Canada", "Germany", "UK", "US"]
return render_template(
"index.html", prediction_text="Likely country: {}".format(countries[output])
)
if __name__ == "__main__":
app.run(debug=True)
```
> 💡 ടിപ്പ്: Flask ഉപയോഗിച്ച് വെബ് ആപ്പ് ഓടിക്കുമ്പോൾ [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) ചേർക്കുമ്പോൾ, ആപ്പിൽ ചെയ്ത മാറ്റങ്ങൾ ഉടൻ പ്രതിഫലിക്കും, സെർവർ റീസ്റ്റാർട്ട് ചെയ്യേണ്ടതില്ല. ശ്രദ്ധിക്കുക! പ്രൊഡക്ഷൻ ആപ്പിൽ ഇത് ഉപയോഗിക്കരുത്.
`python app.py` അല്ലെങ്കിൽ `python3 app.py` ഓടിച്ചാൽ നിങ്ങളുടെ വെബ് സെർവർ ലോക്കലായി ആരംഭിക്കും, നിങ്ങൾക്ക് ഒരു ചെറിയ ഫോർം പൂരിപ്പിച്ച് UFO ദൃശ്യങ്ങൾ എവിടെ കണ്ടുവെന്ന് അറിയാം!
അതിനുമുമ്പ്, `app.py` ഭാഗങ്ങൾ നോക്കാം:
1. ആദ്യം, ഡിപ്പൻഡൻസികൾ ലോഡ് ചെയ്ത് ആപ്പ് ആരംഭിക്കുന്നു.
1. തുടർന്ന്, മോഡൽ ഇറക്കുമതി ചെയ്യുന്നു.
1. പിന്നീട്, ഹോം റൂട്ടിൽ index.html റെൻഡർ ചെയ്യുന്നു.
`/predict` റൂട്ടിൽ, ഫോർം പോസ്റ്റ് ചെയ്തപ്പോൾ പല കാര്യങ്ങളും നടക്കുന്നു:
1. ഫോർം വേരിയബിളുകൾ ശേഖരിച്ച് numpy അറേ ആയി മാറ്റുന്നു. മോഡലിലേക്ക് അയച്ച് പ്രവചന ഫലം ലഭിക്കുന്നു.
2. പ്രവചിച്ച രാജ്യ കോഡിൽ നിന്നുള്ള രാജ്യങ്ങൾ വായിക്കാൻ കഴിയുന്ന ടെക്സ്റ്റായി മാറ്റി index.html-ലേക്ക് അയക്കുന്നു, ടെംപ്ലേറ്റിൽ പ്രദർശിപ്പിക്കാൻ.
Flask-ഉം pickle ചെയ്ത മോഡലും ഉപയോഗിച്ച് മോഡൽ ഇങ്ങനെ ഉപയോഗിക്കുന്നത് സാദാരണമാണ്. ഏറ്റവും ബുദ്ധിമുട്ടുള്ളത് മോഡലിന് അയയ്ക്കേണ്ട ഡാറ്റയുടെ രൂപം മനസ്സിലാക്കലാണ്. മോഡൽ എങ്ങനെ പരിശീലിപ്പിച്ചതിനനുസരിച്ച് ഇത് വ്യത്യാസപ്പെടും. ഈ മോഡലിന് പ്രവചനത്തിന് മൂന്ന് ഡാറ്റ പോയിന്റുകൾ നൽകണം.
പ്രൊഫഷണൽ സാഹചര്യത്തിൽ, മോഡൽ പരിശീലിപ്പിക്കുന്നവരും വെബ് അല്ലെങ്കിൽ മൊബൈൽ ആപ്പ് ഉപയോഗിക്കുന്നവരും നല്ല ആശയവിനിമയം വേണം. നമ്മുടെ കേസിൽ, അത് നിങ്ങൾ മാത്രം!
---
## 🚀 ചലഞ്ച്
നോട്ട്ബുക്കിൽ പ്രവർത്തിക്കാതെ, മോഡൽ Flask ആപ്പിൽ തന്നെ പരിശീലിപ്പിക്കാൻ ശ്രമിക്കൂ! നിങ്ങളുടെ Python കോഡ് നോട്ട്ബുക്കിൽ നിന്ന് മാറ്റി, ഡാറ്റ ശുദ്ധീകരിച്ചതിന് ശേഷം, `train` എന്ന റൂട്ടിൽ ആപ്പിനുള്ളിൽ മോഡൽ പരിശീലിപ്പിക്കുക. ഈ രീതിയുടെ ഗുണങ്ങളും ദോഷങ്ങളും എന്തെല്ലാമാണ്?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ML മോഡലുകൾ ഉപയോഗിക്കുന്ന വെബ് ആപ്പുകൾ നിർമ്മിക്കാൻ പല വഴികളുണ്ട്. ജാവാസ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ Python ഉപയോഗിച്ച് ML ലെവറേജ് ചെയ്യാൻ നിങ്ങൾക്ക് കഴിയുന്ന വഴികളുടെ പട്ടിക തയ്യാറാക്കുക. ആർക്കിടെക്ചർ പരിഗണിക്കുക: മോഡൽ ആപ്പിൽ തന്നെ നിലനിൽക്കണോ, ക്ലൗഡിൽ ആയിരിക്കണോ? പിന്നീട് എങ്ങനെ ആക്‌സസ് ചെയ്യും? പ്രയോഗിച്ച ML വെബ് പരിഹാരത്തിനുള്ള ഒരു ആർക്കിടെക്ചറൽ മോഡൽ വരച്ചുകാണിക്കുക.
## അസൈൻമെന്റ്
[മറ്റൊരു മോഡൽ പരീക്ഷിക്കുക](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/ml/3-Web-App/1-Web-App/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a8e8ae10be335cbc745b75ee552317ff",
"translation_date": "2025-12-19T14:15:14+00:00",
"source_file": "3-Web-App/1-Web-App/assignment.md",
"language_code": "ml"
}
-->
# വ്യത്യസ്തമായ ഒരു മോഡൽ പരീക്ഷിക്കുക
## നിർദ്ദേശങ്ങൾ
നിങ്ങൾ ഒരു പരിശീലിത Regression മോഡൽ ഉപയോഗിച്ച് ഒരു വെബ് ആപ്പ് നിർമ്മിച്ചിട്ടുണ്ടെങ്കിൽ, മുൻപ് Regression പാഠത്തിൽ നിന്നുള്ള ഒരു മോഡൽ ഉപയോഗിച്ച് ഈ വെബ് ആപ്പ് വീണ്ടും നിർമ്മിക്കുക. പംപ്കിൻ ഡാറ്റയെ പ്രതിഫലിപ്പിക്കാൻ നിങ്ങൾക്ക് സ്റ്റൈൽ നിലനിർത്താമോ അല്ലെങ്കിൽ വ്യത്യസ്തമായി രൂപകൽപ്പന ചെയ്യാമോ. നിങ്ങളുടെ മോഡലിന്റെ പരിശീലന രീതിയെ പ്രതിഫലിപ്പിക്കാൻ ഇൻപുട്ടുകൾ മാറ്റാൻ ശ്രദ്ധിക്കുക.
## റൂബ്രിക്
| മാനദണ്ഡങ്ങൾ | ഉദാഹരണപരമായത് | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് |
| -------------------------- | --------------------------------------------------------- | --------------------------------------------------------- | -------------------------------------- |
| | വെബ് ആപ്പ് പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുകയും ക്ലൗഡിൽ വിന്യസിക്കപ്പെടുകയും ചെയ്യുന്നു | വെബ് ആപ്പിൽ പിഴവുകൾ ഉണ്ടോ അല്ലെങ്കിൽ അപ്രതീക്ഷിത ഫലങ്ങൾ കാണിക്കുന്നു | വെബ് ആപ്പ് ശരിയായി പ്രവർത്തിക്കുന്നില്ല |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

0
translations/ml/3-Web-App/1-Web-App/notebook.ipynb
Unescape View File

269
translations/ml/3-Web-App/1-Web-App/solution/notebook.ipynb
Unescape View File

@ -0,0 +1,269 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"orig_nbformat": 2,
"kernelspec": {
"name": "python37364bit8d3b438fb5fc4430a93ac2cb74d693a7",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"coopTranslator": {
"original_hash": "5fa2e8f4584c78250ca9729b46562ceb",
"translation_date": "2025-12-19T16:48:19+00:00",
"source_file": "3-Web-App/1-Web-App/solution/notebook.ipynb",
"language_code": "ml"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"## യു.എഫ്.ഒ. ദൃശ്യാനുഭവങ്ങളെക്കുറിച്ച് പഠിക്കാൻ റെഗ്രഷൻ മോഡൽ ഉപയോഗിച്ച് വെബ് ആപ്പ് നിർമ്മിക്കുക\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" datetime city state country shape \\\n",
"0 10/10/1949 20:30 san marcos tx us cylinder \n",
"1 10/10/1949 21:00 lackland afb tx NaN light \n",
"2 10/10/1955 17:00 chester (uk/england) NaN gb circle \n",
"3 10/10/1956 21:00 edna tx us circle \n",
"4 10/10/1960 20:00 kaneohe hi us light \n",
"\n",
" duration (seconds) duration (hours/min) \\\n",
"0 2700.0 45 minutes \n",
"1 7200.0 1-2 hrs \n",
"2 20.0 20 seconds \n",
"3 20.0 1/2 hour \n",
"4 900.0 15 minutes \n",
"\n",
" comments date posted latitude \\\n",
"0 This event took place in early fall around 194... 4/27/2004 29.883056 \n",
"1 1949 Lackland AFB&#44 TX. Lights racing acros... 12/16/2005 29.384210 \n",
"2 Green/Orange circular disc over Chester&#44 En... 1/21/2008 53.200000 \n",
"3 My older brother and twin sister were leaving ... 1/17/2004 28.978333 \n",
"4 AS a Marine 1st Lt. flying an FJ4B fighter/att... 1/22/2004 21.418056 \n",
"\n",
" longitude \n",
"0 -97.941111 \n",
"1 -98.581082 \n",
"2 -2.916667 \n",
"3 -96.645833 \n",
"4 -157.803611 "
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>datetime</th>\n <th>city</th>\n <th>state</th>\n <th>country</th>\n <th>shape</th>\n <th>duration (seconds)</th>\n <th>duration (hours/min)</th>\n <th>comments</th>\n <th>date posted</th>\n <th>latitude</th>\n <th>longitude</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>10/10/1949 20:30</td>\n <td>san marcos</td>\n <td>tx</td>\n <td>us</td>\n <td>cylinder</td>\n <td>2700.0</td>\n <td>45 minutes</td>\n <td>This event took place in early fall around 194...</td>\n <td>4/27/2004</td>\n <td>29.883056</td>\n <td>-97.941111</td>\n </tr>\n <tr>\n <th>1</th>\n <td>10/10/1949 21:00</td>\n <td>lackland afb</td>\n <td>tx</td>\n <td>NaN</td>\n <td>light</td>\n <td>7200.0</td>\n <td>1-2 hrs</td>\n <td>1949 Lackland AFB&amp;#44 TX. Lights racing acros...</td>\n <td>12/16/2005</td>\n <td>29.384210</td>\n <td>-98.581082</td>\n </tr>\n <tr>\n <th>2</th>\n <td>10/10/1955 17:00</td>\n <td>chester (uk/england)</td>\n <td>NaN</td>\n <td>gb</td>\n <td>circle</td>\n <td>20.0</td>\n <td>20 seconds</td>\n <td>Green/Orange circular disc over Chester&amp;#44 En...</td>\n <td>1/21/2008</td>\n <td>53.200000</td>\n <td>-2.916667</td>\n </tr>\n <tr>\n <th>3</th>\n <td>10/10/1956 21:00</td>\n <td>edna</td>\n <td>tx</td>\n <td>us</td>\n <td>circle</td>\n <td>20.0</td>\n <td>1/2 hour</td>\n <td>My older brother and twin sister were leaving ...</td>\n <td>1/17/2004</td>\n <td>28.978333</td>\n <td>-96.645833</td>\n </tr>\n <tr>\n <th>4</th>\n <td>10/10/1960 20:00</td>\n <td>kaneohe</td>\n <td>hi</td>\n <td>us</td>\n <td>light</td>\n <td>900.0</td>\n <td>15 minutes</td>\n <td>AS a Marine 1st Lt. flying an FJ4B fighter/att...</td>\n <td>1/22/2004</td>\n <td>21.418056</td>\n <td>-157.803611</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"metadata": {},
"execution_count": 23
}
],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"ufos = pd.read_csv('../data/ufos.csv')\n",
"ufos.head()\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"array(['us', nan, 'gb', 'ca', 'au', 'de'], dtype=object)"
]
},
"metadata": {},
"execution_count": 24
}
],
"source": [
"\n",
"ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})\n",
"\n",
"ufos.Country.unique()\n",
"\n",
"# 0 au, 1 ca, 2 de, 3 gb, 4 us"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"<class 'pandas.core.frame.DataFrame'>\nInt64Index: 25863 entries, 2 to 80330\nData columns (total 4 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 Seconds 25863 non-null float64\n 1 Country 25863 non-null object \n 2 Latitude 25863 non-null float64\n 3 Longitude 25863 non-null float64\ndtypes: float64(3), object(1)\nmemory usage: 1010.3+ KB\n"
]
}
],
"source": [
"ufos.dropna(inplace=True)\n",
"\n",
"ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]\n",
"\n",
"ufos.info()"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" Seconds Country Latitude Longitude\n",
"2 20.0 3 53.200000 -2.916667\n",
"3 20.0 4 28.978333 -96.645833\n",
"14 30.0 4 35.823889 -80.253611\n",
"23 60.0 4 45.582778 -122.352222\n",
"24 3.0 3 51.783333 -0.783333"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>Seconds</th>\n <th>Country</th>\n <th>Latitude</th>\n <th>Longitude</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>2</th>\n <td>20.0</td>\n <td>3</td>\n <td>53.200000</td>\n <td>-2.916667</td>\n </tr>\n <tr>\n <th>3</th>\n <td>20.0</td>\n <td>4</td>\n <td>28.978333</td>\n <td>-96.645833</td>\n </tr>\n <tr>\n <th>14</th>\n <td>30.0</td>\n <td>4</td>\n <td>35.823889</td>\n <td>-80.253611</td>\n </tr>\n <tr>\n <th>23</th>\n <td>60.0</td>\n <td>4</td>\n <td>45.582778</td>\n <td>-122.352222</td>\n </tr>\n <tr>\n <th>24</th>\n <td>3.0</td>\n <td>3</td>\n <td>51.783333</td>\n <td>-0.783333</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"metadata": {},
"execution_count": 26
}
],
"source": [
"from sklearn.preprocessing import LabelEncoder\n",
"\n",
"ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])\n",
"\n",
"ufos.head()"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"\n",
"Selected_features = ['Seconds','Latitude','Longitude']\n",
"\n",
"X = ufos[Selected_features]\n",
"y = ufos['Country']\n",
"\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
" FutureWarning)\n",
"/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:469: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning.\n",
" \"this warning.\", FutureWarning)\n",
" precision recall f1-score support\n",
"\n",
" 0 1.00 1.00 1.00 41\n",
" 1 1.00 0.02 0.05 250\n",
" 2 0.00 0.00 0.00 8\n",
" 3 0.94 1.00 0.97 131\n",
" 4 0.95 1.00 0.97 4743\n",
"\n",
" accuracy 0.95 5173\n",
" macro avg 0.78 0.60 0.60 5173\n",
"weighted avg 0.95 0.95 0.93 5173\n",
"\n",
"Predicted labels: [4 4 4 ... 3 4 4]\n",
"Accuracy: 0.9512855209742895\n",
"/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/metrics/classification.py:1437: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n",
" 'precision', 'predicted', average, warn_for)\n"
]
}
],
"source": [
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score, classification_report \n",
"from sklearn.linear_model import LogisticRegression\n",
"model = LogisticRegression()\n",
"model.fit(X_train, y_train)\n",
"predictions = model.predict(X_test)\n",
"\n",
"print(classification_report(y_test, predictions))\n",
"print('Predicted labels: ', predictions)\n",
"print('Accuracy: ', accuracy_score(y_test, predictions))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[3]\n"
]
}
],
"source": [
"import pickle\n",
"model_filename = 'ufo-model.pkl'\n",
"pickle.dump(model, open(model_filename,'wb'))\n",
"\n",
"model = pickle.load(open('ufo-model.pkl','rb'))\n",
"print(model.predict([[50,44,-12]]))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\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"
]
}
]
}

37
translations/ml/3-Web-App/README.md
Unescape View File

@ -0,0 +1,37 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9836ff53cfef716ddfd70e06c5f43436",
"translation_date": "2025-12-19T12:59:36+00:00",
"source_file": "3-Web-App/README.md",
"language_code": "ml"
}
-->
# നിങ്ങളുടെ ML മോഡൽ ഉപയോഗിക്കാൻ ഒരു വെബ് ആപ്പ് നിർമ്മിക്കുക
പാഠ്യപദ്ധതിയുടെ ഈ ഭാഗത്തിൽ, നിങ്ങൾക്ക് പ്രയോഗാത്മകമായ ഒരു ML വിഷയം പരിചയപ്പെടുത്തും: നിങ്ങളുടെ Scikit-learn മോഡൽ ഫയലായി സേവ് ചെയ്യുന്നത്, അത് വെബ് ആപ്ലിക്കേഷനിൽ പ്രവചനങ്ങൾ നടത്താൻ ഉപയോഗിക്കാവുന്നതാണ്. മോഡൽ സേവ് ചെയ്ത ശേഷം, Flask-ൽ നിർമ്മിച്ച ഒരു വെബ് ആപ്പിൽ അത് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും. ആദ്യം, UFO കാണപ്പെട്ടതുമായി ബന്ധപ്പെട്ട ചില ഡാറ്റ ഉപയോഗിച്ച് ഒരു മോഡൽ നിങ്ങൾ സൃഷ്ടിക്കും! പിന്നീട്, ഒരു വെബ് ആപ്പ് നിർമ്മിക്കും, അതിലൂടെ നിങ്ങൾ സെക്കൻഡുകളുടെ എണ്ണം, അക്ഷാംശവും രേഖാംശവും നൽകുമ്പോൾ ഏത് രാജ്യമാണ് UFO കണ്ടതായി റിപ്പോർട്ട് ചെയ്തതെന്ന് പ്രവചിക്കാനാകും.
![UFO Parking](../../../translated_images/ufo.9e787f5161da9d4d1dafc537e1da09be8210f2ee996cb638aa5cee1d92867a04.ml.jpg)
ഫോട്ടോ <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> എന്നവരിൽ നിന്നാണ് <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## പാഠങ്ങൾ
1. [Build a Web App](1-Web-App/README.md)
## ക്രെഡിറ്റുകൾ
"Build a Web App" ♥️ ഉപയോഗിച്ച് എഴുതിയത് [Jen Looper](https://twitter.com/jenlooper) ആണ്.
♥️ ക്വിസുകൾ എഴുതിയത് Rohan Raj ആണ്.
ഡാറ്റാസെറ്റ് [Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings) നിന്നാണ് ലഭിച്ചത്.
വെബ് ആപ്പ് ആർക്കിടെക്ചർ ഭാഗികമായി [ഈ ലേഖനം](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4) ഉം [ഈ റിപോ](https://github.com/abhinavsagar/machine-learning-deployment) ഉം Abhinav Sagar നിർദ്ദേശിച്ചവയാണ്.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Write Preview
Loading…
Cancel
Save