{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# X-Pert for Unseen Perturbation Prediction\n",
        "\n",
        "This notebook is a refactored and streamlined version of the original workflow. It:\n",
        "- keeps the same behavior and outputs;\n",
        "- removes redundant code and paths;\n",
        "- organizes steps into clear sections with English markdown.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Imports\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Core\n",
        "import os, json, time, copy, warnings\n",
        "from pathlib import Path\n",
        "from typing import Dict\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "from torch import nn\n",
        "from tqdm import tqdm\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# X-Pert package\n",
        "import xpert\n",
        "from xpert.models import TransformerGenerator\n",
        "from xpert.loss import masked_relative_error, masked_mse_loss, masked_huber_loss\n",
        "from xpert.external_model.scgpt.gene_tokenizer import GeneVocab\n",
        "from xpert.external_model.gears.inference import compute_metrics\n",
        "from xpert.data import Byte_Pert_Data\n",
        "\n",
        "# Utils\n",
        "from xpert.utils import fix_seed, merge_plot\n",
        "from xpert.external_model.scgpt.util import set_seed, map_raw_id_to_vocab_id, add_file_handler\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Global Settings and Logger\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "INFO:xpert:Running on 2025-10-31 22:48:13\n"
          ]
        }
      ],
      "source": [
        "# Reproducibility\n",
        "set_seed(42)\n",
        "fix_seed(2024)\n",
        "\n",
        "# Logger to file\n",
        "save_root = Path(\"./NormanWeissman2019_filtered/model_mode_scFlamingo_v18\")\n",
        "save_root.mkdir(parents=True, exist_ok=True)\n",
        "logger = xpert.logger\n",
        "add_file_handler(logger, save_root / \"run.log\")\n",
        "logger.info(f\"Running on {time.strftime('%Y-%m-%d %H:%M:%S')}\")\n",
        "\n",
        "# Plot default\n",
        "plt.rcdefaults()\n",
        "warnings.filterwarnings(\"ignore\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Data Configuration\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Dataset and split\n",
        "prefix = 'Norman2019'\n",
        "add_control = False\n",
        "\n",
        "# Paths\n",
        "if True:  # single env path\n",
        "    # data root for intermediate artifacts\n",
        "    # tmp_dir = Path('/nfs/public/lichen/results/single_cell_perturbation/perturbation_benchmark/scPerturb')\n",
        "    # save_dir = tmp_dir / prefix / 'GEARS_v2-prefix_NormanWeissman2019_filtered-pert_cell_filter_100-seed_2024-split_type_1-var_num_5000-num_de_genes_20-bs_train_32-bs_test_32'\n",
        "    # save_dir.mkdir(parents=True, exist_ok=True)\n",
        "    pass\n",
        "\n",
        "# scGPT pretrained model\n",
        "load_model_dir = Path('../../data/scGPT_human')\n",
        "model_config_file = load_model_dir / 'args.json'\n",
        "model_file = load_model_dir / 'best_model.pt'\n",
        "vocab_file = load_model_dir / 'vocab.json'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Model Hyperparameters\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Noted that we use nlayers = 2 here to accelerate training. In the original paper, we use nlayers = 12 to fully release the model performance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Training hyperparameters\n",
        "batch_size = 64\n",
        "eval_batch_size = 64\n",
        "log_interval = 100\n",
        "\n",
        "# Cell encoder hyperparameters\n",
        "embsize = 512\n",
        "d_hid = 512\n",
        "nlayers = 2\n",
        "nhead = 8\n",
        "n_layers_cls = 3\n",
        "dropout = 0.2\n",
        "use_fast_transformer = True\n",
        "amp = True\n",
        "device_ids = [4, 5, 6, 7]\n",
        "gpt_emb_dim = 1536\n",
        "\n",
        "# add-token settings\n",
        "load_encoder_plus = True  # copy encoder weights to encoder_plus when adding tokens\n",
        "include_zero_gene = \"all\"\n",
        "\n",
        "\n",
        "# Task settings\n",
        "\n",
        "# X-Pert settings\n",
        "delta_mode = False\n",
        "attn_gate_mode = True\n",
        "load_cxg_weight = True\n",
        "mask_mode = True\n",
        "pert_mode = 'gene'\n",
        "pert_flag_mode = True\n",
        "use_scgpt_layer = True\n",
        "use_scgpt_input = True\n",
        "add_token = True\n",
        "init_mode = False\n",
        "cross_mode = True\n",
        "\n",
        "# Scheduler\n",
        "epochs = 2\n",
        "lr = 5e-5\n",
        "scheduler_type = 'cosine_warm'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 5. Helper Losses and Training/Eval Routines\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "# LR scheduler (cosine with warmup)\n",
        "from torch.optim.lr_scheduler import LambdaLR\n",
        "import math\n",
        "\n",
        "def get_cosine_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps):\n",
        "    def lr_lambda(current_step):\n",
        "        if current_step < num_warmup_steps:\n",
        "            return float(current_step) / float(max(1, num_warmup_steps))\n",
        "        progress = (current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))\n",
        "        return max(0.0, 0.5 * (1.0 + math.cos(math.pi * progress)))\n",
        "    return LambdaLR(optimizer, lr_lambda)\n",
        "\n",
        "# Training / Evaluation routines (behavior-preserving)\n",
        "def train(model: nn.Module, train_loader: torch.utils.data.DataLoader) -> None:\n",
        "    model.train()\n",
        "    total_loss, total_mse = 0.0, 0.0\n",
        "    start_time = time.time()\n",
        "    num_batches = len(train_loader)\n",
        "\n",
        "    for batch, batch_data in enumerate(tqdm(train_loader)):\n",
        "        batch_size = len(batch_data.y)\n",
        "        batch_data.to(device)\n",
        "        x: torch.Tensor = batch_data.x\n",
        "        ori_gene_values = x\n",
        "        pert_flags = batch_data.pert_flags.long()\n",
        "        target_gene_values = batch_data.y\n",
        "\n",
        "        # prepare perturbation embeddings (single- or multi-)\n",
        "        batch_perts = batch_data.pert\n",
        "        batch_perts = [[i.split('+')[0]] if 'ctrl' in i else i.split('+') for i in batch_perts]\n",
        "        max_pert_len = max([len(perts) for perts in batch_perts])\n",
        "        batch_pert_embed = torch.zeros(batch_size, max_pert_len, gpt_emb_dim).float()\n",
        "        pert_mask = torch.ones(batch_size, max_pert_len)\n",
        "        for i, perts in enumerate(batch_perts):\n",
        "            for j, pert in enumerate(perts):\n",
        "                batch_pert_embed[i, j, :] = torch.tensor(np.array(pert_embed_dict[pert]))\n",
        "                pert_mask[i, j] = 0\n",
        "        batch_pert_embed = batch_pert_embed.to(device)\n",
        "\n",
        "        # select input genes\n",
        "        if include_zero_gene in [\"all\", \"batch-wise\"]:\n",
        "            if include_zero_gene == \"all\":\n",
        "                input_gene_ids = torch.arange(n_genes, device=device, dtype=torch.long)\n",
        "            else:\n",
        "                input_gene_ids = (\n",
        "                    ori_gene_values.nonzero()[:, 1].flatten().unique().sort()[0]\n",
        "                )\n",
        "            if len(input_gene_ids) > max_seq_len:\n",
        "                input_gene_ids = torch.randperm(len(input_gene_ids), device=device)[:max_seq_len]\n",
        "            input_values = ori_gene_values[:, input_gene_ids]\n",
        "            input_pert_flags = pert_flags[:, input_gene_ids]\n",
        "            target_values = target_gene_values[:, input_gene_ids]\n",
        "            if delta_mode:\n",
        "                target_values = target_values - input_values\n",
        "            mapped_input_gene_ids = map_raw_id_to_vocab_id(input_gene_ids, gene_ids)\n",
        "            mapped_input_gene_ids = mapped_input_gene_ids.repeat(batch_size, 1)\n",
        "            src_key_padding_mask = torch.zeros_like(input_values, dtype=torch.bool, device=device)\n",
        "\n",
        "        with torch.cuda.amp.autocast(enabled=amp):\n",
        "            output_dict = model(\n",
        "                mapped_input_gene_ids,\n",
        "                input_values,\n",
        "                input_pert_flags,\n",
        "                src_key_padding_mask=src_key_padding_mask,\n",
        "                batch_pert_embed=batch_pert_embed,\n",
        "                pert_mask=pert_mask,\n",
        "                batch_dosages_pad=None,\n",
        "            )\n",
        "            output_values = output_dict[\"mlm_output\"]\n",
        "            masked_positions = torch.ones_like(input_values, dtype=torch.bool)\n",
        "            loss = loss_mse = criterion(output_values, target_values, masked_positions)\n",
        "\n",
        "        model.zero_grad()\n",
        "        scaler.scale(loss).backward()\n",
        "        scaler.unscale_(optimizer)\n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
        "        scaler.step(optimizer)\n",
        "        scaler.update()\n",
        "        if scheduler_type in ['cosine', 'cosine_warm']:\n",
        "            scheduler.step()\n",
        "\n",
        "        total_loss += loss.item()\n",
        "        total_mse += loss_mse.item()\n",
        "        if batch % log_interval == 0 and batch > 0:\n",
        "            lr_ = scheduler.get_last_lr()[0] if scheduler_type != 'steplr' else scheduler.get_last_lr()[0]\n",
        "            ms_per_batch = (time.time() - start_time) * 1000 / log_interval\n",
        "            cur_loss = total_loss / log_interval\n",
        "            cur_mse = total_mse / log_interval\n",
        "            logger.info(f\"| epoch {epoch:3d} | {batch:3d}/{num_batches:3d} batches | lr {lr_:07.6f} | ms/batch {ms_per_batch:5.2f} | loss {cur_loss:5.5f} | mse {cur_mse:5.5f} |\")\n",
        "            total_loss = 0\n",
        "            total_mse = 0\n",
        "            start_time = time.time()\n",
        "\n",
        "@torch.no_grad()\n",
        "def evaluate(model: nn.Module, val_loader: torch.utils.data.DataLoader):\n",
        "    model.eval()\n",
        "    total_loss = 0.0\n",
        "    total_error = 0.0\n",
        "    for batch, batch_data in enumerate(val_loader):\n",
        "        batch_size = len(batch_data.y)\n",
        "        batch_data.to(device)\n",
        "        x: torch.Tensor = batch_data.x\n",
        "        ori_gene_values = x\n",
        "        pert_flags = batch_data.pert_flags.long()\n",
        "        target_gene_values = batch_data.y\n",
        "\n",
        "        batch_perts = batch_data.pert\n",
        "        batch_perts = [[i.split('+')[0]] if 'ctrl' in i else i.split('+') for i in batch_perts]\n",
        "        max_pert_len = max([len(perts) for perts in batch_perts])\n",
        "        batch_pert_embed = torch.zeros(batch_size, max_pert_len, gpt_emb_dim).float()\n",
        "        pert_mask = torch.ones(batch_size, max_pert_len)\n",
        "        for i, perts in enumerate(batch_perts):\n",
        "            for j, pert in enumerate(perts):\n",
        "                batch_pert_embed[i, j, :] = torch.tensor(np.array(pert_embed_dict[pert]))\n",
        "                pert_mask[i, j] = 0\n",
        "        batch_pert_embed = batch_pert_embed.to(device)\n",
        "\n",
        "        if include_zero_gene in [\"all\", \"batch-wise\"]:\n",
        "            if include_zero_gene == \"all\":\n",
        "                input_gene_ids = torch.arange(n_genes, device=device)\n",
        "            else:\n",
        "                input_gene_ids = (\n",
        "                    ori_gene_values.nonzero()[:, 1].flatten().unique().sort()[0]\n",
        "                )\n",
        "            if len(input_gene_ids) > max_seq_len:\n",
        "                input_gene_ids = torch.randperm(len(input_gene_ids), device=device)[:max_seq_len]\n",
        "            input_values = ori_gene_values[:, input_gene_ids]\n",
        "            input_pert_flags = pert_flags[:, input_gene_ids]\n",
        "            target_values = target_gene_values[:, input_gene_ids]\n",
        "            if delta_mode:\n",
        "                target_values = target_values - input_values\n",
        "            mapped_input_gene_ids = map_raw_id_to_vocab_id(input_gene_ids, gene_ids)\n",
        "            mapped_input_gene_ids = mapped_input_gene_ids.repeat(batch_size, 1)\n",
        "            src_key_padding_mask = torch.zeros_like(input_values, dtype=torch.bool, device=input_values.device)\n",
        "\n",
        "        with torch.cuda.amp.autocast(enabled=amp):\n",
        "            output_dict = model(\n",
        "                mapped_input_gene_ids,\n",
        "                input_values,\n",
        "                input_pert_flags,\n",
        "                src_key_padding_mask=src_key_padding_mask,\n",
        "                batch_pert_embed=batch_pert_embed,\n",
        "                pert_mask=pert_mask,\n",
        "                batch_dosages_pad=None,\n",
        "                # CLS=CLS, CCE=CCE, MVC=MVC, ECS=ECS, do_sample=True,\n",
        "            )\n",
        "            output_values = output_dict[\"mlm_output\"]\n",
        "            masked_positions = torch.ones_like(input_values, dtype=torch.bool, device=input_values.device)\n",
        "            loss = criterion(output_values, target_values, masked_positions)\n",
        "        total_loss += loss.item()\n",
        "        total_error += masked_relative_error(output_values, target_values, masked_positions).item()\n",
        "    return total_loss / len(val_loader), total_error / len(val_loader)\n",
        "\n",
        "@torch.no_grad()\n",
        "def pred_perturb_new(model, batch_data, include_zero_gene=\"batch-wise\", gene_ids=None, amp=True):\n",
        "    model.eval()\n",
        "    device = next(model.parameters()).device\n",
        "    batch_data.to(device)\n",
        "    batch_size = len(batch_data.pert)\n",
        "    x: torch.Tensor = batch_data.x\n",
        "    ori_gene_values = x\n",
        "    pert_flags = batch_data.pert_flags.long()\n",
        "\n",
        "    batch_perts = batch_data.pert\n",
        "    batch_perts = [[i.split('+')[0]] if 'ctrl' in i else i.split('+') for i in batch_perts]\n",
        "    max_pert_len = max([len(perts) for perts in batch_perts])\n",
        "    batch_pert_embed = torch.zeros(batch_size, max_pert_len, gpt_emb_dim).float()\n",
        "    pert_mask = torch.ones(batch_size, max_pert_len)\n",
        "    for i, perts in enumerate(batch_perts):\n",
        "        for j, pert in enumerate(perts):\n",
        "            batch_pert_embed[i, j, :] = torch.tensor(np.array(pert_embed_dict[pert]))\n",
        "            pert_mask[i, j] = 0\n",
        "    batch_pert_embed = batch_pert_embed.to(device)\n",
        "\n",
        "    if include_zero_gene in [\"all\", \"batch-wise\"]:\n",
        "        assert gene_ids is not None\n",
        "        if include_zero_gene == \"all\":\n",
        "            input_gene_ids = torch.arange(ori_gene_values.size(1), device=device)\n",
        "        else:\n",
        "            input_gene_ids = (\n",
        "                ori_gene_values.nonzero()[:, 1].flatten().unique().sort()[0]\n",
        "            )\n",
        "        input_values = ori_gene_values[:, input_gene_ids]\n",
        "        input_pert_flags = pert_flags[:, input_gene_ids]\n",
        "        mapped_input_gene_ids = map_raw_id_to_vocab_id(input_gene_ids, gene_ids)\n",
        "        mapped_input_gene_ids = mapped_input_gene_ids.repeat(batch_size, 1)\n",
        "        src_key_padding_mask = torch.zeros_like(input_values, dtype=torch.bool, device=device)\n",
        "        with torch.cuda.amp.autocast(enabled=amp):\n",
        "            output_dict = model(\n",
        "                mapped_input_gene_ids,\n",
        "                input_values,\n",
        "                input_pert_flags,\n",
        "                src_key_padding_mask=src_key_padding_mask,\n",
        "                batch_pert_embed=batch_pert_embed,\n",
        "                pert_mask=pert_mask,\n",
        "                batch_dosages_pad=None,\n",
        "                # CLS=False, CCE=False, MVC=False, ECS=False, do_sample=True,\n",
        "            )\n",
        "        output_values = output_dict[\"mlm_output\"].float()\n",
        "        pred_gene_values = torch.zeros_like(ori_gene_values)\n",
        "        pred_gene_values[:, input_gene_ids] = output_values\n",
        "        if delta_mode:\n",
        "            pred_gene_values = input_values + pred_gene_values\n",
        "    return pred_gene_values\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "def eval_perturb_new(\n",
        "    loader,\n",
        "    model,\n",
        "    device: torch.device,\n",
        "):\n",
        "    \"\"\"\n",
        "    Run model in inference mode using a given data loader.\n",
        "    Returns a dict with predictions on all genes and DE gene subsets, per the original logic.\n",
        "    \"\"\"\n",
        "    model.eval()\n",
        "    model.to(device)\n",
        "\n",
        "    pert_cat = []\n",
        "    pred = []\n",
        "    truth = []\n",
        "    pred_de = []\n",
        "    truth_de = []\n",
        "    results = {}\n",
        "\n",
        "    for itr, batch in enumerate(loader):\n",
        "        batch.to(device)\n",
        "        pert_cat.extend(batch.pert)\n",
        "\n",
        "        with torch.no_grad():\n",
        "            p = pred_perturb_new(model, batch, include_zero_gene, gene_ids=gene_ids)\n",
        "            t = batch.y\n",
        "            pred.extend(p.cpu())\n",
        "            truth.extend(t.cpu())\n",
        "\n",
        "            # Differentially expressed genes\n",
        "            for bidx, de_idx in enumerate(batch.de_idx):\n",
        "                pred_de.append(p[bidx, de_idx])\n",
        "                truth_de.append(t[bidx, de_idx])\n",
        "\n",
        "    # all genes\n",
        "    results[\"pert_cat\"] = np.array(pert_cat)\n",
        "    pred = torch.stack(pred)\n",
        "    truth = torch.stack(truth)\n",
        "    results[\"pred\"] = pred.detach().cpu().numpy().astype(np.float64)\n",
        "    results[\"truth\"] = truth.detach().cpu().numpy().astype(np.float64)\n",
        "\n",
        "    # DE genes\n",
        "    pred_de = torch.stack(pred_de)\n",
        "    truth_de = torch.stack(truth_de)\n",
        "    results[\"pred_de\"] = pred_de.detach().cpu().numpy().astype(np.float64)\n",
        "    results[\"truth_de\"] = truth_de.detach().cpu().numpy().astype(np.float64)\n",
        "\n",
        "    return results\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 6. Data Loading and Tokenization\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 156/156 [00:38<00:00,  4.02it/s]\n",
            "100%|██████████| 45/45 [00:11<00:00,  3.99it/s]\n",
            "100%|██████████| 23/23 [00:06<00:00,  3.74it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "========== get Data_scGPT finished!\n",
            "add adata finished\n",
            "add condition finished\n",
            "add set2conditions finished\n"
          ]
        }
      ],
      "source": [
        "# Build dataset via Byte_Pert_Data (behavior preserved)\n",
        "pert_cell_filter = 100\n",
        "seed = 2024\n",
        "split_type = 1\n",
        "split_ratio = [0.7, 0.2, 0.1]\n",
        "var_num = 5000\n",
        "num_de_genes = 20\n",
        "bs_train = 80\n",
        "bs_test = bs_train * 2\n",
        "\n",
        "# Load preprocessed pert_data object (same as original)\n",
        "# You can also reconstruct it by running the upstream data pipeline\n",
        "pert_data_pkl = '../../data/Norman2019/pert_data.pkl'\n",
        "pert_data = pd.read_pickle(pert_data_pkl)\n",
        "\n",
        "# Build X-Pert training datasets\n",
        "pert_data.get_Data_scgpt(\n",
        "    num_de_genes=pert_data.num_de_genes,\n",
        "    dataset_name=['train', 'test', 'val'],\n",
        "    add_control=add_control,\n",
        ")\n",
        "\n",
        "# GEARS-specific additions\n",
        "pert_data.modify_gears()\n",
        "\n",
        "# DataLoaders\n",
        "trainloader, testloader, valloader = pert_data.get_dataloader(\n",
        "    mode='all', bs_train=int(bs_train)*len(device_ids), bs_test=int(bs_test)*len(device_ids)\n",
        ")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 7. Perturbation Embeddings and Vocabulary\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "INFO:xpert:match 5040/5040 genes in vocabulary of size 61194.\n"
          ]
        }
      ],
      "source": [
        "# Load perturbation embeddings\n",
        "if True:\n",
        "    gpt_embed_root = Path('../../data/')\n",
        "    gene_embed = pd.read_csv(gpt_embed_root / prefix / 'pert_embed.csv', sep=',', index_col=0)\n",
        "\n",
        "# Collect all perturbation names\n",
        "total_perts = []\n",
        "for pert_list in [pert_data.train_perts, pert_data.test_perts, pert_data.val_perts]:\n",
        "    for pert in pert_list:\n",
        "        if ';' in pert:\n",
        "            total_perts.extend(pert.split('; '))\n",
        "        else:\n",
        "            total_perts.append(pert)\n",
        "        \n",
        "total_perts = np.unique(total_perts)\n",
        "pert_embed_dict: Dict[str, np.ndarray] = {}\n",
        "np.random.seed(2024)\n",
        "for pert in total_perts:\n",
        "    if pert in gene_embed.columns:\n",
        "        pert_embed_dict[pert] = gene_embed.loc[:, pert].values\n",
        "    else:\n",
        "        pert_embed_dict[pert] = gene_embed.loc[:, np.random.choice(gene_embed.columns, 1)[0]].values\n",
        "\n",
        "# Load vocab and extend if needed\n",
        "vocab = GeneVocab.from_file(vocab_file)\n",
        "special_tokens = [\"<pad>\", \"<cls>\", \"<eoc>\"]\n",
        "for s in special_tokens:\n",
        "    if s not in vocab:\n",
        "        vocab.append_token(s)\n",
        "        \n",
        "vocab_ori = copy.deepcopy(vocab)\n",
        "if add_token:\n",
        "    # add non-overlap genes to the vocab\n",
        "    add_genes = np.setdiff1d(pert_data.adata.var_names, list(vocab.get_stoi().keys()))\n",
        "    for gene in add_genes:\n",
        "        if gene not in vocab:\n",
        "            vocab.append_token(gene)\n",
        "\n",
        "# Mark genes present in vocab\n",
        "pert_data.adata.var[\"id_in_vocab\"] = [1 if gene in vocab else -1 for gene in pert_data.adata.var_names]\n",
        "gene_ids_in_vocab = np.array(pert_data.adata.var[\"id_in_vocab\"])\n",
        "logger.info(f\"match {np.sum(gene_ids_in_vocab >= 0)}/{len(gene_ids_in_vocab)} genes in vocabulary of size {len(vocab)}.\")\n",
        "\n",
        "# Build token ids for input genes\n",
        "genes = pert_data.adata.var[\"gene_name\"].tolist() if \"gene_name\" in pert_data.adata.var.columns else pert_data.adata.var_names.tolist()\n",
        "vocab.set_default_index(vocab[\"<pad>\"])\n",
        "gene_ids = np.array([vocab[g] if g in vocab else vocab[\"<pad>\"] for g in genes], dtype=int)\n",
        "n_genes = len(genes)\n",
        "\n",
        "# longer than Sequence length\n",
        "max_seq_len = 6000\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 8. Build Model, Optimizer and Scheduler\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Using simple batchnorm instead of domain specific batchnorm\n",
            "Missing keys: []\n",
            "Unexpected keys: ['transformer_encoder.layers.2.self_attn.Wqkv.weight', 'transformer_encoder.layers.2.self_attn.Wqkv.bias', 'transformer_encoder.layers.2.self_attn.out_proj.weight', 'transformer_encoder.layers.2.self_attn.out_proj.bias', 'transformer_encoder.layers.2.linear1.weight', 'transformer_encoder.layers.2.linear1.bias', 'transformer_encoder.layers.2.linear2.weight', 'transformer_encoder.layers.2.linear2.bias', 'transformer_encoder.layers.2.norm1.weight', 'transformer_encoder.layers.2.norm1.bias', 'transformer_encoder.layers.2.norm2.weight', 'transformer_encoder.layers.2.norm2.bias', 'transformer_encoder.layers.3.self_attn.Wqkv.weight', 'transformer_encoder.layers.3.self_attn.Wqkv.bias', 'transformer_encoder.layers.3.self_attn.out_proj.weight', 'transformer_encoder.layers.3.self_attn.out_proj.bias', 'transformer_encoder.layers.3.linear1.weight', 'transformer_encoder.layers.3.linear1.bias', 'transformer_encoder.layers.3.linear2.weight', 'transformer_encoder.layers.3.linear2.bias', 'transformer_encoder.layers.3.norm1.weight', 'transformer_encoder.layers.3.norm1.bias', 'transformer_encoder.layers.3.norm2.weight', 'transformer_encoder.layers.3.norm2.bias', 'transformer_encoder.layers.4.self_attn.Wqkv.weight', 'transformer_encoder.layers.4.self_attn.Wqkv.bias', 'transformer_encoder.layers.4.self_attn.out_proj.weight', 'transformer_encoder.layers.4.self_attn.out_proj.bias', 'transformer_encoder.layers.4.linear1.weight', 'transformer_encoder.layers.4.linear1.bias', 'transformer_encoder.layers.4.linear2.weight', 'transformer_encoder.layers.4.linear2.bias', 'transformer_encoder.layers.4.norm1.weight', 'transformer_encoder.layers.4.norm1.bias', 'transformer_encoder.layers.4.norm2.weight', 'transformer_encoder.layers.4.norm2.bias', 'transformer_encoder.layers.5.self_attn.Wqkv.weight', 'transformer_encoder.layers.5.self_attn.Wqkv.bias', 'transformer_encoder.layers.5.self_attn.out_proj.weight', 'transformer_encoder.layers.5.self_attn.out_proj.bias', 'transformer_encoder.layers.5.linear1.weight', 'transformer_encoder.layers.5.linear1.bias', 'transformer_encoder.layers.5.linear2.weight', 'transformer_encoder.layers.5.linear2.bias', 'transformer_encoder.layers.5.norm1.weight', 'transformer_encoder.layers.5.norm1.bias', 'transformer_encoder.layers.5.norm2.weight', 'transformer_encoder.layers.5.norm2.bias', 'transformer_encoder.layers.6.self_attn.Wqkv.weight', 'transformer_encoder.layers.6.self_attn.Wqkv.bias', 'transformer_encoder.layers.6.self_attn.out_proj.weight', 'transformer_encoder.layers.6.self_attn.out_proj.bias', 'transformer_encoder.layers.6.linear1.weight', 'transformer_encoder.layers.6.linear1.bias', 'transformer_encoder.layers.6.linear2.weight', 'transformer_encoder.layers.6.linear2.bias', 'transformer_encoder.layers.6.norm1.weight', 'transformer_encoder.layers.6.norm1.bias', 'transformer_encoder.layers.6.norm2.weight', 'transformer_encoder.layers.6.norm2.bias', 'transformer_encoder.layers.7.self_attn.Wqkv.weight', 'transformer_encoder.layers.7.self_attn.Wqkv.bias', 'transformer_encoder.layers.7.self_attn.out_proj.weight', 'transformer_encoder.layers.7.self_attn.out_proj.bias', 'transformer_encoder.layers.7.linear1.weight', 'transformer_encoder.layers.7.linear1.bias', 'transformer_encoder.layers.7.linear2.weight', 'transformer_encoder.layers.7.linear2.bias', 'transformer_encoder.layers.7.norm1.weight', 'transformer_encoder.layers.7.norm1.bias', 'transformer_encoder.layers.7.norm2.weight', 'transformer_encoder.layers.7.norm2.bias', 'transformer_encoder.layers.8.self_attn.Wqkv.weight', 'transformer_encoder.layers.8.self_attn.Wqkv.bias', 'transformer_encoder.layers.8.self_attn.out_proj.weight', 'transformer_encoder.layers.8.self_attn.out_proj.bias', 'transformer_encoder.layers.8.linear1.weight', 'transformer_encoder.layers.8.linear1.bias', 'transformer_encoder.layers.8.linear2.weight', 'transformer_encoder.layers.8.linear2.bias', 'transformer_encoder.layers.8.norm1.weight', 'transformer_encoder.layers.8.norm1.bias', 'transformer_encoder.layers.8.norm2.weight', 'transformer_encoder.layers.8.norm2.bias', 'transformer_encoder.layers.9.self_attn.Wqkv.weight', 'transformer_encoder.layers.9.self_attn.Wqkv.bias', 'transformer_encoder.layers.9.self_attn.out_proj.weight', 'transformer_encoder.layers.9.self_attn.out_proj.bias', 'transformer_encoder.layers.9.linear1.weight', 'transformer_encoder.layers.9.linear1.bias', 'transformer_encoder.layers.9.linear2.weight', 'transformer_encoder.layers.9.linear2.bias', 'transformer_encoder.layers.9.norm1.weight', 'transformer_encoder.layers.9.norm1.bias', 'transformer_encoder.layers.9.norm2.weight', 'transformer_encoder.layers.9.norm2.bias', 'transformer_encoder.layers.10.self_attn.Wqkv.weight', 'transformer_encoder.layers.10.self_attn.Wqkv.bias', 'transformer_encoder.layers.10.self_attn.out_proj.weight', 'transformer_encoder.layers.10.self_attn.out_proj.bias', 'transformer_encoder.layers.10.linear1.weight', 'transformer_encoder.layers.10.linear1.bias', 'transformer_encoder.layers.10.linear2.weight', 'transformer_encoder.layers.10.linear2.bias', 'transformer_encoder.layers.10.norm1.weight', 'transformer_encoder.layers.10.norm1.bias', 'transformer_encoder.layers.10.norm2.weight', 'transformer_encoder.layers.10.norm2.bias', 'transformer_encoder.layers.11.self_attn.Wqkv.weight', 'transformer_encoder.layers.11.self_attn.Wqkv.bias', 'transformer_encoder.layers.11.self_attn.out_proj.weight', 'transformer_encoder.layers.11.self_attn.out_proj.bias', 'transformer_encoder.layers.11.linear1.weight', 'transformer_encoder.layers.11.linear1.bias', 'transformer_encoder.layers.11.linear2.weight', 'transformer_encoder.layers.11.linear2.bias', 'transformer_encoder.layers.11.norm1.weight', 'transformer_encoder.layers.11.norm1.bias', 'transformer_encoder.layers.11.norm2.weight', 'transformer_encoder.layers.11.norm2.bias']\n"
          ]
        }
      ],
      "source": [
        "# Load model config\n",
        "with open(model_config_file, 'r') as f:\n",
        "    model_configs = json.load(f)\n",
        "embsize = model_configs.get('embsize', embsize)\n",
        "d_hid = model_configs.get('d_hid', d_hid)\n",
        "n_layers_cls = model_configs.get('n_layers_cls', n_layers_cls)\n",
        "\n",
        "# nhead = model_configs.get('nheads', nhead)\n",
        "# nlayers = model_configs.get('nlayers', nlayers)\n",
        "\n",
        "# Token count\n",
        "ntokens = len(vocab_ori)  # using extended vocab if add_token True\n",
        "\n",
        "# Model\n",
        "model = TransformerGenerator(\n",
        "    ntokens,\n",
        "    embsize,\n",
        "    nhead,\n",
        "    d_hid,\n",
        "    nlayers,\n",
        "    nlayers_cls=n_layers_cls,\n",
        "    n_cls=1,\n",
        "    vocab=vocab,\n",
        "    dropout=dropout,\n",
        "    pad_token='<pad>',\n",
        "    pad_value=0,\n",
        "    pert_pad_id=2,\n",
        "\n",
        "    use_fast_transformer=use_fast_transformer,\n",
        "    pert_embed_dict=pert_embed_dict,\n",
        "    gpt_emb_dim=gpt_emb_dim,\n",
        "    # model_mode=model_mode,\n",
        "    attn_gate_mode=attn_gate_mode,\n",
        "    pert_mode=pert_mode,\n",
        "    # drug_embed_mode=drug_embed_mode,\n",
        "    pert_flag_mode=pert_flag_mode,\n",
        "    use_scgpt_layer=use_scgpt_layer,\n",
        "    use_scgpt_input=use_scgpt_input,\n",
        "    mask_mode=mask_mode,\n",
        "    add_token=add_token,\n",
        "    init_mode=init_mode,\n",
        "    # dosage_mode_type=dosage_mode_type,\n",
        "    cross_mode=cross_mode,\n",
        ")\n",
        "\n",
        "# Optionally load pretrained partial weights\n",
        "if load_cxg_weight:\n",
        "    load_param_prefixs = [\"encoder\", \"value_encoder\", \"transformer_encoder\"]\n",
        "    state = torch.load(model_file)\n",
        "    model_dict = model.state_dict()\n",
        "    pretrained_dict = {k: v for k, v in state.items() if any([k.startswith(p) for p in load_param_prefixs])}\n",
        "    model_dict.update(pretrained_dict)\n",
        "    missing = model.load_state_dict(model_dict, strict=False)\n",
        "    print(\"Missing keys:\", missing.missing_keys)\n",
        "    print(\"Unexpected keys:\", missing.unexpected_keys)\n",
        "\n",
        "# If adding tokens, optionally load encoder weights into encoder_plus and init new tokens\n",
        "if add_token and load_encoder_plus:\n",
        "    with torch.no_grad():\n",
        "        n = model.encoder.embedding.num_embeddings\n",
        "        # copy base encoder weights and norms\n",
        "        model.encoder_plus.embedding.weight[:n] = model.encoder.embedding.weight\n",
        "        model.encoder_plus.enc_norm.weight[:] = model.encoder.enc_norm.weight\n",
        "        model.encoder_plus.enc_norm.bias[:] = model.encoder.enc_norm.bias\n",
        "        # initialize newly added tokens with mean/std of pretrained embeddings\n",
        "        pretrained_embed = model.encoder.embedding.weight  # (n, d)\n",
        "        mean = pretrained_embed.mean(dim=0)\n",
        "        std = pretrained_embed.std(dim=0)\n",
        "        m = model.encoder_plus.embedding.num_embeddings - n\n",
        "        if m > 0:\n",
        "            model.encoder_plus.embedding.weight[n:] = torch.normal(\n",
        "                mean=mean.expand(m, -1),\n",
        "                std=std.expand(m, -1)\n",
        "            )\n",
        "\n",
        "# Device & DP\n",
        "device = torch.device(f\"cuda:{device_ids[0]}\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Set device ids similar to the original notebook behavior\n",
        "# If you have a preferred GPU list, set it here, e.g., device_ids = [4,5,6,7]\n",
        "if torch.cuda.device_count() > 1:\n",
        "    try:\n",
        "        device_ids  # use pre-defined list if exists\n",
        "    except NameError:\n",
        "        device_ids = list(range(torch.cuda.device_count()))\n",
        "    model = torch.nn.DataParallel(model, device_ids=device_ids).to(device)\n",
        "else:\n",
        "    model = model.to(device)\n",
        "\n",
        "# Loss, optimizer, scheduler\n",
        "loss_type = 'mse'\n",
        "criterion = masked_mse_loss if loss_type == 'mse' else masked_huber_loss\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
        "if scheduler_type == 'steplr':\n",
        "    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 5, gamma=0.98)\n",
        "elif scheduler_type == 'cosine':\n",
        "    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=len(trainloader)*epochs)\n",
        "elif scheduler_type == 'cosine_warm':\n",
        "    scheduler = get_cosine_schedule_with_warmup(\n",
        "        optimizer,\n",
        "        num_warmup_steps=int(len(trainloader)*epochs*0.05),\n",
        "        num_training_steps=len(trainloader)*epochs,\n",
        "    )\n",
        "else:\n",
        "    raise ValueError('Unknown scheduler')\n",
        "\n",
        "scaler = torch.cuda.amp.GradScaler(enabled=amp)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 9. Training Loop and Validation\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            " 48%|████▊     | 100/209 [01:26<01:24,  1.28it/s]INFO:xpert:| epoch   1 | 100/209 batches | lr 0.000045 | ms/batch 871.90 | loss 0.07585 | mse 0.07585 |\n",
            " 96%|█████████▌| 200/209 [02:49<00:07,  1.24it/s]INFO:xpert:| epoch   1 | 200/209 batches | lr 0.000029 | ms/batch 829.66 | loss 0.05854 | mse 0.05854 |\n",
            "100%|██████████| 209/209 [02:56<00:00,  1.19it/s]\n",
            "INFO:xpert:-----------------------------------------------------------------------------------------\n",
            "INFO:xpert:| end of epoch   1 | time: 190.88s | valid loss/mse 0.0544 |\n",
            "INFO:xpert:-----------------------------------------------------------------------------------------\n",
            "INFO:xpert:Best model with score 0.0544\n",
            " 48%|████▊     | 100/209 [01:21<01:27,  1.24it/s]INFO:xpert:| epoch   2 | 100/209 batches | lr 0.000009 | ms/batch 823.23 | loss 0.05632 | mse 0.05632 |\n",
            " 96%|█████████▌| 200/209 [02:42<00:07,  1.24it/s]INFO:xpert:| epoch   2 | 200/209 batches | lr 0.000000 | ms/batch 806.34 | loss 0.05538 | mse 0.05538 |\n",
            "100%|██████████| 209/209 [02:48<00:00,  1.24it/s]\n",
            "INFO:xpert:-----------------------------------------------------------------------------------------\n",
            "INFO:xpert:| end of epoch   2 | time: 183.47s | valid loss/mse 0.0536 |\n",
            "INFO:xpert:-----------------------------------------------------------------------------------------\n",
            "INFO:xpert:Best model with score 0.0536\n"
          ]
        }
      ],
      "source": [
        "# Training loop\n",
        "best_val_loss = float('inf')\n",
        "best_model = None\n",
        "patience = 0\n",
        "early_stop = epochs\n",
        "\n",
        "train_metrics_list, train_metrics_pert_list = [], []\n",
        "val_metrics_list, val_metrics_pert_list = [], []\n",
        "\n",
        "for epoch in range(1, epochs + 1):\n",
        "    epoch_start_time = time.time()\n",
        "    train_loader = pert_data.dataloader[\"train_loader\"]\n",
        "    valid_loader = pert_data.dataloader[\"val_loader\"]\n",
        "\n",
        "    train(model, train_loader)\n",
        "    val_loss, val_mre = evaluate(model, valid_loader)\n",
        "    elapsed = time.time() - epoch_start_time\n",
        "    logger.info(\"-\" * 89)\n",
        "    logger.info(f\"| end of epoch {epoch:3d} | time: {elapsed:5.2f}s | valid loss/mse {val_loss:5.4f} |\")\n",
        "    logger.info(\"-\" * 89)\n",
        "\n",
        "    if val_loss < best_val_loss:\n",
        "        best_val_loss = val_loss\n",
        "        best_model = copy.deepcopy(model)\n",
        "        logger.info(f\"Best model with score {best_val_loss:5.4f}\")\n",
        "        patience = 0\n",
        "        torch.save(best_model.state_dict(), save_root / \"model_best.pt\")\n",
        "    else:\n",
        "        patience += 1\n",
        "        if patience >= early_stop:\n",
        "            logger.info(f\"Early stop at epoch {epoch}\")\n",
        "            break\n",
        "\n",
        "    # Collect metrics for plotting later\n",
        "    # train_res = None\n",
        "    # val_res = None\n",
        "    # Optional: compute metrics per epoch (can be expensive). Keep minimal to preserve runtime.\n",
        "    # If needed:\n",
        "    train_res = eval_perturb_new(train_loader, model, device)\n",
        "    val_res = eval_perturb_new(valid_loader, model, device)\n",
        "    if train_res is not None:\n",
        "        train_metrics, train_metrics_pert = compute_metrics(train_res)\n",
        "        train_metrics_list.append(train_metrics)\n",
        "        train_metrics_pert_list.append(train_metrics_pert)\n",
        "    if val_res is not None:\n",
        "        val_metrics, val_metrics_pert = compute_metrics(val_res)\n",
        "        val_metrics_list.append(val_metrics)\n",
        "        val_metrics_pert_list.append(val_metrics_pert)\n",
        "\n",
        "    if scheduler_type == 'steplr':\n",
        "        scheduler.step()\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 10. Final Evaluation and Save Artifacts\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x800 with 4 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x800 with 4 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Save best model and evaluate on test set\n",
        "torch.save(best_model.state_dict(), save_root / \"model_best.pt\")\n",
        "\n",
        "test_loader = pert_data.dataloader[\"test_loader\"]\n",
        "\n",
        "test_res = eval_perturb_new(test_loader, best_model, device)\n",
        "# test_metrics, test_pert_res = compute_metrics(test_res)  # optional\n",
        "\n",
        "# Save results\n",
        "model_prefix = f'lr_{lr}'\n",
        "result_dir = save_root / f'result_{model_prefix}'\n",
        "result_dir.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "import pickle\n",
        "pickle.dump(test_res, open(result_dir / 'test_res.pkl', 'wb'))\n",
        "pickle.dump(train_metrics_list, open(result_dir / 'train_metrics_list.pkl', 'wb'))\n",
        "pickle.dump(train_metrics_pert_list, open(result_dir / 'train_metrics_pert_list.pkl', 'wb'))\n",
        "pickle.dump(val_metrics_list, open(result_dir / 'val_metrics_list.pkl', 'wb'))\n",
        "pickle.dump(val_metrics_pert_list, open(result_dir / 'val_metrics_pert_list.pkl', 'wb'))\n",
        "\n",
        "# Optional plotting if metrics were collected\n",
        "try:\n",
        "    merge_plot(train_metrics_list, 'train', str(result_dir / 'train.png'))\n",
        "    merge_plot(val_metrics_list, 'test', str(result_dir / 'test.png'))\n",
        "except Exception as e:\n",
        "    logger.warning(f\"Plotting skipped: {e}\")\n",
        "\n",
        "# Free CUDA cache\n",
        "torch.cuda.empty_cache()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "scGPT_2",
      "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.10.14"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}