def find_valid_y_time_ntimes(self):
valid_y_info_dic = {} #sample:[occurrences, chain_break_fraction]
calculation_time = 0
for _ in range(self.n):
s3_destination_folder = ('amazon-braket-ecc806acea4c',
'qaExactLogisticRegression_ssato')
dw = BraketDWaveSampler(
s3_destination_folder,
device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6')
qa_sampler = AutoEmbeddingComposite(dw)
res = qa_sampler.sample(self.bqm,
chain_strength=self.chain_strength,
chain_break_fraction=True,
num_reads=self.num_reads)
for sample, energy, num_occurrences, chain_break_fraction in res.data(
[
'sample', 'energy', 'num_occurrences',
'chain_break_fraction'
]):
if energy == 0.0:
sample_tuple = tuple(sample.values())
if sample_tuple in list(valid_y_info_dic.keys()):
valid_y_info_dic[sample_tuple][0] += num_occurrences
else:
valid_y_info_dic[sample_tuple] = [
num_occurrences, chain_break_fraction
]
calculation_time += res.info['additionalMetadata'][
'dwaveMetadata']['timing']['qpuAccessTime'] * 10**(-6)
return valid_y_info_dic, calculation_time
class QPUSubproblemAutoEmbeddingSampler(traits.SubproblemSampler, traits.SISO, Runnable):
r"""A quantum sampler for a subproblem with automated heuristic
minor-embedding.
Args:
num_reads (int, optional, default=100):
Number of states (output solutions) to read from the sampler.
qpu_sampler (:class:`dimod.Sampler`, optional, default=\ :class:`~dwave.system.samplers.DWaveSampler`\ ()):
Quantum sampler such as a D-Wave system. Subproblems that do not fit the
sampler's structure are minor-embedded on the fly with
:class:`~dwave.system.composites.AutoEmbeddingComposite`.
sampling_params (dict):
Dictionary of keyword arguments with values that will be used
on every call of the (embedding-wrapped QPU) sampler.
auto_embedding_params (dict, optional):
If provided, parameters are passed to the
:class:`~dwave.system.composites.AutoEmbeddingComposite` constructor
as keyword arguments.
See :ref:`samplers-examples`.
"""
def __init__(self, num_reads=100, qpu_sampler=None, sampling_params=None,
auto_embedding_params=None, **runopts):
super(QPUSubproblemAutoEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if qpu_sampler is None:
qpu_sampler = DWaveSampler()
if sampling_params is None:
sampling_params = {}
self.sampling_params = sampling_params
# embed on the fly and only if needed
if auto_embedding_params is None:
auto_embedding_params = {}
self.sampler = AutoEmbeddingComposite(qpu_sampler, **auto_embedding_params)
def __repr__(self):
return ("{self}(num_reads={self.num_reads!r}, "
"qpu_sampler={self.sampler!r}, "
"sampling_params={self.sampling_params!r})").format(self=self)
def next(self, state, **runopts):
num_reads = runopts.get('num_reads', self.num_reads)
sampling_params = runopts.get('sampling_params', self.sampling_params)
params = sampling_params.copy()
params.update(num_reads=num_reads)
response = self.sampler.sample(state.subproblem, **params)
return state.updated(subsamples=response)
class ReverseAnnealingAutoEmbeddingSampler(traits.SubproblemSampler, traits.SISO, Runnable):
"""A quantum reverse annealing sampler for a subproblem with automated
heuristic minor-embedding.
Args:
num_reads (int, optional, default=100):
Number of states (output solutions) to read from the sampler.
qpu_sampler (:class:`dimod.Sampler`, optional,
default=:class:`AutoEmbeddingComposite`(:class:`DWaveSampler`())):
Quantum sampler such as a D-Wave system. Subproblems that do not fit
the sampler's structure are minor-embedded on the fly with
:class:`~dwave.system.composites.AutoEmbeddingComposite`.
anneal_schedule (list(list), optional, default=[[0, 1], [0.5, 0.5], [1, 1]]):
An anneal schedule defined by a series of pairs of floating-point
numbers identifying points in the schedule at which to change slope.
The first element in the pair is time t in microseconds; the second,
normalized persistent current s in the range [0,1]. The resulting
schedule is the piecewise-linear curve that connects the provided
points. For more details, see
:meth:`~dwave.system.DWaveSampler.validate_anneal_schedule`.
"""
def __init__(self, num_reads=100, qpu_sampler=None, anneal_schedule=None, **runopts):
super(ReverseAnnealingAutoEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if anneal_schedule is None:
anneal_schedule = [[0, 1], [0.5, 0.5], [1, 1]]
self.anneal_schedule = anneal_schedule
if qpu_sampler is None:
qpu_sampler = DWaveSampler(
solver={'max_anneal_schedule_points__gte': len(self.anneal_schedule)})
# validate schedule, raising `ValueError` on invalid schedule or
# `RuntimeError` if anneal schedule not supported by QPU (this could
# happen only if user provided the `qpu_sampler`)
qpu_sampler.validate_anneal_schedule(anneal_schedule)
# embed on fly and only if needed
self.sampler = AutoEmbeddingComposite(qpu_sampler)
def __repr__(self):
return ("{self}(num_reads={self.num_reads!r}, "
"qpu_sampler={self.sampler!r}, "
"anneal_schedule={self.anneal_schedule!r})").format(self=self)
def next(self, state, **runopts):
# TODO: handle more than just the first subsample (not yet supported via API)
subsamples = self.sampler.sample(
state.subproblem, num_reads=self.num_reads,
initial_state=state.subsamples.first.sample,
anneal_schedule=self.anneal_schedule)
return state.updated(subsamples=subsamples)
class QPUSubproblemAutoEmbeddingSampler(Runnable, traits.SubproblemSampler):
"""A quantum sampler for a subproblem with automated heuristic
minor-embedding.
Args:
num_reads (int, optional, default=100):
Number of states (output solutions) to read from the sampler.
qpu_sampler (:class:`dimod.Sampler`, optional,
default=:class:`AutoEmbeddingComposite`(:class:`DWaveSampler`())):
Quantum sampler such as a D-Wave system. Subproblems that do not fit
the sampler's structure are minor-embedded on the fly with
:class:`~dwave.system.composites.AutoEmbeddingComposite`.
qpu_params (dict):
Dictionary of keyword arguments with values that will be used
on every call of the QPU sampler.
See :ref:`samplers-examples`.
"""
def __init__(self,
num_reads=100,
qpu_sampler=None,
qpu_params=None,
**runopts):
super(QPUSubproblemAutoEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if qpu_sampler is None:
qpu_sampler = DWaveSampler()
# embed on fly and only if needed
self.sampler = AutoEmbeddingComposite(qpu_sampler)
if qpu_params is None:
qpu_params = {}
self.qpu_params = qpu_params
def __repr__(self):
return ("{self}(num_reads={self.num_reads!r}, "
"qpu_sampler={self.sampler!r}, "
"qpu_params={self.qpu_params!r})").format(self=self)
def next(self, state, **runopts):
num_reads = runopts.get('num_reads', self.num_reads)
qpu_params = runopts.get('qpu_params', self.qpu_params)
params = qpu_params.copy()
params.update(num_reads=num_reads)
response = self.sampler.sample(state.subproblem, **params)
return state.updated(subsamples=response)
def aws_get_response(bqm, chain_strength, num_reads):
s3_destination_folder = ('amazon-braket-ecc806acea4c',
'qaExactLogisticRegression_ssato')
dw = BraketDWaveSampler(
s3_destination_folder,
device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6')
qa_sampler = AutoEmbeddingComposite(dw)
res = qa_sampler.sample(bqm,
chain_strength=chain_strength,
chain_break_fraction=True,
num_reads=num_reads)
return res
def pyqubo_response(df, param_a, param_b, param_c, num_reads, do_qbsolve):
t_list = calc_marginals(df)
#make H
N = len(df)
Y = Array.create('Y', shape=N, vartype='BINARY')
ysum = sum(y for y in Y)
H_0 = (ysum - t_list[0])**2
sex = df['SEX'].values.tolist()
sex_array = sum(s * y for s, y in zip(sex, Y))
H_1 = (sex_array - t_list[1])**2
aop = df['AOP'].values.tolist()
aop_array = sum(a * y for a, y in zip(aop, Y))
H_2 = (aop_array - t_list[2])**2
alpha = Placeholder("alpha")
beta = Placeholder("beta")
gamma = Placeholder("gamma")
H = alpha * H_0 + beta * H_1 + gamma * H_2
#パラメータ
feed_dict = {'alpha': param_a, 'beta': param_b, 'gamma': param_c}
#QUBOのコンパイル
model = H.compile()
qubo, offset = model.to_qubo(feed_dict=feed_dict)
if do_qbsolve == True:
res = QBSolv().sample_qubo(qubo, num_reads=num_reads)
else:
s3_destination_folder = ('amazon-braket-ecc806acea4c',
'qaExactLogisticRegression_ssato')
dw = BraketDWaveSampler(
s3_destination_folder,
device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6')
qa_sampler = AutoEmbeddingComposite(dw)
res = qa_sampler.sample(bqm,
chain_strength=chain_strength,
auto_scale=True,
chain_break_fraction=True,
num_reads=num_reads)
return res
def p_value_transition(self, output_path):
t1 = int(np.dot(self.df['Y'], self.df['LI']))
t1_y = 0
p_dic = {}
valid_y_list = []
for _ in range(self.n):
s3_destination_folder = ('amazon-braket-ecc806acea4c',
'qaExactLogisticRegression_ssato')
dw = BraketDWaveSampler(
s3_destination_folder,
device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6')
qa_sampler = AutoEmbeddingComposite(dw)
res = qa_sampler.sample(self.bqm,
chain_strength=self.chain_strength,
chain_break_fraction=True,
num_reads=self.num_reads)
for sample, energy, num_occurrences, chain_break_fraction in res.data(
[
'sample', 'energy', 'num_occurrences',
'chain_break_fraction'
]):
if energy == 0.:
this_time_y = tuple(sample.values())
if this_time_y in valid_y_list:
continue
else:
valid_y_list.append(this_time_y) #
this_time_y_se = pd.Series(this_time_y)
if int(np.dot(this_time_y_se, self.df['LI'])) == t1:
t1_y += 1
p_dic[len(valid_y_list)] = t1_y / len(valid_y_list)
plt.xlabel('number of valid y')
plt.ylabel('p value')
plt.plot(list(p_dic.keys()), list(p_dic.values()))
plt.savefig(output_path)
plt.show()
plt.close()
return valid_y_list, p_dic
def num_y_transition(self, path):
time_list = [] #
valid_y_num_nodup = {}
time_0 = time.time()
for _ in range(self.n):
s3_destination_folder = ('amazon-braket-ecc806acea4c',
'qaExactLogisticRegression_ssato')
dw = BraketDWaveSampler(
s3_destination_folder,
device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6')
qa_sampler = AutoEmbeddingComposite(dw)
res = qa_sampler.sample(self.bqm,
chain_strength=self.chain_strength,
chain_break_fraction=True,
num_reads=self.num_reads)
for sample, energy, num_occurrences, chain_break_fraction in res.data(
[
'sample', 'energy', 'num_occurrences',
'chain_break_fraction'
]):
if energy == 0.:
sample_tuple = tuple(sample.values())
if sample_tuple in list(valid_y_num_nodup.keys()):
continue
else:
valid_y_num_nodup[sample_tuple] = 1
time_1 = time.time()
elapsed_time = time_1 - time_0
time_list.append(elapsed_time)
valid_y_num_list = [i for i in range(1, len(valid_y_num_nodup) + 1)]
plt.xlabel('time')
plt.ylabel('number of valid y')
plt.plot(time_list, valid_y_num_list)
plt.savefig(path)
plt.show()
plt.close()
return time_list
class ReverseAnnealingAutoEmbeddingSampler(traits.SubproblemSampler,
traits.SubsamplesIntaking,
traits.SISO, Runnable):
r"""A quantum reverse annealing sampler for a subproblem with automated
heuristic minor-embedding.
Args:
num_reads (int, optional, default=100):
Number of states (output solutions) to read from the sampler.
anneal_schedule (list(list), optional, default=[[0, 1], [0.5, 0.5], [1, 1]]):
An anneal schedule defined by a series of pairs of floating-point
numbers identifying points in the schedule at which to change slope.
The first element in the pair is time t in microseconds; the second,
normalized persistent current s in the range [0,1]. The resulting
schedule is the piecewise-linear curve that connects the provided
points. For more details, see
:meth:`~dwave.system.DWaveSampler.validate_anneal_schedule`.
qpu_sampler (:class:`dimod.Sampler`, optional):
Quantum sampler such as a D-Wave system. Subproblems that do not fit
the sampler's structure are minor-embedded on the fly with
:class:`~dwave.system.composites.AutoEmbeddingComposite`.
If sampler is not provided, it defaults to::
qpu_sampler = DWaveSampler(
solver=dict(max_anneal_schedule_points__gte=len(anneal_schedule)))
sampling_params (dict):
Dictionary of keyword arguments with values that will be used
on every call of the (embedding-wrapped QPU) sampler.
auto_embedding_params (dict, optional):
If provided, parameters are passed to the
:class:`~dwave.system.composites.AutoEmbeddingComposite` constructor
as keyword arguments.
"""
def __init__(self, num_reads=100, anneal_schedule=None, qpu_sampler=None,
sampling_params=None, auto_embedding_params=None, **runopts):
super(ReverseAnnealingAutoEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if anneal_schedule is None:
anneal_schedule = [[0, 1], [0.5, 0.5], [1, 1]]
self.anneal_schedule = anneal_schedule
if qpu_sampler is None:
qpu_sampler = DWaveSampler(
solver=dict(max_anneal_schedule_points__gte=len(self.anneal_schedule)))
# validate schedule, raising `ValueError` on invalid schedule or
# `RuntimeError` if anneal schedule not supported by QPU (this could
# happen only if user provided the `qpu_sampler`)
qpu_sampler.validate_anneal_schedule(anneal_schedule)
if sampling_params is None:
sampling_params = {}
self.sampling_params = sampling_params
# embed on the fly and only if needed
if auto_embedding_params is None:
auto_embedding_params = {}
self.sampler = AutoEmbeddingComposite(qpu_sampler, **auto_embedding_params)
def __repr__(self):
return ("{self}(num_reads={self.num_reads!r}, "
"anneal_schedule={self.anneal_schedule!r}, "
"qpu_sampler={self.sampler!r}, "
"sampling_params={self.sampling_params!r})").format(self=self)
def next(self, state, **runopts):
num_reads = runopts.get('num_reads', self.num_reads)
anneal_schedule = runopts.get('anneal_schedule', self.anneal_schedule)
sampling_params = runopts.get('sampling_params', self.sampling_params)
params = sampling_params.copy()
params.update(num_reads=num_reads, anneal_schedule=anneal_schedule)
# TODO: handle more than just the first subsample (not yet supported via API)
subsamples = self.sampler.sample(
state.subproblem, initial_state=state.subsamples.first.sample, **params)
return state.updated(subsamples=subsamples)
