Global Framework [Big Graph].ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "723586bb",
   "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 IPython.display import display\n",
    "from tqdm import tqdm\n",
    "import scipy\n",
    "import seaborn as sns\n",
    "from math import nan, isnan\n",
    "import time\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(1)\n",
    "random.seed(1)\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6f346427",
   "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 f_D(gp_model, X_v, X_s):\n",
    "    sigma = sigma_matrix(gp_model, X_v)\n",
    "    sigma_prime = sigma_prime_matrix(gp_model, X_v, X_s)\n",
    "    return 0.5 * (np.log(np.linalg.det(sigma)) - np.log(np.linalg.det(sigma_prime)))\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 pollutant_concentration(x, y, z, Q, u, h_s, g, V, T_a, T_s, a_y, b_y, a_z, b_z):\n",
    "    if x==0:\n",
    "        x = 0.7\n",
    "    sigma_y = sigma_function(x, a_y, b_y)\n",
    "    sigma_z = sigma_function(x, a_z, b_z)\n",
    "    H = h_s + delta_h(x, u, g, V, T_a, T_s)\n",
    "    return (Q/(2*np.pi*u*sigma_y*sigma_z))*np.exp(-y**2/(2*sigma_y))*(np.exp(-(z-H)**2/(2*sigma_y))+np.exp(-(z+H)**2/(2*sigma_y)))\n",
    "\n",
    "def sigma_function(x, a, b):\n",
    "    return a * (abs(x) ** b)\n",
    "\n",
    "def delta_h(x, u, g, V, T_a, T_s):\n",
    "    F = (g/np.pi) * V * ((T_s - T_a)/T_s)\n",
    "    return (1.6 * (F**(1/3)) * (x**(2/3))) / u\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])\n",
    "\n",
    "def plot_heat_map(means, graph_dim, ax=None):\n",
    "    means = np.reshape(np.array(means), (graph_dim[0],graph_dim[1]))\n",
    "    ax = sns.heatmap(means, linewidth = 0, cmap = 'coolwarm', ax=ax)\n",
    "    ax.invert_yaxis()\n",
    "    plt.show()\n",
    "    \n",
    "def plot_results(steps, avg_rewards, err, train_py_env, grd_truth_variances, grd_truth_lengthscales, perturbations_steps):\n",
    "    fig, axs = plt.subplots(1, 4, figsize=(20, 5))\n",
    "    axs[0].plot(steps, avg_rewards)\n",
    "    axs[1].plot(steps, err)\n",
    "    axs[2].plot(range(1,len(train_py_env.liste_variances)+1), train_py_env.liste_variances)\n",
    "    axs[3].plot(range(1,len(train_py_env.liste_lengthscales)+1), train_py_env.liste_lengthscales)\n",
    "    for var in grd_truth_variances:\n",
    "        axs[2].axhline(y=10, color='red', linestyle='--')\n",
    "    for l in grd_truth_lengthscales:\n",
    "        axs[3].axhline(y=l, color='red', linestyle='--')\n",
    "    for s in perturbations_steps:\n",
    "        axs[1].axvline(x=s, color='green', linestyle='--')\n",
    "        axs[2].axvline(x=s/100, color='green', linestyle='--')\n",
    "        axs[3].axvline(x=s/100, color='green', linestyle='--')\n",
    "        \n",
    "def compute_means(graph_dim, height, Q, u, h_s, g, V, T_a, T_s, a_y, b_y, a_z, b_z, display=False):\n",
    "    means = []\n",
    "    i = 0\n",
    "    j = -1 * int(graph_dim[1]/2)\n",
    "    i_m = 0\n",
    "    j_m = 0\n",
    "    matrice = [[-1 for _ in range(graph_dim[0])] for _ in range(graph_dim[1])]\n",
    "    for _ in range(graph_dim[1]):\n",
    "        for _ in range(graph_dim[0]):\n",
    "            concentration = pollutant_concentration(i, j, height, Q, u, h_s, g, V, T_a, T_s, a_y, b_y, a_z, b_z)\n",
    "            means.append(concentration + 10)\n",
    "            matrice[i_m][j_m] = concentration\n",
    "            i += 1\n",
    "            j_m += 1\n",
    "        j += 1\n",
    "        i = 0\n",
    "        j_m = 0\n",
    "        i_m += 1\n",
    "    if display:\n",
    "        ax = sns.heatmap(matrice, linewidth = 0, cmap = 'coolwarm')\n",
    "        ax.invert_yaxis()\n",
    "    return means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6b3f4c03",
   "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",
    "        \n",
    "        for i in sparse_nodes:\n",
    "            l = variances[i]\n",
    "            l[0], l[1], l[2] = weighted_variance(l[0], l[1], l[2], Y_D[i][0], memory_window, gamma)\n",
    "        \n",
    "        sorted_nodes = sorted(sparse_nodes)\n",
    "        \n",
    "        for j in range(len(sorted_nodes)):\n",
    "            if j==0 or sorted_nodes[j]!=sorted_nodes[j-1]:\n",
    "                for i in range(len(sorted_nodes)):\n",
    "                    if sorted_nodes[i]!=sorted_nodes[j] and (sorted_nodes[i]!=sorted_nodes[i-1] or i==0):\n",
    "                        if distance(X_D[sorted_nodes[j]], X_D[sorted_nodes[i]])<=2.83:\n",
    "                            l = liste_covariances[sorted_nodes[j]][sorted_nodes[i]]\n",
    "                            l[0], l[1], l[2], l[3] = weighted_covariance(l[0], l[1], l[2], l[3], Y_D[sorted_nodes[j]], Y_D[sorted_nodes[i]], memory_window, gamma)\n",
    "        \"\"\"\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]]\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",
    "        \"\"\"\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(gp_model, graph, graph_dim, 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 j in range(len(liste_covariances)):\n",
    "        covariances = liste_covariances[j]\n",
    "    #j = 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[j], X_v[i], 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": "194304f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variance:  8.376112385928357\n",
      "Lengthscale:  [1.15751322]\n",
      "Carte:  [ 10.75264642  11.32311613  13.85837336  12.52638523  11.51614467\n",
      "  14.26300441  16.43195461  19.71007937  24.20090585  22.62500812\n",
      "  22.57812952  27.42825908  26.69219251  25.30725892  26.74695744\n",
      "  27.63871459  29.25577269  27.87252782  25.01938148  28.40663161\n",
      "  12.22154859   9.31322866  12.72050845  22.14726489  33.56912308\n",
      "  41.40376403  47.79509584  52.22866103  55.73184379  55.12396075\n",
      "  52.05524861  54.38021197  55.89885196  54.07704346  51.12148767\n",
      "  49.17514734  49.83604216  48.34496765  46.03558747  44.25345014\n",
      "   9.16774964  15.7158314   56.53395853  90.96553637 109.75350196\n",
      " 115.94510822 116.08069696 112.42534523 105.97966991 101.11189841\n",
      "  96.12391102  91.66553846  86.84427813  83.1268019   80.76306415\n",
      "  75.22874615  68.9956136   65.00195555  62.43930201  60.28350973\n",
      "  15.02880092  35.8379208  112.37730138 159.94626947 170.02638082\n",
      " 167.35304548 157.51962971 147.53159004 137.35506939 127.63879021\n",
      " 120.02268893 113.23784331 104.08654744  95.85926659  92.06490864\n",
      "  85.27430191  78.74062332  75.93357343  70.52592969  69.02048511\n",
      "  12.30282744  15.25145019  57.95294508  93.00058879 107.85224211\n",
      " 115.33985263 114.74773584 110.83970014 106.02161471 100.19217918\n",
      "  94.54829359  91.94975766  89.13723924  82.18202821  77.36134831\n",
      "  73.09532778  70.75085425  69.14296692  63.45892449  63.20025274\n",
      "  11.70397415  10.3254644   13.66534964  24.3863646   34.01237856\n",
      "  42.23096388  47.1028701   49.49837875  51.5000987   53.62961346\n",
      "  52.55985796  52.63330829  54.7401207   52.05777595  51.12066011\n",
      "  50.56307321  48.03593775  44.7157282   44.29528369  47.03026405\n",
      "  11.23742938  13.23460344  10.60799504  10.25435016  11.44546158\n",
      "  15.8046195   16.98338241  17.60750716  20.33121244  23.13346581\n",
      "  23.52589082  24.3177668   26.50768947  25.89207671  26.95501885\n",
      "  28.18743321  29.4600716   28.55328793  28.36954083  26.43666352]\n",
      "Incertitude initiale :  473.3356690325918\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph_dim = (20, 7)\n",
    "graph_unity = 1\n",
    "\n",
    "################## Parameters of the Gaussian dispersion model #####################\n",
    "Q = 10000 # Pollution sources emission rate (g/s)\n",
    "u = 2 # Wind speed (m/s)\n",
    "h_s = 25 # Pollution sources height (m)\n",
    "g = 9.8 #  Gravity constant (m/s²)\n",
    "V = 6.03e-10 # Volumetric flow (m3/s)\n",
    "T_a = 288.15 # Ambient air temperature 15°C -> K\n",
    "T_s = 303.15 # Pollutant temperature 30°C -> K\n",
    "a_y = 0.34\n",
    "b_y = 0.82\n",
    "a_z = 0.275\n",
    "b_z = 0.69\n",
    "####################################################################################\n",
    "\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 = compute_means(graph_dim, 27, Q, u, h_s, g, V, T_a, T_s, a_y, b_y, a_z, b_z, display=True)\n",
    "means[0], means[120] = 10.8339689395607643, 10.8339689395607643\n",
    "means[1], means[121] = 11.526398647810964, 11.526398647810964\n",
    "means[2], means[122] = 12.278479893954115, 12.278479893954115\n",
    "means[3], means[123] = 12.648879083228234, 12.648879083228234\n",
    "means[4], means[124] = 13.278479893954115, 13.278479893954115\n",
    "#print(means)\n",
    "\n",
    "nb_agents = 5\n",
    "exploration_steps = 140\n",
    "variance_lengthscale = [10, 2]\n",
    "memory_window = 1000\n",
    "gamma = 0.995\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())]\n",
    "liste_covariances = [[[0, 0, 0, 0] for _ in range(graph.number_of_nodes())] for _ in range(graph.number_of_nodes())]\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(gp_model, graph, graph_dim, memory_window, gamma)\n",
    "print(\"Variance: \", var)\n",
    "print(\"Lengthscale: \", l)\n",
    "print(\"Carte: \", moyenne)\n",
    "\n",
    "gp_model.plot()\n",
    "#print(gp_model.predict(np.array([[0, 0]]))[0])\n",
    "#print(gp_model.predict(np.array([[4, 4]]))[0])\n",
    "print(\"Incertitude initiale : \", incertitude_initiale(sigma_matrix(gp_model, X_v), graph))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04bfb25d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eefda13a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d8cab6b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d9c25a4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_gp_model(gp_model, x, y, display_gp_model=False):\n",
    "    X = np.concatenate((gp_model.X, x))[-6000:]\n",
    "    Y = np.concatenate((gp_model.Y, y))[-6000:]\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\n",
    "\n",
    "def take_measurements(nodes, means, X_v, graph_dim, 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",
    "    \n",
    "    for i in nodes:\n",
    "        l = variances[i]\n",
    "        l[0], l[1], l[2] = weighted_variance(l[0], l[1], l[2], Y_v[i][0], memory_window, gamma)\n",
    "    \n",
    "    sorted_nodes = sorted(nodes)\n",
    "    \n",
    "    for j in range(len(sorted_nodes)):\n",
    "            if j==0 or sorted_nodes[j]!=sorted_nodes[j-1]:\n",
    "                for i in range(len(sorted_nodes)):\n",
    "                    if sorted_nodes[i]!=sorted_nodes[j] and (sorted_nodes[i]!=sorted_nodes[i-1] or i==0):\n",
    "                        if distance(X_v[sorted_nodes[j]], X_v[sorted_nodes[i]])<=2.83:\n",
    "                            l = liste_covariances[sorted_nodes[j]][sorted_nodes[i]]\n",
    "                            l[0], l[1], l[2], l[3] = weighted_covariance(l[0], l[1], l[2], l[3], Y_v[sorted_nodes[j]], Y_v[sorted_nodes[i]], memory_window, gamma)\n",
    "    \"\"\"\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]]\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",
    "    \"\"\"\n",
    "    return X_v[nodes], Y_v[nodes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e9b7d0e0",
   "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",
    "        \n",
    "        positions, mesures = take_measurements(actions, means, self.X_v, self.graph_dim, self.memory_window, self.gamma)\n",
    "        if self.train_env:\n",
    "            m, var, l = hyperparameters_estimator(self.gp_model, 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 = concatenate(self.x, positions)\n",
    "            self.y = concatenate(self.y, mesures)\n",
    "            self.cpt_update_gp_model = (self.cpt_update_gp_model + 1)%560\n",
    "            if self.cpt_update_gp_model==0:\n",
    "                self.gp_model = update_gp_model(self.gp_model, self.x, self.y)\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": "9e9b3a3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_iterations = 20000\n",
    "fc_layer_params = (128,64,128,)\n",
    "replay_buffer_capacity = 10000\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",
    "\n",
    "num_eval_episodes = 10\n",
    "log_eval_interval = 1000\n",
    "\n",
    "max_episode_length = 140\n",
    "budgets = 140 * np.ones(nb_agents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "99c15320",
   "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=0.99,\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",
    "    collect_policies[-1]._epsilon = 1.\n",
    "    \n",
    "    policies_checkpointers.append(common.Checkpointer(ckpt_dir='Collisions_Politique__'+str(i), policy=eval_policies[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6eeaf3c1",
   "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 random_compute_avg_return(environment, 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 = [random.randint(0, 3) for _ in range(nb_agents)]\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",
    "def random_collect_step(environment, environment_py):\n",
    "    time_step = environment.current_time_step()\n",
    "    actions = [random.randint(0, 3) for _ in range(nb_agents)]\n",
    "    actions = tf.convert_to_tensor([actions])\n",
    "    next_time_step = environment.step(actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e76e270f",
   "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",
    "    iterators.append(iter(dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4babb8f8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "226.2114\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_15628/2185087472.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcompute_avg_return\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0meval_env\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcollect_policies\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_eval_episodes\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcompute_avg_return\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0meval_env\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0meval_policies\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_eval_episodes\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0msteps\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mavg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_15628/2868047350.py\u001b[0m in \u001b[0;36mcompute_avg_return\u001b[1;34m(environment, policies, num_episodes)\u001b[0m\n\u001b[0;32m      7\u001b[0m             \u001b[0mactions\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m             \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnb_agents\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m                 \u001b[0mactions\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpolicies\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_step\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maction\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m             \u001b[0mactions\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_to_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mactions\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m             \u001b[0mtime_step\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mactions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tf_agents\\policies\\tf_policy.py\u001b[0m in \u001b[0;36maction\u001b[1;34m(self, time_step, policy_state, seed)\u001b[0m\n\u001b[0;32m    322\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_automatic_state_reset\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    323\u001b[0m       \u001b[0mpolicy_state\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_reset_state\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_step\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpolicy_state\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 324\u001b[1;33m     \u001b[0mstep\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maction_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_step\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtime_step\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpolicy_state\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mpolicy_state\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    325\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    326\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mclip_action\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maction\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maction_spec\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tf_agents\\utils\\common.py\u001b[0m in \u001b[0;36mwith_check_resource_vars\u001b[1;34m(*fn_args, **fn_kwargs)\u001b[0m\n\u001b[0;32m    186\u001b[0m         \u001b[1;31m# We're either in eager mode or in tf.function mode (no in-between); so\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    187\u001b[0m         \u001b[1;31m# autodep-like behavior is already expected of fn.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 188\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mfn_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mfn_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    189\u001b[0m       \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mresource_variables_enabled\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    190\u001b[0m         \u001b[1;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mMISSING_RESOURCE_VARIABLES_ERROR\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tf_agents\\policies\\tf_policy.py\u001b[0m in \u001b[0;36m_action\u001b[1;34m(self, time_step, policy_state, seed)\u001b[0m\n\u001b[0;32m    559\u001b[0m     \u001b[0mseed_stream\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtfp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mutil\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mSeedStream\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msalt\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'tf_agents_tf_policy'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    560\u001b[0m     \u001b[0mdistribution_step\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_distribution\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_step\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpolicy_state\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pytype: disable=wrong-arg-types\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 561\u001b[1;33m     actions = tf.nest.map_structure(\n\u001b[0m\u001b[0;32m    562\u001b[0m         \u001b[1;32mlambda\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mreparameterized_sampling\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msample\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mseed_stream\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    563\u001b[0m         distribution_step.action)\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\nest.py\u001b[0m in \u001b[0;36mmap_structure\u001b[1;34m(func, *structure, **kwargs)\u001b[0m\n\u001b[0;32m    912\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    913\u001b[0m   return pack_sequence_as(\n\u001b[1;32m--> 914\u001b[1;33m       \u001b[0mstructure\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mentries\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    915\u001b[0m       expand_composites=expand_composites)\n\u001b[0;32m    916\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\nest.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    912\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    913\u001b[0m   return pack_sequence_as(\n\u001b[1;32m--> 914\u001b[1;33m       \u001b[0mstructure\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mentries\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    915\u001b[0m       expand_composites=expand_composites)\n\u001b[0;32m    916\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tf_agents\\policies\\tf_policy.py\u001b[0m in \u001b[0;36m<lambda>\u001b[1;34m(d)\u001b[0m\n\u001b[0;32m    560\u001b[0m     \u001b[0mdistribution_step\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_distribution\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_step\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpolicy_state\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pytype: disable=wrong-arg-types\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    561\u001b[0m     actions = tf.nest.map_structure(\n\u001b[1;32m--> 562\u001b[1;33m         \u001b[1;32mlambda\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mreparameterized_sampling\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msample\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mseed_stream\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    563\u001b[0m         distribution_step.action)\n\u001b[0;32m    564\u001b[0m     \u001b[0minfo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdistribution_step\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tf_agents\\distributions\\reparameterized_sampling.py\u001b[0m in \u001b[0;36msample\u001b[1;34m(distribution, reparam, **kwargs)\u001b[0m\n\u001b[0;32m     49\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0mdistribution\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_to_one_hot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     50\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 51\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mdistribution\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msample\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\distributions\\distribution.py\u001b[0m in \u001b[0;36msample\u001b[1;34m(self, sample_shape, seed, name, **kwargs)\u001b[0m\n\u001b[0;32m   1232\u001b[0m     \"\"\"\n\u001b[0;32m   1233\u001b[0m     \u001b[1;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_name_and_control_scope\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1234\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call_sample_n\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msample_shape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1235\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1236\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m_call_sample_and_log_prob\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_shape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\distributions\\distribution.py\u001b[0m in \u001b[0;36m_call_sample_n\u001b[1;34m(self, sample_shape, seed, **kwargs)\u001b[0m\n\u001b[0;32m   1209\u001b[0m     sample_shape, n = self._expand_sample_shape_to_vector(\n\u001b[0;32m   1210\u001b[0m         sample_shape, 'sample_shape')\n\u001b[1;32m-> 1211\u001b[1;33m     samples = self._sample_n(\n\u001b[0m\u001b[0;32m   1212\u001b[0m         n, seed=seed() if callable(seed) else seed, **kwargs)\n\u001b[0;32m   1213\u001b[0m     samples = tf.nest.map_structure(\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\distributions\\deterministic.py\u001b[0m in \u001b[0;36m_sample_n\u001b[1;34m(***failed resolving arguments***)\u001b[0m\n\u001b[0;32m    157\u001b[0m     return tf.broadcast_to(\n\u001b[0;32m    158\u001b[0m         \u001b[0mloc\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 159\u001b[1;33m         ps.concat([[n], self._batch_shape_tensor(loc=loc),\n\u001b[0m\u001b[0;32m    160\u001b[0m                    self._event_shape_tensor(loc=loc)],\n\u001b[0;32m    161\u001b[0m                   axis=0))\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\distributions\\distribution.py\u001b[0m in \u001b[0;36m_batch_shape_tensor\u001b[1;34m(self, **parameter_kwargs)\u001b[0m\n\u001b[0;32m   1011\u001b[0m     \"\"\"\n\u001b[0;32m   1012\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1013\u001b[1;33m       return batch_shape_lib.inferred_batch_shape_tensor(\n\u001b[0m\u001b[0;32m   1014\u001b[0m           self, **parameter_kwargs)\n\u001b[0;32m   1015\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\internal\\batch_shape_lib.py\u001b[0m in \u001b[0;36minferred_batch_shape_tensor\u001b[1;34m(batch_object, bijector_x_event_ndims, **parameter_kwargs)\u001b[0m\n\u001b[0;32m    108\u001b[0m     \u001b[0mbatch_shape_tensor\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0mbroadcast\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0mshape\u001b[0m \u001b[0mof\u001b[0m \u001b[0mall\u001b[0m \u001b[0mparameters\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    109\u001b[0m   \"\"\"\n\u001b[1;32m--> 110\u001b[1;33m   batch_shapes = map_fn_over_parameters_with_event_ndims(\n\u001b[0m\u001b[0;32m    111\u001b[0m       \u001b[0mbatch_object\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    112\u001b[0m       \u001b[0mget_batch_shape_tensor_part\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\internal\\batch_shape_lib.py\u001b[0m in \u001b[0;36mmap_fn_over_parameters_with_event_ndims\u001b[1;34m(batch_object, fn, bijector_x_event_ndims, require_static, **parameter_kwargs)\u001b[0m\n\u001b[0;32m    359\u001b[0m         \u001b[0mparam\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtensor_util\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_nonref_to_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mparam\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mparam_name\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    360\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 361\u001b[1;33m     results[param_name] = nest.map_structure_up_to(\n\u001b[0m\u001b[0;32m    362\u001b[0m         param, fn, param, param_event_ndims)\n\u001b[0;32m    363\u001b[0m   \u001b[1;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\nest.py\u001b[0m in \u001b[0;36mmap_structure_up_to\u001b[1;34m(shallow_tree, func, *inputs, **kwargs)\u001b[0m\n\u001b[0;32m   1423\u001b[0m     \u001b[0;31m`\u001b[0m\u001b[0mshallow_tree\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1424\u001b[0m   \"\"\"\n\u001b[1;32m-> 1425\u001b[1;33m   return map_structure_with_tuple_paths_up_to(\n\u001b[0m\u001b[0;32m   1426\u001b[0m       \u001b[0mshallow_tree\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1427\u001b[0m       \u001b[1;32mlambda\u001b[0m \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;31m# Discards the path arg.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\nest.py\u001b[0m in \u001b[0;36mmap_structure_with_tuple_paths_up_to\u001b[1;34m(shallow_tree, func, *inputs, **kwargs)\u001b[0m\n\u001b[0;32m   1523\u001b[0m       \u001b[0mpath\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1524\u001b[0m       for path, _ in _yield_flat_up_to(shallow_tree, inputs[0], is_nested_fn))\n\u001b[1;32m-> 1525\u001b[1;33m   results = [\n\u001b[0m\u001b[0;32m   1526\u001b[0m       \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0margs\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mflat_path_gen\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0mflat_value_gen\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1527\u001b[0m   ]\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\nest.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m   1524\u001b[0m       for path, _ in _yield_flat_up_to(shallow_tree, inputs[0], is_nested_fn))\n\u001b[0;32m   1525\u001b[0m   results = [\n\u001b[1;32m-> 1526\u001b[1;33m       \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0margs\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mflat_path_gen\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0mflat_value_gen\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1527\u001b[0m   ]\n\u001b[0;32m   1528\u001b[0m   return pack_sequence_as(structure=shallow_tree, flat_sequence=results,\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\nest.py\u001b[0m in \u001b[0;36m<lambda>\u001b[1;34m(_, *values)\u001b[0m\n\u001b[0;32m   1425\u001b[0m   return map_structure_with_tuple_paths_up_to(\n\u001b[0;32m   1426\u001b[0m       \u001b[0mshallow_tree\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1427\u001b[1;33m       \u001b[1;32mlambda\u001b[0m \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;31m# Discards the path arg.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1428\u001b[0m       \u001b[1;33m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1429\u001b[0m       **kwargs)\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\internal\\batch_shape_lib.py\u001b[0m in \u001b[0;36mget_batch_shape_tensor_part\u001b[1;34m(x, event_ndims)\u001b[0m\n\u001b[0;32m    137\u001b[0m   \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    138\u001b[0m     \u001b[0mbase_shape\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 139\u001b[1;33m   \u001b[1;32mreturn\u001b[0m \u001b[0m_truncate_shape_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbase_shape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mevent_ndims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    140\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    141\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow_probability\\python\\internal\\batch_shape_lib.py\u001b[0m in \u001b[0;36m_truncate_shape_tensor\u001b[1;34m(shape, rightmost_ndims_to_truncate)\u001b[0m\n\u001b[0;32m    178\u001b[0m       rightmost_ndims_to_truncate, dtype_hint=np.int32)\n\u001b[0;32m    179\u001b[0m   \u001b[0mbase_rank\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mps\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrank_from_shape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 180\u001b[1;33m   return shape[:(\n\u001b[0m\u001b[0;32m    181\u001b[0m       \u001b[0mbase_rank\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    182\u001b[0m       \u001b[1;31m# Don't try to slice away more ndims than the parameter\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\dispatch.py\u001b[0m in \u001b[0;36mop_dispatch_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m   1080\u001b[0m       \u001b[1;31m# Fallback dispatch system (dispatch v1):\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1081\u001b[0m       \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1082\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mdispatch_target\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1083\u001b[0m       \u001b[1;32mexcept\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1084\u001b[0m         \u001b[1;31m# Note: convert_to_eager_tensor currently raises a ValueError, not a\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\array_ops.py\u001b[0m in \u001b[0;36m_slice_helper\u001b[1;34m(tensor, slice_spec, var)\u001b[0m\n\u001b[0;32m   1050\u001b[0m       \u001b[0mvar_empty\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mconstant\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1051\u001b[0m       \u001b[0mpacked_begin\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpacked_end\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpacked_strides\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvar_empty\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1052\u001b[1;33m     return strided_slice(\n\u001b[0m\u001b[0;32m   1053\u001b[0m         \u001b[0mtensor\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1054\u001b[0m         \u001b[0mpacked_begin\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\dispatch.py\u001b[0m in \u001b[0;36mop_dispatch_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m   1080\u001b[0m       \u001b[1;31m# Fallback dispatch system (dispatch v1):\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1081\u001b[0m       \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1082\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mdispatch_target\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1083\u001b[0m       \u001b[1;32mexcept\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1084\u001b[0m         \u001b[1;31m# Note: convert_to_eager_tensor currently raises a ValueError, not a\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\array_ops.py\u001b[0m in \u001b[0;36mstrided_slice\u001b[1;34m(input_, begin, end, strides, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask, var, name)\u001b[0m\n\u001b[0;32m   1223\u001b[0m     \u001b[0mstrides\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mones_like\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbegin\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1224\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1225\u001b[1;33m   op = gen_array_ops.strided_slice(\n\u001b[0m\u001b[0;32m   1226\u001b[0m       \u001b[0minput\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minput_\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1227\u001b[0m       \u001b[0mbegin\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mbegin\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\gen_array_ops.py\u001b[0m in \u001b[0;36mstrided_slice\u001b[1;34m(input, begin, end, strides, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask, name)\u001b[0m\n\u001b[0;32m  10662\u001b[0m   \u001b[1;32mif\u001b[0m \u001b[0mtld\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mis_eager\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m  10663\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m> 10664\u001b[1;33m       _result = pywrap_tfe.TFE_Py_FastPathExecute(\n\u001b[0m\u001b[0;32m  10665\u001b[0m         \u001b[0m_ctx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"StridedSlice\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbegin\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mend\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstrides\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"begin_mask\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m  10666\u001b[0m         \u001b[0mbegin_mask\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"end_mask\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mend_mask\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"ellipsis_mask\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mellipsis_mask\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(compute_avg_return(eval_env, collect_policies, num_eval_episodes))\n",
    "print(compute_avg_return(eval_env, eval_policies, num_eval_episodes))\n",
    "\n",
    "steps = []\n",
    "avg = []\n",
    "err = []\n",
    "\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(500)):\n",
    "    collect_step(train_env, train_py_env, collect_policies)\n",
    "\n",
    "for step in tqdm(range(1, num_iterations+1)):\n",
    "    if step%100==0:\n",
    "        for cp in collect_policies:\n",
    "            cp._epsilon = max(cp._epsilon*0.99, 0.1)\n",
    "        \n",
    "    if step==2000:\n",
    "        variance_lengthscale[0] -= 1\n",
    "    if step==10000:\n",
    "        variance_lengthscale[1] -= 1\n",
    "    #if step==40000:\n",
    "        #means = [80, 50, 40, 35, 30, 50, 47.5, 45, 37.5, 31.25, 40, 45, 42.5, 40, 32.5, 35, 37.5, 40, 37.5, 35, 30, 31.25, 32.5, 35, 32.5]\n",
    "    \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",
    "    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",
    "        print(\"Epsilons : \", [cp._epsilon for cp in collect_policies])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58175ea8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(steps)\n",
    "print(avg)\n",
    "print(err)\n",
    "print(train_py_env.liste_variances)\n",
    "print(train_py_env.liste_lengthscales)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff6d02fc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ba61fa1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "56184664",
   "metadata": {},
   "outputs": [],
   "source": [
    "episodes = 3\n",
    "\n",
    "envs = []\n",
    "for _ in range(episodes):\n",
    "    initial_positions = [[random.randint(0, graph.number_of_nodes()-1)] for i in range(nb_agents)]\n",
    "    eval_py_env = wrappers.TimeLimit(pfeEnv(graph, gp_model, nb_agents, budgets, graph_unity, graph_dim, initial_positions, var, l, memory_window, 0.99, train_env=False), duration=max_episode_length)\n",
    "    eval_env = tf_py_environment.TFPyEnvironment(eval_py_env)\n",
    "    envs.append((eval_env,eval_py_env))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c2d4c28c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:46<00:00, 15.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moyenne :  295.36746\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "variances = [[0, 0, 0] for _ in range(graph.number_of_nodes())]\n",
    "liste_covariances = [[[0, 0, 0, 0] for _ in range(graph.number_of_nodes())] for _ in range(graph.number_of_nodes())]\n",
    "\n",
    "ms, vvs, ccs = [], [], []\n",
    "rewards = []\n",
    "for ll in tqdm(range(episodes)):\n",
    "    eval_env, eval_py_env = envs[ll][0], envs[ll][1]\n",
    "    time_step = eval_env.reset()\n",
    "    episode_return = 0.0\n",
    "    while not time_step.is_last():\n",
    "        actions = [random.randint(0, 3) for _ in range(nb_agents)]\n",
    "        #actions = []\n",
    "        #for i in range(nb_agents):\n",
    "            #actions.append(eval_policies[i].action(time_step).action.numpy()[0])\n",
    "        actions = tf.convert_to_tensor([actions])\n",
    "        time_step = eval_env.step(actions)\n",
    "        episode_return += time_step.reward\n",
    "    #print(eval_py_env.paths)\n",
    "    #print(episode_return.numpy()[0])\n",
    "    m, vv, cc = hyperparameters_estimator(eval_py_env.gp_model, eval_py_env.graph, eval_py_env.graph_dim, eval_py_env.memory_window, eval_py_env.gamma)\n",
    "    ms.append(m)\n",
    "    vvs.append(vv)\n",
    "    ccs.append(cc)\n",
    "    #print(\"##################################\")\n",
    "    rewards.append(episode_return.numpy()[0])\n",
    "    \n",
    "print(\"Moyenne : \", np.mean(np.array(rewards)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98ab3424",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RL\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.99, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b66ba7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.99, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e182320e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RL\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.993, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9485d045",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.993, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d7f3ea9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RL\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.996, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b01f1782",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.996, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83e75b33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RL\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.999, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0c51e7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random\n",
    "# Agents : 5, Var : 10, Lengthscale : 2, Layers : (128,64), Episode : 150, Training Steps : 25000, Batch size : 128\n",
    "# gamma : 0.999, memory_window : 1000\n",
    "print(ms)\n",
    "print(\"################\")\n",
    "print(vvs)\n",
    "print(\"################\")\n",
    "print(ccs)\n",
    "print(\"################\")\n",
    "print(rewards)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e98405b",
   "metadata": {},
   "source": [
    "## RL vs Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8cae41f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b38f0040",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f5a4c3c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5a530733",
   "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
}