新手教程-使用真机-云平台或者SDK#

用例描述#

通过旅行商问题(TravelingSalesmanProblem，TSP)展示从建模、提交Qubo矩阵到云平台、从云平台获取计算结果的全流程

方式一：通过云平台上传QUBO矩阵计算#

代码建模并生成qubo矩阵#

 1# pylint: disable=<R0801>
 2"""
 3TSP problem solved using CIM.
 4"""
 5import numpy as np
 6import pandas as pd
 7import kaiwu as kw
 8
 9
10def is_edge_used(var_x, var_u, var_v):
11    """
12    Determine whether the edge (u, v) is used in the path.
13
14    Args:
15        var_x (ndarray): Decision variable matrix.
16
17        var_u (int): Start node.
18
19        var_v (int): End node.
20
21    Returns:
22        ndarray: Decision variable corresponding to the edge (u, v).
23    """
24    return kw.qubo.quicksum([var_x[var_u, j] * var_x[var_v, j + 1] for j in range(-1, n - 1)])
25
26
27if __name__ == '__main__':
28    # Import distance matrix
29    w = np.array([[0, 1, 2],
30                  [1, 0, 0],
31                  [2, 0, 0]])
32    # Get the number of nodes
33    n = w.shape[0]
34
35    # Create qubo variable matrix
36    x = kw.qubo.ndarray((n, n), "x", kw.qubo.Binary)
37
38    # Get sets of edge and non-edge pairs
39    edges = [(u, v) for u in range(n) for v in range(n) if w[u, v] != 0]
40    no_edges = [(u, v) for u in range(n) for v in range(n) if w[u, v] == 0]
41
42    qubo_model = kw.qubo.QuboModel()
43    # TSP path cost
44    qubo_model.set_objective(kw.qubo.quicksum([w[u, v] * is_edge_used(x, u, v) for u, v in edges]))
45
46    # Node constraint: Each node must belong to exactly one position
47    qubo_model.add_constraint(x.sum(axis=0) == 1, "sequence_cons", penalty=5.0)
48
49    # Position constraint: Each position can have only one node
50    qubo_model.add_constraint(x.sum(axis=1) == 1, "node_cons", penalty=5.0)
51
52    # Edge constraint: Pairs without edges cannot appear in the path
53    qubo_model.add_constraint(kw.qubo.quicksum([is_edge_used(x, u, v) for u, v in no_edges]),
54        "connect_cons", penalty=20.0)
55
56    qubo_mat = qubo_model.get_matrix()
57    pd.DataFrame(qubo_mat).to_csv("tsp.csv", index=False, header=False)

登录云平台上传矩阵#

  1. 登录光量子云计算平台后进入控制台，选择真机后点击新建任务

    ../../_images/new_task.png

  2. 进入任务配置页面后，填写任务名称、上传矩阵，确认后点击下一步

    ../../_images/new_task1.png

  3. 进入确认配置页面，确认任务和真机信息后点击确定按钮

    ../../_images/new_task2.png

  4. 进入提交任务页面，显示提交成功

    ../../_images/new_task3.png

  5. 返回控制台，任务正在校验中

    ../../_images/new_task4.jpg

  6. 校验成功后任务进入排队中状态

    ../../_images/new_task5.jpg

  7. 任务完成后点击详情进入结果详情页面

    ../../_images/new_task6.png

  8. 查看结果详情（qubo解向量、qubo value演化曲线、任务执行时间等）

    ../../_images/new_task7.png

方式二：直接使用SDK调用真机#

下面是同样一个TSP的问题，使用SDK直接调用真机求解的例子。 由于量子计算机有精度限制，例子中用SDK自带的PrecisionReducer进行精度适配。 想了解更多的关于精度的知识，

参见

 1"""
 2TSP calling CIM example
 3"""
 4import kaiwu as kw
 5import numpy as np
 6
 7
 8# 定义边使用判断函数
 9def is_edge_used(var_x, var_u, var_v):
10    """
11    Determine whether the edge (u, v) is used in the path.
12
13    Args:
14        var_x (ndarray): Decision variable matrix.
15
16        var_u (int): Start node.
17
18        var_v (int): End node.
19
20    Returns:
21        ndarray: Decision variable corresponding to the edge (u, v).
22    """
23    return kw.qubo.quicksum([var_x[var_u, j] * var_x[var_v, j + 1] for j in range(-1, n - 1)])
24
25
26if __name__ == "__main__":
27    # Set the save path for intermediate files
28    kw.common.CheckpointManager.save_dir = '/tmp'
29    # Define distance matrix
30    w = np.array([[0, 0, 1, 1, 0],
31                  [0, 0, 1, 0, 1],
32                  [1, 1, 0, 0, 1],
33                  [1, 0, 0, 0, 1],
34                  [0, 1, 1, 1, 0]])
35
36    n = w.shape[0]  # Number of nodes
37
38    # Create a QUBO variable matrix (n x n)
39    x = kw.qubo.ndarray((n, n), "x", kw.qubo.Binary)
40
41    # Generate the set of edges and the set of non-edges
42    edges = [(u, v) for u in range(n) for v in range(n) if w[u, v] != 0]
43    no_edges = [(u, v) for u in range(n) for v in range(n) if w[u, v] == 0]
44
45    # Initialize the QUBO model
46    qubo_model = kw.qubo.QuboModel()
47
48    # Set the objective function: minimize path cost
49    path_cost = kw.qubo.quicksum([w[u, v] * is_edge_used(x, u, v) for u, v in edges])
50    qubo_model.set_objective(path_cost)
51
52    # Add constraints
53    # Node constraints: Each node must occupy one position
54    qubo_model.add_constraint(x.sum(axis=0) == 1, "node_cons", penalty=5.0)
55
56    # Location constraint: Each location must have at least one node.
57    qubo_model.add_constraint(x.sum(axis=1) == 1, "pos_cons", penalty=5.0)
58
59    # Edge constraint: Non-connecting edges must not appear
60    qubo_model.add_constraint(
61        kw.qubo.quicksum([is_edge_used(x, u, v) for u, v in no_edges]),
62        "edge_cons", penalty=5.0
63    )
64
65    # Configure the solver, set wait=True, and wait for the solution to complete.
66    optimizer = kw.cim.CIMOptimizer(user_id="123124141", sdk_code="46sdgvsdgrreewrw", task_name="tsp", wait=True)
67    optimizer = kw.cim.PrecisionReducer(optimizer, 8)  # 8-bit precision
68    solver = kw.solver.SimpleSolver(optimizer)
69
70    # Solve the problem
71    sol_dict, qubo_val = solver.solve_qubo(qubo_model)
72
73    # Verification Results
74    unsatisfied, res_dict = qubo_model.verify_constraint(sol_dict)
75    print(f"Number of unsatisfied constraints: {unsatisfied}")
76    print(f"constraint value: {res_dict}")
77
78    # Calculate path cost
79    path_cost = kw.core.get_val(qubo_model.objective, sol_dict)
80    print(f"Actual path cost: {path_cost}")
On this page