def by_amplify(qubits, model, token, timeout=5000):
client = FixstarsClient()
client.token = token
client.parameters.timeout = timeout
solver = Solver(client)
solver.filter_solution = False
result = solver.solve(model)
values = result[0].values
q_values = decode_solution(qubits, values, 1)
return np.where(np.array(q_values) == 1)[1]
def solve_problem(model):
# set client and parameters
client = FixstarsClient()
client.token = "lJLkgFpKzukTUGnr8F3tjrPJZlO8N0bX"
client.parameters.timeout = 5000
# set solver
solver = Solver(client)
# get result
result = solver.solve(model)
# extract value of objective function and binary variables
obj, values = result[0].energy, result[0].values
# get values of constraints
broken = model.check_constraints(values)
return obj, values, broken
def comb1_main(A):
# 数の集合Aに対応する数のリスト
# A = [2, 10, 3, 8, 5, 7, 9, 5, 3, 2]
print(A)
# len(A): 変数の数
n = len(A)
# イジング変数を生成
s = gen_symbols(IsingPoly, n)
# 変数を確認
print(s)
# 目的関数の構築: イジング
f = IsingPoly()
for i in range(n):
# f += s[i] * A[i]
f += s[i] * int(A[i])
f = f**2
# クライアントの設定
client = FixstarsClient()
client.parameters.timeout = 1000 # タイムアウト1秒
# client.token = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # ローカル環境で使用する場合は、Amplify AEのアクセストークンを入力してください
client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙
solver = Solver(client)
result = solver.solve(f)
# 解が得られなかった場合、len(result) == 0
if len(result) == 0:
raise RuntimeError("No solution was found")
energy = result[0].energy
values = result[0].values
# エネルギー値 (f の最小値) を確認
print(f"f = {energy}")
# valuesを確認
# 変数 s_i の i=0, 1, ..., N-1 の値を格納した辞書
print(f"values = {values}")
solution = decode_solution(s, values)
print(solution)
A0 = sorted([A[idx] for idx, val in enumerate(solution) if val != 1])
A1 = sorted([A[idx] for idx, val in enumerate(solution) if val == 1])
print(f"A0 = {A0}")
print(f"A1 = {A1}")
Res0 = f"{A0}"
Res1 = f"{A1}"
return Res0, Res1
def __init__(self, puzzle):
load_dotenv()
self.client = FixstarsClient()
self.client.token = os.getenv("TOKEN")
self.client.parameters.timeout = 10000
self.client.parameters.outputs.duplicate = False
if os.getenv("https_proxy") is not None:
self.client.proxy = os.getenv("https_proxy")
with open(puzzle) as f:
puzzle = parse(f.read())
can_rotate = puzzle.get("can_rotate", True)
can_reverse = puzzle.get("can_reverse", True) if can_rotate else False
pieces_str = list(
map(lambda x: x.split("\n"), puzzle["pieces"].split("\n\n")))
pieces_str = list(
map(lambda p: list(filter(lambda x: '#' in x, p)), pieces_str))
pieces_str = list(filter(lambda x: len(x) != 0, pieces_str))
self.pieces = list()
for p in pieces_str:
self.pieces.append(Piece(p, can_rotate, can_reverse))
board_str = puzzle["board"].split("\n")
self.board = Board(board_str)
def solve(self,
c_weight: float = 3,
timeout: int = 1000,
num_unit_step: int = 10) -> Setlist:
"""
Args:
c_weight (float): 時間制約の強さ
timeout (int, optional): Fixstars AE のタイムアウト[ms] (デフォルト: 10000)
num_unit_step (int, optional): Fixstars AE のステップ数 (デフォルト: 10)
Returns:
Setlist: セットリスト
"""
self.q = gen_symbols(BinaryPoly, self.num_tracks)
energy_function = self.energy(c_weight)
model = BinaryQuadraticModel(energy_function)
fixstars_client = FixstarsClient()
fixstars_client.token = os.environ.get("FIXSTARS_API_TOKEN")
fixstars_client.parameters.timeout = timeout
fixstars_client.parameters.num_unit_steps = num_unit_step
amplify_solver = Solver(fixstars_client)
amplify_solver.filter_solution = False
result = amplify_solver.solve(model)
q_values = decode_solution(self.q, result[0].values)
tracks = [self.candidates[i] for i, v in enumerate(q_values) if v == 1]
total_time = 0
user_scores = np.zeros(self.num_users)
for track in tracks:
user_scores += np.array(track.p)
total_time += track.duration_ms
return Setlist(tracks=tracks,
scores=user_scores.tolist(),
score_sum=user_scores.sum(),
score_avg=user_scores.mean(),
score_var=user_scores.var(),
total_time=total_time)
from amplify import IsingPoly, gen_symbols, Solver, decode_solution
from amplify.client import FixstarsClient
# クライアントの設定
client = FixstarsClient() # Fixstars Optigan
client.parameters.timeout = 1000 # タイムアウト1秒
client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効
client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙するオプション（解が複数個ある場合）
# 数の集合Aに対応する数のリスト
A = [2, 10, 3, 8, 5, 7, 9, 5, 3, 2]
# len(A): 変数の数
n = len(A)
# イジング変数を生成
s = gen_symbols(IsingPoly, n)
# 目的関数の構築: イジング
f = IsingPoly()
for i in range(n):
f += s[i] * A[i]
f = f ** 2
# ソルバーの構築
solver = Solver(client)
# 問題を入力してマシンを実行
result = solver.solve(f)
# 目的関数: 各回転位相の偏光角の変化の違いを小さくするためのもの
obj_pa_diff = 0.0
coef = 1.0 / 180.0
for j in range(len(pa_diff_test)):
obj_pa_diff_j = pa_diff_test[j][1]
for i in range(len(pa_diff_data)):
obj_pa_diff_j -= pa_diff_data[i][2][j][1] * q[i]
obj_pa_diff += coef**2 * obj_pa_diff_j**2
H = 1.0 * const_onehot + 1.0 * obj_pa + 1.0 * obj_pa_diff
# クライアントの設定
client = FixstarsClient()
client.parameters.timeout = 1000
# client.token = ""
# ソルバーの構築
solver = Solver(client)
# 問題を入力してマシンを実行
result = solver.solve(H)
# 出力
for sol in result:
solution = decode_solution(q, sol.values)
count = 0
index = -1
def find_feasible_solution(self):
"""find a feasible locations with makespan, found -> set self.used_edges
"""
# create variables
q = []
index = 0
for t in range(self.makespan):
q.append([])
for v in range(self.field["size"]):
l = len(self.field["adj"][v])+1 # +1 -> stay at the current location
q[-1].append(
amplify.gen_symbols( amplify.BinaryPoly, index, (1, l) )
)
index += l
# set starts
constraints_starts = [
equal_to(sum_poly( q[0][v][0] ), 1) # q[timestep][node][0]
for v in self.instance["starts"]
]
for v in range(self.field["size"]):
if v in self.instance["starts"]:
continue
# other locations
for i in range(len(q[0][v][0])):
q[0][v][0][i] = amplify.BinaryPoly(0)
# set goals
constraints_goals = [
equal_to(sum_poly([ q[-1][u][0][ self.field["adj"][u].index(v) ]
for u in self.field["adj"][v] ] +
[ q[-1][v][0][ len(self.field["adj"][v]) ] ]),
1)
for v in self.instance["goals"]
]
for v in range(self.field["size"]):
# other locations
for i in range(len(self.field["adj"][v])):
if self.field["adj"][v][i] not in self.instance["goals"]:
q[-1][v][0][i] = amplify.BinaryPoly(0)
if v not in self.instance["goals"]:
q[-1][v][0][-1] = amplify.BinaryPoly(0)
# upper bound, in
constraints_in = [
less_equal(sum_poly([ q[t][u][0][ self.field["adj"][u].index(v) ]
for u in self.field["adj"][v] ] +
[ q[t][v][0][ len(self.field["adj"][v]) ] ]),
1)
for v, t in product(range(self.field["size"]), range(0, self.makespan-1))
]
# upper bound, out
constraints_out = [
less_equal(sum_poly( q[t][v][0] ),
1)
for v, t in product(range(self.field["size"]), range(1, self.makespan))
]
# continuity
constraints_continuity = [
equal_to(sum_poly([ q[t][u][0][ self.field["adj"][u].index(v) ]
for u in self.field["adj"][v] ] +
[ q[t][v][0][ len(self.field["adj"][v]) ] ])
-
sum_poly( q[t+1][v][0] ),
0)
for v, t in product(range(self.field["size"]), range(0, self.makespan-1))
]
# branching
for v in range(self.field["size"]):
if not self.field["body"][v]:
continue
# unreachable vertexes from starts
for t in range(0, min(self.DIST_TABLE_FROM_STARTS[v], self.makespan)):
for i in range(len(q[t][v][0])):
q[t][v][0][i] = amplify.BinaryPoly(0)
# unreachable vertexes to goals
for t in range(max(self.makespan - self.DIST_TABLE_FROM_GOALS[v] + 1, 0), self.makespan):
for i in range(len(q[t][v][0])):
q[t][v][0][i] = amplify.BinaryPoly(0)
# set occupied vertex
for v in range(self.field["size"]):
if self.field["body"][v]:
continue
for t in range(0, self.makespan):
q[t][v][0][-1] = amplify.BinaryPoly(0)
# create model
model = sum(constraints_starts)
model += sum(constraints_goals)
if len(constraints_in) > 0:
model += sum(constraints_in)
if len(constraints_out) > 0:
model += sum(constraints_out)
if len(constraints_continuity) > 0:
model += sum(constraints_continuity)
# setup client
client = FixstarsClient()
client.token = os.environ['TOKEN']
client.parameters.timeout = self.timeout
# solve
solver = amplify.Solver(client)
result = solver.solve(model)
if len(result) > 0:
self.used_edges = amplify.decode_solution(q, result[0].values)
from amplify import *
from amplify.constraint import *
from amplify.client import FixstarsClient
import os
client = FixstarsClient()
client.token = os.environ['AMPLIFY_TOKEN']
client.parameters.timeout = 5000
N,M,K = map(int,input().split()) # N: 時間数, M: バイトの人数, K: グループの個数
A = [list(map(int,input().split())) for _ in range(M)]
B = [list(map(int,input().split())) for _ in range(K)]
C = [list(map(int,input().split())) for _ in range(M)]
cost1_weight = 1 # 勤務時間平均化の重み
cost2_weight = N*N*4 # 必要人数の重み
cost3_weight = N*N*N # 勤務可能かどうかの重み
cost4_weight = N*N*N # グループの制限の重み
cost5_weight = N*N # 勤務回数最小化の重み
q = gen_symbols(BinaryPoly, M, N, K)
# q[i][j][k] := バイト i が時間 j にグループ k として勤務するかどうか
cost1 = BinaryPoly()
mean = BinaryPoly()
for i in range(M):
for j in range(K):
for k in range(N):
mean += q[i][k][j]
from amplify import BinaryPoly, BinaryQuadraticModel, gen_symbols, Solver
from amplify.client import FixstarsClient
q = gen_symbols(BinaryPoly, 2)
f = 1 - q[0] * q[1]
model = BinaryQuadraticModel(f)
client = FixstarsClient()
client.token = "CxVcQ2gwOawevU/7itsRGkAph9wAXwck"
client.parameters.timeout = 1000 # タイムアウト1秒
solver = Solver(client)
result = solver.solve(model)
for solution in result:
print(f"energy = {solution.energy}\nvalues = {solution.values}")