aeml_experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d5ce3eb1-6140-4c77-9b9e-4931de5dd013",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import sys\n",
    "import math, random, numpy as np\n",
    "import json\n",
    "import datetime\n",
    "from pathlib import Path\n",
    "from matplotlib import pyplot as plt\n",
    "import torch\n",
    "from torch import nn, optim\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torch.nn import functional as F\n",
    "from torchvision import models, transforms as T\n",
    "from torchvision.utils import make_grid\n",
    "\n",
    "from sklearn.cluster import MiniBatchKMeans, KMeans\n",
    "from sklearn.decomposition import IncrementalPCA\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "from sklearn.metrics.cluster import normalized_mutual_info_score\n",
    "from tqdm import tqdm\n",
    "\n",
    "import torchvision.datasets as datasets\n",
    "from torch.utils.data import ConcatDataset\n",
    "import h5py\n",
    "from sklearn.manifold import TSNE\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b12b47c-59ee-4aba-a8e8-05b4db45b333",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d8809859-920f-4b26-ab27-17f15be6334a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from deep_clastering.datasets import LogatecDataset, LabeledGhentDataset, LabeledITSDataset \n",
    "from deep_clastering.cnn import AE_CNN_1D\n",
    "from deep_clastering.visualization import get_averaged_clusters, plot_averaged_clusters_spectograms\n",
    "from deep_clastering.visualization import plot_tsne, plot_labels_dist_across_clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "edf42d16-cfd6-4ec2-9121-d0011735e6da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current device:  0\n",
      "Current device:  True\n"
     ]
    }
   ],
   "source": [
    "# Setup GPU\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.set_device(0)\n",
    "    device = torch.device('cuda')\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    pin_memory = True\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "    pin_memory = False\n",
    "\n",
    "print(\"Current device: \", torch.cuda.current_device())  \n",
    "print(\"Current device: \", torch.cuda.is_available())  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "68c534c1-78ae-4db7-b6d3-fe1888d8a4f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_lr(optimizer):\n",
    "    for param_group in optimizer.param_groups:\n",
    "        return param_group['lr']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b13c59a6-5a18-4ac8-b2c8-e15b68d51f75",
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance_based_clustering_loss(features:torch.Tensor, clusters_centres:torch.Tensor):\n",
    "    \"\"\"\n",
    "    H. Zhou, J. Bai, Y. Wang, J. Ren, X. Yang, and L. Jiao, “Deep radio\n",
    "    signal clustering with interpretability analysis based on saliency map\" 2023\n",
    "    Algorithm 1\n",
    "    \n",
    "    Train weighted distances between samples and clusters centres.\n",
    "    \n",
    "    Weights are calculated to give the biggest penalty \n",
    "    to distance between a sample and it's nearest cluster. Weights are not trainable\n",
    "    \"\"\"\n",
    "    num_clusters = clusters_centres.shape[0]\n",
    "    num_samples = features.shape[0]\n",
    "    \n",
    "    # (num_clusters, num_samples, num_features)\n",
    "    \n",
    "    features = features.unsqueeze(0).repeat(num_clusters, 1, 1)\n",
    "    clusters_centres = clusters_centres.unsqueeze(1).repeat(1,num_samples,1)\n",
    "    \n",
    "    distances = ((features - clusters_centres)**2).sum(axis = 2)\n",
    "        \n",
    "    min_distances, _ = distances.detach().min(dim=0)\n",
    "    \n",
    "    min_distances = min_distances.unsqueeze(0).repeat(num_clusters, 1)\n",
    "    \n",
    "    exp_shifted_distances = torch.exp(-(distances - min_distances)).detach()\n",
    "    \n",
    "    exp_shifted_distances_sums = exp_shifted_distances.sum(axis = 0)\n",
    "    \n",
    "    weighted_distances = distances * exp_shifted_distances / exp_shifted_distances_sums\n",
    "    \n",
    "    return weighted_distances.mean()\n",
    "\n",
    "KLDiv_clustering_loss = nn.KLDivLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5c9e57d2-50e0-4534-b7e5-597a37fb8abd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class ClusterlingLayer(nn.Module):\n",
    "    \"\"\"\n",
    "    Clustering layer definition (see DCEC article for equations)\n",
    "    \"\"\"\n",
    "    def __init__(self, in_features=10, out_features=10, alpha=1.0):\n",
    "        super(ClusterlingLayer, self).__init__()\n",
    "        self.in_features = in_features\n",
    "        self.out_features = out_features\n",
    "        self.alpha = alpha\n",
    "        self.weight = nn.Parameter(torch.Tensor(self.out_features, self.in_features))\n",
    "        self.weight = nn.init.xavier_uniform_(self.weight)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.unsqueeze(1) - self.weight\n",
    "        x = torch.mul(x, x)\n",
    "        x = torch.sum(x, dim=2)\n",
    "        x = 1.0 + (x / self.alpha)\n",
    "        x = 1.0 / x\n",
    "        x = x ** ((self.alpha +1.0) / 2.0)\n",
    "        x = torch.t(x) / torch.sum(x, dim=1)\n",
    "        x = torch.t(x)\n",
    "        return x\n",
    "\n",
    "    def extra_repr(self):\n",
    "        return 'in_features={}, out_features={}, alpha={}'.format(\n",
    "            self.in_features, self.out_features, self.alpha\n",
    "        )\n",
    "\n",
    "    def set_weight(self, tensor):\n",
    "        self.weight = nn.Parameter(tensor)\n",
    "\n",
    "# Function forwarding data through network, collecting clustering weight output and returning prediciotns and labels\n",
    "def calculate_predictions(model, clustering_layer, dataset, train_config):\n",
    "    \n",
    "    dataloader = DataLoader(\n",
    "        dataset, \n",
    "        num_workers=train_config['num_workers'], \n",
    "        batch_size=train_config['batch_size'], \n",
    "        shuffle=True)\n",
    "    \n",
    "    probs_array = []\n",
    "    label_array = []\n",
    "    preds = []\n",
    "    \n",
    "    model.eval()\n",
    "    clustering_layer.eval()\n",
    "    \n",
    "    for data in dataloader:\n",
    "        \n",
    "        inputs, labels = data\n",
    "        inputs = inputs.to(train_config['device'])\n",
    "        labels = labels.to(train_config['device'])\n",
    "        \n",
    "        outputs, features = model(inputs)\n",
    "        probs = clustering_layer(features)\n",
    "        \n",
    "        probs_array.append(probs.detach().cpu())\n",
    "        label_array.append(labels.cpu().detach())\n",
    "        \n",
    "    probs_array = torch.cat(probs_array).numpy()\n",
    "    \n",
    "    label_array = torch.cat(label_array).numpy()\n",
    "    \n",
    "    preds = np.argmax(probs_array, axis=1)\n",
    "    \n",
    "    return probs_array, label_array, preds\n",
    "\n",
    "def cacl_target_dist(out_distr):\n",
    "    tar_dist = out_distr ** 2 / np.sum(out_distr, axis=0)\n",
    "    tar_dist = np.transpose(np.transpose(tar_dist) / np.sum(tar_dist, axis=1))\n",
    "    return tar_dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ccb9cd8f-0587-4f17-8ffe-365d4e80b7a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_features(model:nn.Module, dataset:Dataset, train_config:dict)->torch.Tensor:\n",
    "    num_workers = train_config['num_workers']\n",
    "    batch_size = train_config['batch_size']\n",
    "    data_loader = DataLoader(dataset, \n",
    "                             batch_size=batch_size,\n",
    "                             num_workers=num_workers,\n",
    "                             shuffle=False)\n",
    "    model.eval()\n",
    "    features_list = []\n",
    "    for imgs, label in data_loader:\n",
    "        output, features = model(imgs.to(device))\n",
    "        features_list.append(features.detach().cpu())\n",
    "    \n",
    "    return torch.cat(features_list)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "743253b4-55c0-45e2-9fcf-6eed62b512cb",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def train(\n",
    "    model, \n",
    "    dataset,\n",
    "    criterion_reconstruction, \n",
    "    scheduler, \n",
    "    optimizer, \n",
    "    train_config\n",
    "):\n",
    "    num_warmup_epochs = train_config['num_warmup_epochs']\n",
    "    num_train_epochs = train_config['num_train_epochs']\n",
    "    \n",
    "    num_workers = train_config['num_workers']\n",
    "    batch_size = train_config['batch_size']\n",
    "    \n",
    "    num_clusters = train_config['num_clusters']\n",
    "    clustres_centers = None\n",
    "    target_distribution = None\n",
    "    clastering_layer = None\n",
    "    \n",
    "    num_epochs_update_target_dist = train_config.get('update_target_dist_epochs')\n",
    "    \n",
    "    clastering_loss_type = train_config['clustring_loss_type']\n",
    "    clustering_loss_coeff = train_config['clustering_loss_coeff']\n",
    "\n",
    "    \n",
    "    if hasattr(dataset, 'name'):\n",
    "        dataset_name = dataset.name\n",
    "    else:\n",
    "        dataset_name = 'unknown_data'\n",
    "\n",
    "    if hasattr(model, 'name'):\n",
    "        model_name = model.name\n",
    "    else: \n",
    "        model_name = 'unknown_model'\n",
    "    \n",
    "    dataloader = DataLoader(dataset, \n",
    "                            batch_size=batch_size, \n",
    "                            num_workers=num_workers,\n",
    "                            shuffle=False)\n",
    "    \n",
    "    \n",
    "    init_time = time.time()\n",
    "\n",
    "    \n",
    "    d_t_string = datetime.datetime.now().strftime(\"%H_%M_%S_%d_%m_%Y\")\n",
    "    \n",
    "    SAVE_MODEL_PATH = (\n",
    "        f\"/results/models/{model_name}_{dataset_name}_e_warm{num_warmup_epochs}\"\n",
    "        f\"_e_train{num_train_epochs}_coeff_{clustering_loss_coeff}_\"\n",
    "        f\"{clastering_loss_type}_{d_t_string}.pt\")\n",
    "    \n",
    "    epoch_losses = []\n",
    "    c_epoch_losses = []\n",
    "    \n",
    "    \n",
    "    for epoch in range(num_warmup_epochs + num_train_epochs):\n",
    "        print('training: \\t Epoch {}/{}'.format(epoch + 1, num_warmup_epochs+ num_train_epochs))\n",
    "    \n",
    "        model.train(True)\n",
    "\n",
    "        running_loss = 0.0\n",
    "        \n",
    "        # Keep the batch number for inter-phase statistics\n",
    "        batch_num = 1\n",
    "        \n",
    "        # Images to show\n",
    "        img_counter = 0\n",
    "        c_running_loss = 0\n",
    "        \n",
    "        # Progress bar for easier tracking of the status\n",
    "        pbar = tqdm(dataloader, desc='training', unit='batch')\n",
    "        \n",
    "        times = []\n",
    "        \n",
    "        if epoch == num_warmup_epochs:\n",
    "            #init clusters_centres\n",
    "            \n",
    "            if clastering_loss_type == 'distance_based':\n",
    "                \n",
    "                kmeans = MiniBatchKMeans(n_clusters=num_clusters, \n",
    "                                          batch_size=256, \n",
    "                                          init_size=3*train_config['num_clusters'], \n",
    "                                          n_init=3)\n",
    "                \n",
    "                features = extract_features(model, dataset, train_config)\n",
    "                kmeans.fit_predict(features)\n",
    "                init_clusters = kmeans.cluster_centers_\n",
    "                clustres_centers = torch.from_numpy(init_clusters).to(device)\n",
    "                \n",
    "            if clastering_loss_type == 'KLDivLoss':\n",
    "                clastering_layer = ClusterlingLayer()\n",
    "                clastering_layer.to(device)\n",
    "\n",
    "        # update tagret distr\n",
    "        if (epoch >= num_warmup_epochs and \n",
    "            clastering_loss_type == 'KLDivLoss' and\n",
    "            (epoch - num_warmup_epochs) % num_epochs_update_target_dist == 0):\n",
    "            output_distribution, labels, preds =\\\n",
    "            calculate_predictions(model, clastering_layer, dataset, train_config)\n",
    "                \n",
    "            target_distribution = cacl_target_dist(output_distribution)\n",
    "                \n",
    "        # Iterate over data.\n",
    "        for inputs, labels in pbar:\n",
    "\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "            \n",
    "            # zero the parameter gradients\n",
    "            optimizer.zero_grad()\n",
    "            \n",
    "            outputs, features = model(inputs)\n",
    "            loss = criterion_reconstruction(outputs, inputs)\n",
    "            loss.backward(retain_graph=True)\n",
    "            \n",
    "            if epoch >= num_warmup_epochs:\n",
    "                \n",
    "                if clastering_loss_type == 'distance_based':\n",
    "                    \n",
    "                    c_loss = distance_based_clustering_loss(features, clustres_centers)\n",
    "                    \n",
    "                if clastering_loss_type == 'KLDivLoss':\n",
    "                    \n",
    "                    clusters = clastering_layer(features)\n",
    "                    \n",
    "                    cur_dist =\\\n",
    "                    target_distribution[\n",
    "                        (batch_num - 1) * batch_size : batch_num * batch_size]\n",
    "                    \n",
    "                    cur_dist =  torch.from_numpy(cur_dist).to(device)\n",
    "                    \n",
    "                    c_loss = KLDiv_clustering_loss(torch.log(clusters), cur_dist)\n",
    "                \n",
    "                (c_loss * clustering_loss_coeff).backward()\n",
    "                \n",
    "                c_running_loss += c_loss.item() * inputs.size(0)\n",
    "\n",
    "                # Some current stats\n",
    "                c_loss_batch = c_loss.item()\n",
    "                c_loss_accum = c_running_loss / ((batch_num - 1) * batch_size + inputs.size(0))\n",
    "            \n",
    "            # For keeping statistics\n",
    "            running_loss += loss.item() * inputs.size(0)\n",
    "\n",
    "            # Some current stats\n",
    "            loss_batch = loss.item()\n",
    "            loss_accum = running_loss / ((batch_num - 1) * batch_size + inputs.size(0))\n",
    "                \n",
    "            batch_num = batch_num + 1\n",
    "            \n",
    "            optimizer.step()\n",
    "              \n",
    "        print(\"--- %s seconds calculation of clustering loss per epoch---\" % (sum(times)))\n",
    "        epoch_loss = running_loss / len(dataset)\n",
    "        c_epoch_loss = c_running_loss / len(dataset)\n",
    "\n",
    "        print('Reconstruction loss: \\t Loss: {:.4f}'.format(epoch_loss))\n",
    "        epoch_losses.append(epoch_loss)\n",
    "        \n",
    "        if epoch >= num_warmup_epochs:\n",
    "            print('Clustering loss: \\t Loss: {:.4f}'.format(c_epoch_loss))\n",
    "            c_epoch_losses.append(c_epoch_loss)\n",
    "    \n",
    "    # Update scheduler\n",
    "    scheduler.step()\n",
    "    \n",
    "    time_elapsed = time.time() - init_time\n",
    "    print('Pretraining complete in {:.0f}m {:.0f}s'.format(\n",
    "        time_elapsed // 60, time_elapsed % 60))\n",
    "\n",
    "    # Save the current model state.\n",
    "    torch.save({\n",
    "            'epoch': epoch,\n",
    "            'model_state_dict': model.state_dict(),\n",
    "            'optimizer_state_dict': optimizer.state_dict(),\n",
    "            'reconstruction_loss': epoch_losses,\n",
    "            'clustering_loss' : c_epoch_losses\n",
    "            }, SAVE_MODEL_PATH) \n",
    "\n",
    "    return model, epoch_losses, c_epoch_losses, clustres_centers\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c806034-ae88-4c5b-9ff2-a96d6a806af9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "000e3207-2850-4f91-8026-348b1ceecda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "LABELED_DATASET_PATH = '/data/TCD/labeled_data_ghent.h5'\n",
    "LOGATEC_DATASET_PATH = '/data/LOG-a-TEC/test_data.h5'\n",
    "LABELED_ITS_DATASET_PATH = '/data/ITS/labeled_data_ITS_band.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0b8aca5d-71e7-4c86-b812-03e4050826dc",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "train_config = {\n",
    "    'num_warmup_epochs': 4,\n",
    "    'num_train_epochs': 10,\n",
    "    'clustring_loss_type': 'KLDivLoss', # KLDivLoss, distance_based\n",
    "    'num_workers': 12,\n",
    "    'batch_size': 1024,\n",
    "    'num_clusters': 10,\n",
    "    'update_target_dist_epochs': 5,\n",
    "    'clustering_loss_coeff': 0.1,\n",
    "    'device': device\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "37067990-e75b-436d-8d32-dad0130ea347",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training: \t Epoch 1/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.72batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0344\n",
      "training: \t Epoch 2/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.53batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0340\n",
      "training: \t Epoch 3/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0336\n",
      "training: \t Epoch 4/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.06batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0328\n",
      "training: \t Epoch 5/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training:   0%|          | 0/172 [00:00<?, ?batch/s]/opt/conda/lib/python3.11/site-packages/torch/nn/functional.py:2949: UserWarning: reduction: 'mean' divides the total loss by both the batch size and the support size.'batchmean' divides only by the batch size, and aligns with the KL div math definition.'mean' will be changed to behave the same as 'batchmean' in the next major release.\n",
      "  warnings.warn(\n",
      "training: 100%|██████████| 172/172 [00:27<00:00,  6.28batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0297\n",
      "Clustering loss: \t Loss: 0.0031\n",
      "training: \t Epoch 6/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:14<00:00, 12.20batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0315\n",
      "Clustering loss: \t Loss: 0.0025\n",
      "training: \t Epoch 7/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.58batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0306\n",
      "Clustering loss: \t Loss: 0.0023\n",
      "training: \t Epoch 8/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.64batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0297\n",
      "Clustering loss: \t Loss: 0.0023\n",
      "training: \t Epoch 9/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.15batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0289\n",
      "Clustering loss: \t Loss: 0.0023\n",
      "training: \t Epoch 10/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:25<00:00,  6.68batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0246\n",
      "Clustering loss: \t Loss: 0.0034\n",
      "training: \t Epoch 11/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.72batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0276\n",
      "Clustering loss: \t Loss: 0.0028\n",
      "training: \t Epoch 12/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.68batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0270\n",
      "Clustering loss: \t Loss: 0.0028\n",
      "training: \t Epoch 13/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.55batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0263\n",
      "Clustering loss: \t Loss: 0.0028\n",
      "training: \t Epoch 14/14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.07batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0258\n",
      "Clustering loss: \t Loss: 0.0027\n",
      "Pretraining complete in 3m 32s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model = AE_CNN_1D()\n",
    "model.to(device)\n",
    "\n",
    "train_dataset = LabeledGhentDataset(LABELED_DATASET_PATH, transform=torch.tensor, scale=True)\n",
    "optimizer = optim.AdamW(model.parameters(), lr=1e-5)\n",
    "\n",
    "# Reconstruction loss\n",
    "criterion = nn.MSELoss()\n",
    "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=200, gamma=0.1)\n",
    "\n",
    "model, loss, c_loss, cluster_centres \\\n",
    "= train(model, train_dataset, criterion, scheduler, optimizer, train_config)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dfbe5897-7192-43c8-88a9-b1d5f72b0f6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "features = extract_features(model, train_dataset, train_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "87de4c8e-68ba-4df6-9141-77edabf3406a",
   "metadata": {},
   "outputs": [],
   "source": [
    "kmeans = MiniBatchKMeans(\n",
    "        n_clusters=train_config['num_clusters'], \n",
    "        batch_size=256,\n",
    "        init_size=3*train_config['num_clusters'], \n",
    "        n_init=3)\n",
    "labels = kmeans.fit_predict(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "11e9baba-db05-43de-b1fd-f6d621485e13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 640x480 with 1 Axes>, <Axes: >)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "selected_ids = np.random.choice(len(train_dataset), size = 10000)\n",
    "plot_tsne(labels[selected_ids], features[selected_ids])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d3ebac56-70d5-4a25-a849-8397ae72497a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training: \t Epoch 1/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.49batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0304\n",
      "training: \t Epoch 2/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.74batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0287\n",
      "training: \t Epoch 3/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.79batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0270\n",
      "training: \t Epoch 4/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.38batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0256\n",
      "training: \t Epoch 5/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:26<00:00,  6.45batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0269\n",
      "Clustering loss: \t Loss: 0.0464\n",
      "training: \t Epoch 6/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.30batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0251\n",
      "Clustering loss: \t Loss: 0.0389\n",
      "training: \t Epoch 7/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.08batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0241\n",
      "Clustering loss: \t Loss: 0.0385\n",
      "training: \t Epoch 8/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.50batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0233\n",
      "Clustering loss: \t Loss: 0.0378\n",
      "training: \t Epoch 9/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:16<00:00, 10.58batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0226\n",
      "Clustering loss: \t Loss: 0.0373\n",
      "training: \t Epoch 10/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:14<00:00, 11.91batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0220\n",
      "Clustering loss: \t Loss: 0.0369\n",
      "training: \t Epoch 11/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.91batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0214\n",
      "Clustering loss: \t Loss: 0.0365\n",
      "training: \t Epoch 12/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.07batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0208\n",
      "Clustering loss: \t Loss: 0.0362\n",
      "training: \t Epoch 13/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:14<00:00, 12.14batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0202\n",
      "Clustering loss: \t Loss: 0.0358\n",
      "training: \t Epoch 14/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:14<00:00, 12.27batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0197\n",
      "Clustering loss: \t Loss: 0.0354\n",
      "training: \t Epoch 15/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.74batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0192\n",
      "Clustering loss: \t Loss: 0.0351\n",
      "training: \t Epoch 16/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.78batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0187\n",
      "Clustering loss: \t Loss: 0.0348\n",
      "training: \t Epoch 17/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.27batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0182\n",
      "Clustering loss: \t Loss: 0.0345\n",
      "training: \t Epoch 18/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.12batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0178\n",
      "Clustering loss: \t Loss: 0.0341\n",
      "training: \t Epoch 19/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.28batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0173\n",
      "Clustering loss: \t Loss: 0.0338\n",
      "training: \t Epoch 20/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.20batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0169\n",
      "Clustering loss: \t Loss: 0.0336\n",
      "training: \t Epoch 21/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 13.23batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0165\n",
      "Clustering loss: \t Loss: 0.0334\n",
      "training: \t Epoch 22/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.38batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0161\n",
      "Clustering loss: \t Loss: 0.0333\n",
      "training: \t Epoch 23/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:12<00:00, 13.44batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0157\n",
      "Clustering loss: \t Loss: 0.0331\n",
      "training: \t Epoch 24/24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training: 100%|██████████| 172/172 [00:13<00:00, 12.59batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0 seconds calculation of clustering loss per epoch---\n",
      "Reconstruction loss: \t Loss: 0.0154\n",
      "Clustering loss: \t Loss: 0.0330\n",
      "Pretraining complete in 5m 36s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train_config = {\n",
    "    'num_warmup_epochs': 4,\n",
    "    'num_train_epochs': 20,\n",
    "    'clustring_loss_type': 'distance_based', # KLDivLoss, distance_based\n",
    "    'num_workers': 12,\n",
    "    'batch_size': 1024,\n",
    "    'num_clusters': 10,\n",
    "    'update_target_dist_epochs': 5,\n",
    "    'clustering_loss_coeff': 0.1,\n",
    "    'device': device\n",
    "}\n",
    "\n",
    "model = AE_CNN_1D()\n",
    "model.to(device)\n",
    "\n",
    "train_dataset = LabeledGhentDataset(LABELED_DATASET_PATH, transform=torch.tensor, scale=True)\n",
    "optimizer = optim.AdamW(model.parameters(), lr=1e-5)\n",
    "\n",
    "# Reconstruction loss\n",
    "criterion = nn.MSELoss()\n",
    "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=200, gamma=0.1)\n",
    "\n",
    "model, loss, c_loss, cluster_centres \\\n",
    "= train(model, train_dataset, criterion, scheduler, optimizer, train_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "67eb56b0-6b4d-4e4f-b919-2e234cb4fb56",
   "metadata": {},
   "outputs": [],
   "source": [
    "features = extract_features(model, train_dataset, train_config)\n",
    "kmeans = MiniBatchKMeans(\n",
    "        n_clusters=train_config['num_clusters'], \n",
    "        batch_size=256,\n",
    "        init_size=3*train_config['num_clusters'], \n",
    "        n_init=3)\n",
    "labels = kmeans.fit_predict(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "29bb26df-34e3-4037-8417-b9fb7be4e787",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 640x480 with 1 Axes>, <Axes: >)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "selected_ids = np.random.choice(len(train_dataset), size = 10000)\n",
    "plot_tsne(labels[selected_ids], features[selected_ids])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9903314d-68db-47dc-9da7-755d28790ec9",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}