{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "f0fd1ed3",
      "metadata": {
        "id": "f0fd1ed3"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fd1e3c2a",
      "metadata": {
        "id": "fd1e3c2a"
      },
      "source": [
        "# **Qubit-based quantum autoencoder**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "752d1a50",
      "metadata": {
        "id": "752d1a50"
      },
      "source": [
        "This script stores the code related to a **qubit-based quantum autoencoder** that we have replicated following the data in the paper ‘https://arxiv.org/abs/2502.17301’ and that we have used to compare and analyse the results of our model based on qubits.       \n",
        "**Author**: Miranda Carou Laiño"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "928c6f32",
      "metadata": {
        "id": "928c6f32"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e60fd371-4b41-48dc-ac4f-bc6a1c2559e5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e60fd371-4b41-48dc-ac4f-bc6a1c2559e5",
        "outputId": "397adc40-a044-49ad-a5a4-18a24249eca9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Collecting ijson\n",
            "  Downloading ijson-3.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl.metadata (23 kB)\n",
            "Downloading ijson-3.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl (149 kB)\n",
            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/149.7 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m149.7/149.7 kB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: ijson\n",
            "Successfully installed ijson-3.5.0\n",
            "Collecting pennylane\n",
            "  Downloading pennylane-0.44.1-py3-none-any.whl.metadata (12 kB)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from pennylane) (1.16.3)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.12/dist-packages (from pennylane) (3.6.1)\n",
            "Collecting rustworkx>=0.14.0 (from pennylane)\n",
            "  Downloading rustworkx-0.17.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (10 kB)\n",
            "Requirement already satisfied: autograd in /usr/local/lib/python3.12/dist-packages (from pennylane) (1.8.0)\n",
            "Collecting appdirs (from pennylane)\n",
            "  Downloading appdirs-1.4.4-py2.py3-none-any.whl.metadata (9.0 kB)\n",
            "Collecting autoray==0.8.2 (from pennylane)\n",
            "  Downloading autoray-0.8.2-py3-none-any.whl.metadata (6.1 kB)\n",
            "Requirement already satisfied: cachetools in /usr/local/lib/python3.12/dist-packages (from pennylane) (6.2.6)\n",
            "Collecting pennylane-lightning>=0.44 (from pennylane)\n",
            "  Downloading pennylane_lightning-0.44.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (11 kB)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from pennylane) (2.32.4)\n",
            "Requirement already satisfied: tomlkit in /usr/local/lib/python3.12/dist-packages (from pennylane) (0.13.3)\n",
            "Requirement already satisfied: typing_extensions in /usr/local/lib/python3.12/dist-packages (from pennylane) (4.15.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from pennylane) (26.0)\n",
            "Collecting diastatic-malt==2.15.2 (from pennylane)\n",
            "  Downloading diastatic_malt-2.15.2-py3-none-any.whl.metadata (2.6 kB)\n",
            "Requirement already satisfied: gast in /usr/local/lib/python3.12/dist-packages (from pennylane) (0.7.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from pennylane) (2.0.2)\n",
            "Requirement already satisfied: astunparse in /usr/local/lib/python3.12/dist-packages (from diastatic-malt==2.15.2->pennylane) (1.6.3)\n",
            "Requirement already satisfied: termcolor in /usr/local/lib/python3.12/dist-packages (from diastatic-malt==2.15.2->pennylane) (3.3.0)\n",
            "Collecting scipy-openblas32>=0.3.26 (from pennylane-lightning>=0.44->pennylane)\n",
            "  Downloading scipy_openblas32-0.3.31.188.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (57 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.3/57.3 kB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->pennylane) (3.4.6)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->pennylane) (3.11)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->pennylane) (2.5.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->pennylane) (2026.2.25)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from astunparse->diastatic-malt==2.15.2->pennylane) (0.46.3)\n",
            "Requirement already satisfied: six<2.0,>=1.6.1 in /usr/local/lib/python3.12/dist-packages (from astunparse->diastatic-malt==2.15.2->pennylane) (1.17.0)\n",
            "Downloading pennylane-0.44.1-py3-none-any.whl (5.3 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.3/5.3 MB\u001b[0m \u001b[31m50.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading autoray-0.8.2-py3-none-any.whl (935 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m935.6/935.6 kB\u001b[0m \u001b[31m37.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading diastatic_malt-2.15.2-py3-none-any.whl (167 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m167.9/167.9 kB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading pennylane_lightning-0.44.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (2.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.5/2.5 MB\u001b[0m \u001b[31m63.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading rustworkx-0.17.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m59.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading appdirs-1.4.4-py2.py3-none-any.whl (9.6 kB)\n",
            "Downloading scipy_openblas32-0.3.31.188.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (8.9 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.9/8.9 MB\u001b[0m \u001b[31m69.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: appdirs, scipy-openblas32, rustworkx, autoray, diastatic-malt, pennylane-lightning, pennylane\n",
            "Successfully installed appdirs-1.4.4 autoray-0.8.2 diastatic-malt-2.15.2 pennylane-0.44.1 pennylane-lightning-0.44.0 rustworkx-0.17.1 scipy-openblas32-0.3.31.188.0\n"
          ]
        }
      ],
      "source": [
        "!pip install ijson\n",
        "!pip install pennylane\n",
        "\n",
        "import ijson\n",
        "import numpy as np\n",
        "import json\n",
        "from decimal import Decimal\n",
        "import json\n",
        "import time\n",
        "import torch\n",
        "import warnings\n",
        "import pennylane as qml\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from IPython.display import clear_output\n",
        "from sklearn.metrics import roc_auc_score\n",
        "from sklearn.model_selection import train_test_split\n",
        "from scipy.stats import norm\n",
        "from tqdm import tqdm\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2bcb78ec",
      "metadata": {
        "id": "2bcb78ec"
      },
      "source": [
        "## Section 1: Data loading and processing\n",
        "\n",
        "In this section, we load multiple JSON files containing jet events, selects the top constituents by transverse momentum ($p_T$) for each jet, and computes their kinematic variables ($p_T$, $\\eta$, $\\phi$) for further analysis."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b161e9a",
      "metadata": {
        "id": "7b161e9a"
      },
      "source": [
        "### **Loading real data for training**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f7e0fcef-6d9a-4abf-a828-32ef4b7b8888",
      "metadata": {
        "id": "f7e0fcef-6d9a-4abf-a828-32ef4b7b8888"
      },
      "outputs": [],
      "source": [
        "datos = []\n",
        "\n",
        "def cargar_datos_json(json_path, num_jets=22500, num_constituents=10):\n",
        "    with open(json_path, 'r') as f:\n",
        "        data = json.load(f)\n",
        "\n",
        "    eventos = []\n",
        "    for i, evento in enumerate(data[:num_jets]):\n",
        "      jet_pt, jet_eta, jet_phi, jet_mass = evento['jet_kinematics']\n",
        "      constituents = evento['PFCands']\n",
        "      theta = 2 * np.arctan(np.exp(-jet_eta))\n",
        "      p = jet_pt / np.sin(theta)\n",
        "      pz  = p * np.cos(theta)\n",
        "      jet_energy = np.sqrt(pz**2 + jet_pt**2 + jet_mass**2)\n",
        "\n",
        "      # Calculate pT for each constituent\n",
        "      constituents = np.array(constituents)\n",
        "      px = constituents[:, 0]\n",
        "      py = constituents[:, 1]\n",
        "      pt = np.sqrt(px**2 + py**2)\n",
        "\n",
        "      # Indexes of the top num_constituents by pT\n",
        "      indices_ordenados = np.argsort(pt)[::-1][:num_constituents]\n",
        "      top_cands = constituents[indices_ordenados]\n",
        "\n",
        "      # Convert each to the format used in the circuit\n",
        "      top_constituents = []\n",
        "      for cand in top_cands:\n",
        "        px, py, pz, E = cand[0:4]\n",
        "        d0 = cand[4]  # traversal impact parameter\n",
        "        dz = cand[5]  # longitudinal impact parameter\n",
        "        pt = np.sqrt(px**2 + py**2)\n",
        "        p_total = np.sqrt(px**2 + py**2 + pz**2)\n",
        "        eta = 0.5 * np.log((p_total + pz) / (p_total - pz + 1e-8))  # Avoiding dividing by 0\n",
        "        phi = np.arctan2(py, px)\n",
        "        mass = np.sqrt(np.maximum(0, E**2 - (px**2 + py**2 + pz**2)))# In case of negative mass, set it to zero\n",
        "        top_constituents.append({\n",
        "            'pt': pt,\n",
        "            'eta': eta,\n",
        "            'phi': phi,\n",
        "            'mass': mass,\n",
        "            'energy': E,\n",
        "            'd0': d0,\n",
        "            'dz': dz\n",
        "        })\n",
        "\n",
        "      eventos.append({\n",
        "        'pt_jet': jet_pt,\n",
        "        'eta_jet': jet_eta,\n",
        "        'phi_jet': jet_phi,\n",
        "        'mass_jet': jet_mass,\n",
        "        'energy_jet': jet_energy,\n",
        "        'constituents': top_constituents\n",
        "      })\n",
        "\n",
        "    return eventos\n",
        "\n",
        "datos_00 = cargar_datos_json('./runG_batch0_flatpt_reduced.json',2250) ## reduced to 10% of dataset\n",
        "datos_01 = cargar_datos_json('./runG_batch10_flatpt_reduced.json',2250) ## reduced to 10% of dataset\n",
        "datos = datos_00 + datos_01\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Hkf_o03aV0Fv",
      "metadata": {
        "id": "Hkf_o03aV0Fv"
      },
      "outputs": [],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bed5289b",
      "metadata": {
        "id": "bed5289b"
      },
      "source": [
        "### **Loading simulated CMS data** (physical signals mostly for inference step)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "44e8fcd4",
      "metadata": {
        "id": "44e8fcd4"
      },
      "outputs": [],
      "source": [
        "\n",
        "def cargar_datos_json(json_path, num_jets=10000, num_constituents=10):\n",
        "    with open(json_path, 'r') as f:\n",
        "        data = json.load(f)\n",
        "\n",
        "    eventos = []\n",
        "    for i, evento in enumerate(data[:num_jets]):\n",
        "        # Extract jet kinematics\n",
        "        jet_pt = evento.get('jet_pt', i)\n",
        "        jet_eta = evento.get('jet_eta', i)\n",
        "        jet_phi = evento.get('jet_phi', i)\n",
        "        jet_mass = evento.get('jet_sdmass', i)\n",
        "        jet_energy = evento.get('jet_energy', i)\n",
        "        jet_tau1 = evento.get('jet_tau1', i)\n",
        "        jet_tau2 = evento.get('jet_tau2', i)\n",
        "        jet_tau3 = evento.get('jet_tau3', i)\n",
        "        jet_tau4 = evento.get('jet_tau4', i)\n",
        "\n",
        "        jet_tau12 = jet_tau1 / jet_tau2 if jet_tau2 != 0 else 0\n",
        "        jet_tau23 = jet_tau2 / jet_tau3 if jet_tau3 != 0 else 0\n",
        "        jet_tau34 = jet_tau3 / jet_tau4 if jet_tau4 != 0 else 0\n",
        "\n",
        "        # Extract constituents (particles)\n",
        "        part_px = np.array(evento.get('part_px', []))\n",
        "        part_py = np.array(evento.get('part_py', []))\n",
        "        part_pz = np.array(evento.get('part_pz', []))\n",
        "        part_energy = np.array(evento.get('part_energy', []))\n",
        "        part_d0val = np.array(evento.get('part_d0val', []))\n",
        "        part_dzval = np.array(evento.get('part_dzval', []))\n",
        "\n",
        "        # Calculate pT, eta, phi, mass for each constituent\n",
        "        pt = np.sqrt(part_px**2 + part_py**2)\n",
        "        p_total = np.sqrt(part_px**2 + part_py**2 + part_pz**2)\n",
        "        eta = 0.5 * np.log((p_total + part_pz) / (p_total - part_pz + 1e-8))  # Avoiding dividing by 0\n",
        "        phi = np.arctan2(part_py, part_px)\n",
        "        mass = np.sqrt(np.maximum(0, part_energy**2 - (part_px**2 + part_py**2 + part_pz**2)))\n",
        "\n",
        "        # Seleccionar los num_constituents con mayor pt\n",
        "        indices_ordenados = np.argsort(pt)[::-1][:num_constituents]\n",
        "\n",
        "        top_constituents = []\n",
        "        for idx in indices_ordenados:\n",
        "            top_constituents.append({\n",
        "                'pt': pt[idx],\n",
        "                'eta': eta[idx],\n",
        "                'phi': phi[idx],\n",
        "                'px': part_px[idx],\n",
        "                'py': part_py[idx],\n",
        "                'pz': part_pz[idx],\n",
        "                'mass': mass[idx],\n",
        "                'energy': part_energy[idx],\n",
        "                'd0': part_d0val[idx],\n",
        "                'dz': part_dzval[idx]\n",
        "            })\n",
        "\n",
        "        eventos.append({\n",
        "            'pt_jet': jet_pt,\n",
        "            'eta_jet': jet_eta,\n",
        "            'phi_jet': jet_phi,\n",
        "            'mass_jet': jet_mass,\n",
        "            'energy_jet': jet_energy,\n",
        "            'tau1_jet': jet_tau1,\n",
        "            'tau2_jet': jet_tau2,\n",
        "            'tau3_jet': jet_tau3,\n",
        "            'tau4_jet': jet_tau4,\n",
        "            'tau12_jet': jet_tau12,\n",
        "            'tau23_jet': jet_tau23,\n",
        "            'tau34_jet': jet_tau34,\n",
        "            'constituents': top_constituents\n",
        "        })\n",
        "\n",
        "    return eventos\n",
        "\n",
        "datos_HToBB = cargar_datos_json('./HToBB_120_flat_reduced.json', num_jets=1000, num_constituents=10)\n",
        "datos_TTBar = cargar_datos_json('./TTBar_120_flat_reduced.json', num_jets=1000, num_constituents=10)\n",
        "datos_WToqq = cargar_datos_json('./WToQQ_120_flat_reduced.json', num_jets=1000, num_constituents=10)\n",
        "datos_QCD_simu_1 = cargar_datos_json('./ZJetsToNuNu_120_flat_reduced.json', num_jets=2250, num_constituents=10)\n",
        "datos_QCD_simu_2 = cargar_datos_json('./ZJetsToNuNu_121_flat_reduced.json', num_jets=2250, num_constituents=10)\n",
        "datos_QCD_simu_full = datos_QCD_simu_1 + datos_QCD_simu_2"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ac1ef065",
      "metadata": {
        "id": "ac1ef065"
      },
      "source": [
        "## **Section 2**: Splitting data into train, validation, and inference sets\n",
        "\n",
        "This code converts the dataset into a NumPy array and splits it into three parts: 500 samples for training, 200 for validation, and the remaining 3800 for inference. The splits are randomized to ensure diverse sampling.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "69e68d1a-16f3-4540-8a72-4f57f9ba68f1",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "69e68d1a-16f3-4540-8a72-4f57f9ba68f1",
        "outputId": "50ebeee1-02ae-4498-a9dd-5a94da139c30"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training: 500\n",
            "Validation: 200\n",
            "Inference: 3800\n"
          ]
        }
      ],
      "source": [
        "datos = np.array(datos)\n",
        "\n",
        "# Set aside fraction of sample for training and the remaining for validation and inference\n",
        "X_train, X_temp = train_test_split(\n",
        "    datos,\n",
        "    train_size=500,\n",
        "    random_state=42,\n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "# Separate samples for validation and for inference\n",
        "X_val, X_inf = train_test_split(\n",
        "    X_temp,\n",
        "    train_size=200,\n",
        "    random_state=42,\n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "# Verify sizes\n",
        "print(f\"Training: {len(X_train)}\")\n",
        "print(f\"Validation: {len(X_val)}\")\n",
        "print(f\"Inference: {len(X_inf)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cae5c2ef",
      "metadata": {
        "id": "cae5c2ef"
      },
      "source": [
        "### **Version 2**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "55854802",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "55854802",
        "outputId": "4ba8fd66-a4b5-4ac1-bd44-2772cd2e00e1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training: 500\n",
            "Validation: 200\n",
            "Inference: 500\n"
          ]
        }
      ],
      "source": [
        "\n",
        "\n",
        "datos = np.array(datos_QCD_simu_full)\n",
        "\n",
        "\n",
        "X_train, X_temp = train_test_split(\n",
        "    datos,\n",
        "    train_size=500,\n",
        "    random_state=42,\n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "X_val, rest = train_test_split(\n",
        "    X_temp,\n",
        "    train_size=200,\n",
        "    random_state=42,\n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "X_inf, rest = train_test_split(\n",
        "    rest,\n",
        "    train_size=500,\n",
        "    random_state=42,\n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "print(f\"Training: {len(X_train)}\")\n",
        "print(f\"Validation: {len(X_val)}\")\n",
        "print(f\"Inference: {len(X_inf)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "221dccb4",
      "metadata": {
        "id": "221dccb4"
      },
      "source": [
        "### **Reminder**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "788f64e0-596d-4df8-89fa-3b7c6ec6c562",
      "metadata": {
        "id": "788f64e0-596d-4df8-89fa-3b7c6ec6c562"
      },
      "source": [
        "> ***“Each event is represented by a set of reconstructed jets ordered by decreasing transverse momentum (pT)…\"***\n",
        "\n",
        "\n",
        "> \\begin{align}\n",
        "> f \\cdot \\frac{p_T}{p_{T,\\text{jet}}} \\cdot (\\eta - \\eta_{\\text{jet}}) \\rightarrow \\theta \\tag{1} \\\\\n",
        "> f \\cdot \\frac{p_T}{p_{T,\\text{jet}}} \\cdot (\\phi - \\phi_{\\text{jet}}) \\rightarrow \\varphi \\tag{2} \\\\\n",
        "> (p_T, \\eta, \\phi) \\rightarrow |\\psi\\rangle = R_X(\\varphi)R_Y(\\theta) |0\\rangle \\notag \\\\\n",
        "> = \\alpha(\\theta, \\varphi) |0\\rangle + \\beta(\\theta, \\varphi) |1\\rangle \\tag{3} \\\\\n",
        "> f \\rightarrow 1 + \\frac{2\\pi}{1+e^{-w}} \\tag{4}\n",
        "> \\end{align}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "497f332f",
      "metadata": {
        "id": "497f332f"
      },
      "source": [
        "## Section 3: **Quantum circuit setup and encoder definition**\n",
        "\n",
        "This code sets up a **qubit-based quantum autoencoder (QAE)** using PennyLane and PyTorch. It defines the quantum device, initializes wires for latent, trash, reference, and ancilla qubits, and implements the 1P1Q encoding scheme for jet constituents. Variational layers and a QAE circuit are also defined, along with a cost function based on fidelity for training.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7ce2984f-d388-4216-bd96-4dac11cebca4",
      "metadata": {
        "id": "7ce2984f-d388-4216-bd96-4dac11cebca4"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "# --- Circuit parameters ---\n",
        "num_particles = 10\n",
        "num_latent = 2\n",
        "num_ref = num_particles - num_latent\n",
        "num_trash = num_ref\n",
        "wires = list(range(num_particles + num_ref + 1))  # +1 ancilla\n",
        "ancilla = wires[-1]\n",
        "dev = qml.device(\"default.qubit\", wires=wires)\n",
        "\n",
        "latent_wire = 0\n",
        "trash_wires = wires[1:num_particles]\n",
        "ref_wires = wires[num_particles:-1]\n",
        "\n",
        "\n",
        "# --- 1P1Q encoding (same as in the paper) ---\n",
        "def f(w):\n",
        "    return 1 + (2 * np.pi / (1 + torch.exp(-w)))\n",
        "\n",
        "def phi_circuit(w, phi, phi_jet, pt, pt_jet):\n",
        "    return f(w) * pt / pt_jet * (phi - phi_jet)\n",
        "\n",
        "def theta_circuit(w, eta, eta_jet, pt, pt_jet):\n",
        "    return f(w) * pt / pt_jet * (eta - eta_jet)\n",
        "\n",
        "def tau1_circuit(w, tau1_jet, pt, pt_jet):\n",
        "    return f(w) * pt / pt_jet * (tau1_jet)\n",
        "\n",
        "def tau2_circuit(w, tau2_jet, pt, pt_jet):\n",
        "    return f(w) * pt / pt_jet * (tau2_jet)\n",
        "\n",
        "\n",
        "# --- Encoder 1P1Q adapted to the new jet format ---\n",
        "def encode_1p1q(jet, w):\n",
        "    pt_jet = jet['pt_jet']\n",
        "    eta_jet = jet['eta_jet']\n",
        "    phi_jet = jet['phi_jet']\n",
        "    constituents = jet['constituents']\n",
        "\n",
        "    for i in range(num_particles):\n",
        "        c = constituents[i]\n",
        "        theta = theta_circuit(w, c['eta'], eta_jet, c['pt'], pt_jet)\n",
        "        phi = phi_circuit(w, c['phi'], phi_jet, c['pt'], pt_jet)\n",
        "        #In case of using tau variables:\n",
        "        #tau1 = tau1_circuit(w, jet['tau1_jet'], c['pt'], pt_jet)\n",
        "        #tau2 = tau2_circuit(w, jet['tau2_jet'], c['pt'], pt_jet)\n",
        "        qml.RY(theta, wires=i)\n",
        "        qml.RX(phi, wires=i)\n",
        "        #qml.RY(tau1, wires=i)\n",
        "        #qml.RX(tau2, wires=i)\n",
        "\n",
        "\n",
        "# --- Variational layer ---\n",
        "def variational_layer(theta_i, phi_i, w_i, num_layers):\n",
        "    for layer in range(num_layers):\n",
        "        for i in range(num_particles):\n",
        "            for j in range(i + 1, num_particles):\n",
        "                qml.CNOT(wires=[i, j])\n",
        "\n",
        "        for i in range(num_particles):\n",
        "            ## Task 1: apply Rotation gates\n",
        "            ## RX for phi_i[layer, i]\n",
        "            ## RZ for theta_i[layer, i]\n",
        "            ## RY for w_i[layer, i]\n",
        "\n",
        "\n",
        "# --- QAE Circuit ---\n",
        "@qml.qnode(dev, interface=\"torch\", diff_method=\"backprop\")\n",
        "def qae_circuit(jet, w, theta_i, phi_i, w_i, num_layers):\n",
        "    encode_1p1q(jet, w)\n",
        "    variational_layer(theta_i, phi_i, w_i, num_layers)\n",
        "\n",
        "    for trash_wire, ref_wire in zip(trash_wires, ref_wires):\n",
        "        ### Task 2: implement a SWAP test\n",
        "        ### qml.gate....\n",
        "\n",
        "    return qml.probs(wires=ancilla)\n",
        "\n",
        "\n",
        "# --- Cost function for training ---\n",
        "def cost_function_with_fidelity(jet, w, theta_i, phi_i, w_i, num_layers):\n",
        "    prob_0 = qae_circuit(jet, w, theta_i, phi_i, w_i, num_layers)[0]\n",
        "    fidelity = prob_0\n",
        "    return -fidelity, fidelity.item()\n",
        "\n",
        "def encontrar_maximos_per_jet(jet):\n",
        "    max_pt = jet['pt_jet']\n",
        "    max_eta = jet['eta_jet']\n",
        "    max_phi = jet['phi_jet']\n",
        "    return max_pt, max_eta, max_phi\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5c1a618e",
      "metadata": {
        "id": "5c1a618e"
      },
      "source": [
        "## Section 4: **Quantum autoencoder training loop**\n",
        "\n",
        "This code initializes the trainable parameters of the quantum autoencoder and sets up an Adam optimizer. It then runs a training loop over the jets in `X_train`, computing the loss and fidelity for each jet using the QAE circuit, performing backpropagation, and updating the parameters. The average loss and fidelity per epoch are recorded and printed.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ed8fbcd3-a39e-4aae-80c0-101d7b496b67",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ed8fbcd3-a39e-4aae-80c0-101d7b496b67",
        "outputId": "2fb1e61e-a6a1-4a53-8fe8-617bbd72a573"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 500/500 [12:09<00:00,  1.46s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1, Loss: -0.8882, Avg Fidelity: 88.82%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "\n",
        "# --- Parameter initialisation ---\n",
        "w = torch.tensor(1.0, requires_grad=True)\n",
        "num_layers = 1\n",
        "theta_i = (torch.rand(num_layers, num_particles) * 2 * torch.pi).requires_grad_(True)\n",
        "phi_i   = (torch.rand(num_layers, num_particles) * 2 * torch.pi).requires_grad_(True)\n",
        "w_i     = (torch.rand(num_layers, num_particles) * 2 * torch.pi).requires_grad_(True)\n",
        "\n",
        "optimizer = torch.optim.Adam(\n",
        "    [w, theta_i, phi_i, w_i],\n",
        "    lr=5e-3,\n",
        "    betas=(0.5, 0.999),\n",
        "    eps=1e-08,\n",
        "    weight_decay=0.0,\n",
        "    amsgrad=True\n",
        ")\n",
        "\n",
        "# --- Training loop ---\n",
        "num_epochs = 1\n",
        "all_fidelities = []\n",
        "event_fidelities = []\n",
        "\n",
        "# --- Training ---\n",
        "for epoch in range(num_epochs):\n",
        "    total_loss = 0.0\n",
        "    epoch_fidelities = []\n",
        "    for jet in tqdm(X_train):\n",
        "        # Check that there are enough constituents\n",
        "        if len(jet['constituents']) < num_particles:\n",
        "            continue\n",
        "\n",
        "        loss, fidelity = cost_function_with_fidelity(jet, w, theta_i, phi_i, w_i, num_layers)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        total_loss += loss.item()\n",
        "        epoch_fidelities.append(fidelity)\n",
        "        event_fidelities.append(fidelity * 100)  # in %\n",
        "    avg_loss = total_loss / len(epoch_fidelities)\n",
        "    avg_fidelity = np.mean(epoch_fidelities) * 100\n",
        "    all_fidelities.append(avg_fidelity)\n",
        "\n",
        "    print(f\"Epoch {epoch+1}, Loss: {avg_loss:.4f}, Avg Fidelity: {avg_fidelity:.2f}%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b7333e97",
      "metadata": {
        "id": "b7333e97"
      },
      "source": [
        "### **Plotting fidelity distributions**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d859442f-53cf-4032-8e45-22df3401e315",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 706
        },
        "id": "d859442f-53cf-4032-8e45-22df3401e315",
        "outputId": "35df0bdc-0fc6-4929-c525-867db55d2fc0"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "bins = np.linspace(97, 100, 30)\n",
        "\n",
        "plt.figure(figsize=(7, 7))\n",
        "plt.hist(event_fidelities, bins=bins, histtype='stepfilled',\n",
        "         color='steelblue', alpha=0.7, label=r'JetHT CMS Data (2016) ($>$99\\% QCD Jets)')\n",
        "plt.yscale('log')\n",
        "plt.xlabel(r'Quantum Fidelity $\\langle T|R \\rangle$ (in %)', fontsize=13)\n",
        "plt.ylabel(r'No. of events', fontsize=13)\n",
        "plt.legend(loc='upper left', fontsize=11)\n",
        "plt.title(r'QAE trained on JetHT CMS Data (2016)', fontsize=14, pad=20)\n",
        "\n",
        "# Ajuste de márgenes y guardado\n",
        "plt.tight_layout()\n",
        "plt.savefig(\"qae_fidelity_distribution_matched.png\", dpi=300, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "434b3496-390a-4a21-a0ed-22a22ab6ddb6",
      "metadata": {
        "id": "434b3496-390a-4a21-a0ed-22a22ab6ddb6"
      },
      "source": [
        "## Subsection: **Validation**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "07d84f41",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "07d84f41",
        "outputId": "9971119d-bea2-449d-8bc4-7116bb32804e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "98.1725629401693\n"
          ]
        }
      ],
      "source": [
        "event_fidelities_val = []\n",
        "\n",
        "for jet in X_val:\n",
        "    # Verification that the number of constituents is sufficient\n",
        "    if len(jet['constituents']) < num_particles:\n",
        "        continue\n",
        "    _, fidelity = cost_function_with_fidelity(jet, w, theta_i, phi_i, w_i, num_layers)\n",
        "    event_fidelities_val.append(fidelity * 100)\n",
        "\n",
        "print(np.mean(event_fidelities_val))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f85a2999-23bd-4d6f-a2fe-900f4bac9681",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 706
        },
        "id": "f85a2999-23bd-4d6f-a2fe-900f4bac9681",
        "outputId": "6d904ea2-8b45-4f32-ca0b-5175a5f4c134"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "bins = np.linspace(97, 100, 30)\n",
        "\n",
        "plt.figure(figsize=(7, 7))\n",
        "plt.hist(event_fidelities_val, bins=bins, histtype='stepfilled',\n",
        "         color='steelblue', alpha=0.7, label=r'JetHT CMS Data (2016) (Validacion)')\n",
        "plt.yscale('log')\n",
        "plt.xlabel(r'Quantum Fidelity $\\langle T|R \\rangle$ (in %)', fontsize=13)\n",
        "plt.ylabel(r'No. of events', fontsize=13)\n",
        "plt.legend(loc='upper left', fontsize=11)\n",
        "plt.title(r'QAE trained on JetHT CMS Data (2016)', fontsize=14, pad=20)\n",
        "\n",
        "# Ajuste de márgenes y guardado\n",
        "plt.tight_layout()\n",
        "plt.savefig(\"qae_fidelity_distribution_validation.png\", dpi=300, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "74706dba",
      "metadata": {
        "id": "74706dba"
      },
      "source": [
        "## Section 5: **Evaluating fidelity on different jet samples (Inference)**\n",
        "\n",
        "This code computes the fidelity of the trained quantum autoencoder on different datasets. It iterates over the inference set (`X_inf`) and labeled signal datasets (`datos_HToBB`, `datos_TTBar`, `datos_WToqq`), calculating the fidelity for each jet. The fidelities are stored along with labels to later evaluate classification performance or ROC AUC.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7d18003a-553c-4901-9f57-78458e1f40b1",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7d18003a-553c-4901-9f57-78458e1f40b1",
        "outputId": "33c396e1-b6cc-4d7a-af4d-3bfe7c06881b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Processing dataset with label 0...\n",
            "Processing dataset with label 1...\n",
            "Inference complete!\n"
          ]
        }
      ],
      "source": [
        "from concurrent.futures import ProcessPoolExecutor\n",
        "\n",
        "def compute_jet_fidelity(jet_data):\n",
        "    \"\"\"Worker function to process one jet at a time.\"\"\"\n",
        "    if len(jet_data['constituents']) < num_particles:\n",
        "        return None\n",
        "\n",
        "    _, fidelity = cost_function_with_fidelity(\n",
        "        jet_data, w, theta_i, phi_i, w_i, num_layers\n",
        "    )\n",
        "    return fidelity\n",
        "\n",
        "def process_dataset_parallel(dataset, label):\n",
        "    print(f\"Processing dataset with label {label}...\")\n",
        "    with ProcessPoolExecutor() as executor:\n",
        "        results = list(executor.map(compute_jet_fidelity, dataset))\n",
        "\n",
        "    # Filter out None (jets with too few constituents) and format\n",
        "    fids = [f for f in results if f is not None]\n",
        "    labels = [label] * len(fids)\n",
        "    return fids, labels\n",
        "\n",
        "# --- Execution ---\n",
        "\n",
        "# Process all datasets using the parallel helper\n",
        "fids_back, labels_back = process_dataset_parallel(X_inf, 0)\n",
        "fids_HToBB, labels_HToBB = process_dataset_parallel(datos_HToBB, 1)\n",
        "##fids_TTBar, labels_TTBar = process_dataset_parallel(datos_TTBar, 1)\n",
        "##fids_WToqq, labels_WToqq = process_dataset_parallel(datos_WToqq, 1)\n",
        "\n",
        "event_fidelities_back = [f * 100 for f in fids_back]\n",
        "event_fidelities_HToBB = [f * 100 for f in fids_HToBB]\n",
        "##event_fidelities_TTBar = [f * 100 for f in fids_TTBar]\n",
        "##event_fidelities_WToQQ = [f * 100 for f in fids_WToqq]\n",
        "\n",
        "fidelidades = fids_back + fids_HToBB ##+ fids_TTBar + fids_WToqq\n",
        "etiquetas = labels_back + labels_HToBB ##+ labels_TTBar + labels_WToqq\n",
        "\n",
        "print(\"Inference complete!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b05bd629",
      "metadata": {
        "id": "b05bd629"
      },
      "source": [
        "## Section 6: **Plotting fidelity distribution histograms**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "150661cc-c4d9-442f-b69a-af8dda77cf14",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 707
        },
        "id": "150661cc-c4d9-442f-b69a-af8dda77cf14",
        "outputId": "3eb002a7-372e-4ed6-f7f8-c1a7cbb45bb5"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(7, 7))\n",
        "\n",
        "bins = np.linspace(97, 100, 30)\n",
        "\n",
        "# --- Background: blue fill ---\n",
        "plt.hist(event_fidelities_back,\n",
        "         bins=bins,\n",
        "         histtype='stepfilled',\n",
        "         color='steelblue',\n",
        "         alpha=0.7,\n",
        "         label=r'JetHT CMS Data (2016) (>99% QCD Jets)')\n",
        "\n",
        "# --- H → bb : red dashed line ---\n",
        "plt.hist(event_fidelities_HToBB,\n",
        "         bins=bins,\n",
        "         histtype='step',\n",
        "         color='firebrick',\n",
        "         linewidth=1.5,\n",
        "         linestyle='-',\n",
        "         label=r'$H \\rightarrow b\\bar{b}$')\n",
        "\"\"\"\n",
        "# --- t → bqq : green dotted line ---\n",
        "plt.hist(event_fidelities_TTBar,\n",
        "         bins=bins,\n",
        "         histtype='step',\n",
        "         color='forestgreen',\n",
        "         linewidth=1.5,\n",
        "         linestyle='-',\n",
        "         label=r'$t \\rightarrow bq\\bar{q}$')\n",
        "\n",
        "# --- W → qq : orange dotted line ---\n",
        "plt.hist(event_fidelities_WToQQ,\n",
        "         bins=bins,\n",
        "         histtype='step',\n",
        "         color='darkorange',\n",
        "         linewidth=1.5,\n",
        "         linestyle='-',\n",
        "         label=r'$W \\rightarrow q\\bar{q}$')\n",
        "\"\"\"\n",
        "\n",
        "plt.yscale('log')\n",
        "plt.xlabel(r'Quantum Fidelity $\\langle T|R \\rangle$ (in %)', fontsize=13)\n",
        "plt.ylabel(r'No. of events', fontsize=13)\n",
        "plt.title(r'QAE trained on JetHT CMS Data (2016)', fontsize=12, pad=5)\n",
        "plt.legend(loc='upper left', fontsize=11)\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0bfbde03-fc10-46dc-8a6a-97db05e905ef",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0bfbde03-fc10-46dc-8a6a-97db05e905ef",
        "outputId": "a6fcc09f-c998-4fd5-bb9d-1a2f8392df82"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "99.25980903028982\n",
            "nan\n",
            "98.35603158379087\n",
            "nan\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/numpy/_core/fromnumeric.py:3596: RuntimeWarning: Mean of empty slice.\n",
            "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
            "/usr/local/lib/python3.12/dist-packages/numpy/_core/_methods.py:138: RuntimeWarning: invalid value encountered in scalar divide\n",
            "  ret = ret.dtype.type(ret / rcount)\n"
          ]
        }
      ],
      "source": [
        "avg_fidelity_qcd = np.mean(event_fidelities_back)\n",
        "print(avg_fidelity_qcd)\n",
        "\n",
        "avg_fidelity_HToBB = np.mean(event_fidelities_HToBB)\n",
        "print(avg_fidelity_HToBB)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "50b0bc17",
      "metadata": {
        "id": "50b0bc17"
      },
      "source": [
        "## Section 7: **ROC curve and AUC evaluation**\n",
        "\n",
        "This code calculates anomaly scores as `1 - fidelity` for each jet category and computes the AUC (Area Under the Curve) for distinguishing background from different signal types (`H→bb`, `t→bqq`, `W→qq`, `QCD`). It then plots the ROC curves for each signal versus background and showing the classifier visually.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e162dc71-208c-4e4d-90b4-b9ec555e1dfa",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 725
        },
        "id": "e162dc71-208c-4e4d-90b4-b9ec555e1dfa",
        "outputId": "85d89284-0797-485c-9a52-26649fa3829d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "AUC (QCD vs H→bb): 0.7844\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import roc_auc_score, roc_curve\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# --- Anomaly scores (1 - Fidelity) ---\n",
        "## Task 3:\n",
        "anomaly_scores_back = ...\n",
        "anomaly_scores_HToBB = ...\n",
        "\n",
        "\n",
        "# --- Calculate AUC ---\n",
        "auc_HToBB = roc_auc_score(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_HToBB)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_HToBB])\n",
        ")\n",
        "\"\"\"\n",
        "auc_TTBar = roc_auc_score(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_TTBar)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_TTBar])\n",
        ")\n",
        "\n",
        "auc_WToQQ = roc_auc_score(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_WToQQ)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_WToQQ])\n",
        ")\n",
        "\"\"\"\n",
        "\n",
        "print(f\"AUC (QCD vs H→bb): {auc_HToBB:.4f}\")\n",
        "##print(f\"AUC (QCD vs t→bqq): {auc_TTBar:.4f}\")\n",
        "##print(f\"AUC (QCD vs W→qq): {auc_WToQQ:.4f}\")\n",
        "##print(f\"AUC (QCD vs W→qq): {auc_WToQQ:.4f}\")\n",
        "\n",
        "# --- Plot ROC curves ---\n",
        "plt.figure(figsize=(7, 7))\n",
        "\n",
        "# H→bb\n",
        "fpr_HToBB, tpr_HToBB, _ = roc_curve(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_HToBB)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_HToBB])\n",
        ")\n",
        "plt.plot(fpr_HToBB, tpr_HToBB, color='firebrick', linewidth=2,\n",
        "         label=rf'$H \\rightarrow b\\bar{{b}}$ (AUC = {auc_HToBB:.3f})')\n",
        "\"\"\"\n",
        "# t→bqq\n",
        "fpr_TTBar, tpr_TTBar, _ = roc_curve(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_TTBar)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_TTBar])\n",
        ")\n",
        "plt.plot(fpr_TTBar, tpr_TTBar, color='forestgreen', linewidth=2, linestyle=':',\n",
        "         label=rf'$t \\rightarrow bq\\bar{{q}}$ (AUC = {auc_TTBar:.3f})')\n",
        "\n",
        "# W→qq\n",
        "fpr_WToQQ, tpr_WToQQ, _ = roc_curve(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_WToQQ)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_WToQQ])\n",
        ")\n",
        "\n",
        "fpr_WToQQ, tpr_WToQQ, _ = roc_curve(\n",
        "    np.concatenate([np.zeros_like(anomaly_scores_back), np.ones_like(anomaly_scores_WToQQ)]),\n",
        "    np.concatenate([anomaly_scores_back, anomaly_scores_WToQQ])\n",
        ")\n",
        "\n",
        "plt.plot(fpr_WToQQ, tpr_WToQQ, color='darkorange', linewidth=2, linestyle='--',\n",
        "         label=rf'$W \\rightarrow q\\bar{{q}}$ (AUC = {auc_WToQQ:.3f})')\n",
        "\"\"\"\n",
        "plt.plot([0, 1], [0, 1], 'k--', label=r'AUC = 0.5 (Random)')\n",
        "plt.xlabel(r'False Positive Rate (FPR)', fontsize=13)\n",
        "plt.ylabel(r'True Positive Rate (TPR)', fontsize=13)\n",
        "plt.title(r'ROC Curve', fontsize=12, pad=5)\n",
        "plt.legend(loc='lower right', fontsize=11)\n",
        "plt.grid(True, linestyle='--', alpha=0.6)\n",
        "plt.tight_layout()\n",
        "plt.savefig(\"qae_roc_curve_final.png\", dpi=300, bbox_inches='tight')\n",
        "plt.show()\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "python_env",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}