QUBO model + 2023 mathorcup competition question A

some nouns

Ising model, Ising model

QUBO model, Quadratic Unconstrained Binary Optimization, quadratic unconstrained binary optimization model

• The value of the domain space of the spin variable is Ising空间, that is, the domain space is { − 1 , 1 } \{-1,1\}{ −1,1}

• For binary variables, the value of its domain space is 布尔空间, that is, the domain space is { 0 , 1 } \{0,1\}{ 0,1}

HOBO, High Order Binary Optimization, high-order binary optimization problem

Combinatorial optimization problem, combinatorial optimization (Combinatorial Optimization, CO)

Quadratic Unconstrained Binary Optimization (QUBO) Model

Paper reference: Quantum bridge analytics I: a tutorial on formulating and using QUBO models | SpringerLink

Many combinatorial optimization problems can be reformulated as QUBOmodels, and different types of constraint relations can be embodied in "unconstrained" formulations in a very natural way using penalty functionsQUBO . In QUBOthe formula, using the penalty function can produce a more accurate model representation (this sentence is not well understood, it is translated).

The QUBO model is used to solve NP-hard problems, and the method used to design an exact solver that finds an "optimal" solution is basically impossible except for very small instances of the problem . The model uses modern metaheuristics to find a solution that is close to the optimal solution in a limited amount of time.

QUBO basic model

The simplest QUBOmodel can be expressed as:

$$\min y={\mathbf{x}}^{t}Qx$$
where$x$ is a vectorof binary decision variables,$Q$ ismatrix

Here the constant square matrix $Q$ is generally used in optimization problems, without loss of generality, usingsymmetric matricesorupper/lower triangular

Expand the above and rewrite it into a scalar form as follows:
$$\min \sum Q_{ij}{x}_i{x}_j$$

由于 x i ∈ { 0 , 1 } x_i \in \{0,1\} xi​∈{ 0,1 } belongs to binary variables, there is$x_i=x_i^2$, so for a more general QUBOmodel it is expressed as follows:

$$\min \sum _{(i,j)\in \mathcal{E}}{Q}_{ij}{x}_i{x}_j+\sum _{i\in \mathcal{X}}{c}_i{x}_i$$
in,

• x i ∈ { 0 , 1 } , i ∈ X : = { 1 , … , X } x_i \in\{0,1\}, i \in \mathcal{X}:=\{1, \ldots, X\} xi​∈{ 0,1},i∈X:={ 1,…,X } is a binary decision variable, and$\mathcal{E}:=\{(i,j)\mid i,j\in \mathcal{X},i\ne j\}$。
• $Q_{ij}\in \mathbb{R},(i,j)\in E$ , isQUBOthe quadratic term coefficient of the objective function.
• $c_i\in R,i\in X$ , isQUBOthe coefficient of the first-order (linear) term of the objective function.

QUBOThe problem can be represented equivalently using Isingthe model, through the variable $y_i=1-2x{\_}_i$Transformation, QUBOthe decision variable domain space { 0 , 1 } \{ 0,1 \} in the original model{ 0,1 } is mapped toIsingthe model decision variable domain space{ − 1 , + 1 } \{ -1 , +1 \}{ −1,+1}。转变后的Ising模型表述如下：
$$\begin{array}{rl}& \min \sum _{(i,j)\in \mathcal{E}}{J}_{ij}{y}_i{y}_j+\sum _{i\in \mathcal{X}}{h}_i{y}_i,\\ & J_{ij}=-\frac{1}{4}{Q}_{ij},h_i=-\frac{1}{2}\left(c_i+\sum _{j\in \mathcal{X}}{Q}_{ij}\right),\end{array}$$
其中， y i ∈ { − 1 , 1 } , i ∈ X y_{i} \in\{-1,1\}, i \in \mathcal{X} yi​∈{ −1,1},i∈X

A small case in the paper

Optimization problem: Minimizing a quadratic objective function $y$：
$$miny=-5x_1-3x{\_}_2-8x_3-6x{\_}_4+4x{\_}_1{x}_2+8x_1{x}_3+2x{\_}_2{x}_3+10x_3{x}_4$$
where the variable xi ∈ { 0 , 1 } x_i \in \{ 0 , 1 \}xi​∈{ 0,1 } . It has alinear part($-5x_1-3x{\_}_2-8x_3-6x{\_}_4$) sum one quadratic part ( $4x{\_}_1{x}_2+8x_1{x}_3+2x{\_}_2{x}_3+10x_3{x}_4$), since the binary variable $x_j$Satisfy $x_j=x_j^2$, so the linear part can be written as:

$$-5x_1^2-3x{\_}_2^2-8x_3^2-6x{\_}_4^2$$
Based on this, the minimization objective function of the optimization model is written in matrix form:

$$miny=\left[\begin{array}{llll}{x}_1& x_2& x_3& x_4\end{array}\right]\left[\begin{array}{cccc}-5& 2& 4& 0\\ 2& -3& 1& 0\\ 4& 1& -8& 5\\ 0& 0& 5& -6\end{array}\right]\left[\begin{array}{l}{x}_1\\ x_2\\ x_3\\ x_4\end{array}\right]=x^{t}Qx$$

Due to the small size of the problem, exhaustion ( $2^4=16$ possibilities) Find the optimal solution to this problem:$y=-11,x_1=x_4=1,x_2=x_3=0)$

Use the library in python wildqat( pip install wildqat, there is an error in this method, there is a problem, because it depends on python3.6the version, the higher version of the python library is not compatible, there is a problem with the installation)

import wildqat as wq
a = wq.opt()
a.qubo = [[-5,2,4,0],
		  [2,-3,1,0],
    	  [4,1,-8,5],
		  [0,0,5,-6]]
   a.sa()

There is a problem with this library. The optimal solution is not correct, but it can find a close to optimal solution. There may be a problem with the parameter setting.

使用PyQUBO库：[2103.01708] PyQUBO: Python Library for Mapping Combinatorial Optimization Problems to QUBO Form (arxiv.org)

Relevant code:

from pyqubo import Binary
import neal

# 定义哈密顿量
   x1, x2, x3, x4 = Binary("x1"), Binary("x2"), Binary("x3"), Binary("x4")
H = -5 * x1 - 3 * x2 - 8 * x3 - 6 * x4 + 4 * x1 * x2 + 8 * x1 * x3 + 2 * x2 * x3 + 10 * x3 * x4

# 编译哈密顿量得到一个模型
model = H.compile()

# 调用'to_qubo()'获取QUBO系数
# 其中，offset表示下面目标函数中的常数值
# qubo是系数，字典dict类型,{('x2', 'x2'): -3.0,...}表示其系数
qubo, offset = model.to_qubo()

print(qubo)
print(offset)

# 求解qubo模型
# 将Qubo模型输出为BinaryQuadraticModel，BQM来求解
bqm = model.to_bqm()

# 定义采样器，这里使用模拟退火采样器
sa = neal.SimulatedAnnealingSampler()

# 进行采样，由于该采样器机制，需要设置高一点的采样个数，这样能够确保能够获得最优值
# 对应的设置越高，时间花费越久。
sampleset = sa.sample(bqm, num_reads=10)
decoded_samples = model.decode_sampleset(sampleset)

# 将采样出来的结果按照目标函数进行排序，求出最佳（小）的采样结果
best_sample = min(decoded_samples, key=lambda x: x.energy)

# 输出采样结果
print(f"采样取值：{
       
       best_sample.sample}，对应的结果为:{
       
       best_sample.energy}")

Create a QUBO model with known penalties

The general QUBO model requires variables to be binary and not contain any constraints. So if you want to actually solve some problems with constraints, you need to introduce quadratic penalties into the objective function .

classical constraints	Equivalent penalty
$x+y\le 1$	$P\left(xy\right)$
$x+y\ge 1$	$P(1-x-y+xy)$
$x+y=1$	$P(1-x-y+2xy)$
$x\le y$	$P(x-xy)$
$x_1+x_2+x_3\le 1$	$P\left(x_1{x}_2+x_1{x}_3+x_2{x}_3\right)$
$x=y$	$P(x+y-2xy)$

Note here that $P\left(xy\right)$ represents the scalar$P$ times$(x\ast y)$ , that is,$P\ast (x\ast y)$ , the others are similar.

Among them, the function $P$ is calculated as a positive scalar penalty value, and this value must be calculated to be large enough. Because, inQUBO, its constraints are implemented by the optimizer, therefore, the rules specified by the penalty item are: for thethe minimization problem, if it is a feasible solution, that is, the constraint condition is satisfied, the corresponding penalty item is equal to zero; A row solution, that is, a solution that does not satisfy the constraints, has a penalty term equal to some positive penalty amount. for$Whether\; the\; value\; of\; P$ is reasonable can be calculated by solving the solution of the model to calculate the added penalty function. If it is 0, it means that$The\; P$ value effect is OK.

Too large a penalty value can hinder the solution process, because the penalty term will overwhelm the original objective function information, making it difficult to distinguish the quality of a solution. On the other hand, too small a penalty can jeopardize the search for a viable solution. Therefore, how to determine the penalty value needs to be considered and designed.

There are also related skills for the design of constraint items, you can check the information.

solve

Many combinatorial optimization problems can be reformulated as QUBOmodels and can be solved using methods such as simulated annealing , quantum annealing, and quantum approximate optimization algorithms ( ). QAOABoth are modern metaheuristic search methods.

quantum annealing

For many proper nouns and principle details, please refer to: D-Wave System Documentation or check the information. For example 纠缠（entanglement）, 耦合器（coupler）, 本征谱(Eigenspectrum), 哈密顿量(Hamiltonian), 本征态（eigenstates）, 初始哈密顿量（Initial Hamiltonian）, 最终哈密顿量(Final Hamiltonian), 隧穿哈密顿量 (tunneling Hamiltonian), 问题哈密顿量 (problem Hamiltonian).

Quantum annealing is the process of finding the ground state (lowest energy state) based on the natural behavior of coupled qubits . The process of quantum annealing can use the time-varying Hamiltonian $\mathcal{H}(s)$来表示：
$$\mathcal{H}(s)=A(s)H_I-B(s)H_P$$
Among them, $A\left(s\right)$ and$B\left(s\right)$ is the annealing path function, according to the normalized annealing time$s=t/t_a$, among which $t_a$Indicates the total annealing time. This design ensures that:

• This $A(0)=1$ and$B(0)=0$ ，$H\left(s\right)$ represents the initial state$H_I$, defined by the user.
• This $A(1)=0$ and$B(1)=0$ ，$H\left(s\right)$ represents the state HP after annealing$H_P$, which is also called the problem Hamiltonian ( problem Hamiltonian), is the minimum energy state.

Then when designing, the design of the initial state can be simply designed according to the problem, for example:
$$H_I=\sum _i{p}_i^x$$
Among them, $p_i^x$Indicates the iiPauli − x Pauli-x$for\; i$ qubits$Pauli-x$ operator (Pauli$-x$ operator).

And the problem Hamiltonian, that is, $H_P$设计可通过最优化的目标函数给出：
$$H_P=\sum _{i,j}{J}_{ij}{\sigma }_i^z\cdot {\sigma }_j^z+\sum _i{h}_i{\sigma }_i^z$$
其中，${\sigma }_i^z$表示第 $i$ 个量子位的$Pauli-z$ 算子（泡利$-z$ 算子）。

量子退火器首先初始化量子位的叠加态使得$\mathcal{H}(0)=H_I$，然后在退火时间内操作量子位耦合，使 $H\left(s\right)$ towards$H_P$After development, after annealing, it is in the eigenstate (eigenstate) of problem Hamiltonian. According to the adiabatic theorem of quantum computing, if the annealing time is long enough, the time-varying Hamiltonian $H\left(s\right)$ will always maintain the ground state, that is, the optimal function ($the\; solution\; of\; H\left(s\right)$ ).

simulated annealing

Simulated Annealing (SA) is a general global optimization algorithm used to find the optimal solution in the search space. Its basic principle is to simulate the annealing process in physics, and control the probability of accepting suboptimal solutions during the search process through temperature parameters, so as to avoid falling into local optimal solutions. The basic flow of the simulated annealing algorithm is as follows:

1. Initialize a solution $x_0$and an initial temperature $T_0$。

2. At this temperature, iterate, each iteration doing the following:

   a. From the current solution xxRandomly select a new solution x ′ x’in the neighborhood of$x$$x^{\prime }$。

   b. Calculate $x^{\prime }$ objective function value$f(x^{\prime })$andxxThe objective function value of$x$$f(x)$。

   c. Judge whether to accept the new solution according to the Metropolis criterion, that is, if $f(x^{\prime })<f\left(x\right)$ , then with probability$1$ accepts$x^{\prime }$ as the new solution; otherwise, with the probability$e^{-\Delta f/T}$ accepts$x^{\prime }$，其中 $f\_=f\left(x^{\prime }\right)-f\left(x\right)$。

3. Update temperature $T$ , and repeat step 2 until the temperature meets the stop condition

where the temperature $T$ is a parameter that decreases over time, controlling the probability that the algorithm accepts a suboptimal solution.

From the above algorithm, it can be seen that the iterative effect is affected by three parameters: initial temperature, cooling rate and termination temperature.

• The initial temperature is usually set to a higher value to ensure that some poor solutions can be accepted in the early stage of the search, so that there is a greater probability of jumping out of the local optimal solution.

• The termination temperature is usually set to a small value. When the temperature drops to the termination temperature, the search stops, and the solution obtained at this time is the optimal solution obtained by the algorithm.

• The cooling rate is usually set to a constant less than 1. The slower the cooling rate, the longer the search time, but the wider the search range, and the greater the probability of finding the global optimal solution.

Therefore, the three parameters of initial temperature, cooling rate and termination temperature need to be set reasonably so as to quickly reach the optimal solution.

Here is an introduction to the samplers in the dwave-samplersSimulatedAnnealingSampler library and the corresponding parameters.

In this library, the initial and final temperatures are calculated by $\frac{1}{TK}$Convert to $b_1$and $b_0$(where $K$ is the Boltz constant), by passing in the parameter$\text{beta\_range}=[b_0,b_1]$传入。而降温速率一般通过beta_schedule_type和num_sweeps来设置：对于beta_schedule_type参数，有三种方式：

• “linear”：线性，在$[{\beta }_0,{\beta }_1]$中线性获取num_sweeps个采样点作为每次更新温度的数值
• “geometric”，几何，在$[{\beta }_0,{\beta }_1]$中通过np.geomspace(*beta_range, num=num_betas)获取num_sweeps个采样点作为每次更新温度的数值。
• “custom”：用户自定义

量子近似优化算法(QAOA)

量子近似优化算法可以使用QPanda库，这部分不是很了解，有时间后面补充。

高阶问题（HOBO）

主要解决的问题是：对于QUBO模型中高于二次项的目标函数该如何求解问题

参考论文：[2001.00658] Compressed Quadratization of Higher Order Binary Optimization Problems (arxiv.org)

在不同论文中有不同的叫法：

• Higher Order Binary Optimization (HOBO)：高阶二进制优化
• termwise quadratization quadratization: according to the square of the term, this is to convert the monomial into quadratically. That is $x_i=x_i^2,where{x}_i\in 0,1$

Compressive quadraticization of high-order binary optimization problems: For now, there is a method for reducing the order of high-order optimization problems using Rosenberg polynomials , which reduces the number of terms in a Boolean space by introducing an additional variable times, this method will eventually lead to a very sparse final Boolean space matrix, and the problem size will become larger. Then in the paper, a reduction method that operates directly in the original Boolean space is proposed without adding additional variables.

There is one in the paper that I didn't understand:

feel the xx here$X$ is wrong, it should be$z$ , then the meaning you want to express should be, for$z$ belongs to the value of Boolean space, you can increase the variable$y$ , such that whenyyWhen$y$ takes aspecific value$h(z,y_{take\; a\; specific})$ is equivalent to$f\left(z\right)$ , due to$The\; h$ function is not sure, it just means that the function can be found to satisfy the condition of equivalence, then make another limitation, that is, when$When\; y$ takes thisspecific value, it happens to be$h(z,y_{take\; a\; specific})$ to the minimum value,

Then according to the greedy idea, it is easy to understand, when the time comes to minimize $f\left(z\right)$ is equivalent to minimizing$h(z,y)$

Based on this, there are equivalents:

This is more difficult to understand, but think of xi ∈ { 0 , 1 } x_i \in \{ 0 , 1 \}xi​∈{ 0,1 } , and here y is a combination of many, and$y_i\in \{0,1\}$ is easier to list exhaustively, andLinear and quadratic reformulations of nonlinear optimization problems in binary variablesit is proved in the paper that for the highest number$d$ , the desired variable$The\; number\; of\; y$ is$\lceil \log d\rceil -1$ . (I feel that there is a problem with the expression of the formula)

HOBOThere are two problems with this substitution method. For details, please refer to the paper. We did not use variables to replace the descending order, so we did not study this carefully.

Question A of mathorcup in 2023

mathematical definition

noun	mathematical expression
Loan amount	$L$ , fixed value, is 1000000
Interest income rate	$I$ , a fixed value, is 8%
Pass rate matrix, $T$	Among them, $T_{i,j}$Indicates the iiThe jjth$of\; the\; i$ credit score card$pass\; rate\; of\; j$ thresholds
Bad debt ratio matrix, $H$	Among them, $H_{i,j}$Indicates the iiThe jjth$of\; the\; i$ credit score card$Bad\; debt\; rate\; of\; j$ thresholds
total pass rate	$P$
Total Bad Debt Rate	$Q$
Collection space, specifically explained in the article	$\mathcal{X}$
Constraints	$l$
final income	$H$

Question one

For problem one, we define decision variables $x_{i,j}$It is used to represent:
$$x_{i,j}=\{\begin{array}{c}0,Unselect\; thejththreshold\; of\; theithcredit\; scorecard\\ 1,Select\; thej-th\end{array}$$
Then for the decision variable $x_{i,j}$Corresponding pass rate $P_{i,j}$and damage rate $Q_{i,j}$ 有：
$$\begin{gathered} P_{i,j}=x_{i,j}\ast T_{i,j} \\ {Q}_{i,j}=x_{i,j}\ast H_{i,j} \end{gathered}$$
Then the decision variable $x_{i,j}$The corresponding final income $H_{i,j}$ 有
$$H_{i,j}=L\ast I\ast P_{i,j}\ast (1-Q_{i,j})-L\ast P_{i,j}\ast Q_{i,j}$$
Consider the whole, which is the final income $H$ 有
$$\begin{gathered} H=\sum _{(i,j)\in \mathcal{X}}{H}_{i,j} \\ =\sum _{i=1}^{100}\sum _{j=1}^{10}[L\ast I\ast P_{i,j}\ast (1-Q_{i,j})-L\ast P_{i,j}\ast Q_{i,j}] \\ =L\ast I\ast \sum _{i=1}^{100}\sum _{j=1}^{10}{P}_{i,j}-L\ast (I+1)\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(P_{i,j}\ast Q_{i,j}) \\ =L\ast I\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast x_{i,j})-L\ast (I+1)\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast H_{i,j}\ast x_{i,j}^2) \end{gathered}$$
for the final income, we consider minimizing the objective function$-H$,即
$$min-H=L\ast (I+1)\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast H_{i,j}\ast x_{i,j}^2)-L\ast I\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast x_{i,j})$$
Consider constraints: since only one scorecard threshold can be selected in the whole, so in the decision variable$x_{i,j}$Only one of them is 1, namely:
$$\sum _{(i,j)\in \mathcal{X}}{x}_{i,j}=\sum _{i=1}^{100}\sum _{j=1}^{10}{x}_{i,j}=1$$

Here $The\; X$ space is defined as:X : = { ( i , j ) ∣ i ∈ { 1 , 2 , . . . , 100 } , j ∈ { 1 , 2 , . . . , 10 } } \mathcal{X}:= \{(i, j) \mid i \in \{1,2,...,100\}, j \in \{1,2,...,10 \} \}X:={(i,j)∣i∈{ 1,2,...,100},j∈{ 1,2,...,10}}

综上所述：
$$\begin{gathered} min-H=L\ast (I+1)\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast H_{i,j}\ast x_{i,j}^2)-L\ast I\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast x_{i,j}) \\ s.t.\sum _{i=1}^{100}\sum _{j=1}^{10}{x}_{i,j}=1 \end{gathered}$$
通过添加约束项 $\lambda$ Rewrite the above quadratic constrained binary optimization model into a quadratic unconstrained binary optimization model (QUBO):
$$miny=L\ast (I+1)\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast H_{i,j}\ast x_{i,j}^2)-L\ast I\ast \sum _{i=1}^{100}\sum _{j=1}^{10}(T_{i,j}\ast x_{i,j})+l\ast (\sum _{i=1}^{100}\sum _{j=1}^{10}{x}_{i,j}-1{)}^2$$

For the enumeration violence code implementation of question 1 :

import time
import pandas as pd

if __name__ == '__main__':
    # 定义一些变量
    L = 1000000  # 贷款资金
    I = 0.08  # 利息收入率

    df = pd.read_csv('./data/附件1：data_100.csv', header=0)

    # 定义最大的数
    max_value = -1

    # 定义最大数字的索引下标
    max_i = max_j = -1

    start = time.time()

    for i in range(1, 101):
        for j in range(0, 10):

            # 总通过率
            P = df[f"t_{
      
      i}"].iloc[j]

            # 总坏账率
            Q = df[f"h_{
      
      i}"].iloc[j]

            # 此时的最终收入
            temp_value = L * I * P * (1 - Q) - L * P * Q

            # print(f"选卡[{i},{j + 1}]，对应最终收入{temp_value},最大收入:{max_value}")

            if temp_value > max_value:
                max_value = temp_value
                max_i = i
                max_j = j

    end = time.time()
    print(f"暴力时间：{
      
      end - start} s")

    print(f"最大值：{
      
      max_value}")
    print(f"对应的选取卡1：第{
      
      max_i}张{
      
      max_j + 1}个阈值")

Use QUBOthe model + simulated annealing algorithm to achieve:

import time
from pyqubo import Array, Constraint
from dwave.samplers import SimulatedAnnealingSampler

import numpy as np
from pyqubo import Placeholder


# 在字典中找到value的key
def get_key(dict, value):
    return [k for k, v in dict.items() if v == value]


# 主函数,问题一的主要求解函数
def main():
    # 定义一些变量
    L = 1000000  # 贷款资金
    I = 0.08  # 利息收入率

    # 读取数据
    data = np.genfromtxt('./data/附件1：data_100.csv', delimiter=',', skip_header=1)

    # 获取T矩阵和H矩阵
    T = data[:, ::2]
    H = data[:, 1::2]

    # 定义二进制决策变量,10 * 100
    x = Array.create('x', shape=(10, 100), vartype='BINARY')

    # 定义惩罚项M
    M = Placeholder('M')
    M = 100000

    # 定义哈密顿量,也就是对应的目标函数
    # 注意这里不是总通过率和总坏账率，是中间变量，将最终决策目标的连加符号放到里面整出来的
    P = np.sum(np.multiply(x, T))
    Q = np.sum(np.multiply(x, H))
    H = - (L * I * P * (1 - Q) - L * P * Q) + M * Constraint((np.sum(x) - 1) ** 2, label='sum(x_i_j) = 1')

    # 编译哈密顿量得到一个模型
    model = H.compile()

    # 将Qubo模型输出为BinaryQuadraticModel，BQM来求解
    bqm = model.to_bqm()

    # 记录开始退火时间
    start = time.time()

    # 模拟退火
    sa = SimulatedAnnealingSampler()
    sampleset = sa.sample(bqm, seed=666, beta_range=[10e-10, 50], num_sweeps=10000, beta_schedule_type='geometric',num_reads=10)


    # 对数据进行筛选，对选取的数据进行选取最优的
    decoded_samples = model.decode_sampleset(sampleset)  # 将上述采样最好的num_reads组数据变为模型可读的样本数据
    best_sample = min(decoded_samples, key=lambda x: x.energy)  # 将能量值最低的样本统计出来，表示BQM的最优解

    end = time.time()
    print(f"退火时间花费：{
      
      end - start} s")

    # 统计决策变量为1的所有数据
    data_1_list = get_key(best_sample.sample, 1)

    print(f"对应的取1的决策变量有：{
      
      data_1_list}(注意是索引，从0开始),对应的能量为(最大最终收入):{
      
      - best_sample.energy}")
    
    
if __name__ == '__main__':
    main()

For problem 1, although brute force exhaustion QUBOis faster than the running time of model + simulated annealing algorithm, but considering the time complexity of the algorithm: the card has $m$ sheets, the threshold selection has$n$ _

• Brute-forcing algorithm, due to loops, is $O\left(mn\right)$
• QUBOThe model + simulated annealing algorithm is a modern meta-heuristic optimization algorithm. When there is a lot of data, especially on NP problems, the larger the scale, the faster its operation speed is.

question two

For problem two, we consider two understandings of the QUBO model:

• Define decision variables $x_{i,j,k}$Indicate whether to choose: choose the ii for the first credit score card$i$ threshold, the second credit score card choose$There\; are\; j$ thresholds, and the third credit score card selects$k$ thresholds.
• A discovery mainly derived from the process of violent exhaustion, the threshold selection of the first two credit score cards is fixed, and the third credit score card is $Whether\; i$ thresholds are selected as decision variables$x_i$, after determining the optimal threshold of the third credit score card, similarly determine the optimal threshold of the other two credit cards. After several iterations, the threshold determined by this method is the best combination of thresholds in this problem.

See the following for details:

SHOWER

Define decision variables $x_{i,j,k}$Used to represent:
$$x_{i,j,k}=\{\begin{array}{c}0,do\; not\; choose:Select\; thei-th\; threshold\; forthe\; firstcredit\; score\; card,\; thej-th\; threshold\; for\; thesecondcredit\; score\; card\; ,\; andthe\; k-th\; threshold\; forthe\; thirdcredit\; score\; card\\ 1,select:Select\; thei-th\; threshold\; forthe\; firstcredit\; score\; card,\; thej-th\; threshold\; for\; thesecondcredit\; score\; card\; ,\; andthe\; k-th\end{array}$$
Then for decision variables $x_{i,j,k}$Corresponding pass rate $P_{i,j,k}$and damage rate $Q_{i,j,k}$ 有：
$$\begin{gathered} P_{i,j,k}=x_{i,j,k}\ast T_{1,i}\ast T_{2,j}\ast T_{3,k} \\ {Q}_{i,j,k}=x_{i,j,k}\ast \frac{1}{3}\ast (H_{1,i}+H_{2,j}+H_{3,k}) \end{gathered}$$
于是决策变量 $x_{i,j,k}$ 对应的最终收入 $H_{i,j,k}$ 有
$$H_{i,j,k}=L\ast I\ast P_{i,j,k}\ast (1-Q_{i,j,k})-L\ast P_{i,j,k}\ast Q_{i,j,k}$$
考虑整体，也就是最终收入 $H$ 有
$$\begin{gathered} H=\sum _{(i,j,k)\in \mathcal{X}}{H}_{i,j,k} \\ =\sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[L\ast I\ast P_{i,j,k}\ast (1-Q_{i,j,k})-L\ast P_{i,j,k}\ast Q_{i,j,k}] \\ =L\ast I\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}{P}_{i,j,k}-L\ast (I+1)\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}(P_{i,j,k}\ast Q_{i,j,k}) \\ =L\ast I\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[(T_{1,i}\ast T_{2,j}\ast T_{3,k})\ast x_{i,j,k}] \\ -\frac{L\ast (I+1)}{3}\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[(H_{1,i}+H_{2,j}+H_{3,k})\ast T_{1,i}\ast T_{2,j}\ast T_{3,k}\ast x_{i,j,k}^2] \end{gathered}$$
Also consider minimizing the objective function$-H$ , the constraint condition of the decision variable at this time is: (only one option is selected)
$$\sum _{(i,j,k)\in \mathcal{X}}{x}_{i,j,k}=\sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}{x}_{i,j,k}=1$$

Here $The\; X$ space is defined as:$X:=\{(i,j,k)\mid i,j,k\in \{1,2,...,10\}\}$

综上所述：
$$\begin{gathered} min-H=L\ast I\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[(T_{1,i}\ast T_{2,j}\ast T_{3,k})\ast x_{i,j,k}] \\ -\frac{L\ast (I+1)}{3}\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[(H_{1,i}+H_{2,j}+H_{3,k})\ast T_{1,i}\ast T_{2,j}\ast T_{3,k}\ast x_{i,j,k}^2] \\ s.t.\sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}{x}_{i,j,k}=1 \end{gathered}$$
By adding the constraint term$\lambda$ Rewrite the above quadratic constrained binary optimization model into a quadratic unconstrained binary optimization model (QUBO):
$$\begin{gathered} miny=L\ast I\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[(T_{1,i}\ast T_{2,j}\ast T_{3,k})\ast x_{i,j,k}] \\ -\frac{L\ast (I+1)}{3}\ast \sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}[(H_{1,i}+H_{2,j}+H_{3,k})\ast T_{1,i}\ast T_{2,j}\ast T_{3,k}\ast x_{i,j,k}^2] \\ +l\ast (\sum _{i=1}^{10}\sum _{j=1}^{10}\sum _{k=1}^{10}{x}_{i,j,k}-1{)}^2 \end{gathered}$$

In the process of code implementation, due to the need to calculate the total pass rate $T_{1,i}\ast T_{2,j}\ast T_{3,k}$And the total bad debt rate $\frac{1}{3}\ast (H_{1,i}+H_{2,j}+H_{3,k})$ . numpyIf the efficiency of using the for loop is relatively slow, the broadcast mechanism in the libraryis used here

The code is implemented as follows:

import time
from pyqubo import Array, Constraint
from dwave.samplers import SimulatedAnnealingSampler
import numpy as np
from pyqubo import Placeholder


# 在字典中找到value的key
def get_key(dict, value):
    return [k for k, v in dict.items() if v == value]


def main():
    # 定义一些变量
    L = 1000000  # 贷款资金
    I = 0.08  # 利息收入率

    # 表示选取的卡号
    card1, card2, card3 = 1, 2, 3

    # 读取数据
    data = np.genfromtxt('../data/附件1：data_100.csv', delimiter=',', skip_header=1)

    # 获取T矩阵和H矩阵
    T = data[:, ::2]
    H = data[:, 1::2]

    # 定义二进制决策变量,10 * 100
    x = Array.create('x', shape=(10, 10, 10), vartype='BINARY')

    # 定义惩罚项M
    M = Placeholder('M')
    M = 30000

    # 定义哈密顿量,也就是对应的目标函数
    # 注意这里不是总通过率和总坏账率，是中间变量，将最终决策目标的连加符号放到里面整出来的
    T1 = T[:, card1 - 1]
    T2 = T[:, card2 - 1]
    T3 = T[:, card3 - 1]

    H1 = H[:, card1 - 1]
    H2 = H[:, card2 - 1]
    H3 = H[:, card3 - 1]

    # 计算三种组合后的总通过率和总坏账率,通过广播机制来实现
    T = T1[:, None, None] * T2[None, :, None] * T3[None, None, :]
    H = (H1[:, None, None] + H2[None, :, None] + H3[None, None, :]) / 3

    P = np.sum(np.multiply(x, T))
    Q = np.sum(np.multiply(x, H))
    H = - (L * I * P * (1 - Q) - L * P * Q) + M * Constraint((np.sum(x) - 1) ** 2, label='sum(x_i_j) = 1')

    # 编译哈密顿量得到一个模型
    model = H.compile()

    # 将Qubo模型输出为BinaryQuadraticModel，BQM来求解
    bqm = model.to_bqm()

    print("开始模拟退火")

    start = time.time()
    sa = SimulatedAnnealingSampler()
    sampleset = sa.sample(bqm, seed=888, beta_range=[10e-12, 60], beta_schedule_type='geometric', num_reads=50)

    # 对数据进行筛选
    decoded_samples = model.decode_sampleset(sampleset)  # 将上述采样最好的num_reads组数据变为模型可读的样本数据
    best_sample = min(decoded_samples, key=lambda x: x.energy)  # 将能量值最低的样本统计出来，表示BQM的最优解

    # print(f"验证约束条件M：{best_sample.constraints()}")
    end = time.time()
    print(f"退火时间：{
      
      end - start} s")

    # print(best_sample.sample)

    # 统计决策变量为1的所有数据
    data_1_list = get_key(best_sample.sample, 1)

    print(f"对应的取1的决策变量有：{
      
      data_1_list}(表示[第一张卡的阈值][第二张卡的阈值][第三张卡的阈值]，注意是索引，从0开始),对应的能量为{
      
      -best_sample.energy}")


if __name__ == '__main__':
    main()

enumeration violence

The corresponding enumeration violence code is as follows:

import pandas as pd

if __name__ == '__main__':
    # 定义一些变量
    L = 1000000  # 贷款资金
    I = 0.08  # 利息收入率

    # 选取第几列的信用卡
    card1 = 1
    card2 = 2
    card3 = 3

    df = pd.read_csv('../data/附件1：data_100.csv', header=0)
    # 定义最大的数
    max_value = -1

    # 定义最大数字的索引下标
    max_i = max_j = max_k = -1

    for i in range(0, 10):
        for j in range(0, 10):
            for k in range(0, 10):
                # 总通过率
                P = df[f"t_{
      
      card1}"].iloc[i] * df[f"t_{
      
      card2}"].iloc[j] * df[f"t_{
      
      card3}"].iloc[k]

                # 总坏账率
                Q = (df[f"h_{
      
      card1}"].iloc[i] + df[f"h_{
      
      card2}"].iloc[j] + df[f"h_{
      
      card3}"].iloc[k]) / 3

                # 此时的最终收入
                temp_value = L * I * P * (1 - Q) - L * P * Q

                # print(f"选卡1阈值：[{i + 1}]，选卡1阈值：[{j + 1}]，选卡1阈值：[{k + 1}]，对应最终收入{temp_value},之前的最大收入:{max_value}")

                if temp_value > max_value:
                    max_value = temp_value
                    max_i = i
                    max_j = j
                    max_k = k

        print(f"第{
      
      i + 1}个对应的最大值：{
      
      max_value},三个阈值选取为:{
      
      max_i + 1},{
      
      max_j + 1},{
      
      max_k + 1},其中，阈值编号[1-10]")

    print(f"最大值：{
      
      max_value},三个阈值选取为:{
      
      max_i + 1},{
      
      max_j + 1},{
      
      max_k + 1},其中，阈值编号[1-10]")

Greedy + QUBO

During the running process, I found a rule that is very helpful to the third question: You can print out the above decision-making process (for loop) to see:

For the first cycle, its decision process is: [1,1,2]-->[2,1,2]-->[3,1,2]-->[3,1,2]-->[3,1,2]-->[6,1,2]-->[7,1,2]-->[8,1,2]-->[8,1,2]-->[8,1,2]. The results printed here are relatively small, and the rules may not be obvious. But easy to spot:

For the decision-making process of three scoring credit cards, if the threshold selection of the first and second scoring credit cards is fixed, and the threshold selection of the third scoring credit card is considered, the optimal credit scoring card threshold is selected at this time. Then fix the threshold selection of the first and third scoring credit cards, and consider the threshold selection of the second scoring credit card, and select the optimal credit scoring card threshold at this time. Then fix the threshold selection of the second and third scoring credit cards, and consider the threshold selection of the first scoring credit card, and select the optimal credit scoring card threshold at this time. Based on this non-stop iteration, the final threshold selection is the optimal threshold combination. (Consider to prove it).

Based on this process, we can convert the original $10\times 10\times$The solution of$10$$iterations\times Questions\; for\; 10$ decision variables. This is a very important finding for question three. For question three, it was originally$1000\times 990\times The\; 980$ decision variable problem is converted to$iterations\times 980$ decision variable scale questions.

question three

At the beginning we considered: design decision variables $x_{i,j}$It is used to represent:
$$x_{i,j}=\{\begin{array}{c}0,Unselect\; thejththreshold\; of\; theithcredit\; scorecard\\ 1,Select\; thej-th\end{array}$$
Without considering the constraints, the overall pass rate $P$ and damage rate$Q$满足：
$$\begin{gathered} P=\prod _{(i,j)\in \mathcal{X}}(x_{i,j}\ast T_{i,j}+1-x_{i,j})=\prod _{(i,j)\in X}(T_{i,j}^{x_{i,j}}) \\ Q=\frac{1}{3}\ast \sum _{(i,j)\in X}(H_{i,j}\ast x_{i,j}) \end{gathered}$$
corresponding to the final income$H$有：
$$H=L\ast I\ast P\ast (1-Q)-L\ast P\ast Q$$
can be found that if use$P={\prod }_{(i,j)\in \mathcal{X}}(x_{i,j}\ast T_{i,j}+1-x_{i,j})$ of this formula, in its objective function, the coefficient of the highest sub-term of the decision variable is$1001$ times. Converted to$The\; HOBO$ model needs to be downgraded, which feels very complicated. Not consider.

如果使用 $P={\prod }_{(i,j)\in X}(T_{i,j}^{x_{i,j}})$ formula, and then consider the idea of ​​using polynomial approximation (Polynomial approximation), expand the exponential term using polynomials, such as Taylor series expansion:$e^{ax}={\sum }_{n=0}^{\infty }\frac{(ax{)}^n}{n!}$, keeping the first-order term, namely: $e^{ax}\approx 1+ax$ .$\_$In other words, the exponential term can be transformed into a linear term of a polynomial function:
P = ∏ ( i , j ) ∈ X ( T i , jxi , j ) = exp { ∑ ( i , j ) ∈ X [ xi , j ∗ ln ( T i , j ) ] } ≈ 1 + ∑ ( i , j ) ∈ X [ xi , j ∗ ln ( T i , j ) ] P = \prod_{(i,j) \in \mathcal{X}} (T_{i,j}^{x_{i,j}}) = exp \{ \sum_{(i,j) \in \mathcal{X}} [x_{i,j}* ln(T_{i ,j})] \} \approx 1 + \sum_{(i,j) \in \mathcal{X}} [x_{i,j}* ln(T_{i,j})]P=(i,j)∈X∏​(Ti,jxi,j​​)=exp{ (i,j)∈X∑​[xi,j​∗ln(Ti,j​)]}≈1+(i,j)∈X∑​[xi,j​∗ln(Ti,j​)]
Then based on this theory, the original objective function can be transformed into the objective function of the highest quadratic term. But this is also a problem, because the decision variable$x_{i,j}\in \{0,1\}$ is a discrete variable, then using the Taylor-level expansion may not be equivalent, and it will not be considered.

There is a problem in all the above considerations, that is, how to solve the overall pass rate $P$ expression. If the PPcan be$P$ is converted into an expression of a primary item, then it is very simple to solve the entire problem. Then redefine the decision variables$x_{i,j,k,l,m,n}$Used to decide whether to choose: Section $i$ credit score card selection$l$ threshold value,jjthSelect themmth$of\; j\; credit\; score\; cards$$mth$ threshold,$k$ credit score card selection$n$ thresholds. That is:
$$x_{i,j,k,l,m,n}=\{\begin{array}{c}0,do\; not\; choose\\ 1,\end{array}$$
Then for decision variables $x_{i,j,k,l,m,n}$Corresponding pass rate $P_{i,j,k,l,m,n}$and damage rate $Q_{i,j,k,l,m,n}$ 有：
$$\begin{gathered} P_{i,j,k,l,m,n}=x_{i,j,k,l,m,n}\ast T_{i,l}\ast T_{j,m}\ast T_{k,n} \\ {Q}_{i,j,k,l,m,n}=\frac{1}{3}\ast x_{i,j,k,l,m,n}\ast (H_{i,l}+H_{j,m}+H_{k,n}) \end{gathered}$$
into the final income formula:
$$\begin{gathered} H=\sum _{(i,j,k,l,m,n)\in \mathcal{X}}{H}_{i,j,k,l,m,n} \\ =\sum _{i=1}^{100}\sum _{j=1}^{100}\sum _{k=1}^{100}\sum _{l=1}^{10}\sum _{m=1}^{10}\sum _{n=1}^{10}[L\ast I\ast P_{i,j,k,l,m,n}\ast (1-Q_{i,j,k,l,m,n})-L\ast P_{i,j,k,l,m,n}\ast Q_{i,j,k,l,m,n}] \end{gathered}$$
If this method does not consider the constraints, then the quantum number is $100\times 100\times 100\times 10\times 10\times 10$ , the memory is not enough, it can't run this.

Consider violence

Consider using a loop to brute force it to find the best combination. This takes a long time to carry out, so consider the idea of ​​​​multi-threading + divide and conquer against it. The code is as follows:

import time
import pandas as pd
from threading import Thread

# 定义一些变量
L = 1000000  # 贷款资金
I = 0.08  # 利息收入率

df = pd.read_csv('../data/附件1：data_100.csv', header=0)

# 全局变量，用于存储所有线程中的最大值
max_value = -1
# 定义最大数字的索引下标
max_i = max_j = max_k = max_m = max_n = max_l = -1


def computer_result(begin, end):
    # 使用全局变量
    global max_value, max_i, max_j, max_k, max_m, max_n, max_l

    for i in range(begin, end):
        for j in range(i + 1, 101):
            for k in range(j + 1, 101):
                for m in range(0, 10):
                    for n in range(0, 10):
                        for l in range(0, 10):
                            # 总通过率
                            P = df[f"t_{
      
      i}"].iloc[m] * df[f"t_{
      
      j}"].iloc[n] * df[f"t_{
      
      k}"].iloc[l]

                            # 总坏账率
                            Q = (df[f"h_{
      
      i}"].iloc[m] + df[f"h_{
      
      j}"].iloc[n] + df[f"h_{
      
      k}"].iloc[l]) / 3

                            # 此时的最终收入
                            temp_value = L * I * P * (1 - Q) - L * P * Q

                            if temp_value > max_value:
                                max_value, max_i, max_j, max_k, max_m, max_n, max_l = temp_value, i, j, k, m, n, l


if __name__ == '__main__':

    start = time.time()
    print(start)

    # 创建线程并启动它们
    threads = [Thread(target=computer_result, args=(i, i + 1)) for i in range(1, 101)]
    for thread in threads:
        thread.start()

    # 等待所有线程执行完毕
    for thread in threads:
        thread.join()

    end = time.time()
    print(f"时间花费：{
      
      end - start} s")
    print(f"最大值：{
      
      max_value},对应的选取卡1：第{
      
      max_i}张{
      
      max_m + 1}个阈值,"
          f"对应的选取卡2：第{
      
      max_j}张{
      
      max_n + 1}个阈值,"
          f"对应的选取卡3：第{
      
      max_k}张{
      
      max_l + 1}个阈值,其中，卡取值[1-100],阈值取值[1-10]")

I feel that the code can still be optimized, but I don't want to spend time on it.

Consider violence + greed

It is mainly the greedy law found in question 2, so this efficiency is relatively high. Then similarly use the following iterative algorithm:

Then the main problem is how to find the optimal credit score card threshold after fixing the thresholds of the two scoring credit cards? Either brute force, or use QUBOthe model of problem one.

The violent solution is as follows:

import pandas as pd

if __name__ == '__main__':
    # 定义一些变量
    L = 1000000  # 贷款资金
    I = 0.08  # 利息收入率

    # 迭代次数
    Iter = 10

    # 选取第几列的信用卡,初始化最开始选择的数据
    card1, threshold1, card2, threshold2, card3, threshold3 = 1, 0, 2, 0, 3, 0

    # 定义最大的数
    max_value = -1
    # 读取数据
    df = pd.read_csv('../data/附件1：data_100.csv', header=0)

    for iter in range(Iter):  # 迭代次数，其实这里还可以根据几次迭代算出的总值来提前结束迭代
        # 设置更新迭代,不使用临时变量
        card1, threshold1, card2, threshold2, card3, threshold3 = card2, threshold2, card3, threshold3, card1, threshold1

        # 从固定的信用卡1和信用卡2外数据中选一个，构建可以选择的卡的集合
        choose_list = {
    
    i for i in range(1, 101) if i not in (card1, card2)}

        # 获取第一张卡和第二张卡的通过率和坏账率，否则在循环里重复获取了
        t1 = df[f"t_{
      
      card1}"].iloc[threshold1]
        t2 = df[f"t_{
      
      card2}"].iloc[threshold2]
        h1 = df[f"h_{
      
      card1}"].iloc[threshold1]
        h2 = df[f"h_{
      
      card2}"].iloc[threshold2]

        # 固定第一张卡,和第二张卡，然后找到最佳的第三张卡
        for c3 in choose_list:
            for th3 in range(0, 10):
                # 总通过率
                P = t1 * t2 * df[f"t_{
      
      c3}"].iloc[th3]

                # 总坏账率
                Q = (h1 + h2 + df[f"h_{
      
      c3}"].iloc[th3]) / 3

                # 此时的最终收入
                temp_value = L * I * P * (1 - Q) - L * P * Q

                if temp_value > max_value:
                    max_value = temp_value
                    card3 = c3
                    threshold3 = th3

    print(f"最大值：{
      
      max_value},卡选择:{
      
      card1}_{
      
      threshold1 + 1},{
      
      card2}_{
      
      threshold2 + 1},{
      
      card3}_{
      
      threshold3 + 1}")

Greedy + QUBO

code:

import pandas as pd
import time
import re
from pyqubo import Array, Constraint
from dwave.samplers import SimulatedAnnealingSampler
import numpy as np
from pyqubo import Placeholder

# 在字典中找到value的key
def get_key(dict, value):
    return [k for k, v in dict.items() if v == value]


def main():
    # 定义一些变量
    L = 1000000  # 贷款资金
    I = 0.08  # 利息收入率

    # 迭代次数
    Iter = 10

    # 选取第几列的信用卡,初始化最开始选择的数据
    card1, threshold1, card2, threshold2, card3, threshold3 = 1, 0, 2, 0, 3, 0

    # 定义最大的数
    max_value = -1
    # 读取数据
    df = pd.read_csv('../data/附件1：data_100.csv', header=0)

    for iter in range(Iter):  # 迭代次数，其实这里还可以根据几次迭代算出的总值来提前结束迭代
        # 设置更新迭代,不使用临时变量
        card1, threshold1, card2, threshold2, card3, threshold3 = card2, threshold2, card3, threshold3, card1, threshold1

        # 获取第一张卡和第二张卡的通过率和坏账率
        t1 = df[f"t_{
      
      card1}"].iloc[threshold1]
        t2 = df[f"t_{
      
      card2}"].iloc[threshold2]
        h1 = df[f"h_{
      
      card1}"].iloc[threshold1]
        h2 = df[f"h_{
      
      card2}"].iloc[threshold2]

        # 获取第三张卡能够选取的通过率与坏账率的矩阵

        choose_index = [i for i in range(1, 101) if i not in (card1, card2)]
        card3_data = df.drop([f"t_{
      
      card1}", f"h_{
      
      card1}", f"t_{
      
      card2}", f"h_{
      
      card2}"], axis=1).values

        # 获取T矩阵和H矩阵
        T = card3_data[:, ::2]
        H = card3_data[:, 1::2]

        # 定义二进制决策变量,10 * 98
        x = Array.create('x', shape=(10, 98), vartype='BINARY')
        # 定义惩罚项M
        M = Placeholder('M')
        M = 50000

        # 定义哈密顿量,也就是对应的目标函数
        P = t1 * t2 * np.sum(np.multiply(x, T))
        Q = (h1 + h2 + np.sum(np.multiply(x, H))) / 3
        H = - (L * I * P * (1 - Q) - L * P * Q) + M * Constraint((np.sum(x) - 1) ** 2, label='sum(x_i_j) = 1')

        # 编译哈密顿量得到一个模型
        model = H.compile()
        bqm = model.to_bqm()
        # 记录开始退火时间
        start = time.time()

        #
        sa = SimulatedAnnealingSampler()

        sampleset = sa.sample(bqm, seed=666, beta_range=[10e-10, 50], num_sweeps=999, beta_schedule_type='geometric',
                              num_reads=50)

        # 对数据进行筛选，对选取的数据进行选取最优的
        decoded_samples = model.decode_sampleset(sampleset)  # 将上述采样最好的num_reads组数据变为模型可读的样本数据
        best_sample = min(decoded_samples, key=lambda x: x.energy)  # 将能量值最低的样本统计出来，表示BQM的最优解

        end = time.time()
        # print(f"退火时间花费：{end - start} s")

        # 统计决策变量为1的所有数据,并对第一个数据进行拆解，获得对应的下标
        data_1_list = get_key(best_sample.sample, 1)
        index_i_j = re.findall(r'\d+', data_1_list[0])
        index_i = int(index_i_j[0])

        if max_value < - best_sample.energy:
            card3 = choose_index[int(index_i_j[1])]
            threshold3 = index_i
            max_value = - best_sample.energy

        print(
            f"第{
      
      iter + 1}次迭代，最大值：{
      
      max_value},卡选择:{
      
      card1}_{
      
      threshold1 + 1},{
      
      card2}_{
      
      threshold2 + 1},{
      
      card3}_{
      
      threshold3 + 1}")

    print(f"最大值：{
      
      max_value},卡选择:{
      
      card1}_{
      
      threshold1 + 1},{
      
      card2}_{
      
      threshold2 + 1},{
      
      card3}_{
      
      threshold3 + 1}")


if __name__ == '__main__':
    start = time.time()
    main()
    end = time.time()
    print(f"时间花费： {
      
      end - start}s")