Temps execution - Multithreading.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8a12dba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import GPy\n",
    "import random\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "from IPython.display import display\n",
    "from tqdm import tqdm\n",
    "import scipy\n",
    "import time\n",
    "import threading\n",
    "\n",
    "import tensorflow as tf\n",
    "import tf_agents\n",
    "from tf_agents.environments import py_environment\n",
    "from tf_agents.environments import tf_py_environment\n",
    "from tf_agents.specs import array_spec\n",
    "from tf_agents.environments import wrappers\n",
    "from tf_agents.trajectories import time_step as ts\n",
    "from tf_agents.agents.categorical_dqn import categorical_dqn_agent\n",
    "from tf_agents.networks import categorical_q_network\n",
    "from tf_agents.trajectories import trajectory\n",
    "from tf_agents.utils import common\n",
    "\n",
    "tf.compat.v1.enable_v2_behavior()\n",
    "np.random.seed(123)\n",
    "random.seed(123)\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dfdeb171",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version:  3.9.7\n",
      "NetworkX version:  2.6.3\n",
      "Scipy version:  1.7.1\n",
      "Numpy version:  1.20.3\n",
      "GPy version:  1.10.0\n",
      "TensorFlow version:  2.8.0\n",
      "TF Agents version:  0.11.0\n"
     ]
    }
   ],
   "source": [
    "from platform import python_version\n",
    "print(\"Python version: \", python_version())\n",
    "print(\"NetworkX version: \", nx.__version__)\n",
    "print(\"Scipy version: \", scipy.__version__)\n",
    "print(\"Numpy version: \", np.__version__)\n",
    "print(\"GPy version: \", GPy.__version__)\n",
    "print(\"TensorFlow version: \", tf.__version__)\n",
    "print(\"TF Agents version: \", tf_agents.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "683d84a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten(liste):\n",
    "    return [item for sublist in liste for item in sublist]\n",
    "\n",
    "def preprocessing(X_s):\n",
    "    X = []\n",
    "    for liste in X_s:\n",
    "        X += liste.copy()\n",
    "    return np.array(X)\n",
    "\n",
    "def copie_paths(paths):\n",
    "    X = []\n",
    "    for liste in paths:\n",
    "        X.append(liste.copy())\n",
    "    return X\n",
    "\n",
    "def copy_X_D(X_D):\n",
    "    X = []\n",
    "    for liste in X_D:\n",
    "        X.append(liste.copy())\n",
    "    return np.array(X)\n",
    "\n",
    "def concatenate(x, y):\n",
    "    if len(x)==0:\n",
    "        return y\n",
    "    else:\n",
    "        return np.concatenate((x, y))\n",
    "\n",
    "def mean_confidence_interval(data, confidence=0.95):\n",
    "    a = 1.0 * np.array(data)\n",
    "    n = len(a)\n",
    "    m, se = np.mean(a), scipy.stats.sem(a)\n",
    "    h = se * scipy.stats.t.ppf((1 + confidence) / 2., n-1)\n",
    "    return m, m-h, m+h\n",
    "\n",
    "def distance(a,b):\n",
    "    return np.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)\n",
    "        \n",
    "def sigma_matrix(gp_model, X_v):\n",
    "    return gp_model.kern.K(X_v, X_v)\n",
    "    \n",
    "def sigma_prime_matrix(gp_model, X_v, X_s):\n",
    "    kernel = gp_model.rbf\n",
    "    variance_n = float(gp_model.Gaussian_noise.variance)\n",
    "    a = kernel.K(X_v, X_v)\n",
    "    b = kernel.K(X_v, X_s)\n",
    "    c = kernel.K(X_s, X_s)\n",
    "    d = variance_n*np.eye(len(X_s))\n",
    "    e = kernel.K(X_s, X_v)\n",
    "    f = np.linalg.inv(c + d)\n",
    "    g = np.dot(b, f)\n",
    "    h = np.dot(g, e)\n",
    "    return a - h\n",
    "\n",
    "def reward_function(gp_model, X_v, X_s_old, X_s_new):\n",
    "    if len(X_s_old)==0:\n",
    "        sigma_prime_old = sigma_matrix(gp_model, X_v)\n",
    "    else:\n",
    "        sigma_prime_old = sigma_prime_matrix(gp_model, X_v, X_s_old)\n",
    "    if len(X_s_new)==0:\n",
    "        sigma_prime_new = sigma_matrix(gp_model, X_v)\n",
    "    else:\n",
    "        sigma_prime_new = sigma_prime_matrix(gp_model, X_v, X_s_new)\n",
    "    return 0.5 * (np.log(np.linalg.det(sigma_prime_old)) - np.log(np.linalg.det(sigma_prime_new)))\n",
    "\n",
    "def credit_assignment(env, reward, dones):\n",
    "    if env.nb_agents==1:\n",
    "        return np.array([reward])\n",
    "    rewards = np.zeros(env.nb_agents)\n",
    "    if reward==0:\n",
    "        return rewards\n",
    "    X_s = preprocessing(env.X_s)\n",
    "    H = np.log(np.linalg.det(sigma_prime_matrix(env.gp_model, env.X_v, X_s)))\n",
    "    for i in range(env.nb_agents):\n",
    "        if not dones[i]:\n",
    "            X_s_i = env.X_s.copy()\n",
    "            del X_s_i[i]\n",
    "            X_s_i = preprocessing(X_s_i)\n",
    "            if len(X_s_i)==0:\n",
    "                rewards[i] = 0.5 * (np.log(np.linalg.det(sigma_matrix(env.gp_model, env.X_v))) - H)\n",
    "            else:\n",
    "                rewards[i] = 0.5 * (np.log(np.linalg.det(sigma_prime_matrix(env.gp_model, env.X_v, X_s_i))) - H)\n",
    "    somme = np.sum(rewards)\n",
    "    if somme==0:\n",
    "        return rewards\n",
    "    return rewards*(reward/(np.sum(rewards)))\n",
    "\n",
    "def construct_graph(graph_dim, graph_unity):\n",
    "    x = graph_dim[0]\n",
    "    y = graph_dim[1]\n",
    "    i, j = 0.0, 0.0\n",
    "    graph = nx.Graph()\n",
    "    for k in range(x*y):\n",
    "        graph.add_node(k, coord=[i, j])\n",
    "        i += graph_unity\n",
    "        if i==x*graph_unity:\n",
    "            i = 0.0\n",
    "            j += graph_unity\n",
    "    for k in range(x*y):\n",
    "        if (k+1)%x!=0:\n",
    "            graph.add_edge(k, k+1)\n",
    "        if k<x*y-x:\n",
    "            graph.add_edge(k, k+x)\n",
    "    return graph\n",
    "            \n",
    "def show_graph(graph):\n",
    "    nx.draw(graph, with_labels=True, font_weight='bold')\n",
    "\n",
    "def remove_nodes_from_graph(graph, liste):\n",
    "    graph.remove_nodes_from(liste)\n",
    "    return graph\n",
    "\n",
    "def incertitude_initiale(sigma, graph):\n",
    "    return 0.5 * np.log(np.linalg.det(sigma)) + (graph.number_of_nodes()/2) * (1 + np.log(2*np.pi))\n",
    "\n",
    "def coord_to_id(coord, graph_dim):\n",
    "    return graph_dim[0] * int(coord[1]) + int(coord[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fc691978",
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_pilot_data(nb_agents, exploration_steps, graph, graph_dim, means, variance, lengthscale, memory_window, gamma):\n",
    "    X_D = np.array([graph.nodes[i][\"coord\"] for i in range(graph.number_of_nodes())])\n",
    "    simulation_kernel = GPy.kern.RBF(input_dim = 2, variance=variance, lengthscale=lengthscale)\n",
    "    cov = simulation_kernel.K(X_D)\n",
    "    X, Y = [], []\n",
    "    for _ in range(exploration_steps):\n",
    "        Y_D = np.random.multivariate_normal(np.array(means), cov, 1)[0]\n",
    "        Y_D = np.reshape(Y_D, (len(Y_D),1))\n",
    "        Y_D[Y_D<0] = 0.1\n",
    "        sparse_nodes = random.sample(range(0, graph.number_of_nodes()), nb_agents)\n",
    "        sorted_nodes = sorted(sparse_nodes)\n",
    "        if sorted_nodes[0]==0:\n",
    "            for i in range(1,len(sorted_nodes)):\n",
    "                if sorted_nodes[i]!=sorted_nodes[i-1]:\n",
    "                    l = covariances[sorted_nodes[i]-1]\n",
    "                    l[0], l[1], l[2], l[3] = weighted_covariance(l[0], l[1], l[2], l[3], Y_D[0], Y_D[sorted_nodes[i]], memory_window, gamma)\n",
    "        X.append(X_D[sparse_nodes])\n",
    "        Y.append(Y_D[sparse_nodes])\n",
    "    return incertitude_initiale(cov, graph), np.array(X), np.array(Y)\n",
    "\n",
    "def hyperparameters_estimator(X, Y, gp_model, graph, graph_dim, memory_window, gamma):\n",
    "    for i in range(len(X)):\n",
    "        l = variances[coord_to_id(X[i], graph_dim)]\n",
    "        l[0], l[1], l[2] = weighted_variance(l[0], l[1], l[2], Y[i][0], memory_window, gamma)\n",
    "    cumul_var = 0\n",
    "    coeffs = 0\n",
    "    for ele in variances:\n",
    "        coeffs += ele[2]\n",
    "        cumul_var += float(ele[0])*ele[2]\n",
    "    variance = cumul_var/coeffs\n",
    "    ###########################################\n",
    "    X_v = np.array([graph.nodes[i][\"coord\"] for i in range(graph.number_of_nodes())])\n",
    "    moyenne = np.reshape(gp_model.predict(X_v)[0], (graph.number_of_nodes(),))\n",
    "    ###########################################\n",
    "    lengthscale, cpt = 0, 0\n",
    "    for i in range(len(covariances)):\n",
    "        if covariances[i][0]>1:\n",
    "            covariance = covariances[i][1] - covariances[i][2]*covariances[i][3]\n",
    "            if 0<covariance<variance:\n",
    "                cpt += covariances[i][0]\n",
    "                lengthscale += find_lengthscale(X_v[0], X_v[i+1], covariance, variance) * covariances[i][0]\n",
    "    if cpt!=0:\n",
    "        lengthscale /= cpt\n",
    "    else:\n",
    "        lengthscale = 0\n",
    "    return moyenne, variance, lengthscale\n",
    "\n",
    "def find_lengthscale(x1, x2, y, var):\n",
    "    return distance(x1, x2) * np.sqrt(-0.5/np.log(y/var))\n",
    "\n",
    "def weighted_covariance(n, moy_prod, moy_x, moy_y, x_new, y_new, memory_capacity, gamma):\n",
    "    if n>memory_capacity:\n",
    "        return n + 1, gamma * moy_prod + (1-gamma) * x_new * y_new, gamma * moy_x + (1-gamma) * x_new, gamma * moy_y + (1-gamma) * y_new\n",
    "    return n + 1, (n * moy_prod + x_new * y_new)/(n + 1), (n * moy_x + x_new)/(n + 1), (n * moy_y + y_new)/(n + 1)\n",
    "\n",
    "def weighted_variance(var, moy, n, x_new, memory_capacity, gamma):\n",
    "    if n>memory_capacity:\n",
    "        a = gamma*(var+(moy**2)) + (1-gamma)*(x_new**2)\n",
    "        moy = gamma * moy + (1-gamma) * x_new\n",
    "    else:\n",
    "        a = (n*(var+(moy**2)) + (x_new**2))/(n+1)\n",
    "        moy = (n*moy+x_new)/(n+1)\n",
    "    return a-moy**2, moy, n+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "60e90449",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variance:  7.102587673500872\n",
      "Lengthscale:  [2.04531066]\n",
      "Carte:  [59.73235482 32.29178614 19.96140899 14.6273486   9.62287523 32.11552907\n",
      " 26.32580708 23.42204559 16.75472862  9.0532632  18.12702558 23.24095112\n",
      " 24.13850122 19.03094347 12.9759214  12.87103999 16.8960803  18.73692827\n",
      " 17.90248296 14.38394321  9.96150552  9.2792381  11.34516906 14.47060808\n",
      " 12.80547446]\n",
      "Incertitude initiale :  76.51867934794961\n"
     ]
    }
   ],
   "source": [
    "graph_dim = (5, 5)\n",
    "graph_unity = 1\n",
    "graph = construct_graph(graph_dim, graph_unity)\n",
    "X_v = np.array([graph.nodes[i][\"coord\"] for i in range(graph.number_of_nodes())])\n",
    "means = [60, 30, 20, 15, 10, 30, 27.5, 25, 17.5, 11.25, 20, 25, 22.5, 20, 12.5, 15, 17.5, 20, 17.5, 15, 10, 11.25, 12.5, 15, 12.5]\n",
    "nb_agents = 6\n",
    "exploration_steps = 25\n",
    "variance_lengthscale = [10, 2]\n",
    "memory_window = 1000\n",
    "gamma = 0.997\n",
    "\n",
    "variances = [[0, 0, 0] for _ in range(graph.number_of_nodes())]\n",
    "covariances = [[0, 0, 0, 0] for _ in range(graph.number_of_nodes()-1)]\n",
    "\n",
    "incertitude, x, y = collect_pilot_data(nb_agents, exploration_steps, graph, graph_dim, means, variance_lengthscale[0], variance_lengthscale[1], memory_window, gamma)\n",
    "\n",
    "x = np.reshape(x, (nb_agents*exploration_steps,2))\n",
    "y = np.reshape(y, (nb_agents*exploration_steps,1))\n",
    "\n",
    "gp_model = GPy.models.GPRegression(x, y, GPy.kern.RBF(2))\n",
    "gp_model.optimize(messages=False)\n",
    "\n",
    "moyenne, var, l = hyperparameters_estimator(x, y, gp_model, graph, graph_dim, memory_window, gamma)\n",
    "print(\"Variance: \", var)\n",
    "print(\"Lengthscale: \", l)\n",
    "print(\"Carte: \", moyenne)\n",
    "print(\"Incertitude initiale : \", incertitude_initiale(sigma_matrix(gp_model, X_v), graph))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74bb46a3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f017e26",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a95bbca0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "542d999c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_gp_model(gp_model, x, y, graph, graph_dim, memory_window, gamma, display_gp_model=False):\n",
    "    moy, variance, lengthscale = hyperparameters_estimator(x, y, gp_model, graph, graph_dim, memory_window, gamma)\n",
    "    X = np.concatenate((gp_model.X, x))[-1000:]\n",
    "    Y = np.concatenate((gp_model.Y, y))[-1000:]\n",
    "    gp_model.set_XY(X, Y)\n",
    "    gp_model.optimize(messages=False)\n",
    "    if display_gp_model:\n",
    "        display(gp_model)\n",
    "    return gp_model, moy, variance, lengthscale\n",
    "\n",
    "def take_measurements(nodes, means, X_v, memory_window, gamma):\n",
    "    simulation_kernel = GPy.kern.RBF(input_dim = 2, variance=variance_lengthscale[0], lengthscale=variance_lengthscale[1])\n",
    "    cov = simulation_kernel.K(X_v)\n",
    "    Y_v = np.random.multivariate_normal(np.array(means), cov, 1)[0]\n",
    "    Y_v = np.reshape(Y_v, (len(Y_v),1))\n",
    "    Y_v[Y_v<0] = 0.1\n",
    "    sorted_nodes = sorted(nodes)\n",
    "    if sorted_nodes[0]==0:\n",
    "        for i in range(1,len(sorted_nodes)):\n",
    "            if sorted_nodes[i]!=sorted_nodes[i-1]:\n",
    "                l = covariances[sorted_nodes[i]-1]\n",
    "                l[0], l[1], l[2], l[3] = weighted_covariance(l[0], l[1], l[2], l[3], Y_v[0], Y_v[sorted_nodes[i]], memory_window, gamma)\n",
    "    return X_v[nodes], Y_v[nodes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8b643543",
   "metadata": {},
   "outputs": [],
   "source": [
    "class pfeEnv(py_environment.PyEnvironment):\n",
    "\n",
    "    def __init__(self, graph, gp_model, nb_agents, budgets, graph_unity, graph_dim, initial_positions, variance_0, lengthscale_0, memory_window, gamma, train_env=True):\n",
    "        self.nb_agents = nb_agents\n",
    "        self.graph = graph\n",
    "        self.graph_unity = graph_unity\n",
    "        self.graph_dim = graph_dim\n",
    "        self.initial_budgets = budgets/self.graph_unity\n",
    "        self.budgets = self.initial_budgets.copy()\n",
    "        if initial_positions!=None:\n",
    "            self.initial_positions = copie_paths(initial_positions)\n",
    "            self.paths = copie_paths(initial_positions)\n",
    "        else:\n",
    "            self.initial_positions = None\n",
    "            self.paths = [[random.randint(0, self.graph.number_of_nodes()-1)] for i in range(self.nb_agents)]\n",
    "        self.neighbors = [sorted(list(self.graph.neighbors(self.current_node(i)))) for i in range(self.nb_agents)]\n",
    "        self.formater()\n",
    "        self.X_v = np.array([self.graph.nodes[i][\"coord\"] for i in range(self.graph.number_of_nodes())])\n",
    "        self.gp_model = gp_model\n",
    "        self.X_s = [[] for i in range(self.nb_agents)]\n",
    "        self.dones = [False for i in range(self.nb_agents)]\n",
    "        self.cpt_done = 0\n",
    "        self._action_spec = array_spec.BoundedArraySpec(shape=(), dtype=np.int32, minimum=0, maximum=3, name=\"action\")\n",
    "        self._observation_spec = array_spec.BoundedArraySpec(shape=(self.nb_agents*2,), dtype=np.float32, minimum=np.zeros((self.nb_agents*2,)), name=\"observation\")\n",
    "        self._state = flatten([self.graph.nodes[self.current_node(i)][\"coord\"] for i in range(self.nb_agents)])\n",
    "        self._episode_ended = False\n",
    "        #################################\n",
    "        self.cpt_update_gp_model = 0\n",
    "        self.memory_window, self.gamma = memory_window, gamma\n",
    "        self.x, self.y = np.array([]), np.array([])\n",
    "        self.liste_variances, self.liste_lengthscales = [variance_0], [lengthscale_0]\n",
    "        self.train_env = train_env\n",
    "        \n",
    "    def current_node(self, id_agent):\n",
    "        return self.paths[id_agent][-1]\n",
    "\n",
    "    def action_spec(self):\n",
    "        return self._action_spec\n",
    "\n",
    "    def observation_spec(self):\n",
    "        return self._observation_spec\n",
    "    \n",
    "    def formater(self):\n",
    "        for i in range(len(self.neighbors)):\n",
    "            liste = self.neighbors[i]\n",
    "            node = self.current_node(i)\n",
    "            try:\n",
    "                if liste[0]>=node-1:\n",
    "                    liste.insert(0,-1)\n",
    "                if liste[1]!=node-1:\n",
    "                    liste.insert(1,-1)\n",
    "                if liste[2]!=node+1:\n",
    "                    liste.insert(2,-1)\n",
    "            except:\n",
    "                pass\n",
    "            for _ in range(4-len(liste)):\n",
    "                liste.append(-1)\n",
    "\n",
    "    def _reset(self):\n",
    "        if self.initial_positions!=None:\n",
    "            self.paths = copie_paths(self.initial_positions)\n",
    "        else:\n",
    "            self.paths = [[random.randint(0, self.graph.number_of_nodes()-1)] for i in range(self.nb_agents)]\n",
    "        self._state = flatten([self.graph.nodes[self.current_node(i)][\"coord\"] for i in range(self.nb_agents)])\n",
    "        self.neighbors = [sorted(list(self.graph.neighbors(self.current_node(i)))) for i in range(self.nb_agents)] \n",
    "        self.formater()\n",
    "        self.budgets = self.initial_budgets.copy()\n",
    "        self.X_s = [[] for i in range(self.nb_agents)]\n",
    "        self.dones = [False for i in range(self.nb_agents)]\n",
    "        self.cpt_done = 0\n",
    "        self._episode_ended = False\n",
    "        return ts.restart(np.array(self._state, dtype=np.float32))\n",
    "        \n",
    "    def _step(self, abstract_actions):\n",
    "        if self._episode_ended:\n",
    "            return self.reset()\n",
    "        actions = []\n",
    "        for i in range(self.nb_agents):\n",
    "            actions.append(self.neighbors[i][abstract_actions[i]])\n",
    "        X_s_old = preprocessing(self.X_s)\n",
    "        for i in range(self.nb_agents):\n",
    "            if not self.dones[i]:\n",
    "                if actions[i]!=-1:\n",
    "                    self.X_s[i].append([graph.nodes[actions[i]][\"coord\"][0], graph.nodes[actions[i]][\"coord\"][1]])\n",
    "                    self.budgets[i] -= 1\n",
    "                else:\n",
    "                    actions[i] = self.current_node(i)\n",
    "                    self.budgets[i] -= 0.3\n",
    "                if self.budgets[i]<1:\n",
    "                    self.dones[i] = True\n",
    "                    self.cpt_done += 1\n",
    "                self.paths[i].append(actions[i])\n",
    "                coord = self.graph.nodes[self.current_node(i)][\"coord\"]\n",
    "                self._state[2*i] = coord[0]\n",
    "                self._state[2*i+1] = coord[1]\n",
    "        \n",
    "        if self.train_env:\n",
    "            positions, mesures = take_measurements(actions, means, self.X_v, self.memory_window, self.gamma)\n",
    "            self.x = concatenate(self.x, positions)\n",
    "            self.y = concatenate(self.y, mesures)\n",
    "            self.cpt_update_gp_model = (self.cpt_update_gp_model + 1)%100\n",
    "            if self.cpt_update_gp_model==0:\n",
    "                self.gp_model, m, var, l = update_gp_model(self.gp_model, self.x, self.y, self.graph, self.graph_dim, self.memory_window, self.gamma)\n",
    "                self.liste_variances.append(var)\n",
    "                self.liste_lengthscales.append(l)\n",
    "                self.moy = m\n",
    "                self.x, self.y = np.array([]), np.array([])\n",
    "        \n",
    "        self.neighbors = [sorted(list(self.graph.neighbors(self.current_node(i)))) for i in range(self.nb_agents)]\n",
    "        self.formater()\n",
    "        reward = reward_function(self.gp_model, self.X_v, X_s_old, preprocessing(self.X_s))\n",
    "        if self.cpt_done==self.nb_agents:\n",
    "            self._episode_ended = True\n",
    "            return ts.termination(np.array(self._state, dtype=np.float32), reward)\n",
    "        return ts.transition(np.array(self._state, dtype=np.float32), reward=reward, discount=0.97)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6baa6a76",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_iterations = 10000\n",
    "fc_layer_params = (128,64,)\n",
    "replay_buffer_capacity = 300000\n",
    "batch_size = 128\n",
    "learning_rate = 1e-5\n",
    "\n",
    "num_atoms = 51\n",
    "min_q_value = -20\n",
    "max_q_value = 20\n",
    "n_step_update = 3\n",
    "gamma = 0.99\n",
    "\n",
    "num_eval_episodes = 10\n",
    "log_eval_interval = 1000\n",
    "\n",
    "max_episode_length = 25\n",
    "budgets = 25 * np.ones(nb_agents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d93bc57c",
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_positions = None #[[random.randint(0, graph.number_of_nodes()-1)] for i in range(nb_agents)]\n",
    "train_py_env = wrappers.TimeLimit(pfeEnv(graph, gp_model, nb_agents, budgets, graph_unity, graph_dim, initial_positions, var, l, memory_window, gamma, train_env=True), duration=max_episode_length)\n",
    "eval_py_env = wrappers.TimeLimit(pfeEnv(graph, gp_model, nb_agents, budgets, graph_unity, graph_dim, initial_positions, var, l, memory_window, gamma, train_env=False), duration=max_episode_length)\n",
    "\n",
    "train_env = tf_py_environment.TFPyEnvironment(train_py_env)\n",
    "eval_env = tf_py_environment.TFPyEnvironment(eval_py_env)\n",
    "\n",
    "agents_tf = []\n",
    "eval_policies = []\n",
    "collect_policies = []\n",
    "policies_checkpointers = []\n",
    "\n",
    "for i in range(nb_agents):\n",
    "    categorical_q_net = categorical_q_network.CategoricalQNetwork(\n",
    "        train_env.observation_spec(),\n",
    "        train_env.action_spec(),\n",
    "        num_atoms=num_atoms,\n",
    "        fc_layer_params=fc_layer_params)\n",
    "        \n",
    "    optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate)\n",
    "\n",
    "    train_step_counter = tf.compat.v2.Variable(0)\n",
    "\n",
    "    agents_tf.append(categorical_dqn_agent.CategoricalDqnAgent(\n",
    "        train_env.time_step_spec(),\n",
    "        train_env.action_spec(),\n",
    "        categorical_q_network=categorical_q_net,\n",
    "        optimizer=optimizer,\n",
    "        min_q_value=min_q_value,\n",
    "        max_q_value=max_q_value,\n",
    "        n_step_update=n_step_update,\n",
    "        target_update_period=5,\n",
    "        target_update_tau=0.05,\n",
    "        td_errors_loss_fn=common.element_wise_squared_loss,\n",
    "        gamma=gamma,\n",
    "        train_step_counter=train_step_counter))\n",
    "\n",
    "    agents_tf[-1].initialize()\n",
    "\n",
    "    eval_policies.append(agents_tf[-1].policy)\n",
    "    collect_policies.append(agents_tf[-1].collect_policy)\n",
    "    \n",
    "    policies_checkpointers.append(common.Checkpointer(ckpt_dir='MultiThreading_Politique_'+str(i), policy=eval_policies[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "562a871b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_avg_return(environment, policies, num_episodes=10):\n",
    "    total_return = 0.0\n",
    "    for _ in range(num_episodes):\n",
    "        time_step = environment.reset()\n",
    "        episode_return = 0.0\n",
    "        while not time_step.is_last():\n",
    "            actions = []\n",
    "            for i in range(nb_agents):\n",
    "                actions.append(policies[i].action(time_step).action.numpy()[0])\n",
    "            actions = tf.convert_to_tensor([actions])\n",
    "            time_step = environment.step(actions)\n",
    "            episode_return += time_step.reward\n",
    "        total_return += episode_return\n",
    "    avg_return = total_return / num_episodes\n",
    "    return avg_return.numpy()[0]\n",
    "\n",
    "def collect_step(environment, environment_py, policies):\n",
    "    time_step = environment.current_time_step()\n",
    "    actions = []\n",
    "    actions_step = []\n",
    "    dones = environment_py.dones.copy()\n",
    "    for i in range(nb_agents):\n",
    "        actions_step.append(policies[i].action(time_step))\n",
    "        actions.append(actions_step[-1].action.numpy()[0])\n",
    "    actions = tf.convert_to_tensor([actions])\n",
    "    next_time_step = environment.step(actions)\n",
    "    rewards = credit_assignment(environment_py, next_time_step.reward.numpy()[0], dones)\n",
    "    for i in range(nb_agents):\n",
    "        if not dones[i]:\n",
    "            nts = next_time_step._replace(reward=tf.convert_to_tensor([rewards[i]], dtype=np.float32))\n",
    "            traj = trajectory.from_transition(time_step, actions_step[i], nts)\n",
    "            replay_buffers[i].add_batch(traj)\n",
    "            \n",
    "class Train_Thread(threading.Thread):\n",
    "    def __init__(self, event, iterator, agent):\n",
    "        threading.Thread.__init__(self)\n",
    "        self.event = event\n",
    "        self.iterator = iterator\n",
    "        self.agent = agent\n",
    "\n",
    "    def run(self):\n",
    "        experience, _ = next(self.iterator)\n",
    "        self.agent.train(experience=experience)\n",
    "        self.event.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5ea3fe65",
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_buffers = []\n",
    "for i in range(nb_agents):\n",
    "    replay_buffers.append(tf_agents.replay_buffers.TFUniformReplayBuffer(\n",
    "        data_spec = agents_tf[i].collect_data_spec,\n",
    "        batch_size = train_env.batch_size,\n",
    "        max_length = replay_buffer_capacity))\n",
    "\n",
    "iterators = []\n",
    "for i in range(nb_agents):\n",
    "    dataset = replay_buffers[i].as_dataset(\n",
    "        num_parallel_calls=3,\n",
    "        sample_batch_size=batch_size,\n",
    "        num_steps=2).prefetch(3)\n",
    "\n",
    "    iterators.append(iter(dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f61a627d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.762167\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:56<00:00, 17.63it/s]\n",
      "  0%|                                                                                        | 0/10000 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\hm_as\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\dispatch.py:1082: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
      "Instead of:\n",
      "results = tf.foldr(fn, elems, back_prop=False)\n",
      "Use:\n",
      "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\hm_as\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\dispatch.py:1082: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
      "Instead of:\n",
      "results = tf.foldr(fn, elems, back_prop=False)\n",
      "Use:\n",
      "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 5 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x00000263C10A49D0>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 5 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x00000263C10A49D0>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:6 out of the last 6 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x00000263C21020A0>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:6 out of the last 6 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x00000263C21020A0>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      " 10%|███████▌                                                                   | 1003/10000 [01:31<1:59:38,  1.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1000: Average Return = 27.405838012695312\n",
      "Variance :  10.709488351109\n",
      "Lengthscale :  [2.13064145]\n",
      "MSE de la moyenne :  0.7996988361689027\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|███████████████                                                            | 2001/10000 [03:09<2:33:29,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2000: Average Return = 35.26365280151367\n",
      "Variance :  9.788293102841115\n",
      "Lengthscale :  [2.05474622]\n",
      "MSE de la moyenne :  0.44548544647457533\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|██████████████████████▌                                                    | 3001/10000 [04:51<2:17:10,  1.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3000: Average Return = 46.91075897216797\n",
      "Variance :  10.197598536956077\n",
      "Lengthscale :  [2.13042033]\n",
      "MSE de la moyenne :  0.2811363441050984\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|██████████████████████████████                                             | 4001/10000 [06:33<2:01:02,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4000: Average Return = 46.668975830078125\n",
      "Variance :  9.899997953261488\n",
      "Lengthscale :  [2.14452807]\n",
      "MSE de la moyenne :  0.9059393524120243\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████████████████████████████████████▌                                     | 5001/10000 [08:19<1:37:10,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5000: Average Return = 38.733375549316406\n",
      "Variance :  9.83167328093306\n",
      "Lengthscale :  [2.03568202]\n",
      "MSE de la moyenne :  0.6063467288321671\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|█████████████████████████████████████████████                              | 6001/10000 [10:05<1:18:06,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6000: Average Return = 39.37042999267578\n",
      "Variance :  9.946631064524793\n",
      "Lengthscale :  [1.97589207]\n",
      "MSE de la moyenne :  0.2660092742205869\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|█████████████████████████████████████████████████████▉                       | 7001/10000 [11:46<58:38,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7000: Average Return = 38.1429557800293\n",
      "Variance :  10.236356903893352\n",
      "Lengthscale :  [1.92354838]\n",
      "MSE de la moyenne :  0.2843289733572205\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|█████████████████████████████████████████████████████████████▌               | 8001/10000 [13:31<40:26,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8000: Average Return = 39.71796417236328\n",
      "Variance :  9.815240706676525\n",
      "Lengthscale :  [2.0663591]\n",
      "MSE de la moyenne :  0.47892675054518\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████████████████████████████████████████████████████████████████▎       | 9001/10000 [15:17<20:00,  1.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9000: Average Return = 41.045265197753906\n",
      "Variance :  9.653586735831826\n",
      "Lengthscale :  [1.99013854]\n",
      "MSE de la moyenne :  0.40536941577409813\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 10000/10000 [16:57<00:00,  9.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10000: Average Return = 40.41889190673828\n",
      "Variance :  9.737297430566214\n",
      "Lengthscale :  [1.96336217]\n",
      "MSE de la moyenne :  0.31579430700928823\n",
      "Execution Time:  997.2269973754883\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "print(compute_avg_return(eval_env, eval_policies, num_eval_episodes))\n",
    "\n",
    "steps = []\n",
    "avg = []\n",
    "err = []\n",
    "\n",
    "start = time.time()\n",
    "for i in range(nb_agents):\n",
    "    agents_tf[i].train = common.function(agents_tf[i].train)\n",
    "    agents_tf[i].train_step_counter.assign(0)\n",
    "\n",
    "for _ in tqdm(range(1000)):\n",
    "    collect_step(train_env, train_py_env, collect_policies)\n",
    "events = [threading.Event() for _ in range(nb_agents)]\n",
    "temps_execution = time.time() - start\n",
    "\n",
    "for step in tqdm(range(1, num_iterations+1)):\n",
    "    start = time.time()\n",
    "    for _ in range(1):\n",
    "        collect_step(train_env, train_py_env, collect_policies)\n",
    "        \n",
    "    for event in events:\n",
    "        event.clear()\n",
    "    \n",
    "    for i in range(nb_agents):\n",
    "        thread = Train_Thread(events[i], iterators[i], agents_tf[i])\n",
    "        thread.start()\n",
    "        \n",
    "    for event in events:\n",
    "        event.wait()\n",
    "\n",
    "    temps_execution += (time.time() - start) \n",
    "    if step%log_eval_interval==0:\n",
    "        avg_return = compute_avg_return(eval_env, eval_policies, num_eval_episodes)\n",
    "        steps.append(step)\n",
    "        avg.append(avg_return)\n",
    "        print('step = {0}: Average Return = {1}'.format(step, avg_return))\n",
    "        print(\"Variance : \", train_py_env.liste_variances[-1])\n",
    "        print(\"Lengthscale : \", train_py_env.liste_lengthscales[-1])\n",
    "        err.append(np.mean((train_py_env.moy-means)**2))\n",
    "        print(\"MSE de la moyenne : \", err[-1])\n",
    "\n",
    "print(\"Execution Time: \", temps_execution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1bcd59fd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.535397\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [01:01<00:00, 16.23it/s]\n",
      "  0%|                                                                                        | 0/10000 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\hm_as\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\dispatch.py:1082: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
      "Instead of:\n",
      "results = tf.foldr(fn, elems, back_prop=False)\n",
      "Use:\n",
      "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\hm_as\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\dispatch.py:1082: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
      "Instead of:\n",
      "results = tf.foldr(fn, elems, back_prop=False)\n",
      "Use:\n",
      "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 5 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x0000029EB260EE20>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 5 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x0000029EB260EE20>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:6 out of the last 6 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x0000029EB2631070>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:6 out of the last 6 calls to <bound method TFAgent.train of <tf_agents.agents.categorical_dqn.categorical_dqn_agent.CategoricalDqnAgent object at 0x0000029EB2631070>> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      " 10%|███████▌                                                                   | 1001/10000 [01:42<2:49:44,  1.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1000: Average Return = 21.8000431060791\n",
      "Variance :  10.360777049932826\n",
      "Lengthscale :  [2.05962428]\n",
      "MSE de la moyenne :  1.335281401950001\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|███████████████                                                            | 2001/10000 [03:26<2:33:17,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2000: Average Return = 40.176883697509766\n",
      "Variance :  9.728559226716584\n",
      "Lengthscale :  [2.07506677]\n",
      "MSE de la moyenne :  0.48373607567050414\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|██████████████████████▌                                                    | 3001/10000 [05:12<2:14:29,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3000: Average Return = 35.13014221191406\n",
      "Variance :  10.927696366573407\n",
      "Lengthscale :  [1.93341052]\n",
      "MSE de la moyenne :  0.44451932935344485\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|██████████████████████████████                                             | 4001/10000 [06:58<2:00:54,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4000: Average Return = 31.54530906677246\n",
      "Variance :  10.044776718863544\n",
      "Lengthscale :  [2.03814116]\n",
      "MSE de la moyenne :  4.393701188410671\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████████████████████████████████████▌                                     | 5001/10000 [08:47<1:38:23,  1.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5000: Average Return = 16.10317611694336\n",
      "Variance :  9.651532912399707\n",
      "Lengthscale :  [2.0841846]\n",
      "MSE de la moyenne :  2.7707924199176768\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|█████████████████████████████████████████████                              | 6001/10000 [10:42<1:17:41,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6000: Average Return = 36.98417282104492\n",
      "Variance :  9.975744203690786\n",
      "Lengthscale :  [2.02071068]\n",
      "MSE de la moyenne :  0.5252541875640513\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|█████████████████████████████████████████████████████▉                       | 7001/10000 [12:25<58:06,  1.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7000: Average Return = 38.68305969238281\n",
      "Variance :  10.283714901748741\n",
      "Lengthscale :  [1.99464646]\n",
      "MSE de la moyenne :  0.8782754076137571\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|█████████████████████████████████████████████████████████████▌               | 8001/10000 [14:13<38:39,  1.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8000: Average Return = 39.34773254394531\n",
      "Variance :  10.084532653586434\n",
      "Lengthscale :  [2.0117988]\n",
      "MSE de la moyenne :  0.3483434469007864\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████████████████████████████████████████████████████████████████▎       | 9001/10000 [15:56<19:27,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9000: Average Return = 41.09564208984375\n",
      "Variance :  9.77131728778496\n",
      "Lengthscale :  [2.08288804]\n",
      "MSE de la moyenne :  0.41053688029204055\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 10000/10000 [17:39<00:00,  9.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10000: Average Return = 43.57168197631836\n",
      "Variance :  9.777957419739145\n",
      "Lengthscale :  [2.05876437]\n",
      "MSE de la moyenne :  0.5208593993757098\n",
      "Execution Time:  1045.1437935829163\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "print(compute_avg_return(eval_env, eval_policies, num_eval_episodes))\n",
    "\n",
    "steps = []\n",
    "avg = []\n",
    "err = []\n",
    "\n",
    "start = time.time()\n",
    "for i in range(nb_agents):\n",
    "    agents_tf[i].train = common.function(agents_tf[i].train)\n",
    "    agents_tf[i].train_step_counter.assign(0)\n",
    "\n",
    "for _ in tqdm(range(1000)):\n",
    "    collect_step(train_env, train_py_env, collect_policies)\n",
    "temps_execution = time.time() - start\n",
    "    \n",
    "for step in tqdm(range(1, num_iterations+1)):\n",
    "    start = time.time()\n",
    "    for _ in range(1):\n",
    "        collect_step(train_env, train_py_env, collect_policies)\n",
    "    \n",
    "    for i in range(nb_agents):\n",
    "        experience, _ = next(iterators[i])\n",
    "        agents_tf[i].train(experience=experience)\n",
    "\n",
    "    temps_execution += (time.time() - start)\n",
    "    if step%log_eval_interval==0:\n",
    "        avg_return = compute_avg_return(eval_env, eval_policies, num_eval_episodes)\n",
    "        steps.append(step)\n",
    "        avg.append(avg_return)\n",
    "        print('step = {0}: Average Return = {1}'.format(step, avg_return))\n",
    "        print(\"Variance : \", train_py_env.liste_variances[-1])\n",
    "        print(\"Lengthscale : \", train_py_env.liste_lengthscales[-1])\n",
    "        err.append(np.mean((train_py_env.moy-means)**2))\n",
    "        print(\"MSE de la moyenne : \", err[-1])\n",
    "        \n",
    "print(\"Execution Time: \", temps_execution)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "112316a7",
   "metadata": {},
   "source": [
    "## Résultats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "7e1b3ee0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nb_agents = [3, 4, 5]\n",
    "serv_res_opt = [1594.464802265167, 1970.9329478740692, 2916.3075466156006]\n",
    "serv_res_nopt = [1523.2471199035645, 1912.3376867771149, 2827.3631596565247]\n",
    "\n",
    "ax = plt.figure(figsize=(10,5)).gca()\n",
    "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
    "plt.plot(nb_agents, serv_res_opt, \"--or\")\n",
    "plt.plot(nb_agents, serv_res_nopt, \"--ob\")\n",
    "plt.legend([\"Avec Multithreading\", \"Sans Multithreading\"], loc =\"upper left\")\n",
    "plt.ylabel(\"Temps d'exécution\")\n",
    "plt.xlabel(\"Nombre d'agents\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1b996f2f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nb_agents = [3, 4, 5, 6]\n",
    "pc_res_opt = [614.235107421875, 744.7073295116425, 880.3115310668945, 997.2269973754883]\n",
    "pc_res_nopt = [652.9437737464905, 803.6504008769989, 898.3685305118561, 1045.1437935829163]\n",
    "\n",
    "ax = plt.figure(figsize=(10,5)).gca()\n",
    "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
    "plt.plot(nb_agents, pc_res_opt, \"--or\")\n",
    "plt.plot(nb_agents, pc_res_nopt, \"--ob\")\n",
    "plt.legend([\"Avec Multithreading\", \"Sans Multithreading\"], loc =\"upper left\")\n",
    "plt.ylabel(\"Temps d'exécution\")\n",
    "plt.xlabel(\"Nombre d'agents\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b329c5a5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eee13024",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e2d1e20",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "beefe0cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(nb_agents):\n",
    "    policies_checkpointers[i].save(global_step=agents_tf[i].train_step_counter)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}