diff --git a/Project.ipynb b/Project.ipynb index b1dbcc5..60a5484 100644 --- a/Project.ipynb +++ b/Project.ipynb @@ -9,68 +9,5048 @@ "\n", "### Description\n", "\n", - "The [Prisoner's Dilemma](https://en.wikipedia.org/wiki/Prisoner%27s_dilemma) (PD) is a classical game analyzed in game theory, which is widely used to (attempt to) model social/economical interaction. It's a \"dilemma\" as, if exploited to explain the emergence of altruism in human or in general animal society, it fails badly at a first glance.\n", + "The Prisoner’s Dilemma (PD) is a very well known Game Theory case of study, which is widely used to (attempt to) model social/economical interaction. It's a \"dilemma\" as, if exploited to explain the emergence of altruism in human or in general animal society, it fails badly at a first glance.\n", "\n", - "The classical situation-representation of the PD is that of two prisoners whose conviction depends on their mutual cooperation. It is easier understood though if illustrated in terms of a trade-off game (closed bag exachange):\n", + "In the literature it can be found exposed in different interpretations, and we are going to follow the following one:\n", "\n", "*Two people meet and exchange closed bags, with the understanding that one of them contains money, and the other contains a purchase. Either player can choose to honor the deal by putting into his or her bag what he or she agreed, or he or she can defect by handing over an empty bag.*\n", "\n", - "It is obvious that for both players the winning strategy is to NOT cooperate.\n", + "\n", "\n", - "Things changes when the interaction between the two individuals is iterated, in that case a more altruist attitude (strategy) is expected to emerge. The goal of this project is to test this hypothesis.\n", - "\n", - "Mathematically the PD can be expressed with very basic linear algebra. The key component is the **Payoff matrix** $M$, which quantify the reward each player gets depending on whether she cooperated or not (defect):\n", + "In this project we will use the following basic linear algebra framework in order to obtain the players' rewards. Given the payoff matrix $M$, that quantifies the revenue that each player gets depending on whether he cooperates or not, the $i$ player reward can be computed as:\n", "\n", "$$\n", - "M = \n", - "\\begin{pmatrix} \n", - "R & S \\\\\n", - "T & P \n", - "\\end{pmatrix}\n", + "r_i = u_i^T M u_{-i}\n", "$$\n", "\n", - "with $T,R,S,P$ integers that satisfy the following conditions:\n", + "where:\n", + "\\begin{gather*}\n", + " M = \n", + " \\begin{pmatrix}\n", + " 2 & 0\\\\\n", + " 3 & 1\n", + " \\end{pmatrix}\\\\\\\\\n", + " u_{i} = \\text{i-th player move} \\\\\n", + " u_{-i} = \\text{adversary's move} \\\\\\\\\n", + " u_x = \n", + " \\begin{cases}\n", + " \\begin{pmatrix}\n", + " 1 & 0\n", + " \\end{pmatrix}^\\intercal \\quad \\text{when player $x$ collaborates}\n", + " \\\\\\\\\n", + " \\begin{pmatrix}\n", + " 0 & 1\n", + " \\end{pmatrix}^\\intercal \\quad \\text{when player $x$ defects}\n", + " \\end{cases}\n", + "\\end{gather*}\n", "\n", - "$$\n", - "T>R>P>S; \\quad 2R > T+S\n", - "$$\n", + "
\n", "\n", - "for example $T=3$, $R=2$, $P=1$ and $S=0$, or $T=5$, $R=3$, $P=2$, $S=0$. Each player choice (move) can be represented by one of the two axis in ${\\rm I\\!R}^2$, i.e. $u_C=\\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$ or $u_D=\\begin{pmatrix} 0 \\\\ 1 \\end{pmatrix}$, where the first coordinate stands for *Cooperate* and the second for *Defect*. Being $u_1$ and $u_2$ their rewards $r_1$ and $r_2$ can be computed then as:\n", "\n", - "$$\n", - "r_1 = u_1^T M u_2\n", - "\\quad\n", - "\\quad\n", - "r_2 = u_2^T M u_1\n", - "$$\n", + "It is obvious that for both players the winning strategy is to not cooperate. In fact defecting is the strincly dominant strategy and this leads to the result that the expected game outcome will be that both players decide to defect, and this outcome will be a Nash Equilibrium.\n", + "\n", + "But we can notice that the reward obtained by each player when they both decide to collaborate would be higher, in fact this outcome would be Pareto Efficient, namely there would be no way in the whole game that a player can improve his reward without the other player reward get worse.\n", + "\n", + "Things changes when the interaction between the two individuals is iterated, in that case a more altruist attitude (strategy) is expected to emerge. The goal of this project is to test this hypothesis.\n", "\n", "In an Iterative Prisoner's Dilemma (IPD), two players play prisoner's dilemma more than once in succession and they remember previous actions of their opponent and change their strategy accordingly. The winning strategy is the one which yields to a larger reward at the end of the IPD.\n", "\n", - "The strategy can be represented as a function which outputs either $u_C$ or $u_D$. Such function can depend on the opponent's history of moves, her on history of moves, on the number of moves played till that moment and so on, but it can only be based on a probability density function. Possible strategies are:\n", + "### Assignments\n", + "\n", + "* Implement a simple IPD between two players implementing two given strategies. Study the evolution along the tournament confronting different strategies; study the overall outcome in the different configurations. \n", + "* Implement a multiple players IPD (MPIPD) where several strategies play against each other in a roud-robin scheme\n", + "* Iterate what done in the previous task (repeated MPIPD, rMPIPD) by increasing the population implementing a given strategy depending on the results that strategy achieved in the previous iteration\n", + "* (*difficult*) Implement a rMPIPD where strategies are allowed to mutate. The goal is to simulate the effect of genetic mutations and the effect of natura selection. A parameter (gene) should encode the attidue of an individual to cooperate, such gene can mutate randomly and the corresponding phenotype should compete in the MPIPD such that the best-fitted is determined. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import itertools\n", + "from itertools import compress\n", + "import copy\n", + "import time\n", + "from IPython import display" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Abstract class Player" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from abc import ABC, abstractmethod\n", + "\n", + "class Player(ABC):\n", + "\n", + " def __init__(self, r_history=[], move_history=[]):\n", + " self.r_history = copy.deepcopy(r_history)\n", + " self.move_history = copy.deepcopy(move_history)\n", + " \n", + " def append_reward(self, reward):\n", + " self.r_history.append(reward)\n", + " \n", + " # default reset, it will be overridden in 2 classes\n", + " def p_reset(self):\n", + " self.r_history = []\n", + " self.move_history = []\n", + " \n", + " @abstractmethod\n", + " def move(self):\n", + " pass\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Player class extensions\n", + "\n", + "The player strategy can be represented as a function which outputs either $u_C$ or $u_D$. Such function can depend on the opponent's history of moves, on his history of moves, on the number of moves played till that moment and so on.
\n", + "The strategies that we implemented are:\n", "\n", "* **Nice guy**: always cooperate (the function's output is always $u_D$)\n", "* **Bad guy**: always defect \n", "* **Mainly nice**: randomly defect $k\\%$ of the times and cooperate $100-k\\%$, $k<50$\n", "* **Mainly bad**: randomly defect $k\\%$ of the times and cooperate $100-k\\%$, $k>50$\n", - "* **tit-for-tat**: start by cooperating, then repeat what the opponent has done in the previous move \n", + "* **tit-for-tat**: start by cooperating, then repeat what the opponent has done in the previous move\n", + "* **Grim-Trigger**: start by cooperating, than keep cooperating until any player decides to defect; from that moment on, keep defecting\n", + "* **LookBackPlayer**: use past rewards in order to decide the next move." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class NiceGuy(Player):\n", + " \"\"\"\n", + " Player that always outputs the cooperate move\n", + " \"\"\"\n", + " def __init__(self, r_history=[], move_history=[]):\n", + " Player.__init__(self, r_history, move_history)\n", + " self.label = \"NiceGuy\"\n", + " \n", + " def move(self):\n", + " uc = [1,0]\n", + " self.move_history.append(uc)\n", + " return uc\n", + " \n", + " \n", + "class BadGuy(Player):\n", + " \"\"\"\n", + " Player that always outputs the defect move\n", + " \"\"\"\n", + " def __init__(self, r_history=[], move_history=[]):\n", + " Player.__init__(self, r_history, move_history)\n", + " self.label = \"BadGuy\"\n", + " \n", + " def move(self):\n", + " ud = [0,1]\n", + " self.move_history.append(ud)\n", + " return ud\n", + " \n", "\n", - "Many more and much more complex strategies can be implemented. The strategy can even change during the IPD.\n", + " \n", + "class KBadGuy(Player):\n", + " \"\"\"\n", + " Player that outputs the defect move \n", + " with probability k/100\n", + " \"\"\"\n", + " def __init__(self, k, r_history=[], move_history=[]):\n", + " Player.__init__(self, r_history, move_history)\n", + " self.k = k\n", + " self.label = str(k) + \"BadGuy\"\n", + " \n", + " def move(self):\n", + " uc = [1,0]\n", + " ud = [0,1]\n", + " if np.random.rand() > 1-(self.k/100):\n", + " u = ud\n", + " else:\n", + " u = uc \n", + " self.move_history.append(u)\n", + " return u\n", + " \n", + " \n", + "class Tit4Tat(Player):\n", + " \"\"\"\n", + " Player, the first move is cooperate, \n", + " the subsequent moves are the same as the last \n", + " element in self.input_history\n", + " \"\"\"\n", + " def __init__(self, r_history=[], move_history=[], input_history=[]):\n", + " Player.__init__(self, r_history, move_history)\n", + " self.input_history = copy.deepcopy(input_history)\n", "\n", + " def append_input(self, inp):\n", + " self.input_history.append(inp)\n", "\n", - "### Assignments\n", + " def move(self):\n", + " if len(self.input_history) == 0:\n", + " u = [1,0]\n", + " else:\n", + " u = self.input_history[-1]\n", + " self.move_history.append(u)\n", + " return u\n", "\n", - "* Implement a simple IPD between two players implementing two given strategies. Study the evolution along the tournament confronting different strategies; study the overall outcome in the different configurations. \n", - "* Implement a multiple players IPD (MPIPD) where several strategies play against each other in a roud-robin scheme\n", - "* Iterate what done in the previous task (repeated MPIPD, rMPIPD) by increasing the population implementing a given strategy depending on the results that strategy achieved in the previous iteration\n", - "* (*difficult*) Implement a rMPIPD where strategies are allowed to mutate. The goal is to simulate the effect of genetic mutations and the effect of natura selection. A parameter (gene) should encode the attidue of an individual to cooperate, such gene can mutate randomly and the corresponding phenotype should compete in the MPIPD such that the best-fitted is determined. \n" + " \n", + "class Tit4TatMP(Player):\n", + " \"\"\"\n", + " Player that starts with cooperate and then cooperates only if a fraction of players\n", + " above or equal c_treshold has cooperated.\n", + " \"\"\"\n", + " def __init__(self, c_threshold=0.5, r_history=[], move_history=[], input_history=[]):\n", + " Player.__init__(self, r_history, move_history)\n", + " self.input_history = copy.deepcopy(input_history)\n", + " self.c_threshold = c_threshold\n", + " self.label = str(c_threshold) + \"Tit4TatMP\"\n", + "\n", + " def append_input(self, m_inp):\n", + " \"\"\"\n", + " multiplayer input m_inp should be an array or list with N rows for N players,\n", + " in every row the list [1,0] or [0,1], it also works with [1] or [0].\n", + " The number of input players can change. \n", + " \"\"\"\n", + " self.input_history.append(m_inp)\n", + " \n", + " def move(self):\n", + " if len(self.input_history) == 0:\n", + " u = [1,0]\n", + " else:\n", + " last_inp = np.array(self.input_history[-1])[:,0]\n", + " if np.sum(last_inp)/np.shape(last_inp)[0] >= self.c_threshold:\n", + " u = [1,0]\n", + " else:\n", + " u = [0,1]\n", + " self.move_history.append(u)\n", + " return u\n", + " \n", + " # override\n", + " def p_reset(self):\n", + " self.r_history = []\n", + " self.move_history = []\n", + " self.input_history = []\n", + " \n", + " \n", + "class GrimTriggerMP(Player):\n", + " \"\"\"\n", + " Player that cooperates until a numbers of players >= d_threshold defect in a turn,\n", + " from now on he defects in every turn. \n", + " Setting d_threshold=0 means that it needs only one defecting player\n", + " to start defecting itself.\n", + " \"\"\"\n", + " def __init__(self, d_threshold=0.5, r_history=[], move_history=[], input_history=[]):\n", + " Player.__init__(self, r_history, move_history) \n", + " self.input_history = copy.deepcopy(input_history)\n", + " self.d_threshold = d_threshold\n", + " self.defected = False\n", + " self.label = str(d_threshold) + \"GrimTriggerMP\"\n", + " \n", + " def append_input(self, m_inp):\n", + " \"\"\"\n", + " multiplayer input m_inp should be an array or list with N rows for N players,\n", + " in every row the list [1,0] or [0,1], it also works with [1] or [0].\n", + " The number of input players can change. \n", + " \"\"\"\n", + " self.input_history.append(m_inp)\n", + " \n", + " def move(self): \n", + " if not self.defected and len(self.input_history) > 0:\n", + " # check if it has been defected in the last turn\n", + " last_inp = last_inp = np.array(self.input_history[-1])[:,0]\n", + " if np.sum(last_inp)/np.shape(last_inp)[0] < 1 - self.d_threshold:\n", + " self.defected = True\n", + " \n", + " if not self.defected:\n", + " u = [1,0]\n", + " else:\n", + " u = [0,1]\n", + " self.move_history.append(u)\n", + " return u\n", + " \n", + " # override\n", + " def p_reset(self):\n", + " self.r_history = []\n", + " self.move_history = []\n", + " self.input_history = []\n", + " self.defected = False\n", + "\n", + " \n", + "class LookBackPlayer(Player):\n", + " \"\"\"\n", + " Player that use past rewards in order to decide the next move.\n", + " \"\"\"\n", + " def __init__(self, bias, r_history=[], move_history=[], delta = 1):\n", + " \"\"\"\n", + " bias is added to the past rewards during the move decision\n", + " if bias is in range [-3,0] it can change the behaviour of the player\n", + " \"\"\"\n", + " Player.__init__(self, r_history, move_history) \n", + " self.bias = bias\n", + " self.delta = delta\n", + " self.label = str(delta) + \"LookBackPlayer\"\n", + " \n", + " def move(self): \n", + " # random move if its the first move\n", + " if len(self.r_history) == 0:\n", + " if np.random.rand() >= 0.5:\n", + " u = [1,0]\n", + " else:\n", + " u = [0,1]\n", + " else: \n", + " move_cat_history = np.array(self.move_history)\n", + " deltas = np.array([self.delta**i for i in range(len(move_cat_history))])\n", + " deltas = np.hstack((deltas,deltas))\n", + " r_cat_history = np.concatenate((np.array([self.r_history]).T,np.array([self.r_history]).T), axis=1)\n", + " sum_cat_r = np.sum((r_cat_history + self.bias) * move_cat_history, axis=0)\n", + "\n", + " if sum_cat_r[0]>sum_cat_r[1]:\n", + " # cooperate \n", + " u = [1,0]\n", + " elif sum_cat_r[0]= 0.5:\n", + " u = [1,0]\n", + " else:\n", + " u = [0,1]\n", + " \n", + " self.move_history.append(u)\n", + " return u" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Examples of players classes\n", + "Simple example about player initialization and methods " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 0]\n", + "[[1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0]]\n", + "[]\n" + ] + } + ], + "source": [ + "nice_guy = NiceGuy()\n", + "\n", + "for i in range(10):\n", + " u = nice_guy.move()\n", + "print(u)\n", + "\n", + "print(nice_guy.move_history)\n", + "print(nice_guy.r_history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1]\n", + "[[0, 1], [0, 1], [0, 1], [1, 0], [1, 0], [1, 0], [0, 1], [0, 1], [0, 1], [0, 1]]\n" + ] + } + ], + "source": [ + "pino = KBadGuy(30)\n", + "for i in range(10):\n", + " u = pino.move()\n", + "print(u)\n", + "print(pino.move_history)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first move [1, 0]\n", + "[[1, 0]]\n", + "second move (mirrored) [0, 1]\n" + ] + } + ], + "source": [ + "t4t_guy = Tit4Tat()\n", + "u = t4t_guy.move()\n", + "print(\"first move \",u)\n", + "\n", + "print(t4t_guy.move_history)\n", + "t4t_guy.input_history.append([0,1])\n", + "u = t4t_guy.move()\n", + "print(\"second move (mirrored) \", u)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first move [1, 0]\n", + "second move [0, 1]\n", + "third move [1, 0]\n" + ] + } + ], + "source": [ + "t4t_m = Tit4TatMP(c_threshold=0.5)\n", + "\n", + "u = t4t_m.move()\n", + "print(\"first move \", u)\n", + "\n", + "m_inp = [[1,0], [0,1], [0,1]]\n", + "\n", + "t4t_m.append_input(m_inp)\n", + "\n", + "u = t4t_m.move()\n", + "print(\"second move \", u)\n", + "\n", + "m_inp = [[1], [0], [0], [1], [1]]\n", + "t4t_m.append_input(m_inp)\n", + "\n", + "u = t4t_m.move()\n", + "print(\"third move \", u)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first move is cooperate [1, 0]\n", + "second move [0, 1]\n", + "third move [0, 1]\n", + "fourth move [0, 1]\n" + ] + } + ], + "source": [ + "# with d_threshold=0 it needs one defecting player to change\n", + "grim_trigger = GrimTriggerMP(d_threshold=0)\n", + "u = grim_trigger.move()\n", + "print(\"first move is cooperate \", u)\n", + "\n", + "# one defector over 4 other players\n", + "m_inp = [[1,0], [1,0], [1,0], [0,1]]\n", + "grim_trigger.append_input(m_inp)\n", + "\n", + "u = grim_trigger.move()\n", + "print(\"second move \", u)\n", + "\n", + "m_inp = [[1], [1], [1], [1]]\n", + "grim_trigger.append_input(m_inp)\n", + "\n", + "u = grim_trigger.move()\n", + "print(\"third move \", u)\n", + "\n", + "u = grim_trigger.move()\n", + "print(\"fourth move \", u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 1: 2 players IPD\n", + "Implement a simple IPD between two players implementing two given strategies. Study the evolution along the tournament confronting different strategies; study the overall outcome in the different configurations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## KBadGuy vs Tit4Tat\n", + "As Tit4Tat copies the KBadGuy, they tend to finish with similar rewards." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tit4Tat final reward 83\n", + "KBadGuy final reward 83\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "# initialize players instances\n", + "p1 = Tit4Tat()\n", + "p2 = KBadGuy(40)\n", + "\n", + "# game loop\n", + "for i in range(50):\n", + " u1 = p1.move()\n", + " u2 = p2.move()\n", + " #append p2 move, necessary for the tit4tat\n", + " p1.append_input(u2)\n", + " \n", + " p1.append_reward(np.array(u1) @ M @ np.array(u2).T)\n", + " p2.append_reward(np.array(u2) @ M @ np.array(u1).T)\n", + "\n", + "# visualization\n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(p1.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p1.r_history)), p1.r_history, label=(type(p1).__name__),)\n", + "ax[0].plot(p2.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p2.r_history)), p2.r_history, label=(type(p2).__name__),)\n", + "ax[0].legend()\n", + "ax[0].set_yticks(range(0,4))\n", + "ax[0].set_xlabel(\"game\")\n", + "ax[0].set_ylabel(\"reward\")\n", + "ax[0].set_title(\"Reward for every move\")\n", + "\n", + "ax[1].plot(np.cumsum(p1.r_history), label=(type(p1).__name__))\n", + "ax[1].plot(np.cumsum(p2.r_history), label=(type(p2).__name__))\n", + "ax[1].legend()\n", + "ax[0].grid(linestyle=\":\")\n", + "ax[1].set_xlabel(\"game\")\n", + "ax[1].set_ylabel(\"cumulative reward\")\n", + "ax[1].set_title(\"Cumulative reward\")\n", + "ax[1].grid(linestyle=\":\")\n", + "\n", + "\n", + "print(f\"{type(p1).__name__} final reward {sum(p1.r_history)}\")\n", + "print(f\"{type(p2).__name__} final reward {sum(p2.r_history)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tit4Tat vs Tit4Tat\n", + "They start by cooperating and continue to cooperate. They finish with the higher overall reward." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tit4Tat final reward 200\n", + "Tit4Tat final reward 200\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "p1 = Tit4Tat()\n", + "p2 = Tit4Tat()\n", + "\n", + "# game loop\n", + "for i in range(100):\n", + " u1 = p1.move()\n", + " p2.append_input(u1)\n", + " \n", + " u2 = p2.move()\n", + " p1.append_input(u2)\n", + " \n", + " p1.append_reward(np.array(u1) @ M @ np.array(u2).T)\n", + " p2.append_reward(np.array(u2) @ M @ np.array(u1).T)\n", + " \n", + "# visualization \n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(p1.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p1.r_history)), p1.r_history, label=(type(p1).__name__),)\n", + "ax[0].plot(p2.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p2.r_history)), p2.r_history, label=(type(p2).__name__),)\n", + "ax[0].legend()\n", + "ax[0].set_yticks(range(0,4))\n", + "ax[0].grid(linestyle=\":\")\n", + "ax[0].set_xlabel(\"game\")\n", + "ax[0].set_ylabel(\"reward\")\n", + "ax[0].set_title(\"Reward for every move\")\n", + "\n", + "ax[1].plot(np.cumsum(p1.r_history), label=(type(p1).__name__))\n", + "ax[1].plot(np.cumsum(p2.r_history), label=(type(p2).__name__))\n", + "ax[1].legend()\n", + "ax[1].set_xlabel(\"game\")\n", + "ax[1].set_ylabel(\"cumulative reward\")\n", + "ax[1].set_title(\"Cumulative reward\")\n", + "ax[1].grid(linestyle=\":\")\n", + "\n", + "\n", + "print(f\"{type(p1).__name__} final reward {sum(p1.r_history)}\")\n", + "print(f\"{type(p2).__name__} final reward {sum(p2.r_history)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## KBadGuy vs KBadGuy\n", + "The KBadGuy with higher k parameter tends to win." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "player1 final reward 68\n", + "player2 final reward 107\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "# initialize players instances\n", + "p1 = KBadGuy(10)\n", + "p2 = KBadGuy(30)\n", + "\n", + "# game loop\n", + "for i in range(50):\n", + " u1 = p1.move() \n", + " u2 = p2.move()\n", + " \n", + " p1.append_reward(np.array(u1) @ M @ np.array(u2).T)\n", + " p2.append_reward(np.array(u2) @ M @ np.array(u1).T)\n", + " \n", + "# visualization\n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(p1.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p1.r_history)), p1.r_history, label=(\"p1\"),)\n", + "ax[0].plot(p2.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p2.r_history)), p2.r_history, label=(\"p2\"),)\n", + "ax[0].legend()\n", + "ax[0].set_yticks(range(0,4))\n", + "ax[0].set_xlabel(\"game\")\n", + "ax[0].set_ylabel(\"reward\")\n", + "ax[0].set_title(\"Reward for every move\")\n", + "ax[0].grid(linestyle=\":\")\n", + "\n", + "ax[1].plot(np.cumsum(p1.r_history), label=(\"p1\"))\n", + "ax[1].plot(np.cumsum(p2.r_history), label=(\"p2\"))\n", + "ax[1].legend()\n", + "ax[1].set_xlabel(\"game\")\n", + "ax[1].set_ylabel(\"cumulative reward\")\n", + "ax[1].set_title(\"Cumulative reward\")\n", + "ax[1].grid(linestyle=\":\")\n", + "\n", + "\n", + "print(\"player1 final reward \", sum(p1.r_history))\n", + "print(\"player2 final reward \", sum(p2.r_history))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explore the entire range of KBadGuys" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can generalize the previous cell. The entire range of the KBadGuys comprends the NiceGuy (with *k*=0), the BadGuy (with *k*=100) and every strategy inbetween, so we run every possible game while varying the *k* in the two players. We also want to analize the connection between the two *k* values and the overall reward value.\n", + "\n", + "Since every tournament is defined on the variation on two parameters we need to display the reward in a figure using two axis and color. With this result we can prove that the higher overall reward is obtained when the two players have a low *k* parameter.\n", + "So the higher individual reward is obtained with a defective strategy, but the higher group reward, intended as the summation of the individual rewards, is obtained with a cooperative behaviour on both players." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "k_p1 = np.arange(0, 101, 10)\n", + "k_schedule = np.zeros((121,2))\n", + "\n", + "for i in range(0,121,11):\n", + " k_schedule[i:i+11, 0] = k_p1[i//11]\n", + " k_schedule[i:i+11, 1] = k_p1[:]\n", + "\n", + "\n", + "reward_history = []\n", + "for n in range(np.shape(k_schedule)[0]):\n", + " reward_game = [0,0]\n", + " p1 = KBadGuy(k_schedule[n,0])\n", + " p2 = KBadGuy(k_schedule[n,1])\n", + " for i in range(100): \n", + " u1 = p1.move()\n", + " u2 = p2.move()\n", + "\n", + " reward1 = np.array(u1) @ M @ np.array(u2).T\n", + " reward2 = np.array(u2) @ M @ np.array(u1).T\n", + " p1.append_reward(reward1)\n", + " p2.append_reward(reward2)\n", + " \n", + " reward_game[0] += reward1\n", + " reward_game[1] += reward2\n", + " \n", + " reward_history.append(reward_game)\n", + " \n", + "reward_history = np.asarray(reward_history)\n", + "reward_2d = np.reshape(reward_history, (11,11,2))\n", + "\n", + "# visualization \n", + "# fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "# ax[0].plot(reward_history[:,0], label=(\"p1\"))\n", + "# ax[0].plot(reward_history[:,1], label=(\"p2\"))\n", + "# ax[0].legend()\n", + "# ax[0].grid(linestyle=\":\")\n", + "# ax[0].set_title(\"final rewards for the combinations of k\")\n", + "# ax[1].plot(np.sum(reward_history,1), label=(\"p1\"))\n", + "# ax[1].grid(linestyle=\":\")\n", + "# ax[1].set_title(\"Sum of the final reward for both players\")\n", + "\n", + "\n", + "fig, ax = plt.subplots(1,3, figsize = (22,6))\n", + "im0 = ax[0].imshow(reward_2d[:,:,0], origin='lower')\n", + "ax[0].set_xticks(range(11))\n", + "ax[0].set_yticks(range(11))\n", + "ax[0].set_xticklabels(range(0,110,10))\n", + "ax[0].set_yticklabels(range(0,110,10))\n", + "ax[0].set_xlabel(\"p2 k\")\n", + "ax[0].set_ylabel(\"p1 k\")\n", + "ax[0].set_title(\"P1 rewards depending on the combination of k\")\n", + "plt.colorbar(im0, ax=ax[0])\n", + "\n", + "im1 = ax[1].imshow(reward_2d[:,:,1], origin='lower')\n", + "ax[1].set_xticks(range(11))\n", + "ax[1].set_yticks(range(11))\n", + "ax[1].set_xticklabels(range(0,110,10))\n", + "ax[1].set_yticklabels(range(0,110,10))\n", + "ax[1].set_xlabel(\"p2 k\")\n", + "ax[1].set_ylabel(\"p1 k\")\n", + "ax[1].set_title(\"P2 rewards depending on the combination of k\")\n", + "plt.colorbar(im1, ax=ax[1])\n", + "\n", + "im2 = ax[2].imshow(np.sum(reward_2d, 2), origin='lower')\n", + "ax[2].set_xticks(range(11))\n", + "ax[2].set_yticks(range(11))\n", + "ax[2].set_xticklabels(range(0,110,10))\n", + "ax[2].set_yticklabels(range(0,110,10))\n", + "ax[2].set_xlabel(\"p2 k\")\n", + "ax[2].set_ylabel(\"p1 k\")\n", + "ax[2].set_title(\"Sum of P1, P2 rewards\")\n", + "plt.colorbar(im2, ax=ax[2])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introducing the LookBack Player" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The LookBack Player uses the past rewards to choose the best strategy in its next move. It compute the summtion of the rewards obtained for every move and it chooses the one with the higher rewards. During the first move, or when the rewards are equal, it chooses randomly. \n", + "\n", + "We can use a bias that is added to rewards while computing the move decision. This is necessary because with a payoff matrix that has average greater than zero, the LookBack Player tends to simply choose the same move that it has already used from the beginning of the game. So using a bias that is equal to the negative average of the payoff matrix the player decision is not skewed towards the move it has performed more frequently.\n", + "\n", + "We want to see how the LookBack Player performs against a KBadGuy and also if it is able to adopt a cooperative behaviour that maximizes the group reward." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the following game we see that the LookBack Player tends to win against a MainlyNiceGuy, but we will generalize the behaviour against a KBadGuy later." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KBadGuy final reward 14\n", + "LookBackPlayer final reward 122\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "p1 = KBadGuy(40)\n", + "p2 = LookBackPlayer(-1.5)\n", + "\n", + "for i in range(50):\n", + " u1 = p1.move()\n", + " u2 = p2.move()\n", + " \n", + " p1.append_reward(np.array(u1) @ M @ np.array(u2).T)\n", + " p2.append_reward(np.array(u2) @ M @ np.array(u1).T)\n", + " \n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(p1.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p1.r_history)), p1.r_history, label=(type(p1).__name__),)\n", + "ax[0].plot(p2.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p2.r_history)), p2.r_history, label=(type(p2).__name__),)\n", + "ax[0].legend()\n", + "ax[0].grid(linestyle=\":\")\n", + "ax[0].set_yticks(range(0,4))\n", + "ax[0].set_xlabel(\"game\")\n", + "ax[0].set_ylabel(\"reward\")\n", + "ax[0].set_title(\"Reward for every move\")\n", + "\n", + "ax[1].plot(np.cumsum(p1.r_history), label=(type(p1).__name__))\n", + "ax[1].plot(np.cumsum(p2.r_history), label=(type(p2).__name__))\n", + "ax[1].legend()\n", + "ax[1].set_xlabel(\"game\")\n", + "ax[1].set_ylabel(\"cumulative reward\")\n", + "ax[1].set_title(\"Cumulative reward\")\n", + "ax[1].grid(linestyle=\":\")\n", + "\n", + "print(f\"{type(p1).__name__} final reward {sum(p1.r_history)}\")\n", + "print(f\"{type(p2).__name__} final reward {sum(p2.r_history)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LookBack Player vs LookBack Player\n", + "It is interesting to test the performances of a LooKBack Player against another LookBackPlayer. In this case, after few moves, they adopt a cooperative behaviour that maximizes the group reward." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LookBackPlayer1 final reward 193\n", + "LookBackPlayer2 final reward 193\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "p1 = LookBackPlayer(-1.5)\n", + "p2 = LookBackPlayer(-1.5)\n", + "\n", + "for i in range(100):\n", + " u1 = p1.move()\n", + " u2 = p2.move()\n", + " \n", + " p1.append_reward(np.array(u1) @ M @ np.array(u2).T)\n", + " p2.append_reward(np.array(u2) @ M @ np.array(u1).T)\n", + "\n", + " \n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(p1.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p1.r_history)), p1.r_history, label=(\"p1\"),)\n", + "ax[0].plot(p2.r_history, alpha=0.2)\n", + "ax[0].scatter(range(len(p2.r_history)), p2.r_history, label=(\"p2\"),)\n", + "ax[0].legend()\n", + "ax[0].grid(linestyle=\":\")\n", + "ax[0].set_yticks(range(0,4))\n", + "ax[0].set_xlabel(\"game\")\n", + "ax[0].set_ylabel(\"reward\")\n", + "ax[0].set_title(\"Reward for every game\")\n", + "\n", + "ax[1].plot(np.cumsum(p1.r_history), label=(\"p1\"))\n", + "ax[1].plot(np.cumsum(p2.r_history), label=(\"p2\"))\n", + "ax[1].legend()\n", + "ax[1].set_xlabel(\"game\")\n", + "ax[1].set_ylabel(\"cumulative reward\")\n", + "ax[1].set_title(\"Cumulative reward\")\n", + "ax[1].grid(linestyle=\":\")\n", + "\n", + "print(f\"{type(p1).__name__}1 final reward {sum(p1.r_history)}\")\n", + "print(f\"{type(p2).__name__}2 final reward {sum(p2.r_history)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LookBack player against every k bad player\n", + "We want to test the LookBackPlayer performances against every KBadGuy. The LookBack Player it is able to win against every KBadGuy that has a *k* parameter lower than circa *k*=85. \n", + "As before, we see that the group reward is higher when the KBadGuy has a more cooperative behaviour.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "k_p1 = np.arange(0, 101, 10)\n", + "k_schedule = np.arange(101)\n", + "\n", + "reward_history = []\n", + "for n in range(np.shape(k_schedule)[0]):\n", + " reward_game = [0,0]\n", + " p1 = KBadGuy(k_schedule[n])\n", + " p2 = LookBackPlayer(-1.5)\n", + " \n", + " for i in range(100): \n", + " u1 = p1.move()\n", + " u2 = p2.move()\n", + "\n", + " reward1 = np.array(u1) @ M @ np.array(u2).T\n", + " reward2 = np.array(u2) @ M @ np.array(u1).T\n", + " p1.append_reward(reward1)\n", + " p2.append_reward(reward2)\n", + " \n", + " reward_game[0] += reward1\n", + " reward_game[1] += reward2\n", + " \n", + " reward_history.append(reward_game)\n", + " \n", + "reward_history = np.asarray(reward_history)\n", + "# reward_2d = np.reshape(reward_history, (10,10,2))\n", + "\n", + "# visualization \n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(reward_history[:,0], label=(\"KBadGuy\"))\n", + "ax[0].plot(reward_history[:,1], label=(\"LookBackPlayer\"))\n", + "ax[0].legend()\n", + "ax[0].grid(linestyle=\":\")\n", + "ax[0].set_title(\"final rewards for the combinations of k\")\n", + "ax[0].set_xlabel(\"k\")\n", + "ax[0].set_ylabel('final reward')\n", + "\n", + "ax[1].plot(np.sum(reward_history,1), label=(\"p1\"))\n", + "ax[1].grid(linestyle=\":\")\n", + "ax[1].set_title(\"Sum of the final reward for both players\")\n", + "ax[1].set_xlabel(\"k\")\n", + "ax[1].set_ylabel('sum of final rewards')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LookBack player against every k bad player \n", + "We run the previous game multiple times in order to reduce the effect of the randomness and see more clearly the regularities on the games results. We plot the the average reward on 50 runs of the games, and we mark with a shaded area the standard deviation.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Payoff matrix\n", + "M = np.array([[2,0],[3,1]])\n", + "\n", + "k_p1 = np.arange(0, 101, 10)\n", + "k_schedule = np.arange(101)\n", + "\n", + "\n", + "reward_history = []\n", + "std_history =[]\n", + "\n", + "games_per_batch = 50\n", + "for n in range(np.shape(k_schedule)[0]):\n", + " reward_game_batch = [0,0]\n", + " std_history_batch = []\n", + " \n", + " for j in range(games_per_batch):\n", + " reward_game = [0,0]\n", + " p1 = KBadGuy(k_schedule[n])\n", + " p2 = LookBackPlayer(-1.5)\n", + " for i in range(100): \n", + " u1 = p1.move()\n", + " u2 = p2.move()\n", + "\n", + " reward1 = np.array(u1) @ M @ np.array(u2).T\n", + " reward2 = np.array(u2) @ M @ np.array(u1).T\n", + " p1.append_reward(reward1)\n", + " p2.append_reward(reward2)\n", + "\n", + " reward_game[0] += reward1\n", + " reward_game[1] += reward2\n", + " \n", + " std_history_batch.append(reward_game)\n", + " reward_game_batch[0] += reward_game[0]\n", + " reward_game_batch[1] += reward_game[1]\n", + " \n", + " std_history.append(std_history_batch)\n", + " reward_history.append(reward_game_batch)\n", + "\n", + "std_history = np.array(std_history)\n", + "\n", + "\n", + "reward_history = np.asarray(reward_history)/games_per_batch\n", + "\n", + "std = np.std(std_history, axis=1)\n", + "\n", + "std_history_sum = np.sum(std_history, axis=2)\n", + "std_sum =np.std(std_history_sum, axis=1)\n", + "\n", + "reward_history_sum = np.sum(reward_history,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualization \n", + "fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "ax[0].plot(reward_history[:,0], label=(\"KBadGuy\"))\n", + "ax[0].fill_between(range(np.shape(k_schedule)[0]), reward_history[:,0]+std[:,0], reward_history[:,0]-std[:,0], alpha=0.2)\n", + "ax[0].plot(reward_history[:,1], label=(\"LookBackPlayer\"))\n", + "ax[0].fill_between(range(np.shape(k_schedule)[0]), reward_history[:,1]+std[:,1], reward_history[:,1]-std[:,1], alpha=0.2)\n", + "ax[0].legend()\n", + "ax[0].grid(linestyle=\":\")\n", + "ax[0].set_title(\"final rewards for the combinations of k\")\n", + "ax[0].set_xlabel(\"k\")\n", + "ax[0].set_ylabel('final reward')\n", + "\n", + "ax[1].plot(reward_history_sum, label=(\"p1\"))\n", + "ax[1].fill_between(range(np.shape(k_schedule)[0]), reward_history_sum+std_sum, reward_history_sum-std_sum, alpha=0.2)\n", + "ax[1].grid(linestyle=\":\")\n", + "ax[1].set_title(\"Sum of the final reward for both players\")\n", + "ax[1].set_xlabel(\"k\")\n", + "ax[1].set_ylabel('sum of final rewards')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 2: multiplayer IPD\n", + "\n", + "\n", + "In order to extend our game to a N-Players scenario, we started from the normal form matrix proposed in [1]:\n", + "

\n", + "$$\n", + "\\begin{gather*}\n", + " \\text{Number of cooperators among the remaining $n-1$ players}\\\\\n", + " \\text{Player $i$}\n", + " \\begin{pmatrix}\n", + " 0 & 2 & 4 & \\textbf{...} & 2(n-1)\\\\\n", + " 1 & 3 & 5 & \\textbf{...} & 2(n-1)+1\\\\\n", + " \\end{pmatrix}\n", + "\\end{gather*}\\\\\n", + "$$\n", + "
\n", + "Where in the first row we have the player payoffs when he chooses to collaborate, and in the second one the payoffs when he decides to defect.\n", + "\n", + "Thanks to this new payoff matrix, we can simply compute the i-th player payoff as:\n", + "

\n", + "$$\n", + "u_{i} =\n", + "\\begin{cases}\n", + " 2(n_c-1)\\quad\\text{if player $i$ is collaborating}\\\\\n", + " 2n_c+1\\quad\\text{if player $i$ is defecting}\n", + "\\end{cases}\n", + "$$
\n", + "where $n_c$ is the number of cooperators among the $n$ players.
\n", + "Thanks to this game formulation, we can easly compute the average per-round payoff $a$:

\n", + "$$\n", + "a = 1 + \\frac{N_c}{N}(2N-3)\n", + "$$\n", + "
\n", + "where:\n", + "$$\n", + "\\begin{cases}\n", + " N_c = \\text{number of collaborating players}\\\\\n", + " N = \\text{number of players in the game}\n", + "\\end{cases}\n", + "$$\n", + "\n", + "\n", + "References:
\n", + "[1]: https://link.springer.com/chapter/10.1007/3-540-60154-6_50" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_reward(Nc, c):\n", + " if(c == 0): #not collaborating\n", + " return 2*(Nc)+1\n", + " \n", + " else:\n", + " return 2*(Nc-1)\n", + "\n", + "\n", + "#P_list = player list\n", + "#GI = number of Game Iterations\n", + "def MPIPD(P_list, GI):\n", + " # game loop\n", + " for i in range(GI):\n", + "\n", + " U = np.array([P_list[i].move() for i in range(len(P_list))]).T #matrix with all the players move of this round\n", + " Nc = np.sum(U[0,:])#number of collaborating players\n", + " \n", + " for k in range(len(P_list)): #for each player \n", + " \n", + " \n", + " #Calculate rewards\n", + " P_list[k].append_reward(calc_reward(Nc, U[0, k]))\n", + " \n", + "\n", + " #check if player is tit4tat, if yes, update input history\n", + " if(isinstance(P_list[k], Tit4Tat)):\n", + "\n", + " if(Nc > np.ceil(len(P))/2): #at lest 50% are collaborating\n", + " P_list[k].append_input([1,0])\n", + "\n", + " else: #less than 50% are collaborating \n", + " P_list[k].append_input([0,1])\n", + " \n", + " if(isinstance(P_list[k], Tit4TatMP) or isinstance(P_list[k], GrimTriggerMP)):\n", + " P_list[k].append_input(np.delete(U, k, axis=1).T)\n", + "\n", + " \n", + "\n", + "\n", + "#P_list = player list\n", + "#P_plot_index = indexes of the player that we want to plot\n", + "def plot_rewards_MPIPD(P_list, P_plot_index=None): \n", + "\n", + " if(P_plot_index == None): \n", + " P_plot_index = range(len(P_list))\n", + " \n", + " \n", + " fig, ax = plt.subplots(1,2, figsize = (15,6))\n", + "\n", + " for i in P_plot_index:\n", + "\n", + " print(\"player\"+ str(i) +\" final reward \"+ str(sum(P_list[i].r_history)) +\". Player type: \" + str(type(P_list[i]).__name__))\n", + " ax[0].scatter(range(len(P_list[i].r_history)),P_list[i].r_history, alpha=0.7, marker=\".\", s=300)\n", + " ax[0].plot(P_list[i].r_history, alpha=0.2)\n", + " ax[0].grid(linestyle=\":\")\n", + " ax[0].set_xlabel(\"game\")\n", + " ax[0].set_ylabel(\"reward\")\n", + " ax[0].set_title(\"Reward for every game\")\n", + " \n", + " \n", + " ax[1].plot(np.cumsum(P_list[i].r_history), label=str(type(P_list[i]).__name__))\n", + " ax[1].legend()\n", + " ax[1].grid(linestyle=\":\")\n", + " ax[1].set_xlabel(\"game\")\n", + " ax[1].set_ylabel(\"cumulative reward\")\n", + " ax[1].set_title(\"Cumulative reward\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "player0 final reward 238. Player type: Tit4Tat\n", + "player1 final reward 235. Player type: KBadGuy\n", + "player2 final reward 190. Player type: NiceGuy\n", + "player3 final reward 262. Player type: KBadGuy\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# initialize players instances\n", + "\n", + "p1 = Tit4Tat()\n", + "p2 = KBadGuy(40)\n", + "p3 = NiceGuy()\n", + "p4 = BadGuy()\n", + "p5 = KBadGuy(60)\n", + "\n", + "P = [p1, p2, p3, p5]\n", + "\n", + "#run the game\n", + "MPIPD(P, 50)\n", + "\n", + "#plot the results\n", + "plot_rewards_MPIPD(P)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "player0 final reward 234. Player type: Tit4TatMP\n", + "player4 final reward 231. Player type: GrimTriggerMP\n", + "player5 final reward 174. Player type: LookBackPlayer\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "p1 = Tit4TatMP(0.7)\n", + "p2 = KBadGuy(60)\n", + "p3 = NiceGuy()\n", + "p4 = BadGuy()\n", + "p5 = GrimTriggerMP(0.4)\n", + "p6 = LookBackPlayer(-5.5)\n", + "\n", + "P = [p1, p2, p3, p4, p5, p6]\n", + "\n", + "MPIPD(P, 50)\n", + "plot_rewards_MPIPD(P,[0,4,5])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 3: reapeted multiplayer IPD with population increasing\n", + "Iterate what done in the previous task (repeated MPIPD, rMPIPD) by increasing the population implementing a given strategy depending on the results that strategy achieved in the previous iteration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ```rMPIPD```\n", + "Function that takes as input an initial list of players and let them play in a ```MPIPD``` for a number of iterations specified as input (100 as default). The function then adds a player whose type will be chosen among the others who have already played according some criteria given as input. There is a macro criterium, which can be one of the following:\n", + "
    \n", + "
  • Player who achieved maximum final reward
  • \n", + "
  • Randomly
  • \n", + "
  • Player who gained minimum final reward
  • \n", + "
\n", + "and a \"micro\" criterium, i.e, a criterium that is used in case there is a tie between player's payoff, which can happen using the first and third macro criterium (max and min). The 3 micro criteria are the following\n", + "
    \n", + "
  • Highest number of cooperations
  • \n", + "
  • Randomly
  • \n", + "
  • Highest number of defections
  • \n", + "
\n", + "From this logic it comes the name of the criteria put as input to the rMPIPD function, like for example max_r ( which is also the default in the function), which shows that it is used the max as macro criterium, and random as micro criterium.\n", + "The procedure is then repeated for a number of repetitions, called tournaments, given as input (20 as default).\n", + "Finally, the function creates two graphs: one that compares the mean final payoff per tournament of the type of players involved normalized with respect to the maximum time by time and which player was added and one concerning the mean rewards and their deviations of the types of the players along the different tournaments." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + " Function called by the successive one. It is given as input a list made of players of the same type.\n", + " The function returns the mean number of moves of the type given as input done by the players considered.\n", + "'''\n", + "def mean_moves(player_list, type_move):\n", + " move_sum = 0\n", + " if type_move == \"c\":\n", + " for player in player_list:\n", + " history = np.array(player.move_history)\n", + " move_sum += history[history==np.array([1,0])].size\n", + " elif type_move == \"d\":\n", + " for player in player_list:\n", + " history = np.array(player.move_history)\n", + " move_sum += history[history==np.array([0,1])].size\n", + " mean = move_sum/len(player_list)\n", + " return mean\n", + "\n", + "'''\n", + " Function that implements the non random micro criteria. It is given as input the list of players selected\n", + " through the macro criterium, computes the mean number of moves of the type given as input for every category of player\n", + " and outputs the index to be used to add the new player.\n", + "'''\n", + "def max_move_indexes(player_list, selected_lb, index, type_move):\n", + " labels = np.array(list(map(lambda x: x.label, player_list)))\n", + " coop_means = np.zeros(len(selected_lb))\n", + " for h in range(len(selected_lb)):\n", + " coop_means[h] = mean_moves(list(compress(player_list, labels==selected_lb[h])), type_move)\n", + " res = np.where(coop_means==max(coop_means))[0]\n", + " if res.size == 0:\n", + " selecting_index = res\n", + " else:\n", + "# If still after using the micro criterium the choice would be multiple, randomize between these last selection\n", + " selecting_index = index[np.random.choice(res)]\n", + " return selecting_index\n", + "\n", + "\n", + "'''\n", + " Main function which takes as input the initial list of players, let them play in an MPIPD game, and then adds a new player\n", + " following the criterium given as input. The procedure is repeated for the number of times \"rep_num\".\n", + " The function then plots the 2 graphs concerning the players added tournament by tournament and the mean reward trend.\n", + "'''\n", + "def rMPIPD(P_list, criterium = \"max_r\", rep_num=20, iter_num=100):\n", + "\n", + " num_p = len(P_list)\n", + " input_labels = list(map(lambda x: x.label, P_list))\n", + " winners = pd.DataFrame(columns = range(1,rep_num+1), index = input_labels)\n", + " tournaments_rewards = []\n", + " \n", + " for j in range(rep_num):\n", + "# Reset the player's histories and update LookBackPlayer bias after every player addition\n", + " for player in P_list:\n", + " player.p_reset()\n", + " if type(player).__name__ == \"LookBackPlayer\":\n", + " player.bias = -1*(len(P_list)-0.5)\n", + " \n", + "# Run the game\n", + " MPIPD(P_list, iter_num)\n", + " \n", + "# Find mean reward and deviation and store in a DataFrame for later use\n", + "# Retrieve also the labels\n", + " rewards = np.array([np.sum(P_list[i].r_history) for i in range(len(P_list))])\n", + " labels = np.array(list(map(lambda x: x.label, P_list)))\n", + " reward_df = pd.DataFrame({\"reward\": rewards},index=labels)\n", + " rew_list = []\n", + " \n", + " for lab in input_labels:\n", + " lab_reward = np.array(reward_df.loc[lab,\"reward\"])\n", + " mean = np.sum(lab_reward)/lab_reward.size\n", + " std = np.sqrt(np.sum((lab_reward-mean)**2)/lab_reward.size)\n", + " rew_list.append([mean,std])\n", + " \n", + " rew_statistichs = pd.DataFrame(rew_list,columns=('mean','std'),index=input_labels)\n", + " tournaments_rewards.append(rew_statistichs)\n", + " i = np.where(np.array(rew_statistichs.loc[:,'mean'])==max(rew_statistichs.loc[:,'mean']))[0]\n", + " winners_lab = [input_labels[k] for k in i]\n", + " winners.iloc[i,j] += 1\n", + " \n", + "# Understand how the new person should play\n", + " if \"max\" in criterium:\n", + " i = np.where(rewards==max(rewards))[0]\n", + " if i.size > 1:\n", + " if criterium == \"max_r\":\n", + " i = i[np.random.randint(0,i.size)]\n", + " elif criterium == \"max_c\":\n", + " i = max_move_indexes(P_list,winners_lab,i,\"c\")\n", + " elif criterium == \"max_d\":\n", + " i = max_move_indexes(P_list,winners_lab,i,\"d\")\n", + " else:\n", + " i = int(i)\n", + "\n", + " elif criterium==\"random\":\n", + " i = np.random.randint(num_p)\n", + " \n", + " elif \"min\" in criterium:\n", + " i = np.where(np.array(rew_statistichs.loc[:,'mean'])==min(rew_statistichs.loc[:,'mean']))[0]\n", + " loser_labs = [input_labels[k] for k in i]\n", + " if i.size > 1:\n", + " if criterium == \"min_r\":\n", + " i = i[np.random.randint(0,i.size)]\n", + " elif criterium == \"min_c\":\n", + " i = max_move_indexes(P_list,loser_labs,i,\"c\")\n", + " elif criterium == \"min_d\":\n", + " i = max_move_indexes(P_list,loser_labs,i,\"d\")\n", + " else:\n", + " i = int(i)\n", + "\n", + "# Assign the type to the new person joining the game\n", + " new_p = copy.deepcopy(P_list[i])\n", + " P_list.append(new_p) \n", + "#---------------------------------------------------------------\n", + "\n", + "\n", + "# Retrieve data for the plots and the print\n", + " win_data = np.where(winners!=0)\n", + " u = np.unique(win_data[0])\n", + " added_labels = np.array(list(map(lambda x: x.label, P_list[num_p:])))\n", + " u = np.unique(added_labels)\n", + " added_data = []\n", + " for i in range(added_labels.size):\n", + " j = 0\n", + " while added_labels[i]!=input_labels[j]:\n", + " j += 1\n", + " added_data.append(j)\n", + " \n", + " p_rewards_norm = np.empty((num_p,rep_num))\n", + " for i in range(rep_num):\n", + " p_rewards_norm[:,i] = np.array(tournaments_rewards[i].loc[:,'mean'])/np.max(np.array(tournaments_rewards[i].loc[:,'mean']))\n", + "\n", + "# Create first graph concerning the added players\n", + " fig, ax = plt.subplots(1,2, figsize=(16,6))\n", + " fig.suptitle('Analysis on rMPIPD with criterium $' + criterium + '$', fontsize=30, y=1)\n", + " im = ax[0].imshow(p_rewards_norm, origin=\"lower\", aspect='auto', cmap=\"cividis\")\n", + " ax[0].scatter(range(rep_num), added_data, marker='x', s=100, facecolors='r', edgecolors='r', label=\"Added\")\n", + " ax[0].set_yticks(range(num_p))\n", + " ax[0].set_yticklabels(input_labels)\n", + " ax[0].legend()\n", + " ax[0].set_xticks(range(0,rep_num,2))\n", + " ax[0].set_ylabel(\"Player\")\n", + " ax[0].set_xlabel(\"Tournament number\")\n", + " ax[0].set_title(\"Mean normalized reward and additions\", fontsize=13)\n", + " plt.colorbar(im, ax=ax[0])\n", + "\n", + " \n", + "# Create second graph concerning the reward trend\n", + " for lab in input_labels:\n", + " mean = np.array([])\n", + " std = np.array([])\n", + " for it in range(rep_num):\n", + " mean = np.append(mean,tournaments_rewards[it].loc[lab,\"mean\"])\n", + " std = np.append(std,tournaments_rewards[it].loc[lab,\"std\"])\n", + " ax[1].plot(mean,label=lab, linestyle='-', marker='o')\n", + " ax[1].fill_between(range(rep_num),mean-std,mean+std,alpha=0.3)\n", + " ax[1].legend(bbox_to_anchor=(1.05,1))\n", + " ax[1].grid(linestyle=\":\")\n", + " ax[1].set_xticks(range(0,rep_num,2))\n", + " ax[1].set_ylabel(\"Payoff\")\n", + " ax[1].set_xlabel(\"Tournament number\")\n", + " ax[1].set_title(\"Mean player payoff trend and deviations\")\n", + " plt.show()\n", + " \n", + "# Print the number of added players\n", + " print(\"Number of players added\")\n", + " for j in range(0,u.size):\n", + " print(u[j] + \" : \" + str(added_labels[added_labels==u[j]].size))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of players added\n", + "0.4GrimTriggerMP : 3\n", + "0.7Tit4TatMP : 4\n", + "1LookBackPlayer : 1\n", + "NiceGuy : 12\n" + ] + } + ], + "source": [ + "p1 = Tit4TatMP(0.7)\n", + "p2 = KBadGuy(60)\n", + "p3 = NiceGuy()\n", + "p4 = BadGuy()\n", + "p5 = GrimTriggerMP(0.4)\n", + "p6 = LookBackPlayer(-1.5)\n", + "p7 = KBadGuy(40)\n", + "\n", + "P = [p1, p2, p3, p4, p5, p6, p7]\n", + "\n", + "rMPIPD(P,\"min_r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of players added\n", + "BadGuy : 20\n" + ] + } + ], + "source": [ + "p1 = Tit4TatMP(0.7)\n", + "p2 = KBadGuy(60)\n", + "p3 = NiceGuy()\n", + "p4 = BadGuy()\n", + "p5 = GrimTriggerMP(0.4)\n", + "p6 = LookBackPlayer(-1.5)\n", + "p7 = KBadGuy(40)\n", + "\n", + "P = [p1, p2, p3, p4, p5, p6, p7]\n", + "\n", + "rMPIPD(P,\"max_c\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of players added\n", + "0.5GrimTriggerMP : 4\n", + "1LookBackPlayer : 16\n" + ] + } + ], + "source": [ + "p1 = Tit4TatMP(0.5)\n", + "p2 = GrimTriggerMP(0.5)\n", + "p3 = LookBackPlayer(-1.5, delta=1)\n", + "\n", + "P = [p1,p2,p3]\n", + "\n", + "rMPIPD(P,\"max_c\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of players added\n", + "0.5GrimTriggerMP : 8\n", + "50BadGuy : 12\n" + ] + } + ], + "source": [ + "p1 = GrimTriggerMP(0.5)\n", + "p2 = KBadGuy(50)\n", + "\n", + "P = [p1,p2]\n", + "\n", + "rMPIPD(P,\"max_c\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part4: rMPIPD with mutating strategies\n", + "(*difficult*) Implement a rMPIPD where strategies are allowed to mutate. The goal is to simulate the effect of genetic mutations and the effect of natura selection. A parameter (gene) should encode the attidue of an individual to cooperate, such gene can mutate randomly and the corresponding phenotype should compete in the MPIPD such that the best-fitted is determined. \n", + "\n", + "For this task we explore the idea of players that can generate *children* similar to them and *die* if their rewards are not good enough." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import graphic packages for the graph plots" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.lines import Line2D\n", + "\n", + "try:\n", + " import networkx as nx\n", + " from networkx.drawing.nx_agraph import graphviz_layout\n", + "except ImportError:\n", + " print(\"graphviz_layout not installed\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extend KBadGuy \n", + "We need to extend the KBadGuy player adding an identifier property ID, and information about its relation with the other players." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "class KBadGuy2(KBadGuy):\n", + " color_alive = \"#1f77b4\"\n", + " color_dead = \"#8FBBD9\"\n", + " \n", + " def __init__(self, k, family=[], r_history=[], move_history=[], ID=None):\n", + " KBadGuy.__init__(self, k, r_history=r_history, move_history=move_history)\n", + " self.ID = ID\n", + " self.family = copy.deepcopy(family)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define the evolvingMPIPD function\n", + "We define a function that uses MPIPD and takes care of the generation of new players and controls the population size by deleting the player with lower rewards." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "class IDSupplier:\n", + " \"\"\"\n", + " class that returns incremental unique IDs\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " self.count = 0\n", + "\n", + " def new_id(self):\n", + " id = self.count\n", + " self.count += 1\n", + " return id\n", + "\n", + "legend = [ \n", + " Line2D([0], [0], marker=\"o\", color=\"w\", label=\"Alive\", markerfacecolor=KBadGuy2.color_alive, markersize=15),\n", + " Line2D([0], [0], marker=\"o\", color=\"w\", label=\"Dead\", markerfacecolor=KBadGuy2.color_dead, markersize=15)\n", + "] \n", + " \n", + "# P_list = player list\n", + "def evolvingMPIPD(\n", + " P_list,\n", + " num_epochs,\n", + " GI,\n", + " control_population,\n", + " children=1,\n", + " delta_range=10,\n", + " display_graph=False,\n", + "):\n", + " \"\"\"\n", + " parameters:\n", + " P_list (list): initial players instances.\n", + " num_epochs (int): number of epochs performed.\n", + " GI (int): game iterations inside a epoch.\n", + " control_population (int): maximum number of players that can be active\n", + " during an epoch.\n", + " Return:\n", + " it modifies the input P_list\n", + " G: directed graph networkx\n", + " all_k_history: list of all k for each epoch\n", + " \"\"\"\n", + " G = nx.DiGraph()\n", + "\n", + " all_k_history = []\n", + " \n", + " id_sup = IDSupplier()\n", + " for i, player in enumerate(P_list):\n", + " player.ID = id_sup.new_id()\n", + " G.add_node(player.ID, color=player.color_alive)\n", + "\n", + " if display_graph:\n", + " fig, ax = plt.subplots(figsize=(24, 11))\n", + " ax.legend(handles=legend) \n", + "\n", + " for epoch in range(num_epochs):\n", + " \n", + " all_k = []\n", + " \n", + " # reset the reward history\n", + " for player in P_list:\n", + " player.p_reset()\n", + "\n", + " # call a game loop\n", + " MPIPD(P_list, GI)\n", + "\n", + " def key_r(player):\n", + " return sum(player.r_history)\n", + "\n", + " # sort the player list inplace\n", + " P_list.sort(reverse=True, key=key_r)\n", + "\n", + " # kill the player with small rewards and keep population stable\n", + " while len(P_list) > control_population:\n", + " dead_player = P_list.pop()\n", + " colors = nx.get_node_attributes(G, \"color\")\n", + " colors[dead_player.ID] = player.color_dead\n", + " nx.set_node_attributes(G, colors, \"color\")\n", + "\n", + " # remaining players make new children\n", + " current_P = len(P_list)\n", + " \n", + " for player in P_list[0:current_P]:\n", + " for i in range(children):\n", + " son = KBadGuy2(\n", + " k = np.clip(\n", + " player.k + np.random.uniform(-delta_range, delta_range), 0, 100\n", + " ),\n", + " ID = id_sup.new_id(),\n", + " )\n", + " # add son ID to the parent family\n", + " player.family.append(son.ID)\n", + " \n", + " G.add_node(son.ID, color=son.color_alive)\n", + " G.add_edge(player.ID, son.ID)\n", + " P_list.append(son)\n", + "\n", + " if display_graph:\n", + " plt.title(\"Generation graph\")\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " node_color=nx.get_node_attributes(G, \"color\").values(),\n", + " with_labels=False,\n", + " arrows=True,\n", + " )\n", + " display.clear_output(wait=True)\n", + " display.display(plt.gcf())\n", + "\n", + " for player in P_list:\n", + " all_k.append(player.k)\n", + " \n", + " all_k_history.append(all_k)\n", + " \n", + " if display_graph:\n", + " plt.clf()\n", + " return G, all_k_history" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "P_list = [KBadGuy2(i*10) for i in range(1,6)]\n", + "\n", + "\n", + "G, all_k_history = evolvingMPIPD(P_list, 5, 30, 40, children=2, display_graph=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show the final graph to visualize dead and alive players over the different generations." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if \"graphviz_layout\" in dir(nx.drawing.nx_agraph):\n", + " fig, ax = plt.subplots(figsize=(24, 11))\n", + " ax.legend(handles=legend) \n", + " plt.title(\"Generation graph\")\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " node_color=nx.get_node_attributes(G, \"color\").values(),\n", + " with_labels=False,\n", + " arrows=True,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show the graph with only the surviving players" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nodes_list = list(G.nodes(data=\"color\"))\n", + "for i, color in nodes_list:\n", + " if color == KBadGuy2.color_dead:\n", + " G.remove_node(i)\n", + " \n", + "if \"graphviz_layout\" in dir(nx.drawing.nx_agraph):\n", + " fig, ax = plt.subplots(figsize=(24, 6))\n", + " plt.title(\"Generation graph for survived players\")\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " node_color=nx.get_node_attributes(G, \"color\").values(),\n", + " with_labels=False,\n", + " arrows=True,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run again the evolvingMPIPD function and render an animation that shows the evolution of the *k* values of the players over the epochs." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "P_list = [KBadGuy2(i*10) for i in range(1,6)]\n", + "\n", + "\n", + "G, all_k_history = evolvingMPIPD(P_list, 50, 30, 40, children=2, display_graph=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%matplotlib agg\n", + "import matplotlib as cm\n", + "from celluloid import Camera\n", + "from IPython.display import HTML\n", + "\n", + "fig, ax = plt.subplots(2,1)\n", + "camera = Camera(fig)\n", + "for i, k_frame in enumerate(all_k_history):\n", + " scatter = ax[0].scatter(range(len(k_frame)), k_frame, color=\"#1f77b4\")\n", + " ax[0].legend((scatter,), (f\"Epoch {i+1}\",))\n", + " ax[0].set_ylabel(\"k\")\n", + " ax[0].set_title(\"K value variation on each epoch\")\n", + " \n", + " n_bins = max(int(np.std(k_frame)),3)\n", + " hist = ax[1].hist(k_frame, bins=n_bins, color='#ff7f0e')\n", + " ax[1].set_xlabel(\"k\")\n", + " ax[1].set_ylabel(\"frequency of k\")\n", + " camera.snap()\n", + " \n", + "anim = camera.animate(interval=250)\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extend other players\n", + "We need to add the *ID* and *family* property to the other players in order to implement an evolving MPIPD function that works with every player." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "class Tit4TatMP2(Tit4TatMP):\n", + " \"\"\"\n", + " Player that starts with cooperate and then cooperates only if a fraction of players\n", + " above or equal c_treshold has cooperated.\n", + " \"\"\"\n", + "\n", + " color_alive = \"#ff7f0e\"\n", + " color_dead = \"#f7c592\"\n", + "\n", + " def __init__(\n", + " self,\n", + " family=[],\n", + " r_history=[],\n", + " move_history=[],\n", + " input_history=[],\n", + " c_threshold=0.5,\n", + " ID=None,\n", + " ):\n", + " Tit4TatMP.__init__(\n", + " self,\n", + " r_history=r_history,\n", + " move_history=move_history,\n", + " input_history=input_history,\n", + " c_threshold=c_threshold,\n", + " )\n", + " self.ID = ID\n", + " self.family = copy.deepcopy(family)\n", + "\n", + "\n", + "class GrimTriggerMP2(GrimTriggerMP):\n", + " \"\"\"\n", + " Player that cooperates until a numbers of players >= d_threshold defect in a turn,\n", + " from now on he defects in every turn.\n", + " Setting d_threshold=0 means that it needs only one defecting player\n", + " to start defecting itself.\n", + " \"\"\"\n", + "\n", + " color_alive = \"#2ca02c\"\n", + " color_dead = \"#bcf5b3\"\n", + "\n", + " def __init__(\n", + " self,\n", + " family=[],\n", + " r_history=[],\n", + " move_history=[],\n", + " input_history=[],\n", + " d_threshold=0.5,\n", + " ID=None,\n", + " ):\n", + " GrimTriggerMP.__init__(\n", + " self,\n", + " r_history=r_history,\n", + " move_history=move_history,\n", + " input_history=input_history,\n", + " d_threshold=d_threshold,\n", + " )\n", + "\n", + " self.ID = ID\n", + " self.family = copy.deepcopy(family)\n", + "\n", + "\n", + "class LookBackPlayer2(LookBackPlayer):\n", + " \"\"\"\n", + " Player that use past rewards in order to decide the next move.\n", + " \"\"\"\n", + "\n", + " color_alive = \"#d62728\"\n", + " color_dead = \"#ebbec0\"\n", + "\n", + " def __init__(\n", + " self, bias=0, family=[], r_history=[], move_history=[], memory=np.inf, ID=None\n", + " ):\n", + " LookBackPlayer.__init__(\n", + " self, bias, r_history=r_history, move_history=move_history\n", + " )\n", + "\n", + " self.ID = ID\n", + " self.family = copy.deepcopy(family)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define the evolvingMPIPD2 function\n", + "We define a variation of the evolvingMPIPD function that works with every player type. In this function the evolving gene is considered as the player type. At every epoch the alive players generate a number of *children* that are players of its type. " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "legend_elements = [ \n", + " Line2D([0], [0], marker=\"o\", color=\"w\", label=\"KBadGuy2\", markerfacecolor=KBadGuy2.color_alive, markersize=15),\n", + " Line2D([0], [0], marker=\"o\", color=\"w\", label=\"Tit4TatMP2\", markerfacecolor=Tit4TatMP2.color_alive, markersize=15),\n", + " Line2D([0], [0], marker=\"o\", color=\"w\", label=\"GrimTriggerMP2\", markerfacecolor=GrimTriggerMP2.color_alive, markersize=15),\n", + " Line2D([0], [0], marker=\"o\", color=\"w\", label=\"LookBackPlayer2\", markerfacecolor=LookBackPlayer2.color_alive, markersize=15)\n", + "]\n", + "\n", + "\n", + "# P_list = player list\n", + "def evolvingMPIPD2(\n", + " P_list,\n", + " num_epochs,\n", + " GI,\n", + " control_population,\n", + " children=1,\n", + " delta_range=10,\n", + " display_graph=False,\n", + "):\n", + " \"\"\"\n", + " parameters:\n", + " P_list (list): initial players instances.\n", + " num_epochs (int): number of epochs performed.\n", + " GI (int): game iterations inside a epoch.\n", + " control_population (int): maximum number of players that can be active\n", + " during an epoch.\n", + " Return:\n", + " it modifies the input P_list\n", + " G: directed graph networkx\n", + " players_type_history: list with number of players of each type, for each epoch\n", + " \"\"\"\n", + " G = nx.DiGraph()\n", + " \n", + " players_type_history = []\n", + " \n", + " id_sup = IDSupplier()\n", + " \n", + " players_type_counter = {\n", + " \"KBadGuy2\":0,\n", + " \"Tit4TatMP2\":0,\n", + " \"GrimTriggerMP2\":0,\n", + " \"LookBackPlayer2\":0\n", + " } \n", + " \n", + " for i, player in enumerate(P_list):\n", + " player.ID = id_sup.new_id()\n", + " player_type = type(player).__name__\n", + " players_type_counter[player_type] += 1\n", + " G.add_node(player.ID, color=player.color_alive, player_type=player_type)\n", + " \n", + " \n", + " if display_graph:\n", + " fig, ax = plt.subplots(figsize=(24, 11))\n", + " ax.legend(handles=legend_elements) \n", + "\n", + " for epoch in range(num_epochs):\n", + " # reset the reward history\n", + " for player in P_list:\n", + " player.p_reset()\n", + " # adapt the bias of the Lookback player\n", + " # so the biased payoff matrix has zero mean\n", + " if type(player).__name__ == \"LookBackPlayer2\":\n", + " player.bias = -1*(len(P_list)-0.5)\n", + "\n", + " # call a game loop\n", + " MPIPD(P_list, GI)\n", + "\n", + " def key_r(player):\n", + " return sum(player.r_history)\n", + "\n", + " # sort the player list inplace\n", + " P_list.sort(reverse=True, key=key_r)\n", + "\n", + " # kill the player with small rewards and keep population stable\n", + " while len(P_list) > control_population:\n", + " dead_player = P_list.pop()\n", + " colors = nx.get_node_attributes(G, \"color\")\n", + " player_type = type(dead_player).__name__\n", + " \n", + " colors[dead_player.ID] = dead_player.color_dead\n", + " nx.set_node_attributes(G, colors, \"color\")\n", + " players_type_counter[player_type] -= 1\n", + "\n", + " # remaining players make new children\n", + " current_P = len(P_list)\n", + "\n", + " for player in P_list[0:current_P]:\n", + "\n", + " player_type = type(player).__name__\n", + " for i in range(children):\n", + "\n", + " if player_type == \"KBadGuy2\":\n", + " son = KBadGuy2(\n", + " k=player.k,\n", + " family=player.family,\n", + " ID=id_sup.new_id(),\n", + " )\n", + " elif player_type == \"Tit4TatMP2\":\n", + " son = Tit4TatMP2(\n", + " family=player.family,\n", + " c_threshold=player.c_threshold,\n", + " ID=id_sup.new_id(),\n", + " )\n", + "\n", + " elif player_type == \"GrimTriggerMP2\":\n", + " son = GrimTriggerMP2(\n", + " family=player.family,\n", + " d_threshold=player.d_threshold,\n", + " ID=id_sup.new_id(),\n", + " )\n", + " elif player_type == \"LookBackPlayer2\":\n", + " son = LookBackPlayer2(\n", + " bias=player.bias,\n", + " family=player.family,\n", + " ID=id_sup.new_id(),\n", + " )\n", + " \n", + " players_type_counter[player_type] += 1\n", + " \n", + " # add son ID to the parent family\n", + " player.family.append(son.ID)\n", + " \n", + " G.add_node(son.ID, color=son.color_alive, player_type=player_type)\n", + " G.add_edge(player.ID, son.ID)\n", + " P_list.append(son)\n", + " \n", + " if display_graph:\n", + " plt.title(\"Generation graph\")\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " node_color=nx.get_node_attributes(G, \"color\").values(),\n", + " with_labels=False,\n", + " labels=nx.get_node_attributes(G, \"player_type\"),\n", + " arrows=True,\n", + " )\n", + " display.clear_output(wait=True)\n", + " display.display(plt.gcf())\n", + "\n", + " players_type_history.append(copy.deepcopy(players_type_counter))\n", + " \n", + " if display_graph:\n", + " plt.clf()\n", + " \n", + "\n", + " return G, players_type_history" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "P_list = [\n", + " KBadGuy2(10),\n", + " Tit4TatMP2(c_threshold=0.5),\n", + " GrimTriggerMP2(d_threshold=0.5),\n", + " LookBackPlayer2(bias=0),\n", + "]\n", + "# used later to delete dead players from graph\n", + "dead_colors = [player.color_dead for player in P_list]\n", + "\n", + "\n", + "G, players_type_history = evolvingMPIPD2(P_list, 5, 30, 40, children=2, display_graph=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show the generations graph with colors that characterize every player type. Lighter colors indicate dead players." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if \"graphviz_layout\" in dir(nx.drawing.nx_agraph):\n", + " fig, ax = plt.subplots(figsize=(24, 11))\n", + " ax.legend(handles=legend_elements)\n", + " plt.title(\"Generation graph\")\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " node_color=nx.get_node_attributes(G, \"color\").values(),\n", + " with_labels=False,\n", + " labels=nx.get_node_attributes(G, \"player_type\"),\n", + " arrows=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nodes_list = list(G.nodes(data=\"color\"))\n", + "\n", + "for i, color in nodes_list:\n", + " if color in dead_colors:\n", + " G.remove_node(i)\n", + "\n", + "if \"graphviz_layout\" in dir(nx.drawing.nx_agraph):\n", + "\n", + " fig, ax = plt.subplots(figsize=(24, 6))\n", + " plt.title(\"Generation graph for survived players\")\n", + " ax.legend(handles=legend_elements)\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " node_color=nx.get_node_attributes(G, \"color\").values(),\n", + " with_labels=False,\n", + " labels=nx.get_node_attributes(G, \"player_type\"),\n", + " arrows=True,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run again the function and generate an animated bar chart that shows the evolution of the population by player type." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "P_list = [\n", + " KBadGuy2(45),\n", + " Tit4TatMP2(c_threshold=0.5),\n", + " GrimTriggerMP2(d_threshold=0.5),\n", + " LookBackPlayer2(bias=0),\n", + "]\n", + "\n", + "G, players_type_history = evolvingMPIPD2(P_list, 20, 30, 40, children=2, display_graph=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%matplotlib agg\n", + "\n", + "fig = plt.figure()\n", + "camera = Camera(fig)\n", + "for i, D in enumerate(players_type_history):\n", + " bar = plt.bar(range(len(D)), list(D.values()), color=\"#1f77b4\", align='center')\n", + " plt.xticks(range(len(D)), list(D.keys()))\n", + " plt.legend((bar,), (f\"Epoch {i+1}\",))\n", + " plt.ylabel(\"number of players\")\n", + " plt.title(\"Number of players by type\")\n", + " camera.snap()\n", + "\n", + "anim = camera.animate(interval=400, repeat_delay=1)\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] } ], "metadata": { @@ -89,9 +5069,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.8.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/bags.png b/bags.png new file mode 100644 index 0000000..a0f0b8b Binary files /dev/null and b/bags.png differ diff --git a/report.pdf b/report.pdf new file mode 100644 index 0000000..a9d11f2 Binary files /dev/null and b/report.pdf differ