RomanNum3ral
/
AI-For-Beginners
mirror of https://github.com/microsoft/AI-For-Beginners.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
AI-For-Beginners/translations/mr/lessons/2-Symbolic/Animals.ipynb

477 lines
23 KiB
Plaintext
Raw Blame History

{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"# प्राणी तज्ञ प्रणालीची अंमलबजावणी\n",
"\n",
"[AI for Beginners Curriculum](http://github.com/microsoft/ai-for-beginners) मधील एक उदाहरण.\n",
"\n",
"या नमुन्यात, आपण काही भौतिक वैशिष्ट्यांवर आधारित प्राणी ठरवण्यासाठी एक सोपी ज्ञान-आधारित प्रणाली अंमलात आणू. प्रणाली खालील AND-OR वृक्षमुळे दर्शविली जाऊ शकते (हे संपूर्ण वृक्षकडील एक भाग आहे, आपण सहजपणे आणखी काही नियम जोडू शकतो):\n",
"\n",
"![](../../../../../../translated_images/mr/AND-OR-Tree.5592d2c70187f283.webp)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## मागे जाणाऱ्या अनुमानांसह आपल्या स्वत: च्या तज्ञ प्रणाली शेल\n",
"\n",
"चल, उत्पादन नियमांवर आधारित ज्ञान प्रतिनिधीकरणासाठी एक सोपी भाषा परिभाषित करण्याचा प्रयत्न करूया. नियम परिभाषित करण्यासाठी आम्ही Python वर्गांना कीवर्ड म्हणून वापरणार आहोत. मूलतः 3 प्रकारचे वर्ग असतील:\n",
"* `Ask` वापरकर्त्याला विचारायचा प्रश्न दर्शवतो. त्यात शक्य उत्तरे संच असतो.\n",
"* `If` नियम दर्शवतो, आणि तो केवळ नियमाच्या सामग्रीस संचयित करण्यासाठी एक वाक्यरचनात्मक साखर आहे\n",
"* `AND`/`OR` ही वृक्षाच्या AND/OR शाखांचे प्रतिनिधीत्व करणारे वर्ग आहेत. ते फक्त आतल्या तर्कांची यादी संग्रहित करतात. कोड सोपे करण्यासाठी, सर्व कार्यक्षमता पालक वर्ग `Content` मध्ये परिभाषित केली आहे\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"trusted": true
},
"outputs": [],
"source": [
"class Ask():\n",
" def __init__(self,choices=['y','n']):\n",
" self.choices = choices\n",
" def ask(self):\n",
" if max([len(x) for x in self.choices])>1:\n",
" for i,x in enumerate(self.choices):\n",
" print(\"{0}. {1}\".format(i,x),flush=True)\n",
" x = int(input())\n",
" return self.choices[x]\n",
" else:\n",
" print(\"/\".join(self.choices),flush=True)\n",
" return input()\n",
"\n",
"class Content():\n",
" def __init__(self,x):\n",
" self.x=x\n",
" \n",
"class If(Content):\n",
" pass\n",
"\n",
"class AND(Content):\n",
" pass\n",
"\n",
"class OR(Content):\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"आपल्या प्रणालीमध्ये, कार्यशील स्मृतीमध्ये **घटनेची** यादी **गुणधर्म-मूल्य जोड्यां** स्वरूपात असेल. ज्ञानकोशाला एका मोठ्या शब्दकोशाप्रमाणे परिभाषित करता येईल जो क्रियांना (नवीन घटक जे कार्यशील स्मृतीमध्ये समाविष्ट केले जाणे आवश्यक आहे) अटींशी जोडतो, जे AND-OR अभिव्यक्तींमध्ये व्यक्त केल्या जातात. तसेच, काही घटक `Ask` केले जाऊ शकतात.\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"trusted": true
},
"outputs": [],
"source": [
"rules = {\n",
" 'default': Ask(['y','n']),\n",
" 'color' : Ask(['red-brown','black and white','other']),\n",
" 'pattern' : Ask(['dark stripes','dark spots']),\n",
" 'mammal': If(OR(['hair','gives milk'])),\n",
" 'carnivor': If(OR([AND(['sharp teeth','claws','forward-looking eyes']),'eats meat'])),\n",
" 'ungulate': If(['mammal',OR(['has hooves','chews cud'])]),\n",
" 'bird': If(OR(['feathers',AND(['flies','lies eggs'])])),\n",
" 'animal:monkey' : If(['mammal','carnivor','color:red-brown','pattern:dark spots']),\n",
" 'animal:tiger' : If(['mammal','carnivor','color:red-brown','pattern:dark stripes']),\n",
" 'animal:giraffe' : If(['ungulate','long neck','long legs','pattern:dark spots']),\n",
" 'animal:zebra' : If(['ungulate','pattern:dark stripes']),\n",
" 'animal:ostrich' : If(['bird','long nech','color:black and white','cannot fly']),\n",
" 'animal:pinguin' : If(['bird','swims','color:black and white','cannot fly']),\n",
" 'animal:albatross' : If(['bird','flies well'])\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"बॅकवॉर्ड इन्फरन्स करण्यासाठी, आपण `Knowledgebase` क्लास परिभाषित करू. यामध्ये असेल:\n",
"* कार्यरत `memory` - एक डिक्शनरी जी अॅट्रिब्युट्सना मूल्ये मॅप करते\n",
"* Knowledgebase मधील `rules` वरिभाषित स्वरूपात\n",
"\n",
"मुख्य दोन मेथड्स आहेत:\n",
"* `get` जे एका अॅट्रिब्युटचे मूल्य प्राप्त करते, गरज भासल्यास इन्फरन्स करतो. उदाहरणार्थ, `get('color')` रंगाच्या स्लॉटचे मूल्य मिळवेल (गरज भासल्यास विचारेल, आणि नंतरच्या वापरासाठी कार्यरत मेमरीमध्ये मूल्य साठवेल). जर आपण `get('color:blue')` विचारले, तर रंगासाठी विचारेल, आणि नंतर रंगानुसार `y`/`n` मूल्य परत करेल.\n",
"* `eval` प्रत्यक्ष इन्फरन्स करतो, म्हणजे AND/OR ट्रीमध्ये फिरतो, उप-लक्ष्यांचे मूल्यांकन करतो, इत्यादी.\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"trusted": true
},
"outputs": [],
"source": [
"class KnowledgeBase():\n",
" def __init__(self,rules):\n",
" self.rules = rules\n",
" self.memory = {}\n",
" \n",
" def get(self,name):\n",
" if ':' in name:\n",
" k,v = name.split(':')\n",
" vv = self.get(k)\n",
" return 'y' if v==vv else 'n'\n",
" if name in self.memory.keys():\n",
" return self.memory[name]\n",
" for fld in self.rules.keys():\n",
" if fld==name or fld.startswith(name+\":\"):\n",
" # print(\" + proving {}\".format(fld))\n",
" value = 'y' if fld==name else fld.split(':')[1]\n",
" res = self.eval(self.rules[fld],field=name)\n",
" if res!='y' and res!='n' and value=='y':\n",
" self.memory[name] = res\n",
" return res\n",
" if res=='y':\n",
" self.memory[name] = value\n",
" return value\n",
" # field is not found, using default\n",
" res = self.eval(self.rules['default'],field=name)\n",
" self.memory[name]=res\n",
" return res\n",
" \n",
" def eval(self,expr,field=None):\n",
" # print(\" + eval {}\".format(expr))\n",
" if isinstance(expr,Ask):\n",
" print(field)\n",
" return expr.ask()\n",
" elif isinstance(expr,If):\n",
" return self.eval(expr.x)\n",
" elif isinstance(expr,AND) or isinstance(expr,list):\n",
" expr = expr.x if isinstance(expr,AND) else expr\n",
" for x in expr:\n",
" if self.eval(x)=='n':\n",
" return 'n'\n",
" return 'y'\n",
" elif isinstance(expr,OR):\n",
" for x in expr.x:\n",
" if self.eval(x)=='y':\n",
" return 'y'\n",
" return 'n'\n",
" elif isinstance(expr,str):\n",
" return self.get(expr)\n",
" else:\n",
" print(\"Unknown expr: {}\".format(expr))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"आता आपण आपला प्राणी ज्ञानसंच परिभाषित करूया आणि सल्ला प्रक्रिया पार पाडूया. लक्षात ठेवा की या कॉलमध्ये तुम्हाला प्रश्न विचारले जातील. तुम्ही हो वा नाही या प्रश्नांसाठी `y`/`n` टाइप करून उत्तर देऊ शकता, किंवा जास्त पर्याय असलेल्या प्रश्नांसाठी 0..N या क्रमांकावर उत्तर देऊ शकता.\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"trusted": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"hair\n",
"y/n\n",
"sharp teeth\n",
"y/n\n",
"claws\n",
"y/n\n",
"forward-looking eyes\n",
"y/n\n",
"color\n",
"0. red-brown\n",
"1. black and white\n",
"2. other\n",
"has hooves\n",
"y/n\n",
"long neck\n",
"y/n\n",
"long legs\n",
"y/n\n",
"pattern\n",
"0. dark stripes\n",
"1. dark spots\n"
]
},
{
"data": {
"text/plain": [
"'giraffe'"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"kb = KnowledgeBase(rules)\n",
"kb.get('animal')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## पुढील अनुमानासाठी Experta वापरणे\n",
"\n",
"पुढील उदाहरणात, आपण ज्ञान सादरीकरणासाठी असलेल्या लायब्ररींपैकी एका, [Experta](https://github.com/nilp0inter/experta) वापरून पुढील अनुमान अमलात आणण्याचा प्रयत्न करू. **Experta** ही पायथनमधील पुढील अनुमान प्रणाली तयार करण्यासाठीची लायब्ररी आहे, जी पारंपरिक जुन्या प्रणाली [CLIPS](http://www.clipsrules.net/index.html) प्रमाणे डिझाइन केलेली आहे.\n",
"\n",
"आपणही अनेक अडचणीशिवाय पुढील चेनिंग स्वतः अमलात आणू शकतो होतो, पण साध्या अमलबजावणी सहसा फार कार्यक्षम नसतात. अधिक प्रभावी नियम जुळवणीसाठी एक विशेष अल्गोरिदम [Rete](https://en.wikipedia.org/wiki/Rete_algorithm) वापरला जातो.\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"trusted": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Collecting git+https://github.com/nilp0inter/experta\n",
" Cloning https://github.com/nilp0inter/experta to /tmp/pip-req-build-7qurtwk3\n",
" Running command git clone --filter=blob:none --quiet https://github.com/nilp0inter/experta /tmp/pip-req-build-7qurtwk3\n",
" Resolved https://github.com/nilp0inter/experta to commit c6d5834b123861f5ae09e7d07027dc98bec58741\n",
" Installing build dependencies ... \u001b[?25ldone\n",
"\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n",
"\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n",
"\u001b[?25hRequirement already satisfied: frozendict~=2.4.6 in /opt/conda/envs/ai4beg/lib/python3.12/site-packages (from experta==1.9.5.dev1) (2.4.7)\n",
"Collecting schema~=0.6.7 (from experta==1.9.5.dev1)\n",
" Downloading schema-0.6.8-py2.py3-none-any.whl.metadata (14 kB)\n",
"Downloading schema-0.6.8-py2.py3-none-any.whl (14 kB)\n",
"Building wheels for collected packages: experta\n",
" Building wheel for experta (pyproject.toml) ... \u001b[?25ldone\n",
"\u001b[?25h Created wheel for experta: filename=experta-1.9.5.dev1-py3-none-any.whl size=34804 sha256=888c459512a5e713f4b674caa9a0f96cfdf07ec0d6eb56cc318ce0653d218014\n",
" Stored in directory: /tmp/pip-ephem-wheel-cache-1eeii9zy/wheels/3d/e8/bb/22d7956359603fa8dd679aa09f5b8efb3f29991c3986fdc787\n",
"Successfully built experta\n",
"Installing collected packages: schema, experta\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2/2\u001b[0m [experta]\n",
"\u001b[1A\u001b[2KSuccessfully installed experta-1.9.5.dev1 schema-0.6.8\n"
]
}
],
"source": [
"import sys\n",
"!{sys.executable} -m pip install git+https://github.com/nilp0inter/experta"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"trusted": true
},
"outputs": [],
"source": [
"from experta import *\n",
"#import experta"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"आपण आपल्या सिस्टीमला `KnowledgeEngine` ची उपवर्ग वर्ग म्हणून परिभाषित करू. प्रत्येक नियम स्वतंत्र फंक्शनने परिभाषित केला जातो ज्यावर `@Rule` अ‍ॅनोटेशन असते, जे दर्शवते की नियम कधी लागू होईल. नियमाच्या आत, आपण `declare` फंक्शन वापरून नवीन तथ्ये जोडू शकतो, आणि त्या तथ्यांमुळे पुढील नियम फॉरवर्ड इन्फरन्स इंजिनद्वारे कॉल केले जातील.\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"trusted": true
},
"outputs": [],
"source": [
"class Animals(KnowledgeEngine):\n",
" @Rule(OR(\n",
" AND(Fact('sharp teeth'),Fact('claws'),Fact('forward looking eyes')),\n",
" Fact('eats meat')))\n",
" def cornivor(self):\n",
" self.declare(Fact('carnivor'))\n",
" \n",
" @Rule(OR(Fact('hair'),Fact('gives milk')))\n",
" def mammal(self):\n",
" self.declare(Fact('mammal'))\n",
"\n",
" @Rule(Fact('mammal'),\n",
" OR(Fact('has hooves'),Fact('chews cud')))\n",
" def hooves(self):\n",
" self.declare('ungulate')\n",
" \n",
" @Rule(OR(Fact('feathers'),AND(Fact('flies'),Fact('lays eggs'))))\n",
" def bird(self):\n",
" self.declare('bird')\n",
" \n",
" @Rule(Fact('mammal'),Fact('carnivor'),\n",
" Fact(color='red-brown'),\n",
" Fact(pattern='dark spots'))\n",
" def monkey(self):\n",
" self.declare(Fact(animal='monkey'))\n",
"\n",
" @Rule(Fact('mammal'),Fact('carnivor'),\n",
" Fact(color='red-brown'),\n",
" Fact(pattern='dark stripes'))\n",
" def tiger(self):\n",
" self.declare(Fact(animal='tiger'))\n",
"\n",
" @Rule(Fact('ungulate'),\n",
" Fact('long neck'),\n",
" Fact('long legs'),\n",
" Fact(pattern='dark spots'))\n",
" def giraffe(self):\n",
" self.declare(Fact(animal='giraffe'))\n",
"\n",
" @Rule(Fact('ungulate'),\n",
" Fact(pattern='dark stripes'))\n",
" def zebra(self):\n",
" self.declare(Fact(animal='zebra'))\n",
"\n",
" @Rule(Fact('bird'),\n",
" Fact('long neck'),\n",
" Fact('cannot fly'),\n",
" Fact(color='black and white'))\n",
" def straus(self):\n",
" self.declare(Fact(animal='ostrich'))\n",
"\n",
" @Rule(Fact('bird'),\n",
" Fact('swims'),\n",
" Fact('cannot fly'),\n",
" Fact(color='black and white'))\n",
" def pinguin(self):\n",
" self.declare(Fact(animal='pinguin'))\n",
"\n",
" @Rule(Fact('bird'),\n",
" Fact('flies well'))\n",
" def albatros(self):\n",
" self.declare(Fact(animal='albatross'))\n",
" \n",
" @Rule(Fact(animal=MATCH.a))\n",
" def print_result(self,a):\n",
" print('Animal is {}'.format(a))\n",
" \n",
" def factz(self,l):\n",
" for x in l:\n",
" self.declare(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"एकदा आपण ज्ञानभांडार परिभाषित केल्यानंतर, आपण आपली कार्यरत स्मृती काही प्रारंभिक तथ्यांनी भरतो, आणि नंतर `run()` मेथड कॉल करतो ज्यामुळे तपासणी केली जाते. तुम्हाला परिणाम म्हणून दिसेल की नवीन निष्पन्न तथ्ये कार्यरत स्मृतीमध्ये जोडली जातात, ज्यात प्राण्याविषयी अंतिम तथ्यही समाविष्ट आहे (जर आपण सर्व प्रारंभिक तथ्ये योग्यरित्या सेट केली असतील तर).\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"trusted": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Animal is tiger\n"
]
},
{
"data": {
"text/plain": [
"FactList([(0, InitialFact()),\n",
" (1, Fact(color='red-brown')),\n",
" (2, Fact(pattern='dark stripes')),\n",
" (3, Fact('sharp teeth')),\n",
" (4, Fact('claws')),\n",
" (5, Fact('forward looking eyes')),\n",
" (6, Fact('gives milk')),\n",
" (7, Fact('mammal')),\n",
" (8, Fact('carnivor')),\n",
" (9, Fact(animal='tiger'))])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ex1 = Animals()\n",
"ex1.reset()\n",
"ex1.factz([\n",
" Fact(color='red-brown'),\n",
" Fact(pattern='dark stripes'),\n",
" Fact('sharp teeth'),\n",
" Fact('claws'),\n",
" Fact('forward looking eyes'),\n",
" Fact('gives milk')])\n",
"ex1.run()\n",
"ex1.facts"
]
},
{
"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"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.7.4 64-bit (conda)",
"metadata": {
"interpreter": {
"hash": "86193a1ab0ba47eac1c69c1756090baa3b420b3eea7d4aafab8b85f8b312f0c5"
}
},
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.2"
},
"coopTranslator": {
"original_hash": "8ef43db4b9182239fd150a76bd494fdb",
"translation_date": "2026-01-15T12:52:41+00:00",
"source_file": "lessons/2-Symbolic/Animals.ipynb",
"language_code": "mr"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in New Issue View Git Blame Copy Permalink