In this notebook we create a (demo) 9-qubit dataset and fine-tune the model with it. Note, we use direct fine-tuning similar as you would train the model from scratch (with a higher learn-rate and larger dataset).
+from genQC.imports import *
+
+import genQC.util as util
+import genQC.platform.qcircuit_dataset_construction as data_const
+import genQC.inference.infer_srv as infer_srv
+import genQC.dataset.dataset_helper as dahe
+
+from genQC.pipeline.diffusion_pipeline import DiffusionPipeline
+from genQC.dataset.qc_dataset import Qc_Config_Dataset
+from genQC.dataset.mixed_cached_qc_dataset import Mixed_Cached_OpenClip_Datasetdevice = util.infer_torch_device() # use cuda if we can, cpu is much slower
+util.MemoryCleaner.purge_mem() # clean existing memory alloc[INFO]: Cuda device has a capability of 8.6 (>= 8), allowing tf32 matmul.def get_preTrained_pipeline():
+ model_path = "../../saves/qc_unet_config_SRV_3to8_qubit/"
+ pipeline = DiffusionPipeline.from_config_file(model_path, device)
+ return pipelineLoad the pre-trained model. Set 20 sample steps and use rescaled guidance-formula.
+pipeline = get_preTrained_pipeline()
+
+pipeline.guidance_sample_mode = "rescaled"
+pipeline.scheduler.set_timesteps(20)
+
+print("Trained with gates:", pipeline.gate_pool)[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.
+Trained with gates: [<class 'qiskit.circuit.library.standard_gates.h.HGate'>, <class 'qiskit.circuit.library.standard_gates.x.CXGate'>]Generate circuits as explained in the 0_hello_circuit [doc] [notebook] example.
srv = [2, 2, 2, 1, 1, 1, 1, 1, 2] # set your target SRV
+num_of_qubits = len(srv)
+assert num_of_qubits == 9
+
+prompt = f"Generate SRV: {srv}" # model was trained with this phrase
+prompt'Generate SRV: [2, 2, 2, 1, 1, 1, 1, 1, 2]'g = 7.5 # guidance scale
+max_gates = 16 # how many time steps the tensor encoding has
+samples = 64 # how many circuits to generate
+
+out_tensor = infer_srv.generate_srv_tensors(pipeline, prompt, samples, num_of_qubits, num_of_qubits, max_gates, g, no_bar=False)
+qc_list, error_cnt, srv_list = infer_srv.convert_tensors_to_srvs(out_tensor, pipeline.gate_pool) # may take a moment, has to compute partial traces over (2^9)x(2^9) density matrices
+print(f"Not valid error circuits: {error_cnt} out of {samples}")[INFO]: (generate_srv_tensors) Generated 64 tensors
+Not valid error circuits: 1 out of 64acc = infer_srv.get_srv_accuracy(srv_list, srv)
+print(f"Accuracy on requested {len(srv)} qubit SRV={srv}, with a model trained on 3 to 8 qubits circuits: {acc:.2f}")Accuracy on requested 9 qubit SRV=[2, 2, 2, 1, 1, 1, 1, 1, 2], with a model trained on 3 to 8 qubits circuits: 0.02Let’s create a 9 qubit fine-tune training dataset.
+We sample random 9 qubit circuits on which we fine-tune on. Note, there is no balancing over what SRVs are created! The initial model was only trained on 3 to 8 qubit circuits.
+# settings for random circuit sampling
+random_samples = int(512) # how many rnd qcs we sample, here small number to speed up example
+num_of_qubits = 9
+min_gates = 2
+max_gates = 20
+gate_pool = pipeline.gate_pool
+optimized = True # if qiskit optimizer is used
+
+x, y = data_const.gen_qc_dataset(samples=random_samples, num_of_qubits=num_of_qubits, min_gates=min_gates, max_gates=max_gates,
+ gate_pool=gate_pool, optimized=optimized, silent=False)Generated unique circuits: 511y[0]tensor([1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=torch.int32)y = np.array([f"Generate SRV: {srv.numpy()}" for srv in y]) # convert SRV to the trained prompt
+y[0]'Generate SRV: [1 1 1 1 1 1 1 1 1]'We get tokenized circuits with SRV:
+print(f"Example circuit with prompt: \n{y[-1]} \n{x[-1]}")Example circuit with prompt:
+Generate SRV: [1 1 1 1 2 1 2 1 1]
+tensor([[ 2, 2, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [-2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [ 0, -2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [ 0, 0, 0, 0, 0, 2, 1, 2, -2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [ 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [ 0, 0, 0, 0, -2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [ 0, 0, 0, 0, 0, -2, 0, -2, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=torch.int32)Direct fine-tuning is the same as you would train a new model from scratch. First, we create a Qc_Config_Dataset object that handles our dataset.
# meta-data of dataset
+paras = {}
+paras["store_dict"] = {'x':'tensor', 'y':'numpy'} #what is in the datset, with type
+paras["optimized"] = optimized
+paras["dataset_to_gpu"] = True if device=="cuda" else False
+paras["random_samples"] = random_samples
+paras["num_of_qubits"] = num_of_qubits
+paras["min_gates"] = min_gates
+paras["max_gates"] = max_gates
+paras["gate_pool"] = [dahe.class_to_str(gate) for gate in gate_pool]Make sure our dataset has no duplicates and shuffle it:
+x, y = dahe.uniquify_tensor_dataset(x, y)
+assert x.shape[0] == x.unique(dim=0).shape[0] # check if no duplicates
+
+x, y = dahe.shuffle_tensor_dataset(x, y)Now create the Qc_Config_Dataset object:
qc_Config_Dataset = Qc_Config_Dataset(store_device=device, **paras)
+qc_Config_Dataset.x = x
+qc_Config_Dataset.y = y
+qc_Config_Dataset.dataset_to_gpu = True if device.type=="cuda" else False
+qc_Config_Dataset.plot_example()Label: ``Generate SRV: [1 1 1 1 1 1 1 1 1]`` SRV is: [1, 1, 1, 1, 1, 1, 1, 1, 1]
# qc_Config_Dataset.plot_distribution() #print the SRV distribution percentagesIf you want to save the dataset to disk, you could use:
+config_path = "YOUR_CONFIG_FILE"
+save_path = "YOUR_SAVE_PATH"
+qc_Config_Dataset.save_dataset(config_path, save_path)where config_path file-path to the meta-data file, e.g. "../../configs/dataset/qc_9bit_fine_tune.yaml
and save_path file-path prefix where the raw dataset files are stored, e.g. "../../datasets/q-circuits/qc_9bit_fine_tune".
A saved dataset can be loaded with:
+qc_Config_Dataset = Qc_Config_Dataset.from_config_file(config_path, device=device) To speed up training we can cache the CLIP embeddings of the y dataset labels before we start fitting. We provide the Cached_OpenClip_Dataset object for this. Here we use a further extension, the Mixed_Cached_OpenClip_Dataset. It has advanced methods to handle padding and combining different task (e.g. compile and SRV) or different number of qubit datasets together (as explained in the appendix of the paper). We use it here to automatically cut and pad our 9 qubit circuits to the longest circuit within one batch.
See if the pipeline has already a padding token specified, else define one.
+try: pad_constant = pipeline.params_config("")["add_config"]["dataset"]["params"]["pad_constant"] #can NOT be 0 (empty token)! and not any other gate!
+except: pad_constant = len(qc_Config_Dataset.gate_pool)+1
+
+print(f"{pad_constant=}")pad_constant=3dataset_list = [qc_Config_Dataset] # what datasets to combine
+
+parameters = asdict(qc_Config_Dataset.params_config)
+parameters["num_down_scales"] = 3 # defined by the down-scale layers of the UNet
+
+mixed_dataset = Mixed_Cached_OpenClip_Dataset.from_datasets(dataset_list,
+ balance_maxes=[1e8], # what the maximum prompt (y) balance limit is, can be used to balance SRVs for different qubit numbers
+ pad_constant=pad_constant,
+ device=device,
+ bucket_batch_size=-1, # if we use bucket padding
+ max_samples=[1e8], # if we want to limit the sizes of the dataset_list
+ **parameters) - dataset size after balancing 511Let’s see what we are training on:
+fig, axs = plt.subplots(1, 2, figsize=(12, 3.6), squeeze=False, constrained_layout=True)
+plt.sca(axs[0, 0])
+plt.xlabel(r"$s$")
+plt.title("Dist of space")
+min_q, max_q = min(d.num_of_qubits for d in dataset_list), max(d.num_of_qubits for d in dataset_list)
+data = mixed_dataset.z[:, 0].cpu()
+plt.hist(data, bins=np.arange(min_q, max_q+2) - 0.5, rwidth=0.9)
+
+plt.sca(axs[0, 1])
+plt.xlabel(r"$t$")
+plt.title("Dist of time")
+min_g, max_g = min(d.min_gates for d in dataset_list), max(d.max_gates for d in dataset_list)
+data = mixed_dataset.z[:, 1].cpu()
+plt.hist(data, bins=np.arange(min_g, max_g+2) - 0.5, rwidth=0.9)
+
+plt.show()
Finally, we can create the dataloader used by the DiffusionPipeline.fit() funtion. This also caches all our prompts.
tuned_pipeline = get_preTrained_pipeline() # load a fresh pre-trained model we want to train
+
+dataloaders = mixed_dataset.get_dataloaders(batch_size=16, text_encoder=tuned_pipeline.text_encoder.to(device), y_on_cpu=False) # you can set y_on_cpu=True if you run out of device mem[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.
+[INFO]: Not balancing dataset! balance_max=None
+[INFO]: Generate cache: converting tensors to str and tokenize
+ - to str list
+ - tokenize_and_push_to_device
+ - generate_cache
+[INFO]: caching trying to allocate memory (148, 77, 512) on cuda approx. 0.023 GB
+[INFO]: Generated cacheWe have the dataloader object created and can start fine-tuning. Note, we just use all the diffusion scheduler parameters from the pre-trained config we loaded.
+tuned_pipeline.add_config["dataset"] = mixed_dataset.get_config() # add meta-data of dataset to save it with pipeline
+tuned_pipeline.compile(torch.optim.Adam, nn.MSELoss)epochs = 25 # how many epochs we train on our 9bit dataset
+lr = 5e-5 # learn rate
+
+sched = functools.partial(torch.optim.lr_scheduler.OneCycleLR, max_lr=lr, total_steps=epochs*len(dataloaders.train))
+tuned_pipeline.fit(epochs, dataloaders, lr=lr, lr_sched=sched)
If you want you can save the tuned pipeline with:
+store_dir = f"../../saves/fine_tuned_on_9bits/"
+
+tuned_pipeline.store_pipeline(config_path=store_dir, save_path=store_dir)and load it again with the usual:
+tuned_pipeline = DiffusionPipeline.from_config_file(model_path, device) Test again to create a 9 qubit SRV as we did at the start but with the tuned model:
+prompt'Generate SRV: [2, 2, 2, 1, 1, 1, 1, 1, 2]'g = 7.5 # guidance scale
+max_gates = 16 # how many time steps the tensor encoding has
+samples = 64 # how many circuits to generate
+
+tuned_pipeline.guidance_sample_mode = "rescaled"
+tuned_pipeline.scheduler.set_timesteps(20)
+
+out_tensor = infer_srv.generate_srv_tensors(tuned_pipeline, prompt, samples, num_of_qubits, num_of_qubits, max_gates, g, no_bar=False)
+qc_list, error_cnt, srv_list = infer_srv.convert_tensors_to_srvs(out_tensor, tuned_pipeline.gate_pool) # may take a moment, has to compute partial traces over (2^9)x(2^9) density matrices
+print(f"Not valid error circuits: {error_cnt} out of {samples}")[INFO]: (generate_srv_tensors) Generated 64 tensors
+Not valid error circuits: 1 out of 64tuned_acc = infer_srv.get_srv_accuracy(srv_list, srv)
+print(f"Accuracy on requested {len(srv)} qubit SRV={srv}, with a model trained on 3 to 8 qubits qcs: {acc:.2f} and with fine-tuning on 9 qubit qcs: {tuned_acc:.2f}")Accuracy on requested 9 qubit SRV=[2, 2, 2, 1, 1, 1, 1, 1, 2], with a model trained on 3 to 8 qubits qcs: 0.02 and with fine-tuning on 9 qubit qcs: 0.05Note, we didn’t fine-tune on a balanced dataset with all possible 9 qubit SRVs, just some random circuits (most, ~50%, of them will be the SRV with all 1s). So we don’t expect a huge boost in accuracy.
+ + +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", style="clifford")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 = 64 # 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 64 tensorsCheck how many distinct tensors we got:
+out_tensor.unique(dim=0).shape[0]64Let’s look what is generated. Note, 3 is the padding token (or empty action).
+out_tensor[:2]tensor([[[ 0, 2, 0, 2, 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],
+ [ 2, -2, 1, -2, -2, 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],
+ [-2, 0, 0, 0, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]],
+
+ [[ 0, 0, 0, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 1, -2, 1, -2, 1, 0, -2, 0, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3],
+ [ 0, 2, 0, 0, 0, 1, 2, 1, 3, 3, 3, 3, 3, 3, 3, 3]]])To get a qiskit circuit we need to do:
+infer_srv.generate_srv_tensors did this already)qc_list, error_cnt, srv_list = infer_srv.convert_tensors_to_srvs(out_tensor, pipeline.gate_pool)Generated error circuits (token matrices that don’t correspond to circuits):
+error_cnt0What SRVs did we get:
+srv_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 srv_list)/len(srv_list)0.921875Finally 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, srv_list, axs.flatten()):
+ qc.draw("mpl", plot_barriers=False, ax=ax, style = "clifford")
+ 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] [Demo]
+
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", style="clifford")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 masking of circuits2_unitary_compilation [doc] [notebook]: Compile unitaries and transpile circuits3_dataset_and_fineTune [doc] [notebook]: How to create a dataset and fine-tune a pre-trained modelThe installation of genQC is done via pip within a few minutes, depending on your downloading speed.
git 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. You may want to install some of them manually beforehand, e.g. pytorch for specific cuda support, see pytorch.org/get-started/locally.
+Requirements: genQC depends on python (min. version 3.9) and the librarys: torch, numpy, matplotlib, scipy, pandas, omegaconf, qiskit, tqdm, joblib, open_clip_torch, ipywidgets and pylatexenc. All can be installed with pip. In src/RELEASES.md [doc] and the release descriptions specific tested-on versions are listed.
You can run the provided 0_hello_circuit [doc] [notebook] example to test your installation. On a computer with a moderate GPU this inference example notebook should run under half a minute.
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 + 0x7FC59D9A7F20)
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..106b1b7
--- /dev/null
+++ b/sitemap.xml
@@ -0,0 +1,147 @@
+
+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)