project_esol_final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "043917a7983746eb84e2de28b874f306",
       "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": [
      "3.54\n"
     ]
    }
   ],
   "source": [
    "# predictions, att = predict(m, test_loader)\n",
    "# rmse_score = rmse(y_test, predictions.flatten())\n",
    "# print(\"{:.2f}\".format(rmse_score))\n",
    "\n",
    "\n",
    "m =  GraphNeuralNetwork(512, n_convs=3, features_after_layer=25)\n",
    "predictions, att = predict(m, test_loader10)\n",
    "rmse_score = rmse(y_test, predictions.flatten())\n",
    "print(\"{:.2f}\".format(rmse_score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ebde7f9161948c2a6e69f279e431987",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.6712835920560094\n",
      "2.322532194161142\n",
      "2.130964256371969\n",
      "2.0608123964914147\n",
      "2.0376241288849055\n",
      "2.035577642036662\n",
      "2.0221199558082232\n",
      "2.0169706751730123\n",
      "2.0112657127524183\n",
      "1.8898615673308132\n",
      "1.8718627059937472\n",
      "1.7938717731917218\n",
      "1.7447093354126648\n",
      "1.7380891869631108\n",
      "1.699327798455553\n",
      "1.671769369832549\n",
      "1.6456160577834786\n",
      "1.5953693119107528\n",
      "1.5729847633125038\n",
      "1.4867824964400254\n",
      "1.4624101294384269\n",
      "1.4207422309405364\n",
      "1.4156215835136523\n",
      "1.408628694426735\n",
      "1.389991701345296\n",
      "1.3720380930843719\n",
      "1.363474392206617\n",
      "1.360000157775021\n",
      "1.3493674276721848\n",
      "1.3350516672416448\n",
      "1.3336672444097015\n",
      "1.3325064511095237\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "440da48a3de14c79b2b1253937e2cbea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0619514521279947\n",
      "2.7885748909253008\n",
      "2.278639121705403\n",
      "1.959941030227233\n",
      "1.7001796691055957\n",
      "1.6348566966137121\n",
      "1.5557872962118802\n",
      "1.4738320132503155\n",
      "1.446071695826923\n",
      "1.4289253611178774\n",
      "1.4236201971647526\n",
      "1.3987637718229124\n",
      "1.3721275378935227\n",
      "1.3653570328557267\n",
      "1.3447809056086764\n",
      "1.3410760252767164\n",
      "1.3353188487790795\n",
      "1.3175002850933213\n",
      "1.3093608449388314\n",
      "1.2988850564037366\n",
      "1.2932647213929254\n",
      "1.2759502800902116\n",
      "1.2748651066075736\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "773f7abc9f924c0a8c728e630280751a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4248614617358384\n",
      "2.2417864532819123\n",
      "1.9377127958067846\n",
      "1.8172015575559735\n",
      "1.7376216730066372\n",
      "1.6043495974010271\n",
      "1.5071078768211192\n",
      "1.4640979749398828\n",
      "1.4580783053861162\n",
      "1.4262510464318545\n",
      "1.4020451464238373\n",
      "1.3700631070043667\n",
      "1.3573055806833456\n",
      "1.353575867294848\n",
      "1.3136685839197957\n",
      "1.2999142229986083\n",
      "1.2912822580199468\n",
      "1.2769142918356098\n",
      "1.2383999337835876\n",
      "1.2284916477527832\n",
      "1.2265429540132555\n",
      "1.1538638353389448\n",
      "1.1371895540931685\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "GraphNeuralNetwork(\n",
       "  (myAttentionModule): MyAttentionModule4(\n",
       "    (gates): ModuleDict(\n",
       "      (AtomicNum): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=12, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (Degree): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=6, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (TotalNumHs): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=5, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (ImplicitValence): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=6, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (Hybridization): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=5, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (FormalCharge): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (IsInRing): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (IsAromatic): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "      (NumRadicalElectrons): GINConv(nn=Sequential(\n",
       "        (0): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (1): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU()\n",
       "        (3): Linear(in_features=1, out_features=1, bias=True)\n",
       "        (4): ReLU()\n",
       "      ))\n",
       "    )\n",
       "    (feats): ModuleDict(\n",
       "      (AtomicNum): Linear(in_features=12, out_features=100, bias=True)\n",
       "      (Degree): Linear(in_features=6, out_features=100, bias=True)\n",
       "      (TotalNumHs): Linear(in_features=5, out_features=100, bias=True)\n",
       "      (ImplicitValence): Linear(in_features=6, out_features=100, bias=True)\n",
       "      (Hybridization): Linear(in_features=5, out_features=100, bias=True)\n",
       "      (FormalCharge): Linear(in_features=1, out_features=100, bias=True)\n",
       "      (IsInRing): Linear(in_features=1, out_features=100, bias=True)\n",
       "      (IsAromatic): Linear(in_features=1, out_features=100, bias=True)\n",
       "      (NumRadicalElectrons): Linear(in_features=1, out_features=100, bias=True)\n",
       "    )\n",
       "  )\n",
       "  (convs): ModuleList(\n",
       "    (0): GCNConv(100, 512)\n",
       "    (1): GCNConv(512, 512)\n",
       "    (2): GCNConv(512, 512)\n",
       "  )\n",
       "  (linear): Linear(in_features=512, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "######################## wizualizacje #################################################\n",
    "m = GraphNeuralNetwork(512, my_layer=MyAttentionModule4(3), features_after_layer=3)\n",
    "visualize(m, train_loader, valid_loader, test_loader, epochs=100, saveImg=True, title=\"MyAttentionModule4(3)_esol\")\n",
    "\n",
    "m = GraphNeuralNetwork(512, my_layer=MyAttentionModule4(35), features_after_layer=35)\n",
    "visualize(m, train_loader, valid_loader, test_loader, epochs=100, saveImg=True, title=\"MyAttentionModule4(35)_esol\")\n",
    "\n",
    "m = GraphNeuralNetwork(512, my_layer=MyAttentionModule4(100), features_after_layer=100)\n",
    "visualize(m, train_loader, valid_loader, test_loader, epochs=100, saveImg=True, title=\"MyAttentionModule4(100)_esol\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e071e8ffe7ca40bb935637bca04c6ef7",
       "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.9507153235632513\n",
      "1.9336070765198485\n",
      "1.8020398369157058\n",
      "1.7451619325818972\n",
      "1.7217920955216837\n",
      "1.6459449869575147\n",
      "1.6063797811148937\n",
      "1.5136445502637543\n",
      "1.5069087194759647\n",
      "1.4623850255994166\n",
      "1.4602010399483347\n",
      "1.4430459117954815\n",
      "1.4060155950246973\n",
      "1.3979096665072175\n",
      "1.3959800161115443\n",
      "1.3834560199754853\n",
      "1.3503205421283928\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4adedad962d149fdbdd5940b9ffcda13",
       "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": "f6f4dfb7d3c8421cacb73ce461033b9b",
       "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.040449674607077\n",
      "1.9990387934464975\n",
      "1.9314496636167051\n",
      "1.7771565661091726\n",
      "1.701324785364343\n",
      "1.6449128343178203\n",
      "1.6109751994019226\n",
      "1.5257622608714696\n",
      "1.4903172879242397\n",
      "1.46389018306975\n",
      "1.4342442096364971\n",
      "1.397287399774622\n",
      "1.3715533322501603\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32005bf256374df395161a3d5502b73e",
       "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": "faaff767057f417bb99cc8f80686acf8",
       "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.690163815159509\n",
      "2.270544453609616\n",
      "1.9940338680327325\n",
      "1.9727552282176881\n",
      "1.934984344747194\n",
      "1.899994970547648\n",
      "1.860774170773132\n",
      "1.8342236603308848\n",
      "1.8026550134903743\n",
      "1.7859236751545502\n",
      "1.770756387684595\n",
      "1.7616279356368132\n",
      "1.737797189950935\n",
      "1.7058093369041187\n",
      "1.6952512426491542\n",
      "1.6402220687272313\n",
      "1.6128092613866887\n",
      "1.5870159294326989\n",
      "1.5452800177313064\n",
      "1.5179611292224786\n",
      "1.4947919375634686\n",
      "1.4666263418214074\n",
      "1.4590299178619863\n",
      "1.4587807553520309\n",
      "1.4330621721513201\n",
      "1.4310922313807626\n",
      "1.422751201563501\n",
      "1.397723193784015\n",
      "1.388677371867467\n",
      "1.3810083281699392\n",
      "1.3684451620957463\n",
      "1.3610942889778594\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d1a2c3fc62be4aa98b04adc4ec6ddf37",
       "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": "f1f7e88b0aa341059b09541245a5739c",
       "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.2058123620147683\n",
      "2.108326334777673\n",
      "1.9423605336162895\n",
      "1.8425389343921035\n",
      "1.7288628260983714\n",
      "1.6416160013292886\n",
      "1.6407796348134582\n",
      "1.5590929839813341\n",
      "1.5479750163411492\n",
      "1.5390583031751188\n",
      "1.522839751037504\n",
      "1.5006555240408193\n",
      "1.4884594647922222\n",
      "1.4739670834060012\n",
      "1.466810690189429\n",
      "1.4433470263355017\n",
      "1.3939705548305954\n",
      "1.3884410645788892\n",
      "1.3744770465709468\n",
      "1.3696294726556237\n",
      "1.3531780102166269\n",
      "1.3459221967777424\n",
      "1.3361875605796847\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9b0da17e25f04065bdda5408dc2b65b4",
       "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": "859e126f77bf4e75911d599eca05d017",
       "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.06041886335484\n",
      "1.9812661805517087\n",
      "1.8956192670799894\n",
      "1.8249309493999133\n",
      "1.7975369235561747\n",
      "1.6644309032934883\n",
      "1.6097761291018462\n",
      "1.6004326862692304\n",
      "1.5627985120822754\n",
      "1.4844340905920417\n",
      "1.4467170963365799\n",
      "1.4048022080878009\n",
      "1.4038943290017987\n",
      "1.390304199940757\n",
      "1.3898626340732914\n",
      "1.3742956951523768\n",
      "1.3502070595781615\n",
      "1.330506902303553\n",
      "1.3278962916708144\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45534065de4a42b08402b627d1b552ce",
       "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": "048efce076ba49f6a45dc27cc9fe8535",
       "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.936115760155548\n",
      "1.9157316440775218\n",
      "1.6773406408079208\n",
      "1.5308898842749745\n",
      "1.5105765422785449\n",
      "1.4400990577355255\n",
      "1.4271868870790174\n",
      "1.3852198214977192\n",
      "1.3741617388049423\n",
      "1.3709232702533882\n",
      "1.362969987254123\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "28ad44a91831401a9eeb7bd09bd5c8d9",
       "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": "139fc7e1060e4be29744333aac5b418b",
       "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.8643803853319847\n",
      "1.7748274011914371\n",
      "1.5795396995499744\n",
      "1.4764933341941373\n",
      "1.4505314656895476\n",
      "1.449635345075455\n",
      "1.445715666330841\n",
      "1.4384517330996218\n",
      "1.4069882735653705\n",
      "1.3983750056013171\n",
      "1.3911827494205207\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1eae21033e345f2b065baa2c882276c",
       "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": "061508ccc72942e4ac41603924b2a090",
       "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.4980291535961863\n",
      "2.1856174220330282\n",
      "1.9671087732714905\n",
      "1.9437312589388138\n",
      "1.9049592155225756\n",
      "1.878839102151777\n",
      "1.8536757210899935\n",
      "1.850519593518621\n",
      "1.832922805702778\n",
      "1.750067262260857\n",
      "1.7044612693457921\n",
      "1.6194761576587717\n",
      "1.6154067035100588\n",
      "1.5670701477519735\n",
      "1.5593298612250344\n",
      "1.5063981639664978\n",
      "1.4802819383406312\n",
      "1.460958559595057\n",
      "1.413291130651131\n",
      "1.3973993990044586\n",
      "1.3939066637041915\n",
      "1.3713114562836526\n",
      "1.3617410535616512\n",
      "1.3561524420405053\n",
      "1.3551033033770505\n",
      "1.3338489956829997\n",
      "1.329722063481119\n",
      "1.319827986372981\n",
      "1.3101208570521\n",
      "1.3030588080779746\n",
      "1.2875402125868314\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f231fac5e0db489eb481dae08306e61d",
       "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": "71c1223eee434eb993bcf1d05c29efbc",
       "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.198855703376565\n",
      "1.9083248532572572\n",
      "1.9057681694839366\n",
      "1.8284427040674072\n",
      "1.769716736424676\n",
      "1.6801426032910507\n",
      "1.6001127577246639\n",
      "1.4946302527672681\n",
      "1.4487989702966206\n",
      "1.3942801184622422\n",
      "1.3670773456855574\n",
      "1.36497797119824\n",
      "1.3578466637713416\n",
      "1.3420186370809994\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32966f43891241c292f7eb20575d8347",
       "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": "07f3021c31034b26ab483f6077dfb71b",
       "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.196872764133579\n",
      "1.985070880030359\n",
      "1.8029430419990482\n",
      "1.7446481161794951\n",
      "1.6894295617115545\n",
      "1.6311588570636322\n",
      "1.5066950036317592\n",
      "1.41723939269863\n",
      "1.4060188049494906\n",
      "1.384407661575802\n",
      "1.3680763982383535\n",
      "1.3675013824379156\n",
      "1.361047143041858\n",
      "1.3493701577801291\n",
      "1.3320351583017773\n",
      "1.3064851804692894\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4a457ff5405d417cb5feac4ed6186107",
       "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": "105b695ce9b545b4801d4fb6e7cebaf0",
       "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.126309205203446\n",
      "1.864782025223601\n",
      "1.738336437358322\n",
      "1.6342229920002196\n",
      "1.5405349332030227\n",
      "1.4649649320610394\n",
      "1.4262729470821032\n",
      "1.4047561932191155\n",
      "1.401182616894402\n",
      "1.387945550021808\n",
      "1.3792988539059732\n",
      "1.3607168034625619\n",
      "1.3589577600027698\n",
      "1.3585872722999426\n",
      "1.3446514262714169\n",
      "1.3422339605516644\n",
      "1.3421369008943456\n",
      "1.3394623931415675\n",
      "1.3348557137175778\n",
      "1.3247574682830638\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a788289371540dab939f78f7ac25648",
       "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": "657152010145451bb577e94134235979",
       "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.1958081399302296\n",
      "2.0579795936672056\n",
      "1.816715709715082\n",
      "1.6489205637272382\n",
      "1.5666839302288664\n",
      "1.4802335527714285\n",
      "1.4796771952581933\n",
      "1.4767478069981235\n",
      "1.4138527332061372\n",
      "1.394100925391277\n",
      "1.3807341862307887\n",
      "1.3710267476677906\n",
      "1.358764530927332\n",
      "1.3418697172281728\n",
      "1.3284784659784101\n",
      "1.325133665316316\n",
      "1.2916621882643473\n",
      "1.261846832024197\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0bc4c6caa40047ee81a71559b22ebb07",
       "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": "ca4de6d28af04f6db99489e6b4b03e6d",
       "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.033348833462704\n",
      "1.9876776987666809\n",
      "1.933019024173618\n",
      "1.7076210038809039\n",
      "1.6791880816492482\n",
      "1.5594528320829937\n",
      "1.5094001668550758\n",
      "1.4305005719388217\n",
      "1.4234606052234264\n",
      "1.4163100610314847\n",
      "1.4040508536155774\n",
      "1.3953551147821421\n",
      "1.3785014768214283\n",
      "1.3772456833641968\n",
      "1.3617958125507716\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6897b7b1fa7f4413b2e9a682f0c14e81",
       "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": "6001cfd8e79c41e5b522a678b65b5789",
       "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.154742454372726\n",
      "1.9143701014877719\n",
      "1.7928688391457488\n",
      "1.7032417923589058\n",
      "1.6410751509244437\n",
      "1.5085857475819884\n",
      "1.454542536578278\n",
      "1.448898257632102\n",
      "1.444662094113019\n",
      "1.443578328202585\n",
      "1.4270989912775496\n",
      "1.4190686837130566\n",
      "1.402595560542792\n",
      "1.3870367169678721\n",
      "1.3760921584398709\n",
      "1.3688702190900965\n",
      "1.3498344458272884\n",
      "1.3431434369805502\n",
      "1.28646303544707\n",
      "1.27992439982852\n",
      "1.2478308368862268\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "027cb29a8db44c388f6e82e2c2d70b04",
       "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": "ef60277a695d45a1824bcba84204fbdb",
       "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.5756894353277073\n",
      "1.8932578631502783\n",
      "1.8258272650163\n",
      "1.747286112168328\n",
      "1.6742208274294754\n",
      "1.6098838873164996\n",
      "1.552673323392773\n",
      "1.4829229381536282\n",
      "1.4797123174120645\n",
      "1.460727110290447\n",
      "1.45787647947848\n",
      "1.4541821138124846\n",
      "1.4429731898915672\n",
      "1.428449277175453\n",
      "1.4211027011642376\n",
      "1.4179777398119502\n",
      "1.3820740991695473\n",
      "1.37634181749966\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "473f1fba1c8d4d7aaea37736334e0ab7",
       "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": "28156dd33e5e4986a0e458e7fc570859",
       "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.389347381049767\n",
      "1.892593250471659\n",
      "1.7567953936117018\n",
      "1.6809445522393776\n",
      "1.5474778241600646\n",
      "1.4859786818490548\n",
      "1.469259472080138\n",
      "1.4415511678894941\n",
      "1.429821427957469\n",
      "1.4114728730217598\n",
      "1.38634183295939\n",
      "1.3853056823486\n",
      "1.382740056686463\n",
      "1.3785763792682426\n",
      "1.3762642657207962\n",
      "1.3515808483108083\n",
      "1.3470017721174088\n",
      "1.3454005194188055\n",
      "1.3448447360406874\n",
      "1.3354925951183996\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ff8fd1991b144bb987862ff01add82c3",
       "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": "e8eda8cd5b8b4cb188d345d0377edcba",
       "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.591723212715789\n",
      "2.240687459460229\n",
      "2.0018801489916362\n",
      "1.7657423468182099\n",
      "1.7038389356394354\n",
      "1.6682474793882949\n",
      "1.585055915907317\n",
      "1.526214278440462\n",
      "1.5085205876084726\n",
      "1.5012735297897266\n",
      "1.4879487807313638\n",
      "1.4538736138486308\n",
      "1.4434657424945467\n",
      "1.4130280524112215\n",
      "1.391342430160143\n",
      "1.378065586243266\n",
      "1.3439544558338161\n",
      "1.341414249053825\n",
      "1.3373617403222748\n",
      "1.3216798045384914\n",
      "1.3159865791598122\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4c13246512ae4b509bc20091966b8ce2",
       "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": "5ae184c51ff8476ea4598d63349508a3",
       "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.6848804933918333\n",
      "2.071586912249843\n",
      "2.039980422813888\n",
      "2.014061381602108\n",
      "1.9634588646357953\n",
      "1.8942640780924673\n",
      "1.8393212497272249\n",
      "1.8295751907158708\n",
      "1.8275694954905386\n",
      "1.774773174807732\n",
      "1.72743516779504\n",
      "1.7172263730007464\n",
      "1.7110152690235718\n",
      "1.6945877290561366\n",
      "1.6782696623768814\n",
      "1.6779449770924177\n",
      "1.6669657555637551\n",
      "1.607158759304634\n",
      "1.5533287706918628\n",
      "1.5288383261160965\n",
      "1.524878212626171\n",
      "1.4592234758157665\n",
      "1.451160262456404\n",
      "1.4225529458726764\n",
      "1.4052125779732523\n",
      "1.3881444073545368\n",
      "1.367166076293547\n",
      "1.3627700083616665\n",
      "1.3573764345696135\n",
      "1.3309185266298378\n",
      "1.3256839802504279\n",
      "1.3204453972046213\n",
      "1.3174296392325082\n",
      "1.3151383847444629\n",
      "1.3146889256565504\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6aa16e3930f34fb8a5f842263f4c984d",
       "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": "c0e3a590a6204e0b9de5f843790fdb53",
       "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.8040945417673644\n",
      "2.4159542813892405\n",
      "1.9303559323121797\n",
      "1.7793807108924937\n",
      "1.7388240030778142\n",
      "1.6338677142538678\n",
      "1.5771883812734653\n",
      "1.5310630438881394\n",
      "1.4935642290437814\n",
      "1.467161921950416\n",
      "1.4437828954368679\n",
      "1.4160240472213854\n",
      "1.3556800349796694\n",
      "1.3501053367115585\n",
      "1.3483120167793845\n",
      "1.3394940331038983\n",
      "1.327215840906331\n",
      "1.315096569411165\n",
      "1.3007308918423148\n",
      "1.2884275865870136\n",
      "1.2761287071249425\n",
      "1.2728650038673655\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a298ee2430a14800b33c73a685b817a3",
       "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": "3cc1714c81c44594a9f216f455b1c40c",
       "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.174256958206232\n",
      "2.4594508639304955\n",
      "1.8691894012423305\n",
      "1.763709596079766\n",
      "1.6614088946138819\n",
      "1.6262659959115306\n",
      "1.5765856929484787\n",
      "1.5673615664207545\n",
      "1.533938992780935\n",
      "1.4859037924452472\n",
      "1.4270702610658645\n",
      "1.4167887810706077\n",
      "1.3389428454194807\n",
      "1.3354557449693678\n",
      "1.3009163723207087\n",
      "1.2771716145923149\n",
      "1.2740478734916156\n",
      "1.2668566590290185\n",
      "1.2502747367015714\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "666b20dc7d8e4ec786be0822f6901fa4",
       "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": "40f89b7df6004182b5fd389a6595a9d0",
       "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.7188729877205553\n",
      "1.8991200310147698\n",
      "1.7249811714474699\n",
      "1.657293845718564\n",
      "1.5489746172073828\n",
      "1.525122863775939\n",
      "1.4538297044104862\n",
      "1.4172701068375562\n",
      "1.4127056491301486\n",
      "1.4082218001620526\n",
      "1.3757537988543647\n",
      "1.3670491969827896\n",
      "1.3560644616356972\n",
      "1.3368150426557739\n",
      "1.3305052676980265\n",
      "1.3267314182132546\n",
      "1.3082301702620729\n",
      "1.2729396546262126\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c14cde50dd55448487fb9bcebc333151",
       "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": "ee244d3f6e61466a93776fff429de6b6",
       "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.303457662872839\n",
      "1.8357623265563314\n",
      "1.696953437962782\n",
      "1.5728928929944563\n",
      "1.5242257054170278\n",
      "1.4779989393644077\n",
      "1.467576887105727\n",
      "1.4535075908671846\n",
      "1.425234442957334\n",
      "1.4019771983968714\n",
      "1.3804363371037691\n",
      "1.3489542019503546\n",
      "1.3419107790601366\n",
      "1.329942438803476\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "649bb2d5371c43ff964ec0d3ac69ad50",
       "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": "c78179ee81db47d4bebda65866234432",
       "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.3371943351210884\n",
      "1.9333736823988836\n",
      "1.92663902366117\n",
      "1.9225358080119685\n",
      "1.812400726661587\n",
      "1.763215183094616\n",
      "1.757109887675671\n",
      "1.6590034203947988\n",
      "1.651894914816984\n",
      "1.5927471403060842\n",
      "1.5678049077939786\n",
      "1.5582056329650322\n",
      "1.5550507536813654\n",
      "1.5291133876056435\n",
      "1.468704627321427\n",
      "1.4610399236962759\n",
      "1.4277315667138717\n",
      "1.4117211023223626\n",
      "1.3938708081473743\n",
      "1.382933800175482\n",
      "1.3569921486836791\n",
      "1.3492133921199592\n",
      "1.3393907457508216\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "513814ed2ae442a6bd1b4932351ff5dc",
       "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": "20d8b84b94734e4f8e3c4c07079cbc89",
       "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.053197918579084\n",
      "1.923328452168918\n",
      "1.8141837532263048\n",
      "1.7393610520840288\n",
      "1.7328566564771037\n",
      "1.6379143768802502\n",
      "1.5715171292655927\n",
      "1.5110440913533374\n",
      "1.475099634872489\n",
      "1.41968736153766\n",
      "1.4038402567427075\n",
      "1.3760953897301673\n",
      "1.354880950910239\n",
      "1.3373525507033805\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b67999890a9b4be19da895febada0b59",
       "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": "d5ed47e3820e44fa839063a51d716811",
       "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.2317758857123664\n",
      "2.237727691234442\n",
      "2.134932928900715\n",
      "1.8976151858702566\n",
      "1.8635771720073282\n",
      "1.813847942817427\n",
      "1.7637421826409312\n",
      "1.7181024296589655\n",
      "1.6294011707656686\n",
      "1.618869277422022\n",
      "1.613461915949732\n",
      "1.5631977893391726\n",
      "1.5415072125473406\n",
      "1.506106514349331\n",
      "1.4790338094394575\n",
      "1.4586970706299187\n",
      "1.4468469534696473\n",
      "1.421133344942551\n",
      "1.4024285442983928\n",
      "1.3874712341481317\n",
      "1.3522844683434418\n",
      "1.3257033334926316\n",
      "1.303961682488742\n",
      "1.3015682298543843\n",
      "1.2945323561541755\n",
      "1.2892532529947214\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0443b3fecf3d41d9b1e783e1cd94daec",
       "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": "c6fc2d004fb64a2bafaa93f70bafcaa6",
       "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.2883479468962657\n",
      "2.3733152260898023\n",
      "2.161604546445929\n",
      "2.0885896121679934\n",
      "2.0376841437688733\n",
      "2.006926732251402\n",
      "1.9483804456353424\n",
      "1.8625738753663352\n",
      "1.7412314802193776\n",
      "1.6849049413127848\n",
      "1.583316294518996\n",
      "1.529298111751304\n",
      "1.5055606169228002\n",
      "1.4960365894889203\n",
      "1.4918390317265797\n",
      "1.464960485700664\n",
      "1.4548490341748648\n",
      "1.429715527840049\n",
      "1.4271046688072497\n",
      "1.4231810659239235\n",
      "1.4208569018683128\n",
      "1.4192373230483877\n",
      "1.4039345442343674\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7d850520522d4e93a32c834b960d41c9",
       "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": "285f345735844c2991b24cdc4afee56a",
       "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.3689637782842006\n",
      "2.191472239250746\n",
      "1.9915136338010502\n",
      "1.9735104557941037\n",
      "1.8915466658892341\n",
      "1.7267299233958535\n",
      "1.6441133882465033\n",
      "1.5638685786345128\n",
      "1.5269426643730544\n",
      "1.484834797558722\n",
      "1.4566463846901245\n",
      "1.4099137158914137\n",
      "1.4071934130337511\n",
      "1.373831285991315\n",
      "1.3709395121372403\n",
      "1.3537608816640403\n",
      "1.3524086923976977\n",
      "1.3512338133313513\n",
      "1.3438780527576273\n",
      "1.3345478112308322\n",
      "1.3325414185822022\n",
      "1.3270991748372853\n",
      "1.313682940848314\n",
      "1.3131396213606443\n",
      "1.3127841435250405\n",
      "1.299944409217815\n",
      "1.2982631323145128\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a545098ce4d4decbf12704356979a9d",
       "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": "b1b1935aaf1b4c9396ca444107e0c234",
       "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.6050381131850244\n",
      "2.6040989339326805\n",
      "2.1191232653014476\n",
      "2.0406761446222306\n",
      "2.0328186752885613\n",
      "2.0314749677723976\n",
      "1.9428064111811776\n",
      "1.853388446051117\n",
      "1.7238261905613783\n",
      "1.6683516771508287\n",
      "1.6273626870395947\n",
      "1.6171438130296727\n",
      "1.5923994659231164\n",
      "1.5341945856841395\n",
      "1.5316571785661246\n",
      "1.5248358672619349\n",
      "1.4777440298444933\n",
      "1.4684236195195208\n",
      "1.446122190059374\n",
      "1.4422282812231857\n",
      "1.4366211952111383\n",
      "1.425535430943591\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc0731a2b8cf4f4bb06d76347b42cc7f",
       "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": "50865b5ad3f8478ebe8baf87beff0e9d",
       "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.341732328754608\n",
      "2.0780485098058756\n",
      "2.0490589597164157\n",
      "2.0378976425044395\n",
      "1.8733706295902428\n",
      "1.84591578255779\n",
      "1.7997207686045935\n",
      "1.7648624799983432\n",
      "1.732099516602324\n",
      "1.6874371812471363\n",
      "1.5350713762613408\n",
      "1.5336104169776705\n",
      "1.4411535113524847\n",
      "1.3948020542044104\n",
      "1.3812252958336904\n",
      "1.3532129448515586\n",
      "1.3318100121574559\n",
      "1.3235806443868454\n",
      "1.2990660121550337\n",
      "1.285662386457239\n",
      "1.2844286336192554\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d84a236a8fac49d19a5216772fd84bb7",
       "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": "aefa978b5cac48e2a7a620a2eebb16c7",
       "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.6488625403339814\n",
      "2.465366769682158\n",
      "2.227499613898839\n",
      "1.9597275810949073\n",
      "1.8781643704915416\n",
      "1.8527602399073182\n",
      "1.7654759580043813\n",
      "1.7172088132263303\n",
      "1.6595447521693178\n",
      "1.6145950164360432\n",
      "1.607355008048008\n",
      "1.5675994558513349\n",
      "1.5396451575037995\n",
      "1.515201120731396\n",
      "1.4770163224287955\n",
      "1.4165024497876029\n",
      "1.4157357934293107\n",
      "1.403301917393331\n",
      "1.3976333024564487\n",
      "1.3625174663444468\n",
      "1.3619700995962125\n",
      "1.323917495013106\n",
      "1.3119753025234373\n",
      "1.3039152644002219\n",
      "1.3012320135245892\n",
      "1.2979634374289797\n",
      "1.2943654012912942\n",
      "1.2859161164461812\n",
      "1.2857607306133074\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "72e05ed6f06841aaa10eb809b0a404de",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "######################## tabelka ##########################################################\n",
    "df = pd.DataFrame({\"Repr 1\": [], \"Repr 10\": [],\n",
    "                   \"Atention Pooling v2 - size = 3\": [], \"Atention Pooling v2 - size = 35\": [], \"Atention Pooling v2 - size = 100\": []})\n",
    "pd.set_option(\"display.precision\", 2)\n",
    "n_times = 1\n",
    "\n",
    "for n_convs in [1, 3, 5]:\n",
    "    for n_channels in [64, 512]:\n",
    "        row = []\n",
    "\n",
    "        #########################\n",
    "        scores = []\n",
    "        for _ in range(n_times):\n",
    "            m =  GraphNeuralNetwork(n_channels, n_convs=n_convs, features_after_layer=26)\n",
    "            m = train_best(m, train_loader1, valid_loader1, epochs=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",
    "            m = train_best(m, train_loader10, valid_loader10, epochs= 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",
    "                m = train_best(m, train_loader, valid_loader, epochs=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\n",
    "\n",
    "df.to_csv(\"esol_out.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7b534b1490df4e4d8652781ced932d52",
       "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.0227834590960674\n",
      "2.232227819451916\n",
      "1.9664097825587499\n",
      "1.6954093615371726\n",
      "1.5753249000281524\n",
      "1.528144112575394\n",
      "1.5037602970939115\n",
      "1.4768499217727113\n",
      "1.4599923489537663\n",
      "1.4483568674122735\n",
      "1.4434541112822101\n",
      "1.4404855911298529\n",
      "1.4166960942294822\n",
      "1.4114335745871684\n",
      "1.404131302328779\n",
      "1.396338162863882\n",
      "1.3672435244453955\n",
      "1.3436487206584198\n",
      "1.3323085092983822\n",
      "1.3024006344661614\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "42c7e48d393f4bffb6493dff3b4ad2e1",
       "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": [
      "1.32\n"
     ]
    }
   ],
   "source": [
    "m =  GraphNeuralNetwork(512, n_convs=3, my_layer=MyAttentionModule4(35), features_after_layer=35)\n",
    "m = train_best(m, train_loader, valid_loader, epochs=70)\n",
    "predictions, att = predict(m, test_loader)\n",
    "rmse_score = rmse(y_test, predictions.flatten())\n",
    "print(\"{:.2f}\".format(rmse_score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE = 1.32\n"
     ]
    }
   ],
   "source": [
    "###################### 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.to_csv(\"esol_att_single.csv\")\n",
    "df_batch.to_csv(\"esol_att_batch.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>0</th>\n",
       "      <td>0.53</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.27</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.17</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.08</td>\n",
       "      <td>0.34</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.17</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.08</td>\n",
       "      <td>0.34</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.17</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.08</td>\n",
       "      <td>0.34</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.17</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.08</td>\n",
       "      <td>0.34</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.06</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AtomicNum  Degree  TotalNumHs  ImplicitValence  Hybridization   \n",
       "0       0.53    0.03        0.03             0.03           0.27  \\\n",
       "1       0.17    0.06        0.06             0.08           0.34   \n",
       "2       0.17    0.06        0.06             0.08           0.34   \n",
       "3       0.17    0.06        0.06             0.08           0.34   \n",
       "4       0.17    0.06        0.06             0.08           0.34   \n",
       "\n",
       "   FormalCharge  IsInRing  IsAromatic  NumRadicalElectrons  \n",
       "0          0.03      0.03        0.05                 0.03  \n",
       "1          0.06      0.06        0.11                 0.06  \n",
       "2          0.06      0.06        0.11                 0.06  \n",
       "3          0.06      0.06        0.11                 0.06  \n",
       "4          0.06      0.06        0.11                 0.06  "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_single[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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.25</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.24</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.23</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.23</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.23</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.07</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AtomicNum  Degree  TotalNumHs  ImplicitValence  Hybridization   \n",
       "1       0.25    0.06        0.06             0.11           0.22  \\\n",
       "2       0.24    0.06        0.06             0.11           0.22   \n",
       "3       0.23    0.07        0.07             0.11           0.22   \n",
       "4       0.23    0.07        0.07             0.11           0.22   \n",
       "5       0.23    0.07        0.07             0.11           0.22   \n",
       "\n",
       "   FormalCharge  IsInRing  IsAromatic  NumRadicalElectrons  \n",
       "1          0.06      0.06        0.11                 0.06  \n",
       "2          0.06      0.06        0.11                 0.06  \n",
       "3          0.07      0.07        0.11                 0.07  \n",
       "4          0.07      0.07        0.11                 0.07  \n",
       "5          0.07      0.07        0.11                 0.07  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_batch[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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>Atention Pooling v2 - size = 3</th>\n",
       "      <th>Atention Pooling v2 - size = 35</th>\n",
       "      <th>Atention Pooling v2 - size = 100</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1 convs, 64 channels</th>\n",
       "      <td>1.47</td>\n",
       "      <td>1.49</td>\n",
       "      <td>1.41</td>\n",
       "      <td>1.38</td>\n",
       "      <td>1.43</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1 convs, 512 channels</th>\n",
       "      <td>1.48</td>\n",
       "      <td>1.50</td>\n",
       "      <td>1.42</td>\n",
       "      <td>1.51</td>\n",
       "      <td>1.37</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3 convs, 64 channels</th>\n",
       "      <td>1.32</td>\n",
       "      <td>1.32</td>\n",
       "      <td>1.35</td>\n",
       "      <td>1.30</td>\n",
       "      <td>1.39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3 convs, 512 channels</th>\n",
       "      <td>1.31</td>\n",
       "      <td>1.30</td>\n",
       "      <td>1.40</td>\n",
       "      <td>1.26</td>\n",
       "      <td>1.26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5 convs, 64 channels</th>\n",
       "      <td>1.32</td>\n",
       "      <td>1.31</td>\n",
       "      <td>1.35</td>\n",
       "      <td>1.37</td>\n",
       "      <td>1.32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5 convs, 512 channels</th>\n",
       "      <td>1.47</td>\n",
       "      <td>1.29</td>\n",
       "      <td>1.46</td>\n",
       "      <td>1.30</td>\n",
       "      <td>1.34</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      Repr 1 Repr 10 Atention Pooling v2 - size = 3   \n",
       "1 convs, 64 channels    1.47    1.49                           1.41  \\\n",
       "1 convs, 512 channels   1.48    1.50                           1.42   \n",
       "3 convs, 64 channels    1.32    1.32                           1.35   \n",
       "3 convs, 512 channels   1.31    1.30                           1.40   \n",
       "5 convs, 64 channels    1.32    1.31                           1.35   \n",
       "5 convs, 512 channels   1.47    1.29                           1.46   \n",
       "\n",
       "                      Atention Pooling v2 - size = 35   \n",
       "1 convs, 64 channels                             1.38  \\\n",
       "1 convs, 512 channels                            1.51   \n",
       "3 convs, 64 channels                             1.30   \n",
       "3 convs, 512 channels                            1.26   \n",
       "5 convs, 64 channels                             1.37   \n",
       "5 convs, 512 channels                            1.30   \n",
       "\n",
       "                      Atention Pooling v2 - size = 100  \n",
       "1 convs, 64 channels                              1.43  \n",
       "1 convs, 512 channels                             1.37  \n",
       "3 convs, 64 channels                              1.39  \n",
       "3 convs, 512 channels                             1.26  \n",
       "5 convs, 64 channels                              1.32  \n",
       "5 convs, 512 channels                             1.34  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(m.myAttentionModule.state_dict(), \"attention_pooling_esol.pth\")"
   ]
  }
 ],
 "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
}