Training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from itertools import permutations, combinations\n",
    "from collections import defaultdict\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "import scipy.stats as stats\n",
    "import pickle\n",
    "import os\n",
    "from scipy.spatial.distance import euclidean\n",
    "import editdistance\n",
    "from scipy.stats import pearsonr, wasserstein_distance\n",
    "from scipy.spatial.distance import  euclidean\n",
    "from scipy.stats import pearsonr, wasserstein_distance\n",
    "\n",
    "DEVICE = \"cpu\" # set to GPU if available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sender(nn.Module):\n",
    "\n",
    "    def __init__(self, num_concepts, hidden_size, device, num_layers=1, \n",
    "                 vocab_size=5, max_len=10, top_p=0.9, dropout_p=0, \n",
    "                 decoding_strategy=\"gumbel_softmax\"):\n",
    "        super().__init__()\n",
    "\n",
    "        self.encoder = nn.Linear(num_concepts, hidden_size)\n",
    "        self.grus = nn.ModuleList([nn.GRUCell(input_size=hidden_size, hidden_size=hidden_size) for _ in range(num_layers)])\n",
    "        self.output = nn.Linear(hidden_size, vocab_size) # applied at every time step\n",
    "        self.vocab_encoder = nn.Linear(vocab_size, hidden_size, bias=False)\n",
    "        self.dropout = nn.Dropout(p=dropout_p)\n",
    "        \n",
    "        self.vocab_size = vocab_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.device = device\n",
    "        self.max_len = max_len\n",
    "        self.top_p = top_p\n",
    "        self.decoding_strategy = decoding_strategy\n",
    "        assert self.decoding_strategy in [\"top_p\", \"sampling\", \"greedy\", \"gumbel_softmax\"]\n",
    "    \n",
    "    def top_p_sampling(self, output):\n",
    "        sorted_probabilities, sorted_indices = torch.sort(output, descending=True)\n",
    "        cumulative_probabilities = torch.cumsum(sorted_probabilities, dim=0)\n",
    "        top_p_mask = cumulative_probabilities <= self.top_p\n",
    "        top_p_probabilities = sorted_probabilities[top_p_mask]\n",
    "        top_p_indices = sorted_indices[top_p_mask]\n",
    "        if len(top_p_probabilities) == 0: # If top_p is too low, fall back to greedy decoding\n",
    "            next_token = torch.argmax(output) \n",
    "        else:\n",
    "            next_token = top_p_indices[torch.multinomial(top_p_probabilities, 1).item()]\n",
    "        return next_token\n",
    "\n",
    "    def forward(self, x, eval=False, temperature=1.0):\n",
    "        h_0 = self.encoder(x)\n",
    "        latest_token = torch.zeros(self.hidden_size).to(self.device) # Not the same as token 0, it is an embedding state of all zeros\n",
    "        # latest_token = torch.randn(self.hidden_size).to(self.device) \n",
    "\n",
    "        hidden_states = [h_0.clone() for _ in range(self.num_layers)]\n",
    "\n",
    "        output_states = torch.zeros((self.max_len, self.vocab_size)).to(self.device)\n",
    "        decoded_outputs = []\n",
    "\n",
    "        for i in range(self.max_len-1):\n",
    "\n",
    "            hidden_states[0] = self.grus[0](latest_token, hidden_states[0])\n",
    "            for j in range(1, self.num_layers):\n",
    "                x = self.grus[j](hidden_states[j-1], hidden_states[j])\n",
    "                hidden_states[j] = x\n",
    "\n",
    "            if not eval:\n",
    "                logits = self.output(self.dropout(hidden_states[self.num_layers-1]))\n",
    "                if self.decoding_strategy==\"gumbel_softmax\":\n",
    "                    gumbel_logits = -torch.log(-torch.log(torch.rand_like(logits))) # sample from Gumbel(0, 1)\n",
    "                    logits = (logits+gumbel_logits)/temperature\n",
    "            else:\n",
    "                logits = self.output(hidden_states[self.num_layers-1])\n",
    "            \n",
    "            # GRADIENT FLOW THROUGH GUMBEL SAMPLING and STRAIGHT THROUGH ESTIMATOR\n",
    "            \n",
    "            output = torch.softmax(logits, dim = 0)\n",
    "            \n",
    "            if self.decoding_strategy == \"greedy\":\n",
    "                decoded = torch.argmax(output)\n",
    "            elif self.decoding_strategy==\"sampling\":\n",
    "                decoded = torch.multinomial(output, num_samples=1, replacement=True)[0]\n",
    "            elif self.decoding_strategy==\"top_p\":\n",
    "                decoded = self.top_p_sampling(output)\n",
    "            elif self.decoding_strategy==\"gumbel_softmax\":\n",
    "                decoded = torch.argmax(output)\n",
    "                output_hard = torch.zeros_like(output)\n",
    "                output_hard[decoded] = 1.0\n",
    "                output = output_hard + output - output.detach() # Straight-through estimator removes content, keeps gradient\n",
    "\n",
    "            output_states[i] = output\n",
    "            decoded_outputs.append(decoded.item())\n",
    "            \n",
    "            if decoded.item() == 0: # EOS token detected\n",
    "                break\n",
    "\n",
    "            latest_token = self.vocab_encoder(output)\n",
    "        \n",
    "        decoded_outputs = decoded_outputs + [0]*(self.max_len-len(decoded_outputs)) # 0 = END TOKEN\n",
    "        assert len(decoded_outputs) == self.max_len\n",
    "    \n",
    "        return output_states, decoded_outputs\n",
    "    \n",
    "class Receiver(nn.Module):\n",
    "    def __init__ (self, num_concepts, hidden_size, device, num_layers=1, vocab_size=5, max_len=10):\n",
    "        super().__init__()\n",
    "        self.gru_embedding = nn.Linear(vocab_size, hidden_size, bias=False) # nn.Embedding(vocab_size, hidden_size)\n",
    "        self.grus = nn.ModuleList([nn.GRUCell(input_size=hidden_size, hidden_size=hidden_size)])\n",
    "        self.grus.extend([nn.GRUCell(input_size=hidden_size, hidden_size=hidden_size) for _ in range(1, num_layers)])\n",
    "        self.output = nn.Linear(hidden_size, num_concepts)\n",
    "        \n",
    "        self.vocab_size = vocab_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.device = device\n",
    "        self.max_len = max_len\n",
    "    \n",
    "    def forward(self, sender_outputs, decoded_output):\n",
    "\n",
    "        hidden_states = [torch.zeros(self.hidden_size).to(self.device) for _ in range(self.num_layers)]\n",
    "        for i in range(self.max_len):\n",
    "            encoded_input = self.gru_embedding(sender_outputs[i])\n",
    "            hidden_states[0] = self.grus[0](encoded_input, hidden_states[0]) # hidden_states[0] = self.grus[0](sender_outputs[i], hidden_states[0])\n",
    "            for j in range(1, self.num_layers):\n",
    "                hidden_states[j] = self.grus[j](hidden_states[j-1], hidden_states[j])\n",
    "            if decoded_output[i] == 0:\n",
    "                break\n",
    "        output = self.output(hidden_states[self.num_layers-1])\n",
    "        output = torch.softmax(output, dim=0)\n",
    "        return output\n",
    "\n",
    "class Agent:\n",
    "    def __init__ (self, num_concepts, hidden_size, device, num_layers, vocab_size, max_len):\n",
    "        self.sender = Sender(num_concepts, hidden_size, device, num_layers, vocab_size, max_len)\n",
    "        self.receiver = Receiver(num_concepts, hidden_size, device, num_layers, vocab_size, max_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# HELPER FUNCTIONS\n",
    "\n",
    "def transform(sentence):\n",
    "    this_output = \"\"\n",
    "    for ch in sentence:\n",
    "        if ch==0:\n",
    "            break\n",
    "        this_output+=chr(ch+96)\n",
    "    return this_output\n",
    "\n",
    "def generate_ngrams(s, n):\n",
    "    \"\"\"Generate n-grams for a given string s.\"\"\"\n",
    "    return {s[i:i+n] for i in range(len(s) - n + 1)}\n",
    "\n",
    "def sample_ngram_overlap(sample_decoded_outputs, n): # Generalisation of ROUGE-N, without a true \"reference\"\n",
    "    n_grams = [generate_ngrams(sample_decoded_output, n) for sample_decoded_output in sample_decoded_outputs]\n",
    "    intersection = set.intersection(*n_grams)\n",
    "    union = set.union(*n_grams)\n",
    "    if len(union)==0:\n",
    "        return 0\n",
    "    overlap_coefficient = len(intersection)/len(union) # Based on the formula for Jaccard Similarity\n",
    "    return overlap_coefficient\n",
    "\n",
    "def calculate_ngram_overlap(decoded_outputs, n):\n",
    "    ngram_scores = []\n",
    "    for sample_decoded_outputs in decoded_outputs:\n",
    "        score = sample_ngram_overlap(sample_decoded_outputs, n=n)\n",
    "        ngram_scores.append(score)\n",
    "    return ngram_scores\n",
    "\n",
    "def calculate_world_view(agents_dict):\n",
    "    sender_cosine_matrix = []\n",
    "    receiver_cosine_matrix = []\n",
    "\n",
    "    for i, agent in enumerate(agents_dict):\n",
    "        this_cosine_sim = cosine_similarity(agents_dict[agent].sender.vocab_encoder.weight.data.T, agents_dict[agent].sender.vocab_encoder.weight.data.T)\n",
    "        this_cosine_sim = this_cosine_sim[np.tril_indices(this_cosine_sim.shape[0], k=-1)] # select lower triangular matrix\n",
    "        sender_cosine_matrix.append(this_cosine_sim)  \n",
    "    sender_cosine_matrix = np.array(sender_cosine_matrix)\n",
    "\n",
    "    for i, agent in enumerate(agents_dict):\n",
    "        this_cosine_sim = cosine_similarity(agents_dict[agent].receiver.gru_embedding.weight.data.T, agents_dict[agent].receiver.gru_embedding.weight.data.T)\n",
    "        this_cosine_sim = this_cosine_sim[np.tril_indices(this_cosine_sim.shape[0], k=-1)]\n",
    "        receiver_cosine_matrix.append(this_cosine_sim)\n",
    "    receiver_cosine_matrix = np.array(receiver_cosine_matrix)\n",
    "\n",
    "    ss_correlations, rr_correlations, sr_correlations = [], [], []\n",
    "    for a0, a1 in combinations(range(len(agents_dict)), 2):\n",
    "        this_ss_corr = stats.pearsonr(sender_cosine_matrix[a0], sender_cosine_matrix[a1])[0]\n",
    "        this_rr_corr = stats.pearsonr(receiver_cosine_matrix[a0], receiver_cosine_matrix[a1])[0]\n",
    "        ss_correlations.append(this_ss_corr)\n",
    "        rr_correlations.append(this_rr_corr)\n",
    "    \n",
    "    for a0 in range(len(agents_dict)):\n",
    "        this_sr_corr = stats.pearsonr(sender_cosine_matrix[a0], receiver_cosine_matrix[a0])[0]\n",
    "        sr_correlations.append(this_sr_corr)\n",
    "\n",
    "    return ss_correlations, rr_correlations, sr_correlations\n",
    "\n",
    "def forward_pass_simple(agent0, agent1, x, temperature, loss_fn, returnData=False):\n",
    "\n",
    "    sender0_outputs, sender0_decoded_output = agent0.sender(x, temperature=temperature)\n",
    "    receiver1_outputs = agent1.receiver(sender0_outputs, sender0_decoded_output)\n",
    "\n",
    "    loss = loss_fn(receiver1_outputs, x) # STAGE 1\n",
    "\n",
    "    if returnData:\n",
    "        return loss, sender0_decoded_output, receiver1_outputs\n",
    "    else:\n",
    "        return loss\n",
    "    \n",
    "def eval_pass_simple(agent0, agent1, x, temperature, loss_fn, returnData=False):\n",
    "    with torch.no_grad():\n",
    "        sender0_outputs, sender0_decoded_output = agent0.sender(x, temperature=temperature, eval=True)\n",
    "        receiver1_outputs = agent1.receiver(sender0_outputs, sender0_decoded_output)\n",
    "        loss0 = loss_fn(receiver1_outputs, x) \n",
    "\n",
    "    if returnData:\n",
    "        return loss0, sender0_decoded_output, receiver1_outputs\n",
    "    else:\n",
    "        return loss0\n",
    "    \n",
    "def forward_pass_IC(agent0, agent1, x, temperature, loss_fn, returnData=False):\n",
    "\n",
    "    sender0_outputs, sender0_decoded_output = agent0.sender(x, temperature=temperature)\n",
    "    receiver1_outputs = agent0.receiver(sender0_outputs, sender0_decoded_output)\n",
    "\n",
    "    loss = loss_fn(receiver1_outputs, x) # STAGE 1\n",
    "\n",
    "    sender1_outputs, sender1_decoded_output = agent0.sender(receiver1_outputs, temperature=temperature)\n",
    "    receiver2_outputs = agent1.receiver(sender1_outputs, sender1_decoded_output)\n",
    "\n",
    "    loss += loss_fn(receiver2_outputs, receiver1_outputs) # STAGE 2\n",
    "\n",
    "    if returnData:\n",
    "        return loss, sender0_decoded_output, receiver1_outputs, sender1_decoded_output, receiver2_outputs\n",
    "    else:\n",
    "        return loss\n",
    "    \n",
    "def eval_pass_IC(agent0, agent1, x, temperature, loss_fn, returnData=False, returnExtra=False):\n",
    "    with torch.no_grad():\n",
    "        sender0_outputs, sender0_decoded_output = agent0.sender(x, temperature=temperature, eval=True)\n",
    "        receiver1_outputs = agent0.receiver(sender0_outputs, sender0_decoded_output)\n",
    "        loss0 = loss_fn(receiver1_outputs, x) # STAGE 1\n",
    "\n",
    "        sender1_outputs, sender1_decoded_output = agent0.sender(receiver1_outputs, temperature=temperature, eval=True)\n",
    "        receiver2_outputs = agent1.receiver(sender1_outputs, sender1_decoded_output)\n",
    "        loss1 = loss_fn(receiver2_outputs, x) # STAGE 1 \n",
    "\n",
    "        lossEndToEnd = loss_fn(receiver2_outputs, x) # END-TO-END\n",
    "\n",
    "    if returnData:\n",
    "        if returnExtra:\n",
    "            return loss0, loss1, lossEndToEnd, sender0_decoded_output, receiver1_outputs, sender1_decoded_output, receiver2_outputs\n",
    "        else:\n",
    "            return lossEndToEnd, sender1_decoded_output, receiver2_outputs\n",
    "    else:\n",
    "        return lossEndToEnd\n",
    "\n",
    "def topological_similarity(o, m, distance=\"euclidean\"):\n",
    "    assert distance in [\"euclidean\", \"wasserstein\"]\n",
    "\n",
    "    d_o = []\n",
    "    for i in range(len(o)):\n",
    "        for j in range(i+1, len(o)):\n",
    "            if distance==\"euclidean\":\n",
    "                d_o.append(euclidean(o[i], o[j]))\n",
    "            elif distance==\"wasserstein\":\n",
    "                d_o.append(wasserstein_distance(o[i], o[j]))\n",
    "    d_o = np.array(d_o)\n",
    "\n",
    "    d_m = []\n",
    "    for i in range(len(m)):\n",
    "        for j in range(i+1, len(m)):\n",
    "            d_m.append(editdistance.eval(m[i], m[j]))\n",
    "    d_m = np.array(d_m)\n",
    "\n",
    "    return pearsonr(d_o, d_m)\n",
    "\n",
    "def calculate_topological_similarity(agents_dict, dataset, decoded_outputs, directional=False, distance=\"euclidean\"):\n",
    "    top_sim_values = []\n",
    "    o = dataset.dataset.tensors[0]\n",
    "    if not directional:\n",
    "        for i in range(0, len(list(permutations(agents_dict))), len(agents_dict)-1):\n",
    "            m = decoded_outputs[:, i]\n",
    "            top_sim = topological_similarity(o, m, distance)[0]\n",
    "            top_sim_values.append(top_sim)\n",
    "    else:\n",
    "        for i in range(0, len(agents_dict)):\n",
    "            m = decoded_outputs[:, i]\n",
    "            top_sim = topological_similarity(o, m, distance)[0]\n",
    "            top_sim_values.append(top_sim)\n",
    "    return np.mean(top_sim_values)\n",
    "\n",
    "def calculate_edit_distances(decoded_outputs, numAgents=True):\n",
    "    edit_distances = []\n",
    "\n",
    "    if numAgents==2:\n",
    "        for i in range(len(decoded_outputs)):\n",
    "            this_sample = editdistance.distance(decoded_outputs[i][0], decoded_outputs[i][1])/max(len(decoded_outputs[i][0]), len(decoded_outputs[i][1]), 1)\n",
    "            edit_distances.append(this_sample)\n",
    "    else:\n",
    "        decoded_outputs = decoded_outputs[:, ::2]\n",
    "        for i in range(len(decoded_outputs)):\n",
    "            # print (decoded_outputs[i][0], decoded_outputs[i][1], decoded_outputs[i][2])\n",
    "            this_sample = 0\n",
    "            this_sample += editdistance.distance(decoded_outputs[i][0], decoded_outputs[i][1])/max(len(decoded_outputs[i][0]), len(decoded_outputs[i][1]), 1)\n",
    "            this_sample += editdistance.distance(decoded_outputs[i][0], decoded_outputs[i][2])/max(len(decoded_outputs[i][0]), len(decoded_outputs[i][2]), 1)\n",
    "            this_sample += editdistance.distance(decoded_outputs[i][1], decoded_outputs[i][2])/max(len(decoded_outputs[i][1]), len(decoded_outputs[i][2]), 1)\n",
    "            this_sample /= 3\n",
    "            edit_distances.append(this_sample)\n",
    "\n",
    "    return np.mean(edit_distances)\n",
    "\n",
    "def evaluate_matches(decoded_outputs, val_results, agents_dict):\n",
    "\n",
    "    ngram_scores_1 = calculate_ngram_overlap(decoded_outputs, n=1)\n",
    "    val_results[\"1-gram_mean\"].append(np.mean(ngram_scores_1))\n",
    "\n",
    "    ngram_scores_2 = calculate_ngram_overlap(decoded_outputs, n=2)\n",
    "    val_results[\"2-gram_mean\"].append(np.mean(ngram_scores_2))\n",
    "\n",
    "    ngram_scores_3 = calculate_ngram_overlap(decoded_outputs, n=3)\n",
    "    val_results[\"3-gram_mean\"].append(np.mean(ngram_scores_3))\n",
    "\n",
    "    ngram_scores_4 = calculate_ngram_overlap(decoded_outputs, n=4)\n",
    "    val_results[\"4-gram_mean\"].append(np.mean(ngram_scores_4))\n",
    "\n",
    "    ss_correlations, rr_correlations, sr_correlations = calculate_world_view(agents_dict)\n",
    "    val_results[\"ss_correlations_mean\"].append(np.mean(ss_correlations))\n",
    "    val_results[\"rr_correlations_mean\"].append(np.mean(rr_correlations))\n",
    "    val_results[\"sr_correlations_mean\"].append(np.mean(sr_correlations))\n",
    "\n",
    "    edit_distance = calculate_edit_distances(decoded_outputs, numAgents=len(agents_dict))\n",
    "    val_results[\"edit_distance_mean\"].append(edit_distance)\n",
    "\n",
    "    return val_results\n",
    "\n",
    "def get_agent_pair_fc(agents_dict, competitive_level):\n",
    "    pairs = list(permutations(agents_dict.keys(), 2))\n",
    "    multiplicative_factors = [np.random.choice([-1,1], p=[competitive_level, 1-competitive_level]) for _ in range(len(pairs))]\n",
    "    return zip(pairs, multiplicative_factors)\n",
    "\n",
    "def get_agent_pair_ring(agents_dict, competitive_level):\n",
    "    pairs = []\n",
    "    for i in range(3):\n",
    "        pairs.append((i, (i+1)%3))\n",
    "    multiplicative_factors = [np.random.choice([-1,1], p=[competitive_level, 1-competitive_level]) for _ in range(len(pairs))]\n",
    "    return zip(pairs, multiplicative_factors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Main training function, with support for competitiveness, inner speech, and various topologies\n",
    "\n",
    "def simulate_with_competitiveness(\n",
    "                                agents_dict, \n",
    "                                train_dataset, \n",
    "                                val_dataset, \n",
    "                                lr=0.001, \n",
    "                                epochs=300, \n",
    "                                batch_size=16, \n",
    "                                temp_start=1, \n",
    "                                temp_end=1, \n",
    "                                verbose=False, \n",
    "                                evalEpochs=5, \n",
    "                                competitive_level=0,\n",
    "                                fn_generate_pair=get_agent_pair_fc,\n",
    "                                fn_forward_pass=forward_pass_simple,\n",
    "                                fn_eval_pass=eval_pass_simple,\n",
    "                                directional=False,\n",
    "                                loss_fn=nn.MSELoss()):\n",
    "\n",
    "    opts = {f\"sender_{k}\": torch.optim.Adam(v.sender.parameters(), lr=lr) for k, v in agents_dict.items()}\n",
    "    opts.update({f\"receiver_{k}\": torch.optim.Adam(v.receiver.parameters(), lr=lr) for k, v in agents_dict.items()})\n",
    "\n",
    "    epoch_losses = [] # Training loss\n",
    "    agents_val_lossEnfToEnd = {combo : [] for combo in permutations(agents_dict.keys(), 2)}\n",
    "    val_results = {\n",
    "        \"self_intelligibility_mean\": [],\n",
    "        \"ss_correlations_mean\": [],\n",
    "        \"rr_correlations_mean\": [],\n",
    "        \"sr_correlations_mean\": [],\n",
    "        \"1-gram_mean\": [], # same as Jaccard Similarity\n",
    "        \"2-gram_mean\": [],\n",
    "        \"3-gram_mean\": [],\n",
    "        \"4-gram_mean\": [],\n",
    "        \"topological_similarity_mean\": [],\n",
    "        \"edit_distance_mean\": []\n",
    "    }\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        epoch_loss = 0\n",
    "        num_samples = 0\n",
    "\n",
    "        for opt in opts.values():\n",
    "            opt.zero_grad()\n",
    "        loss = 0\n",
    "\n",
    "        temperature = max(temp_end, temp_start + (temp_end - temp_start) * (epoch / epochs))\n",
    "\n",
    "        for j, x in enumerate(train_dataset.dataset.tensors[0]):\n",
    "            \n",
    "            for (agent0, agent1), mult_factor in fn_generate_pair(agents_dict, competitive_level):\n",
    "                loss += mult_factor*fn_forward_pass(agents_dict[agent0], agents_dict[agent1], x, temperature, loss_fn)\n",
    "            \n",
    "            if j%batch_size == 0:\n",
    "                loss.backward()\n",
    "                for opt in opts.values():\n",
    "                    opt.step()\n",
    "                    opt.zero_grad()\n",
    "                epoch_loss += loss\n",
    "                loss = 0\n",
    "\n",
    "            num_samples += 1 # len(x)\n",
    "\n",
    "        epoch_loss /= num_samples\n",
    "        epoch_losses.append(epoch_loss.item())\n",
    "        \n",
    "        if epoch % evalEpochs == 0 or epoch == epochs-1:\n",
    "            \n",
    "            if verbose:\n",
    "                print (f\"Epoch {epoch+1}\")\n",
    "                print (f\"Training loss: {epoch_loss.item()}\")\n",
    "\n",
    "            this_epoch_val_loss = defaultdict(float)\n",
    "            this_epoch_decoded_output = []\n",
    "            self_play_loss = []\n",
    "\n",
    "            for x in val_dataset.dataset.tensors[0]:\n",
    "                this_sample_decoded_output = []\n",
    "                \n",
    "                for name0, name1 in permutations(agents_dict.keys(), 2):\n",
    "                    _loss, _senderOutput, _ = fn_eval_pass(agents_dict[name0], agents_dict[name1], x, temperature, loss_fn, returnData=True)\n",
    "                    this_epoch_val_loss[(name0, name1)] += _loss.item()\n",
    "                    this_sample_decoded_output.append(transform(_senderOutput))\n",
    "                \n",
    "                for agent_name in agents_dict.keys():\n",
    "                    self_play_loss.append(fn_eval_pass(agents_dict[agent_name], agents_dict[agent_name], x, temperature, loss_fn).item())\n",
    "\n",
    "                this_epoch_decoded_output.append(this_sample_decoded_output)\n",
    "\n",
    "            this_epoch_decoded_output = np.array(this_epoch_decoded_output)\n",
    "            # this_epoch_decoded_output = this_epoch_decoded_output[:, ::2]\n",
    "            \n",
    "            val_results = evaluate_matches(this_epoch_decoded_output, val_results, agents_dict)\n",
    "            val_results[\"self_intelligibility_mean\"].append(np.mean(self_play_loss))\n",
    "            val_results[\"topological_similarity_mean\"].append(calculate_topological_similarity(agents_dict, val_dataset, this_epoch_decoded_output, directional=directional))\n",
    "            \n",
    "            for name0, name1 in permutations(agents_dict.keys(), 2):\n",
    "                agents_val_lossEnfToEnd[(name0, name1)].append(this_epoch_val_loss[(name0, name1)]/len(val_dataset))\n",
    "                if verbose:\n",
    "                    print (f\"Validation loss ({name0} -> {name1}): {agents_val_lossEnfToEnd[(name0, name1)][-1]}\")\n",
    "        \n",
    "            print (\"=\"*50)\n",
    "    \n",
    "    return epoch_losses, agents_val_lossEnfToEnd, val_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# DATA GENERATION\n",
    "\n",
    "NUM_CONCEPTS_DIMS = 5\n",
    "NUM_SAMPLES = NUM_CONCEPTS_DIMS*100\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "torch.manual_seed(42)\n",
    "sender_targets = torch.softmax(torch.randn(size = (NUM_SAMPLES, NUM_CONCEPTS_DIMS), device=DEVICE), dim = 1)\n",
    "\n",
    "# DATA SPLIT\n",
    "dataset = torch.utils.data.TensorDataset(sender_targets)\n",
    "train_dataset, val_dataset, test_dataset = torch.utils.data.random_split(dataset, [0.8, 0.1, 0.1])\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(10, 5))\n",
    "sns.boxplot(data=sender_targets, ax=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiment 8.1 - 3 Fully Connected Agents, without Inner Speech"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n",
      "Training loss: 0.1588231474161148\n",
      "Validation loss (0 -> 1): 0.26245445032021963\n",
      "Validation loss (0 -> 2): 0.2623244161484763\n",
      "Validation loss (1 -> 0): 0.2633183699019719\n",
      "Validation loss (1 -> 2): 0.263270394387655\n",
      "Validation loss (2 -> 0): 0.266228602809133\n",
      "Validation loss (2 -> 1): 0.26266267815139144\n",
      "==================================================\n",
      "Epoch 11\n",
      "Training loss: 0.08886328339576721\n",
      "Validation loss (0 -> 1): 0.13204291996284157\n",
      "Validation loss (0 -> 2): 0.13024628087470774\n",
      "Validation loss (1 -> 0): 0.1439338110340759\n",
      "Validation loss (1 -> 2): 0.13234286548249657\n",
      "Validation loss (2 -> 0): 0.1199506537624984\n",
      "Validation loss (2 -> 1): 0.11607153980439762\n",
      "==================================================\n",
      "Epoch 21\n",
      "Training loss: 0.047385793179273605\n",
      "Validation loss (0 -> 1): 0.0765847966549336\n",
      "Validation loss (0 -> 2): 0.07744879558857065\n",
      "Validation loss (1 -> 0): 0.06404348074807785\n",
      "Validation loss (1 -> 2): 0.06749949677614495\n",
      "Validation loss (2 -> 0): 0.05858804844727274\n",
      "Validation loss (2 -> 1): 0.05830523604643531\n",
      "==================================================\n",
      "Epoch 31\n",
      "Training loss: 0.031482722610235214\n",
      "Validation loss (0 -> 1): 0.04872154085860529\n",
      "Validation loss (0 -> 2): 0.049954260291342506\n",
      "Validation loss (1 -> 0): 0.04186058922503435\n",
      "Validation loss (1 -> 2): 0.04257648709535715\n",
      "Validation loss (2 -> 0): 0.03987930426519597\n",
      "Validation loss (2 -> 1): 0.03948504967906047\n",
      "==================================================\n",
      "Epoch 41\n",
      "Training loss: 0.026940129697322845\n",
      "Validation loss (0 -> 1): 0.03975191002318752\n",
      "Validation loss (0 -> 2): 0.04091189728878817\n",
      "Validation loss (1 -> 0): 0.036905375599890246\n",
      "Validation loss (1 -> 2): 0.03818547760223737\n",
      "Validation loss (2 -> 0): 0.03431567314495623\n",
      "Validation loss (2 -> 1): 0.03487412823844352\n",
      "==================================================\n",
      "Epoch 51\n",
      "Training loss: 0.02170884981751442\n",
      "Validation loss (0 -> 1): 0.03224940907595737\n",
      "Validation loss (0 -> 2): 0.032902336952683985\n",
      "Validation loss (1 -> 0): 0.030793785311543614\n",
      "Validation loss (1 -> 2): 0.030418561233964282\n",
      "Validation loss (2 -> 0): 0.028734557215502717\n",
      "Validation loss (2 -> 1): 0.02877490645929356\n",
      "==================================================\n",
      "Epoch 61\n",
      "Training loss: 0.018136966973543167\n",
      "Validation loss (0 -> 1): 0.02556519988225773\n",
      "Validation loss (0 -> 2): 0.026313212990789907\n",
      "Validation loss (1 -> 0): 0.02435031285742298\n",
      "Validation loss (1 -> 2): 0.024514198713368386\n",
      "Validation loss (2 -> 0): 0.02406217992203892\n",
      "Validation loss (2 -> 1): 0.02357350232799945\n",
      "==================================================\n",
      "Epoch 71\n",
      "Training loss: 0.01585673727095127\n",
      "Validation loss (0 -> 1): 0.021627061814215268\n",
      "Validation loss (0 -> 2): 0.021164029889914674\n",
      "Validation loss (1 -> 0): 0.01895822453931032\n",
      "Validation loss (1 -> 2): 0.020173922334070084\n",
      "Validation loss (2 -> 0): 0.01886788235293352\n",
      "Validation loss (2 -> 1): 0.01984271588626143\n",
      "==================================================\n",
      "Epoch 81\n",
      "Training loss: 0.014243151061236858\n",
      "Validation loss (0 -> 1): 0.018766691135242583\n",
      "Validation loss (0 -> 2): 0.018954489827519863\n",
      "Validation loss (1 -> 0): 0.017775945255452827\n",
      "Validation loss (1 -> 2): 0.018800797512813005\n",
      "Validation loss (2 -> 0): 0.016678522786532993\n",
      "Validation loss (2 -> 1): 0.017571858802621135\n",
      "==================================================\n",
      "Epoch 91\n",
      "Training loss: 0.013092529959976673\n",
      "Validation loss (0 -> 1): 0.017186065326532118\n",
      "Validation loss (0 -> 2): 0.017363034056252218\n",
      "Validation loss (1 -> 0): 0.01629903774752165\n",
      "Validation loss (1 -> 2): 0.016631070369112422\n",
      "Validation loss (2 -> 0): 0.01639647624186182\n",
      "Validation loss (2 -> 1): 0.016795302239479497\n",
      "==================================================\n",
      "Epoch 101\n",
      "Training loss: 0.012974938377737999\n",
      "Validation loss (0 -> 1): 0.017194474694842938\n",
      "Validation loss (0 -> 2): 0.017964436331531032\n",
      "Validation loss (1 -> 0): 0.01708047565378365\n",
      "Validation loss (1 -> 2): 0.017432627400521598\n",
      "Validation loss (2 -> 0): 0.016516644116854877\n",
      "Validation loss (2 -> 1): 0.01722760130323877\n",
      "==================================================\n",
      "Epoch 111\n",
      "Training loss: 0.01196620985865593\n",
      "Validation loss (0 -> 1): 0.015706531232353882\n",
      "Validation loss (0 -> 2): 0.01585735755114001\n",
      "Validation loss (1 -> 0): 0.014932597031147452\n",
      "Validation loss (1 -> 2): 0.015191360874596285\n",
      "Validation loss (2 -> 0): 0.014936269252648344\n",
      "Validation loss (2 -> 1): 0.015285294061395688\n",
      "==================================================\n",
      "Epoch 121\n",
      "Training loss: 0.011559737846255302\n",
      "Validation loss (0 -> 1): 0.015564798178620548\n",
      "Validation loss (0 -> 2): 0.01495906306433426\n",
      "Validation loss (1 -> 0): 0.0149557235444081\n",
      "Validation loss (1 -> 2): 0.01542971605558705\n",
      "Validation loss (2 -> 0): 0.014253113135928287\n",
      "Validation loss (2 -> 1): 0.014572692286747043\n",
      "==================================================\n",
      "Epoch 131\n",
      "Training loss: 0.011080104857683182\n",
      "Validation loss (0 -> 1): 0.015014262602344388\n",
      "Validation loss (0 -> 2): 0.01511161428035848\n",
      "Validation loss (1 -> 0): 0.014808578312586178\n",
      "Validation loss (1 -> 2): 0.014840402824374906\n",
      "Validation loss (2 -> 0): 0.013967623031276162\n",
      "Validation loss (2 -> 1): 0.014504139749187744\n",
      "==================================================\n",
      "Epoch 141\n",
      "Training loss: 0.011411251500248909\n",
      "Validation loss (0 -> 1): 0.016080004594914498\n",
      "Validation loss (0 -> 2): 0.015731016048821402\n",
      "Validation loss (1 -> 0): 0.013871548717434052\n",
      "Validation loss (1 -> 2): 0.014160453726071864\n",
      "Validation loss (2 -> 0): 0.013919697190394799\n",
      "Validation loss (2 -> 1): 0.014233937434619292\n",
      "==================================================\n",
      "Epoch 151\n",
      "Training loss: 0.01164428424090147\n",
      "Validation loss (0 -> 1): 0.015868376093530968\n",
      "Validation loss (0 -> 2): 0.015277676672048983\n",
      "Validation loss (1 -> 0): 0.016771888625007704\n",
      "Validation loss (1 -> 2): 0.01636871756563778\n",
      "Validation loss (2 -> 0): 0.014801498073320546\n",
      "Validation loss (2 -> 1): 0.015298643235000782\n",
      "==================================================\n",
      "Epoch 161\n",
      "Training loss: 0.011315780691802502\n",
      "Validation loss (0 -> 1): 0.015939537062040474\n",
      "Validation loss (0 -> 2): 0.015855129756382667\n",
      "Validation loss (1 -> 0): 0.015582461583690019\n",
      "Validation loss (1 -> 2): 0.01508502774515364\n",
      "Validation loss (2 -> 0): 0.014116242360796605\n",
      "Validation loss (2 -> 1): 0.014295369124120043\n",
      "==================================================\n",
      "Epoch 171\n",
      "Training loss: 0.01147916167974472\n",
      "Validation loss (0 -> 1): 0.016939878211996984\n",
      "Validation loss (0 -> 2): 0.016923297042339983\n",
      "Validation loss (1 -> 0): 0.015086525098176935\n",
      "Validation loss (1 -> 2): 0.015533203161694473\n",
      "Validation loss (2 -> 0): 0.014631113579453086\n",
      "Validation loss (2 -> 1): 0.01532835779900779\n",
      "==================================================\n",
      "Epoch 181\n",
      "Training loss: 0.01143065094947815\n",
      "Validation loss (0 -> 1): 0.016911759982904187\n",
      "Validation loss (0 -> 2): 0.016445635522723025\n",
      "Validation loss (1 -> 0): 0.015124928602817818\n",
      "Validation loss (1 -> 2): 0.016080267649631424\n",
      "Validation loss (2 -> 0): 0.014973768469099013\n",
      "Validation loss (2 -> 1): 0.015621585725712065\n",
      "==================================================\n",
      "Epoch 191\n",
      "Training loss: 0.01126090344041586\n",
      "Validation loss (0 -> 1): 0.01694531417950202\n",
      "Validation loss (0 -> 2): 0.01652208993829845\n",
      "Validation loss (1 -> 0): 0.016880835260126334\n",
      "Validation loss (1 -> 2): 0.017314794720850842\n",
      "Validation loss (2 -> 0): 0.015277086158712337\n",
      "Validation loss (2 -> 1): 0.015395036791269377\n",
      "==================================================\n",
      "Epoch 201\n",
      "Training loss: 0.011885862797498703\n",
      "Validation loss (0 -> 1): 0.01857183570480629\n",
      "Validation loss (0 -> 2): 0.01813183991233018\n",
      "Validation loss (1 -> 0): 0.01551806844676321\n",
      "Validation loss (1 -> 2): 0.016848792930759374\n",
      "Validation loss (2 -> 0): 0.015648308366216952\n",
      "Validation loss (2 -> 1): 0.016528184363378388\n",
      "==================================================\n",
      "Epoch 211\n",
      "Training loss: 0.012550048530101776\n",
      "Validation loss (0 -> 1): 0.016628036938855076\n",
      "Validation loss (0 -> 2): 0.016000242357404205\n",
      "Validation loss (1 -> 0): 0.017065041094610933\n",
      "Validation loss (1 -> 2): 0.017120781247504057\n",
      "Validation loss (2 -> 0): 0.017103043129573052\n",
      "Validation loss (2 -> 1): 0.018065071688906757\n",
      "==================================================\n",
      "Epoch 221\n",
      "Training loss: 0.012549522332847118\n",
      "Validation loss (0 -> 1): 0.01681533895451139\n",
      "Validation loss (0 -> 2): 0.01659201270531412\n",
      "Validation loss (1 -> 0): 0.019314137054116144\n",
      "Validation loss (1 -> 2): 0.018779723116840615\n",
      "Validation loss (2 -> 0): 0.016731707957151228\n",
      "Validation loss (2 -> 1): 0.01709200856239477\n",
      "==================================================\n",
      "Epoch 231\n",
      "Training loss: 0.012323427014052868\n",
      "Validation loss (0 -> 1): 0.01657590766517387\n",
      "Validation loss (0 -> 2): 0.015928712885270216\n",
      "Validation loss (1 -> 0): 0.015780441316237556\n",
      "Validation loss (1 -> 2): 0.015782897826820772\n",
      "Validation loss (2 -> 0): 0.0196376123886148\n",
      "Validation loss (2 -> 1): 0.020790649253649464\n",
      "==================================================\n",
      "Epoch 241\n",
      "Training loss: 0.012434324249625206\n",
      "Validation loss (0 -> 1): 0.01623873808493954\n",
      "Validation loss (0 -> 2): 0.016334732886207348\n",
      "Validation loss (1 -> 0): 0.01606637499041426\n",
      "Validation loss (1 -> 2): 0.016299225133006984\n",
      "Validation loss (2 -> 0): 0.018298712502555645\n",
      "Validation loss (2 -> 1): 0.018742312805989057\n",
      "==================================================\n",
      "Epoch 251\n",
      "Training loss: 0.012536589056253433\n",
      "Validation loss (0 -> 1): 0.019452789858041795\n",
      "Validation loss (0 -> 2): 0.019535293217995787\n",
      "Validation loss (1 -> 0): 0.01759621172794141\n",
      "Validation loss (1 -> 2): 0.017514495342038573\n",
      "Validation loss (2 -> 0): 0.01654636816438142\n",
      "Validation loss (2 -> 1): 0.017212760535403503\n",
      "==================================================\n",
      "Epoch 261\n",
      "Training loss: 0.012490489520132542\n",
      "Validation loss (0 -> 1): 0.01884674870991148\n",
      "Validation loss (0 -> 2): 0.019590355559776073\n",
      "Validation loss (1 -> 0): 0.020144979207616417\n",
      "Validation loss (1 -> 2): 0.019872112510493024\n",
      "Validation loss (2 -> 0): 0.017434330564647098\n",
      "Validation loss (2 -> 1): 0.017997445345317827\n",
      "==================================================\n",
      "Epoch 271\n",
      "Training loss: 0.012430587783455849\n",
      "Validation loss (0 -> 1): 0.01837439513354184\n",
      "Validation loss (0 -> 2): 0.018251907862395455\n",
      "Validation loss (1 -> 0): 0.01610378671273793\n",
      "Validation loss (1 -> 2): 0.016626005767902824\n",
      "Validation loss (2 -> 0): 0.01743306681592003\n",
      "Validation loss (2 -> 1): 0.018275881433073665\n",
      "==================================================\n",
      "Epoch 281\n",
      "Training loss: 0.01237119548022747\n",
      "Validation loss (0 -> 1): 0.015971283142571336\n",
      "Validation loss (0 -> 2): 0.015949910837152855\n",
      "Validation loss (1 -> 0): 0.017047899970893923\n",
      "Validation loss (1 -> 2): 0.017018133889941965\n",
      "Validation loss (2 -> 0): 0.018875060819191276\n",
      "Validation loss (2 -> 1): 0.01923593421579426\n",
      "==================================================\n",
      "Epoch 291\n",
      "Training loss: 0.013135322369635105\n",
      "Validation loss (0 -> 1): 0.01967753944809374\n",
      "Validation loss (0 -> 2): 0.01935834338200948\n",
      "Validation loss (1 -> 0): 0.019163388754459446\n",
      "Validation loss (1 -> 2): 0.01945429748026072\n",
      "Validation loss (2 -> 0): 0.019320998775365295\n",
      "Validation loss (2 -> 1): 0.019716407866417283\n",
      "==================================================\n",
      "Epoch 301\n",
      "Training loss: 0.013629832305014133\n",
      "Validation loss (0 -> 1): 0.018784072732159984\n",
      "Validation loss (0 -> 2): 0.018695739424365455\n",
      "Validation loss (1 -> 0): 0.019049339648081514\n",
      "Validation loss (1 -> 2): 0.01934990776102495\n",
      "Validation loss (2 -> 0): 0.018478627398326352\n",
      "Validation loss (2 -> 1): 0.018782651130168235\n",
      "==================================================\n",
      "Epoch 311\n",
      "Training loss: 0.013480414636433125\n",
      "Validation loss (0 -> 1): 0.019034641326870768\n",
      "Validation loss (0 -> 2): 0.019753742504472028\n",
      "Validation loss (1 -> 0): 0.02238212330979877\n",
      "Validation loss (1 -> 2): 0.022501992866527872\n",
      "Validation loss (2 -> 0): 0.018718139042139228\n",
      "Validation loss (2 -> 1): 0.01848203258086869\n",
      "==================================================\n",
      "Epoch 321\n",
      "Training loss: 0.013207035139203072\n",
      "Validation loss (0 -> 1): 0.018699996562645538\n",
      "Validation loss (0 -> 2): 0.0187050629240548\n",
      "Validation loss (1 -> 0): 0.020302657453448773\n",
      "Validation loss (1 -> 2): 0.020477822585526155\n",
      "Validation loss (2 -> 0): 0.019693785043309618\n",
      "Validation loss (2 -> 1): 0.019849545956385554\n",
      "==================================================\n",
      "Epoch 331\n",
      "Training loss: 0.01289929635822773\n",
      "Validation loss (0 -> 1): 0.01903479015767516\n",
      "Validation loss (0 -> 2): 0.019077962593437404\n",
      "Validation loss (1 -> 0): 0.019262498434363805\n",
      "Validation loss (1 -> 2): 0.019808516760895144\n",
      "Validation loss (2 -> 0): 0.01934289847211403\n",
      "Validation loss (2 -> 1): 0.019272858995609567\n",
      "==================================================\n",
      "Epoch 341\n",
      "Training loss: 0.013160512782633305\n",
      "Validation loss (0 -> 1): 0.019429801736114315\n",
      "Validation loss (0 -> 2): 0.017837838732957606\n",
      "Validation loss (1 -> 0): 0.018448878759954823\n",
      "Validation loss (1 -> 2): 0.017976106178175542\n",
      "Validation loss (2 -> 0): 0.01953738012485701\n",
      "Validation loss (2 -> 1): 0.01962075029287007\n",
      "==================================================\n",
      "Epoch 351\n",
      "Training loss: 0.014032798819243908\n",
      "Validation loss (0 -> 1): 0.019692587125027784\n",
      "Validation loss (0 -> 2): 0.01907125392004673\n",
      "Validation loss (1 -> 0): 0.01962019363490981\n",
      "Validation loss (1 -> 2): 0.01991181272700487\n",
      "Validation loss (2 -> 0): 0.0214250357023775\n",
      "Validation loss (2 -> 1): 0.021449786427619983\n",
      "==================================================\n",
      "Epoch 361\n",
      "Training loss: 0.013781274668872356\n",
      "Validation loss (0 -> 1): 0.02071436066296883\n",
      "Validation loss (0 -> 2): 0.021089314617129276\n",
      "Validation loss (1 -> 0): 0.020294181873905474\n",
      "Validation loss (1 -> 2): 0.020332547921971127\n",
      "Validation loss (2 -> 0): 0.021160887996738893\n",
      "Validation loss (2 -> 1): 0.021306584516496516\n",
      "==================================================\n",
      "Epoch 371\n",
      "Training loss: 0.01478550024330616\n",
      "Validation loss (0 -> 1): 0.020755130217621626\n",
      "Validation loss (0 -> 2): 0.020773383559226203\n",
      "Validation loss (1 -> 0): 0.021823880794545402\n",
      "Validation loss (1 -> 2): 0.021719585127138997\n",
      "Validation loss (2 -> 0): 0.02185814326905529\n",
      "Validation loss (2 -> 1): 0.022130971528677035\n",
      "==================================================\n",
      "Epoch 381\n",
      "Training loss: 0.014863122254610062\n",
      "Validation loss (0 -> 1): 0.021366421478160192\n",
      "Validation loss (0 -> 2): 0.021400130543261186\n",
      "Validation loss (1 -> 0): 0.02453600898574223\n",
      "Validation loss (1 -> 2): 0.025142950914159884\n",
      "Validation loss (2 -> 0): 0.021244522676388444\n",
      "Validation loss (2 -> 1): 0.021080861207447014\n",
      "==================================================\n",
      "Epoch 391\n",
      "Training loss: 0.014714051969349384\n",
      "Validation loss (0 -> 1): 0.02099976817586139\n",
      "Validation loss (0 -> 2): 0.02130085965842227\n",
      "Validation loss (1 -> 0): 0.024683288951600844\n",
      "Validation loss (1 -> 2): 0.024890023794141597\n",
      "Validation loss (2 -> 0): 0.02210648147498432\n",
      "Validation loss (2 -> 1): 0.022029150754606236\n",
      "==================================================\n",
      "Epoch 401\n",
      "Training loss: 0.01440621167421341\n",
      "Validation loss (0 -> 1): 0.020176163689175155\n",
      "Validation loss (0 -> 2): 0.019424332725466228\n",
      "Validation loss (1 -> 0): 0.02142237534520973\n",
      "Validation loss (1 -> 2): 0.02101397118074601\n",
      "Validation loss (2 -> 0): 0.02175437212215911\n",
      "Validation loss (2 -> 1): 0.022033952593628784\n",
      "==================================================\n",
      "Epoch 411\n",
      "Training loss: 0.015374830923974514\n",
      "Validation loss (0 -> 1): 0.02217017164133722\n",
      "Validation loss (0 -> 2): 0.02268288322760782\n",
      "Validation loss (1 -> 0): 0.024727514088153837\n",
      "Validation loss (1 -> 2): 0.024885905941409873\n",
      "Validation loss (2 -> 0): 0.02204346825565153\n",
      "Validation loss (2 -> 1): 0.022193660401571832\n",
      "==================================================\n",
      "Epoch 421\n",
      "Training loss: 0.01569301076233387\n",
      "Validation loss (0 -> 1): 0.023232023731688967\n",
      "Validation loss (0 -> 2): 0.022890463281728442\n",
      "Validation loss (1 -> 0): 0.025256086714953198\n",
      "Validation loss (1 -> 2): 0.02576359467537259\n",
      "Validation loss (2 -> 0): 0.023179992152145133\n",
      "Validation loss (2 -> 1): 0.023279978950013172\n",
      "==================================================\n",
      "Epoch 431\n",
      "Training loss: 0.01647350750863552\n",
      "Validation loss (0 -> 1): 0.02339963920898299\n",
      "Validation loss (0 -> 2): 0.023306453338555\n",
      "Validation loss (1 -> 0): 0.024244851417897735\n",
      "Validation loss (1 -> 2): 0.024296492885368934\n",
      "Validation loss (2 -> 0): 0.024652303408292938\n",
      "Validation loss (2 -> 1): 0.02461776131294755\n",
      "==================================================\n",
      "Epoch 441\n",
      "Training loss: 0.017368001863360405\n",
      "Validation loss (0 -> 1): 0.02540577269945061\n",
      "Validation loss (0 -> 2): 0.025345086583474768\n",
      "Validation loss (1 -> 0): 0.025328978143525093\n",
      "Validation loss (1 -> 2): 0.02516341749269486\n",
      "Validation loss (2 -> 0): 0.026445094768205307\n",
      "Validation loss (2 -> 1): 0.026512995606899493\n",
      "==================================================\n",
      "Epoch 451\n",
      "Training loss: 0.017699526622891426\n",
      "Validation loss (0 -> 1): 0.02553346043212514\n",
      "Validation loss (0 -> 2): 0.025849893888807856\n",
      "Validation loss (1 -> 0): 0.02666433918158873\n",
      "Validation loss (1 -> 2): 0.026757078499285852\n",
      "Validation loss (2 -> 0): 0.025814891430200076\n",
      "Validation loss (2 -> 1): 0.02567154226177081\n",
      "==================================================\n",
      "Epoch 461\n",
      "Training loss: 0.017805730924010277\n",
      "Validation loss (0 -> 1): 0.025779292628976692\n",
      "Validation loss (0 -> 2): 0.025988412895239888\n",
      "Validation loss (1 -> 0): 0.028045172505480876\n",
      "Validation loss (1 -> 2): 0.028335546383823386\n",
      "Validation loss (2 -> 0): 0.02459113450058794\n",
      "Validation loss (2 -> 1): 0.024490900270320706\n",
      "==================================================\n",
      "Epoch 471\n",
      "Training loss: 0.019227225333452225\n",
      "Validation loss (0 -> 1): 0.027089657738360983\n",
      "Validation loss (0 -> 2): 0.026816482123176683\n",
      "Validation loss (1 -> 0): 0.030691667367282207\n",
      "Validation loss (1 -> 2): 0.03111893008215702\n",
      "Validation loss (2 -> 0): 0.026121983831617398\n",
      "Validation loss (2 -> 1): 0.026086130188923563\n",
      "==================================================\n",
      "Epoch 481\n",
      "Training loss: 0.018463851884007454\n",
      "Validation loss (0 -> 1): 0.02771665963853593\n",
      "Validation loss (0 -> 2): 0.027956596502226604\n",
      "Validation loss (1 -> 0): 0.029327348149599856\n",
      "Validation loss (1 -> 2): 0.029553846677954423\n",
      "Validation loss (2 -> 0): 0.02666564485334675\n",
      "Validation loss (2 -> 1): 0.027213756882229063\n",
      "==================================================\n",
      "Epoch 491\n",
      "Training loss: 0.020352158695459366\n",
      "Validation loss (0 -> 1): 0.03178301612271753\n",
      "Validation loss (0 -> 2): 0.032048052594109325\n",
      "Validation loss (1 -> 0): 0.03241235513676657\n",
      "Validation loss (1 -> 2): 0.03270389452343807\n",
      "Validation loss (2 -> 0): 0.03351728010646184\n",
      "Validation loss (2 -> 1): 0.03324612215074012\n",
      "==================================================\n",
      "Epoch 500\n",
      "Training loss: 0.018120253458619118\n",
      "Validation loss (0 -> 1): 0.029255987489887048\n",
      "Validation loss (0 -> 2): 0.02931280842036358\n",
      "Validation loss (1 -> 0): 0.028787375685787993\n",
      "Validation loss (1 -> 2): 0.02874247275169182\n",
      "Validation loss (2 -> 0): 0.029824410416185856\n",
      "Validation loss (2 -> 1): 0.029880213563446886\n",
      "==================================================\n",
      "Epoch 1\n",
      "Training loss: 0.15877588093280792\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/adithyavh/anaconda3/envs/rl/lib/python3.11/site-packages/scipy/stats/_stats_py.py:4424: ConstantInputWarning: An input array is constant; the correlation coefficient is not defined.\n",
      "  warnings.warn(stats.ConstantInputWarning(msg))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss (0 -> 1): 0.2634468774078414\n",
      "Validation loss (0 -> 2): 0.2635426861804444\n",
      "Validation loss (1 -> 0): 0.263212647291366\n",
      "Validation loss (1 -> 2): 0.26338837916147895\n",
      "Validation loss (2 -> 0): 0.26338818251620977\n",
      "Validation loss (2 -> 1): 0.26387681761174464\n",
      "==================================================\n",
      "Epoch 11\n",
      "Training loss: 0.10413450002670288\n",
      "Validation loss (0 -> 1): 0.1736723079548392\n",
      "Validation loss (0 -> 2): 0.17707168538094264\n",
      "Validation loss (1 -> 0): 0.1318183813279029\n",
      "Validation loss (1 -> 2): 0.13167854657236602\n",
      "Validation loss (2 -> 0): 0.17749348910961998\n",
      "Validation loss (2 -> 1): 0.17649417801119852\n",
      "==================================================\n",
      "Epoch 21\n",
      "Training loss: 0.07575362175703049\n",
      "Validation loss (0 -> 1): 0.13137482465012\n",
      "Validation loss (0 -> 2): 0.1300869041099213\n",
      "Validation loss (1 -> 0): 0.08311122474027798\n",
      "Validation loss (1 -> 2): 0.08200588357110973\n",
      "Validation loss (2 -> 0): 0.13701117531076307\n",
      "Validation loss (2 -> 1): 0.13194475535303354\n",
      "==================================================\n",
      "Epoch 31\n",
      "Training loss: 0.05055463686585426\n",
      "Validation loss (0 -> 1): 0.09408469423469797\n",
      "Validation loss (0 -> 2): 0.09132527935318649\n",
      "Validation loss (1 -> 0): 0.04634791180586035\n",
      "Validation loss (1 -> 2): 0.046992122894807836\n",
      "Validation loss (2 -> 0): 0.07980807288899086\n",
      "Validation loss (2 -> 1): 0.08763764245377388\n",
      "==================================================\n",
      "Epoch 41\n",
      "Training loss: 0.03564644977450371\n",
      "Validation loss (0 -> 1): 0.0653574847287382\n",
      "Validation loss (0 -> 2): 0.06651878916774877\n",
      "Validation loss (1 -> 0): 0.03276499877916649\n",
      "Validation loss (1 -> 2): 0.03399470080898027\n",
      "Validation loss (2 -> 0): 0.05334073838297627\n",
      "Validation loss (2 -> 1): 0.05695458671398228\n",
      "==================================================\n",
      "Epoch 51\n",
      "Training loss: 0.028561988845467567\n",
      "Validation loss (0 -> 1): 0.04960278666752856\n",
      "Validation loss (0 -> 2): 0.051548227011808195\n",
      "Validation loss (1 -> 0): 0.025792261066526406\n",
      "Validation loss (1 -> 2): 0.027627583293942735\n",
      "Validation loss (2 -> 0): 0.041863445669441716\n",
      "Validation loss (2 -> 1): 0.04518837096024072\n",
      "==================================================\n",
      "Epoch 61\n",
      "Training loss: 0.02421415224671364\n",
      "Validation loss (0 -> 1): 0.04320980985881761\n",
      "Validation loss (0 -> 2): 0.0424213461150066\n",
      "Validation loss (1 -> 0): 0.021420530133327703\n",
      "Validation loss (1 -> 2): 0.023065317692817187\n",
      "Validation loss (2 -> 0): 0.03284192884311778\n",
      "Validation loss (2 -> 1): 0.03737342407810502\n",
      "==================================================\n",
      "Epoch 71\n",
      "Training loss: 0.02075909450650215\n",
      "Validation loss (0 -> 1): 0.03623606682493118\n",
      "Validation loss (0 -> 2): 0.036096389417361936\n",
      "Validation loss (1 -> 0): 0.018835281209394452\n",
      "Validation loss (1 -> 2): 0.020512767783657182\n",
      "Validation loss (2 -> 0): 0.02594488248854759\n",
      "Validation loss (2 -> 1): 0.031027374004770535\n",
      "==================================================\n",
      "Epoch 81\n",
      "Training loss: 0.01803530380129814\n",
      "Validation loss (0 -> 1): 0.031363200199411946\n",
      "Validation loss (0 -> 2): 0.03110068710084306\n",
      "Validation loss (1 -> 0): 0.017613863848746403\n",
      "Validation loss (1 -> 2): 0.019250140684453073\n",
      "Validation loss (2 -> 0): 0.022502579198699094\n",
      "Validation loss (2 -> 1): 0.026392935855983523\n",
      "==================================================\n",
      "Epoch 91\n",
      "Training loss: 0.016609715297818184\n",
      "Validation loss (0 -> 1): 0.02681517360819271\n",
      "Validation loss (0 -> 2): 0.02656352235004306\n",
      "Validation loss (1 -> 0): 0.01753850713655993\n",
      "Validation loss (1 -> 2): 0.0195062142698589\n",
      "Validation loss (2 -> 0): 0.017551835349586327\n",
      "Validation loss (2 -> 1): 0.019588942520204\n",
      "==================================================\n",
      "Epoch 101\n",
      "Training loss: 0.014538399875164032\n",
      "Validation loss (0 -> 1): 0.021180546439136378\n",
      "Validation loss (0 -> 2): 0.022144754687033127\n",
      "Validation loss (1 -> 0): 0.016062731384226935\n",
      "Validation loss (1 -> 2): 0.01720092246803688\n",
      "Validation loss (2 -> 0): 0.01976132120893453\n",
      "Validation loss (2 -> 1): 0.02070515181978408\n",
      "==================================================\n",
      "Epoch 111\n",
      "Training loss: 0.013312951661646366\n",
      "Validation loss (0 -> 1): 0.01984211390852579\n",
      "Validation loss (0 -> 2): 0.020884461341192945\n",
      "Validation loss (1 -> 0): 0.015219605394740938\n",
      "Validation loss (1 -> 2): 0.01613872092566453\n",
      "Validation loss (2 -> 0): 0.018167074452212547\n",
      "Validation loss (2 -> 1): 0.018955584412033204\n",
      "==================================================\n",
      "Epoch 121\n",
      "Training loss: 0.012819519266486168\n",
      "Validation loss (0 -> 1): 0.01760063811991131\n",
      "Validation loss (0 -> 2): 0.018018335669767113\n",
      "Validation loss (1 -> 0): 0.015258072576325504\n",
      "Validation loss (1 -> 2): 0.015506786513942643\n",
      "Validation loss (2 -> 0): 0.016746285279587027\n",
      "Validation loss (2 -> 1): 0.0177438847348094\n",
      "==================================================\n",
      "Epoch 131\n",
      "Training loss: 0.01272567268460989\n",
      "Validation loss (0 -> 1): 0.01801807352569085\n",
      "Validation loss (0 -> 2): 0.017842192527532462\n",
      "Validation loss (1 -> 0): 0.016872974218349556\n",
      "Validation loss (1 -> 2): 0.01709456238124403\n",
      "Validation loss (2 -> 0): 0.018360651126422455\n",
      "Validation loss (2 -> 1): 0.018844166623948694\n",
      "==================================================\n",
      "Epoch 141\n",
      "Training loss: 0.012680402025580406\n",
      "Validation loss (0 -> 1): 0.018574759087714485\n",
      "Validation loss (0 -> 2): 0.01860591722317622\n",
      "Validation loss (1 -> 0): 0.017458845153778383\n",
      "Validation loss (1 -> 2): 0.01731866153793817\n",
      "Validation loss (2 -> 0): 0.018442347039890592\n",
      "Validation loss (2 -> 1): 0.01887029868124955\n",
      "==================================================\n",
      "Epoch 151\n",
      "Training loss: 0.01321092527359724\n",
      "Validation loss (0 -> 1): 0.02043369155957407\n",
      "Validation loss (0 -> 2): 0.020571785877255024\n",
      "Validation loss (1 -> 0): 0.017416171656514053\n",
      "Validation loss (1 -> 2): 0.017647363880387276\n",
      "Validation loss (2 -> 0): 0.019088105244663894\n",
      "Validation loss (2 -> 1): 0.01949663329962277\n",
      "==================================================\n",
      "Epoch 161\n",
      "Training loss: 0.013869703747332096\n",
      "Validation loss (0 -> 1): 0.022552096126782998\n",
      "Validation loss (0 -> 2): 0.02245392465760233\n",
      "Validation loss (1 -> 0): 0.017942435743752868\n",
      "Validation loss (1 -> 2): 0.018266392486402765\n",
      "Validation loss (2 -> 0): 0.02216466873680474\n",
      "Validation loss (2 -> 1): 0.022327127689059124\n",
      "==================================================\n",
      "Epoch 171\n",
      "Training loss: 0.015396696515381336\n",
      "Validation loss (0 -> 1): 0.022233539089356782\n",
      "Validation loss (0 -> 2): 0.021715805544772593\n",
      "Validation loss (1 -> 0): 0.018803952134549037\n",
      "Validation loss (1 -> 2): 0.018768572263406894\n",
      "Validation loss (2 -> 0): 0.021754320354739322\n",
      "Validation loss (2 -> 1): 0.021984846323757665\n",
      "==================================================\n",
      "Epoch 181\n",
      "Training loss: 0.016516992822289467\n",
      "Validation loss (0 -> 1): 0.022435109557482066\n",
      "Validation loss (0 -> 2): 0.022256607371018616\n",
      "Validation loss (1 -> 0): 0.02131082993455493\n",
      "Validation loss (1 -> 2): 0.020742463351489278\n",
      "Validation loss (2 -> 0): 0.02308867529856798\n",
      "Validation loss (2 -> 1): 0.02314850235314225\n",
      "==================================================\n",
      "Epoch 191\n",
      "Training loss: 0.01608194410800934\n",
      "Validation loss (0 -> 1): 0.023236259232653537\n",
      "Validation loss (0 -> 2): 0.023215265309263485\n",
      "Validation loss (1 -> 0): 0.021316418558053555\n",
      "Validation loss (1 -> 2): 0.02143303616088815\n",
      "Validation loss (2 -> 0): 0.023268490225927963\n",
      "Validation loss (2 -> 1): 0.023262491866989875\n",
      "==================================================\n",
      "Epoch 201\n",
      "Training loss: 0.017502594739198685\n",
      "Validation loss (0 -> 1): 0.02773004278235021\n",
      "Validation loss (0 -> 2): 0.027288434994843555\n",
      "Validation loss (1 -> 0): 0.026491384499240666\n",
      "Validation loss (1 -> 2): 0.026056066963901683\n",
      "Validation loss (2 -> 0): 0.027661464616285228\n",
      "Validation loss (2 -> 1): 0.028269911446695915\n",
      "==================================================\n",
      "Epoch 211\n",
      "Training loss: 0.017182135954499245\n",
      "Validation loss (0 -> 1): 0.026588595696666745\n",
      "Validation loss (0 -> 2): 0.02578652039024746\n",
      "Validation loss (1 -> 0): 0.02643524962499214\n",
      "Validation loss (1 -> 2): 0.026566662116165388\n",
      "Validation loss (2 -> 0): 0.029354891207804032\n",
      "Validation loss (2 -> 1): 0.028981668446504044\n",
      "==================================================\n",
      "Epoch 221\n",
      "Training loss: 0.018984388560056686\n",
      "Validation loss (0 -> 1): 0.027784119576317608\n",
      "Validation loss (0 -> 2): 0.02764986910868174\n",
      "Validation loss (1 -> 0): 0.028466859673644648\n",
      "Validation loss (1 -> 2): 0.02884778238436411\n",
      "Validation loss (2 -> 0): 0.028937026876155868\n",
      "Validation loss (2 -> 1): 0.029172677061578726\n",
      "==================================================\n",
      "Epoch 231\n",
      "Training loss: 0.019532492384314537\n",
      "Validation loss (0 -> 1): 0.029907584883840172\n",
      "Validation loss (0 -> 2): 0.03002551059788857\n",
      "Validation loss (1 -> 0): 0.029075221233651975\n",
      "Validation loss (1 -> 2): 0.029179980042463284\n",
      "Validation loss (2 -> 0): 0.03062267038540085\n",
      "Validation loss (2 -> 1): 0.03074400516386959\n",
      "==================================================\n",
      "Epoch 241\n",
      "Training loss: 0.01927952840924263\n",
      "Validation loss (0 -> 1): 0.028094651215033083\n",
      "Validation loss (0 -> 2): 0.027890042017133965\n",
      "Validation loss (1 -> 0): 0.027431569599939393\n",
      "Validation loss (1 -> 2): 0.027773689673485934\n",
      "Validation loss (2 -> 0): 0.026648420859455655\n",
      "Validation loss (2 -> 1): 0.027266157018821104\n",
      "==================================================\n",
      "Epoch 251\n",
      "Training loss: 0.02152881771326065\n",
      "Validation loss (0 -> 1): 0.031625785914438896\n",
      "Validation loss (0 -> 2): 0.031758017238084905\n",
      "Validation loss (1 -> 0): 0.0329073018705094\n",
      "Validation loss (1 -> 2): 0.03313530333496601\n",
      "Validation loss (2 -> 0): 0.03133818105714454\n",
      "Validation loss (2 -> 1): 0.0312866007003322\n",
      "==================================================\n",
      "Epoch 261\n",
      "Training loss: 0.023453807458281517\n",
      "Validation loss (0 -> 1): 0.035506302672438324\n",
      "Validation loss (0 -> 2): 0.0353980259441596\n",
      "Validation loss (1 -> 0): 0.031565995235287116\n",
      "Validation loss (1 -> 2): 0.03102212971451081\n",
      "Validation loss (2 -> 0): 0.037093445538994275\n",
      "Validation loss (2 -> 1): 0.038102581179482516\n",
      "==================================================\n",
      "Epoch 271\n",
      "Training loss: 0.023124434053897858\n",
      "Validation loss (0 -> 1): 0.03475547254631237\n",
      "Validation loss (0 -> 2): 0.03588809179018426\n",
      "Validation loss (1 -> 0): 0.0323328577700886\n",
      "Validation loss (1 -> 2): 0.03242496759812639\n",
      "Validation loss (2 -> 0): 0.036950199582061034\n",
      "Validation loss (2 -> 1): 0.03656719139493361\n",
      "==================================================\n",
      "Epoch 281\n",
      "Training loss: 0.021668612957000732\n",
      "Validation loss (0 -> 1): 0.03404474276401743\n",
      "Validation loss (0 -> 2): 0.0341582148141606\n",
      "Validation loss (1 -> 0): 0.034010389684917756\n",
      "Validation loss (1 -> 2): 0.034049023683546696\n",
      "Validation loss (2 -> 0): 0.034985637452955416\n",
      "Validation loss (2 -> 1): 0.03470354071832844\n",
      "==================================================\n",
      "Epoch 291\n",
      "Training loss: 0.025182483717799187\n",
      "Validation loss (0 -> 1): 0.03494722871353588\n",
      "Validation loss (0 -> 2): 0.03471566836313286\n",
      "Validation loss (1 -> 0): 0.03789035812060319\n",
      "Validation loss (1 -> 2): 0.037311111159397115\n",
      "Validation loss (2 -> 0): 0.03604298360836765\n",
      "Validation loss (2 -> 1): 0.035338066128206266\n",
      "==================================================\n",
      "Epoch 301\n",
      "Training loss: 0.0242911409586668\n",
      "Validation loss (0 -> 1): 0.03513383200421231\n",
      "Validation loss (0 -> 2): 0.034687306340856594\n",
      "Validation loss (1 -> 0): 0.0390216585095186\n",
      "Validation loss (1 -> 2): 0.039134662254800785\n",
      "Validation loss (2 -> 0): 0.03672863821302599\n",
      "Validation loss (2 -> 1): 0.0364167565452226\n",
      "==================================================\n",
      "Epoch 311\n",
      "Training loss: 0.027054384350776672\n",
      "Validation loss (0 -> 1): 0.044134517389393293\n",
      "Validation loss (0 -> 2): 0.044192578000947835\n",
      "Validation loss (1 -> 0): 0.038525478866577034\n",
      "Validation loss (1 -> 2): 0.03769224571835366\n",
      "Validation loss (2 -> 0): 0.050530406737525485\n",
      "Validation loss (2 -> 1): 0.05073215090495069\n",
      "==================================================\n",
      "Epoch 321\n",
      "Training loss: 0.027520794421434402\n",
      "Validation loss (0 -> 1): 0.04600014684227063\n",
      "Validation loss (0 -> 2): 0.04680183493670484\n",
      "Validation loss (1 -> 0): 0.04295663413016882\n",
      "Validation loss (1 -> 2): 0.04335783101014386\n",
      "Validation loss (2 -> 0): 0.04122707791379071\n",
      "Validation loss (2 -> 1): 0.040804710338743465\n",
      "==================================================\n",
      "Epoch 331\n",
      "Training loss: 0.027614368125796318\n",
      "Validation loss (0 -> 1): 0.04562110715880408\n",
      "Validation loss (0 -> 2): 0.046732284787431126\n",
      "Validation loss (1 -> 0): 0.034893804655221176\n",
      "Validation loss (1 -> 2): 0.03401108122772712\n",
      "Validation loss (2 -> 0): 0.050884209622181514\n",
      "Validation loss (2 -> 1): 0.04944175228523818\n",
      "==================================================\n",
      "Epoch 341\n",
      "Training loss: 0.02800566516816616\n",
      "Validation loss (0 -> 1): 0.043527912766730875\n",
      "Validation loss (0 -> 2): 0.04380003397822293\n",
      "Validation loss (1 -> 0): 0.042221551436450684\n",
      "Validation loss (1 -> 2): 0.042464586529386\n",
      "Validation loss (2 -> 0): 0.042369407469104774\n",
      "Validation loss (2 -> 1): 0.042395452636264964\n",
      "==================================================\n",
      "Epoch 351\n",
      "Training loss: 0.027672085911035538\n",
      "Validation loss (0 -> 1): 0.04913243244627665\n",
      "Validation loss (0 -> 2): 0.049865697568748146\n",
      "Validation loss (1 -> 0): 0.03873917540244293\n",
      "Validation loss (1 -> 2): 0.038716400115736176\n",
      "Validation loss (2 -> 0): 0.04561376134690363\n",
      "Validation loss (2 -> 1): 0.044561935372767036\n",
      "==================================================\n",
      "Epoch 361\n",
      "Training loss: 0.02875381149351597\n",
      "Validation loss (0 -> 1): 0.044329954241402444\n",
      "Validation loss (0 -> 2): 0.04441298756035394\n",
      "Validation loss (1 -> 0): 0.04122138438011461\n",
      "Validation loss (1 -> 2): 0.041474034910061165\n",
      "Validation loss (2 -> 0): 0.04377502920560801\n",
      "Validation loss (2 -> 1): 0.04316726387922245\n",
      "==================================================\n",
      "Epoch 371\n",
      "Training loss: 0.02988085336983204\n",
      "Validation loss (0 -> 1): 0.049694954463811884\n",
      "Validation loss (0 -> 2): 0.04964546425078879\n",
      "Validation loss (1 -> 0): 0.044183517107740045\n",
      "Validation loss (1 -> 2): 0.044071124332731415\n",
      "Validation loss (2 -> 0): 0.050093737434326616\n",
      "Validation loss (2 -> 1): 0.049627785946140646\n",
      "==================================================\n",
      "Epoch 381\n",
      "Training loss: 0.03210178017616272\n",
      "Validation loss (0 -> 1): 0.04923687500700907\n",
      "Validation loss (0 -> 2): 0.04923107957216416\n",
      "Validation loss (1 -> 0): 0.048029119830171114\n",
      "Validation loss (1 -> 2): 0.047675449629568906\n",
      "Validation loss (2 -> 0): 0.05995399172592442\n",
      "Validation loss (2 -> 1): 0.05888201664907683\n",
      "==================================================\n",
      "Epoch 391\n",
      "Training loss: 0.03406781330704689\n",
      "Validation loss (0 -> 1): 0.05499230767690278\n",
      "Validation loss (0 -> 2): 0.054787207087429124\n",
      "Validation loss (1 -> 0): 0.04501710370203\n",
      "Validation loss (1 -> 2): 0.04597472474975803\n",
      "Validation loss (2 -> 0): 0.055174912310576474\n",
      "Validation loss (2 -> 1): 0.05456743031190854\n",
      "==================================================\n",
      "Epoch 401\n",
      "Training loss: 0.03441691771149635\n",
      "Validation loss (0 -> 1): 0.04926577622198238\n",
      "Validation loss (0 -> 2): 0.04935357022193784\n",
      "Validation loss (1 -> 0): 0.04831498362913408\n",
      "Validation loss (1 -> 2): 0.050024797360601954\n",
      "Validation loss (2 -> 0): 0.04906420996208908\n",
      "Validation loss (2 -> 1): 0.0506208252475335\n",
      "==================================================\n",
      "Epoch 411\n",
      "Training loss: 0.028195718303322792\n",
      "Validation loss (0 -> 1): 0.04288639369580778\n",
      "Validation loss (0 -> 2): 0.042629962170612996\n",
      "Validation loss (1 -> 0): 0.04475533866439946\n",
      "Validation loss (1 -> 2): 0.04548492320376681\n",
      "Validation loss (2 -> 0): 0.045033824097045\n",
      "Validation loss (2 -> 1): 0.04490295922179939\n",
      "==================================================\n",
      "Epoch 421\n",
      "Training loss: 0.022054849192500114\n",
      "Validation loss (0 -> 1): 0.03359554240807484\n",
      "Validation loss (0 -> 2): 0.03353232681198279\n",
      "Validation loss (1 -> 0): 0.03578919084604422\n",
      "Validation loss (1 -> 2): 0.03515532725650701\n",
      "Validation loss (2 -> 0): 0.03290172798646381\n",
      "Validation loss (2 -> 1): 0.0319697917252779\n",
      "==================================================\n",
      "Epoch 431\n",
      "Training loss: 0.022101322188973427\n",
      "Validation loss (0 -> 1): 0.035754661368810045\n",
      "Validation loss (0 -> 2): 0.03648749434622005\n",
      "Validation loss (1 -> 0): 0.03156771636466146\n",
      "Validation loss (1 -> 2): 0.031898616454054715\n",
      "Validation loss (2 -> 0): 0.03068649848777568\n",
      "Validation loss (2 -> 1): 0.03102976721711457\n",
      "==================================================\n",
      "Epoch 441\n",
      "Training loss: 0.02218053489923477\n",
      "Validation loss (0 -> 1): 0.03226895038984367\n",
      "Validation loss (0 -> 2): 0.032491306256852114\n",
      "Validation loss (1 -> 0): 0.031442206962383354\n",
      "Validation loss (1 -> 2): 0.03181406828305626\n",
      "Validation loss (2 -> 0): 0.03163168236722413\n",
      "Validation loss (2 -> 1): 0.03165353122953093\n",
      "==================================================\n",
      "Epoch 451\n",
      "Training loss: 0.023283222690224648\n",
      "Validation loss (0 -> 1): 0.0381738929709536\n",
      "Validation loss (0 -> 2): 0.03782540693311603\n",
      "Validation loss (1 -> 0): 0.03625177116366103\n",
      "Validation loss (1 -> 2): 0.035852800495631526\n",
      "Validation loss (2 -> 0): 0.03601101101230597\n",
      "Validation loss (2 -> 1): 0.035300978388258956\n",
      "==================================================\n",
      "Epoch 461\n",
      "Training loss: 0.023416846990585327\n",
      "Validation loss (0 -> 1): 0.03749391722682049\n",
      "Validation loss (0 -> 2): 0.03726308097080619\n",
      "Validation loss (1 -> 0): 0.036844992284313774\n",
      "Validation loss (1 -> 2): 0.03667165235630818\n",
      "Validation loss (2 -> 0): 0.03301317705940164\n",
      "Validation loss (2 -> 1): 0.03240727077311021\n",
      "==================================================\n",
      "Epoch 471\n",
      "Training loss: 0.022599831223487854\n",
      "Validation loss (0 -> 1): 0.03264452002469625\n",
      "Validation loss (0 -> 2): 0.03278475267423346\n",
      "Validation loss (1 -> 0): 0.037916296812618384\n",
      "Validation loss (1 -> 2): 0.038087210139819944\n",
      "Validation loss (2 -> 0): 0.03253572596542654\n",
      "Validation loss (2 -> 1): 0.03245651927081781\n",
      "==================================================\n",
      "Epoch 481\n",
      "Training loss: 0.023567164316773415\n",
      "Validation loss (0 -> 1): 0.03660005353944143\n",
      "Validation loss (0 -> 2): 0.03690775158436736\n",
      "Validation loss (1 -> 0): 0.034838889902603115\n",
      "Validation loss (1 -> 2): 0.035632033972651696\n",
      "Validation loss (2 -> 0): 0.0332371402579156\n",
      "Validation loss (2 -> 1): 0.03363942700816551\n",
      "==================================================\n",
      "Epoch 491\n",
      "Training loss: 0.02340387925505638\n",
      "Validation loss (0 -> 1): 0.0346943348541754\n",
      "Validation loss (0 -> 2): 0.03581550891540246\n",
      "Validation loss (1 -> 0): 0.036369037121985456\n",
      "Validation loss (1 -> 2): 0.037004110791312994\n",
      "Validation loss (2 -> 0): 0.03577086504577892\n",
      "Validation loss (2 -> 1): 0.035350203766101915\n",
      "==================================================\n",
      "Epoch 500\n",
      "Training loss: 0.022835517302155495\n",
      "Validation loss (0 -> 1): 0.03583443919509591\n",
      "Validation loss (0 -> 2): 0.035722717719181674\n",
      "Validation loss (1 -> 0): 0.036686991503665924\n",
      "Validation loss (1 -> 2): 0.036192086046721667\n",
      "Validation loss (2 -> 0): 0.04068299202124763\n",
      "Validation loss (2 -> 1): 0.04094367045639956\n",
      "==================================================\n",
      "Epoch 1\n",
      "Training loss: 0.1587931513786316\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/adithyavh/anaconda3/envs/rl/lib/python3.11/site-packages/scipy/stats/_stats_py.py:4424: ConstantInputWarning: An input array is constant; the correlation coefficient is not defined.\n",
      "  warnings.warn(stats.ConstantInputWarning(msg))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss (0 -> 1): 0.26326457770890554\n",
      "Validation loss (0 -> 2): 0.2632461903197691\n",
      "Validation loss (1 -> 0): 0.26363124448456804\n",
      "Validation loss (1 -> 2): 0.2638290307694115\n",
      "Validation loss (2 -> 0): 0.2639074913912918\n",
      "Validation loss (2 -> 1): 0.264008609278244\n",
      "==================================================\n",
      "Epoch 11\n",
      "Training loss: 0.07014760375022888\n",
      "Validation loss (0 -> 1): 0.08467038386384956\n",
      "Validation loss (0 -> 2): 0.08613383604417323\n",
      "Validation loss (1 -> 0): 0.10815577321365709\n",
      "Validation loss (1 -> 2): 0.10610217504989122\n",
      "Validation loss (2 -> 0): 0.11790003432543017\n",
      "Validation loss (2 -> 1): 0.11221621821285226\n",
      "==================================================\n",
      "Epoch 21\n",
      "Training loss: 0.04169260337948799\n",
      "Validation loss (0 -> 1): 0.053481649156310596\n",
      "Validation loss (0 -> 2): 0.05300749162037391\n",
      "Validation loss (1 -> 0): 0.06444675844919402\n",
      "Validation loss (1 -> 2): 0.06116906884242781\n",
      "Validation loss (2 -> 0): 0.05752496463159332\n",
      "Validation loss (2 -> 1): 0.05490230973227881\n",
      "==================================================\n",
      "Epoch 31\n",
      "Training loss: 0.030619382858276367\n",
      "Validation loss (0 -> 1): 0.04116562439900008\n",
      "Validation loss (0 -> 2): 0.04042981054066331\n",
      "Validation loss (1 -> 0): 0.0386988914522226\n",
      "Validation loss (1 -> 2): 0.0364792072151613\n",
      "Validation loss (2 -> 0): 0.043206843754596776\n",
      "Validation loss (2 -> 1): 0.04247046105068875\n",
      "==================================================\n",
      "Epoch 41\n",
      "Training loss: 0.023851357400417328\n",
      "Validation loss (0 -> 1): 0.035587134499073726\n",
      "Validation loss (0 -> 2): 0.0341464374345378\n",
      "Validation loss (1 -> 0): 0.026862499692069833\n",
      "Validation loss (1 -> 2): 0.025852571194336635\n",
      "Validation loss (2 -> 0): 0.035603639811051836\n",
      "Validation loss (2 -> 1): 0.034809375714539785\n",
      "==================================================\n",
      "Epoch 51\n",
      "Training loss: 0.02057829685509205\n",
      "Validation loss (0 -> 1): 0.029506826793221988\n",
      "Validation loss (0 -> 2): 0.027293224659370025\n",
      "Validation loss (1 -> 0): 0.02281793812122487\n",
      "Validation loss (1 -> 2): 0.021978273807035292\n",
      "Validation loss (2 -> 0): 0.026024462009954733\n",
      "Validation loss (2 -> 1): 0.027458259508566698\n",
      "==================================================\n",
      "Epoch 61\n",
      "Training loss: 0.016012273728847504\n",
      "Validation loss (0 -> 1): 0.02166730674893188\n",
      "Validation loss (0 -> 2): 0.020906074492304468\n",
      "Validation loss (1 -> 0): 0.019257650203653612\n",
      "Validation loss (1 -> 2): 0.018589071632450212\n",
      "Validation loss (2 -> 0): 0.019836424394598\n",
      "Validation loss (2 -> 1): 0.019520354446285637\n",
      "==================================================\n",
      "Epoch 71\n",
      "Training loss: 0.013484311290085316\n",
      "Validation loss (0 -> 1): 0.017405438376881646\n",
      "Validation loss (0 -> 2): 0.017503410328135943\n",
      "Validation loss (1 -> 0): 0.016408239595402847\n",
      "Validation loss (1 -> 2): 0.016696081551053794\n",
      "Validation loss (2 -> 0): 0.016585162089177173\n",
      "Validation loss (2 -> 1): 0.016835977835726226\n",
      "==================================================\n",
      "Epoch 81\n",
      "Training loss: 0.012459401972591877\n",
      "Validation loss (0 -> 1): 0.015809559213230386\n",
      "Validation loss (0 -> 2): 0.015645393406884978\n",
      "Validation loss (1 -> 0): 0.015279749712426564\n",
      "Validation loss (1 -> 2): 0.015103064738577815\n",
      "Validation loss (2 -> 0): 0.014920082444732544\n",
      "Validation loss (2 -> 1): 0.01486301953176735\n",
      "==================================================\n",
      "Epoch 91\n",
      "Training loss: 0.011415441520512104\n",
      "Validation loss (0 -> 1): 0.014256281643392868\n",
      "Validation loss (0 -> 2): 0.014235696418036242\n",
      "Validation loss (1 -> 0): 0.013511135407388792\n",
      "Validation loss (1 -> 2): 0.013916541498874722\n",
      "Validation loss (2 -> 0): 0.015066938563468284\n",
      "Validation loss (2 -> 1): 0.015365483516216045\n",
      "==================================================\n",
      "Epoch 101\n",
      "Training loss: 0.010511653497815132\n",
      "Validation loss (0 -> 1): 0.013805683716072962\n",
      "Validation loss (0 -> 2): 0.014252666589527507\n",
      "Validation loss (1 -> 0): 0.01349863374067354\n",
      "Validation loss (1 -> 2): 0.0134336485528911\n",
      "Validation loss (2 -> 0): 0.012803569806710585\n",
      "Validation loss (2 -> 1): 0.012767743757503922\n",
      "==================================================\n",
      "Epoch 111\n",
      "Training loss: 0.010426447726786137\n",
      "Validation loss (0 -> 1): 0.013246007254820143\n",
      "Validation loss (0 -> 2): 0.0136103099457614\n",
      "Validation loss (1 -> 0): 0.013622089007403701\n",
      "Validation loss (1 -> 2): 0.013442763066450425\n",
      "Validation loss (2 -> 0): 0.01324007262574014\n",
      "Validation loss (2 -> 1): 0.013343014059937559\n",
      "==================================================\n",
      "Epoch 121\n",
      "Training loss: 0.009837792254984379\n",
      "Validation loss (0 -> 1): 0.01345209259990952\n",
      "Validation loss (0 -> 2): 0.013426755246800894\n",
      "Validation loss (1 -> 0): 0.012550685637143033\n",
      "Validation loss (1 -> 2): 0.012910415226579063\n",
      "Validation loss (2 -> 0): 0.012452096617671486\n",
      "Validation loss (2 -> 1): 0.012579342549142893\n",
      "==================================================\n",
      "Epoch 131\n",
      "Training loss: 0.009775185957551003\n",
      "Validation loss (0 -> 1): 0.013215810158653767\n",
      "Validation loss (0 -> 2): 0.012957598777793464\n",
      "Validation loss (1 -> 0): 0.01263110066691297\n",
      "Validation loss (1 -> 2): 0.01275998202860137\n",
      "Validation loss (2 -> 0): 0.013859894899273967\n",
      "Validation loss (2 -> 1): 0.013685646039411949\n",
      "==================================================\n",
      "Epoch 141\n",
      "Training loss: 0.009950149804353714\n",
      "Validation loss (0 -> 1): 0.013281823098568566\n",
      "Validation loss (0 -> 2): 0.013671418983140029\n",
      "Validation loss (1 -> 0): 0.013496715912624494\n",
      "Validation loss (1 -> 2): 0.013605400624583127\n",
      "Validation loss (2 -> 0): 0.014128534158899128\n",
      "Validation loss (2 -> 1): 0.013977224739865051\n",
      "==================================================\n",
      "Epoch 151\n",
      "Training loss: 0.009864136576652527\n",
      "Validation loss (0 -> 1): 0.012394424856502155\n",
      "Validation loss (0 -> 2): 0.012421576183478465\n",
      "Validation loss (1 -> 0): 0.012588027459714794\n",
      "Validation loss (1 -> 2): 0.012793458857377118\n",
      "Validation loss (2 -> 0): 0.013413479431037559\n",
      "Validation loss (2 -> 1): 0.01311677364325078\n",
      "==================================================\n",
      "Epoch 161\n",
      "Training loss: 0.0098044378682971\n",
      "Validation loss (0 -> 1): 0.01272478676670289\n",
      "Validation loss (0 -> 2): 0.012630807145933431\n",
      "Validation loss (1 -> 0): 0.013895866157072305\n",
      "Validation loss (1 -> 2): 0.013275868776545394\n",
      "Validation loss (2 -> 0): 0.01259014429677336\n",
      "Validation loss (2 -> 1): 0.012783514831899084\n",
      "==================================================\n",
      "Epoch 171\n",
      "Training loss: 0.010035399347543716\n",
      "Validation loss (0 -> 1): 0.014116365129957557\n",
      "Validation loss (0 -> 2): 0.013979544143458042\n",
      "Validation loss (1 -> 0): 0.012694617085508071\n",
      "Validation loss (1 -> 2): 0.012402765082661062\n",
      "Validation loss (2 -> 0): 0.013702868478794698\n",
      "Validation loss (2 -> 1): 0.013987075524637476\n",
      "==================================================\n",
      "Epoch 181\n",
      "Training loss: 0.00974226649850607\n",
      "Validation loss (0 -> 1): 0.01341969534960299\n",
      "Validation loss (0 -> 2): 0.012737961782040657\n",
      "Validation loss (1 -> 0): 0.014021037540878752\n",
      "Validation loss (1 -> 2): 0.013016565450889174\n",
      "Validation loss (2 -> 0): 0.015213118064202717\n",
      "Validation loss (2 -> 1): 0.015101284100746853\n",
      "==================================================\n",
      "Epoch 191\n",
      "Training loss: 0.009771249257028103\n",
      "Validation loss (0 -> 1): 0.013379257131382473\n",
      "Validation loss (0 -> 2): 0.012317918117769295\n",
      "Validation loss (1 -> 0): 0.013903365126425342\n",
      "Validation loss (1 -> 2): 0.013356942739101214\n",
      "Validation loss (2 -> 0): 0.014166606068320107\n",
      "Validation loss (2 -> 1): 0.014360761793286657\n",
      "==================================================\n",
      "Epoch 201\n",
      "Training loss: 0.01000171434134245\n",
      "Validation loss (0 -> 1): 0.01317624898176291\n",
      "Validation loss (0 -> 2): 0.012128905119898264\n",
      "Validation loss (1 -> 0): 0.012661913363735948\n",
      "Validation loss (1 -> 2): 0.011884749300661497\n",
      "Validation loss (2 -> 0): 0.014234335260480293\n",
      "Validation loss (2 -> 1): 0.014512622052134248\n",
      "==================================================\n",
      "Epoch 211\n",
      "Training loss: 0.010234707035124302\n",
      "Validation loss (0 -> 1): 0.014331173698756174\n",
      "Validation loss (0 -> 2): 0.014135496163653442\n",
      "Validation loss (1 -> 0): 0.016938313413556897\n",
      "Validation loss (1 -> 2): 0.01651695022461354\n",
      "Validation loss (2 -> 0): 0.014973679374779749\n",
      "Validation loss (2 -> 1): 0.014791483097942546\n",
      "==================================================\n",
      "Epoch 221\n",
      "Training loss: 0.011062567122280598\n",
      "Validation loss (0 -> 1): 0.01605192283955148\n",
      "Validation loss (0 -> 2): 0.015375590492112678\n",
      "Validation loss (1 -> 0): 0.015574217283719917\n",
      "Validation loss (1 -> 2): 0.014790199458620918\n",
      "Validation loss (2 -> 0): 0.017001692993926554\n",
      "Validation loss (2 -> 1): 0.01694995190211557\n",
      "==================================================\n",
      "Epoch 231\n",
      "Training loss: 0.010533737018704414\n",
      "Validation loss (0 -> 1): 0.014604576322781213\n",
      "Validation loss (0 -> 2): 0.013965340407939947\n",
      "Validation loss (1 -> 0): 0.014816414622837329\n",
      "Validation loss (1 -> 2): 0.014557342240605066\n",
      "Validation loss (2 -> 0): 0.016372101380038657\n",
      "Validation loss (2 -> 1): 0.01633785257305135\n",
      "==================================================\n",
      "Epoch 241\n",
      "Training loss: 0.01048107910901308\n",
      "Validation loss (0 -> 1): 0.01526371334293799\n",
      "Validation loss (0 -> 2): 0.014740193238121719\n",
      "Validation loss (1 -> 0): 0.0142703248082762\n",
      "Validation loss (1 -> 2): 0.013813519064588036\n",
      "Validation loss (2 -> 0): 0.015298426635054057\n",
      "Validation loss (2 -> 1): 0.014976785667677177\n",
      "==================================================\n",
      "Epoch 251\n",
      "Training loss: 0.01176692545413971\n",
      "Validation loss (0 -> 1): 0.017809699871068004\n",
      "Validation loss (0 -> 2): 0.017288430293829152\n",
      "Validation loss (1 -> 0): 0.01538817969701995\n",
      "Validation loss (1 -> 2): 0.014686318401409153\n",
      "Validation loss (2 -> 0): 0.017569069516739547\n",
      "Validation loss (2 -> 1): 0.01789543809980387\n",
      "==================================================\n",
      "Epoch 261\n",
      "Training loss: 0.011189118959009647\n",
      "Validation loss (0 -> 1): 0.014819230618159054\n",
      "Validation loss (0 -> 2): 0.014326632000520477\n",
      "Validation loss (1 -> 0): 0.014102096310798515\n",
      "Validation loss (1 -> 2): 0.013863600349905027\n",
      "Validation loss (2 -> 0): 0.017682557707412342\n",
      "Validation loss (2 -> 1): 0.017191587273227924\n",
      "==================================================\n",
      "Epoch 271\n",
      "Training loss: 0.011138997040688992\n",
      "Validation loss (0 -> 1): 0.016316933799789695\n",
      "Validation loss (0 -> 2): 0.016388208915668657\n",
      "Validation loss (1 -> 0): 0.015559461087359523\n",
      "Validation loss (1 -> 2): 0.015431205359009255\n",
      "Validation loss (2 -> 0): 0.01910963343012554\n",
      "Validation loss (2 -> 1): 0.01879943050116708\n",
      "==================================================\n",
      "Epoch 281\n",
      "Training loss: 0.011623220518231392\n",
      "Validation loss (0 -> 1): 0.018101704508699187\n",
      "Validation loss (0 -> 2): 0.017441097894243286\n",
      "Validation loss (1 -> 0): 0.018908465432614322\n",
      "Validation loss (1 -> 2): 0.018277134632899105\n",
      "Validation loss (2 -> 0): 0.019536634736505222\n",
      "Validation loss (2 -> 1): 0.019188907465140802\n",
      "==================================================\n",
      "Epoch 291\n",
      "Training loss: 0.011828631162643433\n",
      "Validation loss (0 -> 1): 0.01670278247576789\n",
      "Validation loss (0 -> 2): 0.016132594998007333\n",
      "Validation loss (1 -> 0): 0.016902822043266496\n",
      "Validation loss (1 -> 2): 0.01637990309483939\n",
      "Validation loss (2 -> 0): 0.017125435872512754\n",
      "Validation loss (2 -> 1): 0.017065614266211924\n",
      "==================================================\n",
      "Epoch 301\n",
      "Training loss: 0.012183371931314468\n",
      "Validation loss (0 -> 1): 0.0171576043125242\n",
      "Validation loss (0 -> 2): 0.01677638363536971\n",
      "Validation loss (1 -> 0): 0.017755655992514222\n",
      "Validation loss (1 -> 2): 0.017494850191396835\n",
      "Validation loss (2 -> 0): 0.018484558254276636\n",
      "Validation loss (2 -> 1): 0.01816998855836573\n",
      "==================================================\n",
      "Epoch 311\n",
      "Training loss: 0.012917297892272472\n",
      "Validation loss (0 -> 1): 0.019077039954208886\n",
      "Validation loss (0 -> 2): 0.01872895216467441\n",
      "Validation loss (1 -> 0): 0.017769423657628066\n",
      "Validation loss (1 -> 2): 0.01701244948031672\n",
      "Validation loss (2 -> 0): 0.018065510972446644\n",
      "Validation loss (2 -> 1): 0.01709729019428778\n",
      "==================================================\n",
      "Epoch 321\n",
      "Training loss: 0.013152371160686016\n",
      "Validation loss (0 -> 1): 0.019447354823641946\n",
      "Validation loss (0 -> 2): 0.018919805837867898\n",
      "Validation loss (1 -> 0): 0.021374206409959698\n",
      "Validation loss (1 -> 2): 0.021663010929187293\n",
      "Validation loss (2 -> 0): 0.019572743654180158\n",
      "Validation loss (2 -> 1): 0.01917389450612973\n",
      "==================================================\n",
      "Epoch 331\n",
      "Training loss: 0.013147873803973198\n",
      "Validation loss (0 -> 1): 0.019026959029870342\n",
      "Validation loss (0 -> 2): 0.018339191416562244\n",
      "Validation loss (1 -> 0): 0.018421527347964\n",
      "Validation loss (1 -> 2): 0.01840120328040939\n",
      "Validation loss (2 -> 0): 0.020356128594648908\n",
      "Validation loss (2 -> 1): 0.020241271649829286\n",
      "==================================================\n",
      "Epoch 341\n",
      "Training loss: 0.013338194228708744\n",
      "Validation loss (0 -> 1): 0.02011111869549495\n",
      "Validation loss (0 -> 2): 0.01951359359194612\n",
      "Validation loss (1 -> 0): 0.018763807471623296\n",
      "Validation loss (1 -> 2): 0.018128804993666564\n",
      "Validation loss (2 -> 0): 0.027874779873418448\n",
      "Validation loss (2 -> 1): 0.027520044308330396\n",
      "==================================================\n",
      "Epoch 351\n",
      "Training loss: 0.013385413214564323\n",
      "Validation loss (0 -> 1): 0.02156973476652638\n",
      "Validation loss (0 -> 2): 0.021885481221188455\n",
      "Validation loss (1 -> 0): 0.020972702269882574\n",
      "Validation loss (1 -> 2): 0.02089858212364561\n",
      "Validation loss (2 -> 0): 0.023528916893592395\n",
      "Validation loss (2 -> 1): 0.02331969418657536\n",
      "==================================================\n",
      "Epoch 361\n",
      "Training loss: 0.015011853538453579\n",
      "Validation loss (0 -> 1): 0.024672732499493578\n",
      "Validation loss (0 -> 2): 0.023774181808148567\n",
      "Validation loss (1 -> 0): 0.022616885083843952\n",
      "Validation loss (1 -> 2): 0.021937718718036195\n",
      "Validation loss (2 -> 0): 0.02610257997412191\n",
      "Validation loss (2 -> 1): 0.026298857620713535\n",
      "==================================================\n",
      "Epoch 371\n",
      "Training loss: 0.014394978061318398\n",
      "Validation loss (0 -> 1): 0.02086663904672605\n",
      "Validation loss (0 -> 2): 0.020373110696382354\n",
      "Validation loss (1 -> 0): 0.023113702882401412\n",
      "Validation loss (1 -> 2): 0.0228755860934325\n",
      "Validation loss (2 -> 0): 0.02541061780109885\n",
      "Validation loss (2 -> 1): 0.02541595484035497\n",
      "==================================================\n",
      "Epoch 381\n",
      "Training loss: 0.014941100031137466\n",
      "Validation loss (0 -> 1): 0.02188554745851434\n",
      "Validation loss (0 -> 2): 0.021608212497230852\n",
      "Validation loss (1 -> 0): 0.021383475179900416\n",
      "Validation loss (1 -> 2): 0.02064865942717006\n",
      "Validation loss (2 -> 0): 0.025125464531629404\n",
      "Validation loss (2 -> 1): 0.025050594757049113\n",
      "==================================================\n",
      "Epoch 391\n",
      "Training loss: 0.015251869335770607\n",
      "Validation loss (0 -> 1): 0.024834008086836546\n",
      "Validation loss (0 -> 2): 0.024636184055852935\n",
      "Validation loss (1 -> 0): 0.02237239958907594\n",
      "Validation loss (1 -> 2): 0.021956403417352704\n",
      "Validation loss (2 -> 0): 0.026726456047981628\n",
      "Validation loss (2 -> 1): 0.02658046791821107\n",
      "==================================================\n",
      "Epoch 401\n",
      "Training loss: 0.01598440110683441\n",
      "Validation loss (0 -> 1): 0.02562107478188409\n",
      "Validation loss (0 -> 2): 0.02533032213585102\n",
      "Validation loss (1 -> 0): 0.02437698621864911\n",
      "Validation loss (1 -> 2): 0.023967664886149577\n",
      "Validation loss (2 -> 0): 0.02860071649112797\n",
      "Validation loss (2 -> 1): 0.028015487311058677\n",
      "==================================================\n",
      "Epoch 411\n",
      "Training loss: 0.01488027535378933\n",
      "Validation loss (0 -> 1): 0.019764380836422787\n",
      "Validation loss (0 -> 2): 0.019093522840230435\n",
      "Validation loss (1 -> 0): 0.019089794524988976\n",
      "Validation loss (1 -> 2): 0.01890794748422195\n",
      "Validation loss (2 -> 0): 0.02501841489698563\n",
      "Validation loss (2 -> 1): 0.024953382073363173\n",
      "==================================================\n",
      "Epoch 421\n",
      "Training loss: 0.015547229908406734\n",
      "Validation loss (0 -> 1): 0.025101068365638638\n",
      "Validation loss (0 -> 2): 0.024485237728513312\n",
      "Validation loss (1 -> 0): 0.022626918467358335\n",
      "Validation loss (1 -> 2): 0.022301432902459055\n",
      "Validation loss (2 -> 0): 0.029194713026663523\n",
      "Validation loss (2 -> 1): 0.029495732565919752\n",
      "==================================================\n",
      "Epoch 431\n",
      "Training loss: 0.01681562513113022\n",
      "Validation loss (0 -> 1): 0.024726252836771892\n",
      "Validation loss (0 -> 2): 0.02445412852342997\n",
      "Validation loss (1 -> 0): 0.02393266746228619\n",
      "Validation loss (1 -> 2): 0.023579076142632403\n",
      "Validation loss (2 -> 0): 0.02980467609502739\n",
      "Validation loss (2 -> 1): 0.029724318462685913\n",
      "==================================================\n",
      "Epoch 441\n",
      "Training loss: 0.016356192529201508\n",
      "Validation loss (0 -> 1): 0.0248498085920437\n",
      "Validation loss (0 -> 2): 0.024284366143401712\n",
      "Validation loss (1 -> 0): 0.0238035910907638\n",
      "Validation loss (1 -> 2): 0.023468624995148277\n",
      "Validation loss (2 -> 0): 0.028814763522095745\n",
      "Validation loss (2 -> 1): 0.028871130514889955\n",
      "==================================================\n",
      "Epoch 451\n",
      "Training loss: 0.01641685888171196\n",
      "Validation loss (0 -> 1): 0.024663663260325847\n",
      "Validation loss (0 -> 2): 0.02459409300099651\n",
      "Validation loss (1 -> 0): 0.027744971474494378\n",
      "Validation loss (1 -> 2): 0.02671522929038474\n",
      "Validation loss (2 -> 0): 0.02685983152452536\n",
      "Validation loss (2 -> 1): 0.02673022085964476\n",
      "==================================================\n",
      "Epoch 461\n",
      "Training loss: 0.01701408438384533\n",
      "Validation loss (0 -> 1): 0.02352143734344281\n",
      "Validation loss (0 -> 2): 0.023332737357122824\n",
      "Validation loss (1 -> 0): 0.02477205260362098\n",
      "Validation loss (1 -> 2): 0.024486894367073547\n",
      "Validation loss (2 -> 0): 0.0309850277060832\n",
      "Validation loss (2 -> 1): 0.03087671330671583\n",
      "==================================================\n",
      "Epoch 471\n",
      "Training loss: 0.017479905858635902\n",
      "Validation loss (0 -> 1): 0.02426622531223984\n",
      "Validation loss (0 -> 2): 0.02396354532451369\n",
      "Validation loss (1 -> 0): 0.027522567917840204\n",
      "Validation loss (1 -> 2): 0.0271659920865568\n",
      "Validation loss (2 -> 0): 0.02921957923215814\n",
      "Validation loss (2 -> 1): 0.029683179716448647\n",
      "==================================================\n",
      "Epoch 481\n",
      "Training loss: 0.017547279596328735\n",
      "Validation loss (0 -> 1): 0.02687573074879765\n",
      "Validation loss (0 -> 2): 0.026559172372799367\n",
      "Validation loss (1 -> 0): 0.02676409104551567\n",
      "Validation loss (1 -> 2): 0.026080262961258996\n",
      "Validation loss (2 -> 0): 0.02780527816310496\n",
      "Validation loss (2 -> 1): 0.027922455316656852\n",
      "==================================================\n",
      "Epoch 491\n",
      "Training loss: 0.01719704084098339\n",
      "Validation loss (0 -> 1): 0.024832888853961777\n",
      "Validation loss (0 -> 2): 0.024219120701527572\n",
      "Validation loss (1 -> 0): 0.02619572465606325\n",
      "Validation loss (1 -> 2): 0.02582999115191342\n",
      "Validation loss (2 -> 0): 0.030005298894211593\n",
      "Validation loss (2 -> 1): 0.030229046915155777\n",
      "==================================================\n",
      "Epoch 500\n",
      "Training loss: 0.017566710710525513\n",
      "Validation loss (0 -> 1): 0.02686552975741506\n",
      "Validation loss (0 -> 2): 0.02637698449601885\n",
      "Validation loss (1 -> 0): 0.02549048599696107\n",
      "Validation loss (1 -> 2): 0.024995246831203986\n",
      "Validation loss (2 -> 0): 0.028926648034794198\n",
      "Validation loss (2 -> 1): 0.029232239636094164\n",
      "==================================================\n"
     ]
    }
   ],
   "source": [
    "NUM_RUNS = 3\n",
    "\n",
    "HIDDEN_SIZE = 32\n",
    "NUM_LAYERS = 1\n",
    "VOCAB_SIZE = 9\n",
    "MAX_LEN = 5\n",
    "\n",
    "runs_epoch_losses = []\n",
    "runs_agents_val_lossEnfToEnd = []\n",
    "runs_val_results = []\n",
    "\n",
    "for i in range(NUM_RUNS): \n",
    "    agents_dict = {\n",
    "        0: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "        1: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "        2: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN)\n",
    "    }\n",
    "    epoch_losses, agents_val_lossEnfToEnd, val_results = simulate_with_competitiveness(\n",
    "        agents_dict, \n",
    "        train_dataset,\n",
    "        val_dataset,\n",
    "        epochs=500, \n",
    "        batch_size=16, \n",
    "        verbose=True, \n",
    "        evalEpochs=10,\n",
    "        competitive_level=0.0\n",
    "    )\n",
    "    runs_epoch_losses.append(epoch_losses)\n",
    "    runs_agents_val_lossEnfToEnd.append(agents_val_lossEnfToEnd)\n",
    "    runs_val_results.append(val_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# AGGREGRATE RESULTS FROM MULTIPLE RUNS\n",
    "\n",
    "agg_val_results = {}\n",
    "std_val_results = {}\n",
    "\n",
    "for key in runs_val_results[0].keys():\n",
    "    agg_val_results[key] = np.mean([np.nan_to_num(run[key]) for run in runs_val_results], axis=0)\n",
    "    std_val_results[key] = np.std([np.nan_to_num(run[key]) for run in runs_val_results], axis=0)\n",
    "\n",
    "agg_epoch_losses = np.array(runs_epoch_losses).mean(axis=0)\n",
    "std_epoch_losses = np.array(runs_epoch_losses).std(axis=0)\n",
    "\n",
    "agg_agents_val_lossEnfToEnd = {combo : [] for combo in permutations(agents_dict.keys(), 2)}\n",
    "std_agents_val_lossEnfToEnd = {combo : [] for combo in permutations(agents_dict.keys(), 2)}\n",
    "\n",
    "for val_loss in runs_agents_val_lossEnfToEnd:\n",
    "    for key, val in val_loss.items():\n",
    "        agg_agents_val_lossEnfToEnd[key].append(val)\n",
    "\n",
    "for key in agg_agents_val_lossEnfToEnd:\n",
    "    std_agents_val_lossEnfToEnd[key] = np.std(agg_agents_val_lossEnfToEnd[key], axis=0)\n",
    "    agg_agents_val_lossEnfToEnd[key] = np.mean(agg_agents_val_lossEnfToEnd[key], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "LOADING: Uncomment below and load previous results from file if needed\n",
    "\"\"\"\n",
    "pass\n",
    "\n",
    "# NUM_RUNS = 3\n",
    "\n",
    "# HIDDEN_SIZE = 32\n",
    "# NUM_LAYERS = 1\n",
    "# VOCAB_SIZE = 9\n",
    "# MAX_LEN = 5\n",
    "\n",
    "# EXPT_NAME = \"exp8.1\"\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/agg_epoch_losses.pkl\", \"rb\") as f:\n",
    "#     agg_epoch_losses = pickle.load(f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/std_epoch_losses.pkl\", \"rb\") as f:\n",
    "#     std_epoch_losses = pickle.load(f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/agg_agents_val_lossEnfToEnd.pkl\", \"rb\") as f:\n",
    "#     agg_agents_val_lossEnfToEnd = pickle.load(f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/std_agents_val_lossEnfToEnd.pkl\", \"rb\") as f:\n",
    "#     std_agents_val_lossEnfToEnd = pickle.load(f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/agg_val_results.pkl\", \"rb\") as f:\n",
    "#     agg_val_results = pickle.load(f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/std_val_results.pkl\", \"rb\") as f:\n",
    "#     std_val_results = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PolyCollection at 0x317c2ec00>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epoch_gap = 10\n",
    "epochs = 500 + epoch_gap\n",
    "epoch_line_period = 100\n",
    "\n",
    "f, ax = plt.subplots(1, 1, figsize=(5, 5))\n",
    "\n",
    "# training loss\n",
    "ax.set_title(\"Training Loss\")\n",
    "ax.plot(agg_epoch_losses)\n",
    "ax.fill_between(np.arange(0, epochs-epoch_gap, 1),\n",
    "                        agg_epoch_losses - std_epoch_losses, \n",
    "                        agg_epoch_losses + std_epoch_losses, \n",
    "                        alpha=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x1200 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, ax = plt.subplots(3, 2, figsize=(8, 12))\n",
    "\n",
    "ax[0, 0].set_title(\"Synchronisation\")\n",
    "ax[0, 0].plot(np.arange(0, epochs, epoch_gap), 1-agg_val_results[\"edit_distance_mean\"], label=\"Edit Distance\", color = \"black\")\n",
    "ax[0, 0].fill_between(np.arange(0, epochs, epoch_gap),\n",
    "                        1-agg_val_results[\"edit_distance_mean\"] - std_val_results[\"edit_distance_mean\"], \n",
    "                        1-agg_val_results[\"edit_distance_mean\"] + std_val_results[\"edit_distance_mean\"], \n",
    "                        alpha=0.2, color = \"black\")\n",
    "ax[0, 0].set_ylim(0,1)\n",
    "\n",
    "# validation loss\n",
    "for i, (k, v) in enumerate(agg_agents_val_lossEnfToEnd.items()):\n",
    "    ax[0, 1].plot(np.arange(0, epochs, epoch_gap), v, label=f\"{k[0]} -> {k[1]}\")\n",
    "ax[0, 1].legend()\n",
    "ax[0, 1].set_title(\"Validation Loss\")\n",
    "\n",
    "ax[1, 0].set_title(\"Self Play Loss\")\n",
    "ax[1, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"self_intelligibility_mean\"], label=\"Self Play Loss\", color = \"red\")\n",
    "ax[1, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"self_intelligibility_mean\"] - std_val_results[\"self_intelligibility_mean\"], \n",
    "                      agg_val_results[\"self_intelligibility_mean\"] + std_val_results[\"self_intelligibility_mean\"], \n",
    "                      alpha=0.2, color = \"red\")\n",
    "\n",
    "ax[1, 1].set_title(\"Token Relationship Alignment\")\n",
    "ax[1, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"ss_correlations_mean\"], label=\"Sender-Sender\", color = 'green')\n",
    "ax[1, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"rr_correlations_mean\"], label=\"Receiver-Receiver\", color = 'blue')\n",
    "ax[1, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"sr_correlations_mean\"], label=\"Sender-Receiver\", color = 'red')\n",
    "ax[1, 1].legend()\n",
    "ax[1, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"ss_correlations_mean\"] - std_val_results[\"ss_correlations_mean\"], \n",
    "                      agg_val_results[\"ss_correlations_mean\"] + std_val_results[\"ss_correlations_mean\"], \n",
    "                      alpha=0.2, color = 'green')\n",
    "ax[1, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"rr_correlations_mean\"] - std_val_results[\"rr_correlations_mean\"], \n",
    "                      agg_val_results[\"rr_correlations_mean\"] + std_val_results[\"rr_correlations_mean\"], \n",
    "                      alpha=0.2, color = 'blue')\n",
    "ax[1, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"sr_correlations_mean\"] - std_val_results[\"sr_correlations_mean\"], \n",
    "                      agg_val_results[\"sr_correlations_mean\"] + std_val_results[\"sr_correlations_mean\"], \n",
    "                      alpha=0.2, color = 'red')\n",
    "ax[1, 1].set_ylim(0, 1)\n",
    "\n",
    "ax[2, 0].set_title(\"N-gram Overlap\")\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"1-gram_mean\"], label=\"1-gram\", color = 'orange')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                        agg_val_results[\"1-gram_mean\"] - std_val_results[\"1-gram_mean\"], \n",
    "                        agg_val_results[\"1-gram_mean\"] + std_val_results[\"1-gram_mean\"], \n",
    "                        alpha=0.2, color = 'orange')\n",
    "\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"2-gram_mean\"], label=\"2-gram\", color = 'purple')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"2-gram_mean\"] - std_val_results[\"2-gram_mean\"], \n",
    "                      agg_val_results[\"2-gram_mean\"] + std_val_results[\"2-gram_mean\"], \n",
    "                      alpha=0.2, color = 'purple')\n",
    "\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"3-gram_mean\"], label=\"3-gram\", color = 'blue')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"3-gram_mean\"] - std_val_results[\"3-gram_mean\"], \n",
    "                      agg_val_results[\"3-gram_mean\"] + std_val_results[\"3-gram_mean\"], \n",
    "                      alpha=0.2, color = 'blue')\n",
    "\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"4-gram_mean\"], label=\"4-gram\", color = 'black')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"4-gram_mean\"] - std_val_results[\"4-gram_mean\"], \n",
    "                      agg_val_results[\"4-gram_mean\"] + std_val_results[\"4-gram_mean\"], \n",
    "                      alpha=0.2, color = 'black')\n",
    "ax[2, 0].set_ylim(0, 1)\n",
    "ax[2, 0].legend()\n",
    "\n",
    "ax[2, 1].set_title(\"Compositionality\")\n",
    "ax[2, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"topological_similarity_mean\"], label=\"Topological Similarity\", color = \"purple\")\n",
    "ax[2, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"topological_similarity_mean\"] - std_val_results[\"topological_similarity_mean\"], \n",
    "                      agg_val_results[\"topological_similarity_mean\"] + std_val_results[\"topological_similarity_mean\"], \n",
    "                      alpha=0.2, color = \"purple\")\n",
    "ax[2, 1].set_ylim(0, 1)\n",
    "\n",
    "\n",
    "for i in range(0, epochs, epoch_line_period):\n",
    "    for j in range(3):\n",
    "        ax[j, 0].axvline(x=i, color='gray', linestyle='--', alpha=0.5)\n",
    "        ax[j, 1].axvline(x=i, color='gray', linestyle='--', alpha=0.5)\n",
    "\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "SAVING: Uncomment below and save current model and results to file if needed\n",
    "\"\"\"\n",
    "pass\n",
    "\n",
    "# EXPT_NAME = \"exp8.1\"\n",
    "\n",
    "# os.makedirs(f\"./ModelFiles/{EXPT_NAME}\", exist_ok=True)\n",
    "\n",
    "# for agent in agents_dict:\n",
    "#     torch.save(agents_dict[agent].sender.state_dict(), f\"./ModelFiles/{EXPT_NAME}/sender_{agent}.pth\")\n",
    "#     torch.save(agents_dict[agent].receiver.state_dict(), f\"./ModelFiles/{EXPT_NAME}/receiver_{agent}.pth\")\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/agg_epoch_losses.pkl\", \"wb\") as f:\n",
    "#     pickle.dump(agg_epoch_losses, f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/std_epoch_losses.pkl\", \"wb\") as f:\n",
    "#     pickle.dump(std_epoch_losses, f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/agg_val_results.pkl\", \"wb\") as f:\n",
    "#     pickle.dump(agg_val_results, f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/std_val_results.pkl\", \"wb\") as f:\n",
    "#     pickle.dump(std_val_results, f)\n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/agg_agents_val_lossEnfToEnd.pkl\", \"wb\") as f:\n",
    "#     pickle.dump(agg_agents_val_lossEnfToEnd, f)    \n",
    "\n",
    "# with open(f\"./ModelFiles/{EXPT_NAME}/std_agents_val_lossEnfToEnd.pkl\", \"wb\") as f:\n",
    "#     pickle.dump(std_agents_val_lossEnfToEnd, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "LOADING: Uncomment below and load previous model if needed\n",
    "\"\"\"\n",
    "pass\n",
    "\n",
    "EXPT_NAME = \"exp8.1\"\n",
    "\n",
    "agents_dict = {\n",
    "        0: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "        1: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "        2: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN)\n",
    "    }\n",
    "\n",
    "for agent in agents_dict:\n",
    "    # load\n",
    "    agents_dict[agent].sender.load_state_dict(torch.load(f\"./ModelFiles/{EXPT_NAME}/sender_{agent}.pth\"))\n",
    "    agents_dict[agent].receiver.load_state_dict(torch.load(f\"./ModelFiles/{EXPT_NAME}/receiver_{agent}.pth\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent0 [0.43 0.28 0.16 0.01 0.12] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.43 0.28 0.16 0.01 0.12] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.43 0.28 0.16 0.01 0.12] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.43 0.28 0.16 0.01 0.12] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.43 0.28 0.16 0.01 0.12] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.43 0.28 0.16 0.01 0.12] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.04 0.13 0.03 0.07 0.73] -> gggh -> Agent1 [0.06 0.14 0.06 0.06 0.69]\n",
      "Agent0 [0.04 0.13 0.03 0.07 0.73] -> gggh -> Agent2 [0.06 0.11 0.06 0.06 0.71]\n",
      "Agent1 [0.04 0.13 0.03 0.07 0.73] -> gggg -> Agent0 [0.05 0.11 0.05 0.04 0.75]\n",
      "Agent1 [0.04 0.13 0.03 0.07 0.73] -> gggg -> Agent2 [0.04 0.08 0.05 0.04 0.78]\n",
      "Agent2 [0.04 0.13 0.03 0.07 0.73] -> gggg -> Agent0 [0.05 0.11 0.05 0.04 0.75]\n",
      "Agent2 [0.04 0.13 0.03 0.07 0.73] -> gggg -> Agent1 [0.05 0.11 0.05 0.05 0.75]\n",
      "\n",
      "Agent0 [0.28 0.1  0.2  0.23 0.19] -> eeed -> Agent1 [0.36 0.12 0.11 0.28 0.14]\n",
      "Agent0 [0.28 0.1  0.2  0.23 0.19] -> eeed -> Agent2 [0.34 0.13 0.1  0.29 0.14]\n",
      "Agent1 [0.28 0.1  0.2  0.23 0.19] -> eeed -> Agent0 [0.34 0.14 0.1  0.29 0.13]\n",
      "Agent1 [0.28 0.1  0.2  0.23 0.19] -> eeed -> Agent2 [0.34 0.13 0.1  0.29 0.14]\n",
      "Agent2 [0.28 0.1  0.2  0.23 0.19] -> eeef -> Agent0 [0.25 0.19 0.17 0.21 0.18]\n",
      "Agent2 [0.28 0.1  0.2  0.23 0.19] -> eeef -> Agent1 [0.26 0.17 0.17 0.21 0.19]\n",
      "\n",
      "Agent0 [0.21 0.5  0.08 0.06 0.15] -> ece -> Agent1 [0.23 0.5  0.07 0.09 0.11]\n",
      "Agent0 [0.21 0.5  0.08 0.06 0.15] -> ece -> Agent2 [0.23 0.51 0.07 0.09 0.1 ]\n",
      "Agent1 [0.21 0.5  0.08 0.06 0.15] -> ece -> Agent0 [0.24 0.52 0.07 0.08 0.1 ]\n",
      "Agent1 [0.21 0.5  0.08 0.06 0.15] -> ece -> Agent2 [0.23 0.51 0.07 0.09 0.1 ]\n",
      "Agent2 [0.21 0.5  0.08 0.06 0.15] -> ece -> Agent0 [0.24 0.52 0.07 0.08 0.1 ]\n",
      "Agent2 [0.21 0.5  0.08 0.06 0.15] -> ece -> Agent1 [0.23 0.5  0.07 0.09 0.11]\n",
      "\n",
      "Agent0 [0.03 0.2  0.15 0.37 0.25] -> dfge -> Agent1 [0.06 0.21 0.13 0.37 0.23]\n",
      "Agent0 [0.03 0.2  0.15 0.37 0.25] -> dfge -> Agent2 [0.05 0.21 0.13 0.37 0.24]\n",
      "Agent1 [0.03 0.2  0.15 0.37 0.25] -> dfhc -> Agent0 [0.05 0.18 0.15 0.37 0.24]\n",
      "Agent1 [0.03 0.2  0.15 0.37 0.25] -> dfhc -> Agent2 [0.05 0.18 0.14 0.38 0.25]\n",
      "Agent2 [0.03 0.2  0.15 0.37 0.25] -> ffgh -> Agent0 [0.06 0.18 0.11 0.39 0.27]\n",
      "Agent2 [0.03 0.2  0.15 0.37 0.25] -> ffgh -> Agent1 [0.06 0.18 0.1  0.38 0.28]\n",
      "\n",
      "Agent0 [0.33 0.17 0.34 0.07 0.09] -> eeea -> Agent1 [0.33 0.13 0.31 0.11 0.13]\n",
      "Agent0 [0.33 0.17 0.34 0.07 0.09] -> eeea -> Agent2 [0.33 0.14 0.3  0.11 0.13]\n",
      "Agent1 [0.33 0.17 0.34 0.07 0.09] -> eeea -> Agent0 [0.32 0.14 0.3  0.11 0.13]\n",
      "Agent1 [0.33 0.17 0.34 0.07 0.09] -> eeea -> Agent2 [0.33 0.14 0.3  0.11 0.13]\n",
      "Agent2 [0.33 0.17 0.34 0.07 0.09] -> eeea -> Agent0 [0.32 0.14 0.3  0.11 0.13]\n",
      "Agent2 [0.33 0.17 0.34 0.07 0.09] -> eeea -> Agent1 [0.33 0.13 0.31 0.11 0.13]\n",
      "\n",
      "Agent0 [0.17 0.51 0.05 0.09 0.17] -> ec -> Agent1 [0.21 0.53 0.07 0.08 0.1 ]\n",
      "Agent0 [0.17 0.51 0.05 0.09 0.17] -> ec -> Agent2 [0.2  0.55 0.07 0.09 0.1 ]\n",
      "Agent1 [0.17 0.51 0.05 0.09 0.17] -> ec -> Agent0 [0.2  0.56 0.06 0.08 0.09]\n",
      "Agent1 [0.17 0.51 0.05 0.09 0.17] -> ec -> Agent2 [0.2  0.55 0.07 0.09 0.1 ]\n",
      "Agent2 [0.17 0.51 0.05 0.09 0.17] -> ec -> Agent0 [0.2  0.56 0.06 0.08 0.09]\n",
      "Agent2 [0.17 0.51 0.05 0.09 0.17] -> ec -> Agent1 [0.21 0.53 0.07 0.08 0.1 ]\n",
      "\n",
      "Agent0 [0.59 0.15 0.07 0.14 0.05] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.59 0.15 0.07 0.14 0.05] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.59 0.15 0.07 0.14 0.05] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.59 0.15 0.07 0.14 0.05] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.59 0.15 0.07 0.14 0.05] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.59 0.15 0.07 0.14 0.05] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.05 0.65 0.1  0.13 0.07] -> cbcc -> Agent1 [0.06 0.67 0.11 0.1  0.06]\n",
      "Agent0 [0.05 0.65 0.1  0.13 0.07] -> cbcc -> Agent2 [0.06 0.67 0.12 0.1  0.05]\n",
      "Agent1 [0.05 0.65 0.1  0.13 0.07] -> cbc -> Agent0 [0.06 0.71 0.07 0.11 0.06]\n",
      "Agent1 [0.05 0.65 0.1  0.13 0.07] -> cbc -> Agent2 [0.07 0.7  0.06 0.11 0.06]\n",
      "Agent2 [0.05 0.65 0.1  0.13 0.07] -> cbcb -> Agent0 [0.04 0.68 0.1  0.13 0.05]\n",
      "Agent2 [0.05 0.65 0.1  0.13 0.07] -> cbcb -> Agent1 [0.05 0.65 0.09 0.15 0.06]\n",
      "\n",
      "Agent0 [0.82 0.03 0.06 0.04 0.05] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.82 0.03 0.06 0.04 0.05] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.82 0.03 0.06 0.04 0.05] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.82 0.03 0.06 0.04 0.05] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.82 0.03 0.06 0.04 0.05] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.82 0.03 0.06 0.04 0.05] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.15 0.24 0.09 0.46 0.06] -> ddeb -> Agent1 [0.14 0.22 0.11 0.48 0.06]\n",
      "Agent0 [0.15 0.24 0.09 0.46 0.06] -> ddeb -> Agent2 [0.14 0.22 0.1  0.47 0.06]\n",
      "Agent1 [0.15 0.24 0.09 0.46 0.06] -> ddeb -> Agent0 [0.14 0.23 0.1  0.46 0.07]\n",
      "Agent1 [0.15 0.24 0.09 0.46 0.06] -> ddeb -> Agent2 [0.14 0.22 0.1  0.47 0.06]\n",
      "Agent2 [0.15 0.24 0.09 0.46 0.06] -> fffc -> Agent0 [0.1  0.28 0.13 0.43 0.07]\n",
      "Agent2 [0.15 0.24 0.09 0.46 0.06] -> fffc -> Agent1 [0.09 0.26 0.13 0.44 0.07]\n",
      "\n",
      "Agent0 [0.1  0.05 0.22 0.2  0.42] -> heha -> Agent1 [0.11 0.08 0.22 0.11 0.47]\n",
      "Agent0 [0.1  0.05 0.22 0.2  0.42] -> heha -> Agent2 [0.11 0.08 0.22 0.11 0.48]\n",
      "Agent1 [0.1  0.05 0.22 0.2  0.42] -> heha -> Agent0 [0.12 0.07 0.22 0.12 0.46]\n",
      "Agent1 [0.1  0.05 0.22 0.2  0.42] -> heha -> Agent2 [0.11 0.08 0.22 0.11 0.48]\n",
      "Agent2 [0.1  0.05 0.22 0.2  0.42] -> heha -> Agent0 [0.12 0.07 0.22 0.12 0.46]\n",
      "Agent2 [0.1  0.05 0.22 0.2  0.42] -> heha -> Agent1 [0.11 0.08 0.22 0.11 0.47]\n",
      "\n",
      "Agent0 [0.06 0.4  0.02 0.25 0.27] -> bhd -> Agent1 [0.05 0.41 0.04 0.25 0.24]\n",
      "Agent0 [0.06 0.4  0.02 0.25 0.27] -> bhd -> Agent2 [0.04 0.42 0.03 0.24 0.26]\n",
      "Agent1 [0.06 0.4  0.02 0.25 0.27] -> ebgd -> Agent0 [0.07 0.42 0.08 0.21 0.23]\n",
      "Agent1 [0.06 0.4  0.02 0.25 0.27] -> ebgd -> Agent2 [0.06 0.42 0.07 0.21 0.23]\n",
      "Agent2 [0.06 0.4  0.02 0.25 0.27] -> fgg -> Agent0 [0.04 0.41 0.05 0.2  0.29]\n",
      "Agent2 [0.06 0.4  0.02 0.25 0.27] -> fgg -> Agent1 [0.03 0.39 0.05 0.21 0.31]\n",
      "\n",
      "Agent0 [0.15 0.59 0.11 0.09 0.05] -> cec -> Agent1 [0.18 0.59 0.07 0.07 0.09]\n",
      "Agent0 [0.15 0.59 0.11 0.09 0.05] -> cec -> Agent2 [0.17 0.6  0.07 0.07 0.09]\n",
      "Agent1 [0.15 0.59 0.11 0.09 0.05] -> cce -> Agent0 [0.16 0.64 0.06 0.07 0.08]\n",
      "Agent1 [0.15 0.59 0.11 0.09 0.05] -> cce -> Agent2 [0.14 0.65 0.06 0.06 0.08]\n",
      "Agent2 [0.15 0.59 0.11 0.09 0.05] -> ccec -> Agent0 [0.14 0.63 0.13 0.05 0.06]\n",
      "Agent2 [0.15 0.59 0.11 0.09 0.05] -> ccec -> Agent1 [0.14 0.61 0.13 0.05 0.07]\n",
      "\n",
      "Agent0 [0.05 0.48 0.11 0.22 0.14] -> bebh -> Agent1 [0.08 0.45 0.08 0.22 0.17]\n",
      "Agent0 [0.05 0.48 0.11 0.22 0.14] -> bebh -> Agent2 [0.06 0.48 0.09 0.22 0.15]\n",
      "Agent1 [0.05 0.48 0.11 0.22 0.14] -> befg -> Agent0 [0.06 0.44 0.11 0.23 0.17]\n",
      "Agent1 [0.05 0.48 0.11 0.22 0.14] -> befg -> Agent2 [0.05 0.43 0.11 0.23 0.18]\n",
      "Agent2 [0.05 0.48 0.11 0.22 0.14] -> fccg -> Agent0 [0.05 0.47 0.14 0.18 0.16]\n",
      "Agent2 [0.05 0.48 0.11 0.22 0.14] -> fccg -> Agent1 [0.05 0.45 0.13 0.19 0.17]\n",
      "\n",
      "Agent0 [0.35 0.4  0.12 0.02 0.11] -> eeec -> Agent1 [0.34 0.34 0.15 0.08 0.1 ]\n",
      "Agent0 [0.35 0.4  0.12 0.02 0.11] -> eeec -> Agent2 [0.32 0.36 0.14 0.08 0.1 ]\n",
      "Agent1 [0.35 0.4  0.12 0.02 0.11] -> eeec -> Agent0 [0.33 0.37 0.14 0.07 0.09]\n",
      "Agent1 [0.35 0.4  0.12 0.02 0.11] -> eeec -> Agent2 [0.32 0.36 0.14 0.08 0.1 ]\n",
      "Agent2 [0.35 0.4  0.12 0.02 0.11] -> eeec -> Agent0 [0.33 0.37 0.14 0.07 0.09]\n",
      "Agent2 [0.35 0.4  0.12 0.02 0.11] -> eeec -> Agent1 [0.34 0.34 0.15 0.08 0.1 ]\n",
      "\n",
      "Agent0 [0.24 0.17 0.06 0.13 0.4 ] -> eehh -> Agent1 [0.25 0.09 0.09 0.13 0.45]\n",
      "Agent0 [0.24 0.17 0.06 0.13 0.4 ] -> eehh -> Agent2 [0.26 0.09 0.09 0.11 0.45]\n",
      "Agent1 [0.24 0.17 0.06 0.13 0.4 ] -> eehh -> Agent0 [0.25 0.1  0.09 0.12 0.44]\n",
      "Agent1 [0.24 0.17 0.06 0.13 0.4 ] -> eehh -> Agent2 [0.26 0.09 0.09 0.11 0.45]\n",
      "Agent2 [0.24 0.17 0.06 0.13 0.4 ] -> eehh -> Agent0 [0.25 0.1  0.09 0.12 0.44]\n",
      "Agent2 [0.24 0.17 0.06 0.13 0.4 ] -> eehh -> Agent1 [0.25 0.09 0.09 0.13 0.45]\n",
      "\n",
      "Agent0 [0.2  0.36 0.12 0.24 0.07] -> eebd -> Agent1 [0.2  0.32 0.12 0.25 0.12]\n",
      "Agent0 [0.2  0.36 0.12 0.24 0.07] -> eebd -> Agent2 [0.18 0.36 0.09 0.26 0.11]\n",
      "Agent1 [0.2  0.36 0.12 0.24 0.07] -> eebd -> Agent0 [0.18 0.35 0.12 0.25 0.1 ]\n",
      "Agent1 [0.2  0.36 0.12 0.24 0.07] -> eebd -> Agent2 [0.18 0.36 0.09 0.26 0.11]\n",
      "Agent2 [0.2  0.36 0.12 0.24 0.07] -> fece -> Agent0 [0.17 0.34 0.14 0.25 0.09]\n",
      "Agent2 [0.2  0.36 0.12 0.24 0.07] -> fece -> Agent1 [0.17 0.32 0.16 0.25 0.1 ]\n",
      "\n",
      "Agent0 [0.05 0.28 0.03 0.07 0.58] -> ghg -> Agent1 [0.05 0.3  0.03 0.06 0.55]\n",
      "Agent0 [0.05 0.28 0.03 0.07 0.58] -> ghg -> Agent2 [0.06 0.27 0.04 0.07 0.56]\n",
      "Agent1 [0.05 0.28 0.03 0.07 0.58] -> ggge -> Agent0 [0.06 0.26 0.07 0.04 0.56]\n",
      "Agent1 [0.05 0.28 0.03 0.07 0.58] -> ggge -> Agent2 [0.05 0.24 0.07 0.05 0.59]\n",
      "Agent2 [0.05 0.28 0.03 0.07 0.58] -> gggg -> Agent0 [0.05 0.11 0.05 0.04 0.75]\n",
      "Agent2 [0.05 0.28 0.03 0.07 0.58] -> gggg -> Agent1 [0.05 0.11 0.05 0.05 0.75]\n",
      "\n",
      "Agent0 [0.25 0.01 0.25 0.33 0.16] -> eeda -> Agent1 [0.23 0.11 0.22 0.3  0.15]\n",
      "Agent0 [0.25 0.01 0.25 0.33 0.16] -> eeda -> Agent2 [0.22 0.11 0.23 0.3  0.14]\n",
      "Agent1 [0.25 0.01 0.25 0.33 0.16] -> eeda -> Agent0 [0.2  0.12 0.23 0.3  0.14]\n",
      "Agent1 [0.25 0.01 0.25 0.33 0.16] -> eeda -> Agent2 [0.22 0.11 0.23 0.3  0.14]\n",
      "Agent2 [0.25 0.01 0.25 0.33 0.16] -> feea -> Agent0 [0.22 0.12 0.24 0.29 0.13]\n",
      "Agent2 [0.25 0.01 0.25 0.33 0.16] -> feea -> Agent1 [0.21 0.13 0.23 0.3  0.12]\n",
      "\n",
      "Agent0 [0.24 0.22 0.36 0.08 0.1 ] -> eeae -> Agent1 [0.28 0.12 0.38 0.09 0.13]\n",
      "Agent0 [0.24 0.22 0.36 0.08 0.1 ] -> eeae -> Agent2 [0.28 0.13 0.36 0.1  0.13]\n",
      "Agent1 [0.24 0.22 0.36 0.08 0.1 ] -> eeae -> Agent0 [0.29 0.13 0.37 0.09 0.12]\n",
      "Agent1 [0.24 0.22 0.36 0.08 0.1 ] -> eeae -> Agent2 [0.28 0.13 0.36 0.1  0.13]\n",
      "Agent2 [0.24 0.22 0.36 0.08 0.1 ] -> eeae -> Agent0 [0.29 0.13 0.37 0.09 0.12]\n",
      "Agent2 [0.24 0.22 0.36 0.08 0.1 ] -> eeae -> Agent1 [0.28 0.12 0.38 0.09 0.13]\n",
      "\n",
      "Agent0 [0.22 0.15 0.12 0.13 0.37] -> eehe -> Agent1 [0.24 0.1  0.13 0.15 0.38]\n",
      "Agent0 [0.22 0.15 0.12 0.13 0.37] -> eehe -> Agent2 [0.23 0.11 0.14 0.14 0.37]\n",
      "Agent1 [0.22 0.15 0.12 0.13 0.37] -> eehe -> Agent0 [0.24 0.1  0.14 0.14 0.37]\n",
      "Agent1 [0.22 0.15 0.12 0.13 0.37] -> eehe -> Agent2 [0.23 0.11 0.14 0.14 0.37]\n",
      "Agent2 [0.22 0.15 0.12 0.13 0.37] -> eehe -> Agent0 [0.24 0.1  0.14 0.14 0.37]\n",
      "Agent2 [0.22 0.15 0.12 0.13 0.37] -> eehe -> Agent1 [0.24 0.1  0.13 0.15 0.38]\n",
      "\n",
      "Agent0 [0.29 0.22 0.07 0.26 0.16] -> eeed -> Agent1 [0.36 0.12 0.11 0.28 0.14]\n",
      "Agent0 [0.29 0.22 0.07 0.26 0.16] -> eeed -> Agent2 [0.34 0.13 0.1  0.29 0.14]\n",
      "Agent1 [0.29 0.22 0.07 0.26 0.16] -> eeed -> Agent0 [0.34 0.14 0.1  0.29 0.13]\n",
      "Agent1 [0.29 0.22 0.07 0.26 0.16] -> eeed -> Agent2 [0.34 0.13 0.1  0.29 0.14]\n",
      "Agent2 [0.29 0.22 0.07 0.26 0.16] -> eeef -> Agent0 [0.25 0.19 0.17 0.21 0.18]\n",
      "Agent2 [0.29 0.22 0.07 0.26 0.16] -> eeef -> Agent1 [0.26 0.17 0.17 0.21 0.19]\n",
      "\n",
      "Agent0 [0.23 0.29 0.15 0.09 0.24] -> eeeg -> Agent1 [0.24 0.3  0.09 0.1  0.26]\n",
      "Agent0 [0.23 0.29 0.15 0.09 0.24] -> eeeg -> Agent2 [0.23 0.31 0.09 0.1  0.27]\n",
      "Agent1 [0.23 0.29 0.15 0.09 0.24] -> eeeg -> Agent0 [0.23 0.32 0.09 0.09 0.26]\n",
      "Agent1 [0.23 0.29 0.15 0.09 0.24] -> eeeg -> Agent2 [0.23 0.31 0.09 0.1  0.27]\n",
      "Agent2 [0.23 0.29 0.15 0.09 0.24] -> eeeg -> Agent0 [0.23 0.32 0.09 0.09 0.26]\n",
      "Agent2 [0.23 0.29 0.15 0.09 0.24] -> eeeg -> Agent1 [0.24 0.3  0.09 0.1  0.26]\n",
      "\n",
      "Agent0 [0.12 0.15 0.13 0.25 0.35] -> ehdf -> Agent1 [0.11 0.11 0.11 0.27 0.39]\n",
      "Agent0 [0.12 0.15 0.13 0.25 0.35] -> ehdf -> Agent2 [0.11 0.13 0.11 0.28 0.37]\n",
      "Agent1 [0.12 0.15 0.13 0.25 0.35] -> ehed -> Agent0 [0.16 0.11 0.11 0.25 0.37]\n",
      "Agent1 [0.12 0.15 0.13 0.25 0.35] -> ehed -> Agent2 [0.16 0.1  0.12 0.24 0.38]\n",
      "Agent2 [0.12 0.15 0.13 0.25 0.35] -> fheh -> Agent0 [0.13 0.11 0.12 0.3  0.33]\n",
      "Agent2 [0.12 0.15 0.13 0.25 0.35] -> fheh -> Agent1 [0.11 0.11 0.13 0.3  0.35]\n",
      "\n",
      "Agent0 [0.1  0.14 0.1  0.47 0.19] -> ddfe -> Agent1 [0.13 0.13 0.11 0.52 0.11]\n",
      "Agent0 [0.1  0.14 0.1  0.47 0.19] -> ddfe -> Agent2 [0.11 0.14 0.13 0.5  0.12]\n",
      "Agent1 [0.1  0.14 0.1  0.47 0.19] -> ddfh -> Agent0 [0.07 0.08 0.12 0.51 0.22]\n",
      "Agent1 [0.1  0.14 0.1  0.47 0.19] -> ddfh -> Agent2 [0.07 0.09 0.11 0.5  0.23]\n",
      "Agent2 [0.1  0.14 0.1  0.47 0.19] -> fffh -> Agent0 [0.09 0.07 0.09 0.54 0.21]\n",
      "Agent2 [0.1  0.14 0.1  0.47 0.19] -> fffh -> Agent1 [0.08 0.06 0.1  0.55 0.2 ]\n",
      "\n",
      "Agent0 [0.03 0.04 0.1  0.6  0.23] -> dddh -> Agent1 [0.08 0.04 0.08 0.58 0.21]\n",
      "Agent0 [0.03 0.04 0.1  0.6  0.23] -> dddh -> Agent2 [0.08 0.05 0.08 0.57 0.23]\n",
      "Agent1 [0.03 0.04 0.1  0.6  0.23] -> dddh -> Agent0 [0.08 0.05 0.08 0.57 0.21]\n",
      "Agent1 [0.03 0.04 0.1  0.6  0.23] -> dddh -> Agent2 [0.08 0.05 0.08 0.57 0.23]\n",
      "Agent2 [0.03 0.04 0.1  0.6  0.23] -> fffh -> Agent0 [0.09 0.07 0.09 0.54 0.21]\n",
      "Agent2 [0.03 0.04 0.1  0.6  0.23] -> fffh -> Agent1 [0.08 0.06 0.1  0.55 0.2 ]\n",
      "\n",
      "Agent0 [0.21 0.36 0.12 0.02 0.29] -> eecg -> Agent1 [0.19 0.38 0.1  0.07 0.25]\n",
      "Agent0 [0.21 0.36 0.12 0.02 0.29] -> eecg -> Agent2 [0.17 0.41 0.1  0.07 0.25]\n",
      "Agent1 [0.21 0.36 0.12 0.02 0.29] -> eecg -> Agent0 [0.17 0.42 0.1  0.07 0.24]\n",
      "Agent1 [0.21 0.36 0.12 0.02 0.29] -> eecg -> Agent2 [0.17 0.41 0.1  0.07 0.25]\n",
      "Agent2 [0.21 0.36 0.12 0.02 0.29] -> eech -> Agent0 [0.19 0.36 0.12 0.08 0.26]\n",
      "Agent2 [0.21 0.36 0.12 0.02 0.29] -> eech -> Agent1 [0.2  0.33 0.12 0.08 0.27]\n",
      "\n",
      "Agent0 [0.11 0.45 0.08 0.3  0.06] -> bdeb -> Agent1 [0.09 0.41 0.1  0.34 0.06]\n",
      "Agent0 [0.11 0.45 0.08 0.3  0.06] -> bdeb -> Agent2 [0.08 0.43 0.1  0.32 0.06]\n",
      "Agent1 [0.11 0.45 0.08 0.3  0.06] -> ebdb -> Agent0 [0.1  0.45 0.09 0.29 0.07]\n",
      "Agent1 [0.11 0.45 0.08 0.3  0.06] -> ebdb -> Agent2 [0.1  0.42 0.1  0.3  0.08]\n",
      "Agent2 [0.11 0.45 0.08 0.3  0.06] -> fbce -> Agent0 [0.09 0.44 0.11 0.29 0.06]\n",
      "Agent2 [0.11 0.45 0.08 0.3  0.06] -> fbce -> Agent1 [0.09 0.42 0.13 0.29 0.07]\n",
      "\n",
      "Agent0 [0.19 0.36 0.3  0.09 0.06] -> eeca -> Agent1 [0.18 0.34 0.3  0.09 0.1 ]\n",
      "Agent0 [0.19 0.36 0.3  0.09 0.06] -> eeca -> Agent2 [0.18 0.36 0.29 0.07 0.09]\n",
      "Agent1 [0.19 0.36 0.3  0.09 0.06] -> eeca -> Agent0 [0.18 0.36 0.29 0.08 0.09]\n",
      "Agent1 [0.19 0.36 0.3  0.09 0.06] -> eeca -> Agent2 [0.18 0.36 0.29 0.07 0.09]\n",
      "Agent2 [0.19 0.36 0.3  0.09 0.06] -> eeca -> Agent0 [0.18 0.36 0.29 0.08 0.09]\n",
      "Agent2 [0.19 0.36 0.3  0.09 0.06] -> eeca -> Agent1 [0.18 0.34 0.3  0.09 0.1 ]\n",
      "\n",
      "Agent0 [0.08 0.18 0.23 0.42 0.1 ] -> dfae -> Agent1 [0.13 0.13 0.22 0.42 0.1 ]\n",
      "Agent0 [0.08 0.18 0.23 0.42 0.1 ] -> dfae -> Agent2 [0.09 0.14 0.22 0.43 0.12]\n",
      "Agent1 [0.08 0.18 0.23 0.42 0.1 ] -> dafb -> Agent0 [0.07 0.2  0.22 0.43 0.08]\n",
      "Agent1 [0.08 0.18 0.23 0.42 0.1 ] -> dafb -> Agent2 [0.07 0.18 0.23 0.43 0.09]\n",
      "Agent2 [0.08 0.18 0.23 0.42 0.1 ] -> fffa -> Agent0 [0.1  0.1  0.21 0.51 0.08]\n",
      "Agent2 [0.08 0.18 0.23 0.42 0.1 ] -> fffa -> Agent1 [0.1  0.1  0.22 0.5  0.08]\n",
      "\n",
      "Agent0 [0.6  0.01 0.08 0.04 0.27] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.6  0.01 0.08 0.04 0.27] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.6  0.01 0.08 0.04 0.27] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.6  0.01 0.08 0.04 0.27] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.6  0.01 0.08 0.04 0.27] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.6  0.01 0.08 0.04 0.27] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.03 0.28 0.23 0.16 0.3 ] -> egab -> Agent1 [0.04 0.28 0.23 0.16 0.28]\n",
      "Agent0 [0.03 0.28 0.23 0.16 0.3 ] -> egab -> Agent2 [0.04 0.28 0.23 0.16 0.29]\n",
      "Agent1 [0.03 0.28 0.23 0.16 0.3 ] -> efga -> Agent0 [0.05 0.29 0.23 0.2  0.23]\n",
      "Agent1 [0.03 0.28 0.23 0.16 0.3 ] -> efga -> Agent2 [0.05 0.24 0.21 0.22 0.27]\n",
      "Agent2 [0.03 0.28 0.23 0.16 0.3 ] -> egab -> Agent0 [0.04 0.31 0.23 0.14 0.28]\n",
      "Agent2 [0.03 0.28 0.23 0.16 0.3 ] -> egab -> Agent1 [0.04 0.28 0.23 0.16 0.28]\n",
      "\n",
      "Agent0 [0.08 0.2  0.06 0.03 0.64] -> ghgg -> Agent1 [0.06 0.1  0.05 0.06 0.73]\n",
      "Agent0 [0.08 0.2  0.06 0.03 0.64] -> ghgg -> Agent2 [0.06 0.09 0.06 0.06 0.73]\n",
      "Agent1 [0.08 0.2  0.06 0.03 0.64] -> ggge -> Agent0 [0.06 0.26 0.07 0.04 0.56]\n",
      "Agent1 [0.08 0.2  0.06 0.03 0.64] -> ggge -> Agent2 [0.05 0.24 0.07 0.05 0.59]\n",
      "Agent2 [0.08 0.2  0.06 0.03 0.64] -> gggg -> Agent0 [0.05 0.11 0.05 0.04 0.75]\n",
      "Agent2 [0.08 0.2  0.06 0.03 0.64] -> gggg -> Agent1 [0.05 0.11 0.05 0.05 0.75]\n",
      "\n",
      "Agent0 [0.39 0.11 0.02 0.23 0.24] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.39 0.11 0.02 0.23 0.24] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.39 0.11 0.02 0.23 0.24] -> eeeh -> Agent0 [0.3  0.11 0.11 0.15 0.33]\n",
      "Agent1 [0.39 0.11 0.02 0.23 0.24] -> eeeh -> Agent2 [0.31 0.11 0.11 0.14 0.33]\n",
      "Agent2 [0.39 0.11 0.02 0.23 0.24] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.39 0.11 0.02 0.23 0.24] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.69 0.09 0.1  0.04 0.07] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.69 0.09 0.1  0.04 0.07] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.69 0.09 0.1  0.04 0.07] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.69 0.09 0.1  0.04 0.07] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.69 0.09 0.1  0.04 0.07] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.69 0.09 0.1  0.04 0.07] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.19 0.1  0.15 0.28 0.28] -> eedh -> Agent1 [0.23 0.09 0.1  0.3  0.28]\n",
      "Agent0 [0.19 0.1  0.15 0.28 0.28] -> eedh -> Agent2 [0.21 0.1  0.1  0.3  0.28]\n",
      "Agent1 [0.19 0.1  0.15 0.28 0.28] -> eedh -> Agent0 [0.2  0.11 0.11 0.31 0.27]\n",
      "Agent1 [0.19 0.1  0.15 0.28 0.28] -> eedh -> Agent2 [0.21 0.1  0.1  0.3  0.28]\n",
      "Agent2 [0.19 0.1  0.15 0.28 0.28] -> fehe -> Agent0 [0.17 0.12 0.14 0.31 0.26]\n",
      "Agent2 [0.19 0.1  0.15 0.28 0.28] -> fehe -> Agent1 [0.16 0.12 0.14 0.3  0.28]\n",
      "\n",
      "Agent0 [0.05 0.03 0.23 0.57 0.12] -> ddad -> Agent1 [0.1  0.07 0.2  0.55 0.08]\n",
      "Agent0 [0.05 0.03 0.23 0.57 0.12] -> ddad -> Agent2 [0.1  0.06 0.21 0.55 0.08]\n",
      "Agent1 [0.05 0.03 0.23 0.57 0.12] -> ddaa -> Agent0 [0.1  0.07 0.23 0.51 0.09]\n",
      "Agent1 [0.05 0.03 0.23 0.57 0.12] -> ddaa -> Agent2 [0.1  0.06 0.23 0.51 0.1 ]\n",
      "Agent2 [0.05 0.03 0.23 0.57 0.12] -> fffa -> Agent0 [0.1  0.1  0.21 0.51 0.08]\n",
      "Agent2 [0.05 0.03 0.23 0.57 0.12] -> fffa -> Agent1 [0.1  0.1  0.22 0.5  0.08]\n",
      "\n",
      "Agent0 [0.16 0.16 0.45 0.03 0.2 ] -> aeaa -> Agent1 [0.17 0.1  0.47 0.14 0.12]\n",
      "Agent0 [0.16 0.16 0.45 0.03 0.2 ] -> aeaa -> Agent2 [0.17 0.11 0.47 0.13 0.12]\n",
      "Agent1 [0.16 0.16 0.45 0.03 0.2 ] -> aeac -> Agent0 [0.16 0.2  0.43 0.1  0.1 ]\n",
      "Agent1 [0.16 0.16 0.45 0.03 0.2 ] -> aeac -> Agent2 [0.14 0.22 0.44 0.1  0.1 ]\n",
      "Agent2 [0.16 0.16 0.45 0.03 0.2 ] -> aeae -> Agent0 [0.2  0.11 0.44 0.12 0.12]\n",
      "Agent2 [0.16 0.16 0.45 0.03 0.2 ] -> aeae -> Agent1 [0.18 0.12 0.46 0.13 0.12]\n",
      "\n",
      "Agent0 [0.09 0.04 0.18 0.2  0.49] -> hhef -> Agent1 [0.09 0.09 0.16 0.2  0.47]\n",
      "Agent0 [0.09 0.04 0.18 0.2  0.49] -> hhef -> Agent2 [0.08 0.09 0.16 0.19 0.48]\n",
      "Agent1 [0.09 0.04 0.18 0.2  0.49] -> hhea -> Agent0 [0.1  0.07 0.22 0.12 0.48]\n",
      "Agent1 [0.09 0.04 0.18 0.2  0.49] -> hhea -> Agent2 [0.09 0.07 0.22 0.12 0.5 ]\n",
      "Agent2 [0.09 0.04 0.18 0.2  0.49] -> hhha -> Agent0 [0.1  0.04 0.2  0.13 0.52]\n",
      "Agent2 [0.09 0.04 0.18 0.2  0.49] -> hhha -> Agent1 [0.09 0.05 0.2  0.14 0.52]\n",
      "\n",
      "Agent0 [0.14 0.68 0.05 0.03 0.1 ] -> cc -> Agent1 [0.12 0.7  0.06 0.05 0.07]\n",
      "Agent0 [0.14 0.68 0.05 0.03 0.1 ] -> cc -> Agent2 [0.12 0.69 0.06 0.06 0.07]\n",
      "Agent1 [0.14 0.68 0.05 0.03 0.1 ] -> cc -> Agent0 [0.11 0.71 0.05 0.06 0.07]\n",
      "Agent1 [0.14 0.68 0.05 0.03 0.1 ] -> cc -> Agent2 [0.12 0.69 0.06 0.06 0.07]\n",
      "Agent2 [0.14 0.68 0.05 0.03 0.1 ] -> cc -> Agent0 [0.11 0.71 0.05 0.06 0.07]\n",
      "Agent2 [0.14 0.68 0.05 0.03 0.1 ] -> cc -> Agent1 [0.12 0.7  0.06 0.05 0.07]\n",
      "\n",
      "Agent0 [0.32 0.41 0.18 0.05 0.04] -> eeec -> Agent1 [0.34 0.34 0.15 0.08 0.1 ]\n",
      "Agent0 [0.32 0.41 0.18 0.05 0.04] -> eeec -> Agent2 [0.32 0.36 0.14 0.08 0.1 ]\n",
      "Agent1 [0.32 0.41 0.18 0.05 0.04] -> eece -> Agent0 [0.29 0.42 0.14 0.07 0.09]\n",
      "Agent1 [0.32 0.41 0.18 0.05 0.04] -> eece -> Agent2 [0.27 0.42 0.13 0.08 0.09]\n",
      "Agent2 [0.32 0.41 0.18 0.05 0.04] -> eece -> Agent0 [0.29 0.42 0.14 0.07 0.09]\n",
      "Agent2 [0.32 0.41 0.18 0.05 0.04] -> eece -> Agent1 [0.29 0.4  0.14 0.08 0.09]\n",
      "\n",
      "Agent0 [0.13 0.12 0.25 0.33 0.18] -> edae -> Agent1 [0.19 0.11 0.25 0.32 0.12]\n",
      "Agent0 [0.13 0.12 0.25 0.33 0.18] -> edae -> Agent2 [0.18 0.1  0.25 0.34 0.12]\n",
      "Agent1 [0.13 0.12 0.25 0.33 0.18] -> edah -> Agent0 [0.12 0.08 0.24 0.33 0.23]\n",
      "Agent1 [0.13 0.12 0.25 0.33 0.18] -> edah -> Agent2 [0.11 0.08 0.23 0.34 0.24]\n",
      "Agent2 [0.13 0.12 0.25 0.33 0.18] -> feah -> Agent0 [0.13 0.09 0.27 0.29 0.22]\n",
      "Agent2 [0.13 0.12 0.25 0.33 0.18] -> feah -> Agent1 [0.12 0.09 0.28 0.28 0.23]\n",
      "\n",
      "Agent0 [0.01 0.08 0.35 0.02 0.54] -> ghag -> Agent1 [0.03 0.08 0.31 0.05 0.53]\n",
      "Agent0 [0.01 0.08 0.35 0.02 0.54] -> ghag -> Agent2 [0.03 0.08 0.29 0.06 0.55]\n",
      "Agent1 [0.01 0.08 0.35 0.02 0.54] -> ghaa -> Agent0 [0.02 0.07 0.34 0.05 0.52]\n",
      "Agent1 [0.01 0.08 0.35 0.02 0.54] -> ghaa -> Agent2 [0.02 0.07 0.32 0.06 0.52]\n",
      "Agent2 [0.01 0.08 0.35 0.02 0.54] -> hgaa -> Agent0 [0.02 0.07 0.33 0.05 0.53]\n",
      "Agent2 [0.01 0.08 0.35 0.02 0.54] -> hgaa -> Agent1 [0.03 0.07 0.32 0.05 0.53]\n",
      "\n",
      "Agent0 [0.12 0.05 0.25 0.48 0.09] -> ddaa -> Agent1 [0.1  0.06 0.23 0.52 0.09]\n",
      "Agent0 [0.12 0.05 0.25 0.48 0.09] -> ddaa -> Agent2 [0.1  0.06 0.23 0.51 0.1 ]\n",
      "Agent1 [0.12 0.05 0.25 0.48 0.09] -> dade -> Agent0 [0.15 0.07 0.23 0.48 0.08]\n",
      "Agent1 [0.12 0.05 0.25 0.48 0.09] -> dade -> Agent2 [0.15 0.07 0.23 0.47 0.08]\n",
      "Agent2 [0.12 0.05 0.25 0.48 0.09] -> fffa -> Agent0 [0.1  0.1  0.21 0.51 0.08]\n",
      "Agent2 [0.12 0.05 0.25 0.48 0.09] -> fffa -> Agent1 [0.1  0.1  0.22 0.5  0.08]\n",
      "\n",
      "Agent0 [0.63 0.14 0.04 0.07 0.13] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.63 0.14 0.04 0.07 0.13] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.63 0.14 0.04 0.07 0.13] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.63 0.14 0.04 0.07 0.13] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.63 0.14 0.04 0.07 0.13] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.63 0.14 0.04 0.07 0.13] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.15 0.71 0.09 0.04 0.01] -> cc -> Agent1 [0.12 0.7  0.06 0.05 0.07]\n",
      "Agent0 [0.15 0.71 0.09 0.04 0.01] -> cc -> Agent2 [0.12 0.69 0.06 0.06 0.07]\n",
      "Agent1 [0.15 0.71 0.09 0.04 0.01] -> cc -> Agent0 [0.11 0.71 0.05 0.06 0.07]\n",
      "Agent1 [0.15 0.71 0.09 0.04 0.01] -> cc -> Agent2 [0.12 0.69 0.06 0.06 0.07]\n",
      "Agent2 [0.15 0.71 0.09 0.04 0.01] -> ccc -> Agent0 [0.11 0.72 0.06 0.05 0.05]\n",
      "Agent2 [0.15 0.71 0.09 0.04 0.01] -> ccc -> Agent1 [0.12 0.71 0.06 0.05 0.07]\n",
      "\n",
      "Agent0 [0.07 0.2  0.21 0.24 0.29] -> efha -> Agent1 [0.1  0.14 0.24 0.24 0.29]\n",
      "Agent0 [0.07 0.2  0.21 0.24 0.29] -> efha -> Agent2 [0.08 0.15 0.22 0.26 0.29]\n",
      "Agent1 [0.07 0.2  0.21 0.24 0.29] -> efha -> Agent0 [0.09 0.16 0.24 0.24 0.26]\n",
      "Agent1 [0.07 0.2  0.21 0.24 0.29] -> efha -> Agent2 [0.08 0.15 0.22 0.26 0.29]\n",
      "Agent2 [0.07 0.2  0.21 0.24 0.29] -> fhec -> Agent0 [0.08 0.22 0.17 0.26 0.27]\n",
      "Agent2 [0.07 0.2  0.21 0.24 0.29] -> fhec -> Agent1 [0.08 0.21 0.18 0.25 0.28]\n",
      "\n",
      "Agent0 [0.09 0.31 0.14 0.37 0.1 ] -> dbea -> Agent1 [0.09 0.31 0.16 0.37 0.07]\n",
      "Agent0 [0.09 0.31 0.14 0.37 0.1 ] -> dbea -> Agent2 [0.08 0.33 0.16 0.36 0.06]\n",
      "Agent1 [0.09 0.31 0.14 0.37 0.1 ] -> edbf -> Agent0 [0.11 0.34 0.12 0.33 0.1 ]\n",
      "Agent1 [0.09 0.31 0.14 0.37 0.1 ] -> edbf -> Agent2 [0.11 0.31 0.14 0.34 0.11]\n",
      "Agent2 [0.09 0.31 0.14 0.37 0.1 ] -> ffeb -> Agent0 [0.16 0.28 0.12 0.37 0.06]\n",
      "Agent2 [0.09 0.31 0.14 0.37 0.1 ] -> ffeb -> Agent1 [0.15 0.27 0.12 0.4  0.06]\n",
      "\n",
      "Agent0 [0.1  0.07 0.43 0.35 0.05] -> aada -> Agent1 [0.09 0.05 0.44 0.34 0.07]\n",
      "Agent0 [0.1  0.07 0.43 0.35 0.05] -> aada -> Agent2 [0.09 0.06 0.43 0.35 0.07]\n",
      "Agent1 [0.1  0.07 0.43 0.35 0.05] -> aada -> Agent0 [0.09 0.06 0.42 0.37 0.06]\n",
      "Agent1 [0.1  0.07 0.43 0.35 0.05] -> aada -> Agent2 [0.09 0.06 0.43 0.35 0.07]\n",
      "Agent2 [0.1  0.07 0.43 0.35 0.05] -> afaa -> Agent0 [0.08 0.09 0.4  0.35 0.07]\n",
      "Agent2 [0.1  0.07 0.43 0.35 0.05] -> afaa -> Agent1 [0.09 0.07 0.43 0.33 0.08]\n",
      "\n",
      "Agent0 [0.26 0.18 0.19 0.19 0.18] -> eeef -> Agent1 [0.26 0.17 0.17 0.21 0.19]\n",
      "Agent0 [0.26 0.18 0.19 0.19 0.18] -> eeef -> Agent2 [0.23 0.21 0.18 0.2  0.18]\n",
      "Agent1 [0.26 0.18 0.19 0.19 0.18] -> eeef -> Agent0 [0.25 0.19 0.17 0.21 0.18]\n",
      "Agent1 [0.26 0.18 0.19 0.19 0.18] -> eeef -> Agent2 [0.23 0.21 0.18 0.2  0.18]\n",
      "Agent2 [0.26 0.18 0.19 0.19 0.18] -> eeef -> Agent0 [0.25 0.19 0.17 0.21 0.18]\n",
      "Agent2 [0.26 0.18 0.19 0.19 0.18] -> eeef -> Agent1 [0.26 0.17 0.17 0.21 0.19]\n",
      "\n",
      "Agent0 [0.32 0.13 0.45 0.06 0.05] -> eeaa -> Agent1 [0.27 0.1  0.39 0.1  0.13]\n",
      "Agent0 [0.32 0.13 0.45 0.06 0.05] -> eeaa -> Agent2 [0.26 0.11 0.39 0.1  0.14]\n",
      "Agent1 [0.32 0.13 0.45 0.06 0.05] -> eeaa -> Agent0 [0.26 0.12 0.39 0.1  0.14]\n",
      "Agent1 [0.32 0.13 0.45 0.06 0.05] -> eeaa -> Agent2 [0.26 0.11 0.39 0.1  0.14]\n",
      "Agent2 [0.32 0.13 0.45 0.06 0.05] -> eaee -> Agent0 [0.27 0.12 0.4  0.09 0.12]\n",
      "Agent2 [0.32 0.13 0.45 0.06 0.05] -> eaee -> Agent1 [0.26 0.11 0.41 0.09 0.12]\n",
      "\n",
      "Agent0 [0.05 0.31 0.18 0.43 0.04] -> dfbc -> Agent1 [0.06 0.29 0.14 0.43 0.08]\n",
      "Agent0 [0.05 0.31 0.18 0.43 0.04] -> dfbc -> Agent2 [0.07 0.3  0.13 0.43 0.07]\n",
      "Agent1 [0.05 0.31 0.18 0.43 0.04] -> dbad -> Agent0 [0.06 0.33 0.14 0.42 0.05]\n",
      "Agent1 [0.05 0.31 0.18 0.43 0.04] -> dbad -> Agent2 [0.07 0.29 0.17 0.43 0.05]\n",
      "Agent2 [0.05 0.31 0.18 0.43 0.04] -> fffc -> Agent0 [0.1  0.28 0.13 0.43 0.07]\n",
      "Agent2 [0.05 0.31 0.18 0.43 0.04] -> fffc -> Agent1 [0.09 0.26 0.13 0.44 0.07]\n",
      "\n",
      "Agent0 [0.1  0.23 0.12 0.41 0.14] -> dfec -> Agent1 [0.12 0.23 0.15 0.39 0.1 ]\n",
      "Agent0 [0.1  0.23 0.12 0.41 0.14] -> dfec -> Agent2 [0.1  0.24 0.16 0.39 0.12]\n",
      "Agent1 [0.1  0.23 0.12 0.41 0.14] -> defb -> Agent0 [0.11 0.24 0.13 0.4  0.11]\n",
      "Agent1 [0.1  0.23 0.12 0.41 0.14] -> defb -> Agent2 [0.12 0.24 0.13 0.41 0.1 ]\n",
      "Agent2 [0.1  0.23 0.12 0.41 0.14] -> fffg -> Agent0 [0.07 0.19 0.11 0.47 0.17]\n",
      "Agent2 [0.1  0.23 0.12 0.41 0.14] -> fffg -> Agent1 [0.06 0.16 0.11 0.5  0.17]\n",
      "\n",
      "Agent0 [0.04 0.3  0.08 0.56 0.02] -> ddbd -> Agent1 [0.08 0.23 0.08 0.55 0.05]\n",
      "Agent0 [0.04 0.3  0.08 0.56 0.02] -> ddbd -> Agent2 [0.09 0.26 0.06 0.54 0.04]\n",
      "Agent1 [0.04 0.3  0.08 0.56 0.02] -> ddbb -> Agent0 [0.07 0.3  0.08 0.52 0.04]\n",
      "Agent1 [0.04 0.3  0.08 0.56 0.02] -> ddbb -> Agent2 [0.07 0.29 0.08 0.52 0.03]\n",
      "Agent2 [0.04 0.3  0.08 0.56 0.02] -> fffb -> Agent0 [0.08 0.29 0.08 0.51 0.04]\n",
      "Agent2 [0.04 0.3  0.08 0.56 0.02] -> fffb -> Agent1 [0.08 0.27 0.09 0.52 0.04]\n",
      "\n",
      "Agent0 [0.11 0.1  0.05 0.62 0.12] -> dddd -> Agent1 [0.09 0.06 0.07 0.71 0.07]\n",
      "Agent0 [0.11 0.1  0.05 0.62 0.12] -> dddd -> Agent2 [0.09 0.06 0.07 0.71 0.06]\n",
      "Agent1 [0.11 0.1  0.05 0.62 0.12] -> dddd -> Agent0 [0.1  0.07 0.07 0.71 0.06]\n",
      "Agent1 [0.11 0.1  0.05 0.62 0.12] -> dddd -> Agent2 [0.09 0.06 0.07 0.71 0.06]\n",
      "Agent2 [0.11 0.1  0.05 0.62 0.12] -> ffff -> Agent0 [0.1  0.1  0.07 0.67 0.06]\n",
      "Agent2 [0.11 0.1  0.05 0.62 0.12] -> ffff -> Agent1 [0.1  0.09 0.09 0.67 0.06]\n",
      "\n",
      "Agent0 [0.2  0.42 0.13 0.16 0.09] -> eeb -> Agent1 [0.23 0.41 0.07 0.18 0.09]\n",
      "Agent0 [0.2  0.42 0.13 0.16 0.09] -> eeb -> Agent2 [0.21 0.45 0.07 0.19 0.08]\n",
      "Agent1 [0.2  0.42 0.13 0.16 0.09] -> eecb -> Agent0 [0.19 0.42 0.17 0.13 0.08]\n",
      "Agent1 [0.2  0.42 0.13 0.16 0.09] -> eecb -> Agent2 [0.19 0.42 0.16 0.15 0.09]\n",
      "Agent2 [0.2  0.42 0.13 0.16 0.09] -> eebc -> Agent0 [0.18 0.42 0.17 0.16 0.08]\n",
      "Agent2 [0.2  0.42 0.13 0.16 0.09] -> eebc -> Agent1 [0.18 0.38 0.17 0.18 0.09]\n",
      "\n",
      "Agent0 [0.38 0.15 0.11 0.31 0.04] -> eeed -> Agent1 [0.36 0.12 0.11 0.28 0.14]\n",
      "Agent0 [0.38 0.15 0.11 0.31 0.04] -> eeed -> Agent2 [0.34 0.13 0.1  0.29 0.14]\n",
      "Agent1 [0.38 0.15 0.11 0.31 0.04] -> eeed -> Agent0 [0.34 0.14 0.1  0.29 0.13]\n",
      "Agent1 [0.38 0.15 0.11 0.31 0.04] -> eeed -> Agent2 [0.34 0.13 0.1  0.29 0.14]\n",
      "Agent2 [0.38 0.15 0.11 0.31 0.04] -> feee -> Agent0 [0.35 0.13 0.11 0.31 0.11]\n",
      "Agent2 [0.38 0.15 0.11 0.31 0.04] -> feee -> Agent1 [0.34 0.11 0.12 0.33 0.1 ]\n",
      "\n",
      "Agent0 [0.17 0.19 0.22 0.26 0.15] -> eefa -> Agent1 [0.17 0.17 0.26 0.23 0.17]\n",
      "Agent0 [0.17 0.19 0.22 0.26 0.15] -> eefa -> Agent2 [0.15 0.18 0.25 0.24 0.18]\n",
      "Agent1 [0.17 0.19 0.22 0.26 0.15] -> eefa -> Agent0 [0.16 0.19 0.26 0.22 0.16]\n",
      "Agent1 [0.17 0.19 0.22 0.26 0.15] -> eefa -> Agent2 [0.15 0.18 0.25 0.24 0.18]\n",
      "Agent2 [0.17 0.19 0.22 0.26 0.15] -> feea -> Agent0 [0.22 0.12 0.24 0.29 0.13]\n",
      "Agent2 [0.17 0.19 0.22 0.26 0.15] -> feea -> Agent1 [0.21 0.13 0.23 0.3  0.12]\n",
      "\n",
      "Agent0 [0.07 0.52 0.09 0.18 0.14] -> cbde -> Agent1 [0.09 0.52 0.09 0.22 0.08]\n",
      "Agent0 [0.07 0.52 0.09 0.18 0.14] -> cbde -> Agent2 [0.08 0.52 0.09 0.22 0.1 ]\n",
      "Agent1 [0.07 0.52 0.09 0.18 0.14] -> cbeh -> Agent0 [0.07 0.53 0.1  0.14 0.16]\n",
      "Agent1 [0.07 0.52 0.09 0.18 0.14] -> cbeh -> Agent2 [0.07 0.52 0.09 0.14 0.18]\n",
      "Agent2 [0.07 0.52 0.09 0.18 0.14] -> bceh -> Agent0 [0.07 0.53 0.09 0.16 0.15]\n",
      "Agent2 [0.07 0.52 0.09 0.18 0.14] -> bceh -> Agent1 [0.07 0.5  0.1  0.15 0.18]\n",
      "\n",
      "Agent0 [0.1  0.12 0.41 0.22 0.16] -> aeaf -> Agent1 [0.1  0.13 0.39 0.24 0.13]\n",
      "Agent0 [0.1  0.12 0.41 0.22 0.16] -> aeaf -> Agent2 [0.11 0.14 0.39 0.23 0.13]\n",
      "Agent1 [0.1  0.12 0.41 0.22 0.16] -> aeaf -> Agent0 [0.12 0.12 0.39 0.23 0.13]\n",
      "Agent1 [0.1  0.12 0.41 0.22 0.16] -> aeaf -> Agent2 [0.11 0.14 0.39 0.23 0.13]\n",
      "Agent2 [0.1  0.12 0.41 0.22 0.16] -> aaef -> Agent0 [0.11 0.12 0.43 0.24 0.1 ]\n",
      "Agent2 [0.1  0.12 0.41 0.22 0.16] -> aaef -> Agent1 [0.1  0.1  0.44 0.23 0.13]\n",
      "\n",
      "Agent0 [0.06 0.28 0.05 0.19 0.42] -> hbh -> Agent1 [0.07 0.29 0.05 0.21 0.38]\n",
      "Agent0 [0.06 0.28 0.05 0.19 0.42] -> hbh -> Agent2 [0.05 0.29 0.05 0.22 0.38]\n",
      "Agent1 [0.06 0.28 0.05 0.19 0.42] -> hcgd -> Agent0 [0.05 0.31 0.08 0.15 0.4 ]\n",
      "Agent1 [0.06 0.28 0.05 0.19 0.42] -> hcgd -> Agent2 [0.07 0.28 0.07 0.14 0.44]\n",
      "Agent2 [0.06 0.28 0.05 0.19 0.42] -> hfg -> Agent0 [0.04 0.29 0.08 0.21 0.37]\n",
      "Agent2 [0.06 0.28 0.05 0.19 0.42] -> hfg -> Agent1 [0.04 0.28 0.07 0.22 0.38]\n",
      "\n",
      "Agent0 [0.04 0.11 0.47 0.05 0.34] -> aagg -> Agent1 [0.03 0.11 0.47 0.05 0.34]\n",
      "Agent0 [0.04 0.11 0.47 0.05 0.34] -> aagg -> Agent2 [0.04 0.1  0.47 0.06 0.34]\n",
      "Agent1 [0.04 0.11 0.47 0.05 0.34] -> aagg -> Agent0 [0.03 0.13 0.45 0.07 0.33]\n",
      "Agent1 [0.04 0.11 0.47 0.05 0.34] -> aagg -> Agent2 [0.04 0.1  0.47 0.06 0.34]\n",
      "Agent2 [0.04 0.11 0.47 0.05 0.34] -> aagg -> Agent0 [0.03 0.13 0.45 0.07 0.33]\n",
      "Agent2 [0.04 0.11 0.47 0.05 0.34] -> aagg -> Agent1 [0.03 0.11 0.47 0.05 0.34]\n",
      "\n",
      "Agent0 [0.06 0.09 0.17 0.61 0.07] -> ddda -> Agent1 [0.09 0.07 0.16 0.59 0.09]\n",
      "Agent0 [0.06 0.09 0.17 0.61 0.07] -> ddda -> Agent2 [0.09 0.07 0.16 0.59 0.09]\n",
      "Agent1 [0.06 0.09 0.17 0.61 0.07] -> ddda -> Agent0 [0.09 0.08 0.16 0.59 0.08]\n",
      "Agent1 [0.06 0.09 0.17 0.61 0.07] -> ddda -> Agent2 [0.09 0.07 0.16 0.59 0.09]\n",
      "Agent2 [0.06 0.09 0.17 0.61 0.07] -> ffff -> Agent0 [0.1  0.1  0.07 0.67 0.06]\n",
      "Agent2 [0.06 0.09 0.17 0.61 0.07] -> ffff -> Agent1 [0.1  0.09 0.09 0.67 0.06]\n",
      "\n",
      "Agent0 [0.23 0.07 0.43 0.03 0.24] -> eaea -> Agent1 [0.23 0.11 0.43 0.1  0.13]\n",
      "Agent0 [0.23 0.07 0.43 0.03 0.24] -> eaea -> Agent2 [0.23 0.12 0.41 0.1  0.13]\n",
      "Agent1 [0.23 0.07 0.43 0.03 0.24] -> eaea -> Agent0 [0.24 0.12 0.42 0.09 0.13]\n",
      "Agent1 [0.23 0.07 0.43 0.03 0.24] -> eaea -> Agent2 [0.23 0.12 0.41 0.1  0.13]\n",
      "Agent2 [0.23 0.07 0.43 0.03 0.24] -> eaea -> Agent0 [0.24 0.12 0.42 0.09 0.13]\n",
      "Agent2 [0.23 0.07 0.43 0.03 0.24] -> eaea -> Agent1 [0.23 0.11 0.43 0.1  0.13]\n",
      "\n",
      "Agent0 [0.21 0.14 0.15 0.21 0.29] -> eeeh -> Agent1 [0.3  0.11 0.1  0.16 0.33]\n",
      "Agent0 [0.21 0.14 0.15 0.21 0.29] -> eeeh -> Agent2 [0.31 0.11 0.11 0.14 0.33]\n",
      "Agent1 [0.21 0.14 0.15 0.21 0.29] -> eehe -> Agent0 [0.24 0.1  0.14 0.14 0.37]\n",
      "Agent1 [0.21 0.14 0.15 0.21 0.29] -> eehe -> Agent2 [0.23 0.11 0.14 0.14 0.37]\n",
      "Agent2 [0.21 0.14 0.15 0.21 0.29] -> eeeh -> Agent0 [0.3  0.11 0.11 0.15 0.33]\n",
      "Agent2 [0.21 0.14 0.15 0.21 0.29] -> eeeh -> Agent1 [0.3  0.11 0.1  0.16 0.33]\n",
      "\n",
      "Agent0 [0.04 0.11 0.38 0.32 0.14] -> aadf -> Agent1 [0.07 0.07 0.42 0.34 0.09]\n",
      "Agent0 [0.04 0.11 0.38 0.32 0.14] -> aadf -> Agent2 [0.07 0.09 0.4  0.35 0.09]\n",
      "Agent1 [0.04 0.11 0.38 0.32 0.14] -> aadf -> Agent0 [0.08 0.09 0.4  0.35 0.08]\n",
      "Agent1 [0.04 0.11 0.38 0.32 0.14] -> aadf -> Agent2 [0.07 0.09 0.4  0.35 0.09]\n",
      "Agent2 [0.04 0.11 0.38 0.32 0.14] -> afaa -> Agent0 [0.08 0.09 0.4  0.35 0.07]\n",
      "Agent2 [0.04 0.11 0.38 0.32 0.14] -> afaa -> Agent1 [0.09 0.07 0.43 0.33 0.08]\n",
      "\n",
      "Agent0 [0.14 0.31 0.15 0.28 0.12] -> edcc -> Agent1 [0.15 0.33 0.14 0.27 0.1 ]\n",
      "Agent0 [0.14 0.31 0.15 0.28 0.12] -> edcc -> Agent2 [0.14 0.34 0.15 0.26 0.11]\n",
      "Agent1 [0.14 0.31 0.15 0.28 0.12] -> eefb -> Agent0 [0.15 0.3  0.18 0.24 0.15]\n",
      "Agent1 [0.14 0.31 0.15 0.28 0.12] -> eefb -> Agent2 [0.14 0.29 0.17 0.25 0.15]\n",
      "Agent2 [0.14 0.31 0.15 0.28 0.12] -> feeb -> Agent0 [0.2  0.28 0.14 0.28 0.09]\n",
      "Agent2 [0.14 0.31 0.15 0.28 0.12] -> feeb -> Agent1 [0.2  0.26 0.15 0.31 0.08]\n",
      "\n",
      "Agent0 [0.31 0.09 0.11 0.18 0.32] -> eeeh -> Agent1 [0.3  0.11 0.1  0.16 0.33]\n",
      "Agent0 [0.31 0.09 0.11 0.18 0.32] -> eeeh -> Agent2 [0.31 0.11 0.11 0.14 0.33]\n",
      "Agent1 [0.31 0.09 0.11 0.18 0.32] -> eeeh -> Agent0 [0.3  0.11 0.11 0.15 0.33]\n",
      "Agent1 [0.31 0.09 0.11 0.18 0.32] -> eeeh -> Agent2 [0.31 0.11 0.11 0.14 0.33]\n",
      "Agent2 [0.31 0.09 0.11 0.18 0.32] -> eeeh -> Agent0 [0.3  0.11 0.11 0.15 0.33]\n",
      "Agent2 [0.31 0.09 0.11 0.18 0.32] -> eeeh -> Agent1 [0.3  0.11 0.1  0.16 0.33]\n",
      "\n",
      "Agent0 [0.42 0.08 0.24 0.21 0.04] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.42 0.08 0.24 0.21 0.04] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.42 0.08 0.24 0.21 0.04] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.42 0.08 0.24 0.21 0.04] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.42 0.08 0.24 0.21 0.04] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.42 0.08 0.24 0.21 0.04] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.13 0.17 0.11 0.34 0.26] -> edfh -> Agent1 [0.13 0.12 0.13 0.35 0.27]\n",
      "Agent0 [0.13 0.17 0.11 0.34 0.26] -> edfh -> Agent2 [0.11 0.14 0.13 0.37 0.26]\n",
      "Agent1 [0.13 0.17 0.11 0.34 0.26] -> edhe -> Agent0 [0.16 0.1  0.12 0.34 0.28]\n",
      "Agent1 [0.13 0.17 0.11 0.34 0.26] -> edhe -> Agent2 [0.15 0.1  0.13 0.34 0.29]\n",
      "Agent2 [0.13 0.17 0.11 0.34 0.26] -> fehf -> Agent0 [0.13 0.15 0.13 0.32 0.27]\n",
      "Agent2 [0.13 0.17 0.11 0.34 0.26] -> fehf -> Agent1 [0.12 0.13 0.14 0.32 0.29]\n",
      "\n",
      "Agent0 [0.03 0.08 0.05 0.06 0.78] -> gggg -> Agent1 [0.05 0.11 0.05 0.05 0.75]\n",
      "Agent0 [0.03 0.08 0.05 0.06 0.78] -> gggg -> Agent2 [0.04 0.08 0.05 0.04 0.78]\n",
      "Agent1 [0.03 0.08 0.05 0.06 0.78] -> gggg -> Agent0 [0.05 0.11 0.05 0.04 0.75]\n",
      "Agent1 [0.03 0.08 0.05 0.06 0.78] -> gggg -> Agent2 [0.04 0.08 0.05 0.04 0.78]\n",
      "Agent2 [0.03 0.08 0.05 0.06 0.78] -> gggg -> Agent0 [0.05 0.11 0.05 0.04 0.75]\n",
      "Agent2 [0.03 0.08 0.05 0.06 0.78] -> gggg -> Agent1 [0.05 0.11 0.05 0.05 0.75]\n",
      "\n",
      "Agent0 [0.47 0.38 0.07 0.06 0.01] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.47 0.38 0.07 0.06 0.01] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.47 0.38 0.07 0.06 0.01] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.47 0.38 0.07 0.06 0.01] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.47 0.38 0.07 0.06 0.01] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.47 0.38 0.07 0.06 0.01] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.05 0.07 0.68 0.08 0.12] -> aaaa -> Agent1 [0.08 0.06 0.67 0.1  0.09]\n",
      "Agent0 [0.05 0.07 0.68 0.08 0.12] -> aaaa -> Agent2 [0.08 0.05 0.67 0.1  0.1 ]\n",
      "Agent1 [0.05 0.07 0.68 0.08 0.12] -> aaaa -> Agent0 [0.09 0.06 0.66 0.11 0.09]\n",
      "Agent1 [0.05 0.07 0.68 0.08 0.12] -> aaaa -> Agent2 [0.08 0.05 0.67 0.1  0.1 ]\n",
      "Agent2 [0.05 0.07 0.68 0.08 0.12] -> aaaa -> Agent0 [0.09 0.06 0.66 0.11 0.09]\n",
      "Agent2 [0.05 0.07 0.68 0.08 0.12] -> aaaa -> Agent1 [0.08 0.06 0.67 0.1  0.09]\n",
      "\n",
      "Agent0 [0.47 0.3  0.08 0.1  0.04] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.47 0.3  0.08 0.1  0.04] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.47 0.3  0.08 0.1  0.04] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.47 0.3  0.08 0.1  0.04] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.47 0.3  0.08 0.1  0.04] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.47 0.3  0.08 0.1  0.04] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.4  0.17 0.06 0.06 0.31] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.4  0.17 0.06 0.06 0.31] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.4  0.17 0.06 0.06 0.31] -> eeeh -> Agent0 [0.3  0.11 0.11 0.15 0.33]\n",
      "Agent1 [0.4  0.17 0.06 0.06 0.31] -> eeeh -> Agent2 [0.31 0.11 0.11 0.14 0.33]\n",
      "Agent2 [0.4  0.17 0.06 0.06 0.31] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.4  0.17 0.06 0.06 0.31] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.09 0.38 0.1  0.11 0.32] -> egce -> Agent1 [0.09 0.37 0.13 0.08 0.32]\n",
      "Agent0 [0.09 0.38 0.1  0.11 0.32] -> egce -> Agent2 [0.1  0.37 0.13 0.08 0.33]\n",
      "Agent1 [0.09 0.38 0.1  0.11 0.32] -> egce -> Agent0 [0.1  0.4  0.13 0.07 0.3 ]\n",
      "Agent1 [0.09 0.38 0.1  0.11 0.32] -> egce -> Agent2 [0.1  0.37 0.13 0.08 0.33]\n",
      "Agent2 [0.09 0.38 0.1  0.11 0.32] -> egcf -> Agent0 [0.06 0.4  0.13 0.12 0.29]\n",
      "Agent2 [0.09 0.38 0.1  0.11 0.32] -> egcf -> Agent1 [0.06 0.36 0.14 0.13 0.32]\n",
      "\n",
      "Agent0 [0.12 0.11 0.15 0.57 0.05] -> ddda -> Agent1 [0.09 0.07 0.16 0.59 0.09]\n",
      "Agent0 [0.12 0.11 0.15 0.57 0.05] -> ddda -> Agent2 [0.09 0.07 0.16 0.59 0.09]\n",
      "Agent1 [0.12 0.11 0.15 0.57 0.05] -> ddda -> Agent0 [0.09 0.08 0.16 0.59 0.08]\n",
      "Agent1 [0.12 0.11 0.15 0.57 0.05] -> ddda -> Agent2 [0.09 0.07 0.16 0.59 0.09]\n",
      "Agent2 [0.12 0.11 0.15 0.57 0.05] -> ffff -> Agent0 [0.1  0.1  0.07 0.67 0.06]\n",
      "Agent2 [0.12 0.11 0.15 0.57 0.05] -> ffff -> Agent1 [0.1  0.09 0.09 0.67 0.06]\n",
      "\n",
      "Agent0 [0.21 0.34 0.14 0.03 0.27] -> eech -> Agent1 [0.2  0.33 0.12 0.08 0.27]\n",
      "Agent0 [0.21 0.34 0.14 0.03 0.27] -> eech -> Agent2 [0.19 0.35 0.12 0.08 0.26]\n",
      "Agent1 [0.21 0.34 0.14 0.03 0.27] -> eech -> Agent0 [0.19 0.36 0.12 0.08 0.26]\n",
      "Agent1 [0.21 0.34 0.14 0.03 0.27] -> eech -> Agent2 [0.19 0.35 0.12 0.08 0.26]\n",
      "Agent2 [0.21 0.34 0.14 0.03 0.27] -> eeeg -> Agent0 [0.23 0.32 0.09 0.09 0.26]\n",
      "Agent2 [0.21 0.34 0.14 0.03 0.27] -> eeeg -> Agent1 [0.24 0.3  0.09 0.1  0.26]\n",
      "\n",
      "Agent0 [0.28 0.32 0.08 0.05 0.27] -> eeeg -> Agent1 [0.24 0.3  0.09 0.1  0.26]\n",
      "Agent0 [0.28 0.32 0.08 0.05 0.27] -> eeeg -> Agent2 [0.23 0.31 0.09 0.1  0.27]\n",
      "Agent1 [0.28 0.32 0.08 0.05 0.27] -> eeeg -> Agent0 [0.23 0.32 0.09 0.09 0.26]\n",
      "Agent1 [0.28 0.32 0.08 0.05 0.27] -> eeeg -> Agent2 [0.23 0.31 0.09 0.1  0.27]\n",
      "Agent2 [0.28 0.32 0.08 0.05 0.27] -> eeeg -> Agent0 [0.23 0.32 0.09 0.09 0.26]\n",
      "Agent2 [0.28 0.32 0.08 0.05 0.27] -> eeeg -> Agent1 [0.24 0.3  0.09 0.1  0.26]\n",
      "\n",
      "Agent0 [0.2  0.07 0.09 0.13 0.51] -> ehhh -> Agent1 [0.21 0.07 0.08 0.1  0.54]\n",
      "Agent0 [0.2  0.07 0.09 0.13 0.51] -> ehhh -> Agent2 [0.21 0.07 0.08 0.09 0.54]\n",
      "Agent1 [0.2  0.07 0.09 0.13 0.51] -> ehhh -> Agent0 [0.23 0.07 0.08 0.1  0.53]\n",
      "Agent1 [0.2  0.07 0.09 0.13 0.51] -> ehhh -> Agent2 [0.21 0.07 0.08 0.09 0.54]\n",
      "Agent2 [0.2  0.07 0.09 0.13 0.51] -> hehh -> Agent0 [0.19 0.07 0.11 0.1  0.52]\n",
      "Agent2 [0.2  0.07 0.09 0.13 0.51] -> hehh -> Agent1 [0.17 0.08 0.11 0.1  0.54]\n",
      "\n",
      "Agent0 [0.15 0.2  0.17 0.45 0.04] -> ddec -> Agent1 [0.15 0.21 0.11 0.45 0.07]\n",
      "Agent0 [0.15 0.2  0.17 0.45 0.04] -> ddec -> Agent2 [0.14 0.2  0.12 0.44 0.09]\n",
      "Agent1 [0.15 0.2  0.17 0.45 0.04] -> dedb -> Agent0 [0.15 0.23 0.09 0.45 0.07]\n",
      "Agent1 [0.15 0.2  0.17 0.45 0.04] -> dedb -> Agent2 [0.16 0.23 0.1  0.46 0.06]\n",
      "Agent2 [0.15 0.2  0.17 0.45 0.04] -> fffe -> Agent0 [0.21 0.12 0.1  0.49 0.07]\n",
      "Agent2 [0.15 0.2  0.17 0.45 0.04] -> fffe -> Agent1 [0.2  0.12 0.11 0.49 0.08]\n",
      "\n",
      "Agent0 [0.32 0.38 0.1  0.09 0.1 ] -> eeec -> Agent1 [0.34 0.34 0.15 0.08 0.1 ]\n",
      "Agent0 [0.32 0.38 0.1  0.09 0.1 ] -> eeec -> Agent2 [0.32 0.36 0.14 0.08 0.1 ]\n",
      "Agent1 [0.32 0.38 0.1  0.09 0.1 ] -> eeec -> Agent0 [0.33 0.37 0.14 0.07 0.09]\n",
      "Agent1 [0.32 0.38 0.1  0.09 0.1 ] -> eeec -> Agent2 [0.32 0.36 0.14 0.08 0.1 ]\n",
      "Agent2 [0.32 0.38 0.1  0.09 0.1 ] -> eeec -> Agent0 [0.33 0.37 0.14 0.07 0.09]\n",
      "Agent2 [0.32 0.38 0.1  0.09 0.1 ] -> eeec -> Agent1 [0.34 0.34 0.15 0.08 0.1 ]\n",
      "\n",
      "Agent0 [0.32 0.29 0.04 0.09 0.27] -> eeeg -> Agent1 [0.24 0.3  0.09 0.1  0.26]\n",
      "Agent0 [0.32 0.29 0.04 0.09 0.27] -> eeeg -> Agent2 [0.23 0.31 0.09 0.1  0.27]\n",
      "Agent1 [0.32 0.29 0.04 0.09 0.27] -> eeeg -> Agent0 [0.23 0.32 0.09 0.09 0.26]\n",
      "Agent1 [0.32 0.29 0.04 0.09 0.27] -> eeeg -> Agent2 [0.23 0.31 0.09 0.1  0.27]\n",
      "Agent2 [0.32 0.29 0.04 0.09 0.27] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.32 0.29 0.04 0.09 0.27] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.21 0.19 0.33 0.07 0.21] -> eeae -> Agent1 [0.28 0.12 0.38 0.09 0.13]\n",
      "Agent0 [0.21 0.19 0.33 0.07 0.21] -> eeae -> Agent2 [0.28 0.13 0.36 0.1  0.13]\n",
      "Agent1 [0.21 0.19 0.33 0.07 0.21] -> eeae -> Agent0 [0.29 0.13 0.37 0.09 0.12]\n",
      "Agent1 [0.21 0.19 0.33 0.07 0.21] -> eeae -> Agent2 [0.28 0.13 0.36 0.1  0.13]\n",
      "Agent2 [0.21 0.19 0.33 0.07 0.21] -> eeae -> Agent0 [0.29 0.13 0.37 0.09 0.12]\n",
      "Agent2 [0.21 0.19 0.33 0.07 0.21] -> eeae -> Agent1 [0.28 0.12 0.38 0.09 0.13]\n",
      "\n",
      "Agent0 [0.08 0.22 0.18 0.44 0.08] -> dffe -> Agent1 [0.14 0.15 0.12 0.5  0.1 ]\n",
      "Agent0 [0.08 0.22 0.18 0.44 0.08] -> dffe -> Agent2 [0.09 0.18 0.15 0.45 0.13]\n",
      "Agent1 [0.08 0.22 0.18 0.44 0.08] -> dfab -> Agent0 [0.06 0.24 0.19 0.43 0.08]\n",
      "Agent1 [0.08 0.22 0.18 0.44 0.08] -> dfab -> Agent2 [0.06 0.21 0.21 0.44 0.08]\n",
      "Agent2 [0.08 0.22 0.18 0.44 0.08] -> fffa -> Agent0 [0.1  0.1  0.21 0.51 0.08]\n",
      "Agent2 [0.08 0.22 0.18 0.44 0.08] -> fffa -> Agent1 [0.1  0.1  0.22 0.5  0.08]\n",
      "\n",
      "Agent0 [0.09 0.29 0.09 0.45 0.09] -> ddbc -> Agent1 [0.07 0.27 0.11 0.49 0.05]\n",
      "Agent0 [0.09 0.29 0.09 0.45 0.09] -> ddbc -> Agent2 [0.08 0.29 0.11 0.47 0.05]\n",
      "Agent1 [0.09 0.29 0.09 0.45 0.09] -> ddbc -> Agent0 [0.08 0.3  0.1  0.47 0.06]\n",
      "Agent1 [0.09 0.29 0.09 0.45 0.09] -> ddbc -> Agent2 [0.08 0.29 0.11 0.47 0.05]\n",
      "Agent2 [0.09 0.29 0.09 0.45 0.09] -> fffc -> Agent0 [0.1  0.28 0.13 0.43 0.07]\n",
      "Agent2 [0.09 0.29 0.09 0.45 0.09] -> fffc -> Agent1 [0.09 0.26 0.13 0.44 0.07]\n",
      "\n",
      "Agent0 [0.34 0.19 0.08 0.16 0.23] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.34 0.19 0.08 0.16 0.23] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.34 0.19 0.08 0.16 0.23] -> eeeh -> Agent0 [0.3  0.11 0.11 0.15 0.33]\n",
      "Agent1 [0.34 0.19 0.08 0.16 0.23] -> eeeh -> Agent2 [0.31 0.11 0.11 0.14 0.33]\n",
      "Agent2 [0.34 0.19 0.08 0.16 0.23] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.34 0.19 0.08 0.16 0.23] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.44 0.06 0.23 0.07 0.2 ] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.44 0.06 0.23 0.07 0.2 ] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.44 0.06 0.23 0.07 0.2 ] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.44 0.06 0.23 0.07 0.2 ] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.44 0.06 0.23 0.07 0.2 ] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.44 0.06 0.23 0.07 0.2 ] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.42 0.28 0.06 0.03 0.21] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.42 0.28 0.06 0.03 0.21] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.42 0.28 0.06 0.03 0.21] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.42 0.28 0.06 0.03 0.21] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.42 0.28 0.06 0.03 0.21] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.42 0.28 0.06 0.03 0.21] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.12 0.35 0.22 0.13 0.18] -> eecf -> Agent1 [0.15 0.34 0.21 0.14 0.16]\n",
      "Agent0 [0.12 0.35 0.22 0.13 0.18] -> eecf -> Agent2 [0.15 0.37 0.19 0.15 0.14]\n",
      "Agent1 [0.12 0.35 0.22 0.13 0.18] -> eecf -> Agent0 [0.15 0.39 0.18 0.14 0.14]\n",
      "Agent1 [0.12 0.35 0.22 0.13 0.18] -> eecf -> Agent2 [0.15 0.37 0.19 0.15 0.14]\n",
      "Agent2 [0.12 0.35 0.22 0.13 0.18] -> eecf -> Agent0 [0.15 0.39 0.18 0.14 0.14]\n",
      "Agent2 [0.12 0.35 0.22 0.13 0.18] -> eecf -> Agent1 [0.15 0.34 0.21 0.14 0.16]\n",
      "\n",
      "Agent0 [0.23 0.5  0.09 0.06 0.11] -> ece -> Agent1 [0.23 0.5  0.07 0.09 0.11]\n",
      "Agent0 [0.23 0.5  0.09 0.06 0.11] -> ece -> Agent2 [0.23 0.51 0.07 0.09 0.1 ]\n",
      "Agent1 [0.23 0.5  0.09 0.06 0.11] -> ece -> Agent0 [0.24 0.52 0.07 0.08 0.1 ]\n",
      "Agent1 [0.23 0.5  0.09 0.06 0.11] -> ece -> Agent2 [0.23 0.51 0.07 0.09 0.1 ]\n",
      "Agent2 [0.23 0.5  0.09 0.06 0.11] -> ece -> Agent0 [0.24 0.52 0.07 0.08 0.1 ]\n",
      "Agent2 [0.23 0.5  0.09 0.06 0.11] -> ece -> Agent1 [0.23 0.5  0.07 0.09 0.11]\n",
      "\n",
      "Agent0 [0.14 0.05 0.04 0.38 0.39] -> dhhd -> Agent1 [0.08 0.06 0.07 0.41 0.38]\n",
      "Agent0 [0.14 0.05 0.04 0.38 0.39] -> dhhd -> Agent2 [0.08 0.06 0.09 0.39 0.38]\n",
      "Agent1 [0.14 0.05 0.04 0.38 0.39] -> edhh -> Agent0 [0.16 0.09 0.1  0.34 0.32]\n",
      "Agent1 [0.14 0.05 0.04 0.38 0.39] -> edhh -> Agent2 [0.15 0.08 0.09 0.33 0.35]\n",
      "Agent2 [0.14 0.05 0.04 0.38 0.39] -> fhhh -> Agent0 [0.09 0.06 0.09 0.34 0.41]\n",
      "Agent2 [0.14 0.05 0.04 0.38 0.39] -> fhhh -> Agent1 [0.1  0.07 0.09 0.34 0.41]\n",
      "\n",
      "Agent0 [0.07 0.15 0.14 0.17 0.47] -> hheg -> Agent1 [0.11 0.13 0.12 0.1  0.53]\n",
      "Agent0 [0.07 0.15 0.14 0.17 0.47] -> hheg -> Agent2 [0.11 0.13 0.13 0.1  0.53]\n",
      "Agent1 [0.07 0.15 0.14 0.17 0.47] -> hhec -> Agent0 [0.09 0.15 0.19 0.1  0.47]\n",
      "Agent1 [0.07 0.15 0.14 0.17 0.47] -> hhec -> Agent2 [0.09 0.14 0.17 0.11 0.49]\n",
      "Agent2 [0.07 0.15 0.14 0.17 0.47] -> hheb -> Agent0 [0.06 0.16 0.17 0.18 0.43]\n",
      "Agent2 [0.07 0.15 0.14 0.17 0.47] -> hheb -> Agent1 [0.08 0.14 0.16 0.17 0.45]\n",
      "\n",
      "Agent0 [0.07 0.07 0.09 0.36 0.41] -> hddh -> Agent1 [0.08 0.08 0.07 0.36 0.41]\n",
      "Agent0 [0.07 0.07 0.09 0.36 0.41] -> hddh -> Agent2 [0.08 0.06 0.08 0.37 0.41]\n",
      "Agent1 [0.07 0.07 0.09 0.36 0.41] -> hdhd -> Agent0 [0.07 0.07 0.08 0.36 0.43]\n",
      "Agent1 [0.07 0.07 0.09 0.36 0.41] -> hdhd -> Agent2 [0.08 0.06 0.08 0.33 0.45]\n",
      "Agent2 [0.07 0.07 0.09 0.36 0.41] -> fhhf -> Agent0 [0.06 0.1  0.1  0.35 0.38]\n",
      "Agent2 [0.07 0.07 0.09 0.36 0.41] -> fhhf -> Agent1 [0.06 0.08 0.12 0.35 0.38]\n",
      "\n",
      "Agent0 [0.01 0.52 0.22 0.24 0.01] -> bbac -> Agent1 [0.03 0.52 0.19 0.22 0.04]\n",
      "Agent0 [0.01 0.52 0.22 0.24 0.01] -> bbac -> Agent2 [0.03 0.51 0.2  0.23 0.04]\n",
      "Agent1 [0.01 0.52 0.22 0.24 0.01] -> bbaa -> Agent0 [0.03 0.49 0.2  0.25 0.03]\n",
      "Agent1 [0.01 0.52 0.22 0.24 0.01] -> bbaa -> Agent2 [0.03 0.48 0.2  0.25 0.04]\n",
      "Agent2 [0.01 0.52 0.22 0.24 0.01] -> babc -> Agent0 [0.04 0.49 0.2  0.24 0.04]\n",
      "Agent2 [0.01 0.52 0.22 0.24 0.01] -> babc -> Agent1 [0.04 0.47 0.23 0.22 0.04]\n",
      "\n",
      "Agent0 [0.55 0.25 0.07 0.06 0.07] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "Agent0 [0.55 0.25 0.07 0.06 0.07] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent1 [0.55 0.25 0.07 0.06 0.07] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent1 [0.55 0.25 0.07 0.06 0.07] -> eeee -> Agent2 [0.51 0.15 0.11 0.12 0.11]\n",
      "Agent2 [0.55 0.25 0.07 0.06 0.07] -> eeee -> Agent0 [0.5  0.14 0.11 0.12 0.11]\n",
      "Agent2 [0.55 0.25 0.07 0.06 0.07] -> eeee -> Agent1 [0.51 0.13 0.11 0.13 0.12]\n",
      "\n",
      "Agent0 [0.2  0.07 0.13 0.24 0.35] -> eehd -> Agent1 [0.22 0.1  0.08 0.25 0.35]\n",
      "Agent0 [0.2  0.07 0.13 0.24 0.35] -> eehd -> Agent2 [0.2  0.1  0.09 0.25 0.35]\n",
      "Agent1 [0.2  0.07 0.13 0.24 0.35] -> eehd -> Agent0 [0.2  0.11 0.09 0.25 0.36]\n",
      "Agent1 [0.2  0.07 0.13 0.24 0.35] -> eehd -> Agent2 [0.2  0.1  0.09 0.25 0.35]\n",
      "Agent2 [0.2  0.07 0.13 0.24 0.35] -> eehf -> Agent0 [0.17 0.14 0.13 0.21 0.34]\n",
      "Agent2 [0.2  0.07 0.13 0.24 0.35] -> eehf -> Agent1 [0.17 0.13 0.14 0.21 0.35]\n",
      "\n",
      "Agent0 [0.15 0.08 0.16 0.24 0.37] -> ehed -> Agent1 [0.18 0.1  0.11 0.24 0.37]\n",
      "Agent0 [0.15 0.08 0.16 0.24 0.37] -> ehed -> Agent2 [0.16 0.1  0.12 0.24 0.38]\n",
      "Agent1 [0.15 0.08 0.16 0.24 0.37] -> ehed -> Agent0 [0.16 0.11 0.11 0.25 0.37]\n",
      "Agent1 [0.15 0.08 0.16 0.24 0.37] -> ehed -> Agent2 [0.16 0.1  0.12 0.24 0.38]\n",
      "Agent2 [0.15 0.08 0.16 0.24 0.37] -> ehfh -> Agent0 [0.12 0.12 0.12 0.24 0.4 ]\n",
      "Agent2 [0.15 0.08 0.16 0.24 0.37] -> ehfh -> Agent1 [0.12 0.1  0.13 0.24 0.41]\n",
      "\n",
      "Agent0 [0.12 0.41 0.09 0.24 0.14] -> ebdc -> Agent1 [0.12 0.4  0.11 0.27 0.1 ]\n",
      "Agent0 [0.12 0.41 0.09 0.24 0.14] -> ebdc -> Agent2 [0.11 0.43 0.11 0.26 0.09]\n",
      "Agent1 [0.12 0.41 0.09 0.24 0.14] -> ebed -> Agent0 [0.16 0.39 0.1  0.26 0.09]\n",
      "Agent1 [0.12 0.41 0.09 0.24 0.14] -> ebed -> Agent2 [0.16 0.39 0.09 0.26 0.1 ]\n",
      "Agent2 [0.12 0.41 0.09 0.24 0.14] -> fe -> Agent0 [0.19 0.4  0.06 0.26 0.08]\n",
      "Agent2 [0.12 0.41 0.09 0.24 0.14] -> fe -> Agent1 [0.18 0.39 0.07 0.27 0.1 ]\n",
      "\n",
      "Validation loss (0 -> 1): 0.026865529248661913\n",
      "Validation loss (0 -> 2): 0.0263769847482763\n",
      "Validation loss (1 -> 0): 0.025490485506488768\n",
      "Validation loss (1 -> 2): 0.02499524688231759\n",
      "Validation loss (2 -> 0): 0.028926647001262608\n",
      "Validation loss (2 -> 1): 0.02923223912030153\n"
     ]
    }
   ],
   "source": [
    "decoded_outputs = []\n",
    "loss_fn = nn.MSELoss()\n",
    "\n",
    "this_epoch_val_loss = defaultdict(float)\n",
    "\n",
    "for i, x in enumerate(test_dataset.dataset.tensors[0]):\n",
    "    this_sample_outputs = []\n",
    "    for name0, name1 in permutations(agents_dict.keys(), 2):\n",
    "        _loss, _senderOutput, _receiverOutput = eval_pass_simple(agents_dict[name0], agents_dict[name1], x, 1, loss_fn, returnData=True)\n",
    "        this_epoch_val_loss[(name0, name1)] += _loss.item()\n",
    "        if i<100:\n",
    "            print(f\"Agent{name0} {x.numpy().round(2)} -> {transform(_senderOutput)} -> Agent{name1} {_receiverOutput.numpy().round(2)}\")\n",
    "        this_sample_outputs.append(transform(_senderOutput))\n",
    "    \n",
    "    decoded_outputs.append(this_sample_outputs)\n",
    "    if i<100:\n",
    "        print ()\n",
    "\n",
    "for name0, name1 in permutations(agents_dict.keys(), 2):\n",
    "    this_epoch_val_loss[(name0, name1)] /= len(test_dataset)\n",
    "    print (f\"Validation loss ({name0} -> {name1}): {this_epoch_val_loss[(name0, name1)]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running Other Experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_RUNS = 3 # CHANGE THIS TO 1 IF YOU WANT TO RUN ONLY ONCE\n",
    "\n",
    "HIDDEN_SIZE = 32 # HIDDEN SIZE OF RNN\n",
    "NUM_LAYERS = 1 # DO NOT CHANGE - UNSTABLE FOR >1\n",
    "VOCAB_SIZE = 9 # VOCABULARY SIZE\n",
    "MAX_LEN = 5 # MAXIMUM LENGTH OF OUTPUT SEQUENCE\n",
    "\n",
    "runs_epoch_losses = []\n",
    "runs_agents_val_lossEnfToEnd = []\n",
    "runs_val_results = []\n",
    "\n",
    "for i in range(NUM_RUNS): \n",
    "\n",
    "    #------------------------------------------#\n",
    "    # TO USE 3 AGENTS\n",
    "    agents_dict = {\n",
    "        0: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "        1: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "        2: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN)\n",
    "    }\n",
    "\n",
    "    #------------------------------------------#\n",
    "    # TO USE ONLY A PAIR OF AGENTS\n",
    "\n",
    "    # agents_dict = {\n",
    "    #     0: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "    #     1: Agent(NUM_CONCEPTS_DIMS, HIDDEN_SIZE, DEVICE, NUM_LAYERS, VOCAB_SIZE, MAX_LEN),\n",
    "    # }\n",
    "\n",
    "    #------------------------------------------#\n",
    "    # OTHER EXPERIMENTS\n",
    "\n",
    "    epoch_losses, agents_val_lossEnfToEnd, val_results = simulate_with_competitiveness(\n",
    "        agents_dict, \n",
    "        train_dataset,\n",
    "        val_dataset,\n",
    "        epochs=500, \n",
    "        batch_size=16, \n",
    "        verbose=True, \n",
    "        evalEpochs=10,\n",
    "        competitive_level=0.4,\n",
    "        fn_generate_pair=get_agent_pair_fc, # OR get_agent_pair_ring (samples agent pairs)\n",
    "        fn_forward_pass=forward_pass_simple, # OR forward_pass_IC (for inner speech)\n",
    "        fn_eval_pass=eval_pass_simple, # OR eval_pass_IC (for inner speech)\n",
    "    )\n",
    "\n",
    "    runs_epoch_losses.append(epoch_losses)\n",
    "    runs_agents_val_lossEnfToEnd.append(agents_val_lossEnfToEnd)\n",
    "    runs_val_results.append(val_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# AGGREGRATE RESULTS FROM MULTIPLE RUNS\n",
    "\n",
    "agg_val_results = {}\n",
    "std_val_results = {}\n",
    "\n",
    "for key in runs_val_results[0].keys():\n",
    "    agg_val_results[key] = np.mean([np.nan_to_num(run[key]) for run in runs_val_results], axis=0)\n",
    "    std_val_results[key] = np.std([np.nan_to_num(run[key]) for run in runs_val_results], axis=0)\n",
    "\n",
    "agg_epoch_losses = np.array(runs_epoch_losses).mean(axis=0)\n",
    "std_epoch_losses = np.array(runs_epoch_losses).std(axis=0)\n",
    "\n",
    "agg_agents_val_lossEnfToEnd = {combo : [] for combo in permutations(agents_dict.keys(), 2)}\n",
    "std_agents_val_lossEnfToEnd = {combo : [] for combo in permutations(agents_dict.keys(), 2)}\n",
    "\n",
    "for val_loss in runs_agents_val_lossEnfToEnd:\n",
    "    for key, val in val_loss.items():\n",
    "        agg_agents_val_lossEnfToEnd[key].append(val)\n",
    "\n",
    "for key in agg_agents_val_lossEnfToEnd:\n",
    "    std_agents_val_lossEnfToEnd[key] = np.std(agg_agents_val_lossEnfToEnd[key], axis=0)\n",
    "    agg_agents_val_lossEnfToEnd[key] = np.mean(agg_agents_val_lossEnfToEnd[key], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f, ax = plt.subplots(3, 2, figsize=(8, 12))\n",
    "\n",
    "ax[0, 0].set_title(\"Synchronisation\")\n",
    "ax[0, 0].plot(np.arange(0, epochs, epoch_gap), 1-agg_val_results[\"edit_distance_mean\"], label=\"Edit Distance\", color = \"black\")\n",
    "ax[0, 0].fill_between(np.arange(0, epochs, epoch_gap),\n",
    "                        1-agg_val_results[\"edit_distance_mean\"] - std_val_results[\"edit_distance_mean\"], \n",
    "                        1-agg_val_results[\"edit_distance_mean\"] + std_val_results[\"edit_distance_mean\"], \n",
    "                        alpha=0.2, color = \"black\")\n",
    "ax[0, 0].set_ylim(0,1)\n",
    "\n",
    "# validation loss\n",
    "for i, (k, v) in enumerate(agg_agents_val_lossEnfToEnd.items()):\n",
    "    ax[0, 1].plot(np.arange(0, epochs, epoch_gap), v, label=f\"{k[0]} -> {k[1]}\")\n",
    "ax[0, 1].legend()\n",
    "ax[0, 1].set_title(\"Validation Loss\")\n",
    "\n",
    "ax[1, 0].set_title(\"Self Play Loss\")\n",
    "ax[1, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"self_intelligibility_mean\"], label=\"Self Play Loss\", color = \"red\")\n",
    "ax[1, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"self_intelligibility_mean\"] - std_val_results[\"self_intelligibility_mean\"], \n",
    "                      agg_val_results[\"self_intelligibility_mean\"] + std_val_results[\"self_intelligibility_mean\"], \n",
    "                      alpha=0.2, color = \"red\")\n",
    "\n",
    "ax[1, 1].set_title(\"Token Relationship Alignment\")\n",
    "ax[1, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"ss_correlations_mean\"], label=\"Sender-Sender\", color = 'green')\n",
    "ax[1, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"rr_correlations_mean\"], label=\"Receiver-Receiver\", color = 'blue')\n",
    "ax[1, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"sr_correlations_mean\"], label=\"Sender-Receiver\", color = 'red')\n",
    "ax[1, 1].legend()\n",
    "ax[1, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"ss_correlations_mean\"] - std_val_results[\"ss_correlations_mean\"], \n",
    "                      agg_val_results[\"ss_correlations_mean\"] + std_val_results[\"ss_correlations_mean\"], \n",
    "                      alpha=0.2, color = 'green')\n",
    "ax[1, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"rr_correlations_mean\"] - std_val_results[\"rr_correlations_mean\"], \n",
    "                      agg_val_results[\"rr_correlations_mean\"] + std_val_results[\"rr_correlations_mean\"], \n",
    "                      alpha=0.2, color = 'blue')\n",
    "ax[1, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"sr_correlations_mean\"] - std_val_results[\"sr_correlations_mean\"], \n",
    "                      agg_val_results[\"sr_correlations_mean\"] + std_val_results[\"sr_correlations_mean\"], \n",
    "                      alpha=0.2, color = 'red')\n",
    "ax[1, 1].set_ylim(0, 1)\n",
    "\n",
    "ax[2, 0].set_title(\"N-gram Overlap\")\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"1-gram_mean\"], label=\"1-gram\", color = 'orange')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                        agg_val_results[\"1-gram_mean\"] - std_val_results[\"1-gram_mean\"], \n",
    "                        agg_val_results[\"1-gram_mean\"] + std_val_results[\"1-gram_mean\"], \n",
    "                        alpha=0.2, color = 'orange')\n",
    "\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"2-gram_mean\"], label=\"2-gram\", color = 'purple')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"2-gram_mean\"] - std_val_results[\"2-gram_mean\"], \n",
    "                      agg_val_results[\"2-gram_mean\"] + std_val_results[\"2-gram_mean\"], \n",
    "                      alpha=0.2, color = 'purple')\n",
    "\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"3-gram_mean\"], label=\"3-gram\", color = 'blue')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"3-gram_mean\"] - std_val_results[\"3-gram_mean\"], \n",
    "                      agg_val_results[\"3-gram_mean\"] + std_val_results[\"3-gram_mean\"], \n",
    "                      alpha=0.2, color = 'blue')\n",
    "\n",
    "ax[2, 0].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"4-gram_mean\"], label=\"4-gram\", color = 'black')\n",
    "ax[2, 0].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"4-gram_mean\"] - std_val_results[\"4-gram_mean\"], \n",
    "                      agg_val_results[\"4-gram_mean\"] + std_val_results[\"4-gram_mean\"], \n",
    "                      alpha=0.2, color = 'black')\n",
    "ax[2, 0].set_ylim(0, 1)\n",
    "ax[2, 0].legend()\n",
    "\n",
    "ax[2, 1].set_title(\"Compositionality\")\n",
    "ax[2, 1].plot(np.arange(0, epochs, epoch_gap), agg_val_results[\"topological_similarity_mean\"], label=\"Topological Similarity\", color = \"purple\")\n",
    "ax[2, 1].fill_between(np.arange(0, epochs, epoch_gap), \n",
    "                      agg_val_results[\"topological_similarity_mean\"] - std_val_results[\"topological_similarity_mean\"], \n",
    "                      agg_val_results[\"topological_similarity_mean\"] + std_val_results[\"topological_similarity_mean\"], \n",
    "                      alpha=0.2, color = \"purple\")\n",
    "ax[2, 1].set_ylim(0, 1)\n",
    "\n",
    "\n",
    "for i in range(0, epochs, epoch_line_period):\n",
    "    for j in range(3):\n",
    "        ax[j, 0].axvline(x=i, color='gray', linestyle='--', alpha=0.5)\n",
    "        ax[j, 1].axvline(x=i, color='gray', linestyle='--', alpha=0.5)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rl",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}