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/ne/lessons/2-Symbolic/Animals.ipynb

477 lines
24 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/ne/AND-OR-Tree.5592d2c70187f283.webp)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## हाम्रो आफ्नै विशेषज्ञ प्रणाली शेल पछाडि अन्वेषणसहित\n",
"\n",
"उत्पादन नियमहरूमा आधारित ज्ञान प्रतिनिधित्वको लागि सरल भाषा परिभाषित गर्ने प्रयास गरौं। हामी नियमहरू परिभाषित गर्न कुञ्जीशब्दहरू रूपमा Python कक्षाहरू प्रयोग गर्नेछौं। आधारभूत रूपमा ३ प्रकारका कक्षाहरू हुनेछन्ः\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 अभिव्यक्तिहरूको रूपमा व्यक्त गरिएको हुन्छ। साथै, केही तथ्यहरूलाई `पूछ्न` सकिन्छ।\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": [
"एक पटक हामीले ज्ञानको आधार परिभाषित गरेपछि, हामीले हाम्रो कार्य सम्झनामा केही प्रारम्भिक तथ्यहरू राख्छौं, र त्यसपछि inference प्रदर्शन गर्न `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:53:10+00:00",
"source_file": "lessons/2-Symbolic/Animals.ipynb",
"language_code": "ne"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in New Issue View Git Blame Copy Permalink