In this notebook we show editing and masking of circuits.
+from genQC.imports import *
+from genQC.pipeline.diffusion_pipeline import DiffusionPipeline
+from genQC.inference.infer_srv import convert_tensors_to_srvs, schmidt_rank_vector
+import genQC.platform.qcircuit_dataset_construction as data_const
+import genQC.util as util
+from qiskit.quantum_info import DensityMatrixdevice = util.infer_torch_device() # use cuda if we can
+util.MemoryCleaner.purge_mem() # clean existing memory alloc[INFO]: Cuda device has a capability of 8.6 (>= 8), allowing tf32 matmul.Load the pre-trained model
+model_path = "../../saves/qc_unet_config_SRV_3to8_qubit/"
+pipeline = DiffusionPipeline.from_config_file(model_path, device)[INFO]: `genQC.models.unet_qc.QC_Cond_UNet` instantiated from given config on cuda.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder` instantiated from given config on cuda.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder`. No save_path` provided. No state dict loaded.Set 20 sample steps and use rescaled guidance-formula.
+pipeline.guidance_sample_mode = "rescaled"
+pipeline.scheduler.set_timesteps(40)
+g = 7.5Sample a random circuit with desired parameters as the circuit we want to edit:
+srv_init = [1, 1, 1, 2, 2] # psi_0 state
+desired_length = 5 # 5 gates initially placedinit_qc = data_const.get_specific_rnd_srv_circuit(srv_init, desired_length, pipeline.gate_pool)
+print("SRV is", schmidt_rank_vector(DensityMatrix(init_qc)))
+init_qc.draw("mpl")SRV is [1, 1, 1, 2, 2]
The editing taks is analogous to image editing, we do img2img with conditioning and copy non-edit areas at every time step. Also called latent_filling.
def create_edited_circuits(pipeline, samples, qc, prompt, new_length, num_of_qubits, system_size, t_start_index):
+ #-------------------------------------------
+ # set mask - appending mask!
+ old_length = len(qc.data)
+
+ qubit_mask = torch.ones((system_size, new_length), device=device)
+ qubit_mask[:, :old_length] = 0
+
+ #-------------------------------------------
+ # prepare and encode
+
+ gate_classes = data_const.gate_pool_to_gate_classes(pipeline.gate_pool)
+
+ emb_org_image = data_const.encode_circuit(qc, system_size, gate_classes, new_length).unsqueeze(0).to(device)
+ emb_org_image = pipeline.model.embedd_clrs(emb_org_image)
+
+ emb_org_images = emb_org_image.repeat(samples, *[1]*(emb_org_image.dim()-1))
+
+ #-------------------------------------------
+ # prep condition
+
+ c = pipeline.text_encoder.tokenize_and_push_to_device(str(prompt))
+ c = c.repeat(samples, *[1]*(c.dim()-1))
+
+ #-------------------------------------------
+ # latent fill
+ out_tensor = pipeline.latent_filling(emb_org_images, qubit_mask, c=c, g=g, no_bar=False, t_start_index=t_start_index)
+ out_tensor = pipeline.model.invert_clr(out_tensor)
+ out_tensor = out_tensor[:, :num_of_qubits]
+ out_tensor = torch.unique(out_tensor, dim=0) # we only are interested in unique circuits
+
+ qc_list, error_cnt, srv_list = convert_tensors_to_srvs(out_tensor, pipeline.gate_pool, place_barrier=True)
+
+ return qc_list, srv_listsamples = 16 # how many circuits we sample
+new_length = 16 # how many gates the model can place
+
+srv_target = [2, 2, 2, 2, 2] # desired target SRV
+
+num_of_qubits = len(srv_target)
+t_start_index = t_start_index = int(0.05 * pipeline.scheduler.timesteps.shape[0]) # time step index at which we start denoising
+
+prompt = f"Generate SRV: {srv_target}" # model was trained with this phrase
+prompt'Generate SRV: [2, 2, 2, 2, 2]'# returns only distinct circuits
+edited_qc, srv_list = create_edited_circuits(pipeline, samples, init_qc, prompt, new_length, num_of_qubits, num_of_qubits, t_start_index)Pick only correct ones:
+correct_edited_qc = []
+for qc,srv in zip(edited_qc, srv_list):
+ if srv==srv_target: correct_edited_qc.append(qc)
+print(f"We found {len(correct_edited_qc)} correct distinct solutions.")We found 12 correct distinct solutions.Compare: initial circuit
+init_qc.draw("mpl")
v.s. edited:
+print("SRV is", schmidt_rank_vector(DensityMatrix(correct_edited_qc[0])))
+correct_edited_qc[0].draw("mpl", plot_barriers=False)SRV is [2, 2, 2, 2, 2]
fig, axs = plt.subplots(2,4, figsize=(18,5), constrained_layout=True)
+for qc,ax in zip(correct_edited_qc, axs.flatten()):
+ qc.draw("mpl", plot_barriers=False, ax=ax)
+plt.show()
First we set a desired mask, i.e. a specific layout of a quantum processor.
+max_gates = 16
+num_of_qubits = 5
+
+d = 3
+#------
+def con_set(q1, q2, x, d):
+ qubit_mask[q1, x:x+d] = 1
+ qubit_mask[q2, x:x+d] = 1
+ return x+d
+
+#------
+x = 0
+
+qubit_mask = torch.zeros((num_of_qubits, max_gates), device=device) # mask: ones are getting filled, zeros are fixed !
+x = con_set(0, 1, x, d)
+x = con_set(1, 2, x, d)
+x = con_set(1, 3, x, d)
+x = con_set(3, 4, x, d)def plot_mask():
+ fig = plt.figure(figsize=(3.7,2), constrained_layout=True)
+ plt.imshow(qubit_mask.cpu(), cmap="Greens")
+ plt.xticks(range(0, qubit_mask.shape[1], 2),fontsize=9)
+ plt.yticks(range(num_of_qubits), fontsize=9)
+ plt.xlabel("Gate sequence / time", fontsize=12)
+ plt.ylabel("Qubits", fontsize=12)
+ plt.show()
+plot_mask()
def get_emb_org_images(pipeline, samples, system_size, max_gates, target_num_gates, target_num_bits, qubit_mask):
+ org_image = torch.zeros((1, system_size, max_gates), device=device, dtype=torch.int32)
+
+ padd_tok = len(pipeline.gate_pool) + 1
+ padd_pos = (torch.ceil(torch.tensor(target_num_gates) / 4) * 4).to(torch.int32)
+ org_image[:, :, padd_pos:] = padd_tok
+ org_image[:, target_num_bits:, ] = padd_tok
+
+ emb_org_image = pipeline.model.embedd_clrs(org_image)
+ emb_org_images = emb_org_image.repeat(samples, *[1]*(emb_org_image.dim()-1))
+
+ return emb_org_imagesdef generate_pattern_SRV(pipeline, prompt, samples, system_size, num_of_qubits, max_gates, qubit_mask, t_start_index=0, target_num_gates=None, target_num_bits=None):
+
+ if not exists(target_num_gates):
+ target_num_gates = max_gates
+
+ if not exists(target_num_bits):
+ target_num_bits = num_of_qubits
+
+ emb_org_images = get_emb_org_images(pipeline, samples, system_size, max_gates, target_num_gates, target_num_bits, qubit_mask)
+
+ #----------------
+ # prep condition
+
+ c = pipeline.text_encoder.tokenize_and_push_to_device(str(prompt))
+ c = c.repeat(samples, *[1]*(c.dim()-1))
+
+ #----------------
+ # latent fill
+
+ out_tensor = pipeline.latent_filling(emb_org_images, qubit_mask, c=c, g=g, no_bar=False, t_start_index=t_start_index)
+ out_tensor = pipeline.model.invert_clr(out_tensor)
+ out_tensor = out_tensor[:, :num_of_qubits]
+ out_tensor = torch.unique(out_tensor, dim=0)
+
+ qc_list, error_cnt, srv_list = convert_tensors_to_srvs(out_tensor, pipeline.gate_pool, place_barrier=True)
+
+ return qc_list, srv_listNow generate circuits corresponding to the mask.
+samples = 512 # how many circuits we sample
+srv_target = [2, 1, 2, 2, 2] # desired target SRV
+
+assert len(srv_target)==qubit_mask.shape[0]
+
+prompt = f"Generate SRV: {srv_target}" # model was trained with this phrase
+prompt'Generate SRV: [2, 1, 2, 2, 2]'qc_list, srv_list = generate_pattern_SRV(pipeline, prompt, samples, num_of_qubits, num_of_qubits, max_gates, qubit_mask, t_start_index=1)Pick only correct ones:
+correct_qc = []
+for qc,srv in zip(qc_list, srv_list):
+ if srv==srv_target: correct_qc.append(qc)
+print(f"We found {len(correct_qc)} correct distinct solutions.")We found 9 correct distinct solutions.Let’s plot them. Mask:
+plot_mask()
v.s. solution:
+print("SRV is", schmidt_rank_vector(DensityMatrix(correct_qc[0])))
+correct_qc[0].draw("mpl", plot_barriers=False)SRV is [2, 1, 2, 2, 2]
fig, axs = plt.subplots(1, min(len(correct_qc), 4), figsize=(18,5), constrained_layout=True)
+for qc,ax in zip(correct_qc, axs.flatten()):
+ qc.draw("mpl", plot_barriers=False, ax=ax)
+plt.show()
A minimal example to generate a circuit. We load a pre-trained (SRV, 3 to 8 qubit) model and condition on a given Schmidt-Rank-Vector (SRV).
+from genQC.imports import *
+from genQC.pipeline.diffusion_pipeline import DiffusionPipeline
+import genQC.inference.infer_srv as infer_srv
+import genQC.util as utildevice = util.infer_torch_device() # use cuda if we can
+util.MemoryCleaner.purge_mem() # clean existing memory alloc[INFO]: Cuda device has a capability of 8.6 (>= 8), allowing tf32 matmul.devicedevice(type='cuda')Load the pre-trained model
+model_path = "../../saves/qc_unet_config_SRV_3to8_qubit/"
+pipeline = DiffusionPipeline.from_config_file(model_path, device)[INFO]: `genQC.models.unet_qc.QC_Cond_UNet` instantiated from given config on cuda.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder` instantiated from given config on cuda.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder`. No save_path` provided. No state dict loaded.Check on what gates the model was trained
+pipeline.gate_pool[qiskit.circuit.library.standard_gates.h.HGate,
+ qiskit.circuit.library.standard_gates.x.CXGate]Set 20 sample steps and use rescaled guidance-formula.
+pipeline.guidance_sample_mode = "rescaled"
+pipeline.scheduler.set_timesteps(20)Set our desired condition SRV
+srv = [2, 1, 2, 1, 2] # set your target SRV; can be 3 to 8 qubit
+num_of_qubits = len(srv)
+
+prompt = f"Generate SRV: {srv}" # model was trained with this phrase
+prompt'Generate SRV: [2, 1, 2, 1, 2]'Define sample parameters
+g = 7.5 # guidance scale
+max_gates = 16 # how many time steps the tensor encoding has
+samples = 32 # how many circuits to generateSample tokenized circuits
+out_tensor = infer_srv.generate_srv_tensors(pipeline, prompt, samples, num_of_qubits, num_of_qubits, max_gates, g, no_bar=False)[INFO]: (generate_srv_tensors) Generated 32 tensorsCheck how many distinct tensors we got:
+out_tensor.unique(dim=0).shape[0]32Let’s look what is generated. Note, 3 is the padding token (or empty action).
+out_tensor[:2]tensor([[[ 0, 2, 1, 2, -2, 0, 2, 0, 0, 2, 3, 3, 3, 3, 3, 3],
+ [-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3],
+ [ 2, -2, 0, -2, 2, 1, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, 0, 0, 0, 0, -2, 1, 0, 0, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 1, -2, 3, 3, 3, 3, 3, 3]],
+
+ [[ 1, -2, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 2, 0, -2, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, -2, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, 2, 2, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]]])To get a quiskit circuit we need to do:
+infer_srv.generate_srv_tensors did this already)qc_list, error_cnt, svr_list = infer_srv.convert_tensors_to_srvs(out_tensor, pipeline.gate_pool)Generated error circuits:
+error_cnt0What SRVs did we get:
+svr_list[:4][[2, 1, 2, 1, 2], [2, 1, 2, 1, 2], [2, 1, 2, 1, 2], [2, 1, 2, 1, 2]]That is an accuracy of:
+sum(srv==x for x in svr_list)/len(svr_list)0.9375Finally plot some of the circuits:
+fig, axs = plt.subplots(2, 4, figsize=(18,5), constrained_layout=True)
+for qc,is_svr,ax in zip(qc_list, svr_list, axs.flatten()):
+ qc.draw("mpl", plot_barriers=False, ax=ax)
+ ax.set_title(f"{'Correct' if is_svr==srv else 'NOT correct'}, is SRV = {is_svr}")
+plt.show()
In this notebook we want use the unitary compilation model.
+from genQC.imports import *
+from genQC.pipeline.diffusion_pipeline import DiffusionPipeline
+from qiskit import QuantumCircuit
+from genQC.inference.infer_compilation import generate_comp_tensors, get_gate_and_U_acc
+from genQC.printing import display_colums
+import genQC.platform.qcircuit_dataset_construction as data_const
+import qiskit.quantum_info as qi
+import genQC.util as util
+import astdevice = util.infer_torch_device() # use cuda if we can
+util.MemoryCleaner.purge_mem() # clean existing memory alloc[INFO]: Cuda device has a capability of 8.6 (>= 8), allowing tf32 matmul.def str_cond_to_gate_indices(y): # helper function, used to check if only allowed gates were used by the model!
+ assert y[:15] == "Compile using: "
+ c = ast.literal_eval(y[15:])
+ gate_classes = data_const.gate_pool_to_gate_classes(pipeline.gate_pool)
+ gate_clrs = [0] + [gate_classes[ic] for ic in c] # 0 is empty, always allowed!
+ return gate_clrsLoad the pre-trained model
+model_path = "../../saves/qc_unet_config_Compilation_3_qubit/"
+pipeline = DiffusionPipeline.from_config_file(model_path, device)[INFO]: `genQC.models.unet_qc.QC_Compilation_UNet` instantiated from given config on cuda.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder` instantiated from given config on cuda.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder`. No save_path` provided. No state dict loaded.Set 20 sample steps and use rescaled guidance-formula.
+pipeline.guidance_sample_mode = "rescaled"
+pipeline.scheduler.set_timesteps(20)
+g = 7.5The model was trained with a gate pool of:
+pipeline.gate_pool[qiskit.circuit.library.standard_gates.h.HGate,
+ qiskit.circuit.library.standard_gates.x.CXGate,
+ qiskit.circuit.library.standard_gates.z.ZGate,
+ qiskit.circuit.library.standard_gates.x.XGate,
+ qiskit.circuit.library.standard_gates.x.CCXGate,
+ qiskit.circuit.library.standard_gates.swap.SwapGate]Compile a given unitary \(U\). Note, there has to be a solution with the pipeline.gate_pool in order to find the exact solution.
def compile_and_plot(U, prompt):
+ U_r, U_i = torch.Tensor(np.real(U)), torch.Tensor(np.imag(U))
+ U_tensor = torch.stack([U_r, U_i], dim=0)
+
+ out_tensor = generate_comp_tensors(pipeline, prompt, U_tensor, samples, num_of_qubits, num_of_qubits, max_gates, g, unique=True)
+ _, _, _, _, _, comb_corr_qc, _, _, _ = get_gate_and_U_acc(out_tensor, str_cond_to_gate_indices(prompt), U_tensor, pipeline.gate_pool, num_of_qubits, max_gates)
+ comb_corr_qc = sorted(comb_corr_qc, key=lambda x: len(x.data)) #sort to get the shortest solutions
+
+ fig, axs = plt.subplots(1,4, figsize=(18,5), constrained_layout=True)
+ axs[0].set_title(f"{prompt}")
+ for qc,ax in zip(comb_corr_qc, axs.flatten()):
+ qc.draw("mpl", plot_barriers=False, ax=ax)
+ plt.show()samples = 512
+num_of_qubits = 3
+max_gates = 12prompt = "Compile using: ['h', 'cx', 'z', 'x', 'ccx', 'swap']" # model was trained with phrases like this, allow full gate set
+prompt"Compile using: ['h', 'cx', 'z', 'x', 'ccx', 'swap']"Inspired from (quantumcomputing.stackexchange.com/questions/13821/generate-a-3-qubit-swap-unitary-in-terms-of-elementary-gates/13826). Note, this unitary WAS in the training set.
+U = np.matrix([[1,0,0,0,0,0,0,0],
+ [0,1,0,0,0,0,0,0],
+ [0,0,1,0,0,0,0,0],
+ [0,0,0,0,1,0,0,0],
+ [0,0,0,1,0,0,0,0],
+ [0,0,0,0,0,1,0,0],
+ [0,0,0,0,0,0,1,0],
+ [0,0,0,0,0,0,0,1]], dtype=np.complex128)
+
+assert np.allclose(U.H@U, np.identity(2**num_of_qubits)) and np.allclose(U@U.H, np.identity(2**num_of_qubits)) #check if unitaryPlot correct (exact) compiled circuits:
+compile_and_plot(U, prompt)
Inspired from (quantumcomputing.stackexchange.com/questions/12439/procedures-and-intuition-for-designing-simple-quantum-circuits/12440). Note, this unitary WAS in the training set.
+U = np.matrix([[1,0,0,0,0,0,0,0],
+ [0,0,0,0,0,0,0,1],
+ [0,1,0,0,0,0,0,0],
+ [0,0,1,0,0,0,0,0],
+ [0,0,0,1,0,0,0,0],
+ [0,0,0,0,1,0,0,0],
+ [0,0,0,0,0,1,0,0],
+ [0,0,0,0,0,0,1,0]], dtype=np.complex128)
+
+assert np.allclose(U.H@U, np.identity(2**num_of_qubits)) and np.allclose(U@U.H, np.identity(2**num_of_qubits)) #check if unitaryPlot correct (exact) compiled circuits:
+compile_and_plot(U, prompt)
A randomly generated unitary (from a random circuit). This unitary WAS NOT in the training set, it is new to the model!
+U = np.matrix([[ 0.70710678, 0. , 0. , 0. , 0.70710678, 0. , 0. , 0. ],
+ [ 0. , -0.70710678, 0. , 0. , 0. , -0.70710678, 0. , 0. ],
+ [-0.70710678, 0. , 0. , 0. , 0.70710678, 0. , 0. , 0. ],
+ [ 0. , 0.70710678, 0. , 0. , 0. , -0.70710678, 0. , 0. ],
+ [ 0. , 0. , 0.70710678, 0. , 0. , 0. , 0. , 0.70710678],
+ [ 0. , 0. , 0. , 0.70710678, 0. , 0. , 0.70710678, 0. ],
+ [ 0. , 0. , -0.70710678, 0. , 0. , 0. , 0. , 0.70710678],
+ [ 0. , 0. , 0. ,-0.70710678, 0. , 0. , 0.70710678, 0. ]], dtype=np.complex128)
+
+assert np.allclose(U.H@U, np.identity(2**num_of_qubits)) and np.allclose(U@U.H, np.identity(2**num_of_qubits)) #check if unitaryPlot correct (exact) compiled circuits:
+compile_and_plot(U, prompt)
Set an initial circuit we want to transpile, optimize or use for discovering sub-arrangements:
+qc = QuantumCircuit(3)
+qc.h(2)
+qc.cx(0,1)
+qc.cx(2,1)
+qc.h(1)
+qc.x(1)
+qc.h(1)
+qc.x(2)
+
+U = qi.Operator(qc).to_matrix() # the unitary of the circuit
+
+#-----------------------------------------
+
+fig = qc.draw("mpl")
+fig
We set different gate pool targets to see what the model gives us:
+cs_1 = f"Compile using: {[x().name for x in pipeline.gate_pool]}", "all"
+
+cs_2 = "Compile using: ['h', 'cx', 'z', 'ccx']" , "no x, no swap"
+cs_3 = "Compile using: ['h', 'cx', 'x', 'ccx']" , "no z, no swap"
+cs_4 = "Compile using: ['h', 'x', 'ccx']" , "no cx, no z, no swap"
+cs_5 = "Compile using: ['h', 'z', 'x', 'ccx']" , "no cx, no swap"
+
+cs = [cs_1, cs_2, cs_3, cs_4, cs_5]
+cs[("Compile using: ['h', 'cx', 'z', 'x', 'ccx', 'swap']", 'all'),
+ ("Compile using: ['h', 'cx', 'z', 'ccx']", 'no x, no swap'),
+ ("Compile using: ['h', 'cx', 'x', 'ccx']", 'no z, no swap'),
+ ("Compile using: ['h', 'x', 'ccx']", 'no cx, no z, no swap'),
+ ("Compile using: ['h', 'z', 'x', 'ccx']", 'no cx, no swap')]samples = 512
+num_of_qubits = 3
+max_gates = 12Compile with the different gate-sets and plot correct (exact) compiled circuits. Note, some of the circuits might look the same but the gate time-sequences are distinct. Qiskit reorders “parallel” gates to make smaller plots.
+for c, note in cs: compile_and_plot(U, c)
+
Code repository for generating quantum circuits with diffusion models. [Paper]
+
All weights and functions are contained within this repo. For the CLIP model weights we use the OpenCLIP library, which will download (and cache) the CLIP model on first usage of our pipeline. In case you prefer reading a documentation rather than notebooks or code see [Documentation].
+The repo inlcudes:
+ +A minimal example to generate a 5 qubit circuit conditioned on a SRV of \([1,1,1,2,2]\). You can try it out on your own with our demo [huggingface-space], no coding required.
+from genQC.pipeline.diffusion_pipeline import DiffusionPipeline
+from genQC.inference.infer_srv import generate_srv_tensors, convert_tensors_to_srvs
+
+model_path = "../saves/qc_unet_config_SRV_3to8_qubit/"
+pipeline = DiffusionPipeline.from_config_file(model_path, "cpu")
+pipeline.scheduler.set_timesteps(20)
+
+out_tensor = generate_srv_tensors(pipeline, "Generate SRV: [1,1,1,2,2]", samples=1, system_size=5, num_of_qubits=5, max_gates=16, g=7.5)
+qc_list, _, svr_list = convert_tensors_to_srvs(out_tensor, pipeline.gate_pool)[INFO]: `genQC.models.unet_qc.QC_Cond_UNet` instantiated from given config on cpu.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder` instantiated from given config on cpu.
+[INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder`. No save_path` provided. No state dict loaded.print(f"is SRV {svr_list[0]}")
+qc_list[0].draw("mpl")is SRV [1, 1, 1, 2, 2]
Example notebooks are provided in the directory src/examples/.
0_hello_circuit [doc] [notebook]: how to sample a circuit (conditioned on a SRV)1_editing_and_masking [doc] [notebook]: presents editing and masking2_unitary_compilation [doc] [notebook]: compile unitaries and transpile circuitsgit clone https://github.com/FlorianFuerrutter/genQC.git
+cd genQCThis library is build using jupyter notebooks and nbdev. To install the library use in the clone directory:
+pip install -e .Note, this will install missing requirements automatically: [torch numpy matplotlib scipy pandas omegaconf qiskit tqdm joblib open_clip_torch ipywidgets pylatexenc]. You may want to install some of them manually beforehand, e.g. pytorch for specific cuda support pytorch.org/get-started/locally.
You can run the provided 0_hello_circuit [doc] [notebook] example to test your installation.
The code and weights in this repository are released under the MIT License.
+We kindly ask you to cite our paper if any of the previous material was useful for your work.
+@article{fuerrutter2023quantum,
+ title={Quantum circuit synthesis with diffusion models},
+ author={Florian Fürrutter and Gorka Muñoz-Gil and Hans J. Briegel},
+ year={2023},
+ eprint={2311.02041},
+ publisher = {arXiv},
+ archivePrefix={arXiv},
+ primaryClass={quant-ph},
+ url = {https://arxiv.org/abs/2311.02041},
+ doi = {/10.48550/arXiv.2311.02041},
+}Common model layers.
++++DownBlock2D (in_ch, out_ch, kernel_size=2, stride=2, padding=0, + use_conv=True)
A 2d down scale block.
++++UpBlock2D (in_ch, out_ch, kernel_size=2, stride=2, padding=0, + use_conv=True)
A 2d up scale block.
++++ResBlock2D (in_ch, out_ch, kernel_size, skip=True)
A 2d residual block.
++++ResBlock2D_Conditional (in_ch, out_ch, t_emb_size, kernel_size, + skip=True)
A 2d residual block with input of a time-step \(t\) embedding.
++++FeedForward (in_ch, out_ch, inner_mult=1)
A small dense feed-forward network as used in transformers.
Create sinusoidal position embeddings, same as those from the transformer:
+++PositionalEncoding (d_model:int, dropout:float=0.0, max_len:int=5000)
An absolute pos encoding layer.
++++TimeEmbedding (d_model:int, dropout:float=0.0, max_len:int=5000)
A time embedding layer
++++PositionalEncodingTransposed (d_model:int, dropout:float=0.0, + max_len:int=5000)
An absolute pos encoding layer.
++++PositionalEncoding2D (d_model:int, dropout:float=0.0, max_len:int=5000)
A 2D absolute pos encoding layer.
+a = torch.zeros((1, 4, 3, 4))
+l = PositionalEncoding2D(d_model=4)
+
+l(a)[0].shapetorch.Size([4, 3, 4])Functions to construct a dataset. Here we define the tokenization (encoding and decoding).
++++get_target_control_qubits + (qc:qiskit.circuit.quantumcircuit.QuantumCircu + it, gate:qiskit.circuit.gate.Gate)
+++encode_circuit (qc:qiskit.circuit.quantumcircuit.QuantumCircuit, + num_of_qubits, gate_classes:dict, max_gates:int, + sign_labels={'control_qubits': -1, 'target_qubits': 1}, + return_params=False)
+++decode_circuit (enc_tensor:torch.Tensor, + gate_pool:list[qiskit.circuit.gate.Gate], + place_barrier=True, sign_labels={'control_qubits': -1, + 'target_qubits': 1}, params_tensor=None)
+++get_rnd_encoded_circuit (num_of_qubits, min_gates, max_gates, gate_pool, + gate_classes, rng, optimized=True, + return_params=False)
+++get_rnd_encoded_circuits (samples, num_of_qubits=3, min_gates=3, + max_gates=10, gate_pool=[<class 'qiskit.circuit + .library.standard_gates.h.HGate'>, <class 'qisk + it.circuit.library.standard_gates.x.CXGate'>], + optimized=True, silent=False, + return_params=False)
gate_pool=[ql.HGate, ql.CXGate, ql.CU3Gate, ql.CRXGate]
+
+print("Encode:")
+enc_t, y, params = get_rnd_encoded_circuits(samples=1, num_of_qubits=3, min_gates=6, max_gates=6, gate_pool=gate_pool, optimized=True, return_params=True)
+
+for enc_i, y_i, params_i in zip(enc_t, y, params):
+ print(f"{enc_i=}")
+ print(f"{y_i=}")
+ print(f"{params_i=}")
+
+print("Decode:")
+qc = decode_circuit(enc_t[0], gate_pool=gate_pool, params_tensor=params[0])
+display(qc.draw("mpl"))Encode:
+enc_i=tensor([[-2, 0, -2, 3, 3, 0],
+ [ 2, 1, 2, -3, -3, 0],
+ [ 0, 0, 0, 0, 0, 1]], dtype=torch.int32)
+y_i=[2, 2, 1]
+params_i=tensor([[0.0000, 0.0000, 0.0000, 2.2710, 4.8585, 0.0000],
+ [0.0000, 0.0000, 0.0000, 0.0304, 1.1044, 0.0000],
+ [0.0000, 0.0000, 0.0000, 3.0486, 4.9504, 0.0000]])
+Decode:
+++gen_qc_dataset (samples, num_of_qubits, min_gates, max_gates, gate_pool, + optimized, silent=False)
+++get_specific_rnd_srv_circuit (srv, requested_length, gate_pool, + max_i=2000, silent=True, + fix_length_after_optimizing=True, + requested_length_tolerance=0)
+++gen_compilation_rndGates_dataset (samples, num_of_qubits, min_gates, + max_gates, gate_pool, + min_sub_gate_pool_cnt=1, silent=False)
Samples rnd circuit with a rnd subset of gates and return qc with gate label and unitary
+gate_pool=[ql.HGate, ql.CXGate, ql.ZGate, ql.XGate, ql.CCXGate]
+
+enc_t, y, U = gen_compilation_rndGates_dataset(samples=1, num_of_qubits=3, min_gates=3, max_gates=4, gate_pool=gate_pool)
+
+np.set_printoptions(edgeitems=30, linewidth=100000, formatter=dict(float=lambda x: "%.3g" % x))
+
+print(f"\ny Label >>> {y[0]} <<<")
+print(f"\n{enc_t[0]}")
+print(f"\n{U[0]}")
+print("\nDecoded:")
+qc = decode_circuit(enc_t[0], gate_pool=gate_pool)
+display(qc.draw("mpl"))generated unique circuits: 1
+
+y Label >>> Compile using: ['x'] <<<
+
+tensor([[0, 0, 0, 0],
+ [4, 0, 0, 0],
+ [0, 4, 4, 4]], dtype=torch.int32)
+
+[[0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j]
+ [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j]
+ [0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j]
+ [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j]
+ [0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+ [0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+ [1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+ [0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]]
+
+Decoded:
#place all h on all bist then only cz+++get_number_of_gate_params (gate_cls)
+++gate_pool_to_gate_classes (gate_pool:list[qiskit.circuit.gate.Gate])
Creates a vocabulary from a gate pool.
++++schmidt_rank_vector + (densityMatrix:qiskit.quantum_info.states.densitymat + rix.DensityMatrix)
Return the SRV of a qi.DensityMatrix.
+++rnd_circuit (num_of_qubits, num_of_gates, + gate_pool:list[qiskit.circuit.gate.Gate], rng)
Create a random circuit.
++++optimize_circuit (qc:qiskit.circuit.quantumcircuit.QuantumCircuit, + gate_pool:list[qiskit.circuit.gate.Gate], + optimization_level=2)
Use qiskit.compiler.transpile to optimize a circuit.
+gs = [ql.HGate, ql.CXGate, ql.CRXGate]
+qc = rnd_circuit(num_of_qubits=3, num_of_gates=8, gate_pool=gs, rng=np.random.default_rng())
+svr = schmidt_rank_vector(qi.DensityMatrix(qc))
+display(f"Rand: svr={svr} num_gates={len(qc.data)}", qc.draw('mpl'))
+
+qc = optimize_circuit(qc, gs)
+svr = schmidt_rank_vector(qi.DensityMatrix(qc))
+display(f"Opti: svr={svr} num_gates={len(qc.data)}", qc.draw('mpl'))'Rand: svr=[1, 1, 1] num_gates=8'
'Opti: svr=[1, 1, 1] num_gates=8'
+++plot_svr_stat (num_of_qubits, min_gates, max_gates, gs, samples, + sort=False, opt=True, rng=Generator(PCG64) at + 0x7F5CAD9BBD60)
SRV distrubtion for random sampling
+# gs = [ql.HGate, ql.SGate, ql.TGate, ql.CXGate] # approx universal set
+# gs = [ql.HGate, ql.CCXGate] # approx universal set
+gs = [ql.HGate, ql.CXGate]
+
+plot_svr_stat(num_of_qubits=3, min_gates=6, max_gates=8, gs=gs, samples=int(1e3), rng=np.random.default_rng())[1, 1, 1]: 58.2%
+[2, 2, 1]: 11.5%
+[2, 2, 2]: 11.3%
+[1, 2, 2]: 9.6%
+[2, 1, 2]: 9.4%
def test_srv(system_dims, init, target):
+ vec = qi.Statevector(init, dims=system_dims)
+ vec *= 1/np.sqrt(vec.trace())
+ srv = schmidt_rank_vector(qi.DensityMatrix(vec))
+ assert srv == target, f"srv: {srv}"
+ print(f"passed test, svr: {srv}")
+ display(vec.draw('latex', prefix='|\\psi\\rangle = '))#---------------- |0+> = |00>+|01>
+system_dims = (2,2)
+init = np.zeros(np.prod(system_dims), dtype=complex)
+init[0] = 1
+init[1] = 1
+test_srv(system_dims, init, [1, 1])
+
+#----------------Bell, |00>+|11>
+system_dims = (2,2)
+init = np.zeros(np.prod(system_dims), dtype=complex)
+init[0] = 1
+init[3] = 1
+test_srv(system_dims, init, [2, 2])
+
+#----------------GHZ, |000>+|111>
+system_dims = (2,2,2)
+init = np.zeros(np.prod(system_dims), dtype=complex)
+init[0] = 1
+init[7] = 1
+test_srv(system_dims, init, [2,2,2])
+
+#----------------Sym, |000>+|111>+|222>
+system_dims = (3,3,3)
+init = np.zeros(np.prod(system_dims), dtype=complex)
+init[0] = 1
+init[13] = 1
+init[26] = 1
+test_srv(system_dims, init, [3,3,3])
+
+#----------------Wikipedia example, |000>+|101>+|210>+|311>
+system_dims = (4,4,4)
+init = np.zeros(np.prod(system_dims), dtype=complex)
+init[0] = 1
+init[17] = 1
+init[36] = 1
+init[53] = 1
+test_srv(system_dims, init, [2, 2, 4])passed test, svr: [1, 1]
+passed test, svr: [2, 2]
+passed test, svr: [2, 2, 2]
+passed test, svr: [3, 3, 3]
+passed test, svr: [2, 2, 4]\[|\psi\rangle = \frac{\sqrt{2}}{2} |00\rangle+\frac{\sqrt{2}}{2} |01\rangle\]
+\[|\psi\rangle = \frac{\sqrt{2}}{2} |00\rangle+\frac{\sqrt{2}}{2} |11\rangle\]
+\[|\psi\rangle = \frac{\sqrt{2}}{2} |000\rangle+\frac{\sqrt{2}}{2} |111\rangle\]
+$$\[\begin{align} + +|\psi\rangle = +\begin{bmatrix} +\frac{\sqrt{3}}{3} & 0 & 0 & 0 & \cdots & 0 & 0 & \frac{\sqrt{3}}{3} \\ +\end{bmatrix} +\\ +\text{dims=(3, 3, 3)} +\end{align}\]$$
+$$\[\begin{align} + +|\psi\rangle = +\begin{bmatrix} +\frac{1}{2} & 0 & 0 & 0 & \cdots & 0 & 0 & 0 \\ +\end{bmatrix} +\\ +\text{dims=(4, 4, 4)} +\end{align}\]$$
+${missingFields[0]} field.`,
+ message: `The items being returned for this search do not include all the required fields. Please ensure that your index items include the ${missingFields[0]} field or use index-fields in your _quarto.yml file to specify the field names.`,
+ };
+ } else if (missingFields.length > 1) {
+ const missingFieldList = missingFields
+ .map((field) => {
+ return `${field}`;
+ })
+ .join(", ");
+
+ throw {
+ name: `Error: Search index is missing the following fields: ${missingFieldList}.`,
+ message: `The items being returned for this search do not include all the required fields. Please ensure that your index items includes the following fields: ${missingFieldList}, or use index-fields in your _quarto.yml file to specify the field names.`,
+ };
+ }
+ }
+}
+
+let lastQuery = null;
+function showCopyLink(query, options) {
+ const language = options.language;
+ lastQuery = query;
+ // Insert share icon
+ const inputSuffixEl = window.document.body.querySelector(
+ ".aa-Form .aa-InputWrapperSuffix"
+ );
+
+ if (inputSuffixEl) {
+ let copyButtonEl = window.document.body.querySelector(
+ ".aa-Form .aa-InputWrapperSuffix .aa-CopyButton"
+ );
+
+ if (copyButtonEl === null) {
+ copyButtonEl = window.document.createElement("button");
+ copyButtonEl.setAttribute("class", "aa-CopyButton");
+ copyButtonEl.setAttribute("type", "button");
+ copyButtonEl.setAttribute("title", language["search-copy-link-title"]);
+ copyButtonEl.onmousedown = (e) => {
+ e.preventDefault();
+ e.stopPropagation();
+ };
+
+ const linkIcon = "bi-clipboard";
+ const checkIcon = "bi-check2";
+
+ const shareIconEl = window.document.createElement("i");
+ shareIconEl.setAttribute("class", `bi ${linkIcon}`);
+ copyButtonEl.appendChild(shareIconEl);
+ inputSuffixEl.prepend(copyButtonEl);
+
+ const clipboard = new window.ClipboardJS(".aa-CopyButton", {
+ text: function (_trigger) {
+ const copyUrl = new URL(window.location);
+ copyUrl.searchParams.set(kQueryArg, lastQuery);
+ copyUrl.searchParams.set(kResultsArg, "1");
+ return copyUrl.toString();
+ },
+ });
+ clipboard.on("success", function (e) {
+ // Focus the input
+
+ // button target
+ const button = e.trigger;
+ const icon = button.querySelector("i.bi");
+
+ // flash "checked"
+ icon.classList.add(checkIcon);
+ icon.classList.remove(linkIcon);
+ setTimeout(function () {
+ icon.classList.remove(checkIcon);
+ icon.classList.add(linkIcon);
+ }, 1000);
+ });
+ }
+
+ // If there is a query, show the link icon
+ if (copyButtonEl) {
+ if (lastQuery && options["copy-button"]) {
+ copyButtonEl.style.display = "flex";
+ } else {
+ copyButtonEl.style.display = "none";
+ }
+ }
+ }
+}
+
+/* Search Index Handling */
+// create the index
+var fuseIndex = undefined;
+async function readSearchData() {
+ // Initialize the search index on demand
+ if (fuseIndex === undefined) {
+ // create fuse index
+ const options = {
+ keys: [
+ { name: "title", weight: 20 },
+ { name: "section", weight: 20 },
+ { name: "text", weight: 10 },
+ ],
+ ignoreLocation: true,
+ threshold: 0.1,
+ };
+ const fuse = new window.Fuse([], options);
+
+ // fetch the main search.json
+ const response = await fetch(offsetURL("search.json"));
+ if (response.status == 200) {
+ return response.json().then(function (searchDocs) {
+ searchDocs.forEach(function (searchDoc) {
+ fuse.add(searchDoc);
+ });
+ fuseIndex = fuse;
+ return fuseIndex;
+ });
+ } else {
+ return Promise.reject(
+ new Error(
+ "Unexpected status from search index request: " + response.status
+ )
+ );
+ }
+ }
+ return fuseIndex;
+}
+
+function inputElement() {
+ return window.document.body.querySelector(".aa-Form .aa-Input");
+}
+
+function focusSearchInput() {
+ setTimeout(() => {
+ const inputEl = inputElement();
+ if (inputEl) {
+ inputEl.focus();
+ }
+ }, 50);
+}
+
+/* Panels */
+const kItemTypeDoc = "document";
+const kItemTypeMore = "document-more";
+const kItemTypeItem = "document-item";
+const kItemTypeError = "error";
+
+function renderItem(
+ item,
+ createElement,
+ state,
+ setActiveItemId,
+ setContext,
+ refresh
+) {
+ switch (item.type) {
+ case kItemTypeDoc:
+ return createDocumentCard(
+ createElement,
+ "file-richtext",
+ item.title,
+ item.section,
+ item.text,
+ item.href
+ );
+ case kItemTypeMore:
+ return createMoreCard(
+ createElement,
+ item,
+ state,
+ setActiveItemId,
+ setContext,
+ refresh
+ );
+ case kItemTypeItem:
+ return createSectionCard(
+ createElement,
+ item.section,
+ item.text,
+ item.href
+ );
+ case kItemTypeError:
+ return createErrorCard(createElement, item.title, item.text);
+ default:
+ return undefined;
+ }
+}
+
+function createDocumentCard(createElement, icon, title, section, text, href) {
+ const iconEl = createElement("i", {
+ class: `bi bi-${icon} search-result-icon`,
+ });
+ const titleEl = createElement("p", { class: "search-result-title" }, title);
+ const titleContainerEl = createElement(
+ "div",
+ { class: "search-result-title-container" },
+ [iconEl, titleEl]
+ );
+
+ const textEls = [];
+ if (section) {
+ const sectionEl = createElement(
+ "p",
+ { class: "search-result-section" },
+ section
+ );
+ textEls.push(sectionEl);
+ }
+ const descEl = createElement("p", {
+ class: "search-result-text",
+ dangerouslySetInnerHTML: {
+ __html: text,
+ },
+ });
+ textEls.push(descEl);
+
+ const textContainerEl = createElement(
+ "div",
+ { class: "search-result-text-container" },
+ textEls
+ );
+
+ const containerEl = createElement(
+ "div",
+ {
+ class: "search-result-container",
+ },
+ [titleContainerEl, textContainerEl]
+ );
+
+ const linkEl = createElement(
+ "a",
+ {
+ href: offsetURL(href),
+ class: "search-result-link",
+ },
+ containerEl
+ );
+
+ const classes = ["search-result-doc", "search-item"];
+ if (!section) {
+ classes.push("document-selectable");
+ }
+
+ return createElement(
+ "div",
+ {
+ class: classes.join(" "),
+ },
+ linkEl
+ );
+}
+
+function createMoreCard(
+ createElement,
+ item,
+ state,
+ setActiveItemId,
+ setContext,
+ refresh
+) {
+ const moreCardEl = createElement(
+ "div",
+ {
+ class: "search-result-more search-item",
+ onClick: (e) => {
+ // Handle expanding the sections by adding the expanded
+ // section to the list of expanded sections
+ toggleExpanded(item, state, setContext, setActiveItemId, refresh);
+ e.stopPropagation();
+ },
+ },
+ item.title
+ );
+
+ return moreCardEl;
+}
+
+function toggleExpanded(item, state, setContext, setActiveItemId, refresh) {
+ const expanded = state.context.expanded || [];
+ if (expanded.includes(item.target)) {
+ setContext({
+ expanded: expanded.filter((target) => target !== item.target),
+ });
+ } else {
+ setContext({ expanded: [...expanded, item.target] });
+ }
+
+ refresh();
+ setActiveItemId(item.__autocomplete_id);
+}
+
+function createSectionCard(createElement, section, text, href) {
+ const sectionEl = createSection(createElement, section, text, href);
+ return createElement(
+ "div",
+ {
+ class: "search-result-doc-section search-item",
+ },
+ sectionEl
+ );
+}
+
+function createSection(createElement, title, text, href) {
+ const descEl = createElement("p", {
+ class: "search-result-text",
+ dangerouslySetInnerHTML: {
+ __html: text,
+ },
+ });
+
+ const titleEl = createElement("p", { class: "search-result-section" }, title);
+ const linkEl = createElement(
+ "a",
+ {
+ href: offsetURL(href),
+ class: "search-result-link",
+ },
+ [titleEl, descEl]
+ );
+ return linkEl;
+}
+
+function createErrorCard(createElement, title, text) {
+ const descEl = createElement("p", {
+ class: "search-error-text",
+ dangerouslySetInnerHTML: {
+ __html: text,
+ },
+ });
+
+ const titleEl = createElement("p", {
+ class: "search-error-title",
+ dangerouslySetInnerHTML: {
+ __html: ` ${title}`,
+ },
+ });
+ const errorEl = createElement("div", { class: "search-error" }, [
+ titleEl,
+ descEl,
+ ]);
+ return errorEl;
+}
+
+function positionPanel(pos) {
+ const panelEl = window.document.querySelector(
+ "#quarto-search-results .aa-Panel"
+ );
+ const inputEl = window.document.querySelector(
+ "#quarto-search .aa-Autocomplete"
+ );
+
+ if (panelEl && inputEl) {
+ panelEl.style.top = `${Math.round(panelEl.offsetTop)}px`;
+ if (pos === "start") {
+ panelEl.style.left = `${Math.round(inputEl.left)}px`;
+ } else {
+ panelEl.style.right = `${Math.round(inputEl.offsetRight)}px`;
+ }
+ }
+}
+
+/* Highlighting */
+// highlighting functions
+function highlightMatch(query, text) {
+ if (text) {
+ const start = text.toLowerCase().indexOf(query.toLowerCase());
+ if (start !== -1) {
+ const startMark = "";
+ const endMark = "";
+
+ const end = start + query.length;
+ text =
+ text.slice(0, start) +
+ startMark +
+ text.slice(start, end) +
+ endMark +
+ text.slice(end);
+ const startInfo = clipStart(text, start);
+ const endInfo = clipEnd(
+ text,
+ startInfo.position + startMark.length + endMark.length
+ );
+ text =
+ startInfo.prefix +
+ text.slice(startInfo.position, endInfo.position) +
+ endInfo.suffix;
+
+ return text;
+ } else {
+ return text;
+ }
+ } else {
+ return text;
+ }
+}
+
+function clipStart(text, pos) {
+ const clipStart = pos - 50;
+ if (clipStart < 0) {
+ // This will just return the start of the string
+ return {
+ position: 0,
+ prefix: "",
+ };
+ } else {
+ // We're clipping before the start of the string, walk backwards to the first space.
+ const spacePos = findSpace(text, pos, -1);
+ return {
+ position: spacePos.position,
+ prefix: "",
+ };
+ }
+}
+
+function clipEnd(text, pos) {
+ const clipEnd = pos + 200;
+ if (clipEnd > text.length) {
+ return {
+ position: text.length,
+ suffix: "",
+ };
+ } else {
+ const spacePos = findSpace(text, clipEnd, 1);
+ return {
+ position: spacePos.position,
+ suffix: spacePos.clipped ? "…" : "",
+ };
+ }
+}
+
+function findSpace(text, start, step) {
+ let stepPos = start;
+ while (stepPos > -1 && stepPos < text.length) {
+ const char = text[stepPos];
+ if (char === " " || char === "," || char === ":") {
+ return {
+ position: step === 1 ? stepPos : stepPos - step,
+ clipped: stepPos > 1 && stepPos < text.length,
+ };
+ }
+ stepPos = stepPos + step;
+ }
+
+ return {
+ position: stepPos - step,
+ clipped: false,
+ };
+}
+
+// removes highlighting as implemented by the mark tag
+function clearHighlight(searchterm, el) {
+ const childNodes = el.childNodes;
+ for (let i = childNodes.length - 1; i >= 0; i--) {
+ const node = childNodes[i];
+ if (node.nodeType === Node.ELEMENT_NODE) {
+ if (
+ node.tagName === "MARK" &&
+ node.innerText.toLowerCase() === searchterm.toLowerCase()
+ ) {
+ el.replaceChild(document.createTextNode(node.innerText), node);
+ } else {
+ clearHighlight(searchterm, node);
+ }
+ }
+ }
+}
+
+function escapeRegExp(string) {
+ return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+
+// highlight matches
+function highlight(term, el) {
+ const termRegex = new RegExp(term, "ig");
+ const childNodes = el.childNodes;
+
+ // walk back to front avoid mutating elements in front of us
+ for (let i = childNodes.length - 1; i >= 0; i--) {
+ const node = childNodes[i];
+
+ if (node.nodeType === Node.TEXT_NODE) {
+ // Search text nodes for text to highlight
+ const text = node.nodeValue;
+
+ let startIndex = 0;
+ let matchIndex = text.search(termRegex);
+ if (matchIndex > -1) {
+ const markFragment = document.createDocumentFragment();
+ while (matchIndex > -1) {
+ const prefix = text.slice(startIndex, matchIndex);
+ markFragment.appendChild(document.createTextNode(prefix));
+
+ const mark = document.createElement("mark");
+ mark.appendChild(
+ document.createTextNode(
+ text.slice(matchIndex, matchIndex + term.length)
+ )
+ );
+ markFragment.appendChild(mark);
+
+ startIndex = matchIndex + term.length;
+ matchIndex = text.slice(startIndex).search(new RegExp(term, "ig"));
+ if (matchIndex > -1) {
+ matchIndex = startIndex + matchIndex;
+ }
+ }
+ if (startIndex < text.length) {
+ markFragment.appendChild(
+ document.createTextNode(text.slice(startIndex, text.length))
+ );
+ }
+
+ el.replaceChild(markFragment, node);
+ }
+ } else if (node.nodeType === Node.ELEMENT_NODE) {
+ // recurse through elements
+ highlight(term, node);
+ }
+ }
+}
+
+/* Link Handling */
+// get the offset from this page for a given site root relative url
+function offsetURL(url) {
+ var offset = getMeta("quarto:offset");
+ return offset ? offset + url : url;
+}
+
+// read a meta tag value
+function getMeta(metaName) {
+ var metas = window.document.getElementsByTagName("meta");
+ for (let i = 0; i < metas.length; i++) {
+ if (metas[i].getAttribute("name") === metaName) {
+ return metas[i].getAttribute("content");
+ }
+ }
+ return "";
+}
+
+function algoliaSearch(query, limit, algoliaOptions) {
+ const { getAlgoliaResults } = window["@algolia/autocomplete-preset-algolia"];
+
+ const applicationId = algoliaOptions["application-id"];
+ const searchOnlyApiKey = algoliaOptions["search-only-api-key"];
+ const indexName = algoliaOptions["index-name"];
+ const indexFields = algoliaOptions["index-fields"];
+ const searchClient = window.algoliasearch(applicationId, searchOnlyApiKey);
+ const searchParams = algoliaOptions["params"];
+ const searchAnalytics = !!algoliaOptions["analytics-events"];
+
+ return getAlgoliaResults({
+ searchClient,
+ queries: [
+ {
+ indexName: indexName,
+ query,
+ params: {
+ hitsPerPage: limit,
+ clickAnalytics: searchAnalytics,
+ ...searchParams,
+ },
+ },
+ ],
+ transformResponse: (response) => {
+ if (!indexFields) {
+ return response.hits.map((hit) => {
+ return hit.map((item) => {
+ return {
+ ...item,
+ text: highlightMatch(query, item.text),
+ };
+ });
+ });
+ } else {
+ const remappedHits = response.hits.map((hit) => {
+ return hit.map((item) => {
+ const newItem = { ...item };
+ ["href", "section", "title", "text"].forEach((keyName) => {
+ const mappedName = indexFields[keyName];
+ if (
+ mappedName &&
+ item[mappedName] !== undefined &&
+ mappedName !== keyName
+ ) {
+ newItem[keyName] = item[mappedName];
+ delete newItem[mappedName];
+ }
+ });
+ newItem.text = highlightMatch(query, newItem.text);
+ return newItem;
+ });
+ });
+ return remappedHits;
+ }
+ },
+ });
+}
+
+function fuseSearch(query, fuse, fuseOptions) {
+ return fuse.search(query, fuseOptions).map((result) => {
+ const addParam = (url, name, value) => {
+ const anchorParts = url.split("#");
+ const baseUrl = anchorParts[0];
+ const sep = baseUrl.search("\\?") > 0 ? "&" : "?";
+ anchorParts[0] = baseUrl + sep + name + "=" + value;
+ return anchorParts.join("#");
+ };
+
+ return {
+ title: result.item.title,
+ section: result.item.section,
+ href: addParam(result.item.href, kQueryArg, query),
+ text: highlightMatch(query, result.item.text),
+ };
+ });
+}
diff --git a/sitemap.xml b/sitemap.xml
new file mode 100644
index 0000000..79090ac
--- /dev/null
+++ b/sitemap.xml
@@ -0,0 +1,139 @@
+
+Miscellaneous util code.
++++MemoryCleaner ()
CLass with static methods to clean (gpu) memory.
++++virtual (f:<built-infunctioncallable>)
Decorator to enfore subclass method implementations and raises error at method calls.
+class A():
+ def p1(self, x): print("A p1", x)
+
+ @virtual
+ def p2(self, x): pass
+
+class B(A):
+ def p3(self, x): print("B p2", x)
+
+b = B()
+b.p1(1)
+try:
+ b.p2(1)
+except BaseException as e:
+ print("Exception that would be raised: ", e)A p1 1
+Exception that would be raised: Virtual method p2 needs to be implemented by subclass B.+++DataLoaders (*dls:list[torch.utils.data.dataloader.DataLoader])
Combines train and valid DataLoader.
+++infer_torch_device ()
infer_torch_device()[INFO]: Cuda device has a capability of 8.6 (>= 8), allowing tf32 matmul.device(type='cuda')+++number_of_paramters (model:torch.nn.modules.module.Module)
+++scale_tensor (t:torch.Tensor)
[-1,1] to [0,1]
++++normalize_tensor (t:torch.Tensor)
[0,1] to [-1,1]
++++saveSvg (filename)
+++savePng (filename)
+++savePdf (filename)
+++plot_image_grid (imgs:Union[list,<built-infunctionarray>,torch.Tensor], + labels:list=None, labels_fs='medium', figsize=(16, 4), + cols=8, cmap='Greys', show_colorbar=False, + **imshow_kwargs)
n = 6
+plot_image_grid(torch.randn((n,28,28,1)), [f"label {i}" for i in range(n)])
++ + ++latents_to_pil (latents:torch.Tensor, channels=None)