{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "9e6c8e57",
"metadata": {
"execution": {
"iopub.execute_input": "2022-02-19T02:24:42.995777Z",
"iopub.status.busy": "2022-02-19T02:24:42.992805Z",
"iopub.status.idle": "2022-02-19T02:24:43.689498Z",
"shell.execute_reply": "2022-02-19T02:24:43.689904Z"
},
"papermill": {
"duration": 0.748936,
"end_time": "2022-02-19T02:24:43.690154",
"exception": false,
"start_time": "2022-02-19T02:24:42.941218",
"status": "completed"
},
"tags": [
"remove_cell"
]
},
"outputs": [],
"source": [
"from abc import abstractmethod, ABC\n",
"from collections import defaultdict\n",
"from random import shuffle, random, sample, randint\n",
"\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"from negmas import (\n",
" Action,\n",
" Agent,\n",
" NegotiatorMechanismInterface,\n",
" AgentWorldInterface,\n",
" Breach,\n",
" Contract,\n",
" Issue,\n",
" make_issue,\n",
" LinearUtilityFunction,\n",
" MechanismState,\n",
" Negotiator,\n",
" RandomNegotiator,\n",
" RenegotiationRequest,\n",
" SAONegotiator,\n",
" UtilityFunction,\n",
" World,\n",
" AspirationNegotiator,\n",
" dict2outcome,\n",
")\n",
"from negmas.serialization import to_flat_dict\n",
"from typing import Callable, List, Optional, Set, Dict, Any, Collection"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "22db3011",
"metadata": {
"execution": {
"iopub.execute_input": "2022-02-19T02:24:43.747750Z",
"iopub.status.busy": "2022-02-19T02:24:43.747084Z",
"iopub.status.idle": "2022-02-19T02:24:43.761387Z",
"shell.execute_reply": "2022-02-19T02:24:43.761999Z"
},
"papermill": {
"duration": 0.044776,
"end_time": "2022-02-19T02:24:43.762179",
"exception": false,
"start_time": "2022-02-19T02:24:43.717403",
"status": "completed"
},
"tags": [
"remove_cell"
]
},
"outputs": [
{
"data": {
"text/html": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"import warnings\n",
"\n",
"warnings.filterwarnings(\"ignore\")\n",
"# setup disply parameters\n",
"from matplotlib import pylab as plt\n",
"from matplotlib.ticker import StrMethodFormatter\n",
"\n",
"float_formatter = StrMethodFormatter(\"{x:0.03f}\")\n",
"from IPython.core.display import display, HTML\n",
"\n",
"display(HTML(\"\"))\n",
"SMALL_SIZE = 14\n",
"MEDIUM_SIZE = 16\n",
"BIGGER_SIZE = 20\n",
"\n",
"plt.rc(\"font\", size=SMALL_SIZE) # controls default text sizes\n",
"plt.rc(\"axes\", titlesize=SMALL_SIZE) # fontsize of the axes title\n",
"plt.rc(\"axes\", labelsize=MEDIUM_SIZE) # fontsize of the x and y labels\n",
"plt.rc(\"xtick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n",
"plt.rc(\"ytick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n",
"plt.rc(\"legend\", fontsize=SMALL_SIZE) # legend fontsize\n",
"plt.rc(\"figure\", titlesize=BIGGER_SIZE) # fontsize of the figure title\n",
"plt.rc(\"figure\", figsize=(18, 6)) # set figure size\n",
"plt.rc(\"animation\", html=\"html5\")"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "8b18712e",
"metadata": {
"execution": {
"iopub.execute_input": "2022-02-19T02:24:43.843294Z",
"iopub.status.busy": "2022-02-19T02:24:43.814511Z",
"iopub.status.idle": "2022-02-19T02:24:43.845183Z",
"shell.execute_reply": "2022-02-19T02:24:43.845613Z"
},
"papermill": {
"duration": 0.063954,
"end_time": "2022-02-19T02:24:43.845790",
"exception": false,
"start_time": "2022-02-19T02:24:43.781836",
"status": "completed"
},
"tags": [
"remove_cell"
]
},
"outputs": [],
"source": [
"# just repeating the code from the previous tutorial\n",
"class AWI(AgentWorldInterface):\n",
" @property\n",
" def n_negs(self):\n",
" \"\"\"Number of negotiations an agent can start in a step (holiday season)\"\"\"\n",
" return self._world.neg_quota_step\n",
"\n",
" @property\n",
" def agents(self):\n",
" \"\"\"List of all other agent IDs\"\"\"\n",
" return list(_ for _ in self._world.agents.keys() if _ != self.agent.id)\n",
"\n",
" def request_negotiation(\n",
" self, partners: List[str], negotiator: SAONegotiator\n",
" ) -> bool:\n",
" \"\"\"A convenient way to request negotiations\"\"\"\n",
" if self.agent.id not in partners:\n",
" partners.append(self.agent.id)\n",
" req_id = self.agent.create_negotiation_request(\n",
" issues=self._world.ISSUES,\n",
" partners=partners,\n",
" negotiator=negotiator,\n",
" annotation=dict(),\n",
" extra=dict(negotiator_id=negotiator.id),\n",
" )\n",
" return self.request_negotiation_about(\n",
" issues=self._world.ISSUES, partners=partners, req_id=req_id\n",
" )\n",
"\n",
"\n",
"class TripsWorld(World):\n",
" ISSUES = [\n",
" make_issue((0, 100), \"cost\"),\n",
" make_issue(2, \"active\"),\n",
" make_issue((1, 7), \"duration\"),\n",
" ]\n",
"\n",
" def __init__(self, *args, **kwargs):\n",
" \"\"\"Initialize the world\"\"\"\n",
" kwargs[\"awi_type\"] = AWI\n",
" kwargs[\"negotiation_quota_per_step\"] = kwargs.get(\n",
" \"negotiation_quota_per_step\", 8\n",
" )\n",
" kwargs[\"force_signing\"] = True\n",
" kwargs[\"default_signing_delay\"] = 0\n",
" super().__init__(*args, **kwargs)\n",
" self._contracts: Dict[int, List[Contract]] = defaultdict(list)\n",
" self._total_utility: Dict[str, float] = defaultdict(float)\n",
" self._ufuns: Dict[str, UtilityFunction] = dict()\n",
" self._breach_prob: Dict[str, float] = dict()\n",
"\n",
" def join(self, x, ufun=None, breach_prob=None, **kwargs):\n",
" \"\"\"Define the ufun and breach-probability for each agent\"\"\"\n",
" super().join(x, **kwargs)\n",
" weights = (np.random.rand(len(self.ISSUES)) - 0.5).tolist()\n",
" weights = [_ / i.max_value for _, i in zip(weights, self.ISSUES)]\n",
" x.ufun = (\n",
" LinearUtilityFunction(\n",
" weights=weights, reserved_value=0.0, issues=self.ISSUES\n",
" )\n",
" if ufun is None\n",
" else ufun\n",
" )\n",
" self._ufuns[x.id] = x.ufun\n",
" self._breach_prob[x.id] = random() * 0.1 if breach_prob is None else breach_prob\n",
"\n",
" def simulation_step(self, stage: int = 0):\n",
" \"\"\"What happens in this world? Nothing\"\"\"\n",
" pass\n",
"\n",
" def get_private_state(self, agent: Agent) -> dict:\n",
" \"\"\"What is the information available to agents? total utility points\"\"\"\n",
" return dict(total_utility=self._total_utility[agent.id])\n",
"\n",
" def execute_action(\n",
" self, action: Action, agent: Agent, callback: Callable | None = None\n",
" ) -> bool:\n",
" \"\"\"Executing actions by agents? No actions available\"\"\"\n",
" pass\n",
"\n",
" def on_contract_signed(self, contract: Contract) -> None:\n",
" \"\"\"Save the contract to be executed in the following hoiday season (step)\"\"\"\n",
" super().on_contract_signed(contract)\n",
" self._contracts[self.current_step + 1].append(contract)\n",
"\n",
" def executable_contracts(self) -> Collection[Contract]:\n",
" \"\"\"What contracts are to be executed in the current step?\n",
" Ones that were signed the previous step\"\"\"\n",
" return self._contracts[self.current_step]\n",
"\n",
" def order_contracts_for_execution(\n",
" self, contracts: Collection[Contract]\n",
" ) -> Collection[Contract]:\n",
" \"\"\"What should be the order of contract execution? Random\"\"\"\n",
" shuffle(contracts)\n",
" return contracts\n",
"\n",
" def start_contract_execution(self, contract: Contract) -> Optional[Set[Breach]]:\n",
" \"\"\"What should happen when a contract comes due?\n",
" 1. Find out if it will be breached\n",
" 2. If not, add to each agent its utility from the trip\n",
" \"\"\"\n",
" breaches = []\n",
" for aid in contract.partners:\n",
" if random() < self._breach_prob[aid]:\n",
" breaches.append(\n",
" Breach(\n",
" contract,\n",
" aid,\n",
" \"breach\",\n",
" victims=[_ for _ in contract.partners if _ != aid],\n",
" )\n",
" )\n",
" if len(breaches) > 0:\n",
" return set(breaches)\n",
" for aid in contract.partners:\n",
" self._total_utility[aid] += self._ufuns[aid](\n",
" dict2outcome(contract.agreement, issues=self.ISSUES)\n",
" )\n",
" return set()\n",
"\n",
" def complete_contract_execution(\n",
" self, contract: Contract, breaches: List[Breach], resolution: Contract\n",
" ) -> None:\n",
" \"\"\"What happens if a breach was resolved? Nothing. They cannot\"\"\"\n",
" pass\n",
"\n",
" def delete_executed_contracts(self) -> None:\n",
" \"\"\"Removes all contracts for the current step\"\"\"\n",
" if self._current_step in self._contracts.keys():\n",
" del self._contracts[self.current_step]\n",
"\n",
" def contract_record(self, contract: Contract) -> Dict[str, Any]:\n",
" \"\"\"Convert the contract into a dictionary for saving\"\"\"\n",
" return to_flat_dict(contract)\n",
"\n",
" def breach_record(self, breach: Breach) -> Dict[str, Any]:\n",
" \"\"\"Convert the breach into a dictionary for saving\"\"\"\n",
" return to_flat_dict(breach)\n",
"\n",
" def contract_size(self, contract: Contract) -> float:\n",
" \"\"\"How good is a contract? Welfare\"\"\"\n",
" if contract.agreement is None:\n",
" return 0.0\n",
" return sum(\n",
" self._ufuns[aid](dict2outcome(contract.agreement, issues=self.ISSUES))\n",
" for aid in contract.partners\n",
" )\n",
"\n",
" def post_step_stats(self):\n",
" for aid, agent in self.agents.items():\n",
" self._stats[f\"total_utility_{agent.name}\"].append(self._total_utility[aid])\n",
"\n",
"\n",
"class Person(Agent, ABC):\n",
" @abstractmethod\n",
" def step(self):\n",
" ...\n",
"\n",
" @abstractmethod\n",
" def init(self):\n",
" ...\n",
"\n",
" @abstractmethod\n",
" def respond_to_negotiation_request(\n",
" self,\n",
" initiator: str,\n",
" partners: List[str],\n",
" mechanism: NegotiatorMechanismInterface,\n",
" ) -> Optional[Negotiator]:\n",
" ...\n",
"\n",
" def _respond_to_negotiation_request(\n",
" self,\n",
" initiator: str,\n",
" partners: List[str],\n",
" issues: List[Issue],\n",
" annotation: Dict[str, Any],\n",
" mechanism: NegotiatorMechanismInterface,\n",
" role: Optional[str],\n",
" req_id: Optional[str],\n",
" ) -> Optional[Negotiator]:\n",
" return self.respond_to_negotiation_request(initiator, partners, mechanism)\n",
"\n",
" def on_neg_request_rejected(self, req_id: str, by: Optional[List[str]]):\n",
" pass\n",
"\n",
" def on_neg_request_accepted(\n",
" self, req_id: str, mechanism: NegotiatorMechanismInterface\n",
" ):\n",
" pass\n",
"\n",
" def on_negotiation_failure(\n",
" self,\n",
" partners: List[str],\n",
" annotation: Dict[str, Any],\n",
" mechanism: NegotiatorMechanismInterface,\n",
" state: MechanismState,\n",
" ) -> None:\n",
" pass\n",
"\n",
" def on_negotiation_success(\n",
" self, contract: Contract, mechanism: NegotiatorMechanismInterface\n",
" ) -> None:\n",
" pass\n",
"\n",
" def set_renegotiation_agenda(\n",
" self, contract: Contract, breaches: List[Breach]\n",
" ) -> Optional[RenegotiationRequest]:\n",
" pass\n",
"\n",
" def respond_to_renegotiation_request(\n",
" self, contract: Contract, breaches: List[Breach], agenda: RenegotiationRequest\n",
" ) -> Optional[Negotiator]:\n",
" pass\n",
"\n",
" def on_contract_executed(self, contract: Contract) -> None:\n",
" pass\n",
"\n",
" def on_contract_breached(\n",
" self, contract: Contract, breaches: List[Breach], resolution: Optional[Contract]\n",
" ) -> None:\n",
" pass\n"
]
},
{
"cell_type": "markdown",
"id": "50d97a6f",
"metadata": {
"papermill": {
"duration": 0.02383,
"end_time": "2022-02-19T02:24:43.893406",
"exception": false,
"start_time": "2022-02-19T02:24:43.869576",
"status": "completed"
},
"tags": []
},
"source": [
"## Develop a new agent (for your simulation)\n",
"\n",
"In the previous tutorial, we implemented a world simulation called `TripsWorld` in which agents negotiated how to spend their holiday seasons. In this tutorial we will develop agents for this world and take it on a test-drive.\n",
"\n",
"\n",
"### Making a Random Agent for the Trips World\n",
"\n",
"Our random agent, will just use a random negotiator for everything and will not keep track of the history of other agents. That is the complete code which is self explanatory this time."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "2dd4b012",
"metadata": {
"execution": {
"iopub.execute_input": "2022-02-19T02:24:43.961841Z",
"iopub.status.busy": "2022-02-19T02:24:43.961199Z",
"iopub.status.idle": "2022-02-19T02:24:43.963610Z",
"shell.execute_reply": "2022-02-19T02:24:43.964043Z"
},
"papermill": {
"duration": 0.03881,
"end_time": "2022-02-19T02:24:43.964224",
"exception": false,
"start_time": "2022-02-19T02:24:43.925414",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"class RandomPerson(Person):\n",
" def step(self):\n",
" # get IDs of all ogher agents from the AWI\n",
" agents = self.awi.agents\n",
" # request the maximum number of negotiations possible\n",
" for _ in range(self.awi.n_negs):\n",
" # for each negotiation, use a random subset of partners and a random negotiator\n",
" self.awi.request_negotiation(\n",
" partners=sample(agents, k=randint(1, len(agents) - 1)),\n",
" negotiator=RandomNegotiator(),\n",
" )\n",
"\n",
" def init(self):\n",
" # we need no initialization\n",
" pass\n",
"\n",
" def respond_to_negotiation_request(\n",
" self,\n",
" initiator: str,\n",
" partners: List[str],\n",
" mechanism: NegotiatorMechanismInterface,\n",
" ) -> Optional[Negotiator]:\n",
" # just us a random negotiator for everything\n",
" return RandomNegotiator()"
]
},
{
"cell_type": "markdown",
"id": "843af325",
"metadata": {
"papermill": {
"duration": 0.033196,
"end_time": "2022-02-19T02:24:44.023888",
"exception": false,
"start_time": "2022-02-19T02:24:43.990692",
"status": "completed"
},
"tags": []
},
"source": [
"### Testing the world\n",
"\n",
"We can now start world simulations using our new world and agent"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "ab763a10",
"metadata": {
"execution": {
"iopub.execute_input": "2022-02-19T02:24:44.082266Z",
"iopub.status.busy": "2022-02-19T02:24:44.081377Z",
"iopub.status.idle": "2022-02-19T02:24:50.396570Z",
"shell.execute_reply": "2022-02-19T02:24:50.397364Z"
},
"papermill": {
"duration": 6.349259,
"end_time": "2022-02-19T02:24:50.397694",
"exception": false,
"start_time": "2022-02-19T02:24:44.048435",
"status": "completed"
},
"tags": []
},
"outputs": [
{
"data": {
"text/html": [
"\n"
],
"text/plain": [
"\u001b[?25l"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "99ee864f64a04eccbf23cfb4e499cb10",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Output()"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"\n",
"
\n"
],
"text/plain": [
"\n",
"\u001b[?25h"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"world = TripsWorld(n_steps=10, construct_graphs=True)\n",
"for i in range(5):\n",
" world.join(RandomPerson(name=f\"a{i}\"))\n",
"world.run_with_progress()"
]
},
{
"cell_type": "markdown",
"id": "7e75b4bf",
"metadata": {
"papermill": {
"duration": 0.049469,
"end_time": "2022-02-19T02:24:50.491167",
"exception": false,
"start_time": "2022-02-19T02:24:50.441698",
"status": "completed"
},
"tags": []
},
"source": [
"Let's see what happened in this run. Firstly, how many negotiations were conducted over time. Our agents always conducted the maximum number of negotiations ($8$) and we had $5$ agents which means we expect $40$ negotiations at every step."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "75a618ca",
"metadata": {
"execution": {
"iopub.execute_input": "2022-02-19T02:24:50.613098Z",
"iopub.status.busy": "2022-02-19T02:24:50.587063Z",
"iopub.status.idle": "2022-02-19T02:24:50.872296Z",
"shell.execute_reply": "2022-02-19T02:24:50.872738Z"
},
"papermill": {
"duration": 0.342845,
"end_time": "2022-02-19T02:24:50.873014",
"exception": false,
"start_time": "2022-02-19T02:24:50.530169",
"status": "completed"
},
"tags": []
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"