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

Browse Source
pull/915/head
localizeflow[bot] 2 months ago
parent c8064617b5
commit d318aed598
61 changed files with 14076 additions and 0 deletions
Show Stats Download Patch File Download Diff File

17
translations/te/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:01+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

174
translations/te/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:23+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb",
"language_code": "te"
}
},
"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/te/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:38:20+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/README.md",
"language_code": "te"
}
-->
# హోటల్ సమీక్షలతో భావ విశ్లేషణ
ఇప్పుడు మీరు డేటాసెట్‌ను వివరంగా పరిశీలించినందున, కాలమ్స్‌ను ఫిల్టర్ చేసి, ఆపై డేటాసెట్‌పై NLP సాంకేతికతలను ఉపయోగించి హోటల్స్ గురించి కొత్త అవగాహనలను పొందే సమయం వచ్చింది.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
### ఫిల్టరింగ్ & భావ విశ్లేషణ ఆపరేషన్లు
మీరు గమనించినట్లయితే, డేటాసెట్‌లో కొన్ని సమస్యలు ఉన్నాయి. కొన్ని కాలమ్స్ అనవసరమైన సమాచారంతో నిండిపోయాయి, మరికొన్ని తప్పుగా కనిపిస్తున్నాయి. అవి సరైనవైతే, అవి ఎలా లెక్కించబడ్డాయో స్పష్టంగా లేదు, మరియు మీ స్వంత లెక్కింపులతో సమాధానాలను స్వతంత్రంగా ధృవీకరించలేరు.
## వ్యాయామం: కొంతమంది డేటా ప్రాసెసింగ్
డేటాను కొంచెం మరింత శుభ్రం చేయండి. తర్వాత ఉపయోగకరమైన కాలమ్స్‌ను జోడించండి, ఇతర కాలమ్స్‌లో విలువలను మార్చండి, మరియు కొన్ని కాలమ్స్‌ను పూర్తిగా తొలగించండి.
1. ప్రారంభ కాలమ్ ప్రాసెసింగ్
1. `lat` మరియు `lng` తొలగించండి
2. `Hotel_Address` విలువలను క్రింది విలువలతో మార్చండి (ఒక చిరునామాలో నగరం మరియు దేశం రెండూ ఉంటే, దాన్ని కేవలం నగరం మరియు దేశంగా మార్చండి).
డేటాసెట్‌లో ఉన్న నగరాలు మరియు దేశాలు ఇవే:
Amsterdam, Netherlands
Barcelona, Spain
London, United Kingdom
Milan, Italy
Paris, France
Vienna, Austria
```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` మనకు ఉపయోగం లేదు, కాబట్టి వాటిని లెక్కించే ముందు తొలగించడం మంచిది, కానీ ఇది చాలా వేగంగా జరిగే ఆపరేషన్ కాబట్టి వాటిని ఉంచి పక్కన పెట్టవచ్చు.
### ఉండే కాలం ట్యాగ్స్ తొలగించడం
ఈ ట్యాగ్స్ తొలగించడం మొదటి దశ, ఇది మొత్తం ట్యాగ్స్ సంఖ్యను కొంచెం తగ్గిస్తుంది. గమనించండి, మీరు వాటిని డేటాసెట్ నుండి తొలగించరు, కేవలం సమీక్షల డేటాసెట్‌లో లెక్కించడానికి/ఉంచడానికి పరిగణన నుండి తీసివేస్తారు.
| 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 |
| ... | ... |
గదులు, సూట్లు, స్టూడియోలు, అపార్ట్‌మెంట్లు విభిన్న రకాలు ఉన్నాయి. అవి సారాంశంగా ఒకే అర్థం కలిగి ఉంటాయి మరియు మీకు సంబంధం లేదు, కాబట్టి వాటిని పరిగణన నుండి తీసివేయండి.
| 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 జోడించండి. ఫలితం, ఉదా: వ్యాపార ప్రయాణం vs విశ్రాంతి కోసం ఈ హోటల్ ఎన్ని సమీక్షకులు ఎంచుకున్నారు అనే లెక్క, ఇది హోటల్ సిఫార్సు చేయడంలో ఉపయోగకరమైన సమాచారం.
```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")
# స్టాప్ వర్డ్స్ తొలగించండి - చాలా టెక్స్ట్ కోసం ఇది నెమ్మదిగా ఉండవచ్చు!
# ర్యాన్ హాన్ (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 అని భావిస్తే, కానీ సమీక్షకుడు హోటల్‌కు అత్యల్ప స్కోర్ ఇచ్చినట్లయితే, సమీక్ష పాఠ్యం స్కోర్‌కు సరిపోలకపోవచ్చు లేదా భావ విశ్లేషకుడు భావాన్ని సరిగ్గా గుర్తించలేకపోయినట్టవుతుంది. కొన్ని భావ స్కోర్లు పూర్తిగా తప్పు ఉండవచ్చు, మరియు తరచుగా అది వివరణాత్మకం, ఉదా: సమీక్ష చాలా వ్యంగ్యంగా ఉండవచ్చు "Of course I LOVED sleeping in a room with no heating" మరియు భావ విశ్లేషకుడు దాన్ని పాజిటివ్ భావంగా భావిస్తాడు, కానీ మానవుడు చదివితే అది వ్యంగ్యం అని తెలుసుకుంటాడు.
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). VADER: సోషల్ మీడియా టెక్స్ట్ సెంటిమెంట్ విశ్లేషణ కోసం ఒక సరళమైన నియమాధారిత మోడల్. ఎనిమిదవ అంతర్జాతీయ వెబ్‌లాగ్స్ మరియు సోషల్ మీడియా కాన్ఫరెన్స్ (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/te/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:45:39+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/assignment.md",
"language_code": "te"
}
-->
# వేరే డేటాసెట్ ప్రయత్నించండి
## సూచనలు
ఇప్పుడు మీరు టెక్స్ట్‌కు భావోద్వేగాన్ని కేటాయించడానికి NLTK ఉపయోగించడం గురించి నేర్చుకున్నందున, వేరే డేటాసెట్‌ను ప్రయత్నించండి. మీరు దాని చుట్టూ కొంత డేటా ప్రాసెసింగ్ చేయాల్సి ఉండవచ్చు, కాబట్టి ఒక నోట్‌బుక్ సృష్టించి మీ ఆలోచనా ప్రక్రియను డాక్యుమెంట్ చేయండి. మీరు ఏమి కనుగొంటారు?
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైన | సరిపడిన | మెరుగుదల అవసరం |
| -------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------- |
| | భావోద్వేగం ఎలా కేటాయించబడిందో వివరించే బాగా డాక్యుమెంట్ చేసిన సెల్స్‌తో పూర్తి నోట్‌బుక్ మరియు డేటాసెట్ అందించబడింది | నోట్‌బుక్‌లో మంచి వివరణలు లేవు | నోట్‌బుక్ లోపభూయిష్టం |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

172
translations/te/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:35+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb",
"language_code": "te"
}
},
"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/te/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:46+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/2-notebook.ipynb",
"language_code": "te"
}
},
"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ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
]
}

260
translations/te/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:49:57+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb",
"language_code": "te"
}
},
"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/te/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:32+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/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:04+00:00",
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

@ -0,0 +1,40 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1eb379dc2d0c9940b320732d16083778",
"translation_date": "2025-12-19T13:02:18+00:00",
"source_file": "6-NLP/README.md",
"language_code": "te"
}
-->
# సహజ భాషా ప్రాసెసింగ్‌తో ప్రారంభించడం
సహజ భాషా ప్రాసెసింగ్ (NLP) అనేది కంప్యూటర్ ప్రోగ్రామ్‌కు మానవ భాషను మాట్లాడినట్లు మరియు రాసినట్లు అర్థం చేసుకునే సామర్థ్యం -- దీనిని సహజ భాషగా పిలుస్తారు. ఇది కృత్రిమ మేధస్సు (AI) యొక్క ఒక భాగం. NLP 50 సంవత్సరాలకుపైగా ఉంది మరియు భాషాశాస్త్ర రంగంలో మూలాలు కలిగి ఉంది. మొత్తం రంగం యంత్రాలు మానవ భాషను అర్థం చేసుకోవడంలో మరియు ప్రాసెస్ చేయడంలో సహాయపడటానికి దృష్టి సారించింది. దీన్ని స్పెల్ చెక్ లేదా యంత్ర అనువాదం వంటి పనులను నిర్వహించడానికి ఉపయోగించవచ్చు. ఇది వైద్య పరిశోధన, సెర్చ్ ఇంజిన్లు మరియు వ్యాపార మేధస్సు వంటి అనేక రంగాలలో వాస్తవ ప్రపంచ అనువర్తనాలను కలిగి ఉంది.
## ప్రాంతీయ విషయం: యూరోపియన్ భాషలు మరియు సాహిత్యం మరియు యూరోపియన్ రొమాంటిక్ హోటల్స్ ❤️
ఈ పాఠ్యాంశంలో, మీరు యంత్ర అభ్యాసం యొక్క అత్యంత విస్తృత ఉపయోగాలలో ఒకటైన సహజ భాషా ప్రాసెసింగ్ (NLP) పరిచయం పొందుతారు. కంప్యూటేషనల్ లింగ్విస్టిక్స్ నుండి ఉద్భవించిన ఈ కృత్రిమ మేధస్సు విభాగం మానవులు మరియు యంత్రాల మధ్య వాయిస్ లేదా పాఠ్య కమ్యూనికేషన్ ద్వారా సేతువుగా ఉంటుంది.
ఈ పాఠాలలో మనం NLP యొక్క ప్రాథమికాలను చిన్న సంభాషణ బాట్లను నిర్మించడం ద్వారా నేర్చుకుంటాము, యంత్ర అభ్యాసం ఈ సంభాషణలను మరింత 'స్మార్ట్' గా చేయడంలో ఎలా సహాయపడుతుందో తెలుసుకుంటాము. మీరు జేన్ ఆస్టెన్ యొక్క క్లాసిక్ నవల **ప్రైడ్ అండ్ ప్రెజుడిస్**, 1813లో ప్రచురించబడిన ఎలిజబెత్ బెన్నెట్ మరియు మిస్టర్ డార్సీతో చర్చిస్తూ కాలంలో వెనక్కి ప్రయాణిస్తారు. ఆ తర్వాత, మీరు యూరోపియన్ హోటల్ సమీక్షల ద్వారా భావ విశ్లేషణ గురించి మరింత తెలుసుకుంటారు.
![Pride and Prejudice book and tea](../../../translated_images/p&p.279f1c49ecd889419e4ce6206525e9aa30d32a976955cd24daa636c361c6391f.te.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 -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/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:07+00:00",
"source_file": "6-NLP/data/README.md",
"language_code": "te"
}
-->
హోటల్ సమీక్ష డేటాను ఈ ఫోల్డర్‌లో డౌన్లోడ్ చేయండి.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

201
translations/te/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:02:50+00:00",
"source_file": "7-TimeSeries/1-Introduction/README.md",
"language_code": "te"
}
-->
# టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం
![స్కెచ్ నోట్‌లో టైమ్ సిరీస్ సారాంశం](../../../../translated_images/ml-timeseries.fb98d25f1013fc0c59090030080b5d1911ff336427bec31dbaf1ad08193812e9.te.png)
> స్కెచ్ నోట్ [Tomomi Imura](https://www.twitter.com/girlie_mac) ద్వారా
ఈ పాఠంలో మరియు తదుపరి పాఠంలో, మీరు టైమ్ సిరీస్ ఫోర్కాస్టింగ్ గురించి కొంత తెలుసుకుంటారు, ఇది ఒక ఆసక్తికరమైన మరియు విలువైన భాగం, ఇది ఇతర విషయాల కంటే కొంత తక్కువగా తెలిసినది. టైమ్ సిరీస్ ఫోర్కాస్టింగ్ అనేది ఒక రకమైన 'క్రిస్టల్ బాల్': ధర వంటి ఒక వేరియబుల్ గత ప్రదర్శన ఆధారంగా, మీరు దాని భవిష్యత్తు సామర్థ్య విలువను అంచనా వేయవచ్చు.
[![టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం](https://img.youtube.com/vi/cBojo1hsHiI/0.jpg)](https://youtu.be/cBojo1hsHiI "టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం")
> 🎥 టైమ్ సిరీస్ ఫోర్కాస్టింగ్ గురించి వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
ఇది వ్యాపారానికి ప్రత్యక్ష ప్రయోజనాన్ని కలిగించే ఉపయోగకరమైన మరియు ఆసక్తికరమైన రంగం, ధర నిర్ణయం, నిల్వ, మరియు సరఫరా గొలుసు సమస్యలకు ప్రత్యక్ష అన్వయంతో. భవిష్యత్తు ప్రదర్శనను మెరుగ్గా అంచనా వేయడానికి లోతైన అభ్యాస సాంకేతికతలు ఉపయోగించబడుతున్నప్పటికీ, టైమ్ సిరీస్ ఫోర్కాస్టింగ్ క్లాసిక్ ML సాంకేతికతల ద్వారా చాలా సమాచారం పొందిన రంగంగా కొనసాగుతుంది.
> Penn State యొక్క ఉపయోగకరమైన టైమ్ సిరీస్ పాఠ్యక్రమం [ఇక్కడ](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) ఉంది, ఇది మౌనా లోఆ ఆబ్జర్వేటరీలో నెలవారీ C02 సాంద్రతను నమోదు చేస్తుంది:
| 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) వివిధ రకాల ప్లాట్లు డేటాలో సీజనాలిటీని ఎలా చూపిస్తాయో.
🎓 **అత్యంత భిన్నమైన విలువలు (Outliers)**
అత్యంత భిన్నమైన విలువలు సాధారణ డేటా వ్యత్యాసం నుండి చాలా దూరంగా ఉంటాయి.
🎓 **దీర్ఘకాలిక చక్రం**
సీజనాలిటీకి సంబంధం లేకుండా, డేటా దీర్ఘకాలిక చక్రాన్ని చూపవచ్చు, ఉదాహరణకు ఆర్థిక మాంద్యం ఇది ఒక సంవత్సరం కంటే ఎక్కువకాలం ఉండవచ్చు.
🎓 **స్థిరమైన వ్యత్యాసం**
సమయంతో, కొన్ని డేటా స్థిరమైన మార్పులను చూపుతాయి, ఉదాహరణకు రోజూ మరియు రాత్రి విద్యుత్ వినియోగం.
🎓 **అचानक మార్పులు**
డేటా ఒక అకస్మాత్తు మార్పును చూపవచ్చు, దీనికి మరింత విశ్లేషణ అవసరం. ఉదాహరణకు COVID కారణంగా వ్యాపారాల అకస్మాత్తు మూసివేత డేటాలో మార్పులు కలిగించింది.
✅ ఇది ఒక [నమూనా టైమ్ సిరీస్ ప్లాట్](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python), ఇది కొన్ని సంవత్సరాల పాటు రోజువారీ గేమ్ కరెన్సీ ఖర్చును చూపిస్తుంది. మీరు పై పేర్కొన్న లక్షణాలలో ఏవైనా ఈ డేటాలో గుర్తించగలరా?
![ఇన్-గేమ్ కరెన్సీ ఖర్చు](../../../../translated_images/currency.e7429812bfc8c6087b2d4c410faaa4aaa11b2fcaabf6f09549b8249c9fbdb641.te.png)
## వ్యాయామం - విద్యుత్ వినియోగ డేటాతో ప్రారంభం
గత వినియోగం ఆధారంగా భవిష్యత్తు విద్యుత్ వినియోగాన్ని అంచనా వేయడానికి టైమ్ సిరీస్ నమూనాను సృష్టించడం ప్రారంభిద్దాం.
> ఈ ఉదాహరణలో డేటా GEFCom2014 ఫోర్కాస్టింగ్ పోటీ నుండి తీసుకోబడింది. ఇది 2012 నుండి 2014 వరకు 3 సంవత్సరాల గంటల వారీ విద్యుత్ లోడ్ మరియు ఉష్ణోగ్రత విలువలను కలిగి ఉంది.
>
> Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli మరియు Rob J. Hyndman, "Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and beyond", International Journal of Forecasting, vol.32, no.3, pp 896-913, July-September, 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.te.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.te.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 -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/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:07:50+00:00",
"source_file": "7-TimeSeries/1-Introduction/assignment.md",
"language_code": "te"
}
-->
# మరికొన్ని టైమ్ సిరీస్‌లను విజువలైజ్ చేయండి
## సూచనలు
మీరు టైమ్ సిరీస్ ఫోర్కాస్టింగ్ గురించి ఈ ప్రత్యేక మోడలింగ్ అవసరమయ్యే డేటా రకాన్ని చూసి నేర్చుకోవడం ప్రారంభించారు. మీరు ఎనర్జీ చుట్టూ కొంత డేటాను విజువలైజ్ చేశారు. ఇప్పుడు, టైమ్ సిరీస్ ఫోర్కాస్టింగ్ నుండి లాభపడే మరొక డేటాను వెతకండి. మూడు ఉదాహరణలను కనుగొనండి ([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/te/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:15+00:00",
"source_file": "7-TimeSeries/1-Introduction/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/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:14:49+00:00",
"source_file": "7-TimeSeries/1-Introduction/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

63
translations/te/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:22+00:00",
"source_file": "7-TimeSeries/1-Introduction/working/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

409
translations/te/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:08:40+00:00",
"source_file": "7-TimeSeries/2-ARIMA/README.md",
"language_code": "te"
}
-->
# ARIMA తో టైమ్ సిరీస్ ఫోర్కాస్టింగ్
మునుపటి పాఠంలో, మీరు టైమ్ సిరీస్ ఫోర్కాస్టింగ్ గురించి కొంత తెలుసుకున్నారు మరియు ఒక డేటాసెట్‌ను లోడ్ చేసుకున్నారు, ఇది ఒక కాల వ్యవధిలో విద్యుత్ లోడ్ మార్పులను చూపిస్తుంది.
[![Introduction to ARIMA](https://img.youtube.com/vi/IUSk-YDau10/0.jpg)](https://youtu.be/IUSk-YDau10 "Introduction to 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 తో పని చేయడానికి, మీరు తెలుసుకోవలసిన కొన్ని కాన్సెప్ట్‌లు ఉన్నాయి:
- 🎓 **స్టేషనరీటీ**. గణాంక పరంగా, స్టేషనరీటీ అనగా డేటా పంపిణీ కాలంతో మారదు. నాన్-స్టేషనరీ డేటా అంటే ట్రెండ్ల కారణంగా మార్పులు చూపుతుంది, వాటిని విశ్లేషించడానికి మార్చాలి. ఉదాహరణకు, సీజనాలిటీ డేటాలో మార్పులు తీసుకురావచ్చు, దీన్ని 'సీజనల్-డిఫరెన్సింగ్' ప్రక్రియ ద్వారా తొలగించవచ్చు.
- 🎓 **[డిఫరెన్సింగ్](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. గణాంక పరంగా, డిఫరెన్సింగ్ అనగా నాన్-స్టేషనరీ డేటాను స్టేషనరీగా మార్చే ప్రక్రియ, దీని ద్వారా ట్రెండ్ తొలగించబడుతుంది. "డిఫరెన్సింగ్ టైమ్ సిరీస్ స్థాయిలో మార్పులను తొలగించి, ట్రెండ్ మరియు సీజనాలిటీని తొలగించి, టైమ్ సిరీస్ సగటును స్థిరపరుస్తుంది." [షిక్సియాంగ్ మరియు ఇతరుల పేపర్](https://arxiv.org/abs/1904.07632)
## టైమ్ సిరీస్ సందర్భంలో ARIMA
ARIMA భాగాలను విప్పి చూద్దాం, ఇది టైమ్ సిరీస్ మోడలింగ్ మరియు ఫోర్కాస్టింగ్ లో ఎలా సహాయపడుతుందో అర్థం చేసుకుందాం.
- **AR - ఆటోరెగ్రెసివ్ కోసం**. ఆటోరెగ్రెసివ్ మోడల్స్, పేరుకి అనుగుణంగా, గత విలువలను విశ్లేషించి అంచనాలు వేస్తాయి. ఈ గత విలువలను 'లాగ్స్' అంటారు. ఉదాహరణకు, నెలవారీ పెన్సిల్ అమ్మకాలు డేటా. ప్రతి నెల అమ్మకాలు 'ఎవల్వింగ్ వేరియబుల్' గా పరిగణించబడతాయి. ఈ మోడల్ "ఎవల్వింగ్ వేరియబుల్ తన స్వంత లాగ్డ్ (మునుపటి) విలువలపై రిగ్రెషన్ చేయబడుతుంది." [వికీపీడియా](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average)
- **I - ఇంటిగ్రేటెడ్ కోసం**. ARMA మోడల్స్ తో పోల్చితే, ARIMA లో 'I' దాని *[ఇంటిగ్రేటెడ్](https://wikipedia.org/wiki/Order_of_integration)* అంశాన్ని సూచిస్తుంది. డిఫరెన్సింగ్ దశలు వర్తింపజేసి నాన్-స్టేషనరీతను తొలగిస్తారు.
- **MA - మూవింగ్ అవరేజ్ కోసం**. ఈ మోడల్ యొక్క [మూవింగ్-అవరేజ్](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` Python లైబ్రరీని లోడ్ చేయడానికి నోట్బుక్ నడపండి; 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. సెప్టెంబర్ 1 నుండి అక్టోబర్ 31, 2014 వరకు రెండు నెలల కాలాన్ని ట్రైనింగ్ సెట్కు కేటాయించండి. టెస్ట్ సెట్లో నవంబర్ 1 నుండి డిసెంబర్ 31, 2014 వరకు రెండు నెలల కాలం ఉంటుంది:
```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()
```
![training and testing data](../../../../translated_images/train-test.8928d14e5b91fc942f0ca9201b2d36c890ea7e98f7619fd94f75de3a4c2bacb9.te.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()
```
![original](../../../../translated_images/original.b2b15efe0ce92b8745918f071dceec2231661bf49c8db6918e3ff4b3b0b183c2.te.png)
> ఒరిజినల్ డేటా
![scaled](../../../../translated_images/scaled.e35258ca5cd3d43f86d5175e584ba96b38d51501f234abf52e11f4fe2631e45f.te.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()` ఫంక్షన్ పిలిచి, ముందస్తు కాలం (horizon) ను పేర్కొని అంచనాలు చేయండి.
> 🎓 ఈ అన్ని పరామితులు ఏమికో? 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` వాలిడేషన్ చేయవచ్చు. ప్రాక్టికల్‌గా, టైమ్ సిరీస్ మోడల్స్ ప్రతి కొత్త డేటా అందుకున్నప్పుడు మళ్లీ ట్రైన్ చేయబడతాయి. ఇది ప్రతి టైమ్ స్టెప్‌లో ఉత్తమ ఫోర్కాస్ట్ చేయడానికి సహాయపడుతుంది.
టైమ్ సిరీస్ ప్రారంభంలో ఈ పద్ధతిని ఉపయోగించి, ట్రైన్ డేటా సెట్లో మోడల్‌ను ట్రైన్ చేయండి. తరువాత తదుపరి టైమ్ స్టెప్‌పై అంచనాలు చేయండి. అంచనా తెలిసిన విలువతో పోల్చబడుతుంది. ట్రైన్ సెట్లో ఆ విలువను చేర్చడం ద్వారా విస్తరించబడుతుంది మరియు ప్రక్రియ పునరావృతమవుతుంది.
> గమనిక: ట్రైనింగ్ సమయాన్ని సమర్థవంతంగా ఉంచడానికి, ట్రైన్ సెట్లో కొత్త ఆబ్జర్వేషన్ చేర్చినప్పుడు, మొదటి ఆబ్జర్వేషన్ తొలగించాలి.
ఈ ప్రక్రియ మోడల్ ప్రాక్టికల్‌లో ఎలా పనిచేస్తుందో మరింత బలమైన అంచనాను ఇస్తుంది. అయితే, ఇది చాలా మోడల్స్ సృష్టించాల్సిన కంప్యూటేషన్ ఖర్చుతో వస్తుంది. డేటా చిన్నదైతే లేదా మోడల్ సింపుల్ అయితే ఇది అనుకూలం, కానీ పెద్ద స్థాయిలో సమస్య కావచ్చు.
వాక్-ఫార్వర్డ్ వాలిడేషన్ టైమ్ సిరీస్ మోడల్ అంచనా వేయడంలో గోల్డ్ స్టాండర్డ్ మరియు మీ ప్రాజెక్టులకు సిఫార్సు చేయబడుతుంది.
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.te.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.te.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 -->

26
translations/te/7-TimeSeries/2-ARIMA/assignment.md
Unescape View File

@ -0,0 +1,26 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1c814013e10866dfd92cdb32caaae3ac",
"translation_date": "2025-12-19T16:13:29+00:00",
"source_file": "7-TimeSeries/2-ARIMA/assignment.md",
"language_code": "te"
}
-->
# కొత్త 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/te/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:23+00:00",
"source_file": "7-TimeSeries/2-ARIMA/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/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:15:54+00:00",
"source_file": "7-TimeSeries/2-ARIMA/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

59
translations/te/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:28+00:00",
"source_file": "7-TimeSeries/2-ARIMA/working/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# ARIMA తో టైమ్ సిరీస్ ఫోర్కాస్టింగ్\n",
"\n",
"ఈ నోట్‌బుక్‌లో, మేము ఎలా చేయాలో చూపిస్తాము:\n",
"- ARIMA టైమ్ సిరీస్ ఫోర్కాస్టింగ్ మోడల్ శిక్షణ కోసం టైమ్ సిరీస్ డేటాను సిద్ధం చేయడం\n",
"- టైమ్ సిరీస్‌లో తదుపరి HORIZON దశలను ముందుగా (సమయం *t+1* నుండి *t+HORIZON* వరకు) ఫోర్కాస్ట్ చేయడానికి ఒక సాదారణ ARIMA మోడల్‌ను అమలు చేయడం\n",
"- మోడల్‌ను మూల్యాంకనం చేయడం\n",
"\n",
"ఈ ఉదాహరణలో డేటా GEFCom2014 ఫోర్కాస్టింగ్ పోటీ<sup>1</sup> నుండి తీసుకోబడింది. ఇది 2012 నుండి 2014 వరకు 3 సంవత్సరాల గంటల వారీ విద్యుత్ లోడ్ మరియు ఉష్ణోగ్రత విలువలను కలిగి ఉంది. పని భవిష్యత్తు విద్యుత్ లోడ్ విలువలను ఫోర్కాస్ట్ చేయడం. ఈ ఉదాహరణలో, మేము చారిత్రక లోడ్ డేటాను మాత్రమే ఉపయోగించి ఒక టైమ్ స్టెప్ ముందుకు ఎలా ఫోర్కాస్ట్ చేయాలో చూపిస్తాము.\n",
"\n",
"<sup>1</sup>Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli and Rob J. Hyndman, \"Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and beyond\", International Journal of Forecasting, vol.32, no.3, pp 896-913, July-September, 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ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
]
}

402
translations/te/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:56:34+00:00",
"source_file": "7-TimeSeries/3-SVR/README.md",
"language_code": "te"
}
-->
# టైమ్ సిరీస్ ఫోర్కాస్టింగ్ విత్ సపోర్ట్ వెక్టర్ రిగ్రెసర్
మునుపటి పాఠంలో, మీరు టైమ్ సిరీస్ అంచనాలు చేయడానికి ARIMA మోడల్‌ను ఎలా ఉపయోగించాలో నేర్చుకున్నారు. ఇప్పుడు మీరు సపోర్ట్ వెక్టర్ రిగ్రెసర్ మోడల్‌ను చూడబోతున్నారు, ఇది నిరంతర డేటాను అంచనా వేయడానికి ఉపయోగించే రిగ్రెసర్ మోడల్.
## [ప్రీ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## పరిచయం
ఈ పాఠంలో, మీరు రిగ్రెషన్ కోసం [**SVM**: **S**పోర్ట్ **V**ెక్టర్ **M**షీన్](https://en.wikipedia.org/wiki/Support-vector_machine) తో మోడల్స్‌ను నిర్మించే ఒక ప్రత్యేక విధానాన్ని కనుగొంటారు, లేదా **SVR: సపోర్ట్ వెక్టర్ రిగ్రెసర్**.
### టైమ్ సిరీస్ సందర్భంలో SVR [^1]
టైమ్ సిరీస్ అంచనాలో SVR ప్రాముఖ్యతను అర్థం చేసుకోవడానికి ముందు, మీరు తెలుసుకోవలసిన కొన్ని ముఖ్యమైన భావనలు ఇవి:
- **రిగా్రెషన్:** నిర్దేశిత ఇన్‌పుట్‌ల నుండి నిరంతర విలువలను అంచనా వేయడానికి సూపర్వైజ్డ్ లెర్నింగ్ సాంకేతికత. ఆలోచన ఏమిటంటే ఫీచర్ స్పేస్‌లో గరిష్ట సంఖ్యలో డేటా పాయింట్లను కలిగిన వక్రరేఖ (లేదా రేఖ) ను సరిపోల్చడం. మరింత సమాచారం కోసం [ఇక్కడ క్లిక్ చేయండి](https://en.wikipedia.org/wiki/Regression_analysis).
- **సపోర్ట్ వెక్టర్ మెషీన్ (SVM):** వర్గీకరణ, రిగ్రెషన్ మరియు అవుట్లయర్స్ గుర్తింపు కోసం ఉపయోగించే ఒక రకమైన సూపర్వైజ్డ్ మెషీన్ లెర్నింగ్ మోడల్. ఈ మోడల్ ఫీచర్ స్పేస్‌లో ఒక హైపర్ప్లేన్, వర్గీకరణ సందర్భంలో ఇది సరిహద్దుగా పనిచేస్తుంది, రిగ్రెషన్ సందర్భంలో ఇది ఉత్తమ సరిపోలే రేఖగా పనిచేస్తుంది. SVMలో, సాధారణంగా కర్నెల్ ఫంక్షన్ ఉపయోగించి డేటాసెట్‌ను ఎక్కువ కొలతల స్థలానికి మార్చుతారు, తద్వారా అవి సులభంగా వేరుచేయగలవు. SVMs గురించి మరింత సమాచారం కోసం [ఇక్కడ క్లిక్ చేయండి](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()
```
![full data](../../../../translated_images/full-data.a82ec9957e580e976f651a4fc38f280b9229c6efdbe3cfe7c60abaa9486d2cbe.te.png)
ఇప్పుడు, మన SVR మోడల్‌ను నిర్మిద్దాం.
### శిక్షణ మరియు పరీక్ష డేటాసెట్‌లను సృష్టించండి
ఇప్పుడు మీ డేటా లోడ్ అయింది, కాబట్టి మీరు దాన్ని శిక్షణ మరియు పరీక్ష సెట్లుగా విడగొట్టవచ్చు. ఆపై మీరు SVR కోసం అవసరమైన టైమ్-స్టెప్ ఆధారిత డేటాసెట్ సృష్టించడానికి డేటాను పునఃరూపకల్పన చేస్తారు. మీరు మీ మోడల్‌ను శిక్షణ సెట్లో శిక్షణ ఇస్తారు. మోడల్ శిక్షణ పూర్తయిన తర్వాత, మీరు దాని ఖచ్చితత్వాన్ని శిక్షణ సెట్లో, పరీక్ష సెట్లో మరియు మొత్తం డేటాసెట్‌పై అంచనా వేస్తారు. మోడల్ భవిష్యత్తు కాలం నుండి సమాచారం పొందకుండా ఉండేందుకు పరీక్ష సెట్లో శిక్షణ సెట్లో కంటే తర్వాతి కాలం ఉండాలి [^2] (ఇది *ఓవర్‌ఫిట్టింగ్* అని పిలవబడే పరిస్థితి).
1. సెప్టెంబర్ 1 నుండి అక్టోబర్ 31, 2014 వరకు రెండు నెలల కాలాన్ని శిక్షణ సెట్కు కేటాయించండి. పరీక్ష సెట్లో నవంబర్ 1 నుండి డిసెంబర్ 31, 2014 వరకు రెండు నెలల కాలం ఉంటుంది: [^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()
```
![training and testing data](../../../../translated_images/train-test.ead0cecbfc341921d4875eccf25fed5eefbb860cdbb69cabcc2276c49e4b33e5.te.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 టెన్సర్‌గా మార్చడం:
```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 కర్నెల్](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()
```
![training data prediction](../../../../translated_images/train-data-predict.3c4ef4e78553104ffdd53d47a4c06414007947ea328e9261ddf48d3eafdefbbf.te.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()
```
![testing data prediction](../../../../translated_images/test-data-predict.8afc47ee7e52874f514ebdda4a798647e9ecf44a97cc927c535246fcf7a28aa9.te.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()
```
![full data prediction](../../../../translated_images/full-data-predict.4f0fed16a131c8f3bcc57a3060039dc7f2f714a05b07b68c513e0fe7fb3d8964.te.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) ఉన్న డాక్యుమెంటేషన్‌ను చూడవచ్చు.
- మోడల్ కోసం వేరే కర్నెల్ ఫంక్షన్లను ఉపయోగించి వాటి పనితీరును విశ్లేషించండి. సహాయక డాక్యుమెంటేషన్ [ఇక్కడ](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) SVMs గురించి సాధారణంగా, [SVRs](https://scikit-learn.org/stable/modules/svm.html#regression) మరియు వేరే అమలు వివరాలు, వాడే వేర్వేరు [కర్నెల్ ఫంక్షన్లు](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/te/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:04+00:00",
"source_file": "7-TimeSeries/3-SVR/assignment.md",
"language_code": "te"
}
-->
# కొత్త 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 -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

711
translations/te/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",
"- SVM రిగ్రెసర్ మోడల్ శిక్షణ కోసం 2D టైమ్ సిరీస్ డేటాను సిద్ధం చేయాలి\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:33:32+00:00",
"source_file": "7-TimeSeries/3-SVR/working/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 1
}

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

@ -0,0 +1,39 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "61342603bad8acadbc6b2e4e3aab3f66",
"translation_date": "2025-12-19T13:11:03+00:00",
"source_file": "7-TimeSeries/README.md",
"language_code": "te"
}
-->
# టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం
టైమ్ సిరీస్ ఫోర్కాస్టింగ్ అంటే ఏమిటి? ఇది గత ధోరణులను విశ్లేషించి భవిష్యత్తు సంఘటనలను అంచనా వేయడం.
## ప్రాంతీయ విషయం: ప్రపంచవ్యాప్తంగా విద్యుత్ వినియోగం ✨
ఈ రెండు పాఠాలలో, మీరు టైమ్ సిరీస్ ఫోర్కాస్టింగ్‌కు పరిచయం అవుతారు, ఇది యంత్ర అభ్యాసంలో కొంతమేరకు తక్కువగా తెలిసిన ప్రాంతం అయినప్పటికీ, పరిశ్రమ మరియు వ్యాపార అనువర్తనాల కోసం చాలా విలువైనది, ఇతర రంగాలతో పాటు. న్యూరల్ నెట్‌వర్క్‌లను ఈ మోడల్స్ యొక్క ఉపయోగకరతను పెంచడానికి ఉపయోగించవచ్చు, కానీ మేము వాటిని క్లాసికల్ యంత్ర అభ్యాసం సందర్భంలో అధ్యయనం చేస్తాము, ఎందుకంటే మోడల్స్ గత ఆధారంగా భవిష్యత్తు పనితీరును అంచనా వేయడంలో సహాయపడతాయి.
మా ప్రాంతీయ దృష్టి ప్రపంచంలో విద్యుత్ వినియోగం మీద ఉంది, ఇది గత లోడ్ నమూనాల ఆధారంగా భవిష్యత్తు విద్యుత్ వినియోగాన్ని అంచనా వేయడాన్ని నేర్చుకోవడానికి ఆసక్తికరమైన డేటాసెట్. ఈ రకమైన ఫోర్కాస్టింగ్ వ్యాపార వాతావరణంలో ఎంతగానో సహాయకరమవుతుందో మీరు చూడవచ్చు.
![electric grid](../../../translated_images/electric-grid.0c21d5214db09ffae93c06a87ca2abbb9ba7475ef815129c5b423d7f9a7cf136.te.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. [టైమ్ సిరీస్ ఫోర్కాస్టింగ్ కోసం సపోర్ట్ వెక్టర్ రిగ్రెసర్ నిర్మాణం](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/te/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:44:59+00:00",
"source_file": "8-Reinforcement/1-QLearning/README.md",
"language_code": "te"
}
-->
# రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ మరియు క్యూ-లెర్నింగ్ పరిచయం
![మిషన్ లెర్నింగ్‌లో రీన్ఫోర్స్‌మెంట్ యొక్క సారాంశం స్కెచ్‌నోట్‌లో](../../../../translated_images/ml-reinforcement.94024374d63348dbb3571c343ca7ddabef72adac0b8086d47164b769ba3a8a1d.te.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/Peter_and_the_Wolf)** ప్రపంచాన్ని అన్వేషిస్తాము, ఇది రష్యన్ కంపోజర్ [సెర్గే ప్రోకోఫీవ్](https://en.wikipedia.org/wiki/Sergei_Prokofiev) యొక్క సంగీత కథనంతో ప్రేరణ పొందింది. మనం **రీన్ఫోర్స్‌మెంట్ లెర్నింగ్** ఉపయోగించి, పీటర్ తన పరిసరాలను అన్వేషించి, రుచికరమైన ఆపిల్స్ సేకరించి, వోల్ఫ్‌ను కలవకుండా ఉండేందుకు సహాయపడతాము.
**రీన్ఫోర్స్‌మెంట్ లెర్నింగ్** (RL) అనేది ఒక లెర్నింగ్ సాంకేతికత, ఇది మనకు ఒక **ఏజెంట్** యొక్క ఆప్టిమల్ ప్రవర్తనను కొన్ని **పరిసరాల్లో** అనేక ప్రయోగాలు నిర్వహించడం ద్వారా నేర్చుకోవడానికి అనుమతిస్తుంది. ఈ పరిసరంలో ఏజెంట్‌కు ఒక **లక్ష్యం** ఉండాలి, ఇది **రివార్డ్ ఫంక్షన్** ద్వారా నిర్వచించబడుతుంది.
## పరిసరం
సరళత కోసం, మనం పీటర్ ప్రపంచాన్ని `width` x `height` పరిమాణం గల చతురస్ర బోర్డు అని పరిగణిద్దాం, ఇలా:
![పీటర్ పరిసరం](../../../../translated_images/environment.40ba3cb66256c93fa7e92f6f7214e1d1f588aafa97d266c11d108c5c5d101b6c.te.png)
ఈ బోర్డు లో ప్రతి సెల్:
* **భూమి**, పీటర్ మరియు ఇతర జీవులు నడవగలిగే స్థలం.
* **నీరు**, ఇది మీరు స్పష్టంగా నడవలేరు.
* **చెట్టు** లేదా **గడ్డి**, మీరు విశ్రాంతి తీసుకునే స్థలం.
* **ఆపిల్**, ఇది పీటర్ తనకు ఆహారం కోసం కనుగొనడం ఇష్టపడే వస్తువు.
* **వోల్ఫ్**, ఇది ప్రమాదకరం మరియు దూరంగా ఉండాలి.
ఈ పరిసరంతో పని చేయడానికి ప్రత్యేకమైన పాథాన్ మాడ్యూల్ [`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
```
రివార్డ్ ఫంక్షన్‌ల గురించి ఆసక్తికరమైన విషయం ఏమిటంటే, చాలా సందర్భాల్లో, *మనం గేమ్ చివరలోనే పెద్ద రివార్డ్ పొందుతాము*. అంటే మన అల్గోరిథం "మంచి" అడుగులను గుర్తుంచుకోవాలి, అవి చివరలో సానుకూల రివార్డ్‌కు దారితీస్తాయి, మరియు వాటి ప్రాధాన్యతను పెంచాలి. అలాగే, చెడు ఫలితాలకు దారితీసే అన్ని కదలికలను నిరుత్సాహపరచాలి.
## క్యూ-లెర్నింగ్
ఇక్కడ మనం చర్చించబోయే అల్గోరిథం **క్యూ-లెర్నింగ్** అని పిలవబడుతుంది. ఈ అల్గోరిథంలో, పాలసీ ఒక ఫంక్షన్ (లేదా డేటా స్ట్రక్చర్) ద్వారా నిర్వచించబడుతుంది, దీనిని **Q-టేబుల్** అంటారు. ఇది ప్రతి స్టేట్‌లోని చర్యల "మంచితనాన్ని" నమోదు చేస్తుంది.
దీన్ని Q-టేబుల్ అంటారు ఎందుకంటే దీన్ని సాధారణంగా ఒక పట్టిక లేదా బహుమాణిక శ్రేణిగా ప్రాతినిధ్యం వహించడం సౌకర్యవంతం. మన బోర్డు `width` x `height` పరిమాణం కలిగి ఉండగా, మనం Q-టేబుల్‌ను numpy శ్రేణిగా `width` x `height` x `len(actions)` ఆకారంలో ప్రాతినిధ్యం వహించవచ్చు: (కోడ్ బ్లాక్ 6)
```python
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
```
గమనించండి, మనం Q-టేబుల్ యొక్క అన్ని విలువలను సమాన విలువతో ప్రారంభిస్తాము, మన సందర్భంలో - 0.25. ఇది "రాండమ్ వాక్" పాలసీకి సరిపోతుంది, ఎందుకంటే ప్రతి స్టేట్‌లో అన్ని కదలికలు సమానంగా మంచివి. మనం Q-టేబుల్‌ను `plot` ఫంక్షన్‌కు పంపించి బోర్డుపై పట్టికను విజువలైజ్ చేయవచ్చు: `m.plot(Q)`.
![పీటర్ పరిసరం](../../../../translated_images/env_init.04e8f26d2d60089e128f21d22e5fef57d580e559f0d5937b06c689e5e7cdd438.te.png)
ప్రతి సెల్ మధ్యలో ఒక "అర్రో" ఉంటుంది, ఇది ప్రాధాన్యత ఉన్న కదలిక దిశను సూచిస్తుంది. అన్ని దిశలు సమానంగా ఉన్నప్పుడు, ఒక బిందువు ప్రదర్శించబడుతుంది.
ఇప్పుడు మనం సిమ్యులేషన్ నడిపించి, మన పరిసరాన్ని అన్వేషించి, Q-టేబుల్ విలువల మంచి పంపిణీని నేర్చుకోవాలి, ఇది మనకు ఆపిల్ దారిని త్వరగా కనుగొనడానికి సహాయపడుతుంది.
## క్యూ-లెర్నింగ్ సారాంశం: బెల్మన్ సమీకరణం
మనము కదలడం ప్రారంభించిన వెంటనే, ప్రతి చర్యకు తక్షణ రివార్డు ఉంటుంది, అంటే మనం సిద్దాంతంగా అత్యధిక తక్షణ రివార్డు ఆధారంగా తదుపరి చర్యను ఎంచుకోవచ్చు. అయితే, చాలా స్టేట్స్‌లో, ఆ కదలిక మన లక్ష్యం అయిన ఆపిల్ చేరుకోవడాన్ని సాధించదు, కాబట్టి ఏ దిశ మంచిదో తక్షణమే నిర్ణయించలేము.
> గమనించండి, తక్షణ ఫలితం కాదు, కానీ చివరి ఫలితం ముఖ్యం, అది మనం సిమ్యులేషన్ చివర పొందుతాము.
ఈ ఆలస్యం ఉన్న రివార్డును పరిగణలోకి తీసుకోవడానికి, మనం **[డైనమిక్ ప్రోగ్రామింగ్](https://en.wikipedia.org/wiki/Dynamic_programming)** సూత్రాలను ఉపయోగించాలి, ఇవి మన సమస్యను పునరావృతంగా ఆలోచించడానికి అనుమతిస్తాయి.
మనము ఇప్పుడు స్టేట్ *s* లో ఉన్నాము, మరియు తదుపరి స్టేట్ *s'* కి కదలాలనుకుంటున్నాము. అలా చేస్తే, మనం తక్షణ రివార్డు *r(s,a)* పొందుతాము, ఇది రివార్డ్ ఫంక్షన్ ద్వారా నిర్వచించబడుతుంది, అదనంగా కొంత భవిష్యత్ రివార్డు కూడా ఉంటుంది. మన Q-టేబుల్ ప్రతి చర్య యొక్క "ఆకర్షణ"ను సరిగ్గా ప్రతిబింబిస్తుందని అనుకుంటే, స్టేట్ *s'* లో మనం చర్య *a'* ఎంచుకుంటాము, ఇది గరిష్ట విలువ *Q(s',a')* కలిగి ఉంటుంది. కాబట్టి, స్టేట్ *s* లో మనకు లభించే ఉత్తమ భవిష్యత్ రివార్డు `max`<sub>a'</sub>*Q(s',a')* (ఇక్కడ గరిష్టం అన్ని సాధ్యమైన చర్యలపై లెక్కించబడుతుంది).
ఇది స్టేట్ *s* లో చర్య *a* కోసం Q-టేబుల్ విలువను లెక్కించే **బెల్మన్ సూత్రం**:
<img src="../../../../translated_images/bellman-equation.7c0c4c722e5a6b7c208071a0bae51664965050848e4f8a84bb377cd18bdd838b.te.png"/>
ఇక్కడ γ అనేది **డిస్కౌంట్ ఫ్యాక్టర్**, ఇది మీరు ప్రస్తుత రివార్డును భవిష్యత్ రివార్డుపై ఎంత ప్రాధాన్యం ఇవ్వాలో నిర్ణయిస్తుంది.
## లెర్నింగ్ అల్గోరిథం
పై సమీకరణ ఆధారంగా, మనం ఇప్పుడు మన లెర్నింగ్ అల్గోరిథం కోసం సPseudo-కోడ్ రాయవచ్చు:
* Q-టేబుల్ Qని అన్ని స్టేట్స్ మరియు చర్యల కోసం సమాన సంఖ్యలతో ప్రారంభించండి
* లెర్నింగ్ రేట్ α ← 1 గా సెట్ చేయండి
* అనేక సార్లు సిమ్యులేషన్‌ను పునరావృతం చేయండి
1. యాదృచ్ఛిక స్థానం నుండి ప్రారంభించండి
1. పునరావృతం చేయండి
1. స్టేట్ *s* లో చర్య *a* ఎంచుకోండి
2. చర్యను అమలు చేసి కొత్త స్టేట్ *s'* కి కదలండి
3. గేమ్ ముగింపు పరిస్థితి లేదా మొత్తం రివార్డు చాలా తక్కువ అయితే సిమ్యులేషన్ నుండి బయటకు రండి
4. కొత్త స్టేట్‌లో రివార్డు *r* లెక్కించండి
5. బెల్మన్ సమీకరణ ప్రకారం Q-ఫంక్షన్‌ను నవీకరించండి: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
6. *s* ← *s'*
7. మొత్తం రివార్డు నవీకరించి α తగ్గించండి.
## ఎక్స్‌ప్లోయిట్ vs ఎక్స్‌ప్లోర్
పై అల్గోరిథంలో, మనం 2.1 దశలో చర్య ఎంచుకోవడం ఎలా చేయాలో స్పష్టంగా చెప్పలేదు. యాదృచ్ఛికంగా చర్య ఎంచుకుంటే, మనం యాదృచ్ఛికంగా పరిసరాన్ని **అన్వేషిస్తాము**, మరియు మనం తరచుగా చనిపోవచ్చు అలాగే సాధారణంగా వెళ్లని ప్రాంతాలను అన్వేషించవచ్చు. మరో దృష్టికోణం, మనం ఇప్పటికే తెలిసిన Q-టేబుల్ విలువలను **ఉపయోగించి**, స్టేట్ *s* లో అత్యుత్తమ చర్యను ఎంచుకోవచ్చు. ఇది, అయితే, ఇతర స్టేట్స్‌ను అన్వేషించకుండా చేస్తుంది, మరియు మనం ఆప్టిమల్ పరిష్కారాన్ని కనుగొనకపోవచ్చు.
కాబట్టి, ఉత్తమ దృష్టికోణం అన్వేషణ మరియు వినియోగం మధ్య సమతుల్యత సాధించడం. ఇది Q-టేబుల్ విలువలకు అనుగుణంగా స్టేట్ *s* లో చర్యను ఎంచుకోవడం ద్వారా చేయవచ్చు. ప్రారంభంలో, Q-టేబుల్ విలువలు సమానంగా ఉన్నప్పుడు, ఇది యాదృచ్ఛిక ఎంపికకు సరిపోతుంది, కానీ మనం పరిసరాన్ని మరింత నేర్చుకున్నప్పుడు, మనం ఆప్టిమల్ మార్గాన్ని అనుసరించడానికి ఎక్కువ అవకాశం ఉంటుంది, మరియు ఏజెంట్ కొన్నిసార్లు అన్వేషించని మార్గాన్ని ఎంచుకునే అవకాశం ఉంటుంది.
## పాథాన్ అమలు
ఇప్పుడు మనం లెర్నింగ్ అల్గోరిథం అమలు చేయడానికి సిద్ధంగా ఉన్నాము. దానికి ముందు, మనకు Q-టేబుల్‌లోని ఏదైనా సంఖ్యలను సంబంధిత చర్యల కోసం ప్రాబబిలిటీల వెక్టర్‌గా మార్చే ఫంక్షన్ అవసరం.
1. `probs()` అనే ఫంక్షన్ సృష్టించండి:
```python
def probs(v,eps=1e-4):
v = v-v.min()+eps
v = v/v.sum()
return v
```
ప్రారంభ సందర్భంలో వెక్టర్ యొక్క అన్ని భాగాలు సమానంగా ఉన్నప్పుడు 0తో భాగించకుండా ఉండేందుకు మేము కొంత `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
```
ఈ అల్గోరిథం అమలు చేసిన తర్వాత, Q-టేబుల్ విలువలు నవీకరించబడతాయి, ఇవి ప్రతి దశలో వివిధ చర్యల ఆకర్షణను నిర్వచిస్తాయి. మనం Q-టేబుల్‌ను విజువలైజ్ చేయడానికి ప్రతి సెల్‌లో ఒక వెక్టర్ డ్రా చేయవచ్చు, ఇది కదలిక యొక్క ఇష్టమైన దిశను సూచిస్తుంది. సరళత కోసం, మనం అర్రో హెడ్ స్థానంలో చిన్న వృత్తాన్ని డ్రా చేస్తాము.
<img src="../../../../translated_images/learned.ed28bcd8484b5287a31925c96c43b43e2c2bb876b8ca41a0e1e754f77bb3db20.te.png"/>
## పాలసీ తనిఖీ
Q-టేబుల్ ప్రతి స్టేట్‌లోని చర్యల "ఆకర్షణ"ను సూచిస్తుండగా, మనం దీన్ని మన ప్రపంచంలో సమర్థవంతమైన నావిగేషన్ నిర్వచించడానికి సులభంగా ఉపయోగించవచ్చు. సులభమైన సందర్భంలో, మనం గరిష్ట Q-టేబుల్ విలువ కలిగిన చర్యను ఎంచుకోవచ్చు: (కోడ్ బ్లాక్ 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.te.png"/>
అభ్యాసాలను సారాంశం చేయవచ్చు:
- **సగటు మార్గ పొడవు పెరుగుతుంది**. ఇక్కడ మనం చూస్తున్నది మొదట, సగటు మార్గ పొడవు పెరుగుతుంది. ఇది సాధ్యమైనది ఎందుకంటే మనం వాతావరణం గురించి ఏమీ తెలియకపోతే, మనం చెడు స్థితుల్లో, నీరు లేదా నక్కలో చిక్కిపోవచ్చు. మనం ఎక్కువ నేర్చుకుంటే మరియు ఈ జ్ఞానాన్ని ఉపయోగించడం ప్రారంభిస్తే, మనం వాతావరణాన్ని ఎక్కువ కాలం అన్వేషించవచ్చు, కానీ మనం ఆపిల్స్ ఎక్కడ ఉన్నాయో బాగా తెలియదు.
- **మార్గ పొడవు తగ్గుతుంది, మనం ఎక్కువ నేర్చుకున్నప్పుడు**. మనం సరిపడా నేర్చుకున్న తర్వాత, ఏజెంట్ లక్ష్యాన్ని సాధించడం సులభం అవుతుంది, మరియు మార్గ పొడవు తగ్గడం ప్రారంభిస్తుంది. అయితే, మనం ఇంకా అన్వేషణకు తెరవబడినవారు, కాబట్టి మనం తరచుగా ఉత్తమ మార్గం నుండి దూరంగా వెళ్ళి కొత్త ఎంపికలను అన్వేషిస్తాము, మార్గం ఆప్టిమల్ కంటే ఎక్కువ పొడవుగా మారుతుంది.
- **పొడవు అకస్మాత్తుగా పెరుగుతుంది**. ఈ గ్రాఫ్‌లో మనం గమనించే మరో విషయం ఏమిటంటే, ఒక సమయంలో పొడవు అకస్మాత్తుగా పెరిగింది. ఇది ప్రక్రియ యొక్క యాదృచ్ఛిక స్వభావాన్ని సూచిస్తుంది, మరియు మనం ఒక సమయంలో Q-టేబుల్ గుణకాలను కొత్త విలువలతో మళ్లీ రాయడం ద్వారా "దెబ్బతీయవచ్చు". ఇది సాధారణంగా అభ్యాస రేటును తగ్గించడం ద్వారా తగ్గించాలి (ఉదాహరణకు, శిక్షణ చివర్లో, మనం Q-టేబుల్ విలువలను చిన్న విలువతో మాత్రమే సవరించాలి).
మొత్తానికి, అభ్యాస ప్రక్రియ విజయవంతం మరియు నాణ్యత చాలా పరామితులపై ఆధారపడి ఉంటుంది, ఉదాహరణకు అభ్యాస రేటు, అభ్యాస రేటు తగ్గింపు, మరియు డిస్కౌంట్ ఫ్యాక్టర్. వీటిని తరచుగా **హైపర్‌పరామితులు** అంటారు, ఇవి శిక్షణ సమయంలో మనం ఆప్టిమైజ్ చేసే **పరామితుల** నుండి వేరుగా ఉంటాయి (ఉదాహరణకు, Q-టేబుల్ గుణకాలు). ఉత్తమ హైపర్‌పరామితుల విలువలను కనుగొనడం ప్రక్రియను **హైపర్‌పరామితి ఆప్టిమైజేషన్** అంటారు, ఇది ఒక ప్రత్యేక విషయం.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## అసైన్‌మెంట్
[మరింత వాస్తవిక ప్రపంచం](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

41
translations/te/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:52:14+00:00",
"source_file": "8-Reinforcement/1-QLearning/assignment.md",
"language_code": "te"
}
-->
# మరింత వాస్తవిక ప్రపంచం
మన పరిస్థితిలో, పీటర్ దాదాపు అలసిపోకుండా లేదా ఆకలితో బాధపడకుండా చుట్టూ తిరగగలిగాడు. మరింత వాస్తవిక ప్రపంచంలో, మనం సమయానికి కూర్చొని విశ్రాంతి తీసుకోవాలి, అలాగే తినుకోవాలి కూడా. మన ప్రపంచాన్ని మరింత వాస్తవికంగా మార్చుకుందాం, క్రింది నియమాలను అమలు చేయడం ద్వారా:
1. ఒక చోట నుండి మరొక చోటకు కదలడం ద్వారా, పీటర్ **శక్తి** కోల్పోతాడు మరియు కొంత **దుర్బలత** పొందుతాడు.
2. పీటర్ ఆపిల్స్ తినడం ద్వారా మరింత శక్తిని పొందవచ్చు.
3. పీటర్ చెట్టు కింద లేదా గడ్డి మీద విశ్రాంతి తీసుకోవడం ద్వారా దుర్బలతను తొలగించుకోవచ్చు (అంటే చెట్టు లేదా గడ్డి ఉన్న బోర్డు స్థలంలో నడవడం - ఆకుపచ్చ మైదానం)
4. పీటర్ నక్కను కనుగొని చంపాలి
5. నక్కను చంపడానికి, పీటర్ కు నిర్దిష్ట స్థాయిల శక్తి మరియు దుర్బలత అవసరం, లేకపోతే అతను యుద్ధంలో ఓడిపోతాడు.
## సూచనలు
మీ పరిష్కారానికి ప్రారంభ బిందువుగా అసలు [notebook.ipynb](notebook.ipynb) నోట్బుక్ ఉపయోగించండి.
పైన ఉన్న రివార్డ్ ఫంక్షన్ ను ఆట నియమాల ప్రకారం మార్చండి, గేమ్ గెలవడానికి ఉత్తమ వ్యూహాన్ని నేర్చుకోవడానికి రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ అల్గోరిథమ్ ను నడపండి, మరియు గెలిచిన మరియు ఓడిపోయిన ఆటల సంఖ్య పరంగా రాండమ్ వాక్ తో మీ అల్గోరిథమ్ ఫలితాలను పోల్చండి.
> **గమనిక**: మీ కొత్త ప్రపంచంలో, స్థితి మరింత సంక్లిష్టంగా ఉంటుంది, మరియు మానవ స్థానానికి అదనంగా దుర్బలత మరియు శక్తి స్థాయిలు కూడా ఉంటాయి. మీరు స్థితిని (Board,energy,fatigue) అనే టుపుల్ గా ప్రదర్శించవచ్చు, లేదా స్థితి కోసం ఒక క్లాస్ నిర్వచించవచ్చు (మీరు దీన్ని `Board` నుండి ఉత్పన్నం చేసుకోవచ్చు), లేదా అసలు `Board` క్లాస్ ను [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py) లో మార్చవచ్చు.
మీ పరిష్కారంలో, దయచేసి రాండమ్ వాక్ వ్యూహానికి సంబంధించిన కోడ్ ను ఉంచండి, మరియు చివరలో మీ అల్గోరిథమ్ ఫలితాలను రాండమ్ వాక్ తో పోల్చండి.
> **గమనిక**: ఇది పనిచేయడానికి మీరు హైపర్‌పారామీటర్లను సర్దుబాటు చేయవలసి ఉండవచ్చు, ముఖ్యంగా ఎపోక్స్ సంఖ్య. ఎందుకంటే ఆటలో విజయం (నక్కతో పోరాటం) అరుదైన సంఘటన, మీరు చాలా ఎక్కువ శిక్షణ సమయం ఆశించవచ్చు.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతం | సరిపోతుంది | మెరుగుదల అవసరం |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| | కొత్త ప్రపంచ నియమాల నిర్వచనం, Q-లెర్నింగ్ అల్గోరిథమ్ మరియు కొన్ని వచన వివరణలతో కూడిన నోట్బుక్ అందించబడింది. Q-లెర్నింగ్ రాండమ్ వాక్ తో పోల్చితే ఫలితాలను గణనీయంగా మెరుగుపరుస్తుంది. | నోట్బుక్ అందించబడింది, Q-లెర్నింగ్ అమలు చేయబడింది మరియు రాండమ్ వాక్ తో పోల్చితే ఫలితాలు మెరుగుపడినవి, కానీ గణనీయంగా కాదు; లేదా నోట్బుక్ బాగా డాక్యుమెంట్ చేయబడలేదు మరియు కోడ్ బాగా నిర్మించబడలేదు | ప్రపంచ నియమాలను పునః నిర్వచించడానికి కొంత ప్రయత్నం జరిగింది, కానీ Q-లెర్నింగ్ అల్గోరిథమ్ పనిచేయడం లేదు, లేదా రివార్డ్ ఫంక్షన్ పూర్తిగా నిర్వచించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారులు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

17
translations/te/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:38+00:00",
"source_file": "8-Reinforcement/1-QLearning/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/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:09+00:00",
"source_file": "8-Reinforcement/1-QLearning/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

580
translations/te/8-Reinforcement/1-QLearning/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

356
translations/te/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:38:21+00:00",
"source_file": "8-Reinforcement/2-Gym/README.md",
"language_code": "te"
}
-->
# కార్ట్‌పోల్ స్కేటింగ్
మునుపటి పాఠంలో మేము పరిష్కరించిన సమస్య ఒక ఆటపాట సమస్యగా అనిపించవచ్చు, నిజ జీవిత పరిస్థితులకు అన్వయించదగినది కాదు అనిపించవచ్చు. ఇది నిజం కాదు, ఎందుకంటే అనేక నిజ ప్రపంచ సమస్యలు కూడా ఈ పరిస్థితిని పంచుకుంటాయి - చెస్ లేదా గో ఆడటం సహా. అవి సమానమైనవి, ఎందుకంటే మాకు కూడా ఒక బోర్డు మరియు ఇచ్చిన నియమాలు మరియు ఒక **విభిన్న స్థితి** ఉంటుంది.
## [పూర్వ-పాఠం క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## పరిచయం
ఈ పాఠంలో మేము Q-లెర్నింగ్ యొక్క అదే సూత్రాలను **సతత స్థితి** ఉన్న సమస్యకు వర్తింపజేస్తాము, అంటే ఒకటి లేదా ఎక్కువ వాస్తవ సంఖ్యల ద్వారా ఇచ్చిన స్థితి. మేము క్రింది సమస్యను పరిష్కరిస్తాము:
> **సమస్య**: పీటర్ నక్క నుండి తప్పించుకోవాలంటే, అతను వేగంగా కదలగలగాలి. పీటర్ ఎలా స్కేట్ చేయాలో, ముఖ్యంగా, సమతుల్యతను ఎలా ఉంచాలో Q-లెర్నింగ్ ఉపయోగించి నేర్చుకోవడం ఎలా అనేది మేము చూడబోతున్నాము.
![The great escape!](../../../../translated_images/escape.18862db9930337e3fce23a9b6a76a06445f229dadea2268e12a6f0a1fde12115.te.png)
> పీటర్ మరియు అతని స్నేహితులు నక్క నుండి తప్పించుకోవడానికి సృజనాత్మకత చూపుతున్నారు! చిత్రం [Jen Looper](https://twitter.com/jenlooper) ద్వారా
మేము సమతుల్యతను సాధించడానికి సులభీకరించిన వెర్షన్ అయిన **కార్ట్‌పోల్** సమస్యను ఉపయోగిస్తాము. కార్ట్‌పోల్ ప్రపంచంలో, మాకు ఎడమ లేదా కుడి వైపు కదలగల ఒక ఆడంబరమైన స్లైడర్ ఉంటుంది, మరియు లక్ష్యం స్లైడర్ పై ఒక నిలువెత్తు కాండాన్ని సమతుల్యం చేయడం.
<img alt="a cartpole" src="../../../../translated_images/cartpole.b5609cc0494a14f75d121299495ae24fd8f1c30465e7b40961af94ecda2e1cd0.te.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()
```
మీరు ఈ చిత్రానికి సమానమైన దృశ్యాన్ని చూడవచ్చు:
![non-balancing cartpole](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)
1. సిమ్యులేషన్ సమయంలో, చర్య తీసుకోవడానికి ఎలా నిర్ణయించాలో తెలుసుకోవడానికి పరిశీలనలు పొందాలి. వాస్తవానికి, `step` ఫంక్షన్ ప్రస్తుత పరిశీలనలు, రివార్డ్ ఫంక్షన్, మరియు సిమ్యులేషన్ కొనసాగించవలసినదో లేదో సూచించే `done` ఫ్లాగ్‌ను తిరిగి ఇస్తుంది: (కోడ్ బ్లాక్ 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 వరకు ఉన్న సాదా సంఖ్యల జంటగా ఉండేది, కాబట్టి 8x8x2 ఆకారంలో numpy టెన్సర్ ద్వారా Q-టేబుల్‌ను సులభంగా ప్రాతినిధ్యం వహించగలిగాము. బిన్ల విభజనను ఉపయోగిస్తే, మా స్థితి వెక్టర్ పరిమాణం కూడా తెలుసు, కాబట్టి అదే విధానాన్ని ఉపయోగించి 20x20x10x10x2 ఆకారంలో స్థితిని ప్రాతినిధ్యం చేయవచ్చు (ఇక్కడ 2 చర్య స్థలం పరిమాణం, మొదటి కొలతలు పరిశీలన స్థలం యొక్క ప్రతి పారామీటర్ కోసం ఎంచుకున్న బిన్ల సంఖ్యలకు సరిపోతాయి).
కానీ, కొన్నిసార్లు పరిశీలన స్థలం యొక్క ఖచ్చిత కొలతలు తెలియవు. `discretize` ఫంక్షన్ సందర్భంలో, మా స్థితి నిర్దిష్ట పరిమితులలోనే ఉంటుందని ఎప్పుడూ నమ్మకంగా చెప్పలేము, ఎందుకంటే కొన్ని అసలు విలువలకు ఎటువంటి పరిమితులు లేవు. అందువల్ల, మేము కొంత భిన్నమైన విధానాన్ని ఉపయోగించి Q-టేబుల్‌ను డిక్షనరీగా ప్రాతినిధ్యం చేస్తాము.
1. *(state,action)* జంటను డిక్షనరీ కీగా ఉపయోగించి, విలువ 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)
```
![raw progress](../../../../translated_images/train_progress_raw.2adfdf2daea09c596fc786fa347a23e9aceffe1b463e2257d20a9505794823ec.te.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))
```
![training progress](../../../../translated_images/train_progress_runav.c71694a8fa9ab35935aff6f109e5ecdfdbdf1b0ae265da49479a81b5fae8f0aa.te.png)
## హైపర్‌పారామీటర్ల మార్పులు
లెర్నింగ్‌ను స్థిరంగా చేయడానికి, శిక్షణ సమయంలో కొన్ని హైపర్‌పారామీటర్లను సర్దుబాటు చేయడం మంచిది. ముఖ్యంగా:
- **లెర్నింగ్ రేట్** `alpha` కోసం, మేము 1కి సమీపమైన విలువలతో ప్రారంభించి, తరువాత ఆ పరిమాణాన్ని తగ్గిస్తూ ఉండవచ్చు. కాలంతో, మేము Q-టేబుల్‌లో మంచి ప్రాబబిలిటీ విలువలు పొందుతాము, కాబట్టి వాటిని కొద్దిగా సవరించాలి, పూర్తిగా కొత్త విలువలతో మార్చకూడదు.
- **epsilon పెంచండి**. మేము `epsilon` ను మెల్లగా పెంచాలని కోరుకోవచ్చు, తద్వారా తక్కువ అన్వేషణ మరియు ఎక్కువ ఉపయోగం జరుగుతుంది. సాధారణంగా తక్కువ `epsilon` విలువతో ప్రారంభించి దాన్ని సుమారు 1 వరకు పెంచడం మంచిది.
> **పని 1**: హైపర్‌పారామీటర్ విలువలతో ఆడండి మరియు మీరు ఎక్కువ సమ్మిళిత రివార్డ్ సాధించగలరా చూడండి. మీరు 195 కంటే ఎక్కువ పొందుతున్నారా?
> **Task 2**: సమస్యను అధికారికంగా పరిష్కరించడానికి, మీరు 100連続 రన్స్‌లో సగటు 195 రివార్డు పొందాలి. శిక్షణ సమయంలో దాన్ని కొలవండి మరియు మీరు అధికారికంగా సమస్యను పరిష్కరించారని నిర్ధారించుకోండి!
## ఫలితాన్ని చర్యలో చూడటం
శిక్షణ పొందిన మోడల్ ఎలా ప్రవర్తిస్తుందో నిజంగా చూడటం ఆసక్తికరం. సిమ్యులేషన్‌ను నడిపించి, శిక్షణ సమయంలో ఉపయోగించిన అదే చర్య ఎంపిక వ్యూహాన్ని అనుసరించండి, Q-టేబుల్‌లోని probability distribution ప్రకారం నమూనా తీసుకోండి: (కోడ్ బ్లాక్ 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)
---
## 🚀సవాలు
> **Task 3**: ఇక్కడ, మేము Q-టేబుల్ యొక్క తుది కాపీని ఉపయోగిస్తున్నాము, అది ఉత్తమమైనది కాకపోవచ్చు. మేము ఉత్తమ ప్రదర్శన Q-టేబుల్‌ను `Qbest` వేరియబుల్‌లో నిల్వ చేశామని గుర్తుంచుకోండి! `Qbest` ను `Q` పై కాపీ చేసి అదే ఉదాహరణను ప్రయత్నించి తేడా గమనించండి.
> **Task 4**: ఇక్కడ మేము ప్రతి దశలో ఉత్తమ చర్యను ఎంచుకోలేదు, కానీ సంబంధిత probability distribution ప్రకారం నమూనా తీసుకున్నాము. ఎప్పుడూ అత్యధిక Q-టేబుల్ విలువ కలిగిన ఉత్తమ చర్యను ఎంచుకోవడం మరింత అర్థవంతమా? ఇది `np.argmax` ఫంక్షన్ ఉపయోగించి అత్యధిక Q-టేబుల్ విలువకు సంబంధించిన చర్య సంఖ్యను కనుగొనడం ద్వారా చేయవచ్చు. ఈ వ్యూహాన్ని అమలు చేసి బ్యాలెన్సింగ్ మెరుగవుతుందో చూడండి.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## అసైన్‌మెంట్
[Train a Mountain Car](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/te/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:42:12+00:00",
"source_file": "8-Reinforcement/2-Gym/assignment.md",
"language_code": "te"
}
-->
# ట్రైన్ మౌంటైన్ కార్
[OpenAI జిమ్](http://gym.openai.com) అన్ని వాతావరణాలు ఒకే API అందించే విధంగా రూపొందించబడింది - అంటే ఒకే విధమైన `reset`, `step` మరియు `render` పద్ధతులు, మరియు **action space** మరియు **observation space** యొక్క ఒకే అభివృద్ధులు. అందువల్ల, తక్కువ కోడ్ మార్పులతో వేర్వేరు వాతావరణాలకు ఒకే రీఇన్ఫోర్స్‌మెంట్ లెర్నింగ్ అల్గోరిథమ్స్ అనుకూలపరచడం సాధ్యమవుతుంది.
## ఒక మౌంటైన్ కార్ వాతావరణం
[మౌంటైన్ కార్ వాతావరణం](https://gym.openai.com/envs/MountainCar-v0/) లో ఒక కారు ఒక లోయలో చిక్కుకుంది:
<img src="../../../../translated_images/mountaincar.43d56e588ce581c2d035f28cf038a9af112bec043b2ef8da40ac86119b1e3a93.te.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-లెర్నింగ్ అల్గోరిథమ్ కార్ట్‌పోల్ ఉదాహరణ నుండి తక్కువ కోడ్ మార్పులతో విజయవంతంగా అనుకూలపరచబడింది, 200 దశలలో జెండాను పట్టుకోవడం సమస్యను పరిష్కరించగలదు. | ఇంటర్నెట్ నుండి కొత్త Q-లెర్నింగ్ అల్గోరిథమ్ తీసుకున్నది, కానీ బాగా డాక్యుమెంటెడ్; లేదా ఉన్న అల్గోరిథమ్ తీసుకున్నది, కానీ కావలసిన ఫలితాలు అందలేదు | విద్యార్థి ఏ అల్గోరిథమ్‌ను విజయవంతంగా అనుకూలపరచలేకపోయాడు, కానీ పరిష్కారానికి గణనీయమైన దశలను తీసుకున్నాడు (స్థితి డిస్క్రిటైజేషన్, Q-టేబుల్ డేటా నిర్మాణం మొదలైనవి అమలు చేశాడు) |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

17
translations/te/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:35+00:00",
"source_file": "8-Reinforcement/2-Gym/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/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:07+00:00",
"source_file": "8-Reinforcement/2-Gym/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

File diff suppressed because one or more lines are too long

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

@ -0,0 +1,69 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "20ca019012b1725de956681d036d8b18",
"translation_date": "2025-12-19T13:07:50+00:00",
"source_file": "8-Reinforcement/README.md",
"language_code": "te"
}
-->
# రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ పరిచయం
రీన్ఫోర్స్‌మెంట్ లెర్నింగ్, RL, పర్యవేక్షిత లెర్నింగ్ మరియు పర్యవేక్షణ లేని లెర్నింగ్ తరువాత ఒక ప్రాథమిక మెషీన్ లెర్నింగ్ పద్ధతిగా భావించబడుతుంది. RL అన్నది నిర్ణయాల గురించి: సరైన నిర్ణయాలను తీసుకోవడం లేదా కనీసం వాటి నుండి నేర్చుకోవడం.
మీకు స్టాక్ మార్కెట్ వంటి అనుకరణాత్మక వాతావరణం ఉందని ఊహించుకోండి. మీరు ఒక నిర్దిష్ట నియంత్రణను విధిస్తే ఏమవుతుంది? అది సానుకూల లేదా ప్రతికూల ప్రభావం కలిగిస్తుందా? ఏదైనా ప్రతికూలం జరిగితే, మీరు ఆ _ప్రతికూల రీన్ఫోర్స్‌మెంట్_ తీసుకుని, దానినుండి నేర్చుకుని, మార్గాన్ని మార్చుకోవాలి. అది సానుకూల ఫలితం అయితే, మీరు ఆ _సానుకూల రీన్ఫోర్స్‌మెంట్_ పై ఆధారపడి నిర్మించుకోవాలి.
![peter and the wolf](../../../translated_images/peter.779730f9ba3a8a8d9290600dcf55f2e491c0640c785af7ac0d64f583c49b8864.te.png)
> పీటర్ మరియు అతని స్నేహితులు ఆకలితో ఉన్న నక్క నుండి తప్పించుకోవాలి! చిత్రం [Jen Looper](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)**, ఇక్కడ మనకు చాలా unlabeled డేటా ఉంటుంది, దానిని మోడల్‌ను ప్రీ-ట్రెయిన్ చేయడానికి ఉపయోగించవచ్చు.
- **[రీన్ఫోర్స్‌మెంట్ లెర్నింగ్](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)
## క్రెడిట్స్
"Introduction to Reinforcement Learning" ను ♥️ తో [Dmitry Soshnikov](http://soshnikov.com) రాశారు
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

162
translations/te/9-Real-World/1-Applications/README.md
Unescape View File

@ -0,0 +1,162 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "83320d6b6994909e35d830cebf214039",
"translation_date": "2025-12-19T15:06:27+00:00",
"source_file": "9-Real-World/1-Applications/README.md",
"language_code": "te"
}
-->
# పోస్ట్‌స్క్రిప్ట్: వాస్తవ ప్రపంచంలో మెషీన్ లెర్నింగ్
![వాస్తవ ప్రపంచంలో మెషీన్ లెర్నింగ్ యొక్క సారాంశం స్కెచ్‌నోట్‌లో](../../../../translated_images/ml-realworld.26ee2746716155771f8076598b6145e6533fe4a9e2e465ea745f46648cbf1b84.te.png)
> స్కెచ్‌నోట్ [టోమోమీ ఇమురా](https://www.twitter.com/girlie_mac) ద్వారా
ఈ పాఠ్యक्रमంలో, మీరు శిక్షణ కోసం డేటాను సిద్ధం చేయడం మరియు మెషీన్ లెర్నింగ్ మోడల్స్ సృష్టించడానికి అనేక మార్గాలను నేర్చుకున్నారు. మీరు క్లాసిక్ రిగ్రెషన్, క్లస్టరింగ్, వర్గీకరణ, సహజ భాషా ప్రాసెసింగ్, మరియు టైమ్ సిరీస్ మోడల్స్ సిరీస్‌ను నిర్మించారు. అభినందనలు! ఇప్పుడు, మీరు ఆలోచిస్తున్నారా ఇది అంతా ఏం కోసం... ఈ మోడల్స్‌కు వాస్తవ ప్రపంచంలో ఏవైనా అనువర్తనాలు ఏమిటి?
ఇండస్ట్రీలో ఎక్కువ ఆసక్తి సాధించినది AI, ఇది సాధారణంగా డీప్ లెర్నింగ్‌ను ఉపయోగిస్తుంది, అయినప్పటికీ క్లాసికల్ మెషీన్ లెర్నింగ్ మోడల్స్‌కు ఇంకా విలువైన అనువర్తనాలు ఉన్నాయి. మీరు ఈ అనువర్తనాలలో కొన్ని ఈ రోజు కూడా ఉపయోగించవచ్చు! ఈ పాఠంలో, మీరు ఎనిమిది విభిన్న పరిశ్రమలు మరియు విషయం-విషయ డొమైన్‌లు ఈ రకమైన మోడల్స్‌ను ఎలా ఉపయోగించి తమ అనువర్తనాలను మరింత పనితీరు, నమ్మకదారితనం, తెలివితేట, మరియు వినియోగదారులకు విలువైనదిగా మార్చుతున్నారో అన్వేషిస్తారు.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## 💰 ఫైనాన్స్
ఫైనాన్స్ రంగం మెషీన్ లెర్నింగ్‌కు అనేక అవకాశాలను అందిస్తుంది. ఈ ప్రాంతంలోని అనేక సమస్యలు ML ఉపయోగించి మోడల్ చేయబడతాయి మరియు పరిష్కరించబడతాయి.
### క్రెడిట్ కార్డ్ మోసపూరిత గుర్తింపు
ముందుగా కోర్సులో [k-మీన్స్ క్లస్టరింగ్](../../5-Clustering/2-K-Means/README.md) గురించి నేర్చుకున్నాము, కానీ ఇది క్రెడిట్ కార్డ్ మోసపూరిత సమస్యలను ఎలా పరిష్కరిస్తుంది?
క్రెడిట్ కార్డ్ మోసపూరిత గుర్తింపు సాంకేతికతలో **అసాధారణ గుర్తింపు** అనే పద్ధతిలో k-మీన్స్ క్లస్టరింగ్ ఉపయోగపడుతుంది. అసాధారణాలు లేదా డేటా సెట్‌పై పరిశీలనలలో వ్యత్యాసాలు క్రెడిట్ కార్డ్ సాధారణంగా ఉపయోగించబడుతున్నదా లేదా ఏదైనా అసాధారణం జరుగుతున్నదా అని చెప్పగలవు. క్రింద లింక్ చేసిన పత్రంలో చూపినట్లుగా, మీరు క్రెడిట్ కార్డ్ డేటాను k-మీన్స్ క్లస్టరింగ్ అల్గోరిథం ఉపయోగించి వర్గీకరించవచ్చు మరియు ప్రతి లావాదేవీని అది ఎంత అసాధారణంగా కనిపిస్తుందో ఆధారంగా ఒక క్లస్టర్‌కు కేటాయించవచ్చు. ఆపై, మోసపూరిత మరియు చట్టబద్ధ లావాదేవీల కోసం అత్యంత ప్రమాదకరమైన క్లస్టర్లను మూల్యాంకనం చేయవచ్చు.
[సూచన](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/)
## 🎓 విద్య
విద్య రంగం కూడా మెషీన్ లెర్నింగ్‌ను వర్తింపజేయడానికి చాలా ఆసక్తికరమైన ప్రాంతం. పరీక్షలలో లేదా వ్యాసాలలో మోసం గుర్తించడం లేదా సవరణ ప్రక్రియలో అనుకోకుండా లేదా ఉద్దేశపూర్వకంగా ఉన్న పక్షపాతాన్ని నిర్వహించడం వంటి సమస్యలు ఉన్నాయి.
### విద్యార్థి ప్రవర్తన అంచనా
[Coursera](https://coursera.com), ఒక ఆన్‌లైన్ ఓపెన్ కోర్సు ప్రొవైడర్, అనేక ఇంజనీరింగ్ నిర్ణయాలను చర్చించే గొప్ప టెక్ బ్లాగ్ కలిగి ఉంది. ఈ కేసు స్టడీలో, వారు తక్కువ NPS (నెట్ ప్రమోటర్ స్కోర్) రేటింగ్ మరియు కోర్సు నిలుపుదల లేదా డ్రాప్-ఆఫ్ మధ్య ఏదైనా సంబంధం ఉందా అని అన్వేషించడానికి రిగ్రెషన్ లైన్‌ను ప్లాట్ చేశారు.
[సూచన](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a)
### పక్షపాతం తగ్గించడం
[Grammarly](https://grammarly.com), ఒక రైటింగ్ అసిస్టెంట్, దాని ఉత్పత్తులలో సున్నితమైన [సహజ భాషా ప్రాసెసింగ్ సిస్టమ్స్](../../6-NLP/README.md) ఉపయోగిస్తుంది. వారు తమ టెక్ బ్లాగ్‌లో మెషీన్ లెర్నింగ్‌లో లింగ పక్షపాతాన్ని ఎలా ఎదుర్కొన్నారో గురించి ఆసక్తికరమైన కేసు స్టడీ ప్రచురించారు, ఇది మీరు మా [ప్రారంభ న్యాయసమ్మతత పాఠంలో](../../1-Introduction/3-fairness/README.md) నేర్చుకున్నారు.
[సూచన](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/)
## 👜 రిటైల్
రిటైల్ రంగం ఖచ్చితంగా మెషీన్ లెర్నింగ్ ఉపయోగం ద్వారా లాభపడుతుంది, కస్టమర్ ప్రయాణాన్ని మెరుగుపరచడం నుండి సరుకుల నిల్వను ఆప్టిమైజ్ చేయడం వరకు.
### కస్టమర్ ప్రయాణాన్ని వ్యక్తిగతీకరించడం
Wayfair, ఫర్నిచర్ వంటి హోమ్ గూడ్స్ అమ్మే కంపెనీ, కస్టమర్లకు వారి రుచి మరియు అవసరాలకు సరిపోయే సరుకులను కనుగొనడంలో సహాయం చేయడం అత్యంత ముఖ్యమైనది. ఈ వ్యాసంలో, కంపెనీ ఇంజనీర్లు ML మరియు NLP ఎలా ఉపయోగిస్తారో వివరిస్తారు "కస్టమర్లకు సరైన ఫలితాలను చూపించడానికి". ముఖ్యంగా, వారి Query Intent Engine ఎంటిటీ ఎక్స్‌ట్రాక్షన్, క్లాసిఫైయర్ శిక్షణ, ఆస్తి మరియు అభిప్రాయ ఎక్స్‌ట్రాక్షన్, మరియు కస్టమర్ సమీక్షలపై భావోద్వేగ ట్యాగింగ్ ఉపయోగించి నిర్మించబడింది. ఇది ఆన్‌లైన్ రిటైల్‌లో NLP ఎలా పనిచేస్తుందో క్లాసిక్ ఉదాహరణ.
[సూచన](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search)
### నిల్వ నిర్వహణ
[StitchFix](https://stitchfix.com) వంటి ఆవిష్కరణాత్మక, చురుకైన కంపెనీలు, కస్టమర్ సిఫార్సులు మరియు నిల్వ నిర్వహణ కోసం ML పై బలంగా ఆధారపడతాయి. వారి స్టైలింగ్ టీమ్స్ వారి మెర్చండైజింగ్ టీమ్స్‌తో కలిసి పనిచేస్తాయి: "మా ఒక డేటా సైంటిస్ట్ జెనెటిక్ అల్గోరిథం తో ఆడుతూ దాన్ని దుస్తులపై వర్తింపజేసి, ఇప్పటి వరకు లేని విజయవంతమైన దుస్తులను అంచనా వేసాడు. మేము దాన్ని మెర్చండైజ్ టీమ్‌కు తీసుకువచ్చాము, ఇప్పుడు వారు దాన్ని ఒక సాధనంగా ఉపయోగించవచ్చు."
[సూచన](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)
### ఆసుపత్రి తిరిగి చేర్చడం నిర్వహణ
ఆసుపత్రి సంరక్షణ ఖరీదైనది, ముఖ్యంగా రోగులను తిరిగి చేర్చాల్సినప్పుడు. ఈ పత్రం ఒక కంపెనీ ML ఉపయోగించి తిరిగి చేర్చే అవకాశాన్ని [క్లస్టరింగ్](../../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) ఇక్కడ నిర్మించవచ్చు), అయినప్పటికీ క్లాసిక్ ML ఈ పనిలో ఇంకా ప్రాధాన్యం కలిగి ఉంది.
పశుపాలన జంతువుల కదలికలను ట్రాక్ చేయడానికి సెన్సార్లు మరియు IoT ఈ రకమైన దృశ్య ప్రాసెసింగ్ ఉపయోగిస్తాయి, కానీ ప్రాథమిక ML సాంకేతికతలు డేటాను ప్రీప్రాసెస్ చేయడానికి ఉపయోగకరంగా ఉంటాయి. ఉదాహరణకు, ఈ పత్రంలో, గొర్రెలు భంగిమలను పర్యవేక్షించి వివిధ క్లాసిఫైయర్ అల్గోరిథమ్స్ ఉపయోగించి విశ్లేషించారు. మీరు పేజీ 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)
## 💼 బీమా
బీమా రంగం కూడా ఆర్థిక మరియు యాక్చ్యూరియల్ మోడల్స్ నిర్మించడానికి మరియు ఆప్టిమైజ్ చేయడానికి ML ఉపయోగిస్తుంది.
### అస్థిరత నిర్వహణ
MetLife, ఒక జీవిత బీమా ప్రొవైడర్, వారి ఆర్థిక మోడల్స్‌లో అస్థిరతను ఎలా విశ్లేషించి తగ్గిస్తారో స్పష్టంగా చెప్తుంది. ఈ వ్యాసంలో మీరు బైనరీ మరియు ఆర్డినల్ వర్గీకరణ విజువలైజేషన్లు గమనిస్తారు. మీరు ఫోర్కాస్టింగ్ విజువలైజేషన్లను కూడా కనుగొంటారు.
[సూచన](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf)
## 🎨 కళలు, సంస్కృతి, మరియు సాహిత్యం
కళలలో, ఉదాహరణకు జర్నలిజంలో, అనేక ఆసక్తికర సమస్యలు ఉన్నాయి. ఫేక్ న్యూస్ గుర్తించడం ఒక పెద్ద సమస్య, ఇది ప్రజల అభిప్రాయాన్ని ప్రభావితం చేయడమే కాకుండా ప్రజాస్వామ్యాలను కూడా కూల్చివేయగలదు. మ్యూజియంలు కూడా ఆర్టిఫాక్ట్స్ మధ్య లింకులను కనుగొనడం నుండి వనరుల ప్రణాళిక వరకు ML ఉపయోగించి లాభపడతాయి.
### ఫేక్ న్యూస్ గుర్తింపు
ఈ రోజుల్లో మీడియా లో ఫేక్ న్యూస్ గుర్తించడం ఒక పిల్లి మరియు ఎలుక ఆటలా మారింది. ఈ వ్యాసంలో, పరిశోధకులు మేము అధ్యయనం చేసిన అనేక ML సాంకేతికతలను కలిపిన ఒక సిస్టమ్‌ను పరీక్షించి ఉత్తమ మోడల్‌ను అమలు చేయవచ్చని సూచిస్తున్నారు: "ఈ సిస్టమ్ సహజ భాషా ప్రాసెసింగ్ ఆధారంగా డేటా నుండి లక్షణాలను తీసుకుంటుంది మరియు ఆ లక్షణాలను నైవ్ బేస్, సపోర్ట్ వెక్టర్ మెషీన్ (SVM), రాండమ్ ఫారెస్ట్ (RF), స్టోకాస్టిక్ గ్రాడియెంట్ డిసెంట్ (SGD), మరియు లాజిస్టిక్ రిగ్రెషన్ (LR) వంటి మెషీన్ లెర్నింగ్ క్లాసిఫైయర్ల శిక్షణకు ఉపయోగిస్తారు."
[సూచన](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf)
ఈ వ్యాసం వివిధ ML డొమైన్‌లను కలిపి ఫేక్ న్యూస్ వ్యాప్తిని ఆపడానికి మరియు నిజమైన నష్టం కలిగించకుండా సహాయపడే ఆసక్తికర ఫలితాలను ఎలా ఉత్పత్తి చేయగలదో చూపిస్తుంది; ఈ సందర్భంలో, COVID చికిత్సల గురించి ప్రచారాలు మోబు హింసకు దారితీసినప్పుడు ఇది ప్రేరణ అయింది.
### మ్యూజియం ML
మ్యూజియంలు AI విప్లవం అంచున ఉన్నాయి, ఇందులో సేకరణలను కేటలాగ్ చేయడం మరియు డిజిటైజ్ చేయడం మరియు ఆర్టిఫాక్ట్స్ మధ్య లింకులను కనుగొనడం సాంకేతికత అభివృద్ధితో సులభమవుతోంది. [In Codice Ratio](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) వంటి ప్రాజెక్టులు వేటికన్ ఆర్కైవ్స్ వంటి అందుబాటులో లేని సేకరణల రహస్యాలను తెరవడంలో సహాయపడుతున్నాయి. కానీ, మ్యూజియంల వ్యాపార భాగం కూడా ML మోడల్స్ నుండి లాభపడుతుంది.
ఉదాహరణకు, ఆర్ట్ ఇన్స్టిట్యూట్ ఆఫ్ చికాగో ప్రేక్షకులు ఏమి ఆసక్తి చూపిస్తారో మరియు వారు ఎప్పుడు ప్రదర్శనలకు హాజరవుతారో అంచనా వేయడానికి మోడల్స్ నిర్మించింది. లక్ష్యం ప్రతి సారి వినియోగదారు మ్యూజియం సందర్శించినప్పుడు వ్యక్తిగతీకరించిన మరియు ఆప్టిమైజ్ చేసిన సందర్శక అనుభవాలను సృష్టించడం. "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/)
## 🚀 సవాలు
ఈ పాఠ్యక్రమంలో మీరు నేర్చుకున్న కొన్ని సాంకేతికతలతో లాభపడే మరొక రంగాన్ని గుర్తించండి, మరియు అది ML ను ఎలా ఉపయోగిస్తుందో కనుగొనండి.
## [లెక్చర్ తర్వాత క్విజ్](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/te/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:04+00:00",
"source_file": "9-Real-World/1-Applications/assignment.md",
"language_code": "te"
}
-->
# ఒక ML స్కావెంజర్ హంట్
## సూచనలు
ఈ పాఠంలో, మీరు క్లాసికల్ ML ఉపయోగించి పరిష్కరించబడిన అనేక వాస్తవ జీవిత వినియోగాల గురించి నేర్చుకున్నారు. డీప్ లెర్నింగ్, AIలో కొత్త సాంకేతికతలు మరియు సాధనాల ఉపయోగం, మరియు న్యూరల్ నెట్‌వర్క్‌లను ఉపయోగించడం ఈ రంగాలలో సహాయపడే సాధనాల ఉత్పత్తిని వేగవంతం చేయడంలో సహాయపడినప్పటికీ, ఈ పాఠ్యక్రమంలో ఉన్న సాంకేతికతలను ఉపయోగించే క్లాసిక్ ML ఇంకా గొప్ప విలువను కలిగి ఉంది.
ఈ అసైన్‌మెంట్‌లో, మీరు ఒక హాకథాన్‌లో పాల్గొంటున్నారని ఊహించుకోండి. ఈ పాఠ్యక్రమంలో నేర్చుకున్నదాన్ని ఉపయోగించి క్లాసిక్ ML ద్వారా ఈ పాఠంలో చర్చించిన రంగాలలో ఒక సమస్యను పరిష్కరించడానికి ఒక పరిష్కారాన్ని ప్రతిపాదించండి. మీరు మీ ఆలోచనను ఎలా అమలు చేస్తారో చర్చించే ఒక ప్రెజెంటేషన్ సృష్టించండి. మీరు నమూనా డేటాను సేకరించి మీ భావనకు మద్దతుగా ఒక ML మోడల్‌ను నిర్మిస్తే అదనపు పాయింట్లు పొందవచ్చు!
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ------------------------------------------------------------------- | ------------------------------------------------- | ---------------------- |
| | ఒక పవర్‌పాయింట్ ప్రెజెంటేషన్ అందించబడింది - మోడల్ నిర్మాణానికి బోనస్ | ఒక సృజనాత్మకత లేని, ప్రాథమిక ప్రెజెంటేషన్ అందించబడింది | పని అసంపూర్ణంగా ఉంది |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

185
translations/te/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:10:53+00:00",
"source_file": "9-Real-World/2-Debugging-ML-Models/README.md",
"language_code": "te"
}
-->
# పోస్ట్‌స్క్రిప్ట్: బాధ్యతాయుత 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)
## లోపాల విశ్లేషణ
ఖచ్చితత్వాన్ని కొలవడానికి ఉపయోగించే సాంప్రదాయ మోడల్ పనితీరు మెట్రిక్స్ ఎక్కువగా సరైన మరియు తప్పు అంచనాల ఆధారంగా లెక్కింపులు. ఉదాహరణకు, ఒక మోడల్ 89% సార్లు ఖచ్చితంగా ఉందని, లోపం నష్టం 0.001 అని నిర్ణయించడం మంచి పనితీరు అని పరిగణించవచ్చు. లోపాలు సాధారణంగా మీ ప్రాథమిక డేటాసెట్‌లో సమానంగా పంపిణీ కావు. మీరు 89% మోడల్ ఖచ్చితత్వ స్కోరు పొందవచ్చు కానీ మోడల్ 42% సార్లు విఫలమవుతున్న డేటా ప్రాంతాలు వేరుగా ఉండవచ్చు. ఈ విఫలత నమూనాలు కొన్ని డేటా గుంపులతో న్యాయం లేదా నమ్మకదగినత సమస్యలకు దారితీస్తాయి. మోడల్ బాగా పనిచేస్తున్న లేదా చేయని ప్రాంతాలను అర్థం చేసుకోవడం అవసరం. మోడల్‌లో ఎక్కువ లోపాలు ఉన్న డేటా ప్రాంతాలు ముఖ్యమైన డేటా జనాభా కావచ్చు.
![మోడల్ లోపాలను విశ్లేషించండి మరియు డీబగ్ చేయండి](../../../../translated_images/ea-error-distribution.117452e1177c1dd84fab2369967a68bcde787c76c6ea7fdb92fcf15d1fce8206.te.png)
RAI డాష్‌బోర్డ్‌లో లోపాల విశ్లేషణ భాగం వివిధ కోహార్ట్లలో మోడల్ విఫలత ఎలా పంపిణీ అయిందో చెట్టు విజువలైజేషన్ ద్వారా చూపిస్తుంది. ఇది మీ డేటాసెట్‌లో ఎక్కువ లోపాలున్న లక్షణాలు లేదా ప్రాంతాలను గుర్తించడంలో ఉపయోగపడుతుంది. మోడల్ లోపాల ఎక్కువగా ఎక్కడ నుండి వస్తున్నాయో చూసి, మీరు మూల కారణాన్ని పరిశీలించవచ్చు. మీరు విశ్లేషణ కోసం డేటా కోహార్ట్లను కూడా సృష్టించవచ్చు. ఈ డేటా కోహార్ట్లు డీబగ్గింగ్ ప్రక్రియలో సహాయపడతాయి, ఎందుకు ఒక కోహార్ట్‌లో మోడల్ పనితీరు మంచిది కానీ మరొకదిలో లోపభూయిష్టమో తెలుసుకోవడానికి.
![లోపాల విశ్లేషణ](../../../../translated_images/ea-error-cohort.6886209ea5d438c4daa8bfbf5ce3a7042586364dd3eccda4a4e3d05623ac702a.te.png)
చెట్టు మ్యాప్‌పై విజువల్ సూచికలు సమస్య ప్రాంతాలను త్వరగా గుర్తించడంలో సహాయపడతాయి. ఉదాహరణకు, చెట్టు నోడ్ యొక్క ఎరుపు రంగు గాఢత ఎక్కువైతే, లోపాల రేటు ఎక్కువగా ఉంటుంది.
హీట్ మ్యాప్ మరో విజువలైజేషన్ ఫంక్షనాలిటీ, ఇది ఒకటి లేదా రెండు లక్షణాలను ఉపయోగించి లోపాల రేటును పరిశీలించడానికి ఉపయోగపడుతుంది, మొత్తం డేటాసెట్ లేదా కోహార్ట్లలో మోడల్ లోపాలకు కారణం కనుగొనడానికి.
![లోపాల విశ్లేషణ హీట్‌మ్యాప్](../../../../translated_images/ea-heatmap.8d27185e28cee3830c85e1b2e9df9d2d5e5c8c940f41678efdb68753f2f7e56c.te.png)
లోపాల విశ్లేషణను ఉపయోగించండి, మీరు:
* మోడల్ విఫలతలు డేటాసెట్ మరియు అనేక ఇన్‌పుట్ మరియు లక్షణ పరిమాణాలలో ఎలా పంపిణీ అయ్యాయో లోతుగా అర్థం చేసుకోవాలి.
* సమగ్ర పనితీరు మెట్రిక్స్‌ను విభజించి తప్పు ఉన్న కోహార్ట్లను ఆటోమేటిక్‌గా కనుగొని లక్ష్యిత పరిష్కార చర్యలకు దారితీయాలి.
## మోడల్ అవలోకనం
మెషీన్ లెర్నింగ్ మోడల్ పనితీరును అంచనా వేయడం అంటే దాని ప్రవర్తనను సమగ్రంగా అర్థం చేసుకోవడం. ఇది లోపాల రేటు, ఖచ్చితత్వం, రీకాల్, ప్రెసిషన్ లేదా MAE (Mean Absolute Error) వంటి metrics ను సమీక్షించడం ద్వారా సాధించవచ్చు, పనితీరు మెట్రిక్స్‌లో వ్యత్యాసాలను కనుగొనడానికి. ఒక పనితీరు మెట్రిక్ బాగుండవచ్చు, కానీ మరొక మెట్రిక్ లో లోపాలు కనిపించవచ్చు. అంతేకాక, మొత్తం డేటాసెట్ లేదా కోహార్ట్లలో metrics ను తులనాత్మకంగా పరిశీలించడం మోడల్ ఎక్కడ బాగా పనిచేస్తుందో లేదా చేయదో తెలియజేస్తుంది. ఇది ప్రత్యేకంగా సున్నితమైన లక్షణాలు (ఉదా: రోగి జాతి, లింగం, వయస్సు) ఉన్న కోహార్ట్లలో మోడల్ పనితీరును చూడటానికి ముఖ్యమైనది, ఇది మోడల్ లోపాలను వెలుగులోకి తీసుకురావచ్చు. ఉదాహరణకు, సున్నిత లక్షణాలు ఉన్న కోహార్ట్‌లో మోడల్ ఎక్కువ లోపాలు చూపిస్తే, అది మోడల్ లోపాలను సూచిస్తుంది.
RAI డాష్‌బోర్డ్‌లో మోడల్ అవలోకనం భాగం కేవలం కోహార్ట్‌లో డేటా ప్రాతినిధ్యం పనితీరు మెట్రిక్స్‌ను విశ్లేషించడంలో మాత్రమే కాకుండా, వాడుకదారులకు వివిధ కోహార్ట్లలో మోడల్ ప్రవర్తనను తులనాత్మకంగా చూడటానికి అవకాశం ఇస్తుంది.
![డేటాసెట్ కోహార్ట్లు - RAI డాష్‌బోర్డ్‌లో మోడల్ అవలోకనం](../../../../translated_images/model-overview-dataset-cohorts.dfa463fb527a35a0afc01b7b012fc87bf2cad756763f3652bbd810cac5d6cf33.te.png)
ఈ భాగం లక్షణాల ఆధారిత విశ్లేషణ ఫంక్షనాలిటీ వాడుకదారులకు ఒక నిర్దిష్ట లక్షణంలో డేటా ఉపగుంపులను కుదించడానికి సహాయపడుతుంది, తద్వారా సూక్ష్మ స్థాయిలో అసాధారణతలను గుర్తించవచ్చు. ఉదాహరణకు, డాష్‌బోర్డ్‌లో ఒక వాడుకదారు ఎంచుకున్న లక్షణం కోసం ఆటోమేటిక్‌గా కోహార్ట్లను సృష్టించే ఇంటెలిజెన్స్ ఉంది (ఉదా: *"time_in_hospital < 3"* లేదా *"time_in_hospital >= 7"*). ఇది పెద్ద డేటా గుంపులోని ఒక లక్షణాన్ని వేరుచేసి, అది మోడల్ లోపాలపై కీలక ప్రభావం చూపుతున్నదా అని చూడటానికి సహాయపడుతుంది.
![లక్షణ కోహార్ట్లు - RAI డాష్‌బోర్డ్‌లో మోడల్ అవలోకనం](../../../../translated_images/model-overview-feature-cohorts.c5104d575ffd0c80b7ad8ede7703fab6166bfc6f9125dd395dcc4ace2f522f70.te.png)
మోడల్ అవలోకనం భాగం రెండు తరహా వ్యత్యాస మెట్రిక్స్‌ను మద్దతు ఇస్తుంది:
**మోడల్ పనితీరు వ్యత్యాసం**: ఈ మెట్రిక్స్ ఎంపిక చేసిన పనితీరు మెట్రిక్ విలువలలో డేటా ఉపగుంపుల మధ్య వ్యత్యాసాన్ని లెక్కిస్తాయి. కొన్ని ఉదాహరణలు:
* ఖచ్చితత్వం రేటులో వ్యత్యాసం
* లోపాల రేటులో వ్యత్యాసం
* ప్రెసిషన్‌లో వ్యత్యాసం
* రీకాల్‌లో వ్యత్యాసం
* సగటు సార్వత్రిక లోపం (MAE)లో వ్యత్యాసం
**ఎంపిక రేటులో వ్యత్యాసం**: ఈ మెట్రిక్ ఉపగుంపుల మధ్య ఎంపిక రేటులో (అనుకూల అంచనా) వ్యత్యాసాన్ని కలిగి ఉంటుంది. ఉదాహరణకు, రుణ ఆమోద రేట్లలో వ్యత్యాసం. ఎంపిక రేటు అంటే ప్రతి తరగతిలో 1గా (బైనరీ వర్గీకరణలో) వర్గీకరించిన డేటా పాయింట్ల శాతం లేదా అంచనా విలువల పంపిణీ (రెగ్రెషన్‌లో).
## డేటా విశ్లేషణ
> "మీరు డేటాను చాలాసేపు పీడిస్తే, అది ఏదైనా ఒప్పుకుంటుంది" - రోనాల్డ్ కోస్
ఈ వాక్యం తీవ్రంగా అనిపించవచ్చు, కానీ డేటాను ఏదైనా తర్కాన్ని మద్దతు ఇవ్వడానికి మానవీయంగా మార్చవచ్చు. అలాంటి మార్పులు కొన్నిసార్లు అనుకోకుండా జరుగుతాయి. మనుషులుగా, మనందరికీ పక్షపాతం ఉంటుంది, మరియు మీరు డేటాలో పక్షపాతం ప్రవేశపెడుతున్నప్పుడు అది తెలుసుకోవడం కష్టం. AI మరియు మెషీన్ లెర్నింగ్‌లో న్యాయాన్ని హామీ చేయడం ఒక క్లిష్టమైన సవాలు.
సాంప్రదాయ మోడల్ పనితీరు మెట్రిక్స్‌లకు డేటా ఒక పెద్ద అంధ ప్రాంతం. మీరు అధిక ఖచ్చితత్వ స్కోర్లు పొందవచ్చు, కానీ ఇది మీ డేటాసెట్‌లో ఉండే డేటా పక్షపాతాన్ని ప్రతిబింబించకపోవచ్చు. ఉదాహరణకు, ఒక సంస్థలో ఉద్యోగుల డేటాసెట్‌లో 27% మహిళలు ఎగ్జిక్యూటివ్ స్థాయిలో ఉన్నారు మరియు 73% పురుషులు అదే స్థాయిలో ఉన్నారు అంటే, ఈ డేటాతో శిక్షణ పొందిన ఉద్యోగ ప్రకటన AI మోడల్ పెద్దగా పురుషుల ప్రేక్షకులను లక్ష్యంగా చేసుకోవచ్చు. ఈ అసమతుల్యత మోడల్ అంచనాను ఒక లింగాన్ని ప్రాధాన్యం ఇవ్వడానికి వక్రీకరిస్తుంది. ఇది AI మోడల్‌లో లింగ పక్షపాతం ఉన్న న్యాయ సమస్యను వెల్లడిస్తుంది.
RAI డాష్‌బోర్డ్‌లో డేటా విశ్లేషణ భాగం డేటాసెట్‌లో అధిక మరియు తక్కువ ప్రాతినిధ్యం ఉన్న ప్రాంతాలను గుర్తించడంలో సహాయపడుతుంది. ఇది వాడుకదారులకు డేటా అసమతుల్యతల వల్ల లేదా నిర్దిష్ట డేటా గుంపు ప్రాతినిధ్యం లేకపోవడం వల్ల ఏర్పడిన లోపాలు మరియు న్యాయ సమస్యల మూల కారణాన్ని నిర్ధారించడంలో సహాయపడుతుంది. ఇది వాడుకదారులకు అంచనా మరియు వాస్తవ ఫలితాల, లోపాల గుంపులు, మరియు నిర్దిష్ట లక్షణాల ఆధారంగా డేటాసెట్లను విజువలైజ్ చేయడానికి అవకాశం ఇస్తుంది. కొన్నిసార్లు తక్కువ ప్రాతినిధ్యం ఉన్న డేటా గుంపును కనుగొనడం మోడల్ బాగా నేర్చుకోలేదని కూడా వెల్లడించవచ్చు, అందువల్ల ఎక్కువ లోపాలు ఉంటాయి. డేటా పక్షపాతం ఉన్న మోడల్ కేవలం న్యాయ సమస్య మాత్రమే కాకుండా, మోడల్ సమగ్రత లేదా నమ్మకదగినత లేని దాన్ని సూచిస్తుంది.
![RAI డాష్‌బోర్డ్‌లో డేటా విశ్లేషణ భాగం](../../../../translated_images/dataanalysis-cover.8d6d0683a70a5c1e274e5a94b27a71137e3d0a3b707761d7170eb340dd07f11d.te.png)
డేటా విశ్లేషణను ఉపయోగించండి, మీరు:
* వివిధ ఫిల్టర్లను ఎంచుకుని మీ డేటాను విభిన్న పరిమాణాలుగా (కోహార్ట్లుగా) విభజించి డేటా గణాంకాలను అన్వేషించండి.
* వివిధ కోహార్ట్లు మరియు లక్షణ గుంపులలో మీ డేటాసెట్ పంపిణీని అర్థం చేసుకోండి.
* న్యాయం, లోపాల విశ్లేషణ, మరియు కారణాత్మకత (ఇతర డాష్‌బోర్డ్ భాగాల నుండి పొందిన) సంబంధిత మీ కనుగొనుటలు మీ డేటాసెట్ పంపిణీ ఫలితమా అని నిర్ణయించండి.
* ప్రాతినిధ్యం సమస్యలు, లేబుల్ శబ్దం, లక్షణ శబ్దం, లేబుల్ పక్షపాతం మరియు ఇలాంటి అంశాల వల్ల వచ్చే లోపాలను తగ్గించడానికి ఏ ప్రాంతాల్లో మరిన్ని డేటా సేకరించాలో నిర్ణయించండి.
## మోడల్ వివరణాత్మకత
మెషీన్ లెర్నింగ్ మోడల్స్ బ్లాక్ బాక్స్‌లుగా ఉంటాయి. మోడల్ అంచనాను ప్రభావితం చేసే ముఖ్యమైన డేటా లక్షణాలను అర్థం చేసుకోవడం సవాలుగా ఉంటుంది. ఒక మోడల్ ఎందుకు ఒక నిర్దిష్ట అంచనాను చేస్తుందో పారదర్శకత ఇవ్వడం ముఖ్యం. ఉదాహరణకు, ఒక AI వ్యవస్థ ఒక మధుమేహ రోగి 30 రోజుల్లో ఆసుపత్రికి తిరిగి చేరే ప్రమాదంలో ఉన్నాడని అంచనా వేస్తే, అది తన అంచనాకు కారణమైన మద్దతు డేటాను అందించగలగాలి. మద్దతు డేటా సూచికలు క్లినిషియన్లు లేదా ఆసుపత్రులకు బాగా సమాచారం ఉన్న నిర్ణయాలు తీసుకోవడంలో పారదర్శకతను తీసుకువస్తాయి. అదనంగా, ఒక వ్యక్తిగత రోగి కోసం మోడల్ ఎందుకు అంచనా వేసిందో వివరించడం ఆరోగ్య నియంత్రణలతో బాధ్యతను కలిగిస్తుంది. మీరు ప్రజల జీవితాలను ప్రభావితం చేసే విధంగా మెషీన్ లెర్నింగ్ మోడల్స్ ఉపయోగిస్తున్నప్పుడు, మోడల్ ప్రవర్తనను ప్రభావితం చేసే అంశాలను అర్థం చేసుకోవడం మరియు వివరించడం చాలా ముఖ్యం. మోడల్ వివరణాత్మకత మరియు వివరణాత్మకత ఈ పరిస్థితుల్లో ప్రశ్నలకు సమాధానాలు ఇస్తుంది:
* మోడల్ డీబగ్గింగ్: నా మోడల్ ఈ తప్పు ఎందుకు చేసింది? నేను నా మోడల్‌ను ఎలా మెరుగుపరుచుకోవచ్చు?
* మానవ-AI సహకారం: నేను మోడల్ నిర్ణయాలను ఎలా అర్థం చేసుకుని నమ్మగలను?
* నియంత్రణ అనుగుణత: నా మోడల్ చట్టపరమైన అవసరాలను తీరుస్తుందా?
RAI డాష్‌బోర్డ్‌లో లక్షణ ప్రాముఖ్యత భాగం మోడల్ డీబగ్గింగ్ మరియు మోడల్ అంచనాలు ఎలా జరుగుతున్నాయో సమగ్రంగా అర్థం చేసుకోవడంలో సహాయపడుతుంది. ఇది మెషీన్ లెర్నింగ్ నిపుణులు మరియు నిర్ణయ తీసుకునే వారు మోడల్ ప్రవర్తనను ప్రభావితం చేసే లక్షణాలను వివరించడానికి మరియు నియంత్రణ అనుగుణత కోసం సాక్ష్యాలు చూపడానికి ఉపయోగపడే టూల్. తరువాత, వాడుకదారులు గ్లోబల్ మరియు లోకల్ వివరణలను అన్వేషించి ఏ లక్షణాలు మోడల్ అంచనాలను ప్రభావితం చేస్తున్నాయో ధృవీకరించవచ్చు. గ్లోబల్ వివరణలు మోడల్ మొత్తం అంచనాపై ప్రభావం చూపిన టాప్ లక్షణాలను చూపిస్తాయి. లోకల్ వివరణలు వ్యక్తిగత కేసు కోసం మోడల్ అంచనాకు కారణమైన లక్షణాలను చూపిస్తాయి. లోకల్ వివరణలను అంచనా వేయడం ఒక నిర్దిష్ట కేసును డీబగ్ చేయడంలో లేదా ఆడిట్ చేయడంలో సహాయపడుతుంది, ఎందుకు మోడల్ ఖచ్చితమైన లేదా తప్పు అంచనాను ఇచ్చిందో అర్థం చేసుకోవడానికి.
![RAI డాష్‌బోర్డ్‌లో లక్షణ ప్రాముఖ్యత భాగం](../../../../translated_images/9-feature-importance.cd3193b4bba3fd4bccd415f566c2437fb3298c4824a3dabbcab15270d783606e.te.png)
* గ్లోబల్ వివరణలు: ఉదాహరణకు, మధుమేహ ఆసుపత్రి తిరిగి చేరే మోడల్ మొత్తం ప్రవర్తనను ఏ లక్షణాలు ప్రభావితం చేస్తున్నాయి?
* లోకల్ వివరణలు: ఉదాహరణకు, 60 సంవత్సరాల పైబడిన మధుమేహ రోగి గత ఆసుపత్రి చేర్పులతో 30 రోజుల్లో తిరిగి చేరే లేదా చేరని అంచనాకు కారణమైనది ఏమిటి?
వివిధ కోహార్ట్లలో మోడల్ పనితీరును పరిశీలించే డీబగ్గింగ్ ప్రక్రియలో, లక్షణ ప్రాముఖ్యత కోహార్ట్లలో లక్షణం ఎంత ప్రభావం చూపుతుందో చూపిస్తుంది. ఇది మోడల్ లోపభూయిష్ట అంచనాలను ప్రభావితం చేస్తున్న లక్షణం ప్రభావం స్థాయిలను పోల్చేటప్పుడు అసాధారణతలను వెలుగులోకి తీసుకువస్తుంది. లక్షణ ప్రాముఖ్యత భాగం ఒక లక్షణంలోని విలువలు మోడల్ ఫలితాన్ని సానుకూలంగా లేదా ప్రతికూలంగా ప్రభావితం చేశాయో చూపిస్తుంది. ఉదాహరణకు, ఒక మోడల్ తప్పు అంచనాను ఇచ్చినప్పుడు, ఈ భాగం మీరు లోతుగా వెళ్ళి ఏ లక్షణాలు లేదా లక్షణ విలువలు అంచనాను ప్రభావితం చేశాయో గుర్తించడానికి అవకాశం ఇస్తుంది. ఈ స్థాయి వివరాలు కేవలం డీబగ్గింగ్‌లో కాకుండా ఆడిట్ పరిస్థితుల్లో పారదర్శకత మరియు బాధ్యతను అందిస్తాయి. చివరగా, ఈ భాగం న్యాయ సమస్యలను గుర్తించడంలో సహాయపడుతుంది. ఉదాహరణకు, జాతి లేదా లింగం వంటి సున్నిత లక్షణం మోడల్ అంచనాను ఎక్కువగా ప్రభావితం చేస్తే, ఇది మోడల్‌లో జాతి లేదా లింగ పక్షపాతం సూచన కావచ్చు.
![లక్షణ ప్రాముఖ్యత](../../../../translated_images/9-features-influence.3ead3d3f68a84029f1e40d3eba82107445d3d3b6975d4682b23d8acc905da6d0.te.png)
వివరణాత్మకతను ఉపయోగించండి, మీరు:
* మీ AI వ్యవస్థ అంచనాలు ఎంత నమ్మదగినవో నిర్ణయించండి, అంచనాలకు అత్యంత ముఖ్యమైన లక్షణాలు ఏమిటో అర్థం చేసుకోవడం ద్వారా.
* మీ మోడల్‌ను ముందుగా అర్థం చేసుకుని, అది ఆరోగ్యకరమైన లక్షణాలను ఉపయోగిస్తున్నదా లేదా తప్పు సంబంధాలను మాత్రమే ఉపయోగిస్తున్నదా అని గుర్తించి డీబగ్గింగ్ చేయండి.
* మోడల్ సున్నిత లక్షణాలపై ఆధారపడి అంచనాలు చేస్తున్నదా లేదా వాటితో గాఢంగా సంబంధం ఉన్న లక్షణాలపై ఆధారపడి ఉందా అని అర్థం చేసుకుని, న్యాయ సమస్యల మూలాలను కనుగొనండి.
* లోకల్ వివరణలను సృష్టించి, వాటి ఫలితాలను చూపించి మీ మోడల్ నిర్ణయాలలో వాడుకదారుల నమ్మకాన్ని పెంచండి.
* AI వ్యవస్థ యొక్క నియంత్రణ ఆడిట్ పూర్తి చేసి, మోడల్స్‌ను ధృవీకరించి, మోడల్ నిర్ణయాల మానవులపై ప్రభావాన్ని పర్యవేక్షించండి.
## ముగింపు
అన్ని RAI డాష్‌బోర్డ్ భాగాలు సమాజానికి తక్కువ హానికరమైన మరియు ఎక్కువ నమ్మదగిన మెషీన్ లెర్నింగ్ మోడల్స్ నిర్మించడంలో సహాయపడే ప్రాక్టికల్ టూల్స్. ఇది మానవ హక్కులకు ముప్పు నివారణను మెరుగుపరుస్తుంది; కొన్ని గుంపులను జీవన అవకాశాల నుండి వివక్షించడం లేదా వేరుచేయడం; మరియు శారీరక లేదా మానసిక గాయాల ప్రమాదాన్ని తగ్గిస్తుంది. ఇది లోకల్ వివరణలను సృష్టించి, వాటి ఫలితాలను చూపించి మీ మోడల్ నిర్ణయాలలో నమ్మకాన్ని పెంచడంలో సహాయపడుతుంది. కొన్ని సంభావ్య హానులు ఇలా వర్గీకరించవచ్చు:
- **విభజన**, ఉదాహరణకు ఒక లింగం లేదా జాతి మరొకదానిపై ప్రాధాన్యం పొందినప్పుడు.
- **సేవా నాణ్యత**. మీరు ఒక నిర్దిష్ట పరిస్థితికి డేటాను శిక్షణ ఇచ్చినా, వాస్తవం చాలా క్లిష్టమైనప్పుడు, అది తక్కువ పనితీరు సేవకు దారితీస్తుంది.
- **స్టీరియోటైపింగ్**. ఒక గుంపును ముందుగా కేటాయించిన లక్షణాలతో అనుసంధానం చేయడం.
- **అవమానించడం**. ఏదైనా లేదా ఎవరికైనా అన్యాయంగా విమర్శించడం మరియు లేబుల్ చేయడం.
- **అధిక లేదా తక్కువ ప్రాతినిధ్యం**. ఒక నిర్దిష్ట వృత్తిలో ఒక నిర్దిష్ట సమూహం కనిపించకపోవడం అనే ఆలోచన, మరియు దాన్ని ప్రోత్సహించే ఏ సేవ లేదా ఫంక్షన్ హానికరంగా ఉంటుంది.
### Azure RAI డాష్‌బోర్డు
[Azure 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) ను పరిశీలించి వివిధ భాగాలను ఎలా ఉపయోగించాలో తెలుసుకోండి.
- Azure మెషీన్ లెర్నింగ్‌లో మరింత బాధ్యతాయుత AI సన్నివేశాలను డీబగ్గింగ్ చేయడానికి కొన్ని RAI డాష్‌బోర్డు [నమూనా నోట్బుక్స్](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) ను చూడండి.
---
## 🚀 సవాలు
గణాంక లేదా డేటా పక్షపాతాలను మొదట్లోనే ప్రవేశపెట్టకుండా ఉండేందుకు, మనం:
- వ్యవస్థలపై పని చేసే వ్యక్తులలో వైవిధ్యమైన నేపథ్యాలు మరియు దృష్టికోణాలు ఉండాలి
- మన సమాజ వైవిధ్యాన్ని ప్రతిబింబించే డేటాసెట్‌లలో పెట్టుబడి పెట్టాలి
- పక్షపాతం సంభవించినప్పుడు దాన్ని గుర్తించి సరిచేయడానికి మెరుగైన పద్ధతులను అభివృద్ధి చేయాలి
మోడల్ నిర్మాణం మరియు ఉపయోగంలో అన్యాయం స్పష్టంగా కనిపించే వాస్తవ జీవిత సన్నివేశాల గురించి ఆలోచించండి. మేము మరేమి పరిగణించాలి?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠంలో, మీరు మెషీన్ లెర్నింగ్‌లో బాధ్యతాయుత AIని అనుసరించడానికి కొన్ని ప్రాక్టికల్ టూల్స్ నేర్చుకున్నారు.
ఈ వర్క్‌షాప్‌ను చూడండి మరియు విషయాలను మరింత లోతుగా తెలుసుకోండి:
- బాధ్యతాయుత AI డాష్‌బోర్డు: ప్రాక్టీస్‌లో RAIని ఆపరేషనలైజ్ చేయడానికి ఒకే చోటు - బేస్మిరా నుషి మరియు మెహ్ర్నూష్ సమేకి
[![బాధ్యతాయుత AI డాష్‌బోర్డు: ప్రాక్టీస్‌లో RAIని ఆపరేషనలైజ్ చేయడానికి ఒకే చోటు](https://img.youtube.com/vi/f1oaDNl3djg/0.jpg)](https://www.youtube.com/watch?v=f1oaDNl3djg "బాధ్యతాయుత AI డాష్‌బోర్డు: ప్రాక్టీస్‌లో RAIని ఆపరేషనలైజ్ చేయడానికి ఒకే చోటు")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: బాధ్యతాయుత AI డాష్‌బోర్డు: ప్రాక్టీస్‌లో RAIని ఆపరేషనలైజ్ చేయడానికి ఒకే చోటు - బేస్మిరా నుషి మరియు మెహ్ర్నూష్ సమేకి
బాధ్యతాయుత AI మరియు మరింత నమ్మకమైన మోడల్స్‌ను ఎలా నిర్మించాలో తెలుసుకోవడానికి క్రింది వనరులను సూచించండి:
- Microsoft యొక్క RAI డాష్‌బోర్డు టూల్స్ ML మోడల్స్ డీబగ్గింగ్ కోసం: [బాధ్యతాయుత AI టూల్స్ వనరులు](https://aka.ms/rai-dashboard)
- బాధ్యతాయుత AI టూల్‌కిట్‌ను అన్వేషించండి: [Github](https://github.com/microsoft/responsible-ai-toolbox)
- Microsoft యొక్క RAI వనరుల కేంద్రం: [బాధ్యతాయుత AI వనరులు – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Microsoft యొక్క FATE పరిశోధనా గ్రూప్: [FATE: న్యాయం, బాధ్యత, పారదర్శకత, మరియు 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/te/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:19+00:00",
"source_file": "9-Real-World/2-Debugging-ML-Models/assignment.md",
"language_code": "te"
}
-->
# బాధ్యతాయుత 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/te/9-Real-World/README.md
Unescape View File

@ -0,0 +1,34 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5e069a0ac02a9606a69946c2b3c574a9",
"translation_date": "2025-12-19T13:05:31+00:00",
"source_file": "9-Real-World/README.md",
"language_code": "te"
}
-->
# పోస్ట్‌స్క్రిప్ట్: క్లాసిక్ మెషీన్ లెర్నింగ్ యొక్క వాస్తవ ప్రపంచ అనువర్తనాలు
ఈ పాఠ్యాంశంలో, మీరు క్లాసికల్ ML యొక్క కొన్ని వాస్తవ ప్రపంచ అనువర్తనాలను పరిచయం చేయబడతారు. మేము న్యూరల్ నెట్‌వర్క్స్, డీప్ లెర్నింగ్ మరియు AI ను సాధ్యమైనంత వరకు తప్పించి, ఈ వ్యూహాలను ఉపయోగించిన అనువర్తనాల గురించి వైట్‌పేపర్లు మరియు వ్యాసాలను వెతికాము. వ్యాపార వ్యవస్థలు, పర్యావరణ అనువర్తనాలు, ఆర్థిక, కళలు మరియు సంస్కృతి మరియు మరిన్ని విషయాలలో ML ఎలా ఉపయోగించబడుతున్నదో తెలుసుకోండి.
![chess](../../../translated_images/chess.e704a268781bdad85d1876b6c2295742fa0d856e7dcf3659147052df9d3db205.te.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)
## క్రెడిట్స్
"వాస్తవ ప్రపంచ అనువర్తనాలు" అనేది [Jen Looper](https://twitter.com/jenlooper) మరియు [Ornella Altunyan](https://twitter.com/ornelladotcom) సహా ఒక బృందం ద్వారా రాయబడింది.
"జవాబుదారీ AI డాష్‌బోర్డ్ భాగాలను ఉపయోగించి మెషీన్ లెర్నింగ్‌లో మోడల్ డీబగ్గింగ్" అనేది [Ruth Yakubu](https://twitter.com/ruthieyakubu) ద్వారా రాయబడింది.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

347
translations/te/AGENTS.md
Unescape View File

@ -0,0 +1,347 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "93fdaa0fd38836e50c4793e2f2f25e8b",
"translation_date": "2025-12-19T12:38:53+00:00",
"source_file": "AGENTS.md",
"language_code": "te"
}
-->
# AGENTS.md
## Project Overview
ఇది **Machine Learning for Beginners**, పాఠ్యాంశాల 26తో కూడిన 12 వారాల సమగ్ర పాఠ్యక్రమం, ఇది Python (ప్రధానంగా Scikit-learn తో) మరియు R ఉపయోగించి క్లాసిక్ మెషీన్ లెర్నింగ్ కాన్సెప్ట్‌లను కవర్ చేస్తుంది. ఈ రిపోజిటరీ స్వీయ-గతిలో నేర్చుకునే వనరుగా రూపొందించబడింది, ఇందులో ప్రాక్టికల్ ప్రాజెక్టులు, క్విజ్‌లు మరియు అసైన్‌మెంట్‌లు ఉన్నాయి. ప్రతి పాఠం ప్రపంచవ్యాప్తంగా వివిధ సంస్కృతులు మరియు ప్రాంతాల నుండి వాస్తవ డేటా ద్వారా ML కాన్సెప్ట్‌లను అన్వేషిస్తుంది.
ప్రధాన భాగాలు:
- **విద్యా విషయాలు**: ML పరిచయం, రిగ్రెషన్, క్లాసిఫికేషన్, క్లస్టరింగ్, NLP, టైమ్ సిరీస్, మరియు రీఇన్ఫోర్స్‌మెంట్ లెర్నింగ్‌ను కవర్ చేసే 26 పాఠాలు
- **క్విజ్ అప్లికేషన్**: Vue.js ఆధారిత క్విజ్ యాప్, పాఠం ముందు మరియు తర్వాత అంచనాలతో
- **బహుభాషా మద్దతు**: GitHub Actions ద్వారా 40+ భాషలకు ఆటోమేటెడ్ అనువాదాలు
- **రెండు భాషల మద్దతు**: పాఠాలు Python (Jupyter నోట్‌బుక్స్) మరియు R (R Markdown ఫైళ్లలో) అందుబాటులో ఉన్నాయి
- **ప్రాజెక్ట్ ఆధారిత నేర్చుకోవడం**: ప్రతి అంశం ప్రాక్టికల్ ప్రాజెక్టులు మరియు అసైన్‌మెంట్‌లను కలిగి ఉంటుంది
## 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` - Python Jupyter నోట్‌బుక్
- `solution/` - సొల్యూషన్ కోడ్ (Python మరియు R వెర్షన్లు)
- `assignment.md` - ప్రాక్టీస్ వ్యాయామాలు
- `images/` - విజువల్ వనరులు
## Setup Commands
### For Python Lessons
అధిక భాగం పాఠాలు Jupyter నోట్‌బుక్స్ ఉపయోగిస్తాయి. అవసరమైన డిపెండెన్సీలను ఇన్‌స్టాల్ చేయండి:
```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. Jupyter నోట్‌బుక్ తెరవండి:
```bash
jupyter notebook notebook.ipynb
```
3. పాఠ్యాంశం మరియు వ్యాయామాలపై పని చేయండి
4. అవసరమైతే `solution/` ఫోల్డర్‌లో సొల్యూషన్లను తనిఖీ చేయండి
### Python Development
- పాఠాలు ప్రామాణిక Python డేటా సైన్స్ లైబ్రరీలను ఉపయోగిస్తాయి
- ఇంటరాక్టివ్ నేర్చుకోవడానికి Jupyter నోట్‌బుక్స్
- ప్రతి పాఠం `solution/` ఫోల్డర్‌లో సొల్యూషన్ కోడ్ అందుబాటులో ఉంటుంది
### R Development
- R పాఠాలు `.rmd` ఫార్మాట్ (R Markdown)లో ఉంటాయి
- సొల్యూషన్లు `solution/R/` ఉపడైరెక్టరీలలో ఉంటాయి
- R నోట్‌బుక్స్ నడపడానికి RStudio లేదా R కర్నెల్‌తో Jupyter ఉపయోగించండి
### 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 స్టైల్ మార్గదర్శకాలను అనుసరించండి
- స్పష్టమైన, వివరణాత్మక వేరియబుల్ పేర్లను ఉపయోగించండి
- క్లిష్టమైన ఆపరేషన్లకు వ్యాఖ్యలు చేర్చండి
- Jupyter నోట్‌బుక్స్‌లో కాన్సెప్ట్‌లను వివరించే మార్క్డౌన్ సెల్స్ ఉండాలి
### JavaScript/Vue.js (Quiz App)
- Vue.js స్టైల్ గైడ్‌ను అనుసరిస్తుంది
- `quiz-app/package.json`లో ESLint కాన్ఫిగరేషన్
- సమస్యలను తనిఖీ చేయడానికి మరియు ఆటో-ఫిక్స్ చేయడానికి `npm run lint` నడపండి
### Documentation
- మార్క్డౌన్ ఫైళ్లు స్పష్టంగా మరియు బాగా నిర్మించబడాలి
- కోడ్ ఉదాహరణలను fenced కోడ్ బ్లాక్స్‌లో చేర్చండి
- అంతర్గత సూచనలకు సంబంధిత లింకులను ఉపయోగించండి
- ఉన్న ఫార్మాటింగ్ సంప్రదాయాలను అనుసరించండి
## 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
- **శీర్షిక ఫార్మాట్**: `[Section] మార్పుల సంక్షిప్త వివరణ`
- ఉదా: `[Regression] పాఠం 5లో టైపో సరిచేయండి`
- ఉదా: `[Quiz-App] డిపెండెన్సీలను నవీకరించండి`
- **సమర్పించే ముందు**:
- అన్ని నోట్‌బుక్ సెల్స్ ఎర్రర్ల లేకుండా నడవాలి
- quiz-app మార్చినట్లయితే `npm run lint` నడపండి
- మార్క్డౌన్ ఫార్మాటింగ్ తనిఖీ చేయండి
- కొత్త కోడ్ ఉదాహరణలను పరీక్షించండి
- **PRలో ఉండవలసినవి**:
- మార్పుల వివరణ
- మార్పుల కారణం
- UI మార్పులుంటే స్క్రీన్‌షాట్లు
- **Code of Conduct**: [Microsoft Open Source Code of Conduct](CODE_OF_CONDUCT.md) అనుసరించండి
- **CLA**: Contributor License Agreement సంతకం చేయాలి
## Lesson Structure
ప్రతి పాఠం ఒక సుస్పష్టమైన నమూనాను అనుసరిస్తుంది:
1. **పాఠం ముందు క్విజ్** - ప్రాథమిక జ్ఞానాన్ని పరీక్షించండి
2. **పాఠ్యాంశం** - వ్రాత సూచనలు మరియు వివరణలు
3. **కోడ్ డెమోస్** - నోట్‌బుక్స్‌లో ప్రాక్టికల్ ఉదాహరణలు
4. **జ్ఞాన తనిఖీలు** - అర్థం చేసుకున్నదాన్ని నిర్ధారించండి
5. **చాలెంజ్** - స్వతంత్రంగా కాన్సెప్ట్‌లను వర్తించండి
6. **అసైన్‌మెంట్** - విస్తృత ప్రాక్టీస్
7. **పాఠం తర్వాత క్విజ్** - నేర్చుకున్న ఫలితాలను అంచనా వేయండి
## Common Commands Reference
```bash
# Python/Jupyter
jupyter notebook # Jupyter సర్వర్ ప్రారంభించండి
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 వర్క్‌ఫ్లో
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**: ML పాఠాల కోసం ప్రాథమిక భాష (Scikit-learn, Pandas, NumPy, Matplotlib)
- **R**: tidyverse, tidymodels, caret ఉపయోగించి ప్రత్యామ్నాయ అమలు
- **Jupyter**: Python పాఠాల కోసం ఇంటరాక్టివ్ నోట్‌బుక్స్
- **R Markdown**: R పాఠాల డాక్యుమెంట్లు
- **Vue.js 3**: క్విజ్ అప్లికేషన్ ఫ్రేమ్‌వర్క్
- **Flask**: ML మోడల్ డిప్లాయ్‌మెంట్ కోసం వెబ్ అప్లికేషన్ ఫ్రేమ్‌వర్క్
- **Docsify**: డాక్యుమెంటేషన్ సైట్ జనరేటర్
- **GitHub Actions**: CI/CD మరియు ఆటోమేటెడ్ అనువాదాలు
## 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 ప్యాకేజీ ఇన్‌స్టాల్ ఉందని నిర్ధారించండి
- **కర్నెల్ సమస్యలు**: Jupyter కోసం IRkernel ఇన్‌స్టాల్ చేయవలసి ఉండవచ్చు
## Project-Specific Notes
- ఇది ప్రధానంగా **నెర్చుకునే పాఠ్యక్రమం**, ప్రొడక్షన్ కోడ్ కాదు
- ప్రాధాన్యం **ML కాన్సెప్ట్‌లను అర్థం చేసుకోవడంలో** ఉంది, ప్రాక్టికల్ ద్వారా
- కోడ్ ఉదాహరణలు **స్పష్టతపై ఎక్కువ దృష్టి** పెట్టాయి, ఆప్టిమైజేషన్ కంటే
- ఎక్కువ భాగం పాఠాలు **స్వతంత్రంగా పూర్తి చేయగలవు**
- **సొల్యూషన్లు అందుబాటులో ఉన్నాయి**, కానీ నేర్చుకునేవారు ముందుగా వ్యాయామాలు ప్రయత్నించాలి
- రిపోజిటరీ Docsify ఉపయోగించి వెబ్ డాక్యుమెంటేషన్ అందిస్తుంది, బిల్డ్ స్టెప్ అవసరం లేదు
- **స్కెచ్‌నోట్లు** కాన్సెప్ట్‌ల విజువల్ సారాంశాలను అందిస్తాయి
- **బహుభాషా మద్దతు** కంటెంట్‌ను ప్రపంచవ్యాప్తంగా అందుబాటులో ఉంచుతుంది
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలో ఉన్నది అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/te/CODE_OF_CONDUCT.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
"translation_date": "2025-12-19T12:43:52+00:00",
"source_file": "CODE_OF_CONDUCT.md",
"language_code": "te"
}
-->
# Microsoft ఓపెన్ సోర్స్ కోడ్ ఆఫ్ కండక్ట్
ఈ ప్రాజెక్ట్ [Microsoft ఓపెన్ సోర్స్ కోడ్ ఆఫ్ కండక్ట్](https://opensource.microsoft.com/codeofconduct/)ని ఆమోదించింది.
వనరులు:
- [Microsoft ఓపెన్ సోర్స్ కోడ్ ఆఫ్ కండక్ట్](https://opensource.microsoft.com/codeofconduct/)
- [Microsoft కోడ్ ఆఫ్ కండక్ట్ FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
- ప్రశ్నలు లేదా ఆందోళనల కోసం [opencode@microsoft.com](mailto:opencode@microsoft.com) ను సంప్రదించండి
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

29
translations/te/CONTRIBUTING.md
Unescape View File

@ -0,0 +1,29 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
"translation_date": "2025-12-19T12:27:46+00:00",
"source_file": "CONTRIBUTING.md",
"language_code": "te"
}
-->
# Contributing
ఈ ప్రాజెక్ట్ సహకారాలు మరియు సూచనలను స్వాగతిస్తుంది. ఎక్కువ భాగం సహకారాలకు మీరు
కాంట్రిబ్యూటర్ లైసెన్స్ అగ్రిమెంట్ (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 -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

2840
translations/te/PyTorch_Fundamentals.ipynb
View File

File diff suppressed because it is too large Load Diff

223
translations/te/README.md
Unescape View File

@ -0,0 +1,223 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c300f2380d9da91b7de8c707f69ce99b",
"translation_date": "2025-12-19T12:46:58+00:00",
"source_file": "README.md",
"language_code": "te"
}
-->
[![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](../kn/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](./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 తో నేర్చుకునే సిరీస్ నిర్వహిస్తున్నాము, మరింత తెలుసుకోండి మరియు 18 - 30 సెప్టెంబర్, 2025 న [Learn with AI Series](https://aka.ms/learnwithai/discord) లో చేరండి. మీరు GitHub Copilot ను డేటా సైన్స్ కోసం ఉపయోగించే చిట్కాలు మరియు సలహాలు పొందుతారు.
![Learn with AI series](../../translated_images/3.9b58fd8d6c373c20c588c5070c4948a826ab074426c28ceb5889641294373dfc.te.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` ఫోల్డర్‌లో అందుబాటులో ఉంటుంది.
- పోస్ట్-లెక్చర్ క్విజ్ తీసుకోండి.
- ఛాలెంజ్ పూర్తి చేయండి.
- అసైన్‌మెంట్ పూర్తి చేయండి.
- ఒక పాఠం సమూహం పూర్తి చేసిన తర్వాత, [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) ను సందర్శించి, సరైన PAT రుబ్రిక్‌ను పూరించి "learn out loud" చేయండి. 'PAT' అనేది ప్రోగ్రెస్ అసెస్‌మెంట్ టూల్, ఇది మీరు మీ నేర్చుకునే ప్రక్రియను మెరుగుపరచడానికి పూరించే రుబ్రిక్. మీరు ఇతర PAT లకు కూడా స్పందించవచ్చు, తద్వారా మనం కలిసి నేర్చుకోవచ్చు.
> మరింత అధ్యయనానికి, ఈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) మాడ్యూల్స్ మరియు లెర్నింగ్ పాథ్స్ అనుసరించమని మేము సిఫార్సు చేస్తున్నాము.
**ఉపాధ్యాయులు**, ఈ పాఠ్యక్రమాన్ని ఎలా ఉపయోగించాలో మేము కొన్ని [సూచనలు](for-teachers.md) చేర్చాము.
---
## వీడియో వాక్‌త్రూ
కొన్ని పాఠాలు చిన్న వీడియోలుగా అందుబాటులో ఉన్నాయి. మీరు ఈ వీడియోలను పాఠాలలో inline గా లేదా [Microsoft Developer YouTube ఛానెల్ లో ML for Beginners ప్లేలిస్ట్](https://aka.ms/ml-beginners-videos) లో చూడవచ్చు, క్రింది చిత్రంపై క్లిక్ చేయండి.
[![ML for beginners banner](../../translated_images/ml-for-beginners-video-banner.63f694a100034bc6251134294459696e070a3a9a04632e9fe6a24aa0de4a7384.te.png)](https://aka.ms/ml-beginners-videos)
---
## టీమ్‌ను కలవండి
[![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)
**Gif ద్వారా** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
> 🎥 ప్రాజెక్ట్ మరియు దాన్ని సృష్టించిన వ్యక్తుల గురించి వీడియో కోసం పై చిత్రంపై క్లిక్ చేయండి!
---
## పాఠ్య విధానం
ఈ పాఠ్యక్రమాన్ని రూపొందించేటప్పుడు మేము రెండు పాఠ్య సిద్ధాంతాలను ఎంచుకున్నాము: ఇది చేతితో చేయగలిగే **ప్రాజెక్ట్-ఆధారిత**గా ఉండాలి మరియు ఇందులో **తరచూ క్విజ్‌లు** ఉండాలి. అదనంగా, ఈ పాఠ్యక్రమానికి ఒక సాధారణ **థీమ్** ఉంది, ఇది దానిని సమగ్రత ఇస్తుంది.
కంటెంట్ ప్రాజెక్టులకు అనుగుణంగా ఉండటం ద్వారా, విద్యార్థులకు ఇది మరింత ఆసక్తికరంగా మారుతుంది మరియు భావనల నిలుపుదల పెరుగుతుంది. తరగతి ముందు తక్కువ-ప్రమాద క్విజ్ విద్యార్థి ఒక విషయం నేర్చుకోవాలనే ఉద్దేశ్యాన్ని ఏర్పరుస్తుంది, తరగతి తర్వాత రెండవ క్విజ్ మరింత నిలుపుదలని నిర్ధారిస్తుంది. ఈ పాఠ్యక్రమం సౌకర్యవంతంగా మరియు సరదాగా ఉండేలా రూపొందించబడింది మరియు మొత్తం లేదా భాగంగా తీసుకోవచ్చు. ప్రాజెక్టులు చిన్నదిగా ప్రారంభమై 12 వారాల చక్రం చివరికి క్రమంగా క్లిష్టత పెరుగుతాయి. ఈ పాఠ్యక్రమంలో ML యొక్క వాస్తవ ప్రపంచ అనువర్తనాలపై ఒక పోస్ట్‌స్క్రిప్ట్ కూడా ఉంది, ఇది అదనపు క్రెడిట్ లేదా చర్చకు ఆధారంగా ఉపయోగించవచ్చు.
> మా [Code of Conduct](CODE_OF_CONDUCT.md), [Contributing](CONTRIBUTING.md), [Translation](TRANSLATIONS.md), మరియు [Troubleshooting](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 folder](../../quiz-app) లో ఉన్నాయి, మొత్తం 52 క్విజ్‌లు, ప్రతి ఒక్కటి మూడు ప్రశ్నలతో. అవి పాఠాలలో లింక్ చేయబడ్డాయి కానీ క్విజ్ యాప్ స్థానికంగా నడపవచ్చు; స్థానికంగా హోస్ట్ చేయడానికి లేదా Azure కు డిప్లాయ్ చేయడానికి `quiz-app` ఫోల్డర్ లో సూచనలు అనుసరించండి.
| పాఠం సంఖ్య | విషయం | పాఠం సమూహం | నేర్చుకునే లక్ష్యాలు | లింక్ చేసిన పాఠం | రచయిత |
| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
| 01 | మెషీన్ లెర్నింగ్ పరిచయం | [Introduction](1-Introduction/README.md) | మెషీన్ లెర్నింగ్ వెనుక ఉన్న ప్రాథమిక సూత్రాలను నేర్చుకోండి | [Lesson](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | మెషీన్ లెర్నింగ్ చరిత్ర | [Introduction](1-Introduction/README.md) | ఈ రంగం వెనుక ఉన్న చరిత్రను తెలుసుకోండి | [Lesson](1-Introduction/2-history-of-ML/README.md) | Jen and Amy |
| 03 | న్యాయసమ్మతత మరియు మెషీన్ లెర్నింగ్ | [Introduction](1-Introduction/README.md) | మెషీన్ లెర్నింగ్ మోడల్స్ నిర్మించేటప్పుడు మరియు వర్తింపజేసేటప్పుడు విద్యార్థులు పరిగణించవలసిన ముఖ్యమైన తాత్విక సమస్యలు ఏమిటి? | [Lesson](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | మెషీన్ లెర్నింగ్ సాంకేతికతలు | [Introduction](1-Introduction/README.md) | మెషీన్ లెర్నింగ్ పరిశోధకులు మెషీన్ లెర్నింగ్ మోడల్స్ నిర్మించడానికి ఏ సాంకేతికతలను ఉపయోగిస్తారు? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | Chris and Jen |
| 05 | రిగ్రెషన్ పరిచయం | [Regression](2-Regression/README.md) | రిగ్రెషన్ మోడల్స్ కోసం Python మరియు Scikit-learn తో ప్రారంభించండి | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | ఉత్తర అమెరికన్ పంప్కిన్ ధరలు 🎃 | [Regression](2-Regression/README.md) | మెషీన్ లెర్నింగ్ కోసం డేటాను విజువలైజ్ చేసి శుభ్రపరచండి | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | ఉత్తర అమెరికన్ పంప్కిన్ ధరలు 🎃 | [Regression](2-Regression/README.md) | లీనియర్ మరియు పాలినోమియల్ రిగ్రెషన్ మోడల్స్ నిర్మించండి | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen and Dmitry • Eric Wanjau |
| 08 | ఉత్తర అమెరికన్ పంప్కిన్ ధరలు 🎃 | [Regression](2-Regression/README.md) | లాజిస్టిక్ రిగ్రెషన్ మోడల్ నిర్మించండి | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | ఒక వెబ్ యాప్ 🔌 | [Web App](3-Web-App/README.md) | మీ శిక్షణ పొందిన మోడల్ ఉపయోగించడానికి ఒక వెబ్ యాప్ నిర్మించండి | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | వర్గీకరణ పరిచయం | [Classification](4-Classification/README.md) | మీ డేటాను శుభ్రపరచండి, సిద్ధం చేయండి, మరియు విజువలైజ్ చేయండి; వర్గీకరణకు పరిచయం | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen and Cassie • Eric Wanjau |
| 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) | Jen and Cassie • Eric Wanjau |
| 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) | Jen and Cassie • Eric Wanjau |
| 13 | రుచికరమైన ఆసియా మరియు భారతీయ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | మీ మోడల్ ఉపయోగించి ఒక సిఫార్సు వెబ్ యాప్ నిర్మించండి | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | క్లస్టరింగ్ పరిచయం | [Clustering](5-Clustering/README.md) | మీ డేటాను శుభ్రపరచండి, సిద్ధం చేయండి, మరియు విజువలైజ్ చేయండి; క్లస్టరింగ్ పరిచయం | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | నైజీరియన్ సంగీత రుచులను అన్వేషణ 🎧 | [Clustering](5-Clustering/README.md) | K-Means క్లస్టరింగ్ పద్ధతిని అన్వేషించండి | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | సహజ భాషా ప్రాసెసింగ్ పరిచయం ☕️ | [Natural language processing](6-NLP/README.md) | ఒక సులభమైన బాట్ నిర్మించడం ద్వారా NLP యొక్క ప్రాథమికాలు నేర్చుకోండి | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | సాధారణ NLP పనులు ☕️ | [Natural language processing](6-NLP/README.md) | భాషా నిర్మాణాలతో వ్యవహరించేటప్పుడు అవసరమైన సాధారణ పనులను అర్థం చేసుకోవడం ద్వారా మీ NLP జ్ఞానాన్ని లోతుగా చేయండి | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | అనువాదం మరియు భావ విశ్లేషణ ♥️ | [Natural language processing](6-NLP/README.md) | జేన్ ఆస్టెన్ తో అనువాదం మరియు భావ విశ్లేషణ | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | యూరోప్ యొక్క రొమాంటిక్ హోటల్స్ ♥️ | [Natural language processing](6-NLP/README.md) | హోటల్ సమీక్షలతో భావ విశ్లేషణ 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | యూరోప్ యొక్క రొమాంటిక్ హోటల్స్ ♥️ | [Natural language processing](6-NLP/README.md) | హోటల్ సమీక్షలతో భావ విశ్లేషణ 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం | [Time series](7-TimeSeries/README.md) | టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ ప్రపంచ విద్యుత్ వినియోగం ⚡️ - ARIMA తో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Time series](7-TimeSeries/README.md) | ARIMA తో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ ప్రపంచ విద్యుత్ వినియోగం ⚡️ - SVR తో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Time series](7-TimeSeries/README.md) | సపోర్ట్ వెక్టర్ రిగ్రెషర్ తో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | రీఇన్ఫోర్స్‌మెంట్ లెర్నింగ్ పరిచయం | [Reinforcement learning](8-Reinforcement/README.md) | Q-లెర్నింగ్ తో రీఇన్ఫోర్స్‌మెంట్ లెర్నింగ్ పరిచయం | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | పీటర్‌ను నక్క నుండి తప్పించండి! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | రీఇన్ఫోర్స్‌మెంట్ లెర్నింగ్ జిమ్ | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Postscript | వాస్తవ ప్రపంచ ML పరిస్థితులు మరియు అనువర్తనాలు | [ML in the Wild](9-Real-World/README.md) | క్లాసికల్ ML యొక్క ఆసక్తికరమైన మరియు వెల్లడించే వాస్తవ ప్రపంచ అనువర్తనాలు | [Lesson](9-Real-World/1-Applications/README.md) | Team |
| Postscript | RAI డాష్‌బోర్డ్ ఉపయోగించి ML లో మోడల్ డీబగ్గింగ్ | [ML in the Wild](9-Real-World/README.md) | రిస్పాన్సిబుల్ AI డాష్‌బోర్డ్ భాగాలతో మెషీన్ లెర్నింగ్‌లో మోడల్ డీబగ్గింగ్ | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [ఈ కోర్సు కోసం మా 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 -->
### LangChain
[![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)
---
### Azure / Edge / MCP / Agents
[![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)
---
### Generative AI Series
[![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)
[![Generative AI (Java)](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)
[![Generative AI (JavaScript)](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)
---
### కోర్ లెర్నింగ్
[![ML for Beginners](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)
[![Data Science for Beginners](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 for Beginners](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)
[![Cybersecurity for Beginners](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)
[![Web Dev for Beginners](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)
[![IoT for Beginners](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 Development for Beginners](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)
---
### కోపైలట్ సిరీస్
[![Copilot for AI Paired Programming](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)
[![Copilot for 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)
[![Copilot Adventure](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/te/SECURITY.md
Unescape View File

@ -0,0 +1,53 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
"translation_date": "2025-12-19T12:44:27+00:00",
"source_file": "SECURITY.md",
"language_code": "te"
}
-->
## భద్రత
మైక్రోసాఫ్ట్ మా సాఫ్ట్‌వేర్ ఉత్పత్తులు మరియు సేవల భద్రతను గంభీరంగా తీసుకుంటుంది, దీనిలో మా 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/) ఉన్నాయి.
మీరు Microsoft-స్వంతమైన ఏదైనా రిపాజిటరీలో [Microsoft భద్రతా లోపం నిర్వచనం](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott) కు సరిపోయే భద్రతా లోపాన్ని కనుగొన్నారని భావిస్తే, దయచేసి క్రింద వివరించిన విధంగా మాకు నివేదించండి.
## భద్రతా సమస్యలను నివేదించడం
**దయచేసి భద్రతా లోపాలను పబ్లిక్ GitHub ఇష్యూల ద్వారా నివేదించవద్దు.**
దీనికి బదులుగా, దయచేసి Microsoft Security Response Center (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) పేజీని మా సక్రియ కార్యక్రమాల గురించి మరింత వివరాలకు సందర్శించండి.
## ప్రాధాన్యత ఉన్న భాషలు
మేము అన్ని కమ్యూనికేషన్లు ఆంగ్లంలో ఉండాలని ఇష్టపడతాము.
## విధానం
Microsoft [సమన్వయ భద్రతా లోపం వెల్లడింపు](https://www.microsoft.com/en-us/msrc/cvd) సూత్రాన్ని అనుసరిస్తుంది.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

31
translations/te/SUPPORT.md
Unescape View File

@ -0,0 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "09623d7343ff1c26ff4f198c1b2d3176",
"translation_date": "2025-12-19T12:27:22+00:00",
"source_file": "SUPPORT.md",
"language_code": "te"
}
-->
# మద్దతు
## సమస్యలను ఎలా నమోదు చేయాలి మరియు సహాయం పొందాలి
సమస్యను నమోదు చేయడానికి ముందు, దయచేసి ఇన్‌స్టాలేషన్, సెటప్ మరియు పాఠాలు నడపడంలో సాధారణ సమస్యలకు పరిష్కారాల కోసం మా [Troubleshooting Guide](TROUBLESHOOTING.md) ను తనిఖీ చేయండి.
ఈ ప్రాజెక్ట్ బగ్స్ మరియు ఫీచర్ అభ్యర్థనలను ట్రాక్ చేయడానికి GitHub Issues ను ఉపయోగిస్తుంది. దయచేసి కొత్త సమస్యలను నమోదు చేయడానికి ముందు ఇప్పటికే ఉన్న సమస్యలను శోధించండి, డూప్లికేట్లను నివారించడానికి. కొత్త సమస్యల కోసం, మీ బగ్ లేదా ఫీచర్ అభ్యర్థనను కొత్త Issue గా నమోదు చేయండి.
ఈ ప్రాజెక్ట్ ఉపయోగించడంపై సహాయం మరియు ప్రశ్నల కోసం, మీరు కూడా:
- [Troubleshooting Guide](TROUBLESHOOTING.md) ను తనిఖీ చేయండి
- మా [Discord Discussions #ml-for-beginners channel](https://aka.ms/foundry/discord) ను సందర్శించండి
- సమస్యను నమోదు చేయండి
## Microsoft మద్దతు విధానం
ఈ రిపోజిటరీకి మద్దతు పై పేర్కొన్న వనరులకు మాత్రమే పరిమితం.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

612
translations/te/TROUBLESHOOTING.md
Unescape View File

@ -0,0 +1,612 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "134d8759f0e2ab886e9aa4f62362c201",
"translation_date": "2025-12-19T12:29:53+00:00",
"source_file": "TROUBLESHOOTING.md",
"language_code": "te"
}
-->
# సమస్య పరిష్కరణ గైడ్
ఈ గైడ్ మిషీన్ లెర్నింగ్ ఫర్ బిగినర్స్ పాఠ్యాంశంతో పని చేస్తున్నప్పుడు సాధారణ సమస్యలను పరిష్కరించడంలో మీకు సహాయం చేస్తుంది. మీరు ఇక్కడ పరిష్కారం కనుగొనకపోతే, దయచేసి మా [Discord చర్చలు](https://aka.ms/foundry/discord)ను చూడండి లేదా [ఇష్యూ ఓపెన్ చేయండి](https://github.com/microsoft/ML-For-Beginners/issues).
## విషయ సూచిక
- [ఇన్‌స్టాలేషన్ సమస్యలు](../..)
- [జుపైటర్ నోట్‌బుక్ సమస్యలు](../..)
- [పైథాన్ ప్యాకేజ్ సమస్యలు](../..)
- [ఆర్ ఎన్విరాన్‌మెంట్ సమస్యలు](../..)
- [క్విజ్ అప్లికేషన్ సమస్యలు](../..)
- [డేటా మరియు ఫైల్ పాత్ సమస్యలు](../..)
- [సాధారణ లోప సందేశాలు](../..)
- [పనితీరు సమస్యలు](../..)
- [ఎన్విరాన్‌మెంట్ మరియు కాన్ఫిగరేషన్](../..)
---
## ఇన్‌స్టాలేషన్ సమస్యలు
### పైథాన్ ఇన్‌స్టాలేషన్
**సమస్య**: `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` ఉపయోగించవలసి ఉండవచ్చు
**సమస్య**: బహుళ Python వెర్షన్లు కలగలిపి సమస్యలు సృష్టించడం
**పరిష్కారం**:
```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 ను కాపీ చేసి బ్రౌజర్‌లో మాన్యువల్‌గా పేస్ట్ చేయండి
# ఈ URL కోసం చూడండి: http://localhost:8888/?token=...
```
### ఆర్ ఇన్‌స్టాలేషన్
**సమస్య**: ఆర్ ప్యాకేజీలు ఇన్‌స్టాల్ కావడం లేదు
**పరిష్కారం**:
```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. సమస్య ఉన్న కోడ్ గుర్తించడానికి సెల్స్‌ను ఒక్కొక్కటిగా నడపండి
**సమస్య**: తప్పు Python కర్నెల్ ఎంచుకున్నది
**పరిష్కారం**:
1. ప్రస్తుత కర్నెల్‌ను తనిఖీ చేయండి: `Kernel → Change Kernel`
2. సరైన Python వెర్షన్ ఎంచుకోండి
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
# బైనరీ వెర్షన్ ఇన్‌స్టాల్ చేయండి (విండోస్/మ్యాక్‌ఓఎస్)
install.packages("package-name", type = "binary")
# ప్యాకేజీలు అవసరం అయితే R ను తాజా వెర్షన్‌కు అప్‌డేట్ చేయండి
# R వెర్షన్‌ను తనిఖీ చేయండి
R.version.string
# సిస్టమ్ ఆధారాలు ఇన్‌స్టాల్ చేయండి (లినక్స్)
# ఉబుంటు/డెబియన్ కోసం, టెర్మినల్‌లో:
# 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"))
```
### ఆర్‌మార్క్‌డౌన్ సమస్యలు
**సమస్య**: ఆర్‌మార్క్‌డౌన్ రేండర్ కావడం లేదు
**పరిష్కారం**:
```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
# Node.js వెర్షన్‌ను తనిఖీ చేయండి (14+ ఉండాలి)
node --version
# అవసరమైతే Node.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
# pyplot ను దిగుమతి చేసుకోండి
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
# మాక్OS/లినక్స్
python3 -m venv venv
source venv/bin/activate
# యాక్టివేట్ అయిందో లేదో తనిఖీ చేయండి (ప్రాంప్ట్‌లో వీవిఎన్ పేరు చూపించాలి)
which python # వీవిఎన్ పైథాన్‌ను సూచించాలి
```
**సమస్య**: ప్యాకేజీలు ఇన్‌స్టాల్ అయినా నోట్‌బుక్‌లో కనబడడం లేదు
**పరిష్కారం**:
```bash
# నోట్‌బుక్ సరైన కర్నెల్ ఉపయోగిస్తున్నదని నిర్ధారించుకోండి
# మీ వర్చువల్ ఎన్విరాన్‌మెంట్‌లో ipykernel ను ఇన్‌స్టాల్ చేయండి
pip install ipykernel
python -m ipykernel install --user --name=ml-env --display-name="Python (ml-env)"
# జూపిటర్‌లో: కర్నెల్ → కర్నెల్ మార్చండి → Python (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 కోడ్‌లో Python ఎక్స్‌టెన్షన్ ఇన్‌స్టాల్ చేయండి
2. VS కోడ్‌లో Jupyter ఎక్స్‌టెన్షన్ ఇన్‌స్టాల్ చేయండి
3. సరైన Python ఇంటర్‌ప్రెటర్ ఎంచుకోండి: `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. **కొత్త ఇష్యూ ఓపెన్ చేయండి**: ఇందులో చేర్చండి:
- మీ ఆపరేటింగ్ సిస్టమ్ మరియు వెర్షన్
- Python/R వెర్షన్
- లోప సందేశం (పూర్తి ట్రేస్‌బ్యాక్)
- సమస్యను పునరుత్పత్తి చేసే దశలు
- మీరు ఇప్పటికే ప్రయత్నించినవి
మేము మీకు సహాయం చేయడానికి ఇక్కడ ఉన్నాము! 🚀
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

@ -0,0 +1,59 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "68dd06c685f6ce840e0acfa313352e7c",
"translation_date": "2025-12-19T13:09:48+00:00",
"source_file": "docs/_sidebar.md",
"language_code": "te"
}
-->
- పరిచయం
- [మిషన్ లెర్నింగ్ పరిచయం](../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/te/for-teachers.md
Unescape View File

@ -0,0 +1,39 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
"translation_date": "2025-12-19T12:26:16+00:00",
"source_file": "for-teachers.md",
"language_code": "te"
}
-->
## ఉపాధ్యాయులకు
మీ తరగతిలో ఈ పాఠ్యాంశాన్ని ఉపయోగించాలనుకుంటున్నారా? దయచేసి స్వేచ్ఛగా ఉపయోగించండి!
వాస్తవానికి, మీరు 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 -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

@ -0,0 +1,128 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
"translation_date": "2025-12-19T13:00:27+00:00",
"source_file": "quiz-app/README.md",
"language_code": "te"
}
-->
# క్విజ్‌లు
ఈ క్విజ్‌లు 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
## Azureకి డిప్లాయ్ చేయడం
మీరు ప్రారంభించడానికి సహాయపడే దశల వారీ గైడ్ ఇక్కడ ఉంది:
1. GitHub రిపాజిటరీని ఫోర్క్ చేయండి
మీ స్టాటిక్ వెబ్ యాప్ కోడ్ మీ GitHub రిపాజిటరీలో ఉందని నిర్ధారించుకోండి. ఈ రిపాజిటరీని ఫోర్క్ చేయండి.
2. Azure స్టాటిక్ వెబ్ యాప్ సృష్టించండి
- [Azure ఖాతా](http://azure.microsoft.com) సృష్టించండి
- [Azure పోర్టల్](https://portal.azure.com) కు వెళ్లండి
- "Create a resource" పై క్లిక్ చేసి "Static Web App" కోసం శోధించండి.
- "Create" పై క్లిక్ చేయండి.
3. స్టాటిక్ వెబ్ యాప్‌ను కాన్ఫిగర్ చేయండి
- ప్రాథమికాలు: సబ్‌స్క్రిప్షన్: మీ Azure సబ్‌స్క్రిప్షన్‌ను ఎంచుకోండి.
- రిసోర్స్ గ్రూప్: కొత్త రిసోర్స్ గ్రూప్ సృష్టించండి లేదా ఉన్నదాన్ని ఉపయోగించండి.
- పేరు: మీ స్టాటిక్ వెబ్ యాప్‌కు పేరు ఇవ్వండి.
- ప్రాంతం: మీ వినియోగదారులకు సమీప ప్రాంతాన్ని ఎంచుకోండి.
- #### డిప్లాయ్‌మెంట్ వివరాలు:
- మూలం: "GitHub" ఎంచుకోండి.
- GitHub ఖాతా: Azureకి మీ GitHub ఖాతాకు యాక్సెస్ అనుమతించండి.
- సంస్థ: మీ GitHub సంస్థను ఎంచుకోండి.
- రిపాజిటరీ: మీ స్టాటిక్ వెబ్ యాప్ ఉన్న రిపాజిటరీని ఎంచుకోండి.
- బ్రాంచ్: మీరు డిప్లాయ్ చేయదలచుకున్న బ్రాంచ్‌ను ఎంచుకోండి.
- #### బిల్డ్ వివరాలు:
- బిల్డ్ ప్రీసెట్‌లు: మీ యాప్ నిర్మించబడిన ఫ్రేమ్‌వర్క్‌ను ఎంచుకోండి (ఉదా: React, Angular, Vue, మొదలైనవి).
- యాప్ లొకేషన్: మీ యాప్ కోడ్ ఉన్న ఫోల్డర్‌ను పేర్కొనండి (ఉదా: / రూట్‌లో ఉంటే).
- API లొకేషన్: మీకు API ఉంటే, దాని స్థానం (ఐచ్ఛికం) పేర్కొనండి.
- అవుట్‌పుట్ లొకేషన్: బిల్డ్ అవుట్‌పుట్ ఉత్పత్తి అయ్యే ఫోల్డర్‌ను పేర్కొనండి (ఉదా: build లేదా dist).
4. సమీక్షించి సృష్టించండి
మీ సెట్టింగ్స్‌ను సమీక్షించి "Create" పై క్లిక్ చేయండి. Azure అవసరమైన వనరులను సెట్ చేసి మీ రిపాజిటరీలో GitHub Actions వర్క్‌ఫ్లోని సృష్టిస్తుంది.
5. GitHub Actions వర్క్‌ఫ్లో
Azure మీ రిపాజిటరీలో (.github/workflows/azure-static-web-apps-<name>.yml) GitHub Actions వర్క్‌ఫ్లో ఫైల్‌ను ఆటోమేటిక్‌గా సృష్టిస్తుంది. ఈ వర్క్‌ఫ్లో బిల్డ్ మరియు డిప్లాయ్‌మెంట్ ప్రక్రియను నిర్వహిస్తుంది.
6. డిప్లాయ్‌మెంట్‌ను మానిటర్ చేయండి
మీ GitHub రిపాజిటరీలో "Actions" ట్యాబ్‌కు వెళ్లండి.
ఒక వర్క్‌ఫ్లో నడుస్తున్నట్లు మీరు చూడగలరు. ఈ వర్క్‌ఫ్లో మీ స్టాటిక్ వెబ్ యాప్‌ను Azureకి బిల్డ్ చేసి డిప్లాయ్ చేస్తుంది.
వర్క్‌ఫ్లో పూర్తయిన తర్వాత, మీ యాప్ అందించిన Azure 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 డాక్యుమెంటేషన్](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [GitHub Actions డాక్యుమెంటేషన్](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 -->

335
translations/te/sketchnotes/LICENSE.md
Unescape View File

@ -0,0 +1,335 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
"translation_date": "2025-12-19T13:14:10+00:00",
"source_file": "sketchnotes/LICENSE.md",
"language_code": "te"
}
-->
అట్రిబ్యూషన్-షేర్ అలైక్ 4.0 ఇంటర్నేషనల్
=======================================================================
క్రియేటివ్ కామన్స్ కార్పొరేషన్ ("క్రియేటివ్ కామన్స్") ఒక చట్ట సంస్థ కాదు మరియు
చట్ట సేవలు లేదా చట్ట సలహాలు అందించదు. క్రియేటివ్ కామన్స్ పబ్లిక్ లైసెన్సుల పంపిణీ
ఒక న్యాయవాది-క్లయింట్ లేదా ఇతర సంబంధాన్ని సృష్టించదు. క్రియేటివ్ కామన్స్ తన లైసెన్సులు మరియు సంబంధిత
సమాచారాన్ని "అనుసంధానంగా" అందిస్తుంది. క్రియేటివ్ కామన్స్ తన లైసెన్సుల గురించి, వాటి
నియమాలు మరియు షరతుల క్రింద లైసెన్స్ పొందిన ఏదైనా పదార్థం లేదా సంబంధిత సమాచారంపై
ఏ వారంటీలు ఇవ్వదు. క్రియేటివ్ కామన్స్ వాటి ఉపయోగం వల్ల కలిగే నష్టాలకు
పూర్తి పరిమితి వరకు బాధ్యతను తిరస్కరిస్తుంది.
క్రియేటివ్ కామన్స్ పబ్లిక్ లైసెన్సులు ఉపయోగించడం
క్రియేటివ్ కామన్స్ పబ్లిక్ లైసెన్సులు సృష్టికర్తలు మరియు ఇతర హక్కుదారులు
మూల రచనల మరియు కాపీరైట్ మరియు క్రింది పబ్లిక్ లైసెన్స్‌లో పేర్కొన్న కొన్ని ఇతర హక్కులకు
అధీనమైన ఇతర పదార్థాలను పంచుకునేందుకు ఉపయోగించగల ఒక ప్రమాణిత నిబంధనలు మరియు
షరతుల సెట్‌ను అందిస్తాయి. క్రింది పరిగణనలు సమాచార ప్రయోజనాలకే, అవి
సంపూర్ణంగా లేవు మరియు మా లైసెన్సుల భాగం కావు.
లైసెన్సుదారులకు పరిగణనలు: మా పబ్లిక్ లైసెన్సులు
కాపీరైట్ మరియు కొన్ని ఇతర హక్కుల ద్వారా పరిమితం చేయబడిన
పదార్థాన్ని ప్రజలకు ఉపయోగించడానికి అనుమతి ఇవ్వడానికి
అధికారం ఉన్నవారికి ఉపయోగించడానికి ఉద్దేశించబడ్డాయి.
మా లైసెన్సులు తిరస్కరించలేనివి. లైసెన్సుదారులు
తమకు కావలసిన లైసెన్సును వర్తింపజేసే ముందు దాని నిబంధనలు
మరియు షరతులను చదవాలి మరియు అర్థం చేసుకోవాలి.
లైసెన్సుదారులు ప్రజలు పదార్థాన్ని ఆశించినట్లుగా పునఃఉపయోగించగలిగేలా
అవసరమైన అన్ని హక్కులను పొందాలి. లైసెన్సు వర్తించని
పదార్థాన్ని స్పష్టంగా గుర్తించాలి. ఇందులో ఇతర CC-లైసెన్స్ పొందిన
పదార్థం లేదా కాపీరైట్‌కు మినహాయింపు లేదా పరిమితి క్రింద ఉపయోగించిన
పదార్థం కూడా ఉంటుంది. మరిన్ని పరిగణనలు:
wiki.creativecommons.org/Considerations_for_licensors
ప్రజలకు పరిగణనలు: మా పబ్లిక్ లైసెన్సులలో ఒకదాన్ని ఉపయోగించడం ద్వారా,
లైసెన్సుదారు ప్రజలకు నిర్దిష్ట నిబంధనలు మరియు షరతుల క్రింద
లైసెన్స్ పొందిన పదార్థాన్ని ఉపయోగించడానికి అనుమతి ఇస్తారు.
లైసెన్సుదారు అనుమతి అవసరం లేకపోతే—for example, ఏదైనా వర్తించే
మినహాయింపు లేదా పరిమితి కారణంగా—ఆ ఉపయోగం లైసెన్సు ద్వారా నియంత్రించబడదు.
మా లైసెన్సులు కాపీరైట్ మరియు కొన్ని ఇతర హక్కుల క్రింద మాత్రమే అనుమతులు ఇస్తాయి,
లైసెన్సుదారు అనుమతించగలిగే హక్కులు. పదార్థం ఉపయోగం ఇంకా ఇతర కారణాల వల్ల
పరిమితం కావచ్చు, ఉదాహరణకు ఇతరులకు ఆ పదార్థంపై కాపీరైట్ లేదా ఇతర హక్కులు
ఉన్నందున. లైసెన్సుదారు ప్రత్యేక అభ్యర్థనలు చేయవచ్చు, ఉదాహరణకు అన్ని మార్పులను
గుర్తించమని లేదా వివరించమని అడగవచ్చు. మా లైసెన్సులు అవసరం చేయకపోయినా,
మీరు ఆ అభ్యర్థనలను తగినంతగా గౌరవించమని ప్రోత్సహించబడతారు. మరిన్ని పరిగణనలు:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
క్రియేటివ్ కామన్స్ అట్రిబ్యూషన్-షేర్ అలైక్ 4.0 ఇంటర్నేషనల్ పబ్లిక్ లైసెన్స్
లైసెన్స్ పొందిన హక్కులను (క్రింద నిర్వచించబడిన) ఉపయోగించడం ద్వారా, మీరు ఈ క్రియేటివ్ కామన్స్
అట్రిబ్యూషన్-షేర్ అలైక్ 4.0 ఇంటర్నేషనల్ పబ్లిక్ లైసెన్స్ ("పబ్లిక్ లైసెన్స్") యొక్క
నిబంధనలు మరియు షరతులకు బద్ధబాధ్యతగా అంగీకరిస్తారు. ఈ పబ్లిక్ లైసెన్స్ ఒక ఒప్పందంగా
వివచించబడితే, మీరు ఈ నిబంధనలు అంగీకరించడం కోసం లైసెన్స్ పొందిన హక్కులను పొందుతారు,
మరియు లైసెన్సుదారు ఈ నిబంధనల క్రింద లైసెన్స్ పొందిన పదార్థాన్ని అందించడం ద్వారా లాభాలు పొందుతారు.
విభాగం 1 -- నిర్వచనాలు.
a. అనుకూలీకరించిన పదార్థం అంటే కాపీరైట్ మరియు సమాన హక్కులకు లోబడి,
లైసెన్స్ పొందిన పదార్థం నుండి ఉత్పన్నమై లేదా ఆధారంగా ఉండి,
లైసెన్స్ పొందిన పదార్థం అనువదించబడిన, మార్చబడిన,
అమర్చబడిన, మార్చబడిన లేదా ఇతర విధంగా కాపీరైట్ మరియు సమాన హక్కుల
క్రింద అనుమతి అవసరమయ్యే విధంగా మార్పులు చేయబడిన పదార్థం.
ఈ పబ్లిక్ లైసెన్స్ ప్రయోజనాల కోసం, లైసెన్స్ పొందిన పదార్థం
సంగీత కృతి, ప్రదర్శన లేదా శబ్ద రికార్డింగ్ అయితే,
అనుకూలీకరించిన పదార్థం ఎప్పుడూ లైసెన్స్ పొందిన పదార్థం
ఒక కదిలే చిత్రంతో సమయ సంబంధంలో సింక్ చేయబడినప్పుడు ఉత్పత్తి అవుతుంది.
b. అనుకూలీకర్త యొక్క లైసెన్స్ అంటే మీరు ఈ పబ్లిక్ లైసెన్స్ నిబంధనలు మరియు షరతుల ప్రకారం
అనుకూలీకరించిన పదార్థంలో మీ కాపీరైట్ మరియు సమాన హక్కులకు వర్తింపజేసే లైసెన్స్.
c. BY-SA అనుకూల లైసెన్స్ అంటే creativecommons.org/compatiblelicenses వద్ద జాబితా చేయబడిన,
క్రియేటివ్ కామన్స్ ఈ పబ్లిక్ లైసెన్స్‌కు సమానమైనదిగా ఆమోదించిన లైసెన్స్.
d. కాపీరైట్ మరియు సమాన హక్కులు అంటే కాపీరైట్ మరియు/లేదా కాపీరైట్‌కు సమీపంగా ఉన్న హక్కులు,
పరిమితి లేకుండా, ప్రదర్శన, ప్రసారం, శబ్ద రికార్డింగ్, మరియు Sui Generis డేటాబేస్ హక్కులు,
హక్కులను ఎలా లేబుల్ చేయబడిందో లేదా వర్గీకరించబడిందో సంబంధం లేకుండా.
ఈ పబ్లిక్ లైసెన్స్ ప్రయోజనాల కోసం, విభాగం 2(b)(1)-(2)లో పేర్కొన్న హక్కులు
కాపీరైట్ మరియు సమాన హక్కులు కాదు.
e. సమర్థవంతమైన సాంకేతిక చర్యలు అంటే సరైన అధికారం లేకుండా
తిరస్కరించలేని చర్యలు, 1996 డిసెంబర్ 20న ఆమోదించబడిన WIPO కాపీరైట్
ఒప్పందం ఆర్టికల్ 11 క్రింద లేదా సమాన అంతర్జాతీయ ఒప్పందాల క్రింద
నిబంధనలు నెరవేర్చే చట్టాల ప్రకారం.
f. మినహాయింపులు మరియు పరిమితులు అంటే న్యాయసమ్మత ఉపయోగం, న్యాయసమ్మత వ్యవహారం,
మరియు/లేదా కాపీరైట్ మరియు సమాన హక్కులకు సంబంధించిన మీ లైసెన్స్ పొందిన పదార్థం
ఉపయోగానికి వర్తించే ఏ ఇతర మినహాయింపు లేదా పరిమితి.
g. లైసెన్స్ అంశాలు అంటే క్రియేటివ్ కామన్స్ పబ్లిక్ లైసెన్స్ పేరులో పేర్కొన్న లైసెన్స్ లక్షణాలు.
ఈ పబ్లిక్ లైసెన్స్ యొక్క లైసెన్స్ అంశాలు అట్రిబ్యూషన్ మరియు షేర్ అలైక్.
h. లైసెన్స్ పొందిన పదార్థం అంటే కళాత్మక లేదా సాహిత్య కృతి, డేటాబేస్,
లేదా లైసెన్సుదారు ఈ పబ్లిక్ లైసెన్స్ వర్తింపజేసిన ఇతర పదార్థం.
i. లైసెన్స్ పొందిన హక్కులు అంటే ఈ పబ్లిక్ లైసెన్స్ నిబంధనలు మరియు షరతుల క్రింద
మీకు ఇచ్చిన హక్కులు, ఇవి మీ లైసెన్స్ పొందిన పదార్థం ఉపయోగానికి వర్తించే
అన్ని కాపీరైట్ మరియు సమాన హక్కులకు పరిమితం మరియు లైసెన్సుదారుకు లైసెన్స్ ఇవ్వడానికి
అధికారం ఉన్నవి.
j. లైసెన్సుదారు అంటే ఈ పబ్లిక్ లైసెన్స్ క్రింద హక్కులు ఇస్తున్న వ్యక్తి(లు) లేదా సంస్థ(లు).
k. పంచుకోవడం అంటే లైసెన్స్ పొందిన హక్కుల క్రింద అనుమతి అవసరమయ్యే ఏ విధానమో
లేదా ప్రక్రియతో ప్రజలకు పదార్థాన్ని అందించడం, ఉదాహరణకు పునఃఉత్పత్తి,
ప్రజా ప్రదర్శన, ప్రజా ప్రదర్శన, పంపిణీ, వ్యాప్తి, కమ్యూనికేషన్, లేదా దిగుమతి,
మరియు ప్రజలకు పదార్థాన్ని అందించడం, అందులో ప్రజలు తమకు ఇష్టమైన స్థలం మరియు
సమయానికి పదార్థాన్ని యాక్సెస్ చేసుకునే విధానాలు కూడా ఉన్నాయి.
l. Sui Generis డేటాబేస్ హక్కులు అంటే 1996 మార్చి 11న యూరోపియన్ పార్లమెంట్ మరియు
కౌన్సిల్ యొక్క డైరెక్టివ్ 96/9/EC ప్రకారం డేటాబేసుల చట్టపరమైన రక్షణపై
హక్కులు, మార్పులు లేదా వారసత్వం పొందినవి, అలాగే ప్రపంచంలో ఎక్కడైనా
సమానమైన హక్కులు.
m. మీరు అంటే ఈ పబ్లిక్ లైసెన్స్ క్రింద లైసెన్స్ పొందిన హక్కులను ఉపయోగిస్తున్న వ్యక్తి లేదా సంస్థ.
మీకు అనుగుణంగా అర్థం ఉంటుంది.
విభాగం 2 -- పరిధి.
a. లైసెన్స్ మంజూరు.
1. ఈ పబ్లిక్ లైసెన్స్ నిబంధనలు మరియు షరతులకు అనుగుణంగా,
లైసెన్సుదారు మీకు ప్రపంచవ్యాప్తంగా, రాయితీ రహిత,
ఉపలైసెన్స్ ఇవ్వలేని, ప్రత్యేక హక్కులు లేని, తిరస్కరించలేని
లైసెన్స్ ఇస్తారు, లైసెన్స్ పొందిన పదార్థంలో లైసెన్స్ పొందిన హక్కులను
ఉపయోగించడానికి:
a. లైసెన్స్ పొందిన పదార్థాన్ని, మొత్తం లేదా భాగంగా,
పునఃఉత్పత్తి చేయడం మరియు పంచుకోవడం; మరియు
b. అనుకూలీకరించిన పదార్థాన్ని ఉత్పత్తి చేయడం, పునఃఉత్పత్తి చేయడం,
మరియు పంచుకోవడం.
2. మినహాయింపులు మరియు పరిమితులు. మీ ఉపయోగానికి మినహాయింపులు మరియు పరిమితులు వర్తిస్తే,
ఈ పబ్లిక్ లైసెన్స్ వర్తించదు, మరియు మీరు దాని నిబంధనలు మరియు షరతులను
పాటించాల్సిన అవసరం లేదు.
3. కాలం. ఈ పబ్లిక్ లైసెన్స్ యొక్క కాలం విభాగం 6(a)లో పేర్కొనబడింది.
4. మీడియా మరియు ఫార్మాట్లు; సాంకేతిక మార్పులు అనుమతించబడతాయి. లైసెన్సుదారు
మీరు లైసెన్స్ పొందిన హక్కులను అన్ని మీడియా మరియు ఫార్మాట్లలో ఉపయోగించడానికి
అనుమతిస్తారు, ఇప్పటి వరకు తెలిసిన లేదా భవిష్యత్తులో సృష్టించబడే,
మరియు అలా చేయడానికి అవసరమైన సాంకేతిక మార్పులు చేయడానికి అనుమతిస్తారు.
లైసెన్సుదారు మీరు లైసెన్స్ పొందిన హక్కులను ఉపయోగించడానికి అవసరమైన
సాంకేతిక మార్పులు చేయడాన్ని నిషేధించడానికి లేదా హక్కు లేదా అధికారం
వాదించకూడదని ఒప్పుకుంటారు. ఈ పబ్లిక్ లైసెన్స్ ప్రయోజనాల కోసం,
ఈ విభాగం 2(a)(4)లో అనుమతించిన మార్పులు చేయడం అనుకూలీకరించిన పదార్థం
ఉత్పత్తి చేయదు.
5. దిగువన ఉన్న గ్రహీతలు.
a. లైసెన్సుదారుని నుండి ఆఫర్ -- లైసెన్స్ పొందిన పదార్థం. లైసెన్స్ పొందిన
పదార్థం ప్రతి గ్రహీతకు ఆటోమేటిక్‌గా లైసెన్సుదారుని నుండి ఈ పబ్లిక్
లైసెన్స్ నిబంధనలు మరియు షరతుల క్రింద లైసెన్స్ పొందిన హక్కులను
ఉపయోగించడానికి ఆఫర్ అందుతుంది.
b. లైసెన్సుదారుని నుండి అదనపు ఆఫర్ -- అనుకూలీకరించిన పదార్థం.
మీరు అందించిన అనుకూలీకరించిన పదార్థం ప్రతి గ్రహీతకు
మీరు వర్తింపజేసే అనుకూలీకర్త యొక్క లైసెన్స్ నిబంధనల క్రింద
లైసెన్స్ పొందిన హక్కులను ఉపయోగించడానికి లైసెన్సుదారుని నుండి
ఆటోమేటిక్ ఆఫర్ అందుతుంది.
c. దిగువన ఉన్న పరిమితులు లేవు. మీరు లైసెన్స్ పొందిన పదార్థంపై
ఎలాంటి అదనపు లేదా వేరే నిబంధనలు లేదా షరతులు ఆఫర్ చేయకూడదు
లేదా అమలు చేయకూడదు, లేదా ఎలాంటి సమర్థవంతమైన సాంకేతిక చర్యలు
వర్తింపజేయకూడదు, ఇవి లైసెన్స్ పొందిన పదార్థం గ్రహీతల హక్కుల
వినియోగాన్ని పరిమితం చేస్తే.
6. ఎటువంటి మద్దతు లేదు. ఈ పబ్లిక్ లైసెన్స్‌లో ఏదీ మీరు లైసెన్స్ పొందిన
పదార్థం ఉపయోగం లైసెన్సుదారు లేదా ఇతరులు అట్రిబ్యూషన్ పొందడానికి
నియమించబడిన వారు ద్వారా మద్దతు పొందినట్లు లేదా అధికారిక స్థితి పొందినట్లు
సూచించడానికి అనుమతి ఇవ్వదు లేదా అర్థం చేసుకోబడదు.
b. ఇతర హక్కులు.
1. నైతిక హక్కులు, ఉదాహరణకు సమగ్రత హక్కు, ఈ పబ్లిక్ లైసెన్స్ క్రింద లైసెన్స్
చేయబడవు, అలాగే ప్రజాప్రతిష్ట, గోప్యత మరియు/లేదా ఇతర సమాన వ్యక్తిత్వ హక్కులు;
అయితే, సాధ్యమైనంతవరకు, లైసెన్సుదారు ఈ హక్కులను వదిలివేస్తారు లేదా
మీరు లైసెన్స్ పొందిన హక్కులను ఉపయోగించడానికి అవసరమైన పరిమితి వరకు
ఈ హక్కులను వాదించకూడదని ఒప్పుకుంటారు, కానీ ఇతర విధంగా కాదు.
2. పేటెంట్ మరియు ట్రేడ్‌మార్క్ హక్కులు ఈ పబ్లిక్ లైసెన్స్ క్రింద లైసెన్స్ చేయబడవు.
3. సాధ్యమైనంతవరకు, లైసెన్సుదారు మీరు లైసెన్స్ పొందిన హక్కులను ఉపయోగించడానికి
రాయితీలు సేకరించే హక్కును వదిలివేస్తారు, ప్రత్యక్షంగా లేదా ఏదైనా
స్వచ్ఛంద లేదా వదిలివేయదగిన చట్టబద్ధ లేదా బలవంతపు లైసెన్సింగ్ పథకం
ద్వారా సేకరించే హక్కు. ఇతర అన్ని సందర్భాలలో లైసెన్సుదారు
అటువంటి రాయితీలను సేకరించే హక్కును స్పష్టంగా రిజర్వ్ చేస్తారు.
విభాగం 3 -- లైసెన్స్ షరతులు.
మీరు లైసెన్స్ పొందిన హక్కులను ఉపయోగించడం కింద పేర్కొన్న షరతులకు స్పష్టంగా
బద్ధబాధ్యతగా ఉంటుంది.
a. అట్రిబ్యూషన్.
1. మీరు లైసెన్స్ పొందిన పదార్థాన్ని పంచుకుంటే (మార్పు రూపంలో కూడా),
మీరు:
a. లైసెన్సుదారు లైసెన్స్ పొందిన పదార్థంతో అందించిన
క్రింది విషయాలను నిలుపుకోవాలి:
i. లైసెన్స్ పొందిన పదార్థం సృష్టికర్త(లు) మరియు అట్రిబ్యూషన్ పొందడానికి
నియమించబడిన ఇతరుల గుర్తింపు, లైసెన్సుదారు కోరిన ఏదైనా
తగిన విధానంలో (పseudonym ద్వారా కూడా);
ii. కాపీరైట్ నోటీసు;
iii. ఈ పబ్లిక్ లైసెన్స్‌కు సూచించే నోటీసు;
iv. వారంటీల నిరాకరణకు సూచించే నోటీసు;
v. లైసెన్స్ పొందిన పదార్థానికి URI లేదా హైపర్‌లింక్, సాధ్యమైనంతవరకు;
b. మీరు లైసెన్స్ పొందిన పదార్థాన్ని మార్చినట్లయితే సూచించాలి మరియు
గత మార్పుల సూచనను నిలుపుకోవాలి; మరియు
c. లైసెన్స్ పొందిన పదార్థం ఈ పబ్లిక్ లైసెన్స్ క్రింద లైసెన్స్ పొందినదని
సూచించాలి, మరియు ఈ పబ్లిక్ లైసెన్స్ యొక్క పాఠ్యం లేదా URI లేదా
హైపర్‌లింక్‌ను చేర్చాలి.
2. మీరు సెక్షన్ 3(a)(1)లోని షరతులను మీరు లైసెన్స్ పొందిన పదార్థాన్ని
పంచే మీడియం, మార్గం మరియు సందర్భం ఆధారంగా ఏదైనా తగిన విధానంలో
తీర్చవచ్చు. ఉదాహరణకు, అవసరమైన సమాచారాన్ని కలిగిన వనరుకు URI లేదా
హైపర్‌లింక్ ఇవ్వడం తగినది కావచ్చు.
3. లైసెన్సుదారు కోరినట్లయితే, మీరు సెక్షన్ 3(a)(1)(A)లో అవసరమైన
సమాచారాన్ని సాధ్యమైనంతవరకు తొలగించాలి.
b. షేర్ అలైక్.
సెక్షన్ 3(a)లోని షరతులకు అదనంగా, మీరు ఉత్పత్తి చేసిన అనుకూలీకరించిన
పదార్థాన్ని పంచుకుంటే, క్రింది షరతులు కూడా వర్తిస్తాయి.
1. మీరు వర్తింపజేసే అనుకూలీకర్త యొక్క లైసెన్స్ క్రియేటివ్ కామన్స్
లైసెన్స్ అయి ఉండాలి, అదే లైసెన్స్ అంశాలతో, ఈ సంచిక లేదా తరువాతి,
లేదా BY-SA అనుకూల లైసెన్స్.
2. మీరు వర్తింపజేసే అనుకూలీకర్త యొక్క లైసెన్స్ యొక్క పాఠ్యం లేదా URI
లేదా హైపర్‌లింక్‌ను చేర్చాలి. మీరు అనుకూలీకరించిన పదార్థాన్ని పంచే
మీడియం, మార్గం మరియు సందర్భం ఆధారంగా ఈ షరతును తీర్చవచ్చు.
3. మీరు అనుకూలీకర్త యొక్క లైసెన్స్ క్రింద ఇచ్చిన హక్కుల వినియోగాన్ని
పరిమితం చేసే ఏ అదనపు లేదా వేరే నిబంధనలు లేదా షరతులు ఆఫర్ చేయకూడదు
లేదా అమలు చేయకూడదు, లేదా ఎలాంటి సమర్థవంతమైన సాంకేతిక చర్యలు
అనుకూలీకరించిన పదార్థంపై వర్తింపజేయకూడదు.
విభాగం 4 -- Sui Generis డేటాబేస్ హక్కులు.
లైసెన్స్ పొందిన హక్కులు Sui Generis డేటాబేస్ హక్కులను కలిగి ఉంటే,
మీ లైసెన్స్ పొందిన పదార్థం ఉపయోగానికి వర్తించే:
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 వద్ద ప్రచురించిన క్రియేటివ్ కామన్స్ విధానాల ప్రకారం అనుమతించబడిన విధంగా కాకుండా, క్రియేటివ్ కామన్స్ "Creative Commons" ట్రేడ్‌మార్క్ లేదా ఇతర ట్రేడ్‌మార్క్ లేదా లోగోలను ముందస్తు రాత అనుమతి లేకుండా ఉపయోగించడానికి అనుమతించదు, పరిమితి లేకుండా, దాని పబ్లిక్ లైసెన్స్‌లలో అనధికార మార్పులు లేదా ఇతర ఏర్పాట్లు, అర్థాలు లేదా ఒప్పందాల కోసం. సందేహ నివారణ కోసం, ఈ పేరాగ్రాఫ్ పబ్లిక్ లైసెన్స్‌ల భాగం కాదు.
క్రియేటివ్ కామన్స్ ను 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/te/sketchnotes/README.md
Unescape View File

@ -0,0 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a88d5918c1b9da69a40d917a0840c497",
"translation_date": "2025-12-19T13:12:09+00:00",
"source_file": "sketchnotes/README.md",
"language_code": "te"
}
-->
అన్ని పాఠ్యాంశాల స్కెచ్‌నోట్లు ఇక్కడ డౌన్లోడ్ చేసుకోవచ్చు.
🖨 హై-రెసల్యూషన్‌లో ప్రింటింగ్ కోసం, 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 -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Write Preview
Loading…
Cancel
Save