def test_qgan_save_model(self):
"""Test the QGAN functionality to store the current model."""
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
num_epochs = 5
with tempfile.TemporaryDirectory() as tmpdirname:
_qgan = QGAN(
self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
discriminator=NumPyDiscriminator(n_features=len(num_qubits)),
snapshot_dir=tmpdirname)
_qgan.seed = self.seed
_qgan.set_generator()
trained_statevector = _qgan.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
trained_qasm = _qgan.run(
QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
self.assertAlmostEqual(trained_qasm['rel_entr'],
trained_statevector['rel_entr'],
delta=0.1)
def test_qgan_training_run_algo_numpy(self):
"""Test QGAN training using a NumPy discriminator."""
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
num_epochs = 5
_qgan = QGAN(
self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
discriminator=NumPyDiscriminator(n_features=len(num_qubits)),
snapshot_dir=None)
_qgan.seed = self.seed
_qgan.set_generator()
trained_statevector = _qgan.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
trained_qasm = _qgan.run(
QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
self.assertAlmostEqual(trained_qasm['rel_entr'],
trained_statevector['rel_entr'],
delta=0.1)
def setUp(self):
super().setUp()
self.seed = 7
algorithm_globals.random_seed = self.seed
# Number training data samples
n_v = 5000
# Load data samples from log-normal distribution with mean=1 and standard deviation=1
m_u = 1
sigma = 1
self._real_data = algorithm_globals.random.lognormal(mean=m_u,
sigma=sigma,
size=n_v)
# Set upper and lower data values as list of k
# min/max data values [[min_0,max_0],...,[min_k-1,max_k-1]]
self._bounds = [0.0, 3.0]
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
# num_epochs = 10
num_epochs = 5
# Initialize qGAN
self.qgan = QGAN(
self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
snapshot_dir=None,
)
self.qgan.seed = 7
# Set quantum instance to run the quantum generator
self.qi_statevector = QuantumInstance(
backend=BasicAer.get_backend("statevector_simulator"),
seed_simulator=2,
seed_transpiler=2,
)
self.qi_qasm = QuantumInstance(
backend=BasicAer.get_backend("qasm_simulator"),
shots=1000,
seed_simulator=2,
seed_transpiler=2,
)
# Set entangler map
entangler_map = [[0, 1]]
qc = QuantumCircuit(sum(num_qubits))
qc.h(qc.qubits)
ansatz = RealAmplitudes(sum(num_qubits),
reps=1,
entanglement=entangler_map)
qc.compose(ansatz, inplace=True)
self.generator_circuit = qc
def test_qgan_training_run_algo_numpy_multivariate(self):
"""Test QGAN training using a NumPy discriminator, for multivariate distributions."""
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [1, 2]
# Batch size
batch_size = 100
# Set number of training epochs
num_epochs = 5
# Reshape data in a multi-variate fashion
# (two independent identically distributed variables,
# each represented by half of the generated samples)
real_data = self._real_data.reshape((-1, 2))
bounds = [self._bounds, self._bounds]
_qgan = QGAN(
real_data,
bounds,
num_qubits,
batch_size,
num_epochs,
discriminator=NumPyDiscriminator(n_features=len(num_qubits)),
snapshot_dir=None,
)
_qgan.seed = self.seed
_qgan.set_generator()
trained_statevector = _qgan.run(
QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
))
trained_qasm = _qgan.run(
QuantumInstance(
BasicAer.get_backend("qasm_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
))
self.assertAlmostEqual(trained_qasm["rel_entr"],
trained_statevector["rel_entr"],
delta=0.1)
def test_qgan_gradient_penalty_pytorch(self):
"""
Test QGAN training with gradient penalty for the discriminator
"""
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
num_epochs = 5
_qgan = QGAN(
self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
discriminator=PyTorchDiscriminator(n_features=len(num_qubits)),
snapshot_dir=None,
penalty=True,
)
_qgan.seed = self.seed
_qgan.set_generator()
trained_statevector = _qgan.run(
QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
))
trained_qasm = _qgan.run(
QuantumInstance(
BasicAer.get_backend("qasm_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
))
self.assertAlmostEqual(trained_qasm["rel_entr"],
trained_statevector["rel_entr"],
delta=0.1)
