pytorchModel_ter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ab2411a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extension horovod.torch has not been built: /cvmfs/sft.cern.ch/lcg/views/LCG_103swan/x86_64-centos7-gcc11-opt/lib/python3.9/site-packages/horovod/torch/mpi_lib_v2.cpython-39-x86_64-linux-gnu.so not found\n",
      "If this is not expected, reinstall Horovod with HOROVOD_WITH_PYTORCH=1 to debug the build error.\n",
      "Warning! MPI libs are missing, but python applications are still available.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.utils.data as udata\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# PyTorch geometric\n",
    "import torch_geometric\n",
    "import torch_geometric.data as geom_data\n",
    "import torch_geometric.nn as geom_nn\n",
    "from torch_geometric.nn import GCNConv\n",
    "from torch_geometric.nn import DenseGCNConv\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "from torch_geometric.nn import global_mean_pool\n",
    "\n",
    "from torch_geometric.utils import to_networkx\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "#from sklearn.preprocessing import StandardScaler\n",
    "from scipy.stats import norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "cc43ea73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total training events =  21957 918\n",
      "Index(['pmax3', 'pmax4', 'pmax5', 'pmax6', 'pmax7', 'pmax8', 'pmax9', 'pmax11',\n",
      "       'pmax14', 'negpmax3', 'negpmax4', 'negpmax5', 'negpmax6', 'negpmax7',\n",
      "       'negpmax8', 'negpmax9', 'negpmax11', 'negpmax14'],\n",
      "      dtype='object') 18\n",
      "Index(['x_tracker', 'y_tracker'], dtype='object') 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_547/3204874073.py:30: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  train['x_tracker'] += -0.05\n",
      "/tmp/ipykernel_547/3204874073.py:32: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  train['y_tracker'] += 0.05\n",
      "/tmp/ipykernel_547/3204874073.py:76: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  y_train[column] = y_train[column]  / y_train[column].abs().max()\n",
      "/tmp/ipykernel_547/3204874073.py:77: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  y_test[column] = y_test[column]  / y_test[column].abs().max()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x_tracker</th>\n",
       "      <th>y_tracker</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>26895</th>\n",
       "      <td>-1.000000</td>\n",
       "      <td>-0.606373</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37253</th>\n",
       "      <td>-0.985171</td>\n",
       "      <td>-0.906279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37275</th>\n",
       "      <td>-0.985171</td>\n",
       "      <td>-0.906279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37297</th>\n",
       "      <td>-0.985171</td>\n",
       "      <td>-0.906279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39938</th>\n",
       "      <td>-0.981464</td>\n",
       "      <td>-0.962512</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>115753</th>\n",
       "      <td>-0.881372</td>\n",
       "      <td>-0.868791</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>116407</th>\n",
       "      <td>-0.881372</td>\n",
       "      <td>-0.625117</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>116431</th>\n",
       "      <td>-0.881372</td>\n",
       "      <td>-0.625117</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>116568</th>\n",
       "      <td>-0.881372</td>\n",
       "      <td>-0.568885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>116629</th>\n",
       "      <td>-0.881372</td>\n",
       "      <td>-0.550141</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>21957 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        x_tracker  y_tracker\n",
       "26895   -1.000000  -0.606373\n",
       "37253   -0.985171  -0.906279\n",
       "37275   -0.985171  -0.906279\n",
       "37297   -0.985171  -0.906279\n",
       "39938   -0.981464  -0.962512\n",
       "...           ...        ...\n",
       "115753  -0.881372  -0.868791\n",
       "116407  -0.881372  -0.625117\n",
       "116431  -0.881372  -0.625117\n",
       "116568  -0.881372  -0.568885\n",
       "116629  -0.881372  -0.550141\n",
       "\n",
       "[21957 rows x 2 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'\\nm_train = x_train.mean(0, keepdim=True)\\ns_train = x_train.std(0, unbiased=False, keepdim=True)\\nx_train -= m_train\\nx_train /= 5*s_train\\n\\nm_train_y = y_train.mean(0, keepdim=True)\\ns_train_y = y_train.std(0, unbiased=False, keepdim=True)\\ny_train -= m_train_y\\ny_train /= 5*s_train_y\\n\\nm_test = x_test.mean(0, keepdim=True)\\ns_test = x_test.std(0, unbiased=False, keepdim=True)\\nx_test -= m_test\\nx_test /= 5*s_test\\n\\nm_test_y = y_test.mean(0, keepdim=True)\\ns_test_y = y_test.std(0, unbiased=False, keepdim=True)\\ny_test -= m_test_y\\ny_test /= 5*s_test_y\\n'"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = './'\n",
    "#df_train = pd.read_csv('csv_TB3_Run21_croci450um_W3_285V_150kWfm.csv', sep=',')\n",
    "df_train = pd.read_csv('/eos/user/f/fsiviero/RSD/pytorch/RSD-ML/csv_croci450-RSD2_Run111_285V_49.3pc_W3.csv', sep=',')\n",
    "#df_test = pd.read_csv('csv_TB3_Run20_croci450um_W3_285V_40kWfm.csv', sep=',')\n",
    "df_test = pd.read_csv('/eos/user/f/fsiviero/RSD/pytorch/RSD-ML/csv_TB3_Run20_croci450um_W3_285V_40kWfm.csv', sep=',')\n",
    "\n",
    "df_train = df_train.dropna(axis=1)\n",
    "df_test = df_test.dropna(axis=1)\n",
    "df_train = df_train.dropna(axis=0)\n",
    "df_test = df_test.dropna(axis=0)\n",
    "\n",
    "#df_train = df_train.astype(double)\n",
    "#df_test = df_test.astype(double)\n",
    "\n",
    "Train = df_train\n",
    "Test = df_test\n",
    "\n",
    "x_low = -5.475\n",
    "x_up = -4.575\n",
    "y_low = -1.232\n",
    "y_up = -0.332\n",
    "\n",
    "\n",
    "train = Train[ (Train['x_tracker']>(x_low) ) & (Train['x_tracker']<(x_up)) \\\n",
    "              & (Train['y_tracker']>(y_low)) & (Train['y_tracker']<(y_up)) ]\n",
    "\n",
    "test = Test[ (Test['x_tracker']>x_low) & (Test['x_tracker']<x_up) & (Test['y_tracker']>y_low) \\\n",
    "              & (Test['y_tracker']<y_up) ]\n",
    "\n",
    "train['x_tracker'] += -0.05\n",
    "#test ['x_tracker'] += 5.0\n",
    "train['y_tracker'] += 0.05\n",
    "#test ['y_tracker'] += 1.0\n",
    "\n",
    "train = train[ (train['pmax6']>train['pmax1']) & (train['pmax6']>train['pmax2']) & (train['pmax6']>train['pmax3']) \\\n",
    "        & (train['pmax6']>train['pmax4']) & (train['pmax6']>train['pmax5']) & (train['pmax6']>train['pmax7']) \\\n",
    "        & (train['pmax6']>train['pmax8']) & (train['pmax6']>train['pmax9']) & (train['pmax6']>train['pmax11']) \\\n",
    "        & (train['pmax6']>train['pmax12']) & (train['pmax6']>train['pmax13']) & (train['pmax6']>train['pmax14']) ]\n",
    "\n",
    "test = test[ (test['pmax6']>test['pmax1']) & (test['pmax6']>test['pmax2']) & (test['pmax6']>test['pmax3']) \\\n",
    "        & (test['pmax6']>test['pmax4']) & (test['pmax6']>test['pmax5']) & (test['pmax6']>test['pmax7']) \\\n",
    "        & (test['pmax6']>test['pmax8']) & (test['pmax6']>test['pmax9']) & (test['pmax6']>test['pmax11']) \\\n",
    "        & (test['pmax6']>test['pmax12']) & (test['pmax6']>test['pmax13']) & (test['pmax6']>test['pmax14']) ]\n",
    "\n",
    "train = train[ (train['pmax6']>=10) ]\n",
    "test = test[ (test['pmax6']>=5) ]\n",
    "train = train[ (train['negpmax6']>=-100) ]\n",
    "test = test[ (test['negpmax6']>=-100) ]\n",
    "\n",
    "print(\"Total training events = \", len(train), len(test))\n",
    "\n",
    "y_train = train.iloc[:,:2]\n",
    "x_train = train.drop(['x_tracker','y_tracker','x_rsd','y_rsd','t','t_reco','pmax0','negpmax0','tmax0'],axis=1)\n",
    "x_train = x_train.drop(['pmax1','pmax2','pmax12','pmax13','negpmax1','negpmax2','negpmax12','negpmax13'],axis=1)\n",
    "x_train = x_train.iloc[:,:18]\n",
    "#x_train = x_train.iloc[:,:26]\n",
    "#x_train['diff3'] = x_train['pmax3']+x_train['negpmax3']\n",
    "\n",
    "y_test = test.iloc[:,:2]\n",
    "x_test = test.drop(['x_tracker','y_tracker','x_rsd','y_rsd','t','t_reco','pmax0','negpmax0','tmax0'],axis=1)\n",
    "x_test = x_test.drop(['pmax1','pmax2','pmax12','pmax13','negpmax1','negpmax2','negpmax12','negpmax13'],axis=1)\n",
    "x_test = x_test.iloc[:,:18]\n",
    "#x_test = x_test.iloc[:,:26]\n",
    "#x_test['diff3'] = x_test['pmax3']+x_test['negpmax3']\n",
    "\n",
    "n_var     = len(x_test.columns)\n",
    "n_outputs = len(y_test.columns)\n",
    "print(x_test.columns, n_var)\n",
    "print(y_test.columns, n_outputs)\n",
    "\n",
    "for column in x_train.columns:\n",
    "    x_train[column] = x_train[column]  / x_train[column].abs().max()\n",
    "    x_test[column] = x_test[column]  / x_test[column].abs().max()\n",
    "    \n",
    "for column in y_train.columns:\n",
    "    y_train[column] = y_train[column]  / y_train[column].abs().max()\n",
    "    y_test[column] = y_test[column]  / y_test[column].abs().max()\n",
    "    \n",
    "display(y_train)\n",
    "\n",
    "y_train = torch.tensor(y_train.values)\n",
    "x_train = torch.tensor(x_train.values)\n",
    "\n",
    "y_test = torch.tensor(y_test.values)\n",
    "x_test = torch.tensor(x_test.values)\n",
    "\n",
    "\n",
    "'''\n",
    "x_trains = x_train.square()\n",
    "x_trains = x_trains.sum(0, keepdim=True)\n",
    "x_trains = x_trains.sqrt()\n",
    "x_train /= x_trains\n",
    "\n",
    "y_trains = y_train.square()\n",
    "y_trains = y_trains.sum()\n",
    "y_trains = y_trains.sqrt()\n",
    "y_train /= y_trains\n",
    "\n",
    "x_tests = x_test.square()\n",
    "x_tests = x_tests.sum()\n",
    "x_tests = x_tests.sqrt()\n",
    "x_test /= x_tests\n",
    "\n",
    "y_tests = y_test.square()\n",
    "y_tests = y_tests.sum()\n",
    "y_tests = y_tests.sqrt()\n",
    "y_test /= y_tests\n",
    "'''\n",
    "\n",
    "'''\n",
    "m_train = x_train.mean(0, keepdim=True)\n",
    "s_train = x_train.std(0, unbiased=False, keepdim=True)\n",
    "x_train -= m_train\n",
    "x_train /= 5*s_train\n",
    "\n",
    "m_train_y = y_train.mean(0, keepdim=True)\n",
    "s_train_y = y_train.std(0, unbiased=False, keepdim=True)\n",
    "y_train -= m_train_y\n",
    "y_train /= 5*s_train_y\n",
    "\n",
    "m_test = x_test.mean(0, keepdim=True)\n",
    "s_test = x_test.std(0, unbiased=False, keepdim=True)\n",
    "x_test -= m_test\n",
    "x_test /= 5*s_test\n",
    "\n",
    "m_test_y = y_test.mean(0, keepdim=True)\n",
    "s_test_y = y_test.std(0, unbiased=False, keepdim=True)\n",
    "y_test -= m_test_y\n",
    "y_test /= 5*s_test_y\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "f9ca616e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_list_train = []\n",
    "\n",
    "for a, b in zip(x_train,y_train):\n",
    "    feature_list =  [kx.item() for kx in a]\n",
    "    node_train = torch.tensor([[feature_list[3],feature_list[12]],[feature_list[0],feature_list[9]],[feature_list[1],feature_list[10]],\\\n",
    "                      [feature_list[2],feature_list[11]],[feature_list[4],feature_list[13]],[feature_list[5],feature_list[14]],\\\n",
    "                      [feature_list[6],feature_list[15]],[feature_list[7],feature_list[16]],[feature_list[8],feature_list[17]]])\n",
    "    \n",
    "    edge_index = torch.tensor([[0,1],[1,0],[0,2],[2,0],[0,3],[3,0],[0,4],[4,0],[0,5],[5,0],[0,6],[6,0],[0,7],[7,0],[8,0],[0,8],\\\n",
    "                              [6,5],[5,6],[6,7],[7,6],[5,7],[7,5],[7,8],[8,7],[1,8],[8,1],[1,7],[7,1],[1,2],[2,1],[1,3],[3,1],[2,3],[3,2],[3,4],[4,3],[3,5],[5,3],[4,5],[5,4]])\n",
    "    \n",
    "    \n",
    "    #edge_index = torch.tensor([[0,1],[1,0],[0,2],[2,0],[0,3],[3,0],[0,4],[4,0],[0,5],[5,0],[0,6],[6,0],[0,7],[7,0],[8,0],[0,8]])\n",
    "    #edge_index = torch.tensor([[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8]])\n",
    "    posit_list = [ky.item() for ky in b]\n",
    "    y = torch.tensor([[posit_list[0],posit_list[1]]])\n",
    "    data_train = Data(x=node_train, edge_index=edge_index.t().contiguous(), y=y)\n",
    "    #if(data_train.validate(raise_on_error=True)): \n",
    "    data_list_train.append(data_train)\n",
    "      \n",
    "\n",
    "loader_train = DataLoader(dataset=data_list_train, batch_size=1, num_workers=0, shuffle=False)\n",
    "\n",
    "networkX_graph = to_networkx(data_train)\n",
    "nx.draw(networkX_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "afbf9e06",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_list_test = []\n",
    "\n",
    "for a, b in zip(x_test,y_test):\n",
    "    feature_list =  [kx.item() for kx in a]\n",
    "    node_test = torch.tensor([[feature_list[3],feature_list[12]],[feature_list[0],feature_list[9]],[feature_list[1],feature_list[10]],\\\n",
    "                      [feature_list[2],feature_list[11]],[feature_list[4],feature_list[13]],[feature_list[5],feature_list[14]],\\\n",
    "                      [feature_list[6],feature_list[15]],[feature_list[7],feature_list[16]],[feature_list[8],feature_list[17]]])\n",
    "    edge_index = torch.tensor([[0,1],[1,0],[0,2],[2,0],[0,3],[3,0],[0,4],[4,0],[0,5],[5,0],[0,6],[6,0],[0,7],[7,0],[8,0],[0,8],\\\n",
    "                              [6,5],[5,6],[6,7],[7,6],[5,7],[7,5],[7,8],[8,7],[1,8],[8,1],[1,7],[7,1],[1,2],[2,1],[1,3],[3,1],[2,3],[3,2],[3,4],[4,3],[3,5],[5,3],[4,5],[5,4]])\n",
    "    #edge_index = torch.tensor([[0,1],[1,0],[0,2],[2,0],[0,3],[3,0],[0,4],[4,0],[0,5],[5,0],[0,6],[6,0],[0,7],[7,0],[8,0],[0,8]])\n",
    "    posit_list = [ky.item() for ky in b]\n",
    "    y = torch.tensor([[posit_list[0],posit_list[1]]])\n",
    "    data_test = Data(x=node_test, edge_index=edge_index.t().contiguous(), y=y)\n",
    "    #if(data_test.validate(raise_on_error=True)): \n",
    "    data_list_test.append(data_test)\n",
    "\n",
    "loader_test = DataLoader(dataset=data_list_test, batch_size=1, num_workers=0, shuffle=False)\n",
    "#networkX_graph = to_networkx(data_test)\n",
    "#nx.draw(networkX_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "4525ce44",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs        = 5\n",
    "n_nodes       = 16\n",
    "n_outputs     = 2\n",
    "n_var         = 2\n",
    "drop_out_p    = 0.1\n",
    "learning_rate = 0.000001\n",
    "#learning_rate = 0.001\n",
    "verbose       = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "da73b87b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjusting learning rate of group 0 to 1.0000e-06.\n"
     ]
    }
   ],
   "source": [
    "# Define GNN model\n",
    "class GNN(torch.nn.Module):\n",
    "    def __init__(self, n_var, n_nodes, n_outputs, drop_out_p):\n",
    "        super(GNN, self).__init__()\n",
    "        torch.manual_seed(1234)\n",
    "        self.conv1 = GCNConv(n_var, n_nodes)\n",
    "        self.conv2 = GCNConv(n_nodes, n_nodes)\n",
    "        #self.conv3 = GCNConv(n_nodes, n_nodes)\n",
    "        self.lin1 = nn.Linear(n_nodes, n_nodes)\n",
    "        self.lin2 = nn.Linear(n_nodes, n_nodes)\n",
    "        self.lin3 = nn.Linear(n_nodes, n_outputs)\n",
    "        \n",
    "        \n",
    "    def forward(self, x, edge_index):\n",
    "        xx = self.conv1(x, edge_index)\n",
    "        #xx = xx.relu()\n",
    "        xx = xx.tanh()\n",
    "        xx = F.dropout(xx, p=drop_out_p)\n",
    "        xx = self.conv2(xx, edge_index)\n",
    "        #xx = xx.relu()\n",
    "        #xx = F.dropout(xx, p=drop_out_p)\n",
    "        #xx = self.conv3(xx, edge_index)\n",
    "        xx = xx.tanh()\n",
    "        #xx = self.lin1(xx)\n",
    "        #xx = xx.tanh()\n",
    "        #xx = self.lin2(xx)\n",
    "        #xx = xx.tanh()\n",
    "        xx = self.lin3(xx)\n",
    "        return xx\n",
    "        \n",
    "        #xx = F.dropout(x, p=drop_out_p, training=self.training)\n",
    "        #xx = global_mean_pool(xx)\n",
    "        #x = nn.BatchNorm1d(n_nodes)\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = GNN(n_var=n_var, n_nodes=n_nodes, n_outputs=n_outputs, drop_out_p=drop_out_p).to(device)\n",
    "\n",
    "# Loss function\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "# Optimizer\n",
    "optimizer = optim.Adam(model.parameters(), lr = learning_rate, weight_decay=1e-6)\n",
    "\n",
    "scheduler = optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.95, last_epoch=-1, verbose=verbose)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f031c74b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beginning epoch 0\n"
     ]
    }
   ],
   "source": [
    "training_losses_total = np.zeros(epochs)\n",
    "validation_losses_total = np.zeros(epochs)\n",
    "\n",
    "diff_x_train = []\n",
    "diff_y_train = []\n",
    "xxx_o_train = []\n",
    "yyy_o_train = []\n",
    "xxx_train = []\n",
    "yyy_train = []\n",
    "\n",
    "diff_x_test = []\n",
    "diff_y_test = []\n",
    "xxx_o_test = []\n",
    "yyy_o_test = []\n",
    "xxx_test = []\n",
    "yyy_test = []\n",
    "\n",
    "# training and validation\n",
    "for epoch in range(epochs):\n",
    "    if verbose: print(\"Beginning epoch \" + str(epoch))\n",
    "    # training\n",
    "    train_loss_total = 0\n",
    "    for i, data in enumerate(loader_train,0):\n",
    "        model.float()\n",
    "        model.train()\n",
    "        model.zero_grad()\n",
    "        optimizer.zero_grad()\n",
    "        output = model(data.x, data.edge_index)\n",
    "        batch_loss_total = criterion(data.y[0], output[0])        \n",
    "        batch_loss_total.backward()\n",
    "        optimizer.step()\n",
    "        model.eval()\n",
    "        if epoch==(epochs-1):\n",
    "            diff_x_train.append(data.y[0][0].detach().numpy()-output[0][0].detach().numpy())\n",
    "            diff_y_train.append(data.y[0][1].detach().numpy()-output[0][1].detach().numpy())\n",
    "            xxx_o_train.append(data.y[0][0].detach().numpy())\n",
    "            yyy_o_train.append(data.y[0][1].detach().numpy())\n",
    "            xxx_train.append(output[0][0].detach().numpy())\n",
    "            yyy_train.append(output[0][1].detach().numpy())\n",
    "        train_loss_total += batch_loss_total.item()\n",
    "    train_loss_total /= len(loader_train)\n",
    "    training_losses_total[epoch] = train_loss_total\n",
    "    if np.isnan(train_loss_total):\n",
    "        print(\"nan in training\")\n",
    "        break\n",
    "    if verbose: print(\"t_total: \"+ str(train_loss_total))\n",
    "        \n",
    "    # validation\n",
    "    val_loss_total = 0\n",
    "    for i, data in enumerate(loader_test):\n",
    "        output = model(data.x, data.edge_index)\n",
    "        batch_loss_total = criterion(data.y[0], output[0]) \n",
    "        if epoch==(epochs-1):\n",
    "            diff_x_test.append(data.y[0][0].detach().numpy()-output[0][0].detach().numpy())\n",
    "            diff_y_test.append(data.y[0][1].detach().numpy()-output[0][1].detach().numpy())\n",
    "            xxx_o_test.append(data.y[0][0].detach().numpy())\n",
    "            yyy_o_test.append(data.y[0][1].detach().numpy())\n",
    "            xxx_test.append(output[0][0].detach().numpy())\n",
    "            yyy_test.append(output[0][1].detach().numpy())\n",
    "        val_loss_total += batch_loss_total.item()\n",
    "    val_loss_total /= len(loader_test)\n",
    "    #scheduler.step()\n",
    "    validation_losses_total[epoch] = val_loss_total\n",
    "    if np.isnan(val_loss_total):\n",
    "        print(\"nan in val\")\n",
    "        break\n",
    "    if verbose: print(\"v_total: \"+ str(val_loss_total))\n",
    "    \n",
    "    # save the model\n",
    "    model.eval()\n",
    "    #modelLocation = \"{}/net_{}.pth\".format(\".\",epoch)\n",
    "    #torch.save(model.state_dict(), modelLocation)\n",
    "    \n",
    "print(\"Finished\")\n",
    "print(\"Final loss train:\", training_losses_total[-1])\n",
    "print(\"Final loss test:\",  validation_losses_total[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3efcf71d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot loss/epoch for training and validation sets\n",
    "print(\"Making basic validation plots\")\n",
    "training_total = plt.plot(training_losses_total, label='training_total')\n",
    "validation_total = plt.plot(validation_losses_total, label='validation_total')\n",
    "#plt.yscale(\"log\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "#plt.savefig(\"loss_plot.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e90275db",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(diff_x_train,100)\n",
    "plt.hist(diff_y_train,100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b52b6e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(diff_x_test,100)\n",
    "plt.hist(diff_y_test,100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0912c1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_x_train, sigma_x_train = norm.fit(diff_x_train)\n",
    "mu_y_train, sigma_y_train = norm.fit(diff_y_train)\n",
    "print('Sigma x-axis: '+str(sigma_x_train))\n",
    "print('Sigma y-axis: '+str(sigma_y_train))\n",
    "\n",
    "mu_x_test, sigma_x_test = norm.fit(diff_x_test)\n",
    "mu_y_test, sigma_y_test = norm.fit(diff_y_test)\n",
    "print('Sigma x-axis: '+str(sigma_x_test))\n",
    "print('Sigma y-axis: '+str(sigma_y_test))\n",
    "\n",
    "#np.savetxt('pippo.txt', diff, fmt='%f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4afc9e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "plt.scatter(xxx_o_train,yyy_o_train)\n",
    "plt.scatter(xxx_train,yyy_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79936000",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "plt.scatter(xxx_o_test,yyy_o_test)\n",
    "plt.scatter(xxx_test,yyy_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "235ef570",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs        = 1\n",
    "n_feat        = 2\n",
    "n_hid         = 16\n",
    "n_class       = 9\n",
    "drop_out_p    = 0.0\n",
    "\n",
    "class GNN(nn.Module):\n",
    "    def __init__(self, n_feat, n_hid, n_class, drop_out_p):\n",
    "        super(GNN, self).__init__()\n",
    "\n",
    "        self.gc1 = GCNConv(n_feat, n_hid)\n",
    "        self.gc2 = GCNConv(n_hid, n_class)\n",
    "        self.dropout = drop_out_p\n",
    "        self.LinearLayer = nn.Linear(n_feat, 2)\n",
    "\n",
    "    def forward(self, x, edge_index):\n",
    "        x = F.relu(self.gc1(x, edge_index))\n",
    "\n",
    "        x = F.dropout(x, self.dropout, training=self.training)\n",
    "        x = self.gc2(x, edge_index)\n",
    "        x = self.LinearLayer(torch.transpose(x, 2, 1))\n",
    "\n",
    "        return torch.transpose(x, 2, 1)\n",
    "    \n",
    "model = GNN(n_feat=n_feat, n_hid=n_hid, n_class=n_class, drop_out_p=drop_out_p)"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}