+
+
+
+
+
-
-
-
-
+
\n",
+ " ![\"python-3.12\"](\"https://img.shields.io/badge/python-3.12-red\"){kind=icon}
![\"DOI\"](\"https://zenodo.org/badge/DOI/10.5281/zenodo.10282060.svg\"){kind=icon}
\n",
+ " ![\"https://florianfuerrutter.github.io/genQC\"](\"https://img.shields.io/badge/Documentation-c\"){kind=icon}
![\"huggingface.co/collections/Floki00\"](\"https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models_and_datasets-orange\"){kind=icon}
![\"Online_Demo\"](\"https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Online_Demo-blue\"){kind=icon}
\n",
- " \n",
- "
\n",
- "
\n",
- "
![\"python-3.10\"](\"https://img.shields.io/badge/python-3.10-red\"){kind=icon}
\n",
- "
Synthesis of discrete-continuous quantum circuits.
+::: +::: {.feature} +Easy inference of pre-trained model weights.
+::: +::: {.feature} +Full open source research code and model weights.
+::: +::: +::: + +::: {.figure} +
+:::
+
+
+
+::: {.container}
+::: {.left}
++To install genQC just run: +
+::: +::: {.left-grid-src} +```sh +pip install genQC +``` +::: +::: ++On the right hand side, a minimal example to generate a parametrized quantum circuit conditioned on the 4-qubit QFT unitary. +
+[View tutorials](./examples/tutorials.qmd){.btn-action .btn .btn-info .btn-lg role="button"} +::: + +::: {.right} + +```python +import torch +from genQC.pipeline.multimodal_diffusion_pipeline import MultimodalDiffusionPipeline_ParametrizedCompilation +from genQC.inference.sampling import generate_compilation_tensors, decode_tensors_to_backend +from genQC.utils.misc_utils import infer_torch_device +from genQC.platform.tokenizer.circuits_tokenizer import CircuitTokenizer +from genQC.benchmark.bench_compilation import SpecialUnitaries +from genQC.platform.simulation import Simulator, CircuitBackendType + +device = infer_torch_device() + +pipeline = MultimodalDiffusionPipeline_ParametrizedCompilation.from_pretrained( # <1> + repo_id="Floki00/cirdit_multimodal_compile_3to5qubit", # <1> + device=device) # <1> + +pipeline.scheduler.set_timesteps(40) # <2> +pipeline.scheduler_w.set_timesteps(40) # <2> + +pipeline.g_h, pipeline.g_w = 0.3, 0.1 # <2> +pipeline.lambda_h, pipeline.lambda_w = 1.0, 0.35 # <2> + +prompt = "Compile 4 qubits using: ['h', 'cx', 'ccx', 'swap', 'rx', 'ry', 'rz', 'cp']" # <2> + +U = SpecialUnitaries.QFT(num_qubits=4).to(torch.complex64) # <3> + +out_tensor, params = generate_compilation_tensors(pipeline, # <4> + prompt=prompt, # <4> + U=U, # <4> + samples=8, # <4> + system_size=5, # <4> + num_of_qubits=4, # <4> + max_gates=32) # <4> + +vocabulary = {g:i+1 for i, g in enumerate(pipeline.gate_pool)} # <5> +tokenizer = CircuitTokenizer(vocabulary) # <5> +simulator = Simulator(CircuitBackendType.QISKIT) # <5> + +qc_list, _ = decode_tensors_to_backend(simulator, tokenizer, out_tensor, params) # <5> + +qc_list[0].draw("mpl") +``` +1. Load a pre-trained Diffusion model. +2. Set inference parameters. +3. Specify QFT unitary. +4. Generate tokenized circuits. +5. Decode tensors to circuits. +::: + +::: + diff --git a/src/inference/eval_metrics.ipynb b/src/inference/eval_metrics.ipynb new file mode 100644 index 0000000..f124fd1 --- /dev/null +++ b/src/inference/eval_metrics.ipynb @@ -0,0 +1,237 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", + "metadata": {}, + "source": [ + "# Evaluation metrics\n", + "\n", + "> Different metrics used for evaluation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp inference.eval_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "from genQC.imports import *\n", + "from scipy.stats import unitary_group" + ] + }, + { + "cell_type": "markdown", + "id": "27afa544-b435-4ad2-9897-d731ccfc100d", + "metadata": {}, + "source": [ + "## Base norm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccbc4adc-098b-415a-98c8-8b80a0697d34", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class BaseNorm(abc.ABC): \n", + " \"\"\"Base class for norms.\"\"\"\n", + " \n", + " @staticmethod\n", + " @abc.abstractmethod\n", + " def distance(approx_U: torch.Tensor, target_U: torch.Tensor) -> torch.Tensor: raise NotImplementedError()\n", + " \n", + " @staticmethod\n", + " @abc.abstractmethod\n", + " def name() -> str: raise NotImplementedError()" + ] + }, + { + "cell_type": "markdown", + "id": "c19c4594-4749-4e91-bfc5-27cf95508de0", + "metadata": {}, + "source": [ + "## Unitary distances" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b178cbc-d116-49c9-862d-16f646daa39b", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class UnitaryFrobeniusNorm(BaseNorm):\n", + " \"\"\"\n", + " The Frobenius-Norm for unitaries: defined in https://arxiv.org/pdf/2106.05649.pdf.\n", + " \"\"\"\n", + "\n", + " def __call__(self, approx_U: torch.Tensor, target_U: torch.Tensor) -> torch.Tensor: \n", + " return Unitary_FrobeniusNorm.distance(approx_U, target_U)\n", + " \n", + " @staticmethod\n", + " def distance(approx_U: torch.Tensor, target_U: torch.Tensor) -> torch.Tensor:\n", + " d = 0.5 * torch.linalg.matrix_norm((approx_U-target_U), ord=\"fro\")**2\n", + " return d\n", + " \n", + " @staticmethod\n", + " def name() -> str: return \"Frobenius-Norm\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90080d81-c872-4da3-9f81-31c8908c1056", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class UnitaryInfidelityNorm(BaseNorm):\n", + " \"\"\"\n", + " The Infidelity-Norm for unitaries: defined in https://link.aps.org/accepted/10.1103/PhysRevA.95.042318, TABLE I: 1.\n", + " \"\"\"\n", + "\n", + " def __call__(self, approx_U: torch.Tensor, target_U: torch.Tensor) -> torch.Tensor: \n", + " return Unitary_infidelity.distance(approx_U, target_U)\n", + " \n", + " @staticmethod\n", + " def distance(approx_U: torch.Tensor, target_U: torch.Tensor) -> torch.Tensor: \n", + " \"\"\"Supports batched intputs, can be used as loss. Input shapes [b, n, n] or [n, n].\"\"\"\n", + " d = torch.matmul(torch.transpose(target_U, -2, -1).conj(), approx_U) # out [b, n, n] or [n, n]\n", + " d = torch.diagonal(d, offset=0, dim1=-2, dim2=-1).sum(-1) # do partial (batched) trace, out [b, n] or [n] \n", + " d = 1.0 - (d / target_U.shape[-1]).abs().square()\n", + " return d\n", + " \n", + " @staticmethod\n", + " def name() -> str: return \"Unitary-Infidelity\"" + ] + }, + { + "cell_type": "markdown", + "id": "121c092a-e560-4ef0-9831-84344661137f", + "metadata": {}, + "source": [ + "Test the metrics on random unitaries:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48c7c0a8-9a2b-4ce9-a1f7-547ce74ddee9", + "metadata": {}, + "outputs": [], + "source": [ + "approx_U = torch.tensor(unitary_group.rvs(8))\n", + "target_U = torch.tensor(unitary_group.rvs(8))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0f84359-e366-432e-b83d-926c9816b564", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frobenius-Norm\n" + ] + }, + { + "data": { + "text/plain": [ + "(tensor(0., dtype=torch.float64), tensor(8.5523, dtype=torch.float64))" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(UnitaryFrobeniusNorm.name())\n", + "UnitaryFrobeniusNorm.distance(target_U, target_U), UnitaryFrobeniusNorm.distance(approx_U, target_U)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c019a5ce-b3f2-4af9-9228-613447c8f3f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unitary-Infidelity\n" + ] + }, + { + "data": { + "text/plain": [ + "(tensor(4.4409e-16, dtype=torch.float64), tensor(0.9895, dtype=torch.float64))" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(UnitaryInfidelityNorm.name())\n", + "UnitaryInfidelityNorm.distance(target_U, target_U), UnitaryInfidelityNorm.distance(approx_U, target_U)" + ] + }, + { + "cell_type": "markdown", + "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", + "metadata": {}, + "source": [ + "# Export -" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "import nbdev; nbdev.nbdev_export()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/inference/evaluation_helper.ipynb b/src/inference/evaluation_helper.ipynb new file mode 100644 index 0000000..2cc0543 --- /dev/null +++ b/src/inference/evaluation_helper.ipynb @@ -0,0 +1,120 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e65be610-fea3-4579-b325-80c39c7edd8d", + "metadata": {}, + "source": [ + "# Evaluation helper\n", + "\n", + "> Handy helper functions for model evaluations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b82820c7-3649-4559-9e1f-04fe3e390ebc", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp inference.evaluation_helper" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68f0714b-e45a-46d8-aa05-d6735d4d0e33", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "from genQC.imports import *\n", + "from genQC.utils.async_fn import run_parallel_jobs\n", + "from genQC.platform.simulation import Simulator " + ] + }, + { + "cell_type": "markdown", + "id": "338cf491-3528-440e-9079-d4388efaa448", + "metadata": {}, + "source": [ + "# SRV helper" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f265206e-7f08-4d74-955b-25eb644adc22", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def get_srvs(simulator: Simulator, backend_obj_list: Sequence, n_jobs: int = 1, **kwargs): \n", + " \"\"\"Returns SRVs of a given list of backen objects `backend_obj_list`.\"\"\"\n", + " def _f(backend_obj):\n", + " return simulator.backend.schmidt_rank_vector(backend_obj, **kwargs)\n", + " \n", + " return run_parallel_jobs(_f, backend_obj_list, n_jobs)" + ] + }, + { + "cell_type": "markdown", + "id": "ab5d451d-20de-465d-b47e-174e89e3e4de", + "metadata": {}, + "source": [ + "## Compilation helper" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4cf36492-a8c9-437c-850d-09148fe39eeb", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def get_unitaries(simulator: Simulator, backend_obj_list: Sequence, n_jobs: int = 1, **kwargs):\n", + " \"\"\"Returns unitaries of a given list of backen objects `backend_obj_list`.\"\"\"\n", + " def _f(backend_obj):\n", + " return simulator.backend.get_unitary(backend_obj, **kwargs)\n", + " \n", + " return run_parallel_jobs(_f, backend_obj_list, n_jobs)" + ] + }, + { + "cell_type": "markdown", + "id": "227082e1-29c8-4340-a1a3-2e4071e31604", + "metadata": {}, + "source": [ + "# Export -" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "298aa915-8684-49c0-843e-101a5d84dc20", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "import nbdev; nbdev.nbdev_export()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/inference/export_cudaq.ipynb b/src/inference/export_cudaq.ipynb deleted file mode 100644 index 9446ddc..0000000 --- a/src/inference/export_cudaq.ipynb +++ /dev/null @@ -1,364 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", - "metadata": {}, - "source": [ - "# Export to CUDA-Q" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp inference.export_cudaq" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "from genQC.imports import *\n", - "from typing import Sequence, List, Optional\n", - "import cudaq" - ] - }, - { - "cell_type": "markdown", - "id": "d968941a-c24b-4e2e-bcce-edf497476aa0", - "metadata": {}, - "source": [ - "## CircuitInstructions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5667d650-74c3-4116-95c5-642bb1e69cd0", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "@dataclass\n", - "class CircuitInstruction():\n", - " name: str\n", - " control_nodes: Sequence[int]\n", - " target_nodes: Sequence[int]\n", - " params: Sequence[float]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "95130627-b530-4580-abec-35c77f14d094", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "class CircuitInstructions():\n", - " def __init__(self, tensor_shape: torch.Size) -> None:\n", - " assert len(tensor_shape) == 2 # ... [qubits, time]\n", - " self.tensor_shape = tensor_shape \n", - " self._instructions = []\n", - " self.instruction_names_set = set()\n", - " \n", - " def add_instruction(self, \n", - " name: str, \n", - " control_nodes: Sequence[int], \n", - " target_nodes: Sequence[int], \n", - " params: Sequence[float]) -> None:\n", - " self.instruction_names_set.add(name)\n", - " self._instructions.append(CircuitInstruction(name, control_nodes, target_nodes, params))\n", - "\n", - " @property\n", - " def data(self) -> List[CircuitInstruction]: return self._instructions\n", - "\n", - " @property\n", - " def length(self) -> int: return len(self._instructions)\n", - "\n", - " @property\n", - " def num_qubits(self) -> int: return self.tensor_shape[0]\n", - "\n", - " @property\n", - " def max_gates(self) -> int: return self.tensor_shape[1]\n", - " \n", - " def __repr__(self) -> str: return str(self._instructions)\n", - "\n", - " def print(self) -> None:\n", - " for instruction in self.data: \n", - " print(instruction) " - ] - }, - { - "cell_type": "markdown", - "id": "4adddad8-46fc-4241-ac39-b4ca430ae0dd", - "metadata": {}, - "source": [ - "## CircuitsCudaqBackend" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b3aed961-03b0-4158-8d3a-3188d92b39ac", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "class CircuitsCudaqBackend():\n", - "\n", - " BASIC_BACKEND_TYPE = type[cudaq.kernel]\n", - " \n", - " # Has to match with insides of belows kernel\n", - " KERNEL_VOCABULARY = {\"h\":1, \"cx\":2, \"z\":3, \"x\":4, \"y\":5, \"ccx\":6, \"swap\":7} \n", - " \n", - " def _construct_kernel(self,\n", - " gate_list: List[str],\n", - " target_1_nodes_list: List[int],\n", - " target_2_nodes_list: List[int],\n", - " control_1_nodes_list: List[int],\n", - " control_2_nodes_list: List[int]\n", - " ) -> cudaq.kernel:\n", - " \"\"\"Construct a `cudaq.kernel` from provided paramters.\"\"\"\n", - " \n", - " num_gates = len(gate_list)\n", - " gate_list = [self.KERNEL_VOCABULARY[g] for g in gate_list]\n", - "\n", - " # Note: `@cudaq.kernel` decorator has a overhead of 20ms, regardless of the for-loop inside\n", - " \n", - " @cudaq.kernel\n", - " def place_gate_kernel(gate: int, \n", - " qvector: cudaq.qview,\n", - " target_1: int, \n", - " target_2: int, \n", - " control_1: int, \n", - " control_2: int): \n", - " if gate == 1: h(qvector[target_1])\n", - " elif gate == 2: cx(qvector[control_1], qvector[target_1])\n", - " elif gate == 3: z(qvector[target_1])\n", - " elif gate == 4: x(qvector[target_1])\n", - " elif gate == 5: y(qvector[target_1])\n", - " elif gate == 6: x.ctrl(qvector[control_1], qvector[control_2], qvector[target_1])\n", - " elif gate == 7: swap(qvector[target_1], qvector[target_2])\n", - " \n", - " @cudaq.kernel \n", - " def kernel(input_state: List[complex]):\n", - " qvector = cudaq.qvector(input_state)\n", - " for i in range(num_gates):\n", - " place_gate_kernel(gate_list[i], qvector, target_1_nodes_list[i], target_2_nodes_list[i], control_1_nodes_list[i], control_2_nodes_list[i])\n", - " \n", - " return kernel\n", - "\n", - " def check_error_circuit(self, \n", - " gate: str, \n", - " num_target_nodes: int, \n", - " num_control_nodes: int) -> bool:\n", - " \"\"\"Check number of connections of given gate. Used to check for error circuits.\"\"\"\n", - "\n", - " if gate not in self.KERNEL_VOCABULARY:\n", - " raise NotImplementedError(f\"Unknown gate {gate}, not in `self.KERNEL_VOCABULARY`.\")\n", - " \n", - " if gate in [\"h\", \"z\", \"x\", \"y\"]:\n", - " if num_target_nodes != 1 or num_control_nodes !=0: return False\n", - "\n", - " elif gate in [\"cx\"]:\n", - " if num_target_nodes != 1 or num_control_nodes !=1: return False\n", - "\n", - " elif gate in [\"ccx\"]:\n", - " if num_target_nodes != 1 or num_control_nodes !=2: return False\n", - "\n", - " elif gate in [\"swap\"]:\n", - " if num_target_nodes != 2 or num_control_nodes !=0: return False\n", - "\n", - " else:\n", - " raise NotImplementedError(f\"Unknown gate {gate}, implemetation is faulty!\")\n", - "\n", - " return True\n", - "\n", - " \n", - " def export_cudaq(self, instructions: CircuitInstructions) -> cudaq.kernel:\n", - " \"\"\"Convert given genQC `CircuitInstructions` to a `cudaq.kernel`.\"\"\"\n", - "\n", - " # num_qubits = instructions.num_qubits\n", - " num_gates = instructions.length\n", - "\n", - " # @cudaq.kernel can only take list[int] and no str directly\n", - " # -> we have to map everything to list[int] \n", - " # set default value to 9999 so an error wil be raised if we have a faulty tensor encoding\n", - " \n", - " gate_list = []\n", - " target_1_nodes_list = [9999] * num_gates\n", - " target_2_nodes_list = [9999] * num_gates\n", - " control_1_nodes_list = [9999] * num_gates\n", - " control_2_nodes_list = [9999] * num_gates\n", - "\n", - " for i, instruction in enumerate(instructions.data):\n", - "\n", - " gate = instruction.name.lower()\n", - " control_nodes = instruction.control_nodes\n", - " target_nodes = instruction.target_nodes\n", - " \n", - " if len(instruction.params) > 0:\n", - " raise NotImplementedError(f\"Only support non parametrized gates currently.\")\n", - " \n", - " num_target_nodes = len(target_nodes)\n", - " num_control_nodes = len(control_nodes)\n", - " \n", - " if not self.check_error_circuit(gate, num_target_nodes, num_control_nodes):\n", - " return None\n", - " \n", - " gate_list.append(gate)\n", - " \n", - " if num_target_nodes > 0:\n", - " target_1_nodes_list[i] = target_nodes[0]\n", - " if num_target_nodes > 1: \n", - " target_2_nodes_list[i] = target_nodes[1] \n", - " \n", - " if num_control_nodes > 0:\n", - " control_1_nodes_list[i] = control_nodes[0] \n", - " if num_control_nodes > 1: \n", - " control_2_nodes_list[i] = control_nodes[1] \n", - " \n", - " #--------------------\n", - " kernel= self._construct_kernel(gate_list, target_1_nodes_list, target_2_nodes_list, control_1_nodes_list, control_2_nodes_list)\n", - " return kernel\n", - " \n", - " def get_unitary(self, kernel: cudaq.kernel, num_qubits: int) -> np.ndarray:\n", - " \"\"\"Return the unitary matrix of a `cudaq.kernel`. Currently relies on simulation, could change in future releases of cudaq.\"\"\"\n", - " \n", - " N = 2**num_qubits\n", - " U = np.zeros((N, N), dtype=np.complex128)\n", - " \n", - " for j in range(N): \n", - " state_j = np.zeros((N), dtype=np.complex128) \n", - " state_j[j] = 1\n", - " \n", - " U[:, j] = np.array(cudaq.get_state(kernel, state_j), copy=False)\n", - " \n", - " return U\n", - "\n", - " def draw(self, kernel: cudaq.kernel, num_qubits: int, **kwargs) -> None:\n", - " \"\"\"Draw the given `cudaq.kernel` using cudaq.\"\"\" \n", - " c = [0] * (2**num_qubits)\n", - " c[0] = 1\n", - " print(cudaq.draw(kernel, c))" - ] - }, - { - "cell_type": "markdown", - "id": "fecd2687-2986-4a2d-96fd-ea2d55aae235", - "metadata": {}, - "source": [ - "## Decode" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "101024b0-3c9c-40de-9e56-7f55de3b7673", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def tensor_to_instructions(tensor: torch.Tensor, \n", - " vocabulary_inverse: dict, \n", - " params_tensor: Optional[torch.Tensor] = None, \n", - " params_4pi_normalization: bool = True,\n", - " sign_labels: dict = {\"control_nodes\":-1, \"target_nodes\":+1}) -> CircuitInstructions:\n", - " \"\"\"Convert a given `torch.Tensor` to `CircuitInstructions`.\"\"\"\n", - " \n", - " assert tensor.dim() == 2, f\"{tensor.shape=}\"\n", - " num_of_qubits, time = tensor.shape\n", - " \n", - " instructions = CircuitInstructions(tensor_shape=tensor.shape)\n", - " \n", - " for t in range(time): \n", - " enc_time_slice = tensor[:, t] # contains all bits at time t \n", - " \n", - " for gate_index, gate in vocabulary_inverse.items(): \n", - " \n", - " target_nodes = (enc_time_slice == (sign_labels[\"target_nodes\"] * gate_index)).nonzero(as_tuple=True)[0]\n", - " control_nodes = (enc_time_slice == (sign_labels[\"control_nodes\"] * gate_index)).nonzero(as_tuple=True)[0]\n", - " \n", - " if target_nodes.nelement() > 0: \n", - " params = []\n", - " if exists(params_tensor):\n", - " params = params_tensor[:, t]\n", - " if params_4pi_normalization:\n", - " params = (params+1.0) * 2.0*np.pi # [-1, 1] to [0, 4pi]\n", - " params = params.tolist()\n", - "\n", - " instructions.add_instruction(gate, control_nodes.tolist(), target_nodes.tolist(), params)\n", - " \n", - " break #break on first hit, per def only one gate allowed per t\n", - " \n", - " elif control_nodes.nelement() > 0: # no target but control means error\n", - " raise RuntimeError(\"target_nodes.nelement() <= 0 but control_nodes.nelement() > 0\")\n", - " \n", - " #else we are fine with tensors that have time steps with no action!\n", - " \n", - " return instructions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7d81b862-99c2-4f71-ba05-0acfe7f5d20a", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "backend = CircuitsCudaqBackend()\n", - "\n", - "def genqc_to_cudaq(tensor: torch.Tensor, vocabulary_inverse: dict) -> cudaq.kernel:\n", - " \"\"\"Convert given `torch.Tensor` to a `cudaq.kernel`.\"\"\"\n", - " instructions = tensor_to_instructions(tensor, vocabulary_inverse) \n", - " kernel = backend.export_cudaq(instructions)\n", - " return kernel" - ] - }, - { - "cell_type": "markdown", - "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", - "metadata": {}, - "source": [ - "# Export -" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", - "metadata": {}, - "outputs": [], - "source": [ - "#| hide\n", - "import nbdev; nbdev.nbdev_export()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/inference/infer_compilation.ipynb b/src/inference/infer_compilation.ipynb deleted file mode 100644 index 6fec960..0000000 --- a/src/inference/infer_compilation.ipynb +++ /dev/null @@ -1,564 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", - "metadata": {}, - "source": [ - "# Inference compilation functions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp inference.infer_compilation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "from genQC.imports import *\n", - "from genQC.util import *\n", - "from genQC.inference.infer_misc import *\n", - "from genQC.inference.infer_gate_hist import get_tensor_gate_length\n", - "import genQC.platform.qcircuit_dataset_construction as data_con\n", - "from genQC.dataset.dataset_helper import check_duplicates_in_dataset, uniquify_tensor_dataset, shuffle_tensor_dataset\n", - "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate\n", - "\n", - "from joblib import Parallel, delayed\n", - "import qiskit.quantum_info as qi" - ] - }, - { - "cell_type": "markdown", - "id": "5ae5d100-cb10-457e-8486-ef7866604f59", - "metadata": {}, - "source": [ - "## Misc" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "505366e1-7aa9-4cde-a521-06236566620d", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def split_U_to_tensor(U: np.ndarray):\n", - " U_r, U_i = torch.Tensor(np.real(U)), torch.Tensor(np.imag(U))\n", - " U = torch.stack([U_r, U_i], dim=0)\n", - " return U" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9b1379df-a6a4-4853-a11c-e78918626175", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_new_unitary_indices(Us, dataset, silent=False):\n", - " if type(Us) == list: \n", - " Us = torch.stack([split_U_to_tensor(U) for U in Us]) #numpy to torch\n", - "\n", - " if not silent:\n", - " print(f\"- Checking {Us.shape[0]} unitaries for duplicates in dataset, {torch.unique(Us, dim=0).shape[0]} given unitaries are unique.\")\n", - " \n", - " # need to check uniques only \n", - " Us_dataset = torch.unique(dataset.U, dim=0)\n", - "\n", - " # to vecs\n", - " Us = torch.reshape(Us , [Us.shape[0] , -1]).to(Us_dataset.device) \n", - " Us_dataset = torch.reshape(Us_dataset, [Us_dataset.shape[0], -1]) \n", - " \n", - " #---------------\n", - "\n", - " #check\n", - " comp = ( Us_dataset.unsqueeze(dim=0) == Us.unsqueeze(dim=1) ) # gives [num of Us, num of dataset, ch]\n", - " comp = torch.all(comp, dim=-1) # gives [num of Us, num of dataset]\n", - "\n", - " #reduce\n", - " comp = torch.all(comp==False, dim=1) # gives indices that ARE NOT in datset\n", - " # comp = torch.any(comp, dim=1) # gives indices that ARE in datset\n", - "\n", - " #get indices\n", - " comp = comp.nonzero().squeeze(dim=1)\n", - " \n", - " if not silent:\n", - " print(f\"- Checked {Us.shape[0]} given unitaries with dataset. Returned indices of {comp.shape[0]} not in dataset unitaries.\") \n", - " \n", - " return comp.cpu()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e3de392c-0032-4c12-b33f-ea8d8ffc1d01", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_new_unitary_indices_batch(Us, dataset, auto_batch_size=32, silent=False, n_jobs=1):\n", - " if type(Us) == list: \n", - " Us = torch.stack([split_U_to_tensor(U) for U in Us]) #numpy to torch\n", - "\n", - " if not silent:\n", - " print(f\"- Checking {Us.shape[0]} unitaries for duplicates in dataset, {torch.unique(Us, dim=0).shape[0]} given unitaries are unique.\")\n", - "\n", - " #----------------------------------------\n", - " samples = Us.shape[0]\n", - " num_batches = int(np.ceil(samples/auto_batch_size))\n", - "\n", - " Us_chunks = Us.chunk(num_batches)\n", - "\n", - " indices = []\n", - " \n", - " if n_jobs > 1:\n", - " f = lambda Us_chunk: get_new_unitary_indices(Us_chunk, dataset, silent=True)\n", - " indices = Parallel(n_jobs=n_jobs)(delayed(f)(Us_chunk) for Us_chunk in Us_chunks) \n", - "\n", - " else: \n", - " for Us_chunk in Us_chunks: \n", - " comp = get_new_unitary_indices(Us_chunk, dataset, silent=True)\n", - " indices.append(comp)\n", - " \n", - " indices = torch.cat(indices)\n", - "\n", - " if not silent:\n", - " print(f\"- Checked {samples} given unitaries with dataset. Returned indices of {indices.shape[0]} not in dataset unitaries.\") \n", - " \n", - " return indices" - ] - }, - { - "cell_type": "markdown", - "id": "f28517c0-6105-4e0e-b643-1b1742b5085b", - "metadata": {}, - "source": [ - "## Generation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "164ccd9c-b696-4595-add0-ad7654690b73", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def generate_comp_tensors(pipeline, prompt, U, samples, system_size, num_of_qubits, max_gates, g, no_bar=True, unique=False, auto_batch_size=512):\n", - " #----------------------\n", - " #prepare condtions\n", - "\n", - " prompt = str(prompt)\n", - " c = pipeline.text_encoder.tokenize_and_push_to_device(prompt)\n", - "\n", - " U = U.unsqueeze(0).to(pipeline.device)\n", - " if system_size > num_of_qubits:\n", - " n = 2**system_size\n", - " pad = (0, n-U.shape[-1], 0, n-U.shape[-2]) \n", - " U = F.pad(U, pad, \"constant\", 0)\n", - "\n", - " #----------------------\n", - " #sample and post process to tensor encodings \n", - " \n", - " batch_samples = [auto_batch_size] * int(np.floor(samples/auto_batch_size))\n", - " if samples % auto_batch_size > 0: batch_samples.append(samples % auto_batch_size)\n", - " if len(batch_samples) == 0: batch_samples.append(samples)\n", - "\n", - " out_tensor_list = []\n", - " for batch_sample in batch_samples: \n", - " \n", - " c_batch = c.repeat(batch_sample, *[1]*(c.dim()-1))\n", - " U_batch = U.repeat(batch_sample, *[1]*(U.dim()-1))\n", - " \n", - " latents = torch.randn((c_batch.shape[0], pipeline.model.clr_dim, system_size, max_gates)) \n", - " out_tensor = pipeline(latents=latents, c=c_batch, U=U_batch, g=g, no_bar=no_bar) \n", - " out_tensor_list.append(out_tensor)\n", - " \n", - " out_tensor = torch.cat(out_tensor_list)\n", - " # out_tensor = pipeline(latents=latents, c=c, U=U, g=g, no_bar=no_bar) \n", - "\n", - " out_tensor = pipeline.model.invert_clr(out_tensor)\n", - " out_tensor = out_tensor[:, :num_of_qubits]\n", - " \n", - " if unique: out_tensor = torch.unique(out_tensor, dim=0)\n", - " \n", - " if not no_bar: print(f\"[INFO]: (generate_comp_tensors) Generated {'unique_cnt ' if unique else ''}{out_tensor.shape[0]} tensors\")\n", - "\n", - " return out_tensor" - ] - }, - { - "cell_type": "markdown", - "id": "7759fbca-3c32-4bbd-9893-180688df5b61", - "metadata": {}, - "source": [ - "## Accuracy" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1aaeed42-d97e-42e4-8cc4-c65e47163211", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def check_correct_gates(qc, num_of_qubits, gate_pool, max_gates, allowed_gate_clrs):\n", - " tensor = data_con.encode_circuit(qc, num_of_qubits, data_con.gate_pool_to_gate_classes(gate_pool), max_gates)\n", - " gen_gate_clrs = torch.unique(tensor.abs()).tolist() \n", - " gate_corr = set(gen_gate_clrs).issubset(set(allowed_gate_clrs)) # are gates correct?\n", - " return gate_corr" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5a7bf2d2-d50d-47f5-914d-faeb7d2e00ca", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def check_correct_unitary_exact(qc, U):\n", - " is_U = qi.Operator(qc).to_matrix()\n", - " is_U = split_U_to_tensor(is_U)\n", - "\n", - " u_corr = torch.allclose(is_U, U) # is U correct?\n", - " return u_corr" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e1c12a93-b414-4726-b3be-2fe2ad432fa9", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def check_correct_unitary_distance(qc, target_U, norms):\n", - " is_U = qi.Operator(qc).to_matrix()\n", - " is_U = torch.complex(torch.Tensor(np.real(is_U)), torch.Tensor(np.imag(is_U)))\n", - " \n", - " target_U = torch.complex(target_U[0], target_U[1])\n", - " \n", - " d = []\n", - " for norm in norms:\n", - " u_dist = norm.distance(is_U, target_U).item()\n", - " d.append(u_dist)\n", - " \n", - " return d" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c78f2ef0-f735-43d6-9950-09003e337db2", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_gate_and_U_acc(out_tensor, allowed_gate_clrs, U, gate_pool, num_of_qubits, max_gates, norms=[], no_bar=True):\n", - "\n", - " if isinstance(gate_pool[0], str):\n", - " gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in gate_pool]\n", - " \n", - " #-------------------------\n", - " #decode \n", - " qc_list, error_cnt = convert_tensors_to_circuits(out_tensor, gate_pool)\n", - " if not no_bar: print(f\"Error circuits: {error_cnt}\")\n", - " \n", - " #-------------------------\n", - " acc = [] # combinded acc\n", - " gate_acc = [] # only gates acc\n", - " u_acc = [] # only U acc\n", - " u_norms = [] # list of tuple(norms) for every qc\n", - " \n", - " comb_corr_qc = []\n", - " gate_corr_qc = []\n", - " u_corr_qc = []\n", - " \n", - " #only check circuits that are non-error!\n", - " for qc in qc_list:\n", - " \n", - " #---------------\n", - " # check if in out_tensor only color that correspond to the condtion gate_pool \n", - " gate_corr = check_correct_gates(qc, num_of_qubits, gate_pool, max_gates, allowed_gate_clrs)\n", - " \n", - " #---------------\n", - " # check unitary \n", - " u_corr = check_correct_unitary_exact(qc, U) # true or false\n", - " u_norm = check_correct_unitary_distance(qc, U, norms) # metrics values list\n", - "\n", - " #--------------- \n", - " acc.append(gate_corr and u_corr) \n", - " gate_acc.append(gate_corr) \n", - " u_acc.append(u_corr)\n", - " u_norms.append(u_norm)\n", - " \n", - " if gate_corr and u_corr: comb_corr_qc.append(qc)\n", - " if gate_corr: gate_corr_qc.append(qc)\n", - " if u_corr: u_corr_qc.append(qc)\n", - " \n", - " #average accuracy over sample\n", - " acc = np.mean(acc).item()\n", - " gate_acc = np.mean(gate_acc).item()\n", - " u_acc = np.mean(u_acc).item()\n", - " \n", - " return acc, gate_acc, u_acc, np.array(u_norms), error_cnt, comb_corr_qc, gate_corr_qc, u_corr_qc, qc_list" - ] - }, - { - "cell_type": "markdown", - "id": "c43df64d-4e2f-4866-a8d6-81251a7a5a4a", - "metadata": {}, - "source": [ - "## Tests" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ff118e92-cdba-4d1d-afd5-4e1ec6d8b3a7", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_comp_acc(pipeline, samples, system_size, gate_pool, num_of_qubits, max_gates, g, str_cond_to_gate_indices: callable, Us, ys, train_dataset=None, norms=[]):\n", - " \n", - " if exists(train_dataset):\n", - " not_dups_ind = get_new_unitary_indices_batch(Us, train_dataset) \n", - " Us = [Us[i] for i in not_dups_ind]\n", - " ys = [ys[i] for i in not_dups_ind]\n", - " \n", - " #--------------------\n", - " acc_s = []\n", - " gate_acc_s = []\n", - " u_acc_s = []\n", - " u_norms_s = []\n", - " uniques_cnt_s = []\n", - " error_cnt_s = []\n", - " \n", - " num_found_distinct_circuits_s = []\n", - " \n", - " for U,y in tqdm(zip(Us,ys), total=len(Us)):\n", - " \n", - " allowed_gate_clrs = str_cond_to_gate_indices(y) \n", - " if isinstance(U, np.ndarray):\n", - " U = split_U_to_tensor(U)\n", - " \n", - " out_tensor = generate_comp_tensors(pipeline, y, U, samples, system_size, num_of_qubits, max_gates, g, unique=False)\n", - " outs = get_gate_and_U_acc(out_tensor, allowed_gate_clrs, U, gate_pool, num_of_qubits, max_gates, norms) \n", - " \n", - " acc, gate_acc, u_acc, u_norms, error_cnt, comb_corr_qc, gate_corr_qc, u_corr_qc, qc_list = outs\n", - "\n", - " if len(qc_list) > 0:\n", - " uniques_cnt = torch.stack([data_con.encode_circuit(qc, num_of_qubits, data_con.gate_pool_to_gate_classes(gate_pool), max_gates) for qc in qc_list]).unique(dim=0).shape[0] #how many uniques in sample (not counting erroro circuits)\n", - " # uniques_cnt = out_tensor.shape[0] - error_cnt #was with unique acc definition\n", - " else:\n", - " uniques_cnt = 0\n", - "\n", - " if len(comb_corr_qc) > 0:\n", - " num_found_distinct_circuits = torch.stack([data_con.encode_circuit(qc, num_of_qubits, data_con.gate_pool_to_gate_classes(gate_pool), max_gates) for qc in comb_corr_qc]).unique(dim=0).shape[0] #how many distinct exact solutions we have\n", - " else:\n", - " num_found_distinct_circuits = 0\n", - " \n", - " #--------------------\n", - " acc_s.append(acc)\n", - " gate_acc_s.append(gate_acc)\n", - " u_acc_s.append(u_acc)\n", - " u_norms_s.append(u_norms)\n", - " uniques_cnt_s.append(uniques_cnt)\n", - " error_cnt_s.append(error_cnt)\n", - " num_found_distinct_circuits_s.append(num_found_distinct_circuits)\n", - " \n", - " solved_tasks = np.count_nonzero(num_found_distinct_circuits_s)\n", - " print(f\"Solved {solved_tasks} correctly (at least one qc) that is {100*solved_tasks/len(num_found_distinct_circuits_s):0.2f}%\")\n", - " \n", - " return acc_s, gate_acc_s, u_acc_s, u_norms_s, uniques_cnt_s, error_cnt_s, num_found_distinct_circuits_s " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f4219c42-aaf5-4a8c-9c18-017ba9d6cc26", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_comp_acc_on_testset(pipeline, samples, num_of_U, system_size, gate_pool, num_of_qubits, max_gates, g, str_cond_to_gate_indices: callable, \n", - " prompt_mod: callable, test_dataset, train_dataset=None, norms=[], fix_y=None):\n", - " '''returns: acc_s, gate_acc_s, u_acc_s, uniques_cnt_s, error_cnt_s, num_found_circuits_s, task_qc_len_s'''\n", - " \n", - " if hasattr(test_dataset, \"z\"): # mixed dataset has padding but a z record! \n", - " Us, ys, zs = uniquify_tensor_dataset(test_dataset.U, test_dataset.y, test_dataset.z) \n", - " Us, ys, zs = shuffle_tensor_dataset(Us, ys, zs)\n", - " Us, ys, zs = Us[:num_of_U], ys[:num_of_U], zs[:num_of_U]\n", - " task_qc_len_s = zs[:, 1]\n", - " \n", - " else: # not mixed dataset has no padding\n", - " Us, ys, xs = uniquify_tensor_dataset(test_dataset.U, test_dataset.y, test_dataset.x) \n", - " Us, ys, xs = shuffle_tensor_dataset(Us, ys, xs)\n", - " Us, ys, xs = Us[:num_of_U], ys[:num_of_U], xs[:num_of_U]\n", - " task_qc_len_s = get_tensor_gate_length(xs) \n", - "\n", - " if exists(fix_y): ys = [fix_y for y in ys]\n", - " else: ys = [prompt_mod(y) for y in ys]\n", - " \n", - " \n", - " print(f\"Picked {Us.shape[0]} unitaries from test set\")\n", - " print(f\"Sample task: {ys[0]}\")\n", - " print(Us[0])\n", - " print(xs[0])\n", - " \n", - " out = test_comp_acc(pipeline, samples, system_size, gate_pool, num_of_qubits, max_gates, g, str_cond_to_gate_indices, Us.cpu(), ys, train_dataset, norms) \n", - " return *out, task_qc_len_s" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7f3246d9-9ef9-4d67-82e8-45c1dce8dff2", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_comp_acc_on_rnd_samples(pipeline, samples, num_of_U, system_size, gate_pool, num_of_qubits, max_gates, g, str_cond_to_gate_indices: callable,\n", - " prompt_mod: callable, # takes a single prompt and returns it modified\n", - " rnd_min_gates, rnd_max_gates,\n", - " train_dataset=None, norms=[], fix_y=None):\n", - " '''returns: acc_s, gate_acc_s, u_acc_s, uniques_cnt_s, error_cnt_s, num_found_circuits_s, task_qc_len_s'''\n", - " \n", - " enc_t, ys, Us = data_con.gen_compilation_rndGates_dataset(num_of_U, num_of_qubits, rnd_min_gates, rnd_max_gates, gate_pool)\n", - " task_qc_len_s = get_tensor_gate_length(enc_t) #should give a complexity meassure, longer circuits have a more complex unitary to compile? \n", - "\n", - " if exists(fix_y): ys = [fix_y for y in ys]\n", - " else: ys = [prompt_mod(y) for y in ys]\n", - " \n", - " print(f\"Sample task: {ys[0]}\")\n", - " print(split_U_to_tensor(Us[0]))\n", - " print(enc_t[0])\n", - " \n", - " out = test_comp_acc(pipeline, samples, system_size, gate_pool, num_of_qubits, max_gates, g, str_cond_to_gate_indices, Us, ys, train_dataset, norms)\n", - " return *out, task_qc_len_s" - ] - }, - { - "cell_type": "markdown", - "id": "38a9071d-5cca-4edd-9bb9-a1614bf4c3fc", - "metadata": {}, - "source": [ - "## Plot" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a53b2487-bc9e-406c-9580-2a99c6c33fc7", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def plot_hist_overview(out_tuple, num_of_samples_per_U, rnd_min_gates, rnd_max_gates, max_gates, num_of_qubits):\n", - " acc_s, gate_acc_s, u_acc_s, u_norms_s, uniques_cnt_s, error_cnt_s, num_found_circuits_s, task_qc_len_s = out_tuple \n", - " \n", - " if not exists(rnd_min_gates): rnd_min_gates = \"\"\n", - " if not exists(rnd_max_gates): rnd_max_gates = \"\"\n", - " \n", - " fig, axs = plt.subplots(2, 3, figsize=(13, 6.4), squeeze=False, constrained_layout=True) \n", - " fig.suptitle(f\"Histogram of compilation accuracies (Unitary cnt={len(acc_s)}, samples_per_U={num_of_samples_per_U} {rnd_min_gates=} {rnd_max_gates=} {max_gates=} qubits={num_of_qubits})\")\n", - "\n", - " n = 20\n", - " density = False\n", - " bins = np.linspace(0,1, n+1)\n", - "\n", - " #-----------------\n", - " plt.sca(axs[0, 0])\n", - " plt.title(\"Combined accuracy\")\n", - " plt.xlabel(r\"Accuracy\")\n", - " plt.ylabel(r\"Bin population\" if density==False else \"Accuracy distribution\")\n", - " plt.hist(acc_s, density=density, bins=n*4)\n", - "\n", - " #-----------------\n", - " plt.sca(axs[0, 1])\n", - " plt.title(\"Unitary accuracy\")\n", - " plt.xlabel(r\"Accuracy\")\n", - " plt.hist(u_acc_s, density=density, bins=bins)\n", - "\n", - " #-----------------\n", - " plt.sca(axs[0, 2])\n", - " plt.title(\"Gate accuracy\")\n", - " plt.xlabel(r\"Accuracy\")\n", - " plt.hist(gate_acc_s, density=density, bins=bins)\n", - "\n", - " #-----------------\n", - " plt.sca(axs[1, 0])\n", - " plt.title(\"Generated unique circuits\")\n", - " plt.ylabel(r\"Bin population\" if density==False else \"Number distribution\")\n", - " plt.xlabel(r\"Number of unique circuits\")\n", - " plt.hist(uniques_cnt_s, density=density, bins=n)\n", - " \n", - " #-----------------\n", - " plt.sca(axs[1, 1])\n", - " plt.title(\"Generated error circuits\")\n", - " plt.xlabel(r\"Number of error circuits\")\n", - " plt.hist(error_cnt_s, density=density, bins=n)\n", - " \n", - " #-----------------\n", - " plt.sca(axs[1, 2])\n", - " plt.title(\"Absolute number of distinct correct circuits\")\n", - " plt.xlabel(r\"Number of found circuits\")\n", - " plt.hist(num_found_circuits_s, density=density, bins=n*4)\n", - " \n", - " #-----------------\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", - "metadata": {}, - "source": [ - "# Export -" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", - "metadata": {}, - "outputs": [], - "source": [ - "#| hide\n", - "import nbdev; nbdev.nbdev_export()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/inference/infer_gate_hist.ipynb b/src/inference/infer_gate_hist.ipynb deleted file mode 100644 index 1bf6d99..0000000 --- a/src/inference/infer_gate_hist.ipynb +++ /dev/null @@ -1,102 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", - "metadata": {}, - "source": [ - "# Inference gate distribution" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp inference.infer_gate_hist" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "from genQC.imports import *" - ] - }, - { - "cell_type": "markdown", - "id": "d968941a-c24b-4e2e-bcce-edf497476aa0", - "metadata": {}, - "source": [ - "## Gate length" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4990eae0-c931-4b6a-b540-82c77c26c992", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_tensor_gate_length(clr_tensor, padding_token=0):\n", - " '''Careful with padding tokens!'''\n", - " assert clr_tensor.dim() == 3 #[b, s, t]\n", - " \n", - " collabsed_clr_tensor = (clr_tensor != padding_token).to(torch.int8)\n", - " red_clr_tensor = torch.sum(collabsed_clr_tensor, dim=1) # [b, t]\n", - " return torch.count_nonzero(red_clr_tensor, dim=1) # [b]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b55214a-6f4d-41f0-a61f-beddcf037411", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_circuit_gate_length(qcs): \n", - " lengths = torch.zeros(len(qcs), dtype=int) \n", - " for i,qc in enumerate(qcs): \n", - " if hasattr(qc, \"data\"): \n", - " lengths[i] = len(qc.data) \n", - " return lengths" - ] - }, - { - "cell_type": "markdown", - "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", - "metadata": {}, - "source": [ - "# Export -" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", - "metadata": {}, - "outputs": [], - "source": [ - "#| hide\n", - "import nbdev; nbdev.nbdev_export()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/inference/infer_misc.ipynb b/src/inference/infer_misc.ipynb deleted file mode 100644 index b6a69ba..0000000 --- a/src/inference/infer_misc.ipynb +++ /dev/null @@ -1,141 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", - "metadata": {}, - "source": [ - "# Inference miscellaneous functions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp inference.infer_misc" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "from genQC.imports import *\n", - "from genQC.platform.qcircuit_dataset_construction import decode_circuit, gate_pool_to_gate_classes\n", - "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate" - ] - }, - { - "cell_type": "markdown", - "id": "d968941a-c24b-4e2e-bcce-edf497476aa0", - "metadata": {}, - "source": [ - "## Misc" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a9b6311a-916c-48e9-8f94-7f612884c643", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_rnd_gatepool_subset(gate_pool, min_sub_gate_pool_cnt=2):\n", - " rng = np.random.default_rng()\n", - " \n", - " n = len(gate_pool) + 1\n", - " c_range = np.arange(n-1)\n", - " \n", - " sub_gate_pool_cnt = rng.integers(min_sub_gate_pool_cnt, n) \n", - " sub_gate_pool_ind = rng.choice(c_range, size=sub_gate_pool_cnt, replace=False) \n", - " sub_gate_pool = [gate_pool[ind] for ind in sub_gate_pool_ind] # pick random subeset of gates\n", - " \n", - " return sub_gate_pool" - ] - }, - { - "cell_type": "markdown", - "id": "ecb1da3e-e9cc-420e-9a05-39d6c033b371", - "metadata": {}, - "source": [ - "## Convertion" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e0e50913-ebc3-43c4-a5b6-f8e75cb776cc", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def convert_tensors_to_circuits(out_tensor, gate_pool, params_tensor=None, place_barrier=False): \n", - " if isinstance(gate_pool[0], str):\n", - " gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in gate_pool]\n", - " \n", - " error_cnt = 0\n", - " qc_list = []\n", - "\n", - " if not exists(params_tensor):\n", - " params_tensor = [None]*out_tensor.shape[0]\n", - " \n", - " #TODO: para this loop\n", - " \n", - " for i,(enc_tensor,p) in enumerate(zip(out_tensor, params_tensor)): \n", - " try:\n", - " qc = decode_circuit(enc_tensor=enc_tensor, gate_pool=gate_pool, place_barrier=place_barrier, params_tensor=p)\n", - "\n", - " except Exception as e:\n", - " error_cnt += 1\n", - " # print(e)\n", - " continue\n", - " \n", - " qc_list.append(qc) \n", - " \n", - " return qc_list, error_cnt" - ] - }, - { - "cell_type": "markdown", - "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", - "metadata": {}, - "source": [ - "# Export -" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", - "metadata": {}, - "outputs": [], - "source": [ - "#| hide\n", - "import nbdev; nbdev.nbdev_export()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/inference/infer_srv.ipynb b/src/inference/infer_srv.ipynb deleted file mode 100644 index f726e51..0000000 --- a/src/inference/infer_srv.ipynb +++ /dev/null @@ -1,737 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", - "metadata": {}, - "source": [ - "# Inference SRV functions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp inference.infer_srv" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "from genQC.imports import *\n", - "from genQC.inference.infer_misc import *\n", - "from genQC.inference.infer_gate_hist import get_circuit_gate_length\n", - "from genQC.platform.qcircuit_util import get_entanglement_bins\n", - "from genQC.platform.simulation.qcircuit_sim import schmidt_rank_vector\n", - "from genQC.inference.infer_compilation import generate_comp_tensors\n", - "\n", - "from joblib import Parallel, delayed\n", - "import qiskit.quantum_info as qi" - ] - }, - { - "cell_type": "markdown", - "id": "1cfa411d-6574-4e83-875b-40c146b4a8e3", - "metadata": {}, - "source": [ - "## Generation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "45069ca8-b558-413d-9848-934d631b674e", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_all_srvs(num_of_qubits):\n", - " srvs = [x for x in itertools.product(*([[1,2]]*num_of_qubits))]\n", - " srvs = np.array(srvs, dtype=int)[np.sum(srvs, axis=1)!=num_of_qubits+1].tolist()\n", - " srvs = sorted(srvs, key=lambda x: sum(x))\n", - " return srvs" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "868fe792-0d99-46e6-ac15-4c2a6e7ef640", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def generate_srv_tensors(pipeline, prompt, samples, system_size, num_of_qubits, max_gates, g, no_bar=True, unique=False, auto_batch_size=512):\n", - " if samples==0:\n", - " out_tensor = torch.zeros((0, system_size, max_gates))\n", - " return out_tensor\n", - " \n", - " #----------------------\n", - " #prepare condtions\n", - " \n", - " prompt = str(prompt)\n", - " c = pipeline.text_encoder.tokenize_and_push_to_device(prompt)\n", - "\n", - " #----------------------\n", - " #sample and post process to tensor encodings\n", - "\n", - " batch_samples = [auto_batch_size] * int(np.floor(samples/auto_batch_size))\n", - " if samples % auto_batch_size > 0: batch_samples.append(samples % auto_batch_size)\n", - " if len(batch_samples) == 0: batch_samples.append(samples)\n", - "\n", - " out_tensor_list = []\n", - " for batch_sample in batch_samples: \n", - " \n", - " c_batch = c.repeat(batch_sample, *[1]*(c.dim()-1))\n", - " \n", - " latents = torch.randn((c_batch.shape[0], pipeline.model.clr_dim, system_size, max_gates)) \n", - " out_tensor = pipeline(latents=latents, c=c_batch, g=g, no_bar=no_bar, enable_guidance=True) \n", - " out_tensor_list.append(out_tensor)\n", - " \n", - " out_tensor = torch.cat(out_tensor_list)\n", - " out_tensor = pipeline.model.invert_clr(out_tensor)\n", - " out_tensor = out_tensor[:, :num_of_qubits]\n", - " \n", - " if unique: out_tensor = torch.unique(out_tensor, dim=0)\n", - " \n", - " if not no_bar: print(f\"[INFO]: (generate_srv_tensors) Generated {'unique_cnt ' if unique else ''}{out_tensor.shape[0]} tensors\")\n", - "\n", - " return out_tensor" - ] - }, - { - "cell_type": "markdown", - "id": "29ae8e82-dcc4-456b-8422-cd8ffdd25eab", - "metadata": {}, - "source": [ - "## Convertion" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ab7e53f2-c673-40ae-8378-833fd78be0fd", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def convert_tensors_to_srvs(out_tensor, gate_pool, sort_srv=False, place_barrier=False, n_jobs=1): \n", - " qc_list, error_cnt = convert_tensors_to_circuits(out_tensor, gate_pool=gate_pool, place_barrier=place_barrier)\n", - " \n", - " srv_list = []\n", - " \n", - " #---------------------------------------------\n", - " # This is a bottle-neck for more qubits, speed up with async\n", - " \n", - " if n_jobs > 1:\n", - " assert sort_srv == False\n", - " \n", - " f = lambda qc: schmidt_rank_vector(qi.DensityMatrix(qc))\n", - " # srv_list = Parallel(n_jobs=n_jobs, prefer=\"threads\")(delayed(f)(qc) for qc in qc_list) #prefer=\"threads\"\n", - " srv_list = Parallel(n_jobs=n_jobs)(delayed(f)(qc) for qc in qc_list) \n", - " \n", - " else: \n", - " for qc in qc_list: \n", - " srv = schmidt_rank_vector(qi.DensityMatrix(qc))\n", - " \n", - " if sort_srv: srv = sorted(srv) \n", - " srv_list.append(srv) \n", - " \n", - " return qc_list, error_cnt, srv_list" - ] - }, - { - "cell_type": "markdown", - "id": "6f247332-0894-4603-bbee-c556bc5820b6", - "metadata": {}, - "source": [ - "## Accuracy" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8ca4de23-cdb5-4b00-a89e-04b14cffcf7c", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_srv_accuracy(srv_list, target_srv):\n", - " if not isinstance(srv_list , (torch.Tensor, torch.IntTensor, torch.FloatTensor, torch.LongTensor)): srv_list = torch.tensor(srv_list)\n", - " if not isinstance(target_srv, (torch.Tensor, torch.IntTensor, torch.FloatTensor, torch.LongTensor)): target_srv = torch.tensor(target_srv, device=srv_list.device)\n", - " \n", - " srv_uniques, srv_uniques_cnt = torch.unique(srv_list, dim=0, return_counts=True)\n", - " \n", - " if srv_uniques.numel() == 0: return 0\n", - "\n", - " comp = torch.all(target_srv==srv_uniques, dim=1)\n", - " index = comp.nonzero().squeeze() \n", - " \n", - " if index.dim() == 0: correct_srv_percentage = srv_uniques_cnt[index]/srv_uniques_cnt.sum() \n", - " else: correct_srv_percentage = 0 \n", - " \n", - " return correct_srv_percentage" - ] - }, - { - "cell_type": "markdown", - "id": "1c8e729d-edf2-4228-af86-4f4449acc61d", - "metadata": {}, - "source": [ - "## Tests" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "10594109-3085-4c7d-a92b-d7535ab0ad2e", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def true_sample_bin_dist(samples_per_bin, bin_size):\n", - " true_samples = [max(samples_per_bin//bin_size, 1) for i in range(bin_size)]\n", - "\n", - " if samples_per_bin-sum(true_samples) > 0:\n", - " true_samples[0] += (samples_per_bin-sum(true_samples))\n", - " \n", - " # assert sum(true_samples)==samples_per_bin\n", - " # assert len(true_samples)==bin_size\n", - "\n", - " # print(f\"{true_samples=}\")\n", - " \n", - " return true_samples" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "61603163-81b9-439c-b827-72fe37a21b88", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_srv_clr_distribution_bin_samples(pipeline, samples_per_bin, system_size, num_of_qubits, max_gates, g, gate_pool, silent=False, device=\"cpu\", U=None, prompt_mod: callable=lambda c: c,\n", - " only_diag=False, n_jobs=1):\n", - " dist_srvs = get_all_srvs(num_of_qubits) \n", - " cond_srvs = dist_srvs\n", - "\n", - " values = torch.zeros((len(cond_srvs), len(dist_srvs)), device=device)\n", - "\n", - " #---------------------\n", - "\n", - " ent_bins, ent_labels = get_entanglement_bins(num_of_qubits)\n", - "\n", - " i = 0\n", - " \n", - " for ent_bin in tqdm(ent_bins, total=len(ent_bins)):\n", - "\n", - " true_samples = true_sample_bin_dist(samples_per_bin, len(ent_bin))\n", - " \n", - " for ind,srv in tqdm(enumerate(ent_bin), total=len(ent_bin)): \n", - " if exists(U): out_tensor = generate_comp_tensors(pipeline, prompt_mod(srv), U, true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " else: out_tensor = generate_srv_tensors( pipeline, prompt_mod(srv), true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - "\n", - " qc_list, error_cnt, svr_list = convert_tensors_to_srvs(out_tensor, gate_pool, n_jobs=n_jobs)\n", - " \n", - " if only_diag:\n", - " values[i, i] = get_srv_accuracy(svr_list, srv)\n", - " else:\n", - " for j, dist_srv in enumerate(dist_srvs): \n", - " values[i, j] = get_srv_accuracy(svr_list, dist_srv)\n", - " \n", - " if not silent:\n", - " print(f\"{cond_srv}: unique_cnt {out_tensor.unique(dim=0).shape[0]} error_cnt {error_cnt} acc {values[i, i]:.2f}\")\n", - "\n", - " i += 1\n", - " \n", - " return values" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bd284fc6-c028-45c1-888d-b2bd8fa6a565", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_srv_clr_distribution(pipeline, samples_per_srv, system_size, num_of_qubits, max_gates, g, gate_pool, silent=False, device=\"cpu\", U=None, prompt_mod: callable=lambda c: c,\n", - " dist_srvs=None, cond_srvs=None, only_diag=False, n_jobs=1):\n", - " if not exists(dist_srvs):\n", - " dist_srvs = get_all_srvs(num_of_qubits) \n", - " \n", - " if not exists(cond_srvs):\n", - " cond_srvs = dist_srvs\n", - "\n", - " values = torch.zeros((len(cond_srvs), len(dist_srvs)), device=device)\n", - "\n", - " #---------------------\n", - " \n", - " for i, cond_srv in tqdm(enumerate(cond_srvs), total=len(cond_srvs)): \n", - "\n", - " if exists(U): out_tensor = generate_comp_tensors(pipeline, prompt_mod(cond_srv), U, samples_per_srv, system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " else: out_tensor = generate_srv_tensors( pipeline, prompt_mod(cond_srv), samples_per_srv, system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " \n", - " qc_list, error_cnt, svr_list = convert_tensors_to_srvs(out_tensor, gate_pool, n_jobs=n_jobs)\n", - " \n", - " if only_diag:\n", - " values[i, i] = get_srv_accuracy(svr_list, srv)\n", - " else:\n", - " for j, dist_srv in enumerate(dist_srvs): \n", - " values[i, j] = get_srv_accuracy(svr_list, dist_srv)\n", - "\n", - " if not silent:\n", - " print(f\"{cond_srv}: unique_cnt {out_tensor.unique(dim=0).shape[0]} error_cnt {error_cnt} acc {values[i, i]:.2f}\")\n", - "\n", - " return values" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f31d5177-b9a3-4852-8f6f-1bebc69efca1", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_guidance_dep(pipeline, srvs, samples, system_size, num_of_qubits, max_gates, gs, gate_pool, prompt_mod: callable=lambda c: c, U=None, n_jobs=1): \n", - " guidance_dep_out = []\n", - "\n", - " for srv in srvs:\n", - " unique_percentage_list = []\n", - " error_cnt_percentage_list = []\n", - " correct_srv_percentage_list = []\n", - " \n", - " for g in tqdm(gs): \n", - " if exists(U): out_tensor = generate_comp_tensors(pipeline, prompt_mod(srv), U, samples, system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " else: out_tensor = generate_srv_tensors( pipeline, prompt_mod(srv), samples, system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " \n", - " #---------------------------------\n", - " #calculate the copy percentage, dataset and sample? \n", - " \n", - " unique_percentage = out_tensor.unique(dim=0).shape[0]/out_tensor.shape[0] \n", - " unique_percentage_list.append(unique_percentage)\n", - " \n", - " #---------------------------------\n", - " #decode tensors, get srv\n", - " \n", - " qc_list, error_cnt, svr_list = convert_tensors_to_srvs(out_tensor, gate_pool, n_jobs=n_jobs)\n", - " error_cnt_percentage_list.append(error_cnt/out_tensor.shape[0])\n", - " \n", - " #---------------------------------\n", - " #record the correct number \n", - " \n", - " correct_srv_percentage = get_srv_accuracy(svr_list, srv) \n", - " correct_srv_percentage_list.append(correct_srv_percentage)\n", - "\n", - " guidance_dep_out.append((unique_percentage_list, error_cnt_percentage_list, correct_srv_percentage_list))\n", - " \n", - " return guidance_dep_out" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b782437e-a1bb-45e0-835f-e02c173bc798", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_srv_acc_vs_length(pipeline, samples, system_size, num_of_qubits, max_gates, g, gate_pool, prompt_mod: callable=lambda c: c, U=None, n_jobs=1):\n", - " ent_bins, ent_labels = get_entanglement_bins(num_of_qubits)\n", - " \n", - " ent_ls = []\n", - " ent_accs = []\n", - " ent_cnts = []\n", - " \n", - " for ent_bin in tqdm(ent_bins, total=len(ent_bins)):\n", - " ls_acc = dict() #keep track over bins\n", - " ls_cnt = dict()\n", - "\n", - " true_samples = true_sample_bin_dist(samples_per_bin, len(ent_bin))\n", - " \n", - " for ind,srv in enumerate(ent_bin): \n", - " if exists(U): out_tensor = generate_comp_tensors(pipeline, prompt_mod(srv), U, true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " else: out_tensor = generate_srv_tensors( pipeline, prompt_mod(srv), true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " \n", - " qc_list, error_cnt, svr_list = convert_tensors_to_srvs(out_tensor, gate_pool, n_jobs=n_jobs) \n", - "\n", - " lengths = get_circuit_gate_length(qc_list) #work in qc space to check only non errors\n", - "\n", - " if lengths.numel() < 1: continue\n", - " \n", - " for l in lengths.unique(): #range(lengths.min(), lengths.max()):\n", - " indices = (lengths==l).nonzero().squeeze() \n", - " \n", - " if indices.numel() > 0: \n", - " srvs = torch.tensor(svr_list)[indices] \n", - " if indices.dim() == 0: srvs = srvs.unsqueeze(0)\n", - " \n", - " acc = get_srv_accuracy(srvs, srv)\n", - " \n", - " #---------- \n", - " t = ls_acc.pop(l, [])\n", - " t.append(acc)\n", - " ls_acc[l] = t\n", - " \n", - " t = ls_cnt.pop(l, 0)\n", - " t += srvs.shape[0]\n", - " ls_cnt[l] = t\n", - " \n", - " ls = sorted(ls_acc) # sorted keys (l)\n", - " accs = [np.mean(ls_acc[l]) for l in ls] # average acc per l\n", - " cnts = [np.sum(ls_cnt[l]) for l in ls]\n", - " \n", - " ent_ls.append(ls)\n", - " ent_accs.append(accs)\n", - " ent_cnts.append(cnts)\n", - "\n", - " return ent_ls, ent_accs, ent_cnts, ent_labels" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ac48279f-ad30-474c-98e3-da6d2d94f32a", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_srv_acc_vs_maxLength(pipeline, samples_per_bin, system_size, num_of_qubits, max_gates_list, g, gate_pool, prompt_mod: callable=lambda c: c, U=None, n_jobs=1):\n", - " ent_bins, ent_labels = get_entanglement_bins(num_of_qubits)\n", - " \n", - " ent_accs = []\n", - " for ent_bin in tqdm(ent_bins, total=len(ent_bins)):\n", - " \n", - " true_samples = true_sample_bin_dist(samples_per_bin, len(ent_bin))\n", - " \n", - " bin_accs = []\n", - " for max_gates in max_gates_list:\n", - "\n", - " accs = []\n", - " for ind,srv in enumerate(ent_bin): \n", - " if exists(U): out_tensor = generate_comp_tensors(pipeline, prompt_mod(srv), U, true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " else: out_tensor = generate_srv_tensors( pipeline, prompt_mod(srv), true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " \n", - " qc_list, error_cnt, svr_list = convert_tensors_to_srvs(out_tensor, gate_pool, n_jobs=n_jobs) \n", - "\n", - " acc = get_srv_accuracy(svr_list, srv)\n", - " \n", - " accs.append(acc) \n", - " bin_accs.append(np.mean(accs)) \n", - " ent_accs.append(bin_accs)\n", - " \n", - " return ent_accs, ent_labels" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f6fc9c5c-41c6-4905-8d2e-76e301cef284", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def test_srv_length_distribution(pipeline, samples_per_bin, system_size, num_of_qubits, max_gates, g, gate_pool, silent=False, U=None, prompt_mod: callable=lambda c: c, n_jobs=1):\n", - " ent_bins, ent_labels = get_entanglement_bins(num_of_qubits)\n", - "\n", - " ls = []\n", - " \n", - " for ent_bin in tqdm(ent_bins, total=len(ent_bins)):\n", - "\n", - " true_samples = true_sample_bin_dist(samples_per_bin, len(ent_bin))\n", - " \n", - " bin_ls = []\n", - " \n", - " for ind,srv in tqdm(enumerate(ent_bin), total=len(ent_bin)): \n", - " if exists(U): out_tensor = generate_comp_tensors(pipeline, prompt_mod(srv), U, true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - " else: out_tensor = generate_srv_tensors( pipeline, prompt_mod(srv), true_samples[ind], system_size, num_of_qubits, max_gates, g=g, unique=False)\n", - "\n", - " qc_list, error_cnt, svr_list = convert_tensors_to_srvs(out_tensor, gate_pool, n_jobs=n_jobs)\n", - "\n", - " qc_ls = get_circuit_gate_length(qc_list) #tensor [qcs]\n", - " bin_ls.append(qc_ls)\n", - "\n", - " ls.append(torch.cat(bin_ls))\n", - "\n", - " return ls #[ent_bins, num_of_non_err_samples]" - ] - }, - { - "cell_type": "markdown", - "id": "717dcd10-5e19-4bf7-a8ac-7e360c9e9e08", - "metadata": {}, - "source": [ - "## Plot" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7d9df84e-d680-4db0-907d-913fe68fe782", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def plot_srv_clr_distribution_hist(values, samples, num_of_qubits, save=False, dist_srvs=None, cond_srvs=None):\n", - " if not exists(dist_srvs):\n", - " dist_srvs = get_all_srvs(num_of_qubits) \n", - " \n", - " if not exists(cond_srvs):\n", - " cond_srvs = dist_srvs\n", - "\n", - " n = len(dist_srvs)\n", - " values = values.cpu()\n", - " \n", - " fig = plt.figure(figsize=(12,12))#, constrained_layout=True) \n", - " plt.title(f\"Generated samples per condition: {samples}\")\n", - " plt.ylabel(r\"Condition\")\n", - " plt.xlabel(r\"Generated distribution\")\n", - "\n", - " #--------------------------------------------\n", - " if num_of_qubits < 6 or 0:\n", - " plt.yticks(range(len(cond_srvs)), [str(b) for b in cond_srvs])\n", - " plt.xticks(range(n), [str(b) for b in dist_srvs], rotation=90 if n>3 else 0)\n", - " else:\n", - " plt.yticks([])\n", - " plt.xticks([])\n", - "\n", - " #--------------------------------------------\n", - " plt.imshow(values, vmin=0, vmax=1)\n", - " # plt.imshow(values.cpu(), norm=\"log\")\n", - " plt.colorbar()\n", - "\n", - " #--------------------------------------------\n", - " #print acc\n", - " x_shift = 1*40 if num_of_qubits==5 else 0\n", - " if num_of_qubits < 4:\n", - " for i in range(n): \n", - " plt.text(x_shift+i, i, f\"{values[i, i]:0.2f}\", color='black', ha='center', va='center', fontsize=\"large\")\n", - "\n", - " #--------------------------------------------\n", - " #draw rects\n", - " off = 0.5\n", - " for i in range(2, num_of_qubits):\n", - " w = scipy.special.comb(num_of_qubits, i, exact=True)\n", - " plt.gca().add_patch(plt.Rectangle((off, off), w, w, ls=\"-\", ec=\"white\", fc=\"none\")) #, transform=plt.gca().transAxes))\n", - " off += w\n", - "\n", - " #--------------------------------------------\n", - " #print average acc for rects\n", - " off = 0\n", - " for i in [0]+list(range(2, num_of_qubits+1)):\n", - " w = scipy.special.comb(num_of_qubits, i, exact=True) \n", - " d1 = off\n", - " d2 = d1 + w\n", - " mean_acc = values[d1:d2, d1:d2].diag().mean()\n", - " plt.text(off+2*w/3, off+w/7, f\"{mean_acc:0.2f}\", color='red', ha='center', va='center', fontsize=\"x-large\") \n", - " off += w\n", - "\n", - " #--------------------------------------------\n", - " if save:\n", - " plt.savefig('plot_srv_clr_distribution_hist.svg', bbox_inches='tight')\n", - " \n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18161ea0-df08-4ba1-8e45-5a5d58bdd73c", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def plot_srv_clr_distribution_bin_accuracy(values, samples, num_of_qubits, save=False, plot_percentages=False, trainSet_srv=None):\n", - " values = values.cpu().diag()\n", - " ent_bins, ent_labels = get_entanglement_bins(num_of_qubits)\n", - " \n", - " n = sum(len(srvs) for srvs in ent_bins)\n", - " x = np.arange(n) # the label locations\n", - " width = 0.8\n", - "\n", - " #------------------------\n", - " fig = plt.figure(figsize=(6.6, 4), constrained_layout=True) \n", - " # plt.title(f\"Generated samples per condition: {samples}\", fontsize=14)\n", - " plt.ylabel(r\"Accuracy\", fontsize=25)\n", - " plt.yticks(fontsize=14)\n", - " plt.xticks([])\n", - " \n", - " i = 0\n", - " for j,(label, srvs) in enumerate(zip(ent_labels, ent_bins)): \n", - " label = f\"{sum(srvs[0])-num_of_qubits}\"\n", - " incre = len(srvs)\n", - " rects = plt.bar(x[i:i+incre], values[i:i+incre], width, label=label)\n", - " i += incre\n", - " if plot_percentages: plt.gca().bar_label(rects, padding=3, fmt=\"%0.2f\")\n", - "\n", - " ncols = len(ent_labels)//2+1 if len(ent_labels) > 5 else len(ent_labels)\n", - " leg1 = plt.legend(loc=\"lower center\", fontsize=14, ncols=ncols, title=\"# of entangled qubits:\", title_fontsize=14,bbox_to_anchor=(0.5, 1.01))\n", - " ax = fig.add_artist(leg1)\n", - " \n", - " if exists(trainSet_srv):\n", - " if trainSet_srv.shape[-1]==num_of_qubits:\n", - " srvs = []\n", - " for s in ent_bins: srvs.extend(s)\n", - " \n", - " dataset_percentages = [get_srv_accuracy(trainSet_srv, srv).cpu() for srv in srvs]\n", - " xmin = x - width*0.55\n", - " xmax = x + width*0.55 \n", - " ag = plt.hlines(dataset_percentages, xmin, xmax, label=\"Random sampling\" , color=\"black\", linestyle=\"-\", linewidths=2.3)\n", - " \n", - " plt.legend(handles=[ag], fontsize=14, frameon=False)\n", - "\n", - " ymin, ymax = plt.ylim() \n", - " plt.ylim(ymin, ymax+0.04)\n", - "\n", - " if save:\n", - " plt.savefig(f\"plot_srv_clr_distribution_bin_accuracy.svg\", bbox_inches='tight', transparent=True)\n", - " \n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6feddf06-e127-4cca-bf8e-0c2cc173c839", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def plot_guidance_dep(srvs, gs, guidance_dep_out, samples, save=False): \n", - " assert len(srvs) == len(guidance_dep_out)\n", - "\n", - " n = len(srvs)\n", - " fig, axs = plt.subplots(1, n, figsize=(12, 5), squeeze=False, constrained_layout=True) \n", - " fig.suptitle(fr\"Generated {samples} samples per $g$ and SRV\")\n", - " \n", - " for i,srv in enumerate(srvs): \n", - " unique_percentage_list, error_cnt_percentage_list, correct_srv_percentage_list = guidance_dep_out[i]\n", - " \n", - " #---------------------------------\n", - " #plot now gs vs the numbers \n", - " \n", - " plt.sca(axs[0, i])\n", - " plt.xlabel(r\"Guidance scale $g$\") \n", - " plt.title(f\"SRV = {srv}\")\n", - " plt.plot(gs, unique_percentage_list , label=\"Unique tensors percentage\")\n", - " plt.plot(gs, error_cnt_percentage_list , label=\"Error circuits percentage\")\n", - " plt.plot(gs, correct_srv_percentage_list, label=\"Correct SRV percentage\")\n", - " \n", - " if i == (n-1): plt.legend() \n", - "\n", - " if save:\n", - " plt.savefig(\"plot_guidance_dep.svg\", bbox_inches='tight', transparent=True)\n", - " \n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "13cdecfb-080b-49c3-a13e-d9a7c1711fce", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def plot_srv_acc_vs_length(ent_ls, ent_accs, ent_cnts, ent_labels, samples, plot_dist=True, save=False):\n", - " fig, axs = plt.subplots(2 if plot_dist else 1, 1, figsize=(12, 7), squeeze=False, constrained_layout=True) \n", - "\n", - " #-------------------\n", - " plt.sca(axs[0,0])\n", - " plt.title(f\"Generated samples per entanglement: {samples}\")\n", - " plt.ylabel(\"Accuracy\")\n", - " plt.xlabel(\"Gate number\")\n", - " for i,ent_label in enumerate(ent_labels): \n", - " plt.plot(ent_ls[i], ent_accs[i], label=f\"{ent_label}\")\n", - " plt.legend()\n", - "\n", - " #-------------------\n", - " if plot_dist:\n", - " plt.sca(axs[1,0])\n", - " plt.title(f\"Used samples per l to calculate accuracy, should match gate distribution\")\n", - " plt.ylabel(\"Used samples\")\n", - " plt.xlabel(\"Gate number\")\n", - " for i,ent_label in enumerate(ent_labels): \n", - " plt.plot(ent_ls[i], ent_cnts[i], label=f\"{ent_label}\")\n", - " plt.legend()\n", - "\n", - " #-------------------\n", - " if save:\n", - " plt.savefig('plot_srv_acc_vs_length.svg', bbox_inches='tight')\n", - " \n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05c4ebca-e67c-4d8e-bea1-7e0e2cce5aa9", - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def plot_srv_acc_vs_maxLength(ent_accs, ent_labels, max_gates_list, samples, plot_dist=True, save=False):\n", - " fig = plt.figure(figsize=(12, 4), constrained_layout=True) \n", - " \n", - " plt.title(f\"Generated samples per maxGates per entanglement: {samples}\")\n", - " plt.ylabel(\"Accuracy\")\n", - " plt.xlabel(\"Max number of gates / tensor size\")\n", - " plt.xticks(max_gates_list)\n", - " \n", - " for ent_acc,ent_label in zip(ent_accs, ent_labels): \n", - " plt.plot(max_gates_list, ent_acc, label=f\"{ent_label}\")\n", - " \n", - " plt.legend()\n", - "\n", - " if save:\n", - " plt.savefig('plot_srv_acc_vs_length.svg', bbox_inches='tight')\n", - " \n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", - "metadata": {}, - "source": [ - "# Export -" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", - "metadata": {}, - "outputs": [], - "source": [ - "#| hide\n", - "import nbdev; nbdev.nbdev_export()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/inference/sampling.ipynb b/src/inference/sampling.ipynb new file mode 100644 index 0000000..4aac6ea --- /dev/null +++ b/src/inference/sampling.ipynb @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "da4523d0-f8da-4994-9477-3c28ef7be56d", + "metadata": {}, + "source": [ + "# Sampling functions\n", + "\n", + "> Sampling functions for model inference." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4200f54-7513-4597-973f-b8134853db03", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp inference.sampling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54fea3fd-4a6f-43cc-a2ff-b2cb35d2d626", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "from genQC.imports import *\n", + "from genQC.utils.async_fn import run_parallel_jobs\n", + "from genQC.platform.simulation import Simulator \n", + "from genQC.platform.tokenizer.base_tokenizer import BaseTokenizer\n", + "from genQC.pipeline.pipeline import Pipeline" + ] + }, + { + "cell_type": "markdown", + "id": "529e8286-ea0d-4de5-90e7-6ea1c1f1700c", + "metadata": {}, + "source": [ + "## Generation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff3a4d77-0335-4ffd-9190-900b0efe24dd", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def get_batch_samples(samples: int, auto_batch_size: int = 512) -> list[int]:\n", + " batch_samples = [auto_batch_size] * int(np.floor(samples/auto_batch_size))\n", + " \n", + " if samples % auto_batch_size > 0: \n", + " batch_samples.append(samples % auto_batch_size)\n", + " \n", + " if len(batch_samples) == 0: \n", + " batch_samples.append(samples)\n", + " \n", + " assert sum(batch_samples) == samples\n", + " return batch_samples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a47a3b2-84a4-44b0-846b-bba6f9bd878b", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def batched_sampling(pipeline: Pipeline,\n", + " cond_kwargs: dict[str, torch.Tensor], \n", + " samples: int, \n", + " system_size: int, \n", + " num_of_qubits: int, \n", + " max_gates: int, \n", + " g: float = 1.0, \n", + " init_latents: Optional[torch.Tensor] = None,\n", + " no_bar: bool = True, \n", + " unique: bool = False, \n", + " auto_batch_size: int = 512, \n", + " enable_params: bool = True, \n", + " reduce_spatial: bool = True,\n", + " return_predicted_x0: bool = False):\n", + " \n", + " \"\"\" e.g. cond_kwargs.keys = {\"c\", \"micro_cond\", \"negative_c\", \"U\"} \"\"\"\n", + "\n", + " assert \"c\" in cond_kwargs\n", + " \n", + " c_in = cond_kwargs[\"c\"].shape[0]\n", + " if c_in == 1:\n", + " # Same conditions for all samples\n", + " for cond in cond_kwargs.values():\n", + " assert cond.shape[0] == 1\n", + "\n", + " cond_kwargs = {kw : val.repeat(auto_batch_size, *[1]*(val.dim()-1)) \n", + " for kw, val in cond_kwargs.items()}\n", + " \n", + " else:\n", + " # Different conditions for all samples\n", + " for cond in cond_kwargs.values():\n", + " assert cond.shape[0] == samples\n", + " \n", + " cond_kwargs = {kw:val.to(pipeline.device) \n", + " for kw, val in cond_kwargs.items()} \n", + "\n", + " #----------------------------------------\n", + " if exists(init_latents):\n", + " assert init_latents.shape[0] == samples\n", + " init_latents = init_latents.to(pipeline.device)\n", + " \n", + " #----------------------------------------\n", + " \n", + " # Sample and post process to tensor encodings \n", + " batch_samples = get_batch_samples(samples=samples, auto_batch_size=auto_batch_size)\n", + "\n", + " #----------------------------------------\n", + " \n", + " off = 0\n", + " out_tensor_list = []\n", + " predicted_x0_list = []\n", + " \n", + " for batch_sample in batch_samples: \n", + " #------------\n", + " if c_in == 1:\n", + " # Same conditions for all samples\n", + " _cond_kwargs = {kw:val[:batch_sample] \n", + " for kw, val in cond_kwargs.items()} \n", + " else:\n", + " # Different conditions for all samples\n", + " _cond_kwargs = {kw:val[off:off+batch_sample] \n", + " for kw, val in cond_kwargs.items()}\n", + " \n", + " #------------\n", + " if exists(init_latents):\n", + " latents = init_latents[off:off+batch_sample] \n", + " \n", + " else:\n", + " if pipeline.embedder.channel_last:\n", + " latents = torch.randn((batch_sample, system_size, max_gates, pipeline.model.params_config.clr_dim)) \n", + " else:\n", + " latents = torch.randn((batch_sample, pipeline.model.params_config.clr_dim, system_size, max_gates)) \n", + "\n", + " off += batch_sample\n", + "\n", + " #------------\n", + " out_tensor = pipeline.denoising(latents=latents, \n", + " g=g, \n", + " no_bar=no_bar, \n", + " # enable_guidance=True, \n", + " return_predicted_x0=return_predicted_x0,\n", + " **_cond_kwargs) \n", + "\n", + " if return_predicted_x0:\n", + " out_tensor, predicted_x0 = out_tensor\n", + "\n", + " out_tensor_list.append(out_tensor)\n", + "\n", + " if return_predicted_x0:\n", + " # predicted_x0 ... [timesteps, *out_tensor.shape]\n", + " predicted_x0_list.append(predicted_x0)\n", + "\n", + " #----------------------------------------\n", + "\n", + " out_tensor_raw = torch.cat(out_tensor_list).to(pipeline.device)\n", + "\n", + " if return_predicted_x0:\n", + " predicted_x0_raw = torch.cat(predicted_x0_list, dim=1).to(pipeline.device)\n", + "\n", + " if enable_params: out_tensor, params = pipeline.embedder.invert(out_tensor_raw, reduce_spatial=reduce_spatial)\n", + " else: out_tensor = pipeline.embedder.invert(out_tensor_raw)\n", + " \n", + " #----------------------------------------\n", + " \n", + " out_tensor = out_tensor[:, :num_of_qubits] \n", + " \n", + " if unique: \n", + " if enable_params: \n", + " raise NotImplementedError(\"We have unique and enable_params enabled, how should we handle that?\")\n", + " out_tensor = torch.unique(out_tensor, dim=0)\n", + " \n", + " if not no_bar: print(f\"[INFO]: (generate_comp_tensors) Generated {'unique_cnt ' if unique else ''}{out_tensor.shape[0]} tensors\")\n", + "\n", + " if enable_params: \n", + " if return_predicted_x0:\n", + " return out_tensor, params, predicted_x0_raw\n", + " return out_tensor, params\n", + " \n", + " elif return_predicted_x0:\n", + " return out_tensor, predicted_x0_raw\n", + " \n", + " return out_tensor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe9a3240-a3e6-4901-870d-677a3ea27376", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def prepare_prompts(pipeline: Pipeline, \n", + " prompt: str | Sequence[str], \n", + " negative_prompt: Optional[str | Sequence[str]] = None):\n", + " \n", + " # Prepare conditions\n", + " c = pipeline.text_encoder.tokenize_and_push_to_device(prompt)\n", + "\n", + " if exists(negative_prompt):\n", + " negative_c = pipeline.text_encoder.tokenize_and_push_to_device(negative_prompt)\n", + " assert negative_c.shape[0] == 1\n", + " else:\n", + " negative_c = None\n", + "\n", + " return c, negative_c" + ] + }, + { + "cell_type": "markdown", + "id": "aec071d2-8130-4ea8-832c-4555b15da115", + "metadata": {}, + "source": [ + "### Task specific sampling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ece2684d-7a76-47f4-8791-73d71867863a", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def generate_tensors(pipeline: Pipeline, \n", + " prompt: str | Sequence[str], \n", + " samples: int,\n", + " system_size: int, \n", + " num_of_qubits: int, \n", + " max_gates: int, \n", + " g: float = 1.0, \n", + " init_latents: Optional[torch.Tensor] = None,\n", + " no_bar: bool = True, \n", + " unique: bool = False, \n", + " auto_batch_size: int = 512, \n", + " enable_params: bool = False,\n", + " reduce_spatial: bool = True,\n", + " return_predicted_x0: bool = False,\n", + " negative_prompt: Optional[str | Sequence[str]] = None,\n", + " micro_cond: Optional[torch.Tensor] = None) -> torch.Tensor:\n", + "\n", + " if exists(micro_cond):\n", + " raise NotImplementedError()\n", + "\n", + " # Prepare conditions\n", + " c, negative_c = prepare_prompts(pipeline, prompt, negative_prompt)\n", + " \n", + " cond_kwargs = {\"c\":c}\n", + " if exists(negative_c): cond_kwargs[\"negative_c\"] = negative_c\n", + " if exists(micro_cond): cond_kwargs[\"micro_cond\"] = micro_cond\n", + "\n", + " # Perform sampling\n", + " out = batched_sampling(pipeline=pipeline, \n", + " cond_kwargs=cond_kwargs, \n", + " samples=samples, \n", + " system_size=system_size,\n", + " num_of_qubits=num_of_qubits,\n", + " max_gates=max_gates,\n", + " g=g, \n", + " init_latents=init_latents,\n", + " no_bar=no_bar,\n", + " unique=unique,\n", + " auto_batch_size=auto_batch_size,\n", + " enable_params=enable_params,\n", + " reduce_spatial=reduce_spatial,\n", + " return_predicted_x0=return_predicted_x0)\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e25a4f6-c9fc-404c-b415-b7b68be998bd", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def generate_compilation_tensors(pipeline: Pipeline, \n", + " prompt: str | Sequence[str], \n", + " U: torch.Tensor, \n", + " samples: int, \n", + " system_size: int, \n", + " num_of_qubits: int, \n", + " max_gates: int, \n", + " g: float = 1.0, \n", + " tensor_prod_pad: bool = True,\n", + " init_latents: Optional[torch.Tensor] = None,\n", + " no_bar: bool = True, \n", + " unique: bool = False, \n", + " auto_batch_size: int = 512, \n", + " enable_params: bool = True, \n", + " reduce_spatial: bool = True,\n", + " return_predicted_x0: bool = False,\n", + " negative_prompt: Optional[str | Sequence[str]] = None,\n", + " negative_u: Optional[torch.Tensor] = None,\n", + " micro_cond: Optional[torch.Tensor] = None) -> torch.Tensor:\n", + " \"\"\"\n", + " Samples tensor encodings from the DM for the given sample parameters.\n", + "\n", + " What kind of unitary padding we have depends on what we used for model training, so it depends on the concrete model weights.\n", + " \"\"\"\n", + "\n", + " if torch.is_complex(U):\n", + " U = torch.stack([U.real, U.imag], dim=-3)\n", + " \n", + " if exists(micro_cond):\n", + " raise NotImplementedError()\n", + "\n", + " # Prepare conditions\n", + " c, negative_c = prepare_prompts(pipeline, prompt, negative_prompt)\n", + "\n", + " cond_kwargs = {\"c\":c}\n", + " if exists(negative_c): cond_kwargs[\"negative_c\"] = negative_c\n", + " if exists(micro_cond): cond_kwargs[\"micro_cond\"] = micro_cond\n", + "\n", + " def tensor_pad(U):\n", + " # Prepare unitary condition\n", + " assert U.dim() in [3, 4]\n", + " if U.dim() == 3: \n", + " # [2, N, N] to [1, 2, N, N]\n", + " U = U.unsqueeze(0)\n", + " \n", + " if system_size > num_of_qubits:\n", + " N = 2**system_size\n", + " \n", + " if tensor_prod_pad:\n", + " # Pad with identity tensor product, assume Big Endian \n", + " \n", + " U_pad = torch.zeros((U.shape[0], 2, N, N), device=U.device, dtype=U.dtype)\n", + " \n", + " U_side = U.shape[-1]\n", + " for jj in range(N//U_side): \n", + " _slice = slice(U_side * jj, U_side * (jj+1))\n", + " U_pad[..., _slice, _slice] = U \n", + " \n", + " U = U_pad\n", + " \n", + " else:\n", + " # zero pad\n", + " pad = (0, N-U.shape[-1], 0, N-U.shape[-2]) \n", + " U = F.pad(U, pad, \"constant\", 0)\n", + " return U\n", + " \n", + " cond_kwargs[\"U\"] = tensor_pad(U)\n", + " if exists(negative_u): \n", + " cond_kwargs[\"negative_u\"] = tensor_pad(negative_u)\n", + " \n", + " # Perform sampling\n", + " out = batched_sampling(pipeline=pipeline, \n", + " cond_kwargs=cond_kwargs, \n", + " samples=samples, \n", + " system_size=system_size,\n", + " num_of_qubits=num_of_qubits,\n", + " max_gates=max_gates,\n", + " g=g, \n", + " init_latents=init_latents,\n", + " no_bar=no_bar,\n", + " unique=unique,\n", + " auto_batch_size=auto_batch_size,\n", + " enable_params=enable_params,\n", + " reduce_spatial=reduce_spatial,\n", + " return_predicted_x0=return_predicted_x0)\n", + " return out" + ] + }, + { + "cell_type": "markdown", + "id": "368ff9cc-2515-4056-9dfe-2538380884c3", + "metadata": {}, + "source": [ + "## Convertion" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc14c810-6793-4f64-a421-7cc902ec38b8", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def decode_tensors_to_backend(simulator: Simulator, \n", + " tokenizer: BaseTokenizer, \n", + " tensors: torch.Tensor, \n", + " params: Optional[torch.Tensor] = None, \n", + " silent: bool = True,\n", + " n_jobs: int = 1,\n", + " filter_errs: bool = True) -> tuple[Sequence[any], int]:\n", + " tensors = tensors.cpu()\n", + "\n", + " if exists(params):\n", + " params = params.cpu()\n", + " iter_pack = zip(tensors, params)\n", + " _decode = lambda x, p: tokenizer.decode(x, p)\n", + " \n", + " else:\n", + " iter_pack = zip(tensors, )\n", + " _decode = lambda x: tokenizer.decode(x)\n", + " \n", + " def _f(iter_vars):\n", + " try:\n", + " instructions = _decode(*iter_vars)\n", + " backend_obj = simulator.backend.genqc_to_backend(instructions, place_barriers=False)\n", + " return backend_obj\n", + " except Exception as err:\n", + " if silent: return None\n", + " raise err\n", + " \n", + " pot_qcs = run_parallel_jobs(_f, iter_pack, n_jobs)\n", + "\n", + " if filter_errs:\n", + " backend_obj_list = [pot_qc for pot_qc in pot_qcs if exists(pot_qc)]\n", + " err_cnt = sum(1 for pot_qc in pot_qcs if not_exists(pot_qc))\n", + " assert len(backend_obj_list) + err_cnt == len(pot_qcs)\n", + " else:\n", + " backend_obj_list = pot_qcs\n", + " err_cnt = None\n", + " \n", + " return backend_obj_list, err_cnt" + ] + }, + { + "cell_type": "markdown", + "id": "f7ed6e9d-329c-43f1-b3c6-2fa96ceab9e2", + "metadata": {}, + "source": [ + "# Export -" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48ea3c5a-896d-478f-9c5d-5ecfa408eae0", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "import nbdev; nbdev.nbdev_export()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/models/clip/frozen_open_clip.ipynb b/src/models/clip/frozen_open_clip.ipynb new file mode 100644 index 0000000..82e6eb9 --- /dev/null +++ b/src/models/clip/frozen_open_clip.ipynb @@ -0,0 +1,715 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", + "metadata": {}, + "source": [ + "# Frozen OpenCLIP\n", + "\n", + "> Interface to the [OpenCLIP](https://github.com/mlfoundations/open_clip) library." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp models.clip.frozen_open_clip" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "from genQC.imports import *\n", + "from genQC.models.config_model import ConfigModel\n", + "from genQC.utils.async_fn import run_parallel_jobs\n", + "from genQC.utils.misc_utils import infer_torch_device\n", + "import open_clip" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed668754-6e3d-480a-8bce-c12eed6d939e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OpenCLIP version: 2.30.0\n" + ] + } + ], + "source": [ + "print(\"OpenCLIP version:\", open_clip.__version__)" + ] + }, + { + "cell_type": "markdown", + "id": "3bca1a5d-2c82-4e97-8181-425a38cfe5ee", + "metadata": {}, + "source": [ + "## CLIP model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bd5df0-fbf5-4f5e-bb82-6cab672c3542", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "@dataclass\n", + "class FrozenOpenCLIPEmbedderConfig:\n", + " arch: str\n", + " version: str\n", + " #device: str\n", + " max_length: int\n", + " freeze: bool\n", + " layer: str" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dffe5b29-8362-46fe-9cdc-e83c996ca8b0", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class FrozenOpenCLIPEmbedder(ConfigModel):\n", + " \"\"\"Loads and freezes the [OpenCLIP](https://github.com/mlfoundations/open_clip) transformer encoder for text prompts.\"\"\"\n", + " \n", + " LAYERS = [\n", + " # \"pooled\",\n", + " \"last\",\n", + " \"penultimate\"\n", + " ]\n", + "\n", + " njobs = 1\n", + "\n", + " def __init__(self, arch=\"ViT-B-32\", version=\"datacomp_xl_s13b_b90k\", max_length=77, freeze=True, layer=\"penultimate\", **kwargs):\n", + " super().__init__(**kwargs) \n", + " \n", + " assert layer in self.LAYERS \n", + " self.params_config = FrozenOpenCLIPEmbedderConfig(arch, version, max_length, freeze, layer)\n", + " \n", + " model, _, _ = open_clip.create_model_and_transforms(arch, device=\"cpu\", pretrained=version)\n", + " self.device = \"cpu\"\n", + " \n", + " del model.visual \n", + " self.model = model\n", + " # self.to(device)\n", + " \n", + " self.tokenizer = open_clip.get_tokenizer(arch)\n", + " assert torch.numel(self.tokenizer(\"test\"))\n", + " \n", + " assert max_length <= 77 # max set by the clip \n", + " self.max_length = max_length\n", + " \n", + " if freeze: self.freeze()\n", + " \n", + " self.layer = layer\n", + " if self.layer == \"last\": self.layer_idx = 0\n", + " elif self.layer == \"penultimate\": self.layer_idx = 1\n", + " else: raise NotImplementedError()\n", + "\n", + " #create empty token, can also be, e.g., A nice picture\n", + " self.empty_token = self.tokenize_and_push_to_device(\"\")\n", + " \n", + " def freeze(self, freeze: bool = True):\n", + " super().freeze(freeze=freeze)\n", + " \n", + " for param in self.model.parameters(): \n", + " param.requires_grad = not freeze\n", + " \n", + " def to(self, device):\n", + " self.model = self.model.to(device) \n", + " self.device = device\n", + " return self\n", + " \n", + " @torch.inference_mode()\n", + " def tokenize_and_push_to_device(self, text, to_device=True):\n", + " if self.njobs > 1:\n", + "\n", + " tokens_list = run_parallel_jobs(self.tokenizer, np.array_split(text, self.njobs), self.njobs)\n", + " tokens = torch.cat(tokens_list, dim=0)\n", + " \n", + " else:\n", + " # tokens = open_clip.tokenize(text)\n", + " tokens = self.tokenizer(text)\n", + " \n", + " if to_device:\n", + " tokens = tokens.to(self.device)\n", + " return tokens\n", + " \n", + " @torch.inference_mode()\n", + " def forward(self, c, **kwargs):\n", + " return self.encode_with_transformer(c)\n", + "\n", + " @torch.inference_mode()\n", + " def encode_with_transformer(self, text):\n", + " cast_dtype = self.model.transformer.get_cast_dtype()\n", + " \n", + " x = self.model.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model] \n", + " x = x + self.model.positional_embedding[None, :x.shape[1]].to(cast_dtype)\n", + "\n", + " if not self.model.transformer.batch_first:\n", + " x = x.permute(1, 0, 2) # NLD -> LND\n", + " \n", + " x = self.text_transformer_forward(x, attn_mask=self.model.attn_mask)\n", + "\n", + " if not self.model.transformer.batch_first:\n", + " x = x.permute(1, 0, 2) # LND -> NLD\n", + " \n", + " x = self.model.ln_final(x) # [batch_size, n_ctx, transformer.width]\n", + " \n", + " return x\n", + "\n", + " @torch.inference_mode()\n", + " def text_transformer_forward(self, x: torch.Tensor, attn_mask=None):\n", + " for i, r in enumerate(self.model.transformer.resblocks):\n", + " if i == len(self.model.transformer.resblocks) - self.layer_idx:\n", + " break\n", + " #if self.model.transformer.grad_checkpointing and not torch.jit.is_scripting():\n", + " #x = checkpoint(r, x, attn_mask)\n", + " #else:\n", + " \n", + " x = r(x, attn_mask=attn_mask)\n", + " \n", + " return x\n", + "\n", + " #--------------------------------------------------------------\n", + " \n", + " def get_config(self, save_path=None, without_metadata=False):\n", + " return super().get_config(save_path=None, without_metadata=without_metadata)\n", + " \n", + " def store_model(self, config_path: str, save_path: str=None, without_metadata=False): \n", + " super().store_model(config_path, save_path=None, without_metadata=without_metadata)\n", + "\n", + " @staticmethod\n", + " def from_config(config, device: torch.device, save_path: str=None): \n", + " config[\"save_path\"] = None\n", + " return ConfigModel.from_config(config, device, save_path=None) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c351de75-c3ac-4434-9e74-0472ad849d44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO]: Cuda device has a capability of 8.9 (>= 8), allowing tf32 matmul.\n" + ] + } + ], + "source": [ + "device = infer_torch_device()\n", + "a = FrozenOpenCLIPEmbedder().to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55d98fe4-f697-445d-93e7-39516f2c9f6c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[49406, 314, 272, 267, 273, 267, 273, 316, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [49406, 314, 272, 267, 273, 267, 320, 273, 316, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], device='cuda:0')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p=\"[1, 2, 2]\", \"[1, 2, a 2]\"\n", + "a.tokenize_and_push_to_device(p)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f8639dcf-bba2-4778-b57c-1bb3e6e7bda9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 77])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.tokenize_and_push_to_device(\"\").shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad8a36a9-f409-49b4-aebe-9e0e3be4a7b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([2, 77])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.tokenize_and_push_to_device([\"1,1,2\", \"2,2,2\"]).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9bed0226-be41-462d-b4ce-7afa9001a13e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([77, 77])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.model.attn_mask.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa4393a9-1c98-4ae0-8cad-a096a6b24f73", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([2, 77, 512]),\n", + " tensor([[[-0.3819, -0.3694, -0.0712, ..., 0.0959, -0.0834, -0.0929],\n", + " [-0.2669, 0.1847, -0.5890, ..., 0.7211, -1.7483, 1.2858],\n", + " [-0.9821, -0.6650, 0.2107, ..., -0.4223, 0.5351, 0.8494],\n", + " ...,\n", + " [-0.0300, 1.3871, 0.3989, ..., 0.2657, -0.1257, -1.3758],\n", + " [-0.0797, 1.4044, 0.3595, ..., 0.2328, -0.0766, -1.3314],\n", + " [ 0.1599, 1.5989, 0.2775, ..., 0.1202, -0.1294, -1.5480]],\n", + " \n", + " [[-0.3819, -0.3694, -0.0712, ..., 0.0959, -0.0834, -0.0929],\n", + " [-1.2507, 1.4711, 0.7264, ..., 1.1489, -0.4983, 0.4494],\n", + " [-1.2645, -0.3412, 0.9422, ..., 0.1529, 0.0271, 0.4574],\n", + " ...,\n", + " [-0.0694, 1.4021, 0.4687, ..., 0.2277, -0.0694, -1.3635],\n", + " [-0.1196, 1.4167, 0.4262, ..., 0.1955, -0.0225, -1.3245],\n", + " [ 0.1381, 1.6182, 0.3528, ..., 0.0775, -0.0853, -1.5246]]], device='cuda:0'))" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = a.tokenize_and_push_to_device([\"1,1,2\", \"2,2,2\"])\n", + "enc = a(c)\n", + "enc.shape, enc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56415466-0a23-405d-a554-8b8be57f7df5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'We develop a multi-modal generative diffusion model to compile quantum operations in parameterized quantum circuits.
+::: +::: {.abstract} +Efficiently compiling quantum operations remains a major bottleneck in scaling quantum computing. Today’s state-of-the-art methods achieve low compilation error by combining search algorithms with gradient-based parameter optimization, but they incur long runtimes and require multiple calls to quantum hardware or expensive classical simulations, making their scaling prohibitive. Recently, machine-learning models have emerged as an alternative, though they are currently restricted to discrete gate sets. Here, we introduce a multimodal denoising diffusion model that simultaneously generates a circuit’s structure and its continuous parameters for compiling a target unitary. It leverages two independent diffusion processes, one for discrete gate selection and one for parameter prediction. We benchmark the model over different experiments, analyzing the method’s accuracy across varying qubit counts, circuit depths, and proportions of parameterized gates. Finally, by exploiting its rapid circuit generation, we create large datasets of circuits for particular operations and use these to extract valuable heuristics that can help us discover new insights into quantum circuit synthesis.
+::: +::: + + +# Quantum circuit synthesis with diffusion models +::: {.authors} +We use a generative diffusion model to synthesize quantum circuits for entanglement generation and unitary compilation.
+::: +::: {.abstract} +Quantum computing has recently emerged as a transformative technology. Yet, its promised advantages rely on efficiently translating quantum operations into viable physical realizations. In this work, we use generative machine learning models, specifically denoising diffusion models (DMs), to facilitate this transformation. Leveraging text-conditioning, we steer the model to produce desired quantum operations within gate-based quantum circuits. Notably, DMs allow to sidestep during training the exponential overhead inherent in the classical simulation of quantum dynamics — a consistent bottleneck in preceding ML techniques. We demonstrate the model’s capabilities across two tasks: entanglement generation and unitary compilation. The model excels at generating new circuits and supports typical DM extensions such as masking and editing to, for instance, align the circuit generation to the constraints of the targeted quantum device. Given their flexibility and generalization abilities, we envision DMs as pivotal in quantum circuit synthesis, enhancing both practical applications but also insights into theoretical quantum computation.
+::: +::: {.cite} +