def convert_interaction_op_to_dict(op: InteractionOperator) -> dict:
"""Convert an InteractionOperator to a dictionary.
Args:
op (openfermion.ops.InteractionOperator): the operator
Returns:
dictionary (dict): the dictionary representation
"""
dictionary = {"schema": SCHEMA_VERSION + "-interaction_op"}
dictionary["constant"] = convert_array_to_dict(np.array(op.constant))
dictionary["one_body_tensor"] = convert_array_to_dict(np.array(op.one_body_tensor))
dictionary["two_body_tensor"] = convert_array_to_dict(np.array(op.two_body_tensor))
return dictionary
def test_orquestra_encoder_can_handle_numpy_arrays():
dict_to_serialize = {
"array_1": np.array([1, 2, 3]),
"array_2": np.array([0.5 + 1j, 0.5 - 0.25j]),
"list_of_arrays": [np.array([0.5, 0.4, 0.3]), np.array([1, 2, 3])],
}
deserialized_dict = json.loads(json.dumps(dict_to_serialize, cls=OrquestraEncoder))
expected_deserialized_dict = {
"array_1": convert_array_to_dict(dict_to_serialize["array_1"]),
"array_2": convert_array_to_dict(dict_to_serialize["array_2"]),
"list_of_arrays": [
convert_array_to_dict(arr) for arr in dict_to_serialize["list_of_arrays"]
],
}
assert deserialized_dict == expected_deserialized_dict
def save_optimization_results(optimization_results, filename):
"""Save a dict to a file.
Args:
optimization_results (dict): the dict to be saved
filename (str): the name of the file
"""
data = {}
data['schema'] = SCHEMA_VERSION + '-optimization_result'
for key in optimization_results:
if key != 'history':
if type(optimization_results[key]) == np.ndarray:
data[key] = optimization_results[key].tolist()
elif type(optimization_results[key]) == bytes:
data[key] = optimization_results[key].decode("utf-8")
else:
data[key] = optimization_results[key]
if optimization_results.get('history'):
data['history'] = []
for step in optimization_results['history']:
if 'optimization-evaluation-ids' in step.keys():
evaluation = {
'value':
step.get('value'),
'params':
convert_array_to_dict(step['params']),
'optimization-evaluation-ids':
step['optimization-evaluation-ids']
}
if 'bitstring_distribution' in step.keys():
evaluation['bitstring_distribution'] = step[
'bitstring_distribution']
data['history'].append(evaluation)
else:
evaluation = {
'value': step.get('value'),
'params': convert_array_to_dict(step['params'])
}
if 'bitstring_distribution' in step.keys():
evaluation['bitstring_distribution'] = step[
'bitstring_distribution']
data['history'].append(evaluation)
with open(filename, 'w') as f:
f.write(json.dumps(data, indent=2))
def save_kraus_operators(kraus: dict, filename: str) -> None:
"""Save a kraus operator to file
Args:
kraus (Dict): Has single qubit and two qubit kraus operators
filename (str): the name of the file
"""
for gate in kraus.keys():
for operator_index in range(len(kraus[gate])):
kraus[gate][operator_index] = convert_array_to_dict(kraus[gate][operator_index])
kraus['schema'] = SCHEMA_VERSION +'kraus-dict'
with open(filename, 'w') as f:
f.write(json.dumps(kraus, indent=2))
BitstringDistribution({
"111": 0.25,
"010": 0.75
}),
},
),
],
)
EXPECTED_DESERIALIZED_RESULT = {
"schema":
"zapata-v1-optimization_result",
"opt_value":
0.5,
"opt_params":
convert_array_to_dict(np.array([0, 0.5, 2.5])),
"nit":
3,
"fev":
10,
"history": [
{
"call_number": 0,
"params": convert_array_to_dict(np.array([0.1, 0.2, 0.3j])),
"value": ValueEstimate(0.5, precision=6).to_dict(),
},
{
"call_number": 1,
"params": convert_array_to_dict(np.array([1, 2, 3])),
"value": -10.0,
},
def test_complex_array_conversion(self):
arr = np.array([[1.0, 2.0], [3.0, 4.0j]])
dictionary = convert_array_to_dict(arr)
new_arr = convert_dict_to_array(dictionary)
assert np.allclose(arr, new_arr)
