{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# GA based Agent\n", "#### realworldml.com\n", "#### all rights reserved, Johannes-L Löwe" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "import math\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from tqdm import tqdm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# setup Unity Env" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "env_name = \"../envs/slar2mult2/crawler\" # Name of the Unity environment binary to launch\n", "train_mode = False # Whether to run the environment in training or inference mode" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Python version:\n", "3.6.9 |Anaconda, Inc.| (default, Jul 30 2019, 19:07:31) \n", "[GCC 7.3.0]\n" ] } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import sys\n", "\n", "from mlagents.envs.environment import UnityEnvironment\n", "\n", "%matplotlib inline\n", "\n", "print(\"Python version:\")\n", "print(sys.version)\n", "\n", "# check Python version\n", "if (sys.version_info[0] < 3):\n", " raise Exception(\"ERROR: ML-Agents Toolkit (v0.3 onwards) requires Python 3\")" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# env = UnityEnvironment(file_name=env_name)\n", "\n", "# # Set the default brain to work with\n", "# default_brain = env.brain_names[0]\n", "# brain = env.brains[default_brain]" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# env.reset(train_mode=False)[default_brain].vector_observations" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# for i in range(200):\n", "# env.step([[random.random(),0.2],[0.1,random.random()],[0.1,0.2],[0.1,0.2],[0.1,0.2]])" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# env.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Dancer to balance pole" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "train_mode = True" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "rangesOP = [(0,1),(0,1)]\n", "rangesIP = [(-40,40),(0,40)]" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "action_space = [0,1,2,3]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(4,)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.array([random.choice(action_space) for i in range(len(action_space))]).shape" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[3, 2]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s = list((1,2))\n", "d = s\n", "d[0] = 3\n", "s" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.25, 2.75]" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "space_ranges = rangesOP\n", "bins = [4,4,4]\n", "targetState = [1,11]\n", "mappedValues = [(space_ranges[i][1] - space_ranges[i][0]) * (targetState[i]/bins[i]) for i in range(len(space_ranges))]\n", "mappedValues" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class CrawlerMen:\n", " \n", " def __init__(self,bins,parents, ess, index, mutationrate = 20, qtable = None):\n", " self.bins = bins +[4,4]\n", " self.index = index\n", " self.mutationrate =mutationrate \n", " if parents:\n", " self.crossover(parents)\n", " self.mutate()\n", " else:\n", " if qtable is None:\n", " self.qtable = np.random.random(size=self.bins)\n", " else:\n", " self.qtable = qtable\n", " self.train_mode = True\n", " self.action_timing = 10\n", " self.fitnessValue = 0\n", " self.lastAction = 0\n", " self.state = self.discretize(ess.vector_observations[self.index])\n", " action = self.getAction()\n", " self.setTargetState(action)\n", " self.lastAction = action\n", " self.rewHist = []\n", " \n", " def discretize(self,obv):\n", " space_ranges = rangesIP#[(-20,20),(-math.radians(50), math.radians(50)),(0,3),(-2,2),(-5,5),(-2,2)]#[(-100,100), (-1,1), (-math.radians(24),math.radians(24)), (-math.radians(50), math.radians(50))]\n", " clamped_obv = [min(space_ranges[i][1],max(space_ranges[i][0],obv[i])) for i in range(len(space_ranges))]\n", " mapped_obv = [int(round(((clamped_obv[i] + abs(space_ranges[i][0]))/(abs(space_ranges[i][0]) + abs(space_ranges[i][1])))* (self.bins[i]-1))) for i in range(len(space_ranges))]\n", " return tuple(mapped_obv)#+ [self.lastAction]) \n", " \n", " def setTargetState(self,action):\n", " #copy and remove last action part\n", " ts = list(self.state).copy()[:-1]\n", " a = [0,0]\n", " if action == 0:\n", " a = [-1,0]\n", " elif action == 1:\n", " a = [0,1]\n", " elif action == 2:\n", " a = [1,0]\n", " elif action == 3:\n", " a = [0,-1]\n", " ts = [max(0,min((self.bins[i]-1),ts[i] + a[i])) for i in range(len(ts))]\n", " self.targetState = ts\n", " \n", " def getAction(self):\n", " return np.argmax(self.qtable[self.state])\n", " \n", " def toAction(self):\n", " space_ranges = rangesOP\n", " mappedValues = [(space_ranges[i][1] - space_ranges[i][0]) * (self.targetState[i]/(self.bins[i]-1)) for i in range(len(space_ranges))]\n", " return mappedValues\n", " \n", " def performAction(self, step,es):\n", " reward = es.rewards[self.index]\n", " #adapt for random reward at the start\n", " if step>10:\n", " self.fitnessValue += reward\n", " obs = es.vector_observations[self.index]\n", " done = es.local_done[self.index]\n", " #obs, reward, done, _ = self.env.step(action)\n", " new_state = self.discretize(obs)\n", " if step % self.action_timing == 0:\n", " action = self.getAction()\n", " self.state = new_state\n", " self.setTargetState(action)\n", " self.lastAction = action\n", " self.rewHist += [self.fitnessValue]\n", " #return self.toAction()\n", " \n", " def crossover(self, parents):\n", " p1,p2 = parents\n", " mask = np.random.randint(2, size=self.bins)\n", " mask2 = 1-mask \n", " self.qtable = mask*p1.qtable\n", " self.qtable += mask2*p2.qtable\n", " \n", " def mutate(self):\n", " maxN = 1\n", " for i in self.bins:\n", " maxN *= i\n", " r = np.random.randint(maxN, size = self.mutationrate)\n", " mask = np.zeros(maxN)\n", " maskZ = np.ones(maxN)\n", " maskZ[r] = 0\n", " mask[r] = np.random.random(size=len(r))\n", " mask = mask.reshape(self.bins)\n", " maskZ=maskZ.reshape(self.bins)\n", " self.qtable *= maskZ\n", " self.qtable += mask\n", " \n", " def evaluateFitness(self):\n", " return self.fitnessValue\n", " \n", " def kill(self):\n", " return \"\"\n", " \n", " def __repr__(self):\n", " return \"Agent\"+str(self.index)+\"->\"+str(self.fitnessValue)\n", " \n", " def __lt__(self,other):\n", " return self.fitnessValue < other.fitnessValue\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# use sequence" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "reset_states = []" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "class CrawlerSequence:\n", " \n", " def __init__(self,bins,parents, ess, index, mutationrate = 2, actions = None, actionLength = 10):\n", " self.bins = bins +[4,4]\n", " self.index = index\n", " self.ranges = rangesIP\n", " self.mutationrate =mutationrate\n", " if parents:\n", " self.crossover(parents)\n", " self.mutate()\n", " else:\n", " if actions is None:\n", " self.actions = np.random.randint(4,size=actionLength)\n", " else:\n", " self.actions = actions\n", " self.train_mode = True\n", " self.action_timing = 20\n", " self.fitnessValue = 0\n", " self.decisionStep = 0\n", " self.lastAction = 0\n", " self.targetState = (0,0)\n", " self.state = self.discretize(ess.vector_observations[self.index])\n", " reset_states.append(self.state)\n", " action = self.getAction()\n", " self.setTargetState(action)\n", " self.lastAction = action\n", " self.rewHist = []\n", " self.lastObs = (0,0)\n", " self.stateHist = []\n", " \n", " \n", " def discretize(self,obv):\n", " space_ranges = self.ranges #[(-20,20),(-math.radians(50), math.radians(50)),(0,3),(-2,2),(-5,5),(-2,2)]#[(-100,100), (-1,1), (-math.radians(24),math.radians(24)), (-math.radians(50), math.radians(50))]\n", " clamped_obv = [min(space_ranges[i][1],max(space_ranges[i][0],obv[i])) for i in range(len(space_ranges))]\n", " mapped_obv = [int(round(((clamped_obv[i] - space_ranges[i][0])/(space_ranges[i][1]-space_ranges[i][0]))* (self.bins[i]-1))) for i in range(len(space_ranges))]\n", " return tuple(mapped_obv )\n", "# space_ranges = rangesIP#[(-20,20),(-math.radians(50), math.radians(50)),(0,3),(-2,2),(-5,5),(-2,2)]#[(-100,100), (-1,1), (-math.radians(24),math.radians(24)), (-math.radians(50), math.radians(50))]\n", "# clamped_obv = [min(space_ranges[i][1],max(space_ranges[i][0],obv[i])) for i in range(len(space_ranges))]\n", "# mapped_obv = [int(round(((clamped_obv[i] + abs(space_ranges[i][0]))/(abs(space_ranges[i][0]) + abs(space_ranges[i][1])))* (self.bins[i]-1))) for i in range(len(space_ranges))]\n", "# return tuple(mapped_obv + [self.lastAction]) \n", " \n", " \n", " def setTargetState(self,action):\n", " #copy and remove last action part\n", " ts = list(self.state).copy()#[:-1]\n", " a = [0,0]\n", " if action == 0:\n", " a = [-1,0]\n", " elif action == 1:\n", " a = [0,1]\n", " elif action == 2:\n", " a = [1,0]\n", " elif action == 3:\n", " a = [0,-1]\n", " ts = [max(0,min((self.bins[i]-1),ts[i] + a[i])) for i in range(len(ts))]\n", " self.targetState = ts\n", " \n", " def getAction(self):\n", " return self.actions[self.decisionStep%len(self.actions)]\n", " \n", " def toAction(self):\n", "# space_ranges = rangesOP\n", "# mappedValues = [(space_ranges[i][1] - space_ranges[i][0]) * (self.targetState[i]/(self.bins[i]-1)) for i in range(len(space_ranges))]\n", "# return mappedValues\n", "# print(self.targetState,self.state)\n", " return [self.lastObs[i] - ((self.targetState[i]/(self.bins[i]-1))*(self.ranges[i][1]-self.ranges[i][0])+self.ranges[i][0]) for i in range(len(self.targetState))]\n", "# return [self.targetState[i] - self.state[i] for i in range(len(self.targetState))]\n", "\n", " def performAction(self, step,es):\n", " reward = es.rewards[self.index]\n", " #adapt for random reward at the start\n", " self.fitnessValue += reward\n", " obs = es.vector_observations[self.index]\n", " self.lastObs = obs\n", " done = es.local_done[self.index]\n", " #obs, reward, done, _ = self.env.step(action)\n", " new_state = self.discretize(obs)\n", " self.state = new_state\n", " if step % self.action_timing == 0:\n", " self.decisionStep +=1\n", " action = self.getAction()\n", " self.state = new_state\n", "# if self.state==tuple(self.targetState):\n", "# print(\".\",end=\"\")\n", "# else:\n", "# print(\"x\",end=\"\")\n", " self.stateHist.append(self.state)\n", " self.setTargetState(action)\n", " self.lastAction = action\n", " self.rewHist += [self.fitnessValue]\n", " #return self.toAction()\n", " \n", " def crossover(self, parents):\n", " p1,p2 = parents\n", " mask = np.random.randint(2, size=len(p1.actions))\n", " mask2 = 1-mask \n", " self.actions = mask*p1.actions\n", " self.actions += mask2*p2.actions\n", " \n", " def mutate(self):\n", " r = np.random.randint(len(self.actions), size = self.mutationrate)\n", " self.actions[r] = np.random.randint(4,size = len(r))\n", " \n", " def evaluateFitness(self):\n", " return self.fitnessValue\n", " \n", " def kill(self):\n", " return \"\"\n", " \n", " def __repr__(self):\n", " return \"Agent\"+str(self.index)+\"->\"+str(self.fitnessValue)\n", " \n", " def __lt__(self,other):\n", " return self.fitnessValue < other.fitnessValue\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([3, 0, 0, 0, 1, 3, 2, 1, 1, 2, 3, 3, 0, 3, 1, 3, 0, 2, 0, 3, 0, 0,\n", " 1, 2, 0, 3, 1, 2, 1, 2, 1, 2, 1, 3, 3, 0, 0, 0, 2, 3, 1, 2, 2, 1,\n", " 2, 3, 3, 0, 1, 2, 0, 1, 3, 3, 3, 1, 3, 2, 1, 2, 1, 0, 0, 1, 0, 0,\n", " 3, 3, 1, 1, 1, 3, 3, 3, 1, 3, 2, 3, 3, 1, 0, 3, 2, 0, 3, 3, 1, 0,\n", " 2, 3, 0, 3, 0, 2, 2, 0, 1, 2, 2, 2])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.randint(4,size = 100)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "class CrawlerTrainer:\n", " \n", " def __init__(self, agentsPerGeneration,evluationPeriod,bins, generations,env,cutOff = 600):\n", " self.agentsPerGeneration = agentsPerGeneration\n", " self.evluationPeriod = evluationPeriod\n", " self.generations = generations\n", " self.bins = bins\n", " self.train_mode = True\n", " self.env = env\n", " # Set the default brain to work with\n", " self.default_brain = \"slar\"\n", "# self.brain = self.env.brains[self.default_brain]\n", " self.ess = self.env.reset(train_mode=self.train_mode)[self.default_brain]\n", " self.agents = [CrawlerSequence(bins,None,self.ess,i) for i in range(self.agentsPerGeneration)]\n", " self.bestHist= []\n", " self.bestAgents = []\n", " self.cutOff = cutOff\n", " self.best = None\n", " \n", " def train(self):\n", "# with tqdm(total = self.evluationPeriod) as pbar:\n", " for step in range(self.evluationPeriod):\n", " actions = [a.toAction() for a in self.agents]\n", " self.ess = self.env.step(actions)[self.default_brain]\n", " for a in self.agents:\n", " a.performAction(step,self.ess)\n", "# pbar.update(1)\n", " \n", " def findArg(self,i,l):\n", " for li in range(len(l)):\n", " if i<=l[li]:\n", " return li\n", " \n", " def evaluate(self):\n", " agentsS = sorted(self.agents)\n", " #print(\"fitness \", agentsS)\n", " self.bestHist.append(agentsS[-1].evaluateFitness())\n", " self.bestAgents.append(agentsS[-1])\n", " if self.best == None or agentsS[-1].evaluateFitness()>self.best.evaluateFitness():\n", " self.best = CrawlerSequence(self.bins,None, self.ess, 0,actions = agentsS[-1].actions)\n", "# if self.bestHist[-1]>110:\n", "# print(\"stop training\", self.agents)\n", " self.agents = []\n", " #add best agent again\n", " self.agents.append( CrawlerSequence(self.bins,None, self.ess, 0,actions = agentsS[-1].actions))\n", " r =0\n", " selectionList = []\n", " for a in agentsS:\n", " rval = max(0,a.evaluateFitness())\n", " selectionList.append(r + rval)\n", " r += rval\n", " #print(\"selection List\", selectionList)\n", " #kill old generation - resets their fitness if they have been kept\n", " for a in self.agents:\n", " a.kill()\n", " trialsNatural = 0\n", " while len(self.agents)< self.agentsPerGeneration-3 and trialsNatural <100:\n", " p1i = self.findArg(random.randint(0,int(max(selectionList))),selectionList)\n", " p2i = self.findArg(random.randint(0,int(max(selectionList))),selectionList)\n", " if p1i!=p2i:\n", " self.agents.append(CrawlerSequence(self.bins, (agentsS[p1i],agentsS[p2i]), self.ess,len(self.agents)))\n", " trialsNatural +=1\n", " #if impossible to pair naturally e.g through equal un-fitness\n", "# if len(self.agents)110:\n", " # print(\"goal achieved\")\n", " # break\n", " pbar.update(1)\n", " pbar.set_description(\"best: \" + str(round(self.bestHist[-1],2)))\n", " else:\n", " with tqdm(total = self.generations, desc= \"best:\") as pbar:\n", " maxLastRew = 0\n", "# pbar.max = self.cutOff\n", " while maxLastRew < self.cutOff:\n", " # print(\"Starting generation...\",i)\n", " self.train()\n", " self.ess = self.env.reset(train_mode=self.train_mode)[self.default_brain]\n", " self.evaluate()\n", " # if self.bestHist[-1]>110:\n", " # print(\"goal achieved\")\n", " # break\n", " pbar.update(1)\n", " pbar.set_description(\"best: \" + str(round(self.bestHist[-1],2)))\n", " maxLastRew = self.bestHist[-1]\n", " \n", " def showOff(self,steps):\n", " self.train_mode = False\n", " self.ess = self.env.reset(train_mode=self.train_mode)[self.default_brain]\n", " for step in range(steps):\n", " actions = [a.toAction() for a in self.agents]\n", " self.ess = self.env.step(actions)[self.default_brain]\n", " for a in self.agents:\n", " a.performAction(step,self.ess)\n", " \n", " \n", " def killAll(self):\n", " self.env.close()\n", " for a in self.agents:\n", " a.kill()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# if trainer:\n", "# trainer.killAll()" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:mlagents.envs:\n", "'Academy' started successfully!\n", "Unity Academy name: Academy\n", " Reset Parameters : {}\n" ] } ], "source": [ "env= UnityEnvironment(file_name=env_name)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:mlagents.envs:Connected new brain:\n", "Unity brain name: slar\n", " Number of Visual Observations (per agent): 0\n", " Camera Resolutions: []\n", " Vector Observation space size (per agent): 2\n", " Vector Action space type: discrete\n", " Vector Action space size (per agent): [3, 3]\n", " Vector Action descriptions: \n" ] } ], "source": [ "trainer = CrawlerTrainer(9,400,[4,4],100,env)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trainer.agents[0].targetState" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(-40, 40), (0, 40)]" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trainer.agents[0].ranges" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[13.333333333333336, 0.0]" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trainer.agents[0].toAction()" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# trainer.evolve()" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[Agent0->0,\n", " Agent1->0,\n", " Agent2->0,\n", " Agent3->0,\n", " Agent4->0,\n", " Agent5->0,\n", " Agent6->0,\n", " Agent7->0,\n", " Agent8->0]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sorted(trainer.agents)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "b = sorted(trainer.agents)[-1]" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.stateHist" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "<-,.,->,^\n", "-1 0, 0 1, 1 0, 0 -1\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 1, 3, 0, 1, 1, 0, 3, 1])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.actions" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.targetState" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 0)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.state" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[13.333333333333336, 0.0]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.toAction()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0, 0)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.lastObs" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[-13.333333333333336, 0.0]" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[((b.targetState[i]/(b.bins[i]-1))*(b.ranges[i][1]-b.ranges[i][0])+b.ranges[i][0]) for i in range(len(b.targetState))]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0, 2)" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.discretize((-40,20))" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "# env2 = UnityEnvironment(\"../envs/slar2multInf/crawler\", worker_id=1)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "# trainer.env = env2" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "# trainer.showOff(2000)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "graphdir = 'gagraphs2'" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "import os\n", "try:\n", " os.makedirs(graphdir)\n", "except OSError as e:\n", " if e.errno != os.errno.EEXIST:\n", " raise" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "for 60 episodes:\n", " 1min 49s ± 12.8 s per loop (mean ± std. dev. of 7 runs, 1 loop each)" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.8166666666666667" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "109/60" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "bests = []" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "eps60 = []" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "best: 648.58: 60%|██████ | 36/60 [00:46<00:31, 1.30s/it]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "350: 0\n", "350: 9\n", "600: 35\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\r", "best:: 0%| | 0/60 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "627.3307623639703 with: [3 0 1 0 1 0 3 0 1 2]\n" ] } ], "source": [ "for i in range(10):\n", " \n", " trainer = CrawlerTrainer(9,400,[4,4],60,env,cutOff=600)\n", " trainer.evolve()\n", " b60 = False\n", " b35=False\n", " for e in range(len(trainer.bestHist)):\n", " if trainer.bestHist[e]>600 and not b60:\n", " print(\"600:\",e)\n", " b60 = e\n", " eps60.append(e)\n", " if trainer.bestHist[e]>350 and not b35:\n", " print(\"350:\",e)\n", " b35 = e\n", " plt.plot(trainer.bestHist)\n", " plt.title(\"Genetic Algorithm Best Accumulated Reward\\n\"+str(i)+\" 600:\"+str(b60))\n", " plt.xlabel(\"generation\")\n", " plt.ylabel(\"best accumulated reward\")\n", " plt.savefig(graphdir+\"/ga\"+str(i)+\".png\")\n", " plt.show()\n", " best = trainer.bestAgents[-1]\n", " print(best.evaluateFitness(), \" with: \", best.actions)\n", " bests.append(best)\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "bests[0].stateHist" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "env.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[98, 31, 4, 35, 16, 30, 19, 5, 16, 4, 59, 43, 23]" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[98, 31, 4, 35, 16, 30, 19, 5, 16, 4, 59, 43, 23]" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eps60" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "29.46153846153846" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.mean(eps60)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "25.10781485641284" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.std(eps60)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for a in trainer.agents:\n", "# print(a.qtable[1,2,3])\n", " print(a.evaluateFitness())\n", "# b = trainer.agents[0]\n", "# CrawlerMen([5,5],None,trainer.ess,0,qtable=b.qtable).qtable[1,2,3]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "trainer.agents" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sorted(trainer.agents)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c=np.cumsum(trainer.bestHist)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(c)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "aB = sorted(trainer.agents)[-1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "aB" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# for i in range(len(trainer.agents)):\n", "# trainer.agents[i] = aB" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(trainer.bestHist)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "acts = aB.actions" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "len(acts)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "def calcTargetState(state,action,bins):\n", " #copy and remove last action part\n", " ts = list(state).copy()\n", " a = [0,0]\n", " if action == 0:\n", " a = [-1,0]\n", " elif action == 1:\n", " a = [0,1]\n", " elif action == 2:\n", " a = [1,0]\n", " elif action == 3:\n", " a = [0,-1]\n", " ts = [max(0,min((bins[i]),ts[i] + a[i])) for i in range(len(ts))]\n", " return ts" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "reset_states" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [], "source": [ "s = (2,4)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "# st = np.matrix(st)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 396, "metadata": {}, "outputs": [], "source": [ "def arrowFromAction(a,x,y, al = 0.4):\n", " plt.scatter(x,y,marker='x', c='blue', s=500,linewidths=20)\n", " if a==0:\n", " plt.arrow(x,y,-al,0,width=0.15,head_length = 0.2, length_includes_head=True,head_width = 0.25, facecolor='r')\n", " if a==1:\n", " plt.arrow(x,y,0,al,width=0.1, head_length = 0.2,length_includes_head=True,head_width = 0.2, facecolor='r')\n", " if a==2:\n", " plt.arrow(x,y,al,0,width=0.15, head_length = 0.2,length_includes_head=True,head_width = 0.25, facecolor='r')\n", " if a==3:\n", " plt.arrow(x,y,0,-al,width=0.1, head_length = 0.2,length_includes_head=True,head_width = 0.2, facecolor='r')\n", "# if a==-1:" ] }, { "cell_type": "code", "execution_count": 397, "metadata": {}, "outputs": [], "source": [ "def drawQtablepos(bins, point, a,index = 0):\n", "# for i in range(len(action_space)):\n", " plt.xticks(list(range(bins[0])))\n", " plt.xlim(-0.5,bins[0]-1+0.5)\n", " plt.ylim(-0.5,bins[1]-1+0.5)\n", " plt.yticks(list(range(bins[1])))\n", " for y in range(bins[1]):\n", " for x in range(bins[0]):\n", " plt.scatter(x,y,marker='.',c='b',linewidths=40)\n", " if x ==point[0] and y==point[1]:\n", " print(\" x \",end = \"\")\n", "# plt.arrow(x,y,0.5,0)\n", " arrowFromAction(a,x,y)\n", "# plt.scatter(x,y,marker='x', c='r', s=300)\n", " else:\n", " print(\" . \",end=\"\")\n", " print(\"\\n\")\n", " plt.xlabel(\"shoulder bin\")\n", " plt.ylabel(\"knee bin\")\n", " plt.gca().invert_yaxis()\n", " plt.savefig(graphdir+\"/stateA-\"+str(index)+\".png\")\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 398, "metadata": {}, "outputs": [], "source": [ "import itertools" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "code", "execution_count": 399, "metadata": {}, "outputs": [], "source": [ "action_visuals = [\"<- \",\" . \",\" ->\",\" ^ \"]" ] }, { "cell_type": "code", "execution_count": 400, "metadata": {}, "outputs": [], "source": [ "actions = [3,0,1,0,1,0,2,2,3]" ] }, { "cell_type": "code", "execution_count": 401, "metadata": {}, "outputs": [], "source": [ "# np.ravel(st[0,:])" ] }, { "cell_type": "code", "execution_count": 402, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'bests' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbests\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstateHist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'bests' is not defined" ] } ], "source": [ "len(bests[1].stateHist)" ] }, { "cell_type": "code", "execution_count": 403, "metadata": {}, "outputs": [], "source": [ "def drawQfromActions(bins,acts):\n", " st = []\n", " s = (2,0)\n", " ind = 0\n", " for a in acts:\n", "# print([s[i]/trainer.bins[i] for i in range(len(s))],end = \",\")\n", " drawQtablepos(bins,s,a, index=ind)\n", " s = calcTargetState(s,a,bins)\n", " st.append([s[i]/bins[i] for i in range(len(s))])\n", " ind+=1\n", " drawQtablepos(bins,s,-1, index=ind)\n", " print()\n", " for s in st:\n", " print(s)\n", " print(\"--------------------------\")" ] }, { "cell_type": "code", "execution_count": 404, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[4, 4, 4]" ] }, "execution_count": 404, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bins" ] }, { "cell_type": "code", "execution_count": 405, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " . . x . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . x . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEGCAYAAABvtY4XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dfZAcd3kn8O9jrZ19Gelk2cKyrNWuhWSnJOwlu1uAFI5wkldxsA64FFSOAwQKrF2nhbIkRz6ujtxhy6kkF5JAsCybsiz5hcLmJVKILZniwIGAFPDsAsYySJbx7krWCyLSypqRPV55nvvjN+N5n52deXp6pvv7qeqa6d3p/v307dUzPT3dvxZVBRERBc9FfneAiIi8wQJPRBRQLPBERAHFAk9EFFAs8EREAdXidweyXX755drd3e13N4iImsbw8PBvVXVusd81VIHv7u5GNBr1uxtERE1DRMZK/Y6HaIiIAooFnogooFjgiYgCigWeiCigWOCJiAKqoc6iaRSqwOgosG8fsH8/MDICnDgBnD4NxGJAJALMmQPMmwf09gIrVgDLlwPd3YCI371vPMzTFvO0Feg8VbVhpr6+PvXT2bOqd9+tunSpqtvs05uWLnXLnz3r6z+jYTBPW8zTVlDyBBDVEjXV96KePflV4GMx1c2bVTs6ym/Qjg7VxYsre93mzW69YcQ8bTFPW0HLkwW+jD17VLu6Sm+8zk7Vu+5SHR9XTSbdMsmkm7/rLvf7Ust2danu3Vv3f5KvmKct5mkriHmywBeRSKgODpbeWKtXq+7erTo5WX49k5PudatXl17X4KBrL8iYpy3maSvIebLA55mYUF25snDDzJ6tummT6qFD1a330CHVjRvdevLXvWqVazeImKct5mkr6HmywGc5c0a1pyd3Y/T1qT7wgGo8btNGPK66fbtqb29uOz09wftPxDxtMU9bYciTBT4lkch9J29rU92507v2kkm3/ra23Hf2oHwcZp62mKetsOTJAp+SfQyurU01GvW0uTdEo7kbfXCwPu16jXnaYp62wpInC7y6b8+zPz55+U5ezI4due03+9kLzNNWuTxjscwZHVaSydzT+sKUZz3UM8/QF/hYLPfUqL4++/8wU0kmc4/RdXc373nIzNNWuTxjMTd/6612GSeTbn19fZnMwpJnvdQzz3IFPhRj0dxxBzCWNST+0FD9LzEWce2mjY4Cd95Z3z5YYZ62yuXZ3g68853AF78IbNzoykUtVN16vvhFt972dvfzsORZLw2TZ6nK78fkxR782bO5V6Jdeqndt+fTFY/nnlIVifh/mfN0MU9bleSZ3uMGatuTn2o9YcmzXuqVJ8K8B//ww0A8nplfty6z11Jv7e2u/bRYDHjkEX/6Ui3macvl+StcgiFchCeL5ikC/P3fA7feWv2efPae+623uvXl79UGJ8/MfOj/PktVfj8m6z34ZLJwIKFqL2qwcvBgbn+WLav/8cFqMU87iURCv/rVR3Vua5/OQpu+AxdpKz5eNs9q9+Sns1yz5qka3r9PhPVL1l//Ojfc1atNV1+1gYHcfr34ot89qgzzrN0LL7yg/2PTJn3TzJn67o6Z+jVAE4BuBfTqKz+i58+fLzvF4+d1aOi8Au4xHs/87pVXXilor5o3hWbKM1tY/z5DW+AfeSQ32N27TVdftV27cvv1la/43aPKMM/qTE5O6q5du/QPV6zQy1tbddMll+ivsjsM6F5Af+eiGdra0lLRdIm0aAvcY/pnLRddpD/60Y/eaLfaPf5Gz7OUsP59livwnh6DF5EbReSgiBwWkc942VYx+/dnnnd2AjfdVO8eFLdmDbBgQWY+u5+NjHlOz9GjR/G5z34W3W96Ez6/di0+sm8fjrz6Kv72tddwbd5rbwTwavJ1vHLhQkVTQi9gEu4x/bP3RiI4fvw4gMqOuZfSqHlOhX+fhTwr8CIyA8BWAH8EYCmAD4nIUq/aK2ZkJPP8lluAlga5f1VLi+tP2vCwf32ZDuY5tWQyiSeffBLvv+EGXL94MX77+c9j75kz+OG5c/gIgNY69KGW4g40Vp7Twb/PQl7uwb8NwGFV/bWqvgbgUQDv87C9AidOZJ6vXVvPlqeW3Z+TJ/3rx3Qwz9JOnjyJv/qLv8Cb583D//rgB7Hmu9/FeCKBuxMJXFenPrz6au3FPc3vPKvBv89CXhb4qwAcyZo/mvpZ3Zw+7R47OnI/IlXrttuA1lb3WKvOzszpW+l+NjrmWdq7ly/HnX/+5/irU6cwHIvhkwAide5D4jXggx+svbgD/udZDf59FvL9PHgRuVlEoiISPXXqlOm6YzH3eOWVNleybd0KJBLAPffUvi4RYP589/zcudrXVw/Ms7R/evJJrB8awqciEfxhJIJdAC7UvxtvqKW4A/7nWQ3+fRbyssC/BKAza35B6mc5VPXLqtqvqv1z58417UAktQt1/Hjtl3gD7tLj1lZg/fra16UKHDvmns+cWfv66oF5lnbNNdfg81/6Eo6cOoWPbtuGv73+enS1teH/zJiR8zG2Xmod1sDvPKvBv8+iDXtzyiOAFgC/BnA1gEsA/BzAsnLLWJ8mefXVmVOTxsdNV12zsbFM3xYt8rs3lWGe0/PMM8/o0Cc+oZe2tel7IxHdA+iFvNMjLaf3XDJLv/71b5gMa9CIeU4lrH+f8OM0SVW9AOBTAL4N4JcAvqaqB7xqr5h58zLPH3qoni1PLbs/V1zhXz+mg3lOz3XXXYe7778fR06dwnu/8AX872uvxeKODvzlRRch/3u27wNY2N6OhR0d05rmtXTgMrjHp5Lncdllc2oe1gBozDynwr/PIkpVfj8m6z34oaHMu2Zn59Q31K2XyUnVBQsyffvUp/zuUWWYZ+2efvpp/eSHP6yzW1v1fS3t+j1Ak6krWf/bH39Ax8bGKppGR8d03boxBdzj6OiYHj169I12ahmgrJnyzBbWv0/wSlYN1ZVtXmGediYmJvRja7+kEXTpfHToAKA3rfx4RctWWrx5JavfPXL8vJLV96KePXEsmsbGPG25PJMK/Ejb8AHtu/5rUy4z3aLNsWj8x7FoPCrwYR1dzivM09Z08+RokuWF9e+zXIH3/Tx4L4kUnuJ0773+9KVU++vX1/9uM9Vinramk6dq9VeoTmc8+bDkWS++51mq8vsx8Y5OjY952uIdnWyF8e8TYd2DB4BZs3Lf1c+cAR57zJ++PPooMDGRmV+/3vWvmTBPW1PlWcuee76p9uTDkGc9NUSepSq/H5MXe/Cq4bvLuteYp61yecZibr6WPfd86T35vr5MZmHJs17qmSfC+iVrtj17MmEDqjt3etZUUTt25La/d29927fGPG2VyzMWsy9QyWRuwQlTnvVQzzxZ4FMGBzOBt7WpRqOeNveGaNS1l257cLA+7XqNedpinrbCkicLfEoiobpyZe5G37nTu49vyaR7J29tzbS5apXrRxAwT1vM01ZY8mSBzzIxodrTk9kA6WN027fbfdsej6vef3/uMTjAtTsxYdNGo2CetpinrTDkyQKfZ2LCvbNmbwzAndK0caO7OKEaBw+qbtiQe2pUerrhhuD950ljnraYp62g58kCX0QikXuMLn8aGHBjSEw1YNHkpHtd/uXI2dPgYHA+9pbCPG0xT1tBzpMFvoy9e90pTKU21oIFqlu2uPGc08fukkk3v2VL7ihx+VN3d/OfjTBdzNMW87QVxDxZ4KcQi6nefru70qzUxgNU29tVFy92j+VeF4m49TXrecS1Yp62mKetoOXJAl+hs2dVt251AwKV26ClpmXL3PLNdnm3V5inLeZpKyh5livw4n7fGPr7+zUajfrdDagCY2PAvn3A/v3A8DBw8qS7G/q5c+6einPmuDuz9PUBK1YAy5cDXV3NMzBTPTFPW8zTVrPnKSLDqtpf9Hcs8EREzatcgQ/8YGNERGHFAk9EFFAs8EREAcUCT0QUUCzwREQBxQJPRBRQLPBERAHFAk9EFFAs8EREAcUCT0QUUC1+d6ARqQKjo5mxKUZGgBMn3NgUsRgQibixKebNA3p7M2NTdHc3xtgUjYZ52mKetgKdZ6lRyPyYGmE0ybvvVl26tLrR5ZYudcv7Pbpco2CetpinraDkCQ4XXF4sprp5s2pHR/kN2tHhxoeu5HWbN4d7vG3maYd52gpanizwZezZo9rVVXrjdXaq3nWX6vh47h1exsfdzzs7Sy/b1RW+O+YwT1vM01YQ82SBL2KqezSuXq26e3dl92jcvdu9vtS6eM9L5jldzNNWkPNkgc8zMaG6cmXhhpk9W3XTJtVDh6pb76FD7i7txe6yvmpVsO9azzztME9bQc+TBT7LmTOqPT25G6OvT/WBB1TjcZs24nHV7dtVe3tz2+npCd5/IuZpi3naCkOeLPApiUTuO3lbm+rOnd61l0y69be15b6zB+XjMPO0xTxthSVPFviU7GNwbW2q0ainzb0hGs3d6IOD9WnXa8zTFvO0FZY8WeDVfXue/fHJy3fyYnbsyG2/2c9eYJ62mKetMOUZ+gIfi+WeGtXXlzkFql6SydxjdN3dzXseMvO0xTxthS3PcgU+FGPR3HEHMDaWmR8aqv8lxiKu3bTRUeDOO+vbByvM0xbztMU8s/rh3gAaQ39/v0ajUdN1vvwyMH8+EI+7+UsvBY4eBdrbTZupyPnzwFVXARMTbj4SAV56CZg1q/59qRbztMU8bYUxTxEZVtX+Yr8L/B78ww9nNjYArFvnz8YGXLvr1mXmYzHgkUf86Uu1mKct5mmLeeYpdezGj8n6GHwyWTiQULUXNVg5eDC3P8uW1f/4YLWYpy3maSuseSKsx+BHR4HnnsvMr14NLFniW3cAANdcAwwMZOYPHMg9XtjImKct5mmLeRYKdIHfty93fv16f/qRL78f+f1sVMzTFvO0xTwLBbrA79+fed7ZCdx0k399ybZmDbBgQWY+u5+NjHnaYp62mGchzwq8iDwgIr8RkWe9amMqIyOZ57fcArQ0yP2rWlpcf9KGh/3ry3QwT1vM0xbzLOTlHvxOADd6uP4pnTiReb52rX/9KCa7PydP+teP6WCetpinLeZZyLMCr6o/AHDaq/VX4nSq9Y6O3I9I1brtNqC11T3WqrMzc/rWaV9TqhzztMU8bTHPQp5e6CQi3QAeV9W3lHnNzQBuBoCFCxf2jRl+xdzSArz+OrB4MfD887Wvr7UVSCTc4yuv1L6+JUuAw4eBGTOACxdqX5/XmKct5mkrrHk29IVOqvplVe1X1f65c+earjsScY/Hj7uzUGs1NOQ2tsW386rAsWPu+cyZta+vHpinLeZpi3kW8n0PPpv1UAWLFgEvvuiej4+7j0mNYnwc6OpyzxctAl54wd/+VIJ52mKetsKaZ0PvwXtp3rzM84ce8q8fxWT354or/OvHdDBPW8zTFvMs5OVpkl8FsB/AtSJyVEQ+4VVbpfT2Zp7fd1/jHEe8cMH1J62vz7++TAfztMU8bTHPQl6eRfMhVb1SVS9W1QWqut2rtkpZvjzz/MgR4Ikn6t2D4h5/3I1wl5bdz0bGPG0xT1vMs1CgD9GsWJE7f889/vQjX34/8vvZqJinLeZpi3kWUWoUsuwJwAwA8wEsTE+VLDfdiaNJNjbmaYt52gprnqhlNEkR+TSAkwC+A+CJ1PS4V284lkQKT3G6915/+lKq/fXr63+3mWoxT1vM0xbzLDTlaZIichjA21X1373uDO/o1PiYpy3maSuMedZ6muQRAGdtu1Q/s2blvqufOQM89pg/fXn00czGBly/muk/D8A8rTFPW8wzT6ljN+kJwHYAPwTwPwFsSk9TLVfNZH0MPi1sd1n3GvO0xTxthS1P1HhHp3G44++XAJiZNTWNjg5g27bM/PBw/S+EePDB3OFMt21z/WpGzNMW87TFPLOUqvx+TF7twacNDmbeUdvaVKNRT5t7QzTq2ku3PThYn3a9xjxtMU9bYckTZfbgyx2a+ULq8Z8BfCt/KrVcLZPXBT6RUF25Mnej79zp3ce3ZFJ1xw7V1tZMm6tWuX4EAfO0xTxthSXPagt8X+rxD4pNpZarZfK6wKuqTkyo9vRkNkD6GN327arxuE0b8bjq/ffnHoMDXLsTEzZtNArmaYt52gpDnlUV+JwXuePv1wO4DsAllSxTzVSPAq/qQl+1KndjAKqzZ6tu3OguTqjGwYOqGza49eSv+4YbgvefJ4152mKetoKeZ00FHsBNcKdK/guA78N96fpHUy1XzVSvAq/qPjZlH6PLnwYGVHftUp2cLL+eyUn3uoGB0usaHAzOx95SmKct5mkryHnWWuB/BWBx1vybAfxqquWqmepZ4NP27nWnMJXaWAsWqG7Zojo2ljl2l0y6+S1b3O9LLdvd7dYfJszTFvO0FcQ8ay3wT+fNS/7PrCY/CryqOz/19ttVI5HSGw9QbW9XXbzYPZZ7XSTi1tes5xHXinnaYp62gpZntV+y/nFq2gZgD4CPA/gY3Dg095RarpbJrwKfdvas6tatbkCgchu01LRsmVv+7Flf/xkNg3naYp62gpJnuQJfciwaEdlR/vR5/dMyv6+KF2PRVEMVGBsD9u0D9u93F0qcPOnuhn7unLun4pw57s4sfX1u+M/ly90tuZplYKZ6Yp62mKetZs+z3Fg0nt6TdboapcATETWL0N6TlYgozFjgiYgCigWeiCigKrmj0xUisl1E9qbml4rIJ7zvGhER1aKSPfidAL4Nd09WADgEYINXHSIiIhuVFPjLVfVrAJIAoKoXALzuaa+IiKhmlRT4uIhcBsBdxiryDjTxLfyIiMKipYLXbIIbA/7NIvIjAHMBfMDTXhERUc2mLPCqOiIifwDgWrhxaA6q6qTnPSMioppUchZNO4DPANigqs8C6BaRNZ73jIiIalLJIZodAIYBLE/NvwTg63CDjgWSKjA6mhmbYmQEOHHCjU0RiwGRiBubYt48oLc3MzZFd3djjE3RaJinLeZpK9B5lhqFLD0hNVIZgJ9m/eznUy1XzdQIo0nefbfq0qXVjS63dKlb3u/R5RoF87TFPG0FJU/UOB78PgBtAEZS828G8JOplqtm8nM8+M2bVTs6ym/Qjg43PnQlr9u8OdzjbTNPO8zTVtDyrLXAD8Ddqu8UgK8AGAXw7qmWq2byo8Dv2aPa1VV643V2qt51l+r4eO4dXsbH3c87O0sv29UVvjvmME9bzNNWEPOsqcC75XEZ3L1Z18Bd+GRe3LXOBX6qezSuXq26e3dl92jcvdu9vtS6eM9L5jldzNNWkPO0KPBXAVgB4F3pqZLlpjvVq8BPTKiuXFm4YWbPVt20SfXQoerWe+iQu0t7sbusr1oV7LvWM087zNNW0POs9RDNX6cOyzwB4J9T07emWq6aqR4F/swZ1Z6e3I3R16f6wAOq8bhNG/G46vbtqr29ue309ATvPxHztMU8bYUhz1oL/EEAvzPV6ywmrwt8IpH7Tt7Wprpzp3ftJZNu/W1tue/sQfk4zDxtMU9bYcmz1gK/F0BkqtdZTF4X+OxjcG1tqtGop829IRrN3eiDg/Vp12vM0xbztBWWPGst8N8EcBjAfQD+IT1NtVw1k5cFfs+eTOCAt+/kxezYkdt+s5+9wDxtMU9bYcqz1gL/sWLTVMtVM3lV4GOx3FOj+voyp0DVSzKZe4yuu7t5z0NmnraYp62w5VmuwFcyXPCzqvpg9gTg3ytYrmHccQcwNpaZHxqq/yXGIq7dtNFR4M4769sHK8zTFvO0xTyz+uHeAMq8QGQEwFp1A41BRD4EN/DY260709/fr9Fo1HSdL78MzJ8PxONu/tJLgaNHgfZ202Yqcv48cNVVwMSEm49EgJdeAmbNqn9fqsU8bTFPW2HMU0SGVbW/2O8q2YP/AICHROR3RWQQwHoAqy076KWHH85sbABYt86fjQ24dtety8zHYsAjj/jTl2oxT1vM0xbzzFPq2E32BOAaAM8BeBJAWyXLVDNZH4NPJgsHEqr2ogYrBw/m9mfZsvofH6wW87TFPG2FNU9UcwxeRH4hIs+IyDMAvgFgDoCrAfw49bOGNzoKPPdcZn71amDJEt+6AwC45hpgYCAzf+BA7vHCRsY8bTFPW8yzULlDNGsA/Oes6e1wh2bS8w1v377c+fXr/elHvvx+5PezUTFPW8zTFvMsVLLAq+pYual+Xaze/v2Z552dwE03+deXbGvWAAsWZOaz+9nImKct5mmLeRaq5EvWqohIp4g8JSLPicgBEbnVq7ZKGRnJPL/lFqClkvtX1UFLi+tP2vCwf32ZDuZpi3naYp6FPCvwAC4AuE1VlwJ4B4AhEVnqYXsFTpzIPF+7tp4tTy27PydP+teP6WCetpinLeZZyLMCr6rHVXUk9fwcgF/CDTtcN6dPu8eOjtyPSNW67TagtdU91qqzM3P6VrqfjY552mKetphnoSkvdDJpRKQbwA8AvEVVX8773c0AbgaAhQsX9o0ZfsXc0gK8/jqweDHw/PO1r6+1FUgk3OMrr9S+viVLgMOHgRkzgAsXal+f15inLeZpK6x51nqhU62NR+AGLNuQX9wBQFW/rKr9qto/d+5c07YjEfd4/Lg7C7VWQ0NuY1t8O68KHDvmns+cWfv66oF52mKetphnIU/34EXkYgCPA/i2qv7dVK+3Hqpg0SLgxRfd8/Fx9zGpUYyPA11d7vmiRcALL/jbn0owT1vM01ZY8/RlD15EBMB2AL+spLh7Yd68zPOHHvKjB6Vl9+eKK/zrx3QwT1vM0xbzLOTlIZrfB/BRACtF5Gep6T0etlegtzfz/L77Guc44oULrj9pfX3+9WU6mKct5mmLeRby8iyaH6qqqOr1qvrW1LTHq/aKWb488/zIEeCJJ+rZemmPP+5GuEvL7mcjY562mKct5lnI8y9Z/bRiRe78Pff40498+f3I72ejYp62mKct5llEqVHI/Jg4mmRjY562mKetsOaJGu/o1LRECk9xuvdef/pSqv316+t/t5lqMU9bzNMW8yxUlwudKsU7OjU+5mmLedoKY56+Xujkt1mzct/Vz5wBHnvMn748+mhmYwOuX830nwdgntaYpy3mmafUsRs/Jutj8Glhu8u615inLeZpK2x5IqzH4NM6OoBt2zLzw8P1vxDiwQdzhzPdts31qxkxT1vM0xbzzFKq8vsxebUHnzY4mHlHbWtTjUY9be4N0ahrL9324GB92vUa87TFPG2FJU+U2YP3vahnT14X+ERCdeXK3I2+c6d3H9+SSdUdO1RbWzNtrlrl+hEEzNMW87QVljxZ4LNMTKj29GQ2QPoY3fbtqvG4TRvxuOr99+cegwNcuxMTNm00CuZpi3naCkOeLPB5JibcO2v2xgBUZ89W3bjRXZxQjYMHVTdscOvJX/cNNwTvP08a87TFPG0FPU8W+CISidxjdPnTwIDqrl2qk5Pl1zM56V43MFB6XYODwfnYWwrztMU8bQU5Txb4MvbudacwldpYCxaobtmiOjaWOXaXTLr5LVvc70st293t1h8mzNMW87QVxDxZ4KcQi6nefrtqJFJ64wGq7e2qixe7x3Kvi0Tc+pr1POJaMU9bzNNW0PJkga/Q2bOqW7e6AYHKbdBS07JlbvmzZ339ZzQM5mmLedoKSp7lCnzgx6KphiowNgbs2wfs3+8ulDh50t0N/dw5d0/FOXPcnVn6+tzwn8uXu1tyNcvATPXEPG0xT1vNnme5sWhY4ImImlioBxsjIgorFngiooBigSciCigWeCKigGKBJyIKKBZ4IqKAYoEnIgooFngiooBigSciCigWeCKigGKBJyIKqBa/O9CIVIHR0czgQyMjwIkTbvChWAyIRNzgQ/PmAb29mcGHursbY/ChRsM8bTFPW4HOs9Qwk35MjTBc8N13qy5dWt3woUuXuuX9Hj60UTBPW8zTVlDyBMeDLy8WU928WbWjo/wG7ehwNwCo5HWbN4f7hgrM0w7ztBW0PFngy9izR7Wrq/TG6+xUvesu1fHx3Ft4jY+7n3d2ll62qyt8t0RjnraYp60g5skCX8RUN+FdvVp19+7KbsK7e7d7fal18abGzHO6mKetIOfJAp9nYkJ15crCDTN7tuqmTaqHDlW33kOHVDdudOvJX/eqVa7dIGKetpinraDnyQKf5cwZ1Z6e3I3R16f6wAOq8bhNG/G46vbtqr29ue309ATvPxHztMU8bYUhTxb4lEQi9528rU11507v2ksm3frb2nLf2YPycZh52mKetsKSJwt8SvYxuLY21WjU0+beEI3mbvTBwfq06zXmaYt52gpLnizw6r49z/745OU7eTE7duS23+xnLzBPW8zTVpjyDH2Bj8VyT43q68ucAlUvyWTuMbru7uY9D5l52mKetsKWZ7kCH4qxaO64Axgby8wPDdX/EmMR127a6Chw55317YMV5mmLedpinln9cG8AjaG/v1+j0ajpOl9+GZg/H4jH3fyllwJHjwLt7abNVOT8eeCqq4CJCTcfiQAvvQTMmlX/vlSLedpinrbCmKeIDKtqf7HfBX4P/uGHMxsbANat82djA67ddesy87EY8Mgj/vSlWszTFvO0xTzzlDp248dkfQw+mSwcSKjaixqsHDyY259ly+p/fLBazNMW87QV1jwR1mPwo6PAc89l5levBpYs8a07AIBrrgEGBjLzBw7kHi9sZMzTFvO0xTwLBbrA79uXO79+vT/9yJffj/x+NirmaYt52mKehTwr8CLSKiI/EZGfi8gBEbnDq7ZK2b8/87yzE7jppnr3oLg1a4AFCzLz2f1sZMzTFvO0xTwLebkHnwCwUlV7ALwVwI0i8g4P2yswMpJ5fsstQEuD3L+qpcX1J2142L++TAfztMU8bTHPQp4V+NTx/1hq9uLUVNdzMk+cyDxfu7aeLU8tuz8nT/rXj+lgnraYpy3mWcjTY/AiMkNEfgbgNwC+o6o/9rK9fKdPu8eOjtyPSNW67TagtdU91qqzM3P6VrqfjY552mKetphnobpc6CQiswHsAvBpVX0273c3A7gZABYuXNg3ZvgVc0sL8PrrwOLFwPPP176+1lYgkXCPr7xS+/qWLAEOHwZmzAAuXKh9fV5jnraYp62w5un7hU6qOr7aZ7gAAAhnSURBVAHgKQA3Fvndl1W1X1X7586da9puJOIejx93Z6HWamjIbWyLb+dVgWPH3POZM2tfXz0wT1vM0xbzLNqwNxctAZgLYHbqeRuAfwWwptwy1hc6XX115gKD8XHTVddsbCzTt0WL/O5NZZinLeZpK6x5wqcLna4E8JSIPAPgabhj8I972F6BefMyzx96qJ4tTy27P1dc4V8/poN52mKetphnIS/PonlGVX9PVa9X1beoat3HUuvtzTy/777GOY544YLrT1pfn399mQ7maYt52mKehQJ9Jevy5ZnnR44ATzzhX1+yPf64G+EuLbufjYx52mKetphnoUAX+BUrcufvuceffuTL70d+PxsV87TFPG0xzyJKHZz3Y+Joko2NedpinrbCmifCOpqkSOEpTvfe609fSrW/fn397zZTLeZpi3naYp6FeEenOuIdc2wxT1vM0xbv6FQHs2blvqufOQM89pg/fXn00czGBly/muk/D8A8rTFPW8wzT6ljN35M1sfg08J2l3WvMU9bzNNW2PJEWI/Bp3V0ANu2ZeaHh+t/IcSDD+YOZ7ptm+tXM2KetpinLeaZpVTl92Pyag8+bXAw847a1qYajXra3BuiUddeuu3Bwfq06zXmaYt52gpLniizB+97Uc+evC7wiYTqypW5G33nTu8+viWTqjt2qLa2Ztpctcr1IwiYpy3maSssebLAZ5mYUO3pyWyA9DG67dtV43GbNuJx1fvvzz0GB7h2JyZs2mgUzNMW87QVhjxZ4PNMTLh31uyNAajOnq26caO7OKEaBw+qbtjg1pO/7htuCN5/njTmaYt52gp6nizwRSQSucfo8qeBAdVdu1QnJ8uvZ3LSvW5goPS6BgeD87G3FOZpi3naCnKeLPBl7N3rTmEqtbEWLFDdssWN55w+dpdMuvktW9zvSy3b3e3WHybM0xbztBXEPFngpxCLqd5+u2okUnrjAart7aqLF7vHcq+LRNz6mvU84loxT1vM01bQ8mSBr9DZs6pbt7oBgcpt0FLTsmVu+bNnff1nNAzmaYt52gpKnuUKfODHoqmGKjA2BuzbB+zf7y6UOHnS3Q393Dl3T8U5c9ydWfr63PCfy5cDXV3NMzBTPTFPW8zTVrPnWW4sGhZ4IqImFurBxoiIwooFnogooFjgiYgCigWeiCigGupLVhE5BWDM735M4XIAv/W7EwHCPG0xT1vNkGeXqs4t9ouGKvDNQESipb6xpuljnraYp61mz5OHaIiIAooFnogooFjgp+/LfncgYJinLeZpq6nz5DF4IqKA4h48EVFAscATEQUUC/w0iMiNInJQRA6LyGf87k8zE5EHROQ3IvKs331pdiLSKSJPichzInJARG71u0/NTERaReQnIvLzVJ53+N2navEYfIVEZAaAQwAGABwF8DSAD6nqc752rEmJyLsAxAA8pKpv8bs/zUxErgRwpaqOiMhMAMMA3s+/zeqIiADoUNWYiFwM4IcAblXVf/O5a9PGPfjKvQ3AYVX9taq+BuBRAO/zuU9NS1V/AOC03/0IAlU9rqojqefnAPwSwFX+9qp5pe6jEUvNXpyamnJPmAW+clcBOJI1fxT8T0QNRkS6AfwegB/725PmJiIzRORnAH4D4Duq2pR5ssATBYSIRAB8E8AGVX3Z7/40M1V9XVXfCmABgLeJSFMeRmSBr9xLADqz5hekfkbku9Sx4m8C+Iqq/qPf/QkKVZ0A8BSAG/3uSzVY4Cv3NIAlInK1iFwC4L8C+JbPfSJKfym4HcAvVfXv/O5PsxORuSIyO/W8De7Eil/526vqsMBXSFUvAPgUgG/DfYn1NVU94G+vmpeIfBXAfgDXishREfmE331qYr8P4KMAVorIz1LTe/zuVBO7EsBTIvIM3I7dd1T1cZ/7VBWeJklEFFDcgyciCigWeCKigGKBJyIKKBZ4IqKAYoEnIgooFnhqeiIyKiKXG60rVuLnO0XkAzWs93Mi8mdFfj5fRL5R7XqJymGBJ/KAiLRU8jpVPaaqVb9xEJXDAk9NQ0Q6ROSJ1Djdz4rIn2T9+tMiMiIivxCR3029fo6I7BaRZ0Tk30Tk+tTPc/amU+vqzmtLROTu1Pj//w/Am7J+1yci3xeRYRH5dmq4XojIv4jIF0QkCqDYmOw9IrJfRJ4XkcHUMt3pMfFF5OMi8o8i8mTqNf/XIjcKr4r2MogaxI0AjqnqTQAgIv8h63e/VdVeEVkP4M8AfBLAHQB+qqrvF5GVAB4C8NYK2/ovAK4FsBTAFQCeA/BAasyXLwF4n6qeSr3J/AWAP00td4mq9pdY5/UA3gGgA8BPReSJIq95K9xokAkAB0XkS6p6pMjriKbEPXhqJr8AMCAify0i/1FVz2b9Lj3A1jCA7tTzdwJ4GABU9XsALhORWRW29S4AX02NKngMwPdSP78WwFsAfCc1nOxn4QaeS3uszDr/SVVfUdXfwg1g9bYir/muqp5V1Vfh3lS6KuwvUQHuwVPTUNVDItIL4D0A7hKR76rqnalfJ1KPr2Pqv+sLyN25aZ1GNwTAAVVdXuL38TLL5o8LUmyckETW80r+LUQlcQ+emoaIzAdwXlUfAfA3AHqnWORfAXw4tey74Q7jvAxgNL1s6g3j6iLL/gDAn6Ru/HAlgP+U+vlBAHNFZHlq+YtFZFmF/4T3pe73eRmAd8MNZEXkGe4dUDO5DsDfiEgSwCSA/z7F6z8Hd9z8GQDnAXws9fNvAlgrIgfg7nx0qMiyuwCshDtMMg438iVU9bXU6ZL/kPoOoAXAFwBUMrLoM3CHZi4HsEVVj+V/uUtkiaNJEhEFFA/REBEFFAs8EVFAscATEQUUCzwRUUCxwBMRBRQLPBFRQLHAExEF1P8Hf8SgQHORRiwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . x . . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " . x . . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " x . . . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " . . . . \n", "\n", " x . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " . . . . \n", "\n", " x . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " . . . . \n", "\n", " . x . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " . . . . \n", "\n", " . . x . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " . . . . \n", "\n", " . . x . \n", "\n", " . . . . \n", "\n", " . . . . \n", "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "[0.5, 0.0]\n", "--------------------------\n", "[0.25, 0.0]\n", "--------------------------\n", "[0.25, 0.25]\n", "--------------------------\n", "[0.0, 0.25]\n", "--------------------------\n", "[0.0, 0.5]\n", "--------------------------\n", "[0.0, 0.5]\n", "--------------------------\n", "[0.25, 0.5]\n", "--------------------------\n", "[0.5, 0.5]\n", "--------------------------\n", "[0.5, 0.25]\n", "--------------------------\n" ] } ], "source": [ "drawQfromActions(bins,actions)" ] }, { "cell_type": "code", "execution_count": 406, "metadata": {}, "outputs": [], "source": [ "def drawStatePosition(bins,state, index = 0):\n", " plt.grid(True)\n", " plt.ylim(-0.5,bins[1])\n", " plt.xlim(-0.5,bins[0])\n", " plt.xticks(list(range(bins[0])))\n", " plt.yticks(list(range(bins[1])))\n", " plt.scatter(state[0],state[1],marker=\"x\",linewidths=10,c='r')\n", " plt.gca().invert_yaxis()\n", " plt.savefig(graphdir+\"/state-\"+str(index)+\".png\")\n", " plt.show()\n", "# for y in range(bins[1]):\n", "# for x in range(bins[0]):\n", "# if x ==state[0] and y==state[1]:\n", "# print(\" x \",end = \"\")\n", "# else:\n", "# print(\" . \",end=\"\")\n", "# print(\"\\n\")" ] }, { "cell_type": "code", "execution_count": 352, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'bests' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdrawQfromActions\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbests\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbins\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbests\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'bests' is not defined" ] } ], "source": [ "drawQfromActions(bests[2].bins,bests[2].actions)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "for s in bests[1].stateHist:\n", " drawStatePosition(bests[0].bins,s)\n", " print(\"------------\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "np.ravel(st[:,1])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(np.ravel(st[:,0]),np.ravel(st[:,1]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "[3,2] == list((3,2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = [1,2,3]\n", "a[:-1]" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:mlagents.envs:Environment shut down with return code 0.\n" ] } ], "source": [ "env.close()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.9" } }, "nbformat": 4, "nbformat_minor": 2 }