From f04f87e46f39d7df015b42a9e9ab5d57ddea05f0 Mon Sep 17 00:00:00 2001 From: theta00 <72700814+theta00@users.noreply.github.com> Date: Tue, 31 Jan 2023 20:18:00 +0100 Subject: [PATCH] Update controllers --- FuzzyControlSystem.ipynb | 516 +++++++++++++++++++++------------------ 1 file changed, 273 insertions(+), 243 deletions(-) diff --git a/FuzzyControlSystem.ipynb b/FuzzyControlSystem.ipynb index 8b54d2d..ab3406f 100644 --- a/FuzzyControlSystem.ipynb +++ b/FuzzyControlSystem.ipynb @@ -27,59 +27,64 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 27, "id": "a3a08d50", "metadata": {}, + "outputs": [], + "source": [ + "def getStartDecision(chipVal, lossNum):\n", + " \"\"\"\n", + " Args:\n", + " chipVal (int): current value of the player's chips\n", + " lossNum (int): number of losses in a row\n", + " Returns:\n", + " str: decision\n", + " \"\"\"\n", + " \n", + " FS = FuzzySystem(show_banner=False)\n", + "\n", + " FS.add_linguistic_variable(\"chipValue\", AutoTriangle(3, terms=['low', 'average', 'high'], universe_of_discourse=[0, 10]))\n", + " FS.add_linguistic_variable(\"numLossInRow\", AutoTriangle(3, terms=['low', 'average', 'high'], universe_of_discourse=[0, 10]))\n", + "\n", + " O1 = TriangleFuzzySet(0,0,13, term=\"leave\")\n", + " O2 = TriangleFuzzySet(0,13,25, term=\"play\")\n", + " O3 = TriangleFuzzySet(13,25,25, term=\"playDouble\")\n", + " FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2, O3], universe_of_discourse=[0, 25]))\n", + "\n", + " FS.add_rules([\n", + " \"IF (numLossInRow IS average) AND (chipValue IS average) THEN (decision IS play)\",\n", + " \"IF (numLossInRow IS low) OR (chipValue IS low) THEN (decision IS leave)\",\n", + " \"IF (numLossInRow IS high) AND (chipValue IS high) THEN (decision IS playDouble)\",\n", + " ])\n", + "\n", + " FS.set_variable(\"chipValue\", chipVal) \n", + " FS.set_variable(\"numLossInRow\", lossNum) \n", + "\n", + " result = FS.inference()\n", + " decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", + " endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", + " return endDecision" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "f7729dd6", + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " * Processing output for variable 'decision'\n", - " whose universe of discourse is: [0, 25]\n", - " contains the following fuzzy sets: [, , ]\n", - " ** Rule composition: f.(c.(numLossInRow IS average) AND c.(chipValue IS average)) -> ('decision', 'play', '1.0') , output variable: 'decision' with term: 'play'\n", - " ** Rule composition: f.(c.(numLossInRow IS low) OR c.(chipValue IS low)) -> ('decision', 'leave', '1.0') , output variable: 'decision' with term: 'leave'\n", - " ** Rule composition: f.(c.(numLossInRow IS high) AND c.(chipValue IS high)) -> ('decision', 'playDouble', '1.0') , output variable: 'decision' with term: 'playDouble'\n", - " * Indices: {'play': 1, 'leave': 0, 'playDouble': 2}\n", - " * Weighted values: 6201.36\tValues: 458.14\tCoG: 13.54\n" - ] - }, { "data": { "text/plain": [ "'play'" ] }, - "execution_count": 29, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "FS = FuzzySystem(show_banner=False)\n", - "\n", - "FS.add_linguistic_variable(\"chipValue\", AutoTriangle(3, terms=['low', 'average', 'high'], universe_of_discourse=[0, 10]))\n", - "FS.add_linguistic_variable(\"numLossInRow\", AutoTriangle(3, terms=['low', 'average', 'high'], universe_of_discourse=[0, 10]))\n", - "\n", - "O1 = TriangleFuzzySet(0,0,13, term=\"leave\")\n", - "O2 = TriangleFuzzySet(0,13,25, term=\"play\")\n", - "O3 = TriangleFuzzySet(13,25,25, term=\"playDouble\")\n", - "FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2, O3], universe_of_discourse=[0, 25]))\n", - "\n", - "FS.add_rules([\n", - "\t\"IF (numLossInRow IS average) AND (chipValue IS average) THEN (decision IS play)\",\n", - "\t\"IF (numLossInRow IS low) OR (chipValue IS low) THEN (decision IS leave)\",\n", - " \"IF (numLossInRow IS high) AND (chipValue IS high) THEN (decision IS playDouble)\",\n", - "\t])\n", - "\n", - "FS.set_variable(\"chipValue\", 7) \n", - "FS.set_variable(\"numLossInRow\", 7) \n", - "\n", - "result = FS.inference(verbose=True)\n", - "decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", - "endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", - "endDecision" + "getStartDecision(7, 7)" ] }, { @@ -110,80 +115,114 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 12, "id": "2f13e6ad", "metadata": {}, + "outputs": [], + "source": [ + "def getSplitDecision(dealerCard, playerCard):\n", + " \"\"\"\n", + " Args:\n", + " dealerCard (int): value of the dealer card\n", + " playerCard (int): value of the player card (one of the pair)\n", + " Returns:\n", + " str: decision\n", + " \"\"\"\n", + " \n", + " FS = FuzzySystem(show_banner=False)\n", + "\n", + " T1 = TriangleFuzzySet(0,0,6, term=\"low\")\n", + " T2 = TriangleFuzzySet(4,6,8, term=\"average\")\n", + " T3 = TriangleFuzzySet(6,11,11, term=\"high\")\n", + " FS.add_linguistic_variable(\"dealerCardValue\", LinguisticVariable([T1, T2, T3], universe_of_discourse=[0, 11]))\n", + " FS.add_linguistic_variable(\"playerCardValue\", LinguisticVariable([T1, T2, T3], universe_of_discourse=[0, 11]))\n", + "\n", + "\n", + " O1 = TriangleFuzzySet(0,0,15, term=\"continue\")\n", + " O2 = TriangleFuzzySet(11,25,25, term=\"split\")\n", + " FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2], universe_of_discourse=[0, 25]))\n", + "\n", + " FS.add_rules([\n", + " \"IF (playerCardValue IS high) THEN (decision IS split)\",\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) THEN (decision IS split)\",\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS low) THEN (decision IS split)\",\n", + " \"IF (playerCardValue IS low) AND (dealerCardValue IS high) THEN (decision IS continue)\",\n", + " \"IF (playerCardValue IS low) AND (dealerCardValue IS average) THEN (decision IS split)\",\n", + " \"IF (playerCardValue IS low) AND (dealerCardValue IS low) THEN (decision IS continue)\",\n", + " \"IF (playerCardValue IS low) AND (dealerCardValue IS high) THEN (decision IS continue)\"\n", + " ])\n", + "\n", + " FS.set_variable(\"dealerCardValue\", dealerCard) \n", + " FS.set_variable(\"playerCardValue\", playerCard) \n", + "\n", + " result = FS.inference()\n", + " decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", + " endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", + " return endDecision" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5ac91532", + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " * Processing output for variable 'decision'\n", - " whose universe of discourse is: [0, 25]\n", - " contains the following fuzzy sets: [, ]\n", - " ** Rule composition: c.(playerCardValue IS high) -> ('decision', 'split', '1.0') , output variable: 'decision' with term: 'split'\n", - " ** Rule composition: f.(c.(playerCardValue IS average) AND c.(dealerCardValue IS average)) -> ('decision', 'split', '1.0') , output variable: 'decision' with term: 'split'\n", - " ** Rule composition: f.(c.(playerCardValue IS low) AND c.(dealerCardValue IS average)) -> ('decision', 'split', '1.0') , output variable: 'decision' with term: 'split'\n", - " ** Rule composition: f.(c.(playerCardValue IS low) AND c.(dealerCardValue IS low)) -> ('decision', 'continue', '1.0') , output variable: 'decision' with term: 'continue'\n", - " ** Rule composition: f.(c.(playerCardValue IS low) AND c.(dealerCardValue IS high)) -> ('decision', 'continue', '1.0') , output variable: 'decision' with term: 'continue'\n", - " * Indices: {'split': 1, 'continue': 0}\n", - " * Weighted values: 4597.07\tValues: 290.67\tCoG: 15.82\n" - ] - }, { "data": { "text/plain": [ "'split'" ] }, - "execution_count": 38, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "FS = FuzzySystem(show_banner=False)\n", - "\n", - "T1 = TriangleFuzzySet(0,0,6, term=\"low\")\n", - "T2 = TriangleFuzzySet(4,6,8, term=\"average\")\n", - "T3 = TriangleFuzzySet(6,11,11, term=\"high\")\n", - "FS.add_linguistic_variable(\"dealerCardValue\", LinguisticVariable([T1, T2, T3], universe_of_discourse=[0, 11]))\n", - "FS.add_linguistic_variable(\"playerCardValue\", LinguisticVariable([T1, T2, T3], universe_of_discourse=[0, 11]))\n", - "\n", - "\n", - "O1 = TriangleFuzzySet(0,0,15, term=\"continue\")\n", - "O2 = TriangleFuzzySet(11,25,25, term=\"split\")\n", - "FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2], universe_of_discourse=[0, 25]))\n", - "\n", - "FS.add_rules([\n", - "\t\"IF (playerCardValue IS high) THEN (decision IS split)\",\n", - "\t\"IF (playerCardValue IS average) AND (dealerCardValue IS average) THEN (decision IS split)\",\n", - " \"IF (playerCardValue IS average) AND (dealerCardValue IS low) THEN (decision IS split)\",\n", - " \"IF (playerCardValue IS low) AND (dealerCardValue IS high) THEN (decision IS continue)\",\n", - " \"IF (playerCardValue IS low) AND (dealerCardValue IS average) THEN (decision IS split)\",\n", - " \"IF (playerCardValue IS low) AND (dealerCardValue IS low) THEN (decision IS continue)\",\n", - " \"IF (playerCardValue IS low) AND (dealerCardValue IS high) THEN (decision IS continue)\"\n", - "\t])\n", - "\n", - "FS.set_variable(\"dealerCardValue\", 5) \n", - "FS.set_variable(\"playerCardValue\", 3) \n", - "\n", - "result = FS.inference(verbose=True)\n", - "decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", - "endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", - "endDecision" + "getSplitDecision(5, 3)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "ba24b10d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# FS.plot_variable('dealerCardValue')\n", - "# FS.plot_variable('playerCardValue')\n", - "# FS.plot_variable('decision')" + "FS.plot_variable('dealerCardValue')\n", + "FS.plot_variable('playerCardValue')\n", + "FS.plot_variable('decision')" ] }, { @@ -203,97 +242,97 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 29, "id": "d78bc74a", "metadata": {}, + "outputs": [], + "source": [ + "def getHardHandDecision(dealerCard, playerCardsVal, countedCardsVal, playerCardsNum):\n", + " \"\"\"\n", + " Args:\n", + " dealerCard (int): value of the dealer card\n", + " playerCardsVal (int): sum of the players hand\n", + " countedCardsVal (int): value of the counted cards\n", + " playerCardsNum (int): number of cards in players hadn\n", + " Returns:\n", + " str: decision\n", + " \"\"\"\n", + " \n", + " FS = FuzzySystem(show_banner=False)\n", + "\n", + " FS.add_linguistic_variable(\"dealerCardValue\", LinguisticVariable([\n", + " TriangleFuzzySet(0,0,6, term=\"low\"),\n", + " TriangleFuzzySet(4,6,8, term=\"average\"),\n", + " TriangleFuzzySet(6,11,11, term=\"high\")], \n", + " universe_of_discourse=[0, 11]))\n", + "\n", + " FS.add_linguistic_variable(\"playerCardsValue\", LinguisticVariable([\n", + " TriangleFuzzySet(0,0,12, term=\"low\"),\n", + " TriangleFuzzySet(11,14,17, term=\"average\"),\n", + " TriangleFuzzySet(12,21,21, term=\"high\")], \n", + " universe_of_discourse=[0, 21]))\n", + "\n", + " FS.add_linguistic_variable(\"countedCardsValue\", LinguisticVariable([\n", + " TriangleFuzzySet(-20,-20,0, term=\"low\"),\n", + " TriangleFuzzySet(-5,0,5, term=\"average\"),\n", + " TriangleFuzzySet(0,20,20, term=\"high\")], \n", + " universe_of_discourse=[-20, 20]))\n", + "\n", + "\n", + " O1 = TriangleFuzzySet(0,0,13, term=\"double down\")\n", + " O2 = TriangleFuzzySet(0,13,25, term=\"hit\")\n", + " O3 = TriangleFuzzySet(13,25,25, term=\"stand\")\n", + " FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2, O3], universe_of_discourse=[0, 25]))\n", + "\n", + "\n", + " if playerCardsNum == 2:\n", + " FS.add_rules([\n", + " \"IF (playerCardsValue IS low) THEN (decision IS double down)\",\n", + " \"IF (playerCardsValue IS average) AND (dealerCardValue IS high) THEN (decision IS double down)\",\n", + " \"IF (playerCardsValue IS high) THEN (decision IS stand)\",\n", + " \"IF (playerCardsValue IS average) AND (dealerCardValue IS average) THEN (decision IS stand)\",\n", + " \"IF (playerCardsValue IS average) AND (dealerCardValue IS average) THEN (decision IS double down)\"\n", + " ])\n", + "\n", + " else: \n", + " FS.add_rules([\n", + " \"IF (playerCardsValue IS high) THEN (decision IS stand)\",\n", + " \"IF (playerCardsValue IS low) THEN (decision IS hit)\",\n", + " \"IF (playerCardsValue IS average) AND (dealerCardValue IS low) THEN (decision IS stand)\",\n", + " \"IF (playerCardsValue IS average) AND (dealerCardValue IS high) THEN (decision IS hit)\",\n", + " \"IF (playerCardsValue IS average) AND (dealerCardValue IS average) AND (countedCardsValue IS low) THEN (decision IS hit)\",\n", + " ])\n", + "\n", + "\n", + " FS.set_variable(\"dealerCardValue\", dealerCard) \n", + " FS.set_variable(\"playerCardsValue\", playerCardsVal)\n", + " FS.set_variable(\"countedCardsValue\", countedCardsVal)\n", + "\n", + " result = FS.inference()\n", + " decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", + " endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", + " return endDecision" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ffff8bbd", + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " * Processing output for variable 'decision'\n", - " whose universe of discourse is: [0, 25]\n", - " contains the following fuzzy sets: [, , ]\n", - " ** Rule composition: c.(playerCardsValue IS high) -> ('decision', 'stand', '1.0') , output variable: 'decision' with term: 'stand'\n", - " ** Rule composition: c.(playerCardsValue IS low) -> ('decision', 'hit', '1.0') , output variable: 'decision' with term: 'hit'\n", - " ** Rule composition: f.(c.(playerCardsValue IS average) AND c.(dealerCardValue IS low)) -> ('decision', 'stand', '1.0') , output variable: 'decision' with term: 'stand'\n", - " ** Rule composition: f.(c.(playerCardsValue IS average) AND c.(dealerCardValue IS high)) -> ('decision', 'hit', '1.0') , output variable: 'decision' with term: 'hit'\n", - " ** Rule composition: f.(c.(playerCardsValue IS average) AND f.(c.(dealerCardValue IS average) AND c.(countedCardsValue IS low))) -> ('decision', 'hit', '1.0') , output variable: 'decision' with term: 'hit'\n", - " * Indices: {'stand': 2, 'hit': 1}\n", - " * Weighted values: 1913.98\tValues: 152.62\tCoG: 12.54\n", - "{'decision': 12.540414715943523}\n" - ] - }, { "data": { "text/plain": [ - "'hit'" + "'stand'" ] }, - "execution_count": 6, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# dodatkowy argument określający liczbę kart gracza - w przypadku rozpoczęcia rozgrywki możliwa jest decyzja o podwojeniu\n", - "playerCardsNum = 3\n", - "\n", - "FS = FuzzySystem(show_banner=False)\n", - "\n", - "FS.add_linguistic_variable(\"dealerCardValue\", LinguisticVariable([\n", - " TriangleFuzzySet(0,0,6, term=\"low\"),\n", - " TriangleFuzzySet(4,6,8, term=\"average\"),\n", - " TriangleFuzzySet(6,11,11, term=\"high\")], \n", - " universe_of_discourse=[0, 11]))\n", - "\n", - "FS.add_linguistic_variable(\"playerCardsValue\", LinguisticVariable([\n", - " TriangleFuzzySet(0,0,12, term=\"low\"),\n", - " TriangleFuzzySet(11,14,17, term=\"average\"),\n", - " TriangleFuzzySet(12,21,21, term=\"high\")], \n", - " universe_of_discourse=[0, 21]))\n", - "\n", - "FS.add_linguistic_variable(\"countedCardsValue\", LinguisticVariable([\n", - " TriangleFuzzySet(-20,-20,0, term=\"low\"),\n", - " TriangleFuzzySet(-5,0,5, term=\"average\"),\n", - " TriangleFuzzySet(0,20,20, term=\"high\")], \n", - " universe_of_discourse=[-20, 20]))\n", - "\n", - "\n", - "O1 = TriangleFuzzySet(0,0,13, term=\"doubleDown\")\n", - "O2 = TriangleFuzzySet(0,13,25, term=\"hit\")\n", - "O3 = TriangleFuzzySet(13,25,25, term=\"stand\")\n", - "FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2, O3], universe_of_discourse=[0, 25]))\n", - "\n", - "\n", - "if playerCardsNum == 2:\n", - " FS.add_rules([\n", - " \"IF (playerCardsValue IS low) THEN (decision IS doubleDown)\",\n", - " \"IF (playerCardsValue IS average) AND (dealerCardValue IS high) THEN (decision IS doubleDown)\",\n", - " \"IF (playerCardsValue IS high) THEN (decision IS stand)\",\n", - " \"IF (playerCardsValue IS average) AND (dealerCardValue IS average) THEN (decision IS stand)\",\n", - " \"IF (playerCardsValue IS average) AND (dealerCardValue IS average) THEN (decision IS doubleDown)\"\n", - " ])\n", - " \n", - "else: \n", - " FS.add_rules([\n", - " \"IF (playerCardsValue IS high) THEN (decision IS stand)\",\n", - " \"IF (playerCardsValue IS low) THEN (decision IS hit)\",\n", - " \"IF (playerCardsValue IS average) AND (dealerCardValue IS low) THEN (decision IS stand)\",\n", - " \"IF (playerCardsValue IS average) AND (dealerCardValue IS high) THEN (decision IS hit)\",\n", - " \"IF (playerCardsValue IS average) AND (dealerCardValue IS average) AND (countedCardsValue IS low) THEN (decision IS hit)\",\n", - " ])\n", - " \n", - " \n", - "FS.set_variable(\"dealerCardValue\", 4) \n", - "FS.set_variable(\"playerCardsValue\", 10)\n", - "FS.set_variable(\"countedCardsValue\", 0)\n", - "\n", - "result = FS.inference(verbose=True)\n", - "print(result)\n", - "decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", - "endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", - "endDecision" + "getHardHandDecision(4, 10, 0, 2)" ] }, { @@ -326,93 +365,84 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 25, "id": "878e6c15", "metadata": {}, + "outputs": [], + "source": [ + "def getSoftHandDecision(dealerCard, playerCardsVal, countedCardsVal, playerCardsNum):\n", + " \n", + " FS = FuzzySystem(show_banner=False)\n", + "\n", + " FS.add_linguistic_variable(\"dealerCardValue\", LinguisticVariable([\n", + " TriangleFuzzySet(0,0,6, term=\"low\"),\n", + " TriangleFuzzySet(4,6,8, term=\"average\"),\n", + " TriangleFuzzySet(6,11,11, term=\"high\")], \n", + " universe_of_discourse=[0, 11]))\n", + "\n", + " FS.add_linguistic_variable(\"playerCardValue\", LinguisticVariable([\n", + " TriangleFuzzySet(0,0,5, term=\"low\"),\n", + " TriangleFuzzySet(4,6,8, term=\"average\"),\n", + " TriangleFuzzySet(7,9,9, term=\"high\")], \n", + " universe_of_discourse=[0, 9]))\n", + "\n", + " FS.add_linguistic_variable(\"countedCardsValue\", LinguisticVariable([\n", + " TriangleFuzzySet(-20,-20,0, term=\"low\"),\n", + " TriangleFuzzySet(-5,0,5, term=\"average\"),\n", + " TriangleFuzzySet(0,20,20, term=\"high\")], \n", + " universe_of_discourse=[-20, 20]))\n", + "\n", + "\n", + " O1 = TriangleFuzzySet(0,0,13, term=\"double down\")\n", + " O2 = TriangleFuzzySet(0,13,25, term=\"hit\")\n", + " O3 = TriangleFuzzySet(13,25,25, term=\"stand\")\n", + " FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2, O3], universe_of_discourse=[0, 25]))\n", + "\n", + " if playerCardsNum == 2:\n", + " FS.add_rules([\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) THEN (decision IS double down)\",\n", + " \"IF (playerCardValue IS high) THEN (decision IS Stand)\",\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS high) THEN (decision IS hit)\",\n", + " \"IF (playerCardValue IS low) AND (dealerCardValue IS low) THEN (decision IS hit)\",\n", + " ])\n", + " else:\n", + " FS.add_rules([\n", + " \"IF (playerCardValue IS high) THEN (decision IS Stand)\",\n", + " \"IF (playerCardValue IS low) THEN (decision IS hit)\",\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS high) THEN (decision IS Hit)\",\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) AND (countedCardsValue IS high) THEN (decision IS Stand)\",\n", + " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) AND (countedCardsValue IS low) THEN (decision IS Hit)\"\n", + " ])\n", + "\n", + " FS.set_variable(\"dealerCardValue\", dealerCard) \n", + " FS.set_variable(\"playerCardValue\", playerCardsVal)\n", + " FS.set_variable(\"countedCardsValue\", playerCardsNum)\n", + "\n", + " result = FS.inference()\n", + " decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", + " endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", + " return endDecision" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "0acde55b", + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " * Processing output for variable 'decision'\n", - " whose universe of discourse is: [0, 25]\n", - " contains the following fuzzy sets: [, , ]\n", - " ** Rule composition: c.(playerCardValue IS high) -> ('decision', 'Stand', '1.0') , output variable: 'decision' with term: 'Stand'\n", - " ** Rule composition: c.(playerCardValue IS low) -> ('decision', 'hit', '1.0') , output variable: 'decision' with term: 'hit'\n", - " ** Rule composition: f.(c.(playerCardValue IS average) AND c.(dealerCardValue IS high)) -> ('decision', 'Hit', '1.0') , output variable: 'decision' with term: 'Hit'\n", - " ** Rule composition: f.(c.(playerCardValue IS average) AND f.(c.(dealerCardValue IS average) AND c.(countedCardsValue IS high))) -> ('decision', 'Stand', '1.0') , output variable: 'decision' with term: 'Stand'\n", - " ** Rule composition: f.(c.(playerCardValue IS average) AND f.(c.(dealerCardValue IS average) AND c.(countedCardsValue IS low))) -> ('decision', 'Hit', '1.0') , output variable: 'decision' with term: 'Hit'\n", - " * Indices: {'Stand': -1, 'hit': 1, 'Hit': -1}\n", - " * Weighted values: 3662.59\tValues: 180.07\tCoG: 20.34\n", - "{'decision': 20.339814678947857}\n" - ] - }, { "data": { "text/plain": [ "'stand'" ] }, - "execution_count": 15, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# dodatkowy argument określający liczbę kart gracza - w przypadku rozpoczęcia rozgrywki możliwa jest decyzja o podwojeniu\n", - "playerCardsNum = 3\n", - "\n", - "FS = FuzzySystem(show_banner=False)\n", - "\n", - "FS.add_linguistic_variable(\"dealerCardValue\", LinguisticVariable([\n", - " TriangleFuzzySet(0,0,6, term=\"low\"),\n", - " TriangleFuzzySet(4,6,8, term=\"average\"),\n", - " TriangleFuzzySet(6,11,11, term=\"high\")], \n", - " universe_of_discourse=[0, 11]))\n", - "\n", - "FS.add_linguistic_variable(\"playerCardValue\", LinguisticVariable([\n", - " TriangleFuzzySet(0,0,5, term=\"low\"),\n", - " TriangleFuzzySet(4,6,8, term=\"average\"),\n", - " TriangleFuzzySet(7,9,9, term=\"high\")], \n", - " universe_of_discourse=[0, 9]))\n", - "\n", - "FS.add_linguistic_variable(\"countedCardsValue\", LinguisticVariable([\n", - " TriangleFuzzySet(-20,-20,0, term=\"low\"),\n", - " TriangleFuzzySet(-5,0,5, term=\"average\"),\n", - " TriangleFuzzySet(0,20,20, term=\"high\")], \n", - " universe_of_discourse=[-20, 20]))\n", - "\n", - "\n", - "O1 = TriangleFuzzySet(0,0,13, term=\"doubleDown\")\n", - "O2 = TriangleFuzzySet(0,13,25, term=\"hit\")\n", - "O3 = TriangleFuzzySet(13,25,25, term=\"stand\")\n", - "FS.add_linguistic_variable(\"decision\", LinguisticVariable([O1, O2, O3], universe_of_discourse=[0, 25]))\n", - "\n", - "if playerCardsNum == 2:\n", - " FS.add_rules([\n", - " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) THEN (decision IS doubleDown)\",\n", - " \"IF (playerCardValue IS high) THEN (decision IS Stand)\",\n", - " \"IF (playerCardValue IS average) AND (dealerCardValue IS high) THEN (decision IS hit)\",\n", - " \"IF (playerCardValue IS low) AND (dealerCardValue IS low) THEN (decision IS hit)\",\n", - " ])\n", - "else:\n", - " FS.add_rules([\n", - " \"IF (playerCardValue IS high) THEN (decision IS Stand)\",\n", - " \"IF (playerCardValue IS low) THEN (decision IS hit)\",\n", - " \"IF (playerCardValue IS average) AND (dealerCardValue IS high) THEN (decision IS Hit)\",\n", - " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) AND (countedCardsValue IS high) THEN (decision IS Stand)\",\n", - " \"IF (playerCardValue IS average) AND (dealerCardValue IS average) AND (countedCardsValue IS low) THEN (decision IS Hit)\"\n", - " ])\n", - "\n", - "FS.set_variable(\"dealerCardValue\", 2) \n", - "FS.set_variable(\"playerCardValue\", 8)\n", - "FS.set_variable(\"countedCardsValue\", 0)\n", - "\n", - "result = FS.inference(verbose=True)\n", - "print(result)\n", - "decision_terms = [(i.get_term(), FS.get_fuzzy_set('decision', i.get_term()).get_value(result['decision'])) for i in FS.get_fuzzy_sets('decision')]\n", - "endDecision = max(decision_terms, key=lambda item:item[1])[0]\n", - "endDecision" + "getSoftHandDecision(2, 8, 0, 3)" ] }, {