def work(gi, p, s):
low_g, up_g = 0, 2*pi
low_b, up_b = 0, pi/2
G, C, M, k = common.get_complete(gi)
sample_g, sample_b = common.MLHS(p, s, low_g, up_g, low_b, up_b)
bounds = [[low_g,up_g] if j < p else [low_b,up_b] for j in range(2*p)]
eps = 1e-3
best_exp, best_angles = -1, []
total_eval = 0
for i in range(s):
angles = sample_g[i]
angles.extend(sample_b[i])
options = {'disp': None, 'maxfun': 100, 'gtol': eps, 'ftol': eps}
optimal = minimize(qaoa, angles, method='L-BFGS-B', bounds=bounds, args=(G, C, M, k, p), options=options)
total_eval += optimal.nfev
print('total_eval: ' + str(total_eval))
if -optimal.fun > best_exp + eps:
best_exp = -optimal.fun
best_angles = [list(optimal.x)]
print('s: ' + str(i) + ', ' + str(-optimal.fun) + ', angles: ' + str(optimal.x))
elif -optimal.fun > best_exp - eps:
best_angles.append(list(optimal.x))
#print(str(rank) + ', ' + str(best) + ', ' + str(angles))
'''
G, C, M, k = common.get_complete(gi)
options = {'disp': 1, 'maxfun': 100, 'gtol': 1e-2}
optimal = minimize(qaoa, np.array([0.5*pi, 0.1*pi]), method='L-BFGS-B', bounds=[[0,2*pi],[0,pi/2]], args=(G, C, M, k, p), options=options)
print('optimal: ' + str(-optimal.fun))
print('angles: ' + str(optimal.x))
return -optimal.fun, optimal.x
'''
print('')
print(best_exp)
print(best_angles)
return best_exp, best_angles
def dicke_complete(gi):
low_g, up_g = 0, 2
low_b, up_b = 0, 0.2
G, C, M, k = common.get_complete(gi)
eps = 1e-3
exp = []
for p in range(1, 20):
sample_g = np.linspace(up_g, low_g, num=p + 2)
sample_g = sample_g[1:p + 1]
sample_b = np.linspace(low_b, up_b, num=p + 2)
sample_b = sample_b[1:p + 1]
angles = np.append(sample_g, sample_b)
bounds = [[low_g, up_g] if j < p else [low_b, up_b]
for j in range(2 * p)]
opt = {'disp': None, 'gtol': eps, 'ftol': eps}
kwargs = {
'method': 'L-BFGS-B',
'args': (G, C, M, k, p),
'bounds': bounds,
'options': opt
}
optimal = basinhopping(qaoa,
angles,
niter=300,
minimizer_kwargs=kwargs,
disp=False)
print('p: ' + str(p) + '\t' + str(-optimal.fun) + '\t' +
str(optimal.x))
exp.append(-optimal.fun / 9)
pickle.dump(exp, open('data/91.dicke_complete', 'wb'))
def basin(gi, p, s):
low_g, up_g = 0, 2 * pi
low_b, up_b = 0, pi / 2
G, C, M, k = common.get_complete(gi)
bounds = [[low_g, up_g] if j < p else [low_b, up_b] for j in range(2 * p)]
eps = 1e-3
total_eval = 0
best_exp, best_angles = -1, []
while total_eval < s:
angles = [0 for _ in range(2 * p)]
opt = {'disp': None, 'gtol': eps, 'ftol': eps}
kwargs = {
'method': 'L-BFGS-B',
'args': (G, C, M, k, p),
'bounds': bounds,
'options': opt
}
optimal = basinhopping(qaoa,
angles,
niter=200,
minimizer_kwargs=kwargs,
disp=False)
total_eval += optimal.nfev
print(total_eval)
if -optimal.fun > best_exp + eps:
best_exp = -optimal.fun
best_angles = [list(optimal.x)]
elif -optimal.fun > best_exp - eps:
best_angles.append(list(optimal.x))
return best_exp, best_angles
def initial_complete(gi):
low_g, up_g = 0, 2 * pi
low_b, up_b = 0, pi / 2
G, C, M, k = common.get_complete(gi)
eps = 1e-3
avg = []
error = []
size = int(comb(len(G.nodes), k))
print(size)
for p in range(1, 7):
exp, e = [], 0
bounds = [[low_g, up_g] if j < p else [low_b, up_b]
for j in range(2 * p)]
for i in range(size):
angles = [
random.uniform(0, 2 *
pi) if j < p else random.uniform(0, pi / 2)
for j in range(2 * p)
]
opt = {'disp': None, 'gtol': eps, 'ftol': eps}
kwargs = {
'method': 'L-BFGS-B',
'args': (G, C, M, k, p, i),
'bounds': bounds,
'options': opt
}
optimal = basinhopping(qaoa_initial,
angles,
niter=50,
minimizer_kwargs=kwargs,
disp=False)
print('i: ' + str(i) + ', p: ' + str(p) + '\t' +
str(-optimal.fun) + '\t' + str(optimal.x))
exp.append(-optimal.fun / 9)
avg.append(np.average(exp))
error.append(2.576 * np.std(exp) / np.sqrt(size))
print('avg: ' + str(avg) + '\t' + str(error))
pickle.dump([avg, error], open('data/91.initial_complete', 'wb'))
def work(gi, p, s):
low_g, up_g = 0, 2 * pi
low_b, up_b = 0, pi / 2
G, C, M, k = common.get_complete(gi)
bounds = [[low_g, up_g] if j < p else [low_b, up_b] for j in range(2 * p)]
eps = 1e-3
best_exp, best_angles = -1, []
total_eval = 0
while (total_eval < s):
angles = [
random.uniform(low_g, up_g) if j < p else random.uniform(
low_b, up_b) for j in range(2 * p)
]
#optimal = neldermead(G, C, M, k, p, angles, eps)
optimal = lbfgsb(G, C, M, k, p, angles, eps, bounds)
total_eval += optimal.nfev
if -optimal.fun > best_exp + eps:
best_exp = -optimal.fun
best_angles = [list(optimal.x)]
elif -optimal.fun > best_exp - eps:
best_angles.append(list(optimal.x))
return best_exp, best_angles
low_g, up_g = 0, 2*pi
low_b, up_b = 0, pi/2
best_exp = -1
total_eval = 0
while(best_exp < prev_exp):
angles = [random.uniform(low_g, up_g) if j < p else random.uniform(low_b, up_b) for j in range(2*p)]
value = -qaoa(angles, G, C, M, k, p)
if value > best_exp: best_exp = value
total_eval += 1
return best_exp, total_eval
if __name__ == '__main__':
random.seed(4)
gi = random.randint(163,955)
print('gi = ' + str(gi))
G, C, M, k = common.get_complete(gi)
best_sol = common.brute_force(G, k)
s = 50
exp = [0]*s
prev_best = 0
prev = []
samples = []
error = []
for p in range(1,10):
sample_vec = []
for i in range(s):
new_exp, num_samples = next_level(G, C, M, k, p, prev_best)
exp[i] = new_exp
sample_vec.append(num_samples)
if i % 10 == 0: print('\ti: ' + str(i) + '\tavg: ' + str(np.average(sample_vec)) \