Функция MILP Scipy [закрыто] ⇐ Python

[Anonymous]

Запуск проблемы оптимизации с использованием функции MILP Scipy. Я добираюсь до точки, когда появляется решающий отчет - либо через ограничение срока, либо решение. (см. ниже). В любом случае, когда появляется решающий отчет, я предполагаю, что функция вернется, и мой сценарий продолжится. Однако у меня есть печатный оператор сразу после функции, измеряющего время прошедшего времени, и время между решающим отчетом, и истекшим временем печати сильно варьируется. Есть ли способ оптимизировать эту оптимизацию LOL
[Решение отчета, отображаемое командной строкой] < /p>
Solving report
Status Optimal
Primal bound -39
Dual bound -39
Gap 0% (tolerance: 0.01%)
P-D integral 0
Solution status feasible
-39 (objective)
0 (bound viol.)
0 (int. viol.)
0 (row viol.)
Timing 12.29 (total)
0.00 (presolve)
0.00 (solve)
0.00 (postsolve)
Max sub-MIP depth 12
Nodes 1
Repair LPs 0 (0 feasible; 0 iterations)
LP iterations 29704 (total)
0 (strong br.)
2544 (separation)
18467 (heuristics)
< /code>
Я попытался манипулировать данными, чтобы облегчить их, я заметил, что при запуске MILP на более мелких наборах данных он будет возвращаться быстрее, но даже на более мелких наборах данных он все равно будет загадка. Имейте в виду, что я установил бы 540 второй срок, но затем функция не вернулась бы еще на 1500 секунд.
Используя версию SCIPY 1.15.2
Это код, который я использовал для инициализации MILP:
def solve_and_extract(df_chunk, time_limit):
n = len(df_chunk)
if n < 10:
return [], df_chunk.copy(), False
m = n // 10
caps = df_chunk['Col1'].astype(float).to_numpy()
fr = df_chunk['Col2'].astype(float).to_numpy()

c = np.concatenate([np.zeros(n*m), -np.ones(m), np.zeros(n)])
integrality = np.ones(n*m + m + n, dtype=int)
bounds = Bounds(0, 1)

A_link1 = np.zeros((n, n*m + m + n)); b_link1 = np.zeros(n)
A_link2 = np.zeros((n, n*m + m + n)); b_link2 = np.zeros(n)
for i in range(n):
A_link1[i, i + np.arange(m)*n] = 1
A_link1[i, n*m + m + i] = -1
A_link2[i, i + np.arange(m)*n] = -1
A_link2[i, n*m + m + i] = 1

A2a = np.zeros((m, n*m + m + n)); b2a = np.zeros(m)
A2b = np.zeros((m, n*m + m + n)); b2b = np.zeros(m)
for j in range(m):
A2a[j, j*n:(j+1)*n] = 1
A2a[j, n*m + j] = -10
A2b[j, j*n:(j+1)*n] = -1
A2b[j, n*m + j] = 10

A3 = np.zeros((m, n*m + m + n)); b3 = np.zeros(m)
A4 = np.zeros((m, n*m + m + n)); b4 = np.zeros(m)
A5 = np.zeros((m, n*m + m + n)); b5 = np.zeros(m)
A6 = np.zeros((m, n*m + m + n)); b6 = np.zeros(m)
for j in range(m):
A3[j, j*n:(j+1)*n] = caps
A3[j, n*m + j] = -maxc*10
A4[j, j*n:(j+1)*n] = -caps
A4[j, n*m + j] = minc*10
A5[j, j*n:(j+1)*n] = fr
A5[j, n*m + j] = -max_fr*10
A6[j, j*n:(j+1)*n] = -fr
A6[j, n*m + j] = min_fr*10

A_sym = np.zeros((m-1, n*m + m + n)); b_sym = np.zeros(m-1)
for j in range(m-1):
A_sym[j, n*m + j] = 1
A_sym[j, n*m + j+1] = -1

A7 = np.zeros((1, n*m + m + n))
A7[0, n*m + m:] = +1
A7[0, n*m:n*m+m] = -10

constraints = [
LinearConstraint(A2a, -np.inf, b2a),
LinearConstraint(A2b, -np.inf, b2b),
LinearConstraint(A3, -np.inf, b3),
LinearConstraint(A4, -np.inf, b4),
LinearConstraint(A5, -np.inf, b5),
LinearConstraint(A6, -np.inf, b6),
LinearConstraint(A7, -np.inf, 0),
LinearConstraint(A_link1, -np.inf, b_link1),
LinearConstraint(A_link2, -np.inf, b_link2),
LinearConstraint(A_sym, b_sym, np.inf)
]

res = milp(
c=c,
integrality=integrality,
bounds=bounds,
constraints=constraints,
options={"disp": True, "time_limit": time_limit}
)


Подробнее здесь: https://stackoverflow.com/questions/796 ... p-function