You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
256 lines
32 KiB
256 lines
32 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "911efd5e595089000cb3c16fce1beab8",
|
|
"translation_date": "2025-09-05T10:29:57+00:00",
|
|
"source_file": "8-Reinforcement/1-QLearning/README.md",
|
|
"language_code": "hi"
|
|
}
|
|
-->
|
|
# परिचय: रिइंफोर्समेंट लर्निंग और Q-लर्निंग
|
|
|
|
|
|
> स्केच नोट: [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
|
|
|
रिइंफोर्समेंट लर्निंग तीन महत्वपूर्ण अवधारणाओं पर आधारित है: एजेंट, कुछ स्टेट्स, और प्रत्येक स्टेट के लिए एक्शन का सेट। किसी निर्दिष्ट स्टेट में एक्शन को निष्पादित करके, एजेंट को एक इनाम दिया जाता है। फिर से सुपर मारियो गेम की कल्पना करें। आप मारियो हैं, आप एक गेम लेवल में हैं, और एक चट्टान के किनारे पर खड़े हैं। आपके ऊपर एक सिक्का है। आप मारियो हैं, एक गेम लेवल में, एक विशिष्ट स्थिति में ... यही आपका स्टेट है। दाईं ओर एक कदम बढ़ाना (एक्शन) आपको किनारे से नीचे गिरा देगा, और यह आपको कम अंक देगा। हालांकि, जंप बटन दबाने से आप एक पॉइंट स्कोर करेंगे और जीवित रहेंगे। यह एक सकारात्मक परिणाम है और आपको एक सकारात्मक अंक प्रदान करना चाहिए।
|
|
|
|
रिइंफोर्समेंट लर्निंग और एक सिम्युलेटर (गेम) का उपयोग करके, आप गेम खेलने का तरीका सीख सकते हैं ताकि आप जीवित रह सकें और अधिकतम पॉइंट्स स्कोर कर सकें।
|
|
|
|
[](https://www.youtube.com/watch?v=lDq_en8RNOo)
|
|
|
|
> 🎥 ऊपर दी गई छवि पर क्लिक करें और Dmitry से रिइंफोर्समेंट लर्निंग के बारे में सुनें
|
|
|
|
## [प्री-लेक्चर क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## आवश्यकताएँ और सेटअप
|
|
|
|
इस पाठ में, हम Python में कुछ कोड के साथ प्रयोग करेंगे। आपको इस पाठ के Jupyter Notebook कोड को अपने कंप्यूटर पर या क्लाउड में कहीं भी चलाने में सक्षम होना चाहिए।
|
|
|
|
आप [पाठ नोटबुक](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) फ़ाइल भी प्राप्त करनी होगी, जो नोटबुक कोड में उपयोग की जाती है। इसे नोटबुक के समान डायरेक्टरी में जोड़ें।
|
|
|
|
## परिचय
|
|
|
|
इस पाठ में, हम **[Peter and the Wolf](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)** की दुनिया का अन्वेषण करेंगे, जो एक रूसी संगीतकार [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev) की एक संगीत परी कथा से प्रेरित है। हम **रिइंफोर्समेंट लर्निंग** का उपयोग करेंगे ताकि पीटर अपने वातावरण का पता लगा सके, स्वादिष्ट सेब इकट्ठा कर सके और भेड़िये से बच सके।
|
|
|
|
**रिइंफोर्समेंट लर्निंग** (RL) एक लर्निंग तकनीक है जो हमें कई प्रयोगों को चलाकर किसी **एजेंट** के **वातावरण** में इष्टतम व्यवहार सीखने की अनुमति देती है। इस वातावरण में एक एजेंट का कुछ **लक्ष्य** होना चाहिए, जिसे एक **इनाम फ़ंक्शन** द्वारा परिभाषित किया गया है।
|
|
|
|
## वातावरण
|
|
|
|
सरलता के लिए, आइए पीटर की दुनिया को `width` x `height` आकार के एक वर्ग बोर्ड के रूप में मानें, जैसे:
|
|
|
|
|
|
|
|
इस बोर्ड में प्रत्येक सेल निम्नलिखित में से एक हो सकता है:
|
|
|
|
* **जमीन**, जिस पर पीटर और अन्य जीव चल सकते हैं।
|
|
* **पानी**, जिस पर आप स्पष्ट रूप से नहीं चल सकते।
|
|
* एक **पेड़** या **घास**, एक जगह जहां आप आराम कर सकते हैं।
|
|
* एक **सेब**, जिसे पीटर खुशी से खोजेगा ताकि वह खुद को खिला सके।
|
|
* एक **भेड़िया**, जो खतरनाक है और इससे बचा जाना चाहिए।
|
|
|
|
एक अलग Python मॉड्यूल, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), इस वातावरण के साथ काम करने के लिए कोड को शामिल करता है। चूंकि यह कोड हमारे अवधारणाओं को समझने के लिए महत्वपूर्ण नहीं है, हम मॉड्यूल को आयात करेंगे और नमूना बोर्ड बनाने के लिए इसका उपयोग करेंगे (कोड ब्लॉक 1):
|
|
|
|
```python
|
|
from rlboard import *
|
|
|
|
width, height = 8,8
|
|
m = Board(width,height)
|
|
m.randomize(seed=13)
|
|
m.plot()
|
|
```
|
|
|
|
यह कोड ऊपर दिए गए चित्र के समान वातावरण का चित्र प्रिंट करेगा।
|
|
|
|
## एक्शन और पॉलिसी
|
|
|
|
हमारे उदाहरण में, पीटर का लक्ष्य सेब को खोजना होगा, जबकि भेड़िये और अन्य बाधाओं से बचना होगा। ऐसा करने के लिए, वह सेब को खोजने तक इधर-उधर चल सकता है।
|
|
|
|
इसलिए, किसी भी स्थिति में, वह निम्नलिखित एक्शन में से एक चुन सकता है: ऊपर, नीचे, बाएं और दाएं।
|
|
|
|
हम इन एक्शन को एक डिक्शनरी के रूप में परिभाषित करेंगे, और उन्हें संबंधित समन्वय परिवर्तनों के जोड़े से मैप करेंगे। उदाहरण के लिए, दाईं ओर बढ़ना (`R`) एक जोड़ी `(1,0)` के अनुरूप होगा। (कोड ब्लॉक 2):
|
|
|
|
```python
|
|
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
|
|
action_idx = { a : i for i,a in enumerate(actions.keys()) }
|
|
```
|
|
|
|
इस परिदृश्य की रणनीति और लक्ष्य को संक्षेप में कहें:
|
|
|
|
- **रणनीति**, हमारे एजेंट (पीटर) की, एक तथाकथित **पॉलिसी** द्वारा परिभाषित की जाती है। पॉलिसी एक फ़ंक्शन है जो किसी भी दिए गए स्टेट पर एक्शन लौटाता है। हमारे मामले में, समस्या का स्टेट बोर्ड द्वारा दर्शाया गया है, जिसमें खिलाड़ी की वर्तमान स्थिति शामिल है।
|
|
|
|
- **लक्ष्य**, रिइंफोर्समेंट लर्निंग का, अंततः एक अच्छी पॉलिसी सीखना है जो हमें समस्या को कुशलतापूर्वक हल करने की अनुमति देगा। हालांकि, एक आधार रेखा के रूप में, आइए सबसे सरल पॉलिसी पर विचार करें जिसे **रैंडम वॉक** कहा जाता है।
|
|
|
|
## रैंडम वॉक
|
|
|
|
आइए पहले रैंडम वॉक रणनीति को लागू करके अपनी समस्या को हल करें। रैंडम वॉक के साथ, हम अनुमत एक्शन में से अगले एक्शन को यादृच्छिक रूप से चुनेंगे, जब तक कि हम सेब तक नहीं पहुंच जाते (कोड ब्लॉक 3)।
|
|
|
|
1. नीचे दिए गए कोड के साथ रैंडम वॉक लागू करें:
|
|
|
|
```python
|
|
def random_policy(m):
|
|
return random.choice(list(actions))
|
|
|
|
def walk(m,policy,start_position=None):
|
|
n = 0 # number of steps
|
|
# set initial position
|
|
if start_position:
|
|
m.human = start_position
|
|
else:
|
|
m.random_start()
|
|
while True:
|
|
if m.at() == Board.Cell.apple:
|
|
return n # success!
|
|
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
|
|
return -1 # eaten by wolf or drowned
|
|
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) # do the actual move
|
|
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 कदम है।
|
|
|
|
आप यह भी देख सकते हैं कि रैंडम वॉक के दौरान पीटर की गति कैसी दिखती है:
|
|
|
|
|
|
|
|
## इनाम फ़ंक्शन
|
|
|
|
हमारी पॉलिसी को अधिक बुद्धिमान बनाने के लिए, हमें यह समझने की आवश्यकता है कि कौन से कदम दूसरों की तुलना में "बेहतर" हैं। ऐसा करने के लिए, हमें अपना लक्ष्य परिभाषित करना होगा।
|
|
|
|
लक्ष्य को एक **इनाम फ़ंक्शन** के संदर्भ में परिभाषित किया जा सकता है, जो प्रत्येक स्टेट के लिए कुछ स्कोर मान लौटाएगा। संख्या जितनी अधिक होगी, इनाम फ़ंक्शन उतना ही बेहतर होगा। (कोड ब्लॉक 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-लर्निंग** कहा जाता है। इस एल्गोरिदम में, पॉलिसी को एक फ़ंक्शन (या डेटा संरचना) द्वारा परिभाषित किया जाता है जिसे **Q-टेबल** कहा जाता है। यह प्रत्येक स्टेट में दिए गए एक्शन की "अच्छाई" को रिकॉर्ड करता है।
|
|
|
|
इसे Q-टेबल कहा जाता है क्योंकि इसे अक्सर एक टेबल या बहु-आयामी ऐरे के रूप में प्रस्तुत करना सुविधाजनक होता है। चूंकि हमारे बोर्ड का आयाम `width` x `height` है, हम Q-टेबल को `width` x `height` x `len(actions)` आकार के साथ एक numpy ऐरे का उपयोग करके प्रस्तुत कर सकते हैं: (कोड ब्लॉक 6)
|
|
|
|
```python
|
|
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
|
|
```
|
|
|
|
ध्यान दें कि हम Q-टेबल के सभी मानों को समान मान के साथ प्रारंभ करते हैं, हमारे मामले में - 0.25। यह "रैंडम वॉक" पॉलिसी के अनुरूप है, क्योंकि प्रत्येक स्टेट में सभी कदम समान रूप से अच्छे हैं। हम बोर्ड पर टेबल को विज़ुअलाइज़ करने के लिए Q-टेबल को `plot` फ़ंक्शन में पास कर सकते हैं: `m.plot(Q)`।
|
|
|
|
|
|
|
|
प्रत्येक सेल के केंद्र में एक "तीर" होता है जो गति की पसंदीदा दिशा को इंगित करता है। चूंकि सभी दिशाएँ समान हैं, एक बिंदु प्रदर्शित होता है।
|
|
|
|
अब हमें सिमुलेशन चलाने, अपने वातावरण का पता लगाने, और Q-टेबल मानों के बेहतर वितरण को सीखने की आवश्यकता है, जो हमें सेब तक पहुंचने का रास्ता बहुत तेज़ी से खोजने की अनुमति देगा।
|
|
|
|
## Q-लर्निंग का सार: बेलमैन समीकरण
|
|
|
|
एक बार जब हम चलना शुरू करते हैं, तो प्रत्येक एक्शन का एक संबंधित इनाम होगा, यानी हम सैद्धांतिक रूप से उच्चतम तत्काल इनाम के आधार पर अगले एक्शन का चयन कर सकते हैं। हालांकि, अधिकांश स्टेट्स में, यह कदम हमारे लक्ष्य को प्राप्त नहीं करेगा, और इसलिए हम तुरंत यह तय नहीं कर सकते कि कौन सी दिशा बेहतर है।
|
|
|
|
> याद रखें कि तत्काल परिणाम महत्वपूर्ण नहीं है, बल्कि अंतिम परिणाम है, जिसे हम सिमुलेशन के अंत में प्राप्त करेंगे।
|
|
|
|
इस विलंबित इनाम को ध्यान में रखने के लिए, हमें **[डायनामिक प्रोग्रामिंग](https://en.wikipedia.org/wiki/Dynamic_programming)** के सिद्धांतों का उपयोग करने की आवश्यकता है, जो हमें अपनी समस्या के बारे में पुनरावर्ती रूप से सोचने की अनुमति देते हैं।
|
|
|
|
मान लें कि हम अब स्टेट *s* पर हैं, और हम अगले स्टेट *s'* पर जाना चाहते हैं। ऐसा करने से, हमें तत्काल इनाम *r(s,a)* प्राप्त होगा, जिसे इनाम फ़ंक्शन द्वारा परिभाषित किया गया है, साथ ही कुछ भविष्य का इनाम भी। यदि हम मान लें कि हमारा Q-टेबल प्रत्येक एक्शन की "आकर्षकता" को सही ढंग से दर्शाता है, तो स्टेट *s'* पर हम एक्शन *a'* चुनेंगे जो *Q(s',a')* के अधिकतम मान के अनुरूप होगा। इस प्रकार, स्टेट *s* पर हमें मिलने वाला सबसे अच्छा संभावित भविष्य का इनाम `max`
|
|
|
|
## नीति की जांच करना
|
|
|
|
चूंकि Q-Table प्रत्येक स्थिति में प्रत्येक क्रिया की "आकर्षकता" को सूचीबद्ध करता है, इसे हमारे संसार में कुशल नेविगेशन को परिभाषित करने के लिए उपयोग करना काफी आसान है। सबसे सरल मामले में, हम उस क्रिया का चयन कर सकते हैं जो Q-Table में सबसे उच्च मान से मेल खाती है: (कोड ब्लॉक 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-Value के संदर्भ में, जिससे एजेंट उन अवस्थाओं के बीच अनिश्चितकाल तक घूमता रहता है।
|
|
|
|
## 🚀चुनौती
|
|
|
|
> **कार्य 1:** `walk` फ़ंक्शन को संशोधित करें ताकि पथ की अधिकतम लंबाई को एक निश्चित संख्या (जैसे, 100) तक सीमित किया जा सके, और ऊपर दिया गया कोड समय-समय पर इस मान को लौटाए।
|
|
|
|
> **कार्य 2:** `walk` फ़ंक्शन को संशोधित करें ताकि वह उन स्थानों पर वापस न जाए जहाँ वह पहले ही जा चुका है। यह `walk` को लूपिंग से रोक देगा, लेकिन एजेंट अभी भी ऐसी जगह पर "फंस" सकता है जहाँ से वह बाहर नहीं निकल सकता।
|
|
|
|
## नेविगेशन
|
|
|
|
एक बेहतर नेविगेशन नीति वह होगी जो हमने प्रशिक्षण के दौरान उपयोग की थी, जो शोषण और अन्वेषण को जोड़ती है। इस नीति में, हम प्रत्येक क्रिया को एक निश्चित संभावना के साथ चुनेंगे, जो Q-Table में मानों के अनुपात में होगी। यह रणनीति अभी भी एजेंट को पहले से खोजे गए स्थान पर वापस लौटने का कारण बन सकती है, लेकिन जैसा कि आप नीचे दिए गए कोड से देख सकते हैं, यह वांछित स्थान तक बहुत छोटे औसत पथ का परिणाम देती है (याद रखें कि `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 की सीमा में होगी।
|
|
|
|
## सीखने की प्रक्रिया की जांच
|
|
|
|
जैसा कि हमने उल्लेख किया है, सीखने की प्रक्रिया समस्या स्थान की संरचना के बारे में प्राप्त ज्ञान के अन्वेषण और उपयोग के बीच संतुलन है। हमने देखा है कि सीखने के परिणाम (एजेंट को लक्ष्य तक पहुँचने के लिए छोटा पथ खोजने की क्षमता) में सुधार हुआ है, लेकिन यह देखना भी दिलचस्प है कि सीखने की प्रक्रिया के दौरान औसत पथ लंबाई कैसे व्यवहार करती है:
|
|
|
|
## सीखने को निम्नलिखित रूप में संक्षेपित किया जा सकता है:
|
|
|
|
- **औसत पथ लंबाई बढ़ती है**। यहाँ हम देखते हैं कि शुरुआत में औसत पथ लंबाई बढ़ती है। ऐसा संभवतः इसलिए होता है क्योंकि जब हमें पर्यावरण के बारे में कुछ भी पता नहीं होता, तो हम खराब अवस्थाओं, पानी या भेड़िये में फंसने की संभावना रखते हैं। जैसे-जैसे हम अधिक सीखते हैं और इस ज्ञान का उपयोग करना शुरू करते हैं, हम पर्यावरण का अधिक समय तक अन्वेषण कर सकते हैं, लेकिन हमें अभी भी सेबों के स्थान का सही पता नहीं होता।
|
|
|
|
- **पथ लंबाई घटती है, जैसे-जैसे हम अधिक सीखते हैं**। एक बार जब हम पर्याप्त सीख लेते हैं, तो एजेंट के लिए लक्ष्य प्राप्त करना आसान हो जाता है, और पथ लंबाई घटने लगती है। हालांकि, हम अभी भी अन्वेषण के लिए खुले हैं, इसलिए हम अक्सर सबसे अच्छे पथ से दूर चले जाते हैं और नए विकल्पों का अन्वेषण करते हैं, जिससे पथ आदर्श से लंबा हो जाता है।
|
|
|
|
- **लंबाई अचानक बढ़ जाती है**। जो हम इस ग्राफ पर भी देखते हैं वह यह है कि किसी बिंदु पर, लंबाई अचानक बढ़ जाती है। यह प्रक्रिया की अनिश्चित प्रकृति को इंगित करता है, और यह कि हम किसी बिंदु पर Q-Table गुणांक को नए मानों से अधिलेखित करके "खराब" कर सकते हैं। इसे आदर्श रूप से सीखने की दर को कम करके न्यूनतम किया जाना चाहिए (उदाहरण के लिए, प्रशिक्षण के अंत में, हम केवल Q-Table मानों को एक छोटे मान से समायोजित करते हैं)।
|
|
|
|
कुल मिलाकर, यह याद रखना महत्वपूर्ण है कि सीखने की प्रक्रिया की सफलता और गुणवत्ता काफी हद तक पैरामीटर पर निर्भर करती है, जैसे सीखने की दर, सीखने की दर में कमी, और छूट कारक। इन्हें अक्सर **हाइपरपैरामीटर** कहा जाता है, ताकि उन्हें **पैरामीटर** से अलग किया जा सके, जिन्हें हम प्रशिक्षण के दौरान अनुकूलित करते हैं (उदाहरण के लिए, Q-Table गुणांक)। सबसे अच्छे हाइपरपैरामीटर मानों को खोजने की प्रक्रिया को **हाइपरपैरामीटर अनुकूलन** कहा जाता है, और यह एक अलग विषय के योग्य है।
|
|
|
|
## [पोस्ट-लेक्चर क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## असाइनमेंट
|
|
[एक अधिक यथार्थवादी संसार](assignment.md)
|
|
|
|
---
|
|
|
|
**अस्वीकरण**:
|
|
यह दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता के लिए प्रयासरत हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को आधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं। |