def test_parameter_prefix(self):
"""Test the Parameter prefix"""
encoding_pauli = PauliFeatureMap(feature_dimension=2,
reps=2,
paulis=["ZY"],
parameter_prefix="p")
encoding_z = ZFeatureMap(feature_dimension=2,
reps=2,
parameter_prefix="q")
encoding_zz = ZZFeatureMap(feature_dimension=2,
reps=2,
parameter_prefix="r")
x = ParameterVector("x", 2)
y = Parameter("y")
self.assertEqual(
str(encoding_pauli.parameters),
"ParameterView([ParameterVectorElement(p[0]), ParameterVectorElement(p[1])])",
)
self.assertEqual(
str(encoding_z.parameters),
"ParameterView([ParameterVectorElement(q[0]), ParameterVectorElement(q[1])])",
)
self.assertEqual(
str(encoding_zz.parameters),
"ParameterView([ParameterVectorElement(r[0]), ParameterVectorElement(r[1])])",
)
encoding_pauli_param_x = encoding_pauli.assign_parameters(x)
encoding_z_param_x = encoding_z.assign_parameters(x)
encoding_zz_param_x = encoding_zz.assign_parameters(x)
self.assertEqual(
str(encoding_pauli_param_x.parameters),
"ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1])])",
)
self.assertEqual(
str(encoding_z_param_x.parameters),
"ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1])])",
)
self.assertEqual(
str(encoding_zz_param_x.parameters),
"ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1])])",
)
encoding_pauli_param_y = encoding_pauli.assign_parameters({1, y})
encoding_z_param_y = encoding_z.assign_parameters({1, y})
encoding_zz_param_y = encoding_zz.assign_parameters({1, y})
self.assertEqual(str(encoding_pauli_param_y.parameters),
"ParameterView([Parameter(y)])")
self.assertEqual(str(encoding_z_param_y.parameters),
"ParameterView([Parameter(y)])")
self.assertEqual(str(encoding_zz_param_y.parameters),
"ParameterView([Parameter(y)])")
def run_exp(
method='qrac',
epochs=300,
positive_factor=1 / 3,
depth=4,
seed=10598,
reg=0.,
model_directory=None,
result_directory=None,
real_device=False,
):
assert method in [
'qrac', 'qrac_zz', 'te', 'te_zz', 'zz_dis', 'zz_dis_cont'
], f"method {method} not exist"
if model_directory is None:
model_directory = f'models/Titanic_{method}_{epochs}_{positive_factor}_{depth}_{seed}_{reg}_model'
if result_directory is None:
result_directory = f'results/Titanic_{method}_{epochs}_{positive_factor}_{depth}_{seed}_{reg}_result'
all_discrete = method in ['qrac', 'te', 'zz_dis']
df_train, _, y_train, _ = load_titanic_pd('data/Titanic_train.csv',
'data/Titanic_test.csv',
as_category=all_discrete)
# Get mvp column
mvp_col = ['Sex', 'Age', 'Pclass', 'Fare']
df_train = df_train[mvp_col]
vqc_gen = None
feature_map = None
var_form = None
X_train = None
if method in ['zz_dis']:
X_train = df_train.values
feature_map = ZZFeatureMap(4)
var_form = RYRZ(4, depth=depth)
vqc_gen = VQC
if method in ['zz_dis_cont']:
df_train['Fare'] = np.log(df_train['Fare'] + 1)
df_train['Age'] = df_train['Age'] / 60
X_train = df_train.values
feature_map = ZZFeatureMap(4)
var_form = RYRZ(4, depth=depth)
vqc_gen = VQC
if method in ['qrac', 'te']:
X_train = binary_encoder(df_train.values)
print(X_train)
num_qubit = len(X_train[0]) // 3
if method == 'qrac':
feature_map = CustomFeatureMap('ALL3in1', 1, num_qubit)
var_form = RYRZ(num_qubit, depth=depth)
vqc_gen = VQC
if method == 'te':
feature_map = QuantumCircuit(num_qubit)
var_form = MyRYRZ(num_qubit, depth=depth)
vqc_gen = MyVQC
if method in ['qrac_zz']:
df_train['Fare'] = np.log(df_train['Fare'] + 1)
df_train['Age'] = df_train['Age'] / 60
X_train_num = U3gate_input_encoder(df_train[['Sex', 'Pclass']].values)
X_train_con = df_train[['Age', 'Fare']].values
X_train = np.concatenate([X_train_con, X_train_num], axis=1)
X = [Parameter(f'x[{i}]') for i in range(X_train_num.shape[1])]
qr = QuantumRegister(1, 'cat')
qc = QuantumCircuit(qr)
for i in range(1):
qc.u3(X[2 * i], X[2 * i + 1], 0, i)
feature_map_cat = qc
X1 = Parameter('x[2]')
X2 = Parameter('x[3]')
feature_map_con = ZZFeatureMap(2)
feature_map_con = feature_map_con.assign_parameters([X1, X2])
feature_map = feature_map_con.combine(feature_map_cat)
var_form = RYRZ(3, depth=depth)
vqc_gen = VQC
if method in ['te_zz']:
df_train['Fare'] = np.log(df_train['Fare'] + 1)
df_train['Age'] = df_train['Age'] / 60
X_train_num = binary_encoder(df_train[['Sex', 'Pclass']].values)
X_train_con = df_train[['Age', 'Fare']].values
print(X_train_num[:, None])
print(X_train_con)
X_train = np.array([[x, y] for x, y in zip(X_train_num, X_train_con)])
X1 = Parameter('x[0]')
X2 = Parameter('x[1]')
feature_map_con = ZZFeatureMap(2)
feature_map_con = feature_map_con.assign_parameters([X1, X2])
qr = QuantumRegister(1, 'cat')
feature_map_num = QuantumCircuit(qr)
feature_map = feature_map_num.combine(feature_map_con)
var_form = MyRYRZ_zz(1, 2, depth=depth)
vqc_gen = MyVQC_zz
assert feature_map is not None, "Feature map is none"
assert var_form is not None, "Varform is none"
if real_device:
# Please fix these line...
provider = IBMQ.get_provider()
backend = provider.get_backend('ibmq_london')
else:
backend = QasmSimulator({"method": "statevector_gpu"})
def optimizer_gen():
return SPSA(epochs)
result = kfold_vqc(feature_map,
var_form,
backend,
optimizer_gen,
seed,
X_train,
y_train,
model_directory=model_directory,
result_directory=result_directory,
k=4,
positivedata_duplicate_ratio=positive_factor,
vqc_gen=vqc_gen)
return_result = {
'train_acc': result['Training accuracies (mean)'][-1],
'train_f1': result['Training F1 scores (mean)'][-1],
'test_acc': result['Test accuracies (mean)'][-1],
'test_f1': result['Test F1 scores (mean)'][-1]
}
return return_result
def setUp(self):
super().setUp()
self.seed = 1376
aqua_globals.random_seed = self.seed
self.training_data = {
'A': np.asarray([[2.95309709, 2.51327412],
[3.14159265, 4.08407045]]),
'B': np.asarray([[4.08407045, 2.26194671],
[4.46106157, 2.38761042]])
}
self.testing_data = {
'A': np.asarray([[3.83274304, 2.45044227]]),
'B': np.asarray([[3.89557489, 0.31415927]])
}
self.ref_opt_params = np.array([
10.03814083, -12.22048954, -7.58026833, -2.42392954, 12.91555293,
13.44064652, -2.89951454, -10.20639406, 0.81414546, -1.00551752,
-4.7988307, 14.00831419, 8.26008064, -7.07543736, 11.43368677,
-5.74857438
])
self.ref_train_loss = 0.69366523
self.ref_prediction_a_probs = [[0.79882812, 0.20117188]]
self.ref_prediction_a_label = [0]
# ignore warnings from creating VariationalForm and FeatureMap objects
warnings.filterwarnings('ignore', category=DeprecationWarning)
var_form_ryrz = RYRZ(2, depth=3)
feature_map = SecondOrderExpansion(2, depth=2)
warnings.filterwarnings('always', category=DeprecationWarning)
library_ryrz = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
theta = ParameterVector('theta', var_form_ryrz.num_parameters)
circuit_ryrz = var_form_ryrz.construct_circuit(theta)
resorted = []
for i in range(4):
layer = library_ryrz.ordered_parameters[4 * i:4 * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
library_ryrz.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
self._sorted_wavefunction_params = list(theta)
self.ryrz_wavefunction = {
'wrapped': var_form_ryrz,
'circuit': circuit_ryrz,
'library': library_ryrz
}
library_circuit = ZZFeatureMap(2, reps=2)
x = ParameterVector('x', 2)
circuit = feature_map.construct_circuit(x)
self._sorted_data_params = list(x)
library_circuit.assign_parameters(x, inplace=True)
self.data_preparation = {
'wrapped': feature_map,
'circuit': circuit,
'library': library_circuit
}
