docs/si/cfr/kuhn/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/cfr/kuhn/ init.py)
මෙයකුහ්න් පෝකර් වෙත ප්රතිවිරුද්ධ කනගාටුව අවම කිරීම (CFR) අදාළ වේ.
කුන් පෝකර් යනු ක්රීඩක 3-කාඩ් ඔට්ටු ඇල්ලීමේ ක්රීඩාවකි. ක්රීඩකයන්ට Ace, King සහ Queen (ඇඳුම් කට්ටල නොමැත) අතරින් එක් කාඩ්පතක් බැගින් ගනුදෙනු කරනු ලැබේ. ඇසුරුමේ ඇත්තේ කාඩ්පත් තුනක් පමණක් බැවින් එක් කාඩ්පතක් ඉතිරි වේ. ඒස් කිං සහ රැජින සහ කිං රැජිනට පහර දෙයි - සාමාන්ය කාඩ්පත් ශ්රේණිගත කිරීමේදී මෙන්.
ක්රීඩකයන්දෙදෙනාම 1 චිප් පෙර (අන්ධ ලෙස ඔට්ටු 1 චිපය). කාඩ්පත් දෙස බැලීමෙන් පසු, පළමු ක්රීඩකයාට 1 චිපය සමත් හෝ ඔට්ටු තැබිය හැකිය. පළමු ක්රීඩකයා සමත් වුවහොත්, ඉහළ කාඩ්පතක් ඇති ක්රීඩකයා බඳුන ජය ගනී. පළමු ක්රීඩකයා ඔට්ටු නම්, දෙවන තරගය ඔට්ටු හැකි (i.e. අමතන්න) 1 චිප් හෝ සමත් (i.e. නමන්න). දෙවන ක්රීඩකයා ඔට්ටු ඇල්ලුවහොත් සහ ඉහළ කාඩ්පත ඇති ක්රීඩකයා බඳුන ජය ගනී. දෙවන ක්රීඩකයා සමත් වුවහොත් (එනම් නැමීම්) පළමු ක්රීඩකයා බඳුන ලබා ගනී. මෙම ක්රීඩාව නැවත නැවතත් ක්රීඩා කරන අතර හොඳ උපාය මාර්ගයක් දිගු කාලීන උපයෝගීතාව (හෝ ජයග්රහණ) සඳහා ප්රශස්තිකරණය කරනු ඇත.
මෙන්නඋදාහරණ ක්රීඩා කිහිපයක්:
KAp - ක්රීඩකයා 1 කේ. ක්රීඩකයා 2 ලබා ගනී A. ක්රීඩකයා 1 සමත් වේ. ක්රීඩකයා 2 ඔට්ටු ඇල්ලීමේ අවස්ථාවක් නොලැබෙන අතර ක්රීඩකයා 2 2 චිප්ස් බඳුන දිනා ගනී.QKbp - ක්රීඩකයා 1 ලබා ගනී Q. ප්ලේයර් 2 කේ ප්ලේයර් 1 චිපයක් ඔට්ටු දමයි. ක්රීඩකයා 2 සමත් වේ (නැමීම්). ක්රීඩකයා 1 4 නිසා Player 2 නැවී ඇති බඳුනක් ලැබෙන.QAbb - ක්රීඩකයා 1 Q Player 2 ලබා ගනී A. ක්රීඩකයා 1 චිපයක් ඔට්ටු ඇල්ලීම. ක්රීඩකයා 2 ද ඔට්ටු (ඇමතුම්). ක්රීඩකයා 2 බඳුන ජය ගනී 4.ඔහුඅපි කුන් පෝකර් විශේෂතා __init__.py සමඟ අර්ථ දක්වා ඇති InfoSet``History පන්තිය සහ පන්තිය දීර් extend කරමු.
38fromtypingimportList,cast,Dict3940importnumpyasnp4142fromlabmlimportexperiment43fromlabml.configsimportoption44fromlabml\_nn.cfrimportHistoryas\_History,InfoSetas\_InfoSet,Action,Player,CFRConfigs45fromlabml\_nn.cfr.infoset\_saverimportInfoSetSaver
කූන්පෝකර් ක්රියාවන් සමත් වේ (p ) හෝ ඔට්ටු (b )
48ACTIONS=cast(List[Action],['p','b'])
නාට්යයේකාඩ්පත් තුන වන්නේ ඒස්, කිං සහ රැජින
50CHANCES=cast(List[Action],['A','K','Q'])
ක්රීඩකයන්දෙදෙනෙක් සිටිති
52PLAYERS=cast(List[Player],[0,1])
55classInfoSet(\_InfoSet):
ඉතිරිකිරීමට/බරට සහාය නොදක්වයි
60@staticmethod61deffrom\_dict(data:Dict[str,any])-\>'InfoSet':
63pass
ක්රියාලැයිස්තුව ආපසු ලබා දෙන්න. පර්යන්ත තත්වයන් හසුරුවනු ලබන්නේ History පන්තිය විසිනි.
65defactions(self)-\>List[Action]:
69returnACTIONS
මානවකියවිය හැකි නූල් නිරූපණය - එය ඔට්ටු ඇල්ලීමේ සම්භාවිතාව ලබා දෙයි
71def\_\_repr\_\_(self):
75total=sum(self.cumulative\_strategy.values())76total=max(total,1e-6)77bet=self.cumulative\_strategy[cast(Action,'b')]/total78returnf'{bet\*100: .1f}%'
ක්රීඩාවක්අවසන් වූ විට මෙය අර්ථ දක්වයි, උපයෝගීතාව සහ නියැදි අවස්ථා සිදුවීම් ගණනය කරයි (ගනුදෙනු කාඩ්පත්).
ඉතිහාසයවැලක් තුළ ගබඩා කර ඇත:
81classHistory(\_History):
ඉතිහාසය
95history:str
දීඇති ඉතිහාස නූලක් සමඟ ආරම්භ කරන්න
97def\_\_init\_\_(self,history:str=''):
101self.history=history
ඉතිහාසයපර්යන්තය වේවා (ක්රීඩාව අවසන්).
103defis\_terminal(self):
ක්රීඩකයින්තවමත් ක්රියාමාර්ග ගෙන නොමැත
108iflen(self.history)\<=2:109returnFalse
ක්රීඩාකිරීමට අවසන් ක්රීඩකයා සමත් විය (ක්රීඩාව අවසන්)
111elifself.history[-1]=='p':112returnTrue
දෙකමක්රීඩකයන් කැඳවා (ඔට්ටු) (ක්රීඩාව අවසන්)
114elifself.history[-2:]=='bb':115returnTrue
වෙනත්ඕනෑම සංයෝජනයක්
117else:118returnFalse
ක්රීඩකයාසඳහා පර්යන්ත උපයෝගීතාව ගණනය කරන්න 1, u1(z)
120def\_terminal\_utility\_p1(self)-\>float:
+1 ක්රීඩකයා 1 ට වඩා හොඳ කාඩ්පතක් තිබේ නම් සහ −1 වෙනත් ආකාරයකින්
125winner=-1+2\*(self.history[0]\<self.history[1])
දෙවනක්රීඩකයා සමත් විය
128ifself.history[-2:]=='bp':129return1
ක්රීඩකයන්දෙදෙනාම කැඳවනු ලැබේ, වඩා හොඳ කාඩ්පතක් ඇති ක්රීඩකයා 2 චිප්ස් දිනා ගනී
131elifself.history[-2:]=='bb':132returnwinner\*2
පළමුක්රීඩකයා සමත් විය, වඩා හොඳ කාඩ්පතක් ඇති ක්රීඩකයා 1 චිපය දිනා ගනී
134elifself.history[-1]=='p':135returnwinner
ඉතිහාසයපර්යන්ත නොවන
137else:138raiseRuntimeError()
ක්රීඩකයාසඳහා පර්යන්ත උපයෝගීතාව ලබා ගන්න i
140defterminal\_utility(self,i:Player)-\>float:
ක්රීඩකයා i නම් 1
145ifi==PLAYERS[0]:146returnself.\_terminal\_utility\_p1()
එසේනොමැති නම් u2(z)=−u1(z)
148else:149return-1\*self.\_terminal\_utility\_p1()
පළමුසිදුවීම් දෙක වන්නේ කාඩ්පත් ගනුදෙනු කිරීමයි; එනම් අහම්බෙන් සිදුවීම්
151defis\_chance(self)-\>bool:
155returnlen(self.history)\<2
ඉතිහාසයටක්රියාවක් එක් කර නව ඉතිහාසයක් නැවත ලබා දෙන්න
157def\_\_add\_\_(self,other:Action):
161returnHistory(self.history+other)
වත්මන්ක්රීඩකයා
163defplayer(self)-\>Player:
167returncast(Player,len(self.history)%2)
අවස්ථාවක්ලබා ගන්න
169defsample\_chance(self)-\>Action:
173whileTrue:
අහඹුලෙස කාඩ්පතක් තෝරන්න
175r=np.random.randint(len(CHANCES))176chance=CHANCES[r]
කාඩ්පතකලින් ගනුදෙනු කර ඇත්දැයි බලන්න
178forcinself.history:179ifc==chance:180chance=None181break
පෙරගනුදෙනු නොකළේ නම් කාඩ්පත ආපසු ලබා දෙන්න
184ifchanceisnotNone:185returncast(Action,chance)
මානවකියවිය හැකි නිරූපණය
187def\_\_repr\_\_(self):
191returnrepr(self.history)
තොරතුරුවත්මන් ඉතිහාසය සඳහා ප්රධාන කට්ටලයක්. මෙය වර්තමාන ක්රීඩකයාට පමණක් පෙනෙන ක්රියා වැලක් වේ.
193definfo\_set\_key(self)-\>str:
වත්මන්ක්රීඩකයා ලබා ගන්න
199i=self.player()
වත්මන්ක්රීඩකයා ඇගේ කාඩ්පත සහ ඔට්ටු ඇල්ලීමේ ක්රියාවන් දකී
201returnself.history[i]+self.history[2:]
203defnew\_info\_set(self)-\>InfoSet:
නවතොරතුරු කට්ටලයක් වස්තුවක් සාදන්න
205returnInfoSet(self.info\_set\_key())
හිස්ඉතිහාස වස්තුවක් නිර්මාණය කිරීමේ කාර්යයක්
208defcreate\_new\_history():
210returnHistory()
වින්යාසයන්CFR වින්යාස කිරීමේ පන්තිය පුළුල් කරයි
213classConfigs(CFRConfigs):
217pass
කූන්පෝකර් සඳහා create_new_history ක්රමය සකසන්න
220@option(Configs.create\_new\_history)221def\_cnh():
225returncreate\_new\_history
228defmain():
අත්හදාබැලීමක් සාදන්න, අපි ලියන්නේ දේවල් වේගවත් sqlite කිරීම සඳහා ලුහුබැඳීමේ තොරතුරු පමණි. ඇල්ගොරිතම වේගයෙන් පුනරාවර්තනය වන අතර අපි එක් එක් පුනරාවර්තනයේ දත්ත නිරීක්ෂණය කරන බැවින්, ටෙන්සෝර්බෝඩ් වැනි වෙනත් ගමනාන්ත වෙත ලිවීම සාපේක්ෂව කාලය ගත කළ හැකිය. SQLite අපගේ විශ්ලේෂණ සඳහා ප්රමාණවත් වේ.
237experiment.create(name='kuhn\_poker',writers={'sqlite'})
වින්යාසයආරම්භ කරන්න
239conf=Configs()
පැටවීමවින්යාස
241experiment.configs(conf)
ඉතිරිකිරීම සඳහා ආකෘති සකසන්න
243experiment.add\_model\_savers({'info\_sets':InfoSetSaver(conf.cfr.info\_sets)})
අත්හදාබැලීම ආරම්භ කරන්න
245withexperiment.start():
නැවතආරම්භ කරන්න
247conf.cfr.iterate()
251if\_\_name\_\_=='\_\_main\_\_':252main()