def detail(run_id: str) -> None:
click.echo(click.style("Run [{}] detailed information.\n".format(run_id), fg='magenta'))
glob_query = "{}/**/{}/run.json".format(EXPERIMENTS_DIRECTORY, run_id)
results = glob.glob(glob_query)
if len(results) == 0:
click.echo(click.style("No data for experiment found =(\n"
"Check `qiskitflow runs`", fg="yellow"))
for path in results:
run = Experiment.load(path)
ps = "\n".join(str(p) for p in run.parameters)
ms = "\n".join(str(m) for m in run.metrics)
cts = "\n".join(str(c) for c in run.counts)
header = ["", "Values"]
rows = [
["Run ID", run.run_id],
["Experiment", run.name],
["Date", datetime.fromtimestamp(run.timestamp)],
["Parameters", ps],
["Metrics", ms],
["Counts", cts]
]
click.echo(click.style(tabulate(rows, header, tablefmt='grid'), fg='white'))
def test_experiments_list(self):
""" Test experiments list. """
with self.runner.isolated_filesystem():
for idx in range(5):
with Experiment("{} experiment".format(idx)) as exp:
exp.write_metric("metric", idx * 1.)
exp.write_parameter("parameter", "value {}".format(idx))
result = self.runner.invoke(experiments_list)
expected_result = """+--------------+----------+
| Experiment | # runs |
+==============+==========+
| 4 experiment | 1 |
+--------------+----------+
| 1 experiment | 1 |
+--------------+----------+
| 3 experiment | 1 |
+--------------+----------+
| 0 experiment | 1 |
+--------------+----------+
| 2 experiment | 1 |
+--------------+----------+"""
self.assertEqual(result.exit_code, 0)
for idx in range(5):
self.assertTrue("{} experiment".format(idx) in result.output)
def run():
with Experiment("LEL", entrypoint="test.py") as exp:
exp.write_metric("lel", 0.1)
exp.write_metric("lel2", 0.2)
exp.write_metric("lel3", 0.3)
exp.write_metric("lel4", 0.4)
exp.write_parameter("asdasd", "asdasd")
exp.write_parameter("asdasd123", "asdasd")
exp.write_parameter("asdasd1232", "asdasd")
exp.write_parameter("asdasd123123", "asdasd")
def _get_runs(search: str,
experiment_name: str,
order_by: str,
order_type: str = "asc"):
glob_query = "{}/**/**/run.json".format(EXPERIMENTS_DIRECTORY)
if experiment_name:
glob_query = "{}/{}/**/run.json".format(EXPERIMENTS_DIRECTORY,
experiment_name)
runs_paths = glob.glob(glob_query)
# gather all runs and sort them accordingly
runs = []
for path in runs_paths:
experiment = Experiment.load(path)
if experiment_name and experiment_name != experiment.name:
continue
if search in experiment.run_id:
ordering = experiment.get_metric(
order_by) if order_by else os.path.getctime(path)
runs.append({"order": int(ordering), "run": Experiment.load(path)})
runs.sort(key=lambda x: x["order"], reverse=order_type == "desc")
# collect rows to display
rows = []
for entry in runs:
run = entry["run"]
ps = [str(p) for p in run.parameters]
ms = [str(m) for m in run.metrics]
rows.append([
datetime.fromtimestamp(run.timestamp),
"{}\n({})".format(run.name,
run.run_id), "\n".join(ms), "\n".join(ps)
])
return rows
def run():
with Experiment("LEL") as exp:
exp.write_metric("lel", 0.1)
exp.write_metric("lel2", 0.2)
exp.write_metric("lel3", 0.3)
exp.write_metric("lel4", 0.4)
exp.write_parameter("asdasd", "asdasd")
exp.write_parameter("asdasd123", "asdasd")
exp.write_parameter("asdasd1232", "asdasd")
exp.write_parameter("asdasd123123", "asdasd")
exp.write_counts("measure 1", {"01": 123123})
def test_experiment_info(self):
""" Test experiments list. """
with self.runner.isolated_filesystem():
with Experiment("experiment") as exp:
exp.write_metric("metric", 1.)
exp.write_metric("other metric", 2.)
exp.write_parameter("parameter", "value")
exp.write_parameter("other parameter", "other value")
result = self.runner.invoke(experiment_info, ["experiment"])
self.assertEqual(result.exit_code, 0)
for metric in exp.metrics:
self.assertTrue(str(metric) in result.output)
for param in exp.parameters:
self.assertTrue(str(param) in result.output)
def test_metrics_and_parameters_options(self):
""" Tests metrics and parameters command options. """
with self.runner.isolated_filesystem():
with Experiment("experiment") as exp:
exp.write_metric("metric", 1.)
exp.write_metric("other metric", 2.)
exp.write_parameter("parameter", "value")
exp.write_parameter("other parameter", "other value")
result = self.runner.invoke(experiment_info, [
"experiment", "--metrics=metric",
"--parameters=parameter,other parameter"
])
self.assertEqual(result.exit_code, 0)
self.assertTrue("M[metric]" in result.output)
self.assertFalse("other metric" in result.output)
def _get_runs(name: str, metrics: str, parameters: str):
""" Get run list.
Args:
name (str): name of experiment
metrics (str): csv list of metrics to display
parameters (str): csv list of parameters to display
sort (str): sort by metric
Returns:
rows (list): list of rows for rendered table
"""
runs = []
for idx, path in enumerate(
glob.glob("{}/{}/**/run.json".format(EXPERIMENTS_DIRECTORY,
name))):
_, _, run_id, _ = path.split("/")
experiment = Experiment.load(path)
if not metrics and not parameters:
ms = [str(m) for m in experiment.metrics]
ps = [str(p) for p in experiment.parameters]
runs.append([run_id, "\n".join(ps), "\n".join(ms)])
else:
run = [run_id]
for parameter in parameters.split(","):
params_dict = {p.name: p.value for p in experiment.parameters}
run.append(params_dict.get(parameter, ""))
for metric in metrics.split(","):
metrics_dict = {m.name: m.value for m in experiment.metrics}
run.append(metrics_dict.get(metric, ""))
runs.append(run)
return runs
def quantum_teleporation_experiment():
experiment = Experiment("quantum_teleportation")
qc = QuantumCircuit(1) # Create a quantum circuit with one qubit
psi = [1 / sqrt(2),
1 / sqrt(2)] # Define initial_state in a superposition state
initial_state = Initialize(psi)
qc.append(initial_state,
[0]) # Apply initialisation operation to the 0th qubit
result = execute(qc, Aer.get_backend('statevector_simulator')).result(
) # Do the simulation, returning the result
exp_state = result.get_statevector(qc)
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.append(initial_state, [0])
circuit.barrier()
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.barrier()
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier()
circuit.cz(qr[0], qr[2])
circuit.cx(qr[1], qr[2])
circuit.measure(qr[2], cr)
t = time.time()
backend = Aer.get_backend('qasm_simulator')
job_circuit = execute(circuit, backend=backend, shots=4096)
device_counts = job_circuit.result().get_counts(circuit)
experiment.write_measurement(device_counts)
qc = QuantumRegister(3)
circuit = QuantumCircuit(qc)
circuit.append(initial_state, [0])
circuit.barrier()
circuit.h(qc[1])
circuit.cx(qc[1], qc[2])
circuit.barrier()
circuit.cx(qc[0], qc[1])
circuit.h(qc[0])
circuit.barrier()
circuit.cz(qc[0], qc[2])
circuit.cx(qc[1], qc[2])
t = time.time()
qst_circuit = state_tomography_circuits(circuit, qc[2])
job_circuit = execute(qst_circuit, backend=backend, shots=4096)
tomo_circuit = StateTomographyFitter(job_circuit.result(), qst_circuit)
tomo_circuit.data
rho_circuit = tomo_circuit.fit()
F_state = state_fidelity(exp_state, rho_circuit)
pur = purity(rho_circuit)
experiment.write_metric("purity", float(pur))
experiment.write_metric("fit_fidelity_state", float(F_state))
experiment.write_metric("execution time", int(time.time() - t))
experiment.write_parameter("backend", "qasm_simulator")
experiment.write_parameter("number of shots", 4096)
experiment.write_parameter("job id", str(job_circuit.job_id()))
experiment.save_exoeriment()
print("WOOHOO!") # that exact feeling when your code is working
from qiskitflow.lib.experiment import Experiment
import random
import os
for name in ["entanglement", "simple_circuit_experiment", "qml_experiment", "quantum_ensembling"]:
for i in range(5):
experiment = Experiment(name)
experiment.write_measurement({
"0000": random.randint(0, 1024),
"0001": random.randint(0, 1024),
"0010": random.randint(0, 1024),
"0011": random.randint(0, 1024)
})
experiment.write_measurement({
"0000": random.randint(0, 1024),
"0001": random.randint(0, 1024),
"0010": random.randint(0, 1024),
"0011": random.randint(0, 1024)
})
experiment.write_measurement({
"0000": random.randint(0, 1024),
"0001": random.randint(0, 1024),
"0010": random.randint(0, 1024),
"0011": random.randint(0, 1024)
})
experiment.write_metric("t0", 0.1)
experiment.write_metric("execution time", 10)
from qiskitflow.lib.experiment import Experiment
experiment = Experiment("some name")
experiment.write_measurement({"00": 1024})
experiment.write_measurement({"01": 1024})
experiment.write_metric("t0", 0.1)
experiment.write_parameter("backend", "Tashkent")
experiment.save_exoeriment()