def _run(self):
self.train(self._training_dataset[0], self._training_dataset[1])
if self._test_dataset is not None:
self.test(self._test_dataset[0], self._test_dataset[1])
if self._datapoints is not None:
predicted_probs, predicted_labels = self.predict(self._datapoints)
self._ret['predicted_classes'] = map_label_to_class_name(
predicted_labels, self._label_to_class)
return self._ret
def _run(self):
self.train(self._training_dataset[0], self._training_dataset[1])
if self._test_dataset is not None:
self.test(self._test_dataset[0], self._test_dataset[1])
if self._datapoints is not None:
_, predicted_labels = self.predict(self._datapoints)
self._ret['predicted_classes'] = map_label_to_class_name(predicted_labels,
self._label_to_class)
self.cleanup_parameterized_circuits()
return self._ret
def run(self):
"""
put the train, test, predict together
"""
self.train(self._qalgo.training_dataset[0], self._qalgo.training_dataset[1])
if self._qalgo.test_dataset is not None:
self.test(self._qalgo.test_dataset[0], self._qalgo.test_dataset[1])
if self._qalgo.datapoints is not None:
predicted_labels = self.predict(self._qalgo.datapoints)
predicted_classes = map_label_to_class_name(predicted_labels, self._qalgo.label_to_class)
self._ret['predicted_classes'] = predicted_classes
return self._ret
reps=2,
entanglement='linear')
qsvm = QSVM(feature_map, training_input, test_input, datapoints[0])
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed)
result = qsvm.run(quantum_instance)
print("testing success ratio: {}".format(result['testing_accuracy']))
print("preduction of datapoints:")
print("ground truth: {}".format(
map_label_to_class_name(datapoints[1], qsvm.label_to_class)))
print("prediction: {}".format(result['predicted_classes']))
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),
interpolation='nearest',
origin='upper',
cmap='bone_r')
plt.show()
sample_Total, training_input, test_input, class_labels = breast_cancer(
training_size=20, test_size=10, n=2, plot_data=True)
seed = 10598
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
gap=0.3,
plot_data=True)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
print(class_to_label)
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(max_trials=100, c0=4.0, skip_calibration=True)
optimizer.set_options(save_steps=1)
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2)
var_form = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=3)
vqc = VQC(optimizer, feature_map, var_form, training_input, test_input)
quantum_instance = QuantumInstance(backend,
shots=shots,
seed_simulator=random_seed,
seed_transpiler=random_seed)
result = vqc.run(quantum_instance)
print("testing success ratio: ", result['testing_accuracy'])
predicted_probs, predicted_labels = vqc.predict(datapoints[0])
predicted_classes = map_label_to_class_name(predicted_labels,
vqc.label_to_class)
print("prediction: {}".format(predicted_labels))
# testing success ratio: 1.0
# sumber = https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/machine_learning/vqc.ipynb
print("testing success ratio: ", result['testing_accuracy'])
print("predicted classes:", result['predicted_classes'])
sample_Total, training_input, test_input, class_labels = breast_cancer(
training_size=20, test_size=10, n=2, plot_data=True
)
# n =2 is the dimension of each data point
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
label_to_class = {label:class_name for class_name, label in class_to_label.items()}
print(class_to_label, label_to_class)
result = SklearnSVM(training_input, test_input, datapoints[0]).run()
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r')
plt.show()
print("testing success ratio: ", result['testing_accuracy'])
print("ground truth: {}".format(map_label_to_class_name(datapoints[1], label_to_class)))
print("predicted: {}".format(result['predicted_classes']))
# testing success ratio: 0.85
# sumber = https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/machine_learning/svm_classical.ipynb
vqc = VQC(optimizer, feature_map, var_form, train_input, test_input,
datapoints[0])
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
print('Prediction from datapoints set:')
print(
f' ground truth: {map_label_to_class_name(datapoints[1], vqc.label_to_class)}'
)
print(f' prediction: {result["predicted_classes"]}')
a = map_label_to_class_name(datapoints[1], vqc.label_to_class)
b = result["predicted_classes"]
r = len(a)
result = {}
for i in range(r):
if a[i] == b[i]:
if a[i] not in result:
result[a[i]] = 1
else:
result[a[i]] += 1
a1 = (result['A'] / a.count('A')) * 100
b1 = (result['B'] / a.count('B')) * 100
print(
f'The background rejection:{round(a1,3)}%.The signal efficiency:{round(b1,3)}%'
