project_esol_final_transfer_learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "from tdc.single_pred.adme import ADME\n",
    "from tdc import Evaluator\n",
    "from tqdm.notebook import tqdm, trange\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython import display\n",
    "\n",
    "from typing import List, Tuple\n",
    "\n",
    "\n",
    "class Featurizer:\n",
    "    def __init__(self, y_column, smiles_col='Drug', **kwargs):\n",
    "        self.y_column = y_column\n",
    "        self.smiles_col = smiles_col\n",
    "        self.__dict__.update(kwargs)\n",
    "    \n",
    "    def __call__(self, df):\n",
    "        raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.data import Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "\n",
    "\n",
    "def one_of_k_encoding(x, allowable_set):\n",
    "    if x not in allowable_set:\n",
    "        raise ValueError(\"input {0} not in allowable set{1}:\".format(\n",
    "            x, allowable_set))\n",
    "    return list(map(lambda s: x == s, allowable_set))\n",
    "\n",
    "\n",
    "def one_of_k_encoding_unk(x, allowable_set):\n",
    "    if x not in allowable_set:\n",
    "        x = allowable_set[-1]\n",
    "    return list(map(lambda s: x == s, allowable_set))\n",
    "\n",
    "\n",
    "from rdkit.Chem import rdMolDescriptors\n",
    "\n",
    "class GraphFeaturizer(Featurizer):\n",
    "    def __call__(self, df, getRepresentation):\n",
    "        graphs = []\n",
    "        labels = []\n",
    "        for i, row in df.iterrows():\n",
    "            y = row[self.y_column]\n",
    "            smiles = row[self.smiles_col]\n",
    "            mol = Chem.MolFromSmiles(smiles)\n",
    "            \n",
    "            edges = []\n",
    "            for bond in mol.GetBonds():\n",
    "                begin = bond.GetBeginAtomIdx()\n",
    "                end = bond.GetEndAtomIdx()\n",
    "                edges.append((begin, end))  # TODO: Add edges in both directions\n",
    "            edges = np.array(edges)\n",
    "            \n",
    "            nodes = []\n",
    "            for atom in mol.GetAtoms():\n",
    "                # print(atom.GetAtomicNum(), atom.GetNumImplicitHs(), atom.GetTotalNumHs(), atom.GetSymbol(), atom.GetNumExplicitHs(), atom.GetTotalValence())\n",
    "                results = getRepresentation(atom)\n",
    "                # print(results)\n",
    "                nodes.append(results)\n",
    "            nodes = np.array(nodes)\n",
    "            \n",
    "            graphs.append((nodes, edges.T))\n",
    "            labels.append(y)\n",
    "        labels = np.array(labels)\n",
    "        return [Data(\n",
    "            x=torch.FloatTensor(x), \n",
    "            edge_index=torch.LongTensor(edge_index), \n",
    "            y=torch.FloatTensor([y])\n",
    "        ) for ((x, edge_index), y) in zip(graphs, labels)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def defaultRepresentation(atom):\n",
    "    return one_of_k_encoding_unk(atom.GetAtomicNum(), range(11)) + one_of_k_encoding(\n",
    "                    atom.GetDegree(), range(11)\n",
    "                ) + one_of_k_encoding_unk(\n",
    "                    atom.GetImplicitValence(), range(11)\n",
    "                ) + [atom.GetIsAromatic()] + one_of_k_encoding_unk(\n",
    "                    atom.GetTotalNumHs(), range(11)\n",
    "                ) + [atom.GetNumImplicitHs(), atom.GetFormalCharge(), atom.GetNumRadicalElectrons(), atom.IsInRing()] # TODO: Add atom features as a list, you can use one_of_k_encodings defined above\n",
    "\n",
    "def representation1(atom):\n",
    "    return one_of_k_encoding_unk(atom.GetAtomicNum(), range(12)) + one_of_k_encoding_unk(\n",
    "                    atom.GetDegree(), range(6)) + one_of_k_encoding_unk(\n",
    "                    atom.GetTotalNumHs(), range(5)\n",
    "                ) + [atom.GetFormalCharge(), atom.IsInRing(), atom.GetIsAromatic()]\n",
    "\n",
    "def representation10(atom):\n",
    "    return one_of_k_encoding_unk(atom.GetAtomicNum(), range(12)) + one_of_k_encoding_unk(\n",
    "                    atom.GetDegree(), range(6)) + one_of_k_encoding_unk(\n",
    "                    atom.GetTotalNumHs(), range(5)\n",
    "                ) + [atom.IsInRing(), atom.GetIsAromatic()]\n",
    "\n",
    "def representationAll(atom):\n",
    "    return one_of_k_encoding_unk(atom.GetAtomicNum(), range(12)) + one_of_k_encoding_unk(\n",
    "                    atom.GetDegree(), range(6)) + one_of_k_encoding_unk(\n",
    "                    atom.GetTotalNumHs(), range(5)) + one_of_k_encoding_unk(\n",
    "                    atom.GetImplicitValence(), range(6))  + one_of_k_encoding_unk(\n",
    "                    atom.GetHybridization(),\n",
    "                    [\n",
    "                        Chem.rdchem.HybridizationType.SP, Chem.rdchem.HybridizationType.SP2,\n",
    "                        Chem.rdchem.HybridizationType.SP3, Chem.rdchem.HybridizationType.SP3D,\n",
    "                        Chem.rdchem.HybridizationType.SP3D2\n",
    "                    ]\n",
    "                ) + [atom.GetFormalCharge(), atom.IsInRing(), atom.GetIsAromatic()\n",
    "                     ] + [atom.GetNumRadicalElectrons()]\n",
    "\n",
    "def printProperties(atom):\n",
    "    print(\"=========\")\n",
    "    print(\"GetDegree\", atom.GetDegree())\n",
    "    print(\"GetImplicitValence\", atom.GetImplicitValence())\n",
    "    print(\"GetAtomicNum\", atom.GetAtomicNum())\n",
    "    print(\"GetTotalNumHs\", atom.GetTotalNumHs())\n",
    "    print(\"GetNumImplicitHs\", atom.GetNumImplicitHs())\n",
    "    print(\"GetNeighbors\", atom.GetNeighbors())\n",
    "    print(\"GetNumExplicitHs\", atom.GetNumExplicitHs())\n",
    "    print(\"GetTotalDegree\", atom.GetTotalDegree())\n",
    "    print(\"GetTotalNumHs\", atom.GetTotalNumHs())\n",
    "    print(\"GetTotalValence\", atom.GetTotalValence())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ECFPFeaturizer(Featurizer):\n",
    "    def __init__(self, y_column, radius=2, length=1024, **kwargs):\n",
    "        self.radius = radius\n",
    "        self.length = length\n",
    "        super().__init__(y_column, **kwargs)\n",
    "    \n",
    "    def __call__(self, df):\n",
    "        fingerprints = []\n",
    "        labels = []\n",
    "        for i, row in df.iterrows():\n",
    "            y = row[self.y_column]\n",
    "            smiles = row[self.smiles_col]\n",
    "            mol = Chem.MolFromSmiles(smiles)\n",
    "            fp = AllChem.GetMorganFingerprintAsBitVect(mol, self.radius, nBits=self.length)\n",
    "            fingerprints.append(fp)\n",
    "            labels.append(y)\n",
    "        fingerprints = np.array(fingerprints)\n",
    "        labels = np.array(labels)\n",
    "        return fingerprints, labels\n",
    "\n",
    "dataset = pd.read_csv(\"./datasets/esol.csv\")\n",
    "\n",
    "from sklearn.utils import shuffle\n",
    "dataset = shuffle(dataset)\n",
    "train_dataset = dataset[:500]\n",
    "val_dataset = dataset[500:800]\n",
    "test_dataset = dataset[800:1100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "rmse = Evaluator(name = 'RMSE')\n",
    "\n",
    "featurizer = ECFPFeaturizer(y_column='measured log solubility in mols per litre', smiles_col=\"smiles\")\n",
    "X_train, y_train = featurizer(train_dataset)\n",
    "X_valid, y_valid = featurizer(val_dataset)\n",
    "X_test, y_test = featurizer(test_dataset)\n",
    "\n",
    "featurizer = GraphFeaturizer(y_column='measured log solubility in mols per litre', smiles_col=\"smiles\")\n",
    "\n",
    "graph = featurizer(test_dataset.iloc[:1], representationAll)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.loader import DataLoader as GraphDataLoader\n",
    "\n",
    "\n",
    "# prepare data loaders\n",
    "batch_size = 64\n",
    "\n",
    "train_loader1 = GraphDataLoader(featurizer(train_dataset, representation1), batch_size=batch_size, shuffle=True)\n",
    "valid_loader1 = GraphDataLoader(featurizer(val_dataset, representation1), batch_size=batch_size)\n",
    "test_loader1 = GraphDataLoader(featurizer(test_dataset, representation1), batch_size=batch_size)\n",
    "\n",
    "train_loader10 = GraphDataLoader(featurizer(train_dataset, representation10), batch_size=batch_size, shuffle=True)\n",
    "valid_loader10 = GraphDataLoader(featurizer(val_dataset, representation10), batch_size=batch_size)\n",
    "test_loader10 = GraphDataLoader(featurizer(test_dataset, representation10), batch_size=batch_size)\n",
    "\n",
    "train_loader = GraphDataLoader(featurizer(train_dataset, representationAll), batch_size=batch_size, shuffle=True)\n",
    "valid_loader = GraphDataLoader(featurizer(val_dataset, representationAll), batch_size=batch_size)\n",
    "test_loader = GraphDataLoader(featurizer(test_dataset, representationAll), batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.nn import GCNConv, GINConv, global_mean_pool\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric.nn import global_mean_pool as gap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#warstwa attention pooling\n",
    "class MyAttentionModule3(torch.nn.Module): # zakladamy ze atom ma 49 featerow\n",
    "    def __init__(self, groupFeatures=1):\n",
    "        super().__init__()\n",
    "        self.groupFeatures = groupFeatures\n",
    "        self.gates = torch.nn.ModuleDict({ # do wyliczenia atencji dla kazdej grupy cech - jest ich 9\n",
    "            'AtomicNum': GCNConv(12, 1),\n",
    "            'Degree': GCNConv(6, 1),\n",
    "            'TotalNumHs': GCNConv(5, 1),\n",
    "            'ImplicitValence': GCNConv(6, 1),\n",
    "            'Hybridization': GCNConv(5, 1),\n",
    "            'FormalCharge': GCNConv(1, 1),\n",
    "            'IsInRing': GCNConv(1, 1),\n",
    "            'IsAromatic': GCNConv(1, 1),\n",
    "            'NumRadicalElectrons': GCNConv(1, 1)\n",
    "        })\n",
    "        \n",
    "        self.feats = torch.nn.ModuleDict({ # do transformacji grupy cech w wektor, na razie dziala tylko dla groupFeatures=1\n",
    "            'AtomicNum': torch.nn.Linear(12, groupFeatures),\n",
    "            'Degree': torch.nn.Linear(6, groupFeatures),\n",
    "            'TotalNumHs': torch.nn.Linear(5, groupFeatures),\n",
    "            'ImplicitValence': torch.nn.Linear(6, groupFeatures),\n",
    "            'Hybridization': torch.nn.Linear(5, groupFeatures),\n",
    "            'FormalCharge': torch.nn.Linear(1, groupFeatures),\n",
    "            'IsInRing': torch.nn.Linear(1, groupFeatures),\n",
    "            'IsAromatic': torch.nn.Linear(1, groupFeatures),\n",
    "            'NumRadicalElectrons': torch.nn.Linear(1, groupFeatures)\n",
    "        })\n",
    "\n",
    "    def forward(self, x, edge_index, batch):\n",
    "        gates = []\n",
    "        gates.append(self.gates['AtomicNum'](x[:,0:12], edge_index))\n",
    "        gates.append(self.gates['Degree'](x[:,12:18], edge_index))\n",
    "        gates.append(self.gates['TotalNumHs'](x[:,18:23], edge_index))\n",
    "        gates.append(self.gates['ImplicitValence'](x[:,23:29], edge_index))\n",
    "        gates.append(self.gates['Hybridization'](x[:,29:34], edge_index))\n",
    "        gates.append(self.gates['FormalCharge'](x[:,34:35], edge_index))\n",
    "        gates.append(self.gates['IsInRing'](x[:,35:36], edge_index))\n",
    "        gates.append(self.gates['IsAromatic'](x[:,36:37], edge_index))\n",
    "        gates.append(self.gates['NumRadicalElectrons'](x[:,37:38], edge_index))\n",
    "        logits = torch.cat(gates, dim=-1)\n",
    "        attention = torch.softmax(logits, dim=-1).unsqueeze(-1)\n",
    "        \n",
    "        subgroups = []\n",
    "        subgroups.append(self.feats['AtomicNum'](x[:,0:12]) * attention[:,0])\n",
    "        subgroups.append(self.feats['Degree'](x[:,12:18]) * attention[:,1])\n",
    "        subgroups.append(self.feats['TotalNumHs'](x[:,18:23]) * attention[:,2])\n",
    "        subgroups.append(self.feats['ImplicitValence'](x[:,23:29]) * attention[:,3])\n",
    "        subgroups.append(self.feats['Hybridization'](x[:,29:34]) * attention[:,4])\n",
    "        subgroups.append(self.feats['FormalCharge'](x[:,34:35]) * attention[:,5])\n",
    "        subgroups.append(self.feats['IsInRing'](x[:,35:36]) * attention[:,6])\n",
    "        subgroups.append(self.feats['IsAromatic'](x[:,36:37]) * attention[:,7])\n",
    "        subgroups.append(self.feats['NumRadicalElectrons'](x[:,37:38]) * attention[:,8])\n",
    "        x = torch.stack(subgroups, dim=-2)\n",
    "        x = torch.sum(x, dim=-2)\n",
    "        \n",
    "        return x, attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def attSequential(n_feats):\n",
    "    return torch.nn.Sequential(torch.nn.Linear(n_feats, 1),\n",
    "                       torch.nn.BatchNorm1d(1), torch.nn.ReLU(),\n",
    "                       torch.nn.Linear(1, 1), torch.nn.ReLU())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#warstwa attention pooling\n",
    "class MyAttentionModule4(torch.nn.Module): # zakladamy ze atom ma 49 featerow\n",
    "    def __init__(self, groupFeatures=1):\n",
    "        super().__init__()\n",
    "        self.groupFeatures = groupFeatures\n",
    "        self.gates = torch.nn.ModuleDict({ # do wyliczenia atencji dla kazdej grupy cech - jest ich 9\n",
    "            'AtomicNum': GINConv(attSequential(12), train_eps=True),\n",
    "            'Degree': GINConv(attSequential(6), train_eps=True),\n",
    "            'TotalNumHs': GINConv(attSequential(5), train_eps=True),\n",
    "            'ImplicitValence': GINConv(attSequential(6), train_eps=True),\n",
    "            'Hybridization': GINConv(attSequential(5), train_eps=True),\n",
    "            'FormalCharge': GINConv(attSequential(1), train_eps=True),\n",
    "            'IsInRing': GINConv(attSequential(1), train_eps=True),\n",
    "            'IsAromatic': GINConv(attSequential(1), train_eps=True),\n",
    "            'NumRadicalElectrons': GINConv(attSequential(1), train_eps=True)\n",
    "        })\n",
    "        \n",
    "        self.feats = torch.nn.ModuleDict({ # do transformacji grupy cech w wektor, na razie dziala tylko dla groupFeatures=1\n",
    "            'AtomicNum': torch.nn.Linear(12, groupFeatures),\n",
    "            'Degree': torch.nn.Linear(6, groupFeatures),\n",
    "            'TotalNumHs': torch.nn.Linear(5, groupFeatures),\n",
    "            'ImplicitValence': torch.nn.Linear(6, groupFeatures),\n",
    "            'Hybridization': torch.nn.Linear(5, groupFeatures),\n",
    "            'FormalCharge': torch.nn.Linear(1, groupFeatures),\n",
    "            'IsInRing': torch.nn.Linear(1, groupFeatures),\n",
    "            'IsAromatic': torch.nn.Linear(1, groupFeatures),\n",
    "            'NumRadicalElectrons': torch.nn.Linear(1, groupFeatures)\n",
    "        })\n",
    "\n",
    "    def forward(self, x, edge_index, batch):\n",
    "        gates = []\n",
    "        gates.append(self.gates['AtomicNum'](x[:,0:12], edge_index))\n",
    "        gates.append(self.gates['Degree'](x[:,12:18], edge_index))\n",
    "        gates.append(self.gates['TotalNumHs'](x[:,18:23], edge_index))\n",
    "        gates.append(self.gates['ImplicitValence'](x[:,23:29], edge_index))\n",
    "        gates.append(self.gates['Hybridization'](x[:,29:34], edge_index))\n",
    "        gates.append(self.gates['FormalCharge'](x[:,34:35], edge_index))\n",
    "        gates.append(self.gates['IsInRing'](x[:,35:36], edge_index))\n",
    "        gates.append(self.gates['IsAromatic'](x[:,36:37], edge_index))\n",
    "        gates.append(self.gates['NumRadicalElectrons'](x[:,37:38], edge_index))\n",
    "        logits = torch.cat(gates, dim=-1)\n",
    "        attention = torch.softmax(logits, dim=-1).unsqueeze(-1)\n",
    "        \n",
    "        subgroups = []\n",
    "        subgroups.append(self.feats['AtomicNum'](x[:,0:12]) * attention[:,0])\n",
    "        subgroups.append(self.feats['Degree'](x[:,12:18]) * attention[:,1])\n",
    "        subgroups.append(self.feats['TotalNumHs'](x[:,18:23]) * attention[:,2])\n",
    "        subgroups.append(self.feats['ImplicitValence'](x[:,23:29]) * attention[:,3])\n",
    "        subgroups.append(self.feats['Hybridization'](x[:,29:34]) * attention[:,4])\n",
    "        subgroups.append(self.feats['FormalCharge'](x[:,34:35]) * attention[:,5])\n",
    "        subgroups.append(self.feats['IsInRing'](x[:,35:36]) * attention[:,6])\n",
    "        subgroups.append(self.feats['IsAromatic'](x[:,36:37]) * attention[:,7])\n",
    "        subgroups.append(self.feats['NumRadicalElectrons'](x[:,37:38]) * attention[:,8])\n",
    "        x = torch.stack(subgroups, dim=-2)\n",
    "        x = torch.sum(x, dim=-2)\n",
    "        \n",
    "        return x, attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphNeuralNetwork(torch.nn.Module):  # TODO: assign hyperparameters to attributes and define the forward pass\n",
    "    def __init__(self, hidden_size, n_convs=3, my_layer=None, features_after_layer=26, n_features=49, dropout=0.2):\n",
    "        super().__init__()\n",
    "        self.myAttentionModule = my_layer\n",
    "        self.dropout = dropout\n",
    "\n",
    "        convs = torch.nn.ModuleList()\n",
    "        convs.append(GCNConv(features_after_layer, hidden_size))\n",
    "        for i in range(1, n_convs):\n",
    "            convs.append(GCNConv(hidden_size, hidden_size))\n",
    "        self.convs = convs\n",
    "        self.linear = torch.nn.Linear(hidden_size, 1)\n",
    "    \n",
    "    def forward(self, x, edge_index, batch):\n",
    "        att = None\n",
    "        if self.myAttentionModule is not None:\n",
    "            x, att = self.myAttentionModule(x, edge_index, batch)\n",
    "        for i in range(0, len(self.convs)-1):\n",
    "            x = self.convs[i](x, edge_index)\n",
    "            x = x.relu()\n",
    "        x = self.convs[-1](x, edge_index)\n",
    "        \n",
    "        x = gap(x, batch)\n",
    "        \n",
    "        x = F.dropout(x, p=self.dropout, training=self.training)\n",
    "\n",
    "        out = self.linear(x)\n",
    "\n",
    "        return out, att"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, train_loader, valid_loader, epochs=20, learning_rate = 0.01):\n",
    "    model.train()\n",
    "    \n",
    "    # training loop\n",
    "    optimizer = torch.optim.Adam(model.parameters(), learning_rate) # TODO: define an optimizer\n",
    "    loss_fn = torch.nn.MSELoss()  # TODO: define a loss function\n",
    "    for epoch in trange(1, epochs + 1, leave=False):\n",
    "        for data in tqdm(train_loader, leave=False):\n",
    "            x, edge_index, batch, y = data.x, data.edge_index, data.batch, data.y\n",
    "            model.zero_grad()\n",
    "            preds, att = model(x, edge_index, batch)\n",
    "            loss = loss_fn(preds, y.reshape(-1, 1))\n",
    "            loss.backward()\n",
    "            # print(\"==============\")\n",
    "            # for par in model.myAttentionModule.parameters():\n",
    "            #     print(par)\n",
    "            optimizer.step()\n",
    "    return model\n",
    "\n",
    "\n",
    "def predict(model, test_loader):\n",
    "    # evaluation loop\n",
    "    preds_batches = []\n",
    "    with torch.no_grad():\n",
    "        for data in tqdm(test_loader):\n",
    "            x, edge_index, batch = data.x, data.edge_index, data.batch\n",
    "            \n",
    "            preds, att = model(x, edge_index, batch)\n",
    "            preds_batches.append(preds.cpu().detach().numpy())\n",
    "    preds = np.concatenate(preds_batches)\n",
    "    return preds, att"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "def train_best(model, train_loader, valid_loader, epochs=20, learning_rate = 0.01, saveImg=False, title=\"\"):\n",
    "    model.train()\n",
    "\n",
    "    torch.save(model, \"train.pth\")\n",
    "    best_val = 1000000\n",
    "    \n",
    "    # training loop\n",
    "    optimizer = torch.optim.Adam(model.parameters(), learning_rate) # TODO: define an optimizer\n",
    "    loss_fn = torch.nn.MSELoss()  # TODO: define a loss function\n",
    "    for epoch in trange(1, epochs + 1, leave=False):\n",
    "        # preds_batches = []\n",
    "        running_loss = 0.0\n",
    "        for data in train_loader:\n",
    "            x, edge_index, batch, y = data.x, data.edge_index, data.batch, data.y\n",
    "            model.zero_grad()\n",
    "            preds, att = model(x, edge_index, batch)\n",
    "            loss = loss_fn(preds, y.reshape(-1, 1))\n",
    "\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "        # evaluation loop\n",
    "        preds_batches = []\n",
    "        with torch.no_grad():\n",
    "            for data in valid_loader:\n",
    "                x, edge_index, batch, y = data.x, data.edge_index, data.batch, data.y\n",
    "                preds, att = model(x, edge_index, batch)\n",
    "                loss = loss_fn(preds, y.reshape(-1, 1))\n",
    "                preds_batches.append(preds.cpu().detach().numpy())\n",
    "        preds = np.concatenate(preds_batches)\n",
    "        mae = rmse(y_valid, preds.flatten())\n",
    "        if mae < best_val:\n",
    "            torch.save(model, \"train.pth\")\n",
    "            best_val = mae\n",
    "            print(best_val)\n",
    "\n",
    "    model = torch.load(\"train.pth\")\n",
    "    model.eval()\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize(model, train_loader, valid_loader, test_loader, epochs=20, learning_rate = 0.01, saveImg=False, title=\"\"):\n",
    "    model.train()\n",
    "\n",
    "    best_state = deepcopy(model.state_dict())\n",
    "    best_val = 1000000\n",
    "    \n",
    "    # training loop\n",
    "    optimizer = torch.optim.Adam(model.parameters(), learning_rate) # TODO: define an optimizer\n",
    "    loss_fn = torch.nn.MSELoss()  # TODO: define a loss function\n",
    "    train_losses = []\n",
    "    val_losses = []\n",
    "    train_errors = []\n",
    "    val_errors = []\n",
    "    for epoch in trange(1, epochs + 1, leave=False):\n",
    "        # preds_batches = []\n",
    "        running_loss = 0.0\n",
    "        for data in train_loader:\n",
    "            x, edge_index, batch, y = data.x, data.edge_index, data.batch, data.y\n",
    "            model.zero_grad()\n",
    "            preds, att = model(x, edge_index, batch)\n",
    "            loss = loss_fn(preds, y.reshape(-1, 1))\n",
    "            # print(len(train_dataset))\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            # preds_batches.append(preds.cpu().detach().numpy())\n",
    "\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        epoch_loss = running_loss / len(train_loader)\n",
    "        train_losses.append(epoch_loss)\n",
    "        # preds = np.concatenate(preds_batches)\n",
    "        # mae = rmse(y_train, preds.flatten())\n",
    "        # train_errors.append(mae)\n",
    "\n",
    "        # evaluation loop\n",
    "        preds_batches = []\n",
    "        running_loss = 0.0\n",
    "        with torch.no_grad():\n",
    "            for data in valid_loader:\n",
    "                x, edge_index, batch, y = data.x, data.edge_index, data.batch, data.y\n",
    "                preds, att = model(x, edge_index, batch)\n",
    "                loss = loss_fn(preds, y.reshape(-1, 1))\n",
    "                # print(len(train_dataset))\n",
    "\n",
    "                running_loss += loss.item()\n",
    "                preds_batches.append(preds.cpu().detach().numpy())\n",
    "        epoch_loss = running_loss / len(valid_loader)\n",
    "        val_losses.append(epoch_loss)\n",
    "        preds = np.concatenate(preds_batches)\n",
    "        mae = rmse(y_valid, preds.flatten())\n",
    "        if mae < best_val:\n",
    "            best_state = deepcopy(model.state_dict())\n",
    "            best_val = mae\n",
    "            print(best_val)\n",
    "        val_errors.append(mae)\n",
    "\n",
    "    model.load_state_dict(best_state)\n",
    "\n",
    "    ##### visualize ########\n",
    "    plt.plot(train_losses, label='train_loss')\n",
    "    plt.plot(val_losses, label='val_loss')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    if saveImg:\n",
    "        plt.savefig(title + \"_loss.png\")\n",
    "\n",
    "    # plt.plot(train_errors,label='train_errors')\n",
    "    plt.plot(val_errors, label='val_RMSE')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    if saveImg:\n",
    "        plt.savefig(title + \"_val_error.png\")\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({\"Repr 1\": [], \"Repr 10\": [],\n",
    "                   \"transfer learning - size = 3\": [], \"transfer learning - size = 35\": [], \"transfer learning - size = 100\": [], \"transfer learning - size = 35 (big)\": []})\n",
    "pd.set_option(\"display.precision\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5f964cce5e684415b83cdbbc40c85e37",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.919210000241129\n",
      "1.8875742012074346\n",
      "1.8128823640992133\n",
      "1.7828375152351428\n",
      "1.7484528173592107\n",
      "1.7008084572651492\n",
      "1.662525493547055\n",
      "1.5934826422368402\n",
      "1.545240702663627\n",
      "1.528743632285316\n",
      "1.5107668068537372\n",
      "1.4600473617386434\n",
      "1.4259611257099267\n",
      "1.4110027002222325\n",
      "1.3800354996381161\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "74b78758af9f4693ac0bdff023a9b29a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8a35542a3b3a4ddb9d14b2c624a2701b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8659060461439392\n",
      "1.8377834976476903\n",
      "1.7517939977746408\n",
      "1.717046140096354\n",
      "1.6918970731926377\n",
      "1.6256029081830696\n",
      "1.5986230923735258\n",
      "1.5579976444057555\n",
      "1.5503093044875527\n",
      "1.5170412150073322\n",
      "1.4875040306594676\n",
      "1.4761089340868143\n",
      "1.4444659769972963\n",
      "1.4440566448902117\n",
      "1.4201252319780804\n",
      "1.4110182616482496\n",
      "1.3989328806615169\n",
      "1.391021213108861\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1aa00101bfd84a8995e9979cdddf5585",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "77e522c32d91437d84b6bc95b90b1bc3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0870910779973766\n",
      "2.189100186675679\n",
      "2.1613052160104824\n",
      "2.0611582423017163\n",
      "2.060824494013457\n",
      "2.0546840749533515\n",
      "2.045551451966513\n",
      "2.0382254176073697\n",
      "2.019116103421966\n",
      "2.017594243367857\n",
      "2.0043235443066645\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "609cc2b14fdc44af9728ced1db92d908",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2879eb0026784c96970e6a3dac24aae9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.197210947342556\n",
      "2.073512992042253\n",
      "1.9997812959524564\n",
      "1.874556774003057\n",
      "1.7851887857834072\n",
      "1.7562887072848594\n",
      "1.6784919960029894\n",
      "1.6554540879391506\n",
      "1.6257196699498806\n",
      "1.6218138887553153\n",
      "1.553740557078893\n",
      "1.5499615161906348\n",
      "1.5368622390843156\n",
      "1.5269646646270914\n",
      "1.52276136519477\n",
      "1.4922921860656064\n",
      "1.4753968317884443\n",
      "1.4697451035187215\n",
      "1.4587216806337435\n",
      "1.4557226985772365\n",
      "1.4542277757698447\n",
      "1.4309677551891782\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7dd9e5ceaa8341bead03279d5e541364",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9a69a99aa8d64a97bb5555e4d0552461",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0831263170051026\n",
      "1.9413869876089362\n",
      "1.9255884780781447\n",
      "1.8254380949461888\n",
      "1.8152034643100654\n",
      "1.7864527781378445\n",
      "1.7218022699423106\n",
      "1.6938066174587127\n",
      "1.6414945389948592\n",
      "1.6292729284352476\n",
      "1.582764669193196\n",
      "1.5627790021533017\n",
      "1.5297559916545849\n",
      "1.5238314757289195\n",
      "1.5009720959573898\n",
      "1.4421782216151957\n",
      "1.4159648472485633\n",
      "1.3979880229801283\n",
      "1.376301337032023\n",
      "1.3650116236585563\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "278145275a904f14989841c40e7e6a6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8124047c116e44ee8cd22b5594a1fc5c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9983794288179046\n",
      "1.801950634485625\n",
      "1.6015408449727886\n",
      "1.4941554743011511\n",
      "1.4598194480549034\n",
      "1.4084674447719288\n",
      "1.4042729564309242\n",
      "1.3863328239727128\n",
      "1.3749361339234718\n",
      "1.352853993019618\n",
      "1.3336179804170916\n",
      "1.3248869128899554\n",
      "1.321134010080794\n",
      "1.3208861898548416\n",
      "1.31083827683457\n",
      "1.2888652854116913\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6bfcc77eace74315a89f5354ba815d53",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f49f916df4d04eaaba885ff31c261f23",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9965476113520741\n",
      "1.8507389032014334\n",
      "1.7029651640371517\n",
      "1.5226383523451907\n",
      "1.4760979040421711\n",
      "1.4203167245394293\n",
      "1.3844797831498241\n",
      "1.3727112680527331\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "21ce8441c13847f490bec846e7a7496a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b2041165b97b49e388d11b4657439b43",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9499196082584371\n",
      "1.6631863642828542\n",
      "1.6163522539969764\n",
      "1.5376643012997049\n",
      "1.5025224538734103\n",
      "1.4646591184810882\n",
      "1.4402458055951026\n",
      "1.4242034314258076\n",
      "1.3933725649667286\n",
      "1.3900498345330934\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d28f06c774974806b2710692bfe39ccd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45e9a38b15eb4aa282100bbb32f6e918",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.111751284885849\n",
      "2.0899294360782066\n",
      "2.0388174829742827\n",
      "2.0227440197976314\n",
      "2.019444418165573\n",
      "2.015503376842233\n",
      "2.01364070426803\n",
      "2.0098241156596592\n",
      "2.00657888672797\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2617cb2b07ae44f88680919efd322d3b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "27f8d45e95074c9cb93c26f5baefff7e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9800487935860718\n",
      "1.7715563350535866\n",
      "1.737341869026017\n",
      "1.64335317679222\n",
      "1.6390311965435982\n",
      "1.6300105306192727\n",
      "1.5687549227202198\n",
      "1.5501777043693596\n",
      "1.5405869330760116\n",
      "1.5098845468451867\n",
      "1.480905292482298\n",
      "1.454832458947198\n",
      "1.4486157149612586\n",
      "1.4419394901123346\n",
      "1.4172067492658682\n",
      "1.4121588006671804\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9011514a59bb46a1936520d003558bb0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b557177987bf4bc2871e4d25deb69e9e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2450304896164264\n",
      "1.9448839047213737\n",
      "1.9007180499102647\n",
      "1.7610400616217117\n",
      "1.7085180418521806\n",
      "1.5882125742941142\n",
      "1.5410311147513536\n",
      "1.5103040311099383\n",
      "1.4708867502273897\n",
      "1.4500832380419963\n",
      "1.438689163931888\n",
      "1.4362738879757364\n",
      "1.3996028330975163\n",
      "1.3806520877846145\n",
      "1.3785544084993315\n",
      "1.3774329364686395\n",
      "1.3662455288016355\n",
      "1.3548658562916267\n",
      "1.347193543049383\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8929d9742d8e4bd5b24c4b8e9e97f928",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f4989a6b092c4fe89094443d1050588e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8907471879809903\n",
      "1.63814265451715\n",
      "1.4589414187760394\n",
      "1.4258487974199883\n",
      "1.3974273874001535\n",
      "1.3609753055922746\n",
      "1.3245909022675704\n",
      "1.3223722005452718\n",
      "1.3216503979979561\n",
      "1.3138720049414039\n",
      "1.3126323629143253\n",
      "1.2980252296546704\n",
      "1.2961175720037676\n",
      "1.295850216029008\n",
      "1.295367156953934\n",
      "1.2857346543375718\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ddeb01da28a4c629181684a78a702df",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca2e8143cf2e4d118858f4001cf841ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2593763514266847\n",
      "1.8665154480468513\n",
      "1.79528746828003\n",
      "1.664619323950496\n",
      "1.626638293038277\n",
      "1.5349713223314467\n",
      "1.5140956286606704\n",
      "1.479857670989559\n",
      "1.4587641091926336\n",
      "1.440531751525087\n",
      "1.4309458788800742\n",
      "1.4165501445390454\n",
      "1.3876976029298491\n",
      "1.3766406339989687\n",
      "1.3616135086550623\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "884459fdf80546638f0aeed88a8909f5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7d67b2b1d5964b14bf8f46fa172eb86d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.235420419580229\n",
      "1.7915238315559567\n",
      "1.7059149312084498\n",
      "1.6140493313784399\n",
      "1.6042493914177562\n",
      "1.5487218317628035\n",
      "1.504146795759281\n",
      "1.4676365511825207\n",
      "1.4419061120794072\n",
      "1.4323486667351146\n",
      "1.412253036250473\n",
      "1.4117477741297348\n",
      "1.4082975888429898\n",
      "1.4005828652455103\n",
      "1.3895564635779991\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d3635f40b9f453984ee441ccd1e5b0f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9171f5173ba644f1b43cbcfac6294b35",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1372533100645965\n",
      "2.118094361911294\n",
      "2.0836641739629878\n",
      "2.028119926652294\n",
      "2.0106115891232386\n",
      "1.9885724921551862\n",
      "1.929931415340632\n",
      "1.8692707106083508\n",
      "1.8394112126599855\n",
      "1.7912613547494112\n",
      "1.7649617540559595\n",
      "1.7413409703063474\n",
      "1.7030840978047046\n",
      "1.68700035387531\n",
      "1.655183919406697\n",
      "1.634911486824778\n",
      "1.5946690757870863\n",
      "1.5825637903540424\n",
      "1.568598521214862\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "68c200ac2b53429090f8550958cca48f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66cb52b65dfa4ea69103551723cded8f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2597523069082524\n",
      "1.8653226888457046\n",
      "1.688940973183897\n",
      "1.6277652381734977\n",
      "1.583436945438083\n",
      "1.5625559868765315\n",
      "1.5156316725757322\n",
      "1.4971950730229275\n",
      "1.4943603040481397\n",
      "1.426542398252899\n",
      "1.399335082167342\n",
      "1.3688127667439713\n",
      "1.3538264667179474\n",
      "1.3285128562672532\n",
      "1.303241736826639\n",
      "1.2613920400790872\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9343440e4e97426088b79dedc2ca55d5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "27922ef8de4e48a6b8ec12d715fe228a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.073165398402355\n",
      "1.8633565559631797\n",
      "1.8360584809211469\n",
      "1.7744807670540852\n",
      "1.7533452572158388\n",
      "1.6893290030577304\n",
      "1.64617346870535\n",
      "1.6448740602284886\n",
      "1.5772078530035696\n",
      "1.5411588811940125\n",
      "1.5111351959910087\n",
      "1.5033026376634173\n",
      "1.4951482190608436\n",
      "1.4753263926187374\n",
      "1.4601855839970486\n",
      "1.4511003611292197\n",
      "1.4430840019122553\n",
      "1.4390566014939268\n",
      "1.4358011662942254\n",
      "1.4330182023599904\n",
      "1.4174990260437796\n",
      "1.409212379778454\n",
      "1.4017961223308122\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e22f0b962b546e1a3f3d2f2e0435cd3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fb1fdf7f55f14f538512dd6274f0c6ba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2179765564935474\n",
      "1.7590315023000704\n",
      "1.6396743706970613\n",
      "1.4788270663190202\n",
      "1.4745658319566295\n",
      "1.4022046256888145\n",
      "1.3584212368097504\n",
      "1.3173435310346178\n",
      "1.3047445639762991\n",
      "1.297300081496483\n",
      "1.2863315492697909\n",
      "1.2747402201434372\n",
      "1.26409057924734\n",
      "1.246188850392894\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e0547c319d4d4098a830ec04a32864f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f5870cac9b054872b9b88aebc28db8f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4316875280885233\n",
      "2.3172912034071076\n",
      "1.9133140330376979\n",
      "1.8542776950135975\n",
      "1.7213684427721478\n",
      "1.6147083415138677\n",
      "1.543024036718655\n",
      "1.5283027819089487\n",
      "1.4806634875392315\n",
      "1.4512137605153619\n",
      "1.447334306639332\n",
      "1.446723198340461\n",
      "1.425213446676107\n",
      "1.4236189711076008\n",
      "1.4181081104945696\n",
      "1.3903739128020345\n",
      "1.3772430933265571\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "92524640760c4b0aa75442111e01aea8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "de5db71f3cea4c3d848bf85e8d1c62a3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5820595872063214\n",
      "2.261405155244928\n",
      "1.8747783991106608\n",
      "1.7706074853048557\n",
      "1.7254856231508149\n",
      "1.6587565828766566\n",
      "1.641325679296234\n",
      "1.5569840344595167\n",
      "1.5496738752842996\n",
      "1.5253960705767085\n",
      "1.5230774349724197\n",
      "1.4997542773508836\n",
      "1.486876743795592\n",
      "1.4859147836618558\n",
      "1.4847465528586195\n",
      "1.4530737209307616\n",
      "1.4452747186472452\n",
      "1.4276983591969687\n",
      "1.4224430377999995\n",
      "1.4183881088608012\n",
      "1.4129993408241277\n",
      "1.3842318658334927\n",
      "1.3782261399887767\n",
      "1.373629404709079\n",
      "1.364730715548696\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "578770076779442a9b4a8906e49c0e95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "95f7aed640284cefa3f779f646e87a8a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.660813205083213\n",
      "2.8547947623026033\n",
      "2.211020561085547\n",
      "2.0686209261557047\n",
      "2.06428035942092\n",
      "2.0436223533470295\n",
      "2.030495073349139\n",
      "2.013399966476248\n",
      "1.9806371299383245\n",
      "1.9609046664571885\n",
      "1.9418349970652011\n",
      "1.931625141405596\n",
      "1.9263838248592808\n",
      "1.9189184183123413\n",
      "1.9119502975846432\n",
      "1.898987978361421\n",
      "1.8422465310493932\n",
      "1.8056136455912666\n",
      "1.796267255574078\n",
      "1.7653903390292134\n",
      "1.7598031158431318\n",
      "1.7535204023002873\n",
      "1.689544634461888\n",
      "1.641015997920109\n",
      "1.6304198426832863\n",
      "1.5977768915129138\n",
      "1.5591539433843635\n",
      "1.5336576347434976\n",
      "1.529298339325055\n",
      "1.5076116291928192\n",
      "1.5011019424537506\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3d146e81bddf47a28a507ba3315a0127",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3afd72d12aa143bebabaf94b4fd1068b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5273247529148835\n",
      "2.437066372156476\n",
      "2.131195727532482\n",
      "1.7822984377331192\n",
      "1.78073051335549\n",
      "1.6577664462030444\n",
      "1.5811509694033707\n",
      "1.5561265288394484\n",
      "1.5015998628215053\n",
      "1.4720524811381899\n",
      "1.401405248146472\n",
      "1.3666474317654673\n",
      "1.3268981640568236\n",
      "1.308481890107092\n",
      "1.2880176018958704\n",
      "1.2624498747380106\n",
      "1.2534182520712305\n",
      "1.2428499633578078\n",
      "1.2190512111937843\n",
      "1.2162147700760606\n",
      "1.1902260129306876\n",
      "1.1798730298769742\n",
      "1.1764137308493872\n",
      "1.1570122806152197\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "69624bf9a18c4d9c93d5b5de2d1777ba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cbc047df9ece4795939aac13d51dd89a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.493041354614386\n",
      "2.292642869260036\n",
      "1.9856567196066468\n",
      "1.8111131843417336\n",
      "1.750221173951596\n",
      "1.6909003051901288\n",
      "1.6425058807666912\n",
      "1.5934004215455724\n",
      "1.560052526583636\n",
      "1.5371002901837605\n",
      "1.5258197245432652\n",
      "1.5222571858836027\n",
      "1.4991028707676528\n",
      "1.4849567725222796\n",
      "1.466435486232716\n",
      "1.4462591041739739\n",
      "1.4255726645520943\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2b1b0b310e354c49901342160045a58f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "18841ca4aa034d1ea5f21e8918afbd91",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4444478542413837\n",
      "1.936656801380953\n",
      "1.7446393770120183\n",
      "1.7382234394856309\n",
      "1.5808608737840133\n",
      "1.5367162575037783\n",
      "1.4406673770237919\n",
      "1.391457002748705\n",
      "1.350361342777464\n",
      "1.2963172877329976\n",
      "1.286877719330493\n",
      "1.2852224407981314\n",
      "1.252366112058997\n",
      "1.2369944891008129\n",
      "1.2216730156494902\n",
      "1.2188178797303442\n",
      "1.199424374831199\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "34596f91483f4b9ca51a204dbadd5e1f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0254e55278994b32a474473614760cc6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.255222927836605\n",
      "1.9876450324148198\n",
      "1.8783373134016532\n",
      "1.8706244464730057\n",
      "1.6180887929057963\n",
      "1.5688646303327398\n",
      "1.5139503228644346\n",
      "1.4921213067496466\n",
      "1.477165193603976\n",
      "1.4673668504797597\n",
      "1.4623291466544879\n",
      "1.4398939862077922\n",
      "1.4316138012644604\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fabd8c06973a4e24a72a751eb268e3d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "096e7389b1244b249f0bc882eacf154c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.7873189912373346\n",
      "1.7003609509245043\n",
      "1.6077988514756734\n",
      "1.5373729401158325\n",
      "1.4972386194482148\n",
      "1.48939393090681\n",
      "1.4844409873177489\n",
      "1.4730862648296381\n",
      "1.4712925910039099\n",
      "1.4681701551483273\n",
      "1.4659464736757355\n",
      "1.4605315199446347\n",
      "1.4446585985069282\n",
      "1.4354721156352586\n",
      "1.427247754784203\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1228ea05b65347e0a33837b66a521af4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5206f1c859494324a9afc9ccf5baad21",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6625246305974994\n",
      "2.068815535325529\n",
      "2.014151487186758\n",
      "1.9254726697265399\n",
      "1.8409397406991599\n",
      "1.7607565795769058\n",
      "1.7186117551839786\n",
      "1.7006700785207618\n",
      "1.6971875660626827\n",
      "1.647661644223737\n",
      "1.6035336600316514\n",
      "1.5739688900584519\n",
      "1.5243635426981863\n",
      "1.4879670829815497\n",
      "1.4247270990815386\n",
      "1.3998550559012646\n",
      "1.3582643799321175\n",
      "1.3580644848824173\n",
      "1.3503814006249681\n",
      "1.323787301884579\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52c0042c3ff7469da121aa9e578917de",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b6686827bcff4ff6bf0cd0370d579ab4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.289807157074048\n",
      "2.1247384160534533\n",
      "1.7455398660953132\n",
      "1.6752676452178124\n",
      "1.6469033335910475\n",
      "1.619266144400537\n",
      "1.5692742347047066\n",
      "1.5551826003379998\n",
      "1.5277662546571074\n",
      "1.5065565993532584\n",
      "1.4977929596812738\n",
      "1.4930485486535525\n",
      "1.4921486838523341\n",
      "1.4613741966554215\n",
      "1.4485625941252198\n",
      "1.4482112053432592\n",
      "1.4442308097543912\n",
      "1.3900920468660825\n",
      "1.3833110669406752\n",
      "1.3734791061042475\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7b16b52c780f445898497ade493a9dc5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ed3263fd357454a81961d8afdec4ee0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.7217103536346454\n",
      "2.074520058079494\n",
      "1.9457252792406003\n",
      "1.8381846650583884\n",
      "1.7902194359075991\n",
      "1.7706548995468507\n",
      "1.7081602942926108\n",
      "1.6807635862006935\n",
      "1.6399871531875048\n",
      "1.5654322567830377\n",
      "1.549073469543986\n",
      "1.5260531679163944\n",
      "1.5214311644954002\n",
      "1.5074080821249003\n",
      "1.4767547793722502\n",
      "1.4676558745180464\n",
      "1.4542161959561586\n",
      "1.4473018270307063\n",
      "1.4460936973026728\n",
      "1.4331707156892997\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4c7f9e5c78544199b4df0709bba70960",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c9713162cccb4ab48d3a4d57c55c8404",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8759647525480918\n",
      "1.6626367375481081\n",
      "1.6441862330494579\n",
      "1.5635152111483184\n",
      "1.525127822987958\n",
      "1.495302614930617\n",
      "1.4275587357739983\n",
      "1.377008179685238\n",
      "1.3589833565394562\n",
      "1.3490539300100166\n",
      "1.3359131750122086\n",
      "1.3237513507226526\n",
      "1.3044143358580766\n",
      "1.2776343640104717\n",
      "1.249636029867538\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e8073427b9534242b4750ce7465bbf76",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7610b50b07834730b2a54667f1c23f75",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0208624589498023\n",
      "2.36717136852326\n",
      "2.079986920668971\n",
      "1.9104394491581247\n",
      "1.7735344680091554\n",
      "1.6665089826289001\n",
      "1.652842550595414\n",
      "1.5729794071211844\n",
      "1.529273673278022\n",
      "1.4989145718142096\n",
      "1.4750704117012496\n",
      "1.4395787453289963\n",
      "1.429615463344367\n",
      "1.4174768667614774\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d8ad4310403b4f4e97a1303990d5332c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a8589884772043a69667427c699b55a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.442296158319279\n",
      "2.118564033927657\n",
      "2.0952793837605856\n",
      "2.072149629117616\n",
      "2.037780180767393\n",
      "1.8804171153285456\n",
      "1.7920204630535168\n",
      "1.6671171522877208\n",
      "1.5621589721024833\n",
      "1.5126522483291291\n",
      "1.5065821262258972\n",
      "1.5055541197344733\n",
      "1.5024678881327664\n",
      "1.4954308972718553\n",
      "1.4774602836736046\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8c9a2e9608a9437bb4c5c97fa50d2da5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22a9ef784f6340409c44fe2a26c8100c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.244459892006319\n",
      "2.2125773948907637\n",
      "2.145400384150295\n",
      "2.0922676991476528\n",
      "2.077041135254518\n",
      "2.0691910562491005\n",
      "2.068576829780089\n",
      "2.0633615266440084\n",
      "2.0483608675614997\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "305f6f9f26614c82bd430b3a973e9e19",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "60bc7b410186460093622c02980d1083",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.510082242692972\n",
      "2.119262773254372\n",
      "2.0525628840774868\n",
      "1.9733432755136824\n",
      "1.7586608662712742\n",
      "1.7360814162282383\n",
      "1.6518055362163402\n",
      "1.6163332195478923\n",
      "1.5979231899966195\n",
      "1.5822042053947605\n",
      "1.5526236713581536\n",
      "1.5115239503034232\n",
      "1.4975539497150132\n",
      "1.47417930303045\n",
      "1.4585537302219043\n",
      "1.44983635612046\n",
      "1.4386398700086527\n",
      "1.433152222532711\n",
      "1.4280607118889714\n",
      "1.3774978599187329\n",
      "1.3630514114336267\n",
      "1.3345326967953315\n",
      "1.3010809731670991\n",
      "1.2534080712191635\n",
      "1.2397631078527314\n",
      "1.2263408600907213\n",
      "1.2183339959400694\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e8f31f1154d740069dab09bbe7488f46",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b7dac55ee654a42a5fca31031a33f92",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.406385465945386\n",
      "2.2765600734422122\n",
      "2.089817866215952\n",
      "1.8932903903933995\n",
      "1.7528851968668837\n",
      "1.665645788074467\n",
      "1.640887820004751\n",
      "1.6298383614007605\n",
      "1.6186722420231323\n",
      "1.609325243630616\n",
      "1.55501438990352\n",
      "1.544793616967955\n",
      "1.5192483263115495\n",
      "1.4949276566733267\n",
      "1.4642738185465878\n",
      "1.4421707881786157\n",
      "1.4284909224754492\n",
      "1.4124389185176112\n",
      "1.4094603957299865\n",
      "1.4090246612459612\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e8ef70dc6bb345f1b7e9d47f40db3e89",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ed2ed6269e24875aebb815acfcc1379",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5155766862477744\n",
      "2.1118106381910358\n",
      "1.9877283938899954\n",
      "1.7271361089985928\n",
      "1.5755474307741035\n",
      "1.4366467727098433\n",
      "1.4152346389548829\n",
      "1.368905245166827\n",
      "1.3431280102996752\n",
      "1.3341132648412444\n",
      "1.3293872287073156\n",
      "1.3146112287867233\n",
      "1.300832595021333\n",
      "1.29992024256105\n",
      "1.283199266417951\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94e839e656bf4cbcaf8f0ee00bb6c7e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_times = 1\n",
    "\n",
    "for n_convs in [1, 3, 5]:\n",
    "    for n_channels in [64, 512]:\n",
    "        row = []\n",
    "        #########################\n",
    "        scores = []\n",
    "        for _ in range(n_times):\n",
    "            m =  GraphNeuralNetwork(n_channels, n_convs=n_convs, features_after_layer=26)\n",
    "\n",
    "            m = train_best(m, train_loader1, valid_loader1, 70)\n",
    "            predictions, att = predict(m, test_loader1)\n",
    "            rmse_score = rmse(y_test, predictions.flatten())\n",
    "            scores.append(\"{:.2f}\".format(rmse_score))\n",
    "        row.append(\" | \".join(scores))\n",
    "\n",
    "        #########################\n",
    "        scores = []\n",
    "        for _ in range(n_times):\n",
    "            m =  GraphNeuralNetwork(n_channels, n_convs=n_convs, features_after_layer=25)\n",
    "\n",
    "            m = train_best(m, train_loader10, valid_loader10, 70)\n",
    "            predictions, att = predict(m, test_loader10)\n",
    "            rmse_score = rmse(y_test, predictions.flatten())\n",
    "            scores.append(\"{:.2f}\".format(rmse_score))\n",
    "        row.append(\" | \".join(scores))\n",
    "\n",
    "        #########################\n",
    "        for vect_size in [3, 35, 100]:\n",
    "            scores = []\n",
    "            for _ in range(n_times):\n",
    "                m =  GraphNeuralNetwork(n_channels, n_convs=n_convs, my_layer=MyAttentionModule4(vect_size), features_after_layer=vect_size)\n",
    "\n",
    "                m.myAttentionModule.load_state_dict(torch.load('attention_pooling' + str(vect_size) + '.pth'))\n",
    "                m.eval()\n",
    "                for par in m.myAttentionModule.parameters():\n",
    "                        par.requires_grad = False\n",
    "\n",
    "                m = train_best(m, train_loader, valid_loader, 70)\n",
    "                predictions, att = predict(m, test_loader)\n",
    "                rmse_score = rmse(y_test, predictions.flatten())\n",
    "                scores.append(\"{:.2f}\".format(rmse_score))\n",
    "            row.append(\" | \".join(scores))\n",
    "\n",
    "        #########################\n",
    "        scores = []\n",
    "        for _ in range(n_times):\n",
    "            m =  GraphNeuralNetwork(n_channels, n_convs=n_convs, my_layer=MyAttentionModule4(35), features_after_layer=35)\n",
    "\n",
    "            m.myAttentionModule.load_state_dict(torch.load('attention_pooling35_big.pth'))\n",
    "            m.eval()\n",
    "            for par in m.myAttentionModule.parameters():\n",
    "                    par.requires_grad = False\n",
    "\n",
    "            m = train_best(m, train_loader, valid_loader, 70)\n",
    "            predictions, att = predict(m, test_loader)\n",
    "            rmse_score = rmse(y_test, predictions.flatten())\n",
    "            scores.append(\"{:.2f}\".format(rmse_score))\n",
    "        row.append(\" | \".join(scores))\n",
    "\n",
    "        df.loc[str(n_convs) + \" convs, \" + str(n_channels) + \" channels\"] = row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Repr 1</th>\n",
       "      <th>Repr 10</th>\n",
       "      <th>transfer learning - size = 3</th>\n",
       "      <th>transfer learning - size = 35</th>\n",
       "      <th>transfer learning - size = 100</th>\n",
       "      <th>transfer learning - size = 35 (big)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1 convs, 64 channels</th>\n",
       "      <td>1.49</td>\n",
       "      <td>1.48</td>\n",
       "      <td>2.33</td>\n",
       "      <td>1.64</td>\n",
       "      <td>1.56</td>\n",
       "      <td>1.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1 convs, 512 channels</th>\n",
       "      <td>1.48</td>\n",
       "      <td>1.48</td>\n",
       "      <td>2.35</td>\n",
       "      <td>1.62</td>\n",
       "      <td>1.53</td>\n",
       "      <td>1.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3 convs, 64 channels</th>\n",
       "      <td>1.37</td>\n",
       "      <td>1.40</td>\n",
       "      <td>1.71</td>\n",
       "      <td>1.58</td>\n",
       "      <td>1.52</td>\n",
       "      <td>1.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3 convs, 512 channels</th>\n",
       "      <td>1.44</td>\n",
       "      <td>1.45</td>\n",
       "      <td>2.14</td>\n",
       "      <td>1.46</td>\n",
       "      <td>1.55</td>\n",
       "      <td>1.17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5 convs, 64 channels</th>\n",
       "      <td>1.46</td>\n",
       "      <td>1.46</td>\n",
       "      <td>1.40</td>\n",
       "      <td>1.52</td>\n",
       "      <td>1.51</td>\n",
       "      <td>1.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5 convs, 512 channels</th>\n",
       "      <td>1.52</td>\n",
       "      <td>1.56</td>\n",
       "      <td>2.34</td>\n",
       "      <td>1.29</td>\n",
       "      <td>1.45</td>\n",
       "      <td>1.28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      Repr 1 Repr 10 transfer learning - size = 3   \n",
       "1 convs, 64 channels    1.49    1.48                         2.33  \\\n",
       "1 convs, 512 channels   1.48    1.48                         2.35   \n",
       "3 convs, 64 channels    1.37    1.40                         1.71   \n",
       "3 convs, 512 channels   1.44    1.45                         2.14   \n",
       "5 convs, 64 channels    1.46    1.46                         1.40   \n",
       "5 convs, 512 channels   1.52    1.56                         2.34   \n",
       "\n",
       "                      transfer learning - size = 35   \n",
       "1 convs, 64 channels                           1.64  \\\n",
       "1 convs, 512 channels                          1.62   \n",
       "3 convs, 64 channels                           1.58   \n",
       "3 convs, 512 channels                          1.46   \n",
       "5 convs, 64 channels                           1.52   \n",
       "5 convs, 512 channels                          1.29   \n",
       "\n",
       "                      transfer learning - size = 100   \n",
       "1 convs, 64 channels                            1.56  \\\n",
       "1 convs, 512 channels                           1.53   \n",
       "3 convs, 64 channels                            1.52   \n",
       "3 convs, 512 channels                           1.55   \n",
       "5 convs, 64 channels                            1.51   \n",
       "5 convs, 512 channels                           1.45   \n",
       "\n",
       "                      transfer learning - size = 35 (big)  \n",
       "1 convs, 64 channels                                 1.35  \n",
       "1 convs, 512 channels                                1.35  \n",
       "3 convs, 64 channels                                 1.30  \n",
       "3 convs, 512 channels                                1.17  \n",
       "5 convs, 64 channels                                 1.25  \n",
       "5 convs, 512 channels                                1.28  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4962a3a8671e4504a7cb1c4f7efcb9f2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3655222600643584\n",
      "2.1522534478454642\n",
      "1.9321602654377317\n",
      "1.7427049183001957\n",
      "1.6375673789358671\n",
      "1.5013309329953834\n",
      "1.380769958293459\n",
      "1.3650897134731423\n",
      "1.3495792890871938\n",
      "1.3324222014567297\n",
      "1.3257246624602181\n",
      "1.296787756954208\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3fbc438d0e444c0986ba3ebe27795af6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE = 1.37\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AtomicNum</th>\n",
       "      <th>Degree</th>\n",
       "      <th>TotalNumHs</th>\n",
       "      <th>ImplicitValence</th>\n",
       "      <th>Hybridization</th>\n",
       "      <th>FormalCharge</th>\n",
       "      <th>IsInRing</th>\n",
       "      <th>IsAromatic</th>\n",
       "      <th>NumRadicalElectrons</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.16</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.09</td>\n",
       "      <td>0.19</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.13</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.16</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.16</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.16</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AtomicNum  Degree  TotalNumHs  ImplicitValence  Hybridization   \n",
       "0       0.11    0.11        0.11             0.16           0.11  \\\n",
       "1       0.09    0.19        0.09             0.13           0.09   \n",
       "2       0.11    0.11        0.11             0.11           0.11   \n",
       "3       0.11    0.11        0.11             0.16           0.11   \n",
       "4       0.11    0.11        0.11             0.16           0.11   \n",
       "\n",
       "   FormalCharge  IsInRing  IsAromatic  NumRadicalElectrons  \n",
       "0          0.11      0.11        0.11                 0.11  \n",
       "1          0.09      0.16        0.09                 0.09  \n",
       "2          0.11      0.11        0.11                 0.11  \n",
       "3          0.11      0.11        0.11                 0.11  \n",
       "4          0.11      0.11        0.11                 0.11  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m =  GraphNeuralNetwork(n_channels, n_convs=n_convs, my_layer=MyAttentionModule4(35), features_after_layer=35)\n",
    "\n",
    "m.myAttentionModule.load_state_dict(torch.load('attention_pooling35_big.pth'))\n",
    "for par in m.myAttentionModule.parameters():\n",
    "        par.requires_grad = False\n",
    "\n",
    "m = train_best(m, train_loader, valid_loader, 70)\n",
    "predictions, att = predict(m, test_loader)\n",
    "rmse_score = rmse(y_test, predictions.flatten())\n",
    "###################### atencja #################################\n",
    "\n",
    "df_single = pd.DataFrame({\"AtomicNum\": [], \"Degree\": [], \"TotalNumHs\": [], \"ImplicitValence\": [], \"Hybridization\": [], \"FormalCharge\": [],\n",
    "                          \"IsInRing\": [], \"IsAromatic\": [], \"NumRadicalElectrons\": []})\n",
    "df_single.style.set_caption(\"Hello World\")\n",
    "\n",
    "df_batch = pd.DataFrame({\"AtomicNum\": [], \"Degree\": [], \"TotalNumHs\": [], \"ImplicitValence\": [], \"Hybridization\": [], \"FormalCharge\": [],\n",
    "                          \"IsInRing\": [], \"IsAromatic\": [], \"NumRadicalElectrons\": []})\n",
    "df_batch.style.set_caption(\"Hello World\")\n",
    "\n",
    "preds_batches = []\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        x, edge_index, batch = data.x, data.edge_index, data.batch\n",
    "        \n",
    "        preds, att = m(x, edge_index, batch)\n",
    "        preds_batches.append(preds.cpu().detach().numpy())\n",
    "        att = att.squeeze()\n",
    "        df_single.loc[len(df_single)] = att[0].tolist()\n",
    "        df_batch.loc[len(df_single)] = torch.mean(gap(att, batch), dim=0).tolist()\n",
    "preds = np.concatenate(preds_batches)\n",
    "\n",
    "rmse_score = rmse(y_test, predictions.flatten())\n",
    "\n",
    "print(f'RMSE = {rmse_score:.2f}')\n",
    "df_single[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AtomicNum</th>\n",
       "      <th>Degree</th>\n",
       "      <th>TotalNumHs</th>\n",
       "      <th>ImplicitValence</th>\n",
       "      <th>Hybridization</th>\n",
       "      <th>FormalCharge</th>\n",
       "      <th>IsInRing</th>\n",
       "      <th>IsAromatic</th>\n",
       "      <th>NumRadicalElectrons</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.09</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.20</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.12</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.09</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.20</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.12</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.09</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.20</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.12</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.09</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.20</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.13</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.09</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.21</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AtomicNum  Degree  TotalNumHs  ImplicitValence  Hybridization   \n",
       "1       0.09    0.15        0.09             0.20           0.09  \\\n",
       "2       0.09    0.15        0.09             0.20           0.09   \n",
       "3       0.09    0.15        0.09             0.20           0.09   \n",
       "4       0.09    0.15        0.09             0.20           0.09   \n",
       "5       0.09    0.15        0.09             0.21           0.09   \n",
       "\n",
       "   FormalCharge  IsInRing  IsAromatic  NumRadicalElectrons  \n",
       "1          0.09      0.12        0.09                 0.09  \n",
       "2          0.09      0.12        0.09                 0.09  \n",
       "3          0.09      0.12        0.09                 0.09  \n",
       "4          0.09      0.13        0.09                 0.09  \n",
       "5          0.09      0.11        0.09                 0.09  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_batch[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Repr 1</th>\n",
       "      <th>Repr 10</th>\n",
       "      <th>transfer learning - size = 3</th>\n",
       "      <th>transfer learning - size = 35</th>\n",
       "      <th>transfer learning - size = 100</th>\n",
       "      <th>transfer learning - size = 35 (big)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1 convs, 64 channels</th>\n",
       "      <td>1.49</td>\n",
       "      <td>1.48</td>\n",
       "      <td>2.33</td>\n",
       "      <td>1.64</td>\n",
       "      <td>1.56</td>\n",
       "      <td>1.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1 convs, 512 channels</th>\n",
       "      <td>1.48</td>\n",
       "      <td>1.48</td>\n",
       "      <td>2.35</td>\n",
       "      <td>1.62</td>\n",
       "      <td>1.53</td>\n",
       "      <td>1.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3 convs, 64 channels</th>\n",
       "      <td>1.37</td>\n",
       "      <td>1.40</td>\n",
       "      <td>1.71</td>\n",
       "      <td>1.58</td>\n",
       "      <td>1.52</td>\n",
       "      <td>1.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3 convs, 512 channels</th>\n",
       "      <td>1.44</td>\n",
       "      <td>1.45</td>\n",
       "      <td>2.14</td>\n",
       "      <td>1.46</td>\n",
       "      <td>1.55</td>\n",
       "      <td>1.17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5 convs, 64 channels</th>\n",
       "      <td>1.46</td>\n",
       "      <td>1.46</td>\n",
       "      <td>1.40</td>\n",
       "      <td>1.52</td>\n",
       "      <td>1.51</td>\n",
       "      <td>1.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5 convs, 512 channels</th>\n",
       "      <td>1.52</td>\n",
       "      <td>1.56</td>\n",
       "      <td>2.34</td>\n",
       "      <td>1.29</td>\n",
       "      <td>1.45</td>\n",
       "      <td>1.28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      Repr 1 Repr 10 transfer learning - size = 3   \n",
       "1 convs, 64 channels    1.49    1.48                         2.33  \\\n",
       "1 convs, 512 channels   1.48    1.48                         2.35   \n",
       "3 convs, 64 channels    1.37    1.40                         1.71   \n",
       "3 convs, 512 channels   1.44    1.45                         2.14   \n",
       "5 convs, 64 channels    1.46    1.46                         1.40   \n",
       "5 convs, 512 channels   1.52    1.56                         2.34   \n",
       "\n",
       "                      transfer learning - size = 35   \n",
       "1 convs, 64 channels                           1.64  \\\n",
       "1 convs, 512 channels                          1.62   \n",
       "3 convs, 64 channels                           1.58   \n",
       "3 convs, 512 channels                          1.46   \n",
       "5 convs, 64 channels                           1.52   \n",
       "5 convs, 512 channels                          1.29   \n",
       "\n",
       "                      transfer learning - size = 100   \n",
       "1 convs, 64 channels                            1.56  \\\n",
       "1 convs, 512 channels                           1.53   \n",
       "3 convs, 64 channels                            1.52   \n",
       "3 convs, 512 channels                           1.55   \n",
       "5 convs, 64 channels                            1.51   \n",
       "5 convs, 512 channels                           1.45   \n",
       "\n",
       "                      transfer learning - size = 35 (big)  \n",
       "1 convs, 64 channels                                 1.35  \n",
       "1 convs, 512 channels                                1.35  \n",
       "3 convs, 64 channels                                 1.30  \n",
       "3 convs, 512 channels                                1.17  \n",
       "5 convs, 64 channels                                 1.25  \n",
       "5 convs, 512 channels                                1.28  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mldd23",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}