tsnp_plot.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from TraGT.load_data import load_data, load_data_long,CustomDataset,adj_list_to_adj_matrix\n",
    "import torch\n",
    "from torch_geometric.data import Data\n",
    "from TraGT.seq_models import TransformerModel\n",
    "from TraGT.graph_models import Graph_Transformer\n",
    "from TraGT.fusion_model import FusionModel\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "from datetime import datetime\n",
    "import os\n",
    "from sklearn.metrics import roc_auc_score, f1_score, precision_score, recall_score\n",
    "import numpy as np\n",
    "from sklearn.manifold import TSNE\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data_name='bbbp'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[23:55:04] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:05] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:06] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "[23:55:07] WARNING: not removing hydrogen atom without neighbors\n",
      "C:\\Users\\vysha\\AppData\\Local\\Temp\\ipykernel_119152\\1327122607.py:12: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  data_list_train = [Data(x=torch.tensor(features, dtype=torch.float),\n",
      "C:\\Users\\vysha\\AppData\\Local\\Temp\\ipykernel_119152\\1327122607.py:14: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  y=torch.tensor(label, dtype=torch.float))\n",
      "C:\\Users\\vysha\\AppData\\Local\\Temp\\ipykernel_119152\\1327122607.py:16: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  data_list_test = [Data(x=torch.tensor(features, dtype=torch.float),\n"
     ]
    }
   ],
   "source": [
    "train_data, train_labels, test_data, test_labels = load_data_long(data_name, device=torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\"))\n",
    "device=torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "input_dim_train = train_data['features'][0].size(-1)\n",
    "input_dim_test = test_data['features'][0].size(-1)\n",
    "\n",
    "\n",
    "adj_matrices_train = [adj_list_to_adj_matrix(adj_list) for adj_list in train_data['adj_lists']]\n",
    "adj_matrices_test = [adj_list_to_adj_matrix(adj_list) for adj_list in test_data['adj_lists']]\n",
    "\n",
    "\n",
    "data_list_train = [Data(x=torch.tensor(features, dtype=torch.float),\n",
    "                        edge_index=torch.nonzero(adj_matrix, as_tuple=False).t().contiguous(),\n",
    "                        y=torch.tensor(label, dtype=torch.float))\n",
    "                    for features, adj_matrix, label in zip(train_data['features'], adj_matrices_train, train_labels)]\n",
    "data_list_test = [Data(x=torch.tensor(features, dtype=torch.float),\n",
    "                                edge_index=torch.nonzero(adj_matrix, as_tuple=False).t().contiguous(),\n",
    "                                y=torch.tensor(label, dtype=torch.float))\n",
    "                            for features, adj_matrix, label in zip(test_data['features'], adj_matrices_test, test_labels)]\n",
    "\n",
    "train_dataset = CustomDataset(data_list_train, train_data['sequence'])\n",
    "test_dataset = CustomDataset(data_list_test, test_data['sequence'])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Python312\\Lib\\site-packages\\torch\\nn\\modules\\transformer.py:286: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.self_attn.batch_first was not True(use batch_first for better inference performance)\n",
      "  warnings.warn(f\"enable_nested_tensor is True, but self.use_nested_tensor is False because {why_not_sparsity_fast_path}\")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "vocab_size = 100\n",
    "d_model = 100\n",
    "nhead = 4\n",
    "num_encoder_layers = 3\n",
    "dim_feedforward = 512\n",
    "max_length = 100\n",
    "batch_size = 1\n",
    "num_epochs = 100\n",
    "model_path = 'saved_models/bbbp_2024-05-01_15-49-53/test_best_model_90.674.pth'\n",
    "\n",
    "graph_model = Graph_Transformer(in_channels=input_dim_train, hidden_channels=64, out_channels=1, heads=4).to(device)\n",
    "\n",
    "sequence_model = TransformerModel(vocab_size, d_model, nhead, num_encoder_layers, dim_feedforward).to(device)\n",
    "\n",
    "fusion_model = FusionModel(graph_model, sequence_model).to(device)\n",
    "\n",
    "# Load the state dict into the model\n",
    "fusion_model.load_state_dict(torch.load(model_path))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100, Epoch Accuracy: 86.9433\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[19], line 82\u001b[0m\n\u001b[0;32m     79\u001b[0m         sequence_targets \u001b[38;5;241m=\u001b[39m sequence_targets\u001b[38;5;241m.\u001b[39munsqueeze(\u001b[38;5;241m0\u001b[39m)\n\u001b[0;32m     81\u001b[0m     \u001b[38;5;66;03m# Compute epoch test accuracy\u001b[39;00m\n\u001b[1;32m---> 82\u001b[0m     epoch_test_accuracy \u001b[38;5;241m=\u001b[39m (\u001b[43mtotal_correct\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mtotal_samples\u001b[49m) \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m100\u001b[39m\n\u001b[0;32m     83\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEpoch Testing Accuracy: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch_test_accuracy\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     85\u001b[0m \u001b[38;5;66;03m# Concatenate features and labels for t-SNE visualization\u001b[39;00m\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.manifold import TSNE\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "# Variables for best metrics\n",
    "best_train_accuracy = 0.0\n",
    "best_test_accuracy = 0.0\n",
    "\n",
    "# Lists to store features and labels for t-SNE visualization\n",
    "tsne_train_features = []  # Features for training set\n",
    "tsne_train_labels = []  # Labels for training set\n",
    "tsne_test_features = []  # Features for testing set\n",
    "tsne_test_labels = []  # Labels for testing set\n",
    "\n",
    "optimizer = optim.Adam(fusion_model.parameters(), lr=0.001,weight_decay=5e-4)  # Adam optimizer\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "\n",
    "# Testing loop\n",
    "total_correct = 0\n",
    "total_samples = 0\n",
    "true_labels_test = []\n",
    "pred_probs_test = []    \n",
    "for data_batch in test_dataset:\n",
    "    graph_data_batch = data_batch[0]\n",
    "    sequence_inputs = data_batch[1].to(device)                                                      \n",
    "    sequence_targets = graph_data_batch.y\n",
    "    \n",
    "    output= fusion_model(sequence_inputs)\n",
    "    binary_predictions = (output >= 0.5).float()\n",
    "    sequence_targets = sequence_targets.unsqueeze(0)\n",
    "# Compute epoch test accuracy\n",
    "epoch_test_accuracy = (total_correct / total_samples) * 100\n",
    "print(f\"Epoch Testing Accuracy: {epoch_test_accuracy:.4f}\")\n",
    "\n",
    "# Concatenate features and labels for t-SNE visualization\n",
    "test_features = np.concatenate(tsne_test_features, axis=0)  # Test features\n",
    "test_labels = np.concatenate(tsne_test_labels, axis=0)  # Test labels\n",
    "\n",
    "# Define TP, TN, FP, FN in the test set\n",
    "test_predictions = (test_features >= 0.5).astype(int)  # Binary predictions\n",
    "tp_indices = np.where((test_predictions == 1) & (test_labels == 1))[0]\n",
    "tn_indices = np.where((test_predictions == 0) & (test_labels == 0))[0]\n",
    "fp_indices = np.where((test_predictions == 1) & (test_labels == 0))[0]\n",
    "fn_indices = np.where((test_predictions == 0) & (test_labels == 1))[0]\n",
    "\n",
    "# Apply t-SNE for visualization\n",
    "tsne = TSNE(n_components=2, random_state=42)  # Reduce to 2D\n",
    "tsne_results = tsne.fit_transform(test_features)  # Apply t-SNE to test set\n",
    "\n",
    "# Create scatter plot with different colors for TP, TN, FP, FN\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.scatter(tsne_results[tp_indices, 0], tsne_results[tp_indices, 1], c='blue', label='True Positive (TP)', alpha=0.7, s=30)\n",
    "plt.scatter(tsne_results[tn_indices, 0], tsne_results[tn_indices, 1], c='orange', label='True Negative (TN)', alpha=0.7, s=30)\n",
    "plt.scatter(tsne_results[fp_indices, 0], tsne_results[fp_indices, 1], c='red', label='False Positive (FP)', alpha=0.7, s=30)\n",
    "plt.scatter(tsne_results[fn_indices, 0], tsne_results[fn_indices, 1], c='green', label='False Negative (FN)', alpha=0.7, s=30)\n",
    "\n",
    "plt.xlabel(\"t-SNE Dimension 1\")\n",
    "plt.ylabel(\"t-SNE Dimension 2\")\n",
    "plt.title(\"t-SNE Visualization of Model Predictions\")\n",
    "plt.legend()  # Add a legend for clarity\n",
    "plt.show()  # Display the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the t-SNE transformed data\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(outputs_test_1d, range(len(outputs_test_1d)), s=10, c='b', alpha=0.5)\n",
    "plt.xlabel('t-SNE Transformed Dimension')\n",
    "plt.ylabel('Data Point Index')\n",
    "plt.title('t-SNE Transformed Data')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}