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

477 lines
20 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
"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/ur/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 اظہار کے طور پر ظاہر کی جاتی ہیں۔ نیز، کچھ حقائق کو `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** ایک لائبریری ہے جو Python میں فارورڈ انفرنس سسٹمز بنانے کے لیے استعمال ہوتی ہے، جو کلاسیکی پرانے سسٹم [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-15T11:42:55+00:00",
"source_file": "lessons/2-Symbolic/Animals.ipynb",
"language_code": "ur"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in New Issue View Git Blame Copy Permalink