Почему CVXPY продолжает терпеть неудачу в решении проблем и остается осуществимым? ⇐ Python

[Anonymous]

Это выпуклая задача, которая также соответствует синтаксическим правилам CVXPY. Я пробовал менять решатель (ECOS или SCS) и корректировать параметры эксперимента, но все безуспешно.
Я использую пакет CVXPY на Python, версия CVXPY v1.7.3.
Результаты решения следующие. Я понятия не имею, в чем заключается проблема:

Тестирование распределителя ресурсов (выпуклый решатель CVXPY)

Целевое фиктивное действие:

[[0.17732602 0.11025 0.28628772 0.42613626]

[0.358793 0.21895458 0.21797714 0.20427531]

[0.10907146 0.13038586 0.6538224 0.10672026]]

Размеры задач (Мбит): [0.04617009 0.09707677 0.01234047]

Выпуклый распределитель ресурсов (CVXPY) инициализирован для 3 WD.
CVXPY
v1.7.3

(CVXPY) 9 ноября 23:20:03: В вашей задаче 29 переменных, 62 ограничения и 0 параметров.

(CVXPY) 9 ноября 23:20:03: Она совместима со следующими грамматиками: DCP, DQCP

(CVXPY) 9 ноября 23:20:03: (Если вам нужно решить эту проблему несколько раз, но с разными данными, рассмотрите возможность использования параметров.)

(CVXPY) 9 ноября 23:20:03: CVXPY сначала скомпилирует вашу задачу; затем он вызовет числовой решатель для получения решения.

(CVXPY) 9 ноября 23:20:03: Ваша проблема скомпилирована с помощью механизма канонизации CPP.

(CVXPY) 9 ноября 23:20:03: Проблема компиляции (целевой решатель=SCS).

(CVXPY) Ноябрь 09 23:20:03: Цепочка сокращения: Dcp2Cone -> CvxAttr2Constr -> ConeMatrixStuffing -> SCS

(CVXPY) 09 ноября 23:20:03: Применение сокращения Dcp2Cone

(CVXPY) 09 ноября 23:20:03: Применение сокращение CvxAttr2Constr

(CVXPY) 9 ноября 23:20:03: Применение сокращения ConeMatrixStuffing
Compilation

(CVXPY) 9 ноября 23:20:03: Применение сокращения SCS

(CVXPY) 9 ноября 23:20:03: Завершена компиляция задачи (заняло 5.687e-02 секунды).

(CVXPY) 9 ноября 23:20:03: Вызов решателя SCS для получения решения.

D:\Anaconda3\envs\mypytorch\lib\site-packages\scs_init_.py:83: Предупреждение пользователя: преобразование A в матрицу CSC (сжатый разреженный столбец); может занять некоторое время.

warn(

D:\Anaconda3\envs\mypytorch\lib\site-packages\scs_init_.py:113: UserWarning: Преобразование P в матрицу CSC (сжатый разреженный столбец); может занять некоторое время.

warn(

(CVXPY) 09 ноября 23:20:03: Статус проблемы: невозможно

(CVXPY) 9 ноября 23:20:03: Оптимальное значение: inf

(CVXPY) 09 ноября 23:20:03: Компиляция заняла 5.687e-02 секунды

(CVXPY) 9 ноября 23:20:03: Решатель (включая время, проведенное в интерфейсе) занял 4.468e-03 секунды
Numerical solver

SCS v3.2.7 - Splitting Conic Solver

(c) Брендан О'Донохью, Стэнфордский университет, 2012 г.
Проблема: переменные n: 44, ограничения m: 136

конусы: z: первичный ноль / двойные свободные переменные: 6

l: линейные переменные: 85

q: переменные soc: 18, qsize: 6

e: переменные выражения: 27, переменные двойного выражения: 0

Настройки: eps_abs: 1.0e-05, eps_rel: 1.0e-05, eps_infeas: 1.0e-07

альфа: 1.50, масштаб: 1.00e-01, Adaptive_scale: 1

max_iters: 20000, нормализовать: 1, rho_x: 1.00e-06

acceleration_lookback: 10, Acceleration_interval: 10

lin-sys: sparse-direct-amd-qdldl

nnz(A): 190, nnz(P): 3
итер | в разрешении | дуа рез | разрыв | объект | масштаб | время (сек)
0| 5.00e+07 1.14e+06 1.71e+13 8.57e+12 1.00e-01 1.70e-03

статус: невозможно

время: всего: 1.71e-03с = настройка: 1.44e-03с + решение: 2.67e-04с

lin-sys: 2.20e-06с, конусы: 1.08e-05с, ускорение: 0.00e+00s
объект = инф
Summary

status= infeasiblesolver= SCS
Результаты оптимизации ---

Ошибка оптимизации: невозможно

resource_allocator.py:
import numpy as np
import cvxpy as cp
import time
from config import * # Import all parameters from config.py
class ResourceAllocator:
"""
Given a fixed unloading matrix X,
The solver finds the optimal (a, tau, e, f, T_ex) to minimize the weighted sum.
"""

def __init__(self):
"""Initialize the solver"""
# Estimate some constants
self.C_rate = (np.log(2) * V_U) / BANDWIDTH_HZ
print(f"Convex ResourceAllocator (CVXPY) initialized for {N_WDs} WDs.")

def _calculate_loads(self, action_matrix: np.ndarray, task_sizes: np.ndarray) -> np.ndarray:
"""
Calculate the total computing load(L_j) of each WD j 。
L_j = (local tasks of WD j) + (All other tasks offloaded by WD i to WD j)
"""
N = N_WDs
loads = np.zeros(N)
for j in range(N): # Target WD j (node index j+1)
for i in range(N): # Source: WD i (Task: c_i)
# action_matrix[i, j+1] is x_{i+1, j+1}
loads[j] += task_sizes * action_matrix[i, j + 1]
return loads

def solve(self, action_matrix: np.ndarray, channel_matrix: np.ndarray, task_sizes: np.ndarray) -> dict:
"""
Solve the convex subproblem using CVXPY

Args:
action_matrix (np.ndarray): Offload decision X, shape (N_WDs, N_NODES)
channel_matrix (np.ndarray): Channel gain H, shape (N_NODES, N_NODES)
task_sizes (np.ndarray): Task size c, shape (N_WDs,)

Returns:
dict: Solution result
"""
N = N_WDs
N_nodes = N_NODES
start_opt_time = time.time()

try:
# --- 1. Pre-computed constant ---
# L_j: Each WD (j=0...) N-1, corresponding to node 1.. The total computing load (bits) of N)
L_j = self._calculate_loads(action_matrix, task_sizes)

# s_ij: The number of bits sent from WD i (node i+1) to node j
s_ij = np.zeros((N, N_nodes))
for i in range(N):
for j in range(N_nodes):
if i + 1 == j: # Skip local computing
continue
s_ij[i, j] = task_sizes * action_matrix[i, j]

# h_ij: Channel gain from WD i (node i+1) to node j
h_ij = channel_matrix[1:, :]

# gamma_ij = h_ij / N0
gamma_ij = h_ij / NOISE_POWER

# E_harv_j (coefficient): the energy collected by WD j (node j+1) from AP (node 0)
# E_harv_j = (coefficient) * a
E_harv_coeff_j = (ENERGY_HARVEST_EFFICIENCY * AP_TX_POWER_W *
ENERGY_HARVEST_SCALE_S * channel_matrix[0, 1:])

# --- 2. Define the CVXPY variable ---
# Scalar
a = cp.Variable(pos=True, name="a")
T_ex = cp.Variable(pos=True, name="T_ex")
# Vector (N_WDs)
f = cp.Variable(N, pos=True, name="f")
# Matrix (N_WDs, N_NODES)
tau = cp.Variable((N, N_nodes), pos=True, name="tau")
e = cp.Variable((N, N_nodes), pos=True, name="e")

# --- 3. Define the objective function---
# T_total = a + T_offload + T_execute
T_offload = cp.sum(tau)
T_total = a + T_offload + T_ex

# E_total = E_tx + E_comp
E_tx = cp.sum(e)
E_comp = cp.sum(CYCLES_PER_BIT * ENERGY_EFFICIENCY_COEFF * cp.multiply(L_j, cp.power(f, 2)))
E_total = E_tx + E_comp

objective = cp.Minimize(TIME_WEIGHT * T_total + ENERGY_WEIGHT * E_total)

# --- 4. Define constraints ---
constraints = []

# Variable boundary
TAU_FLOOR = 1e-9
constraints += [a >= TAU_FLOOR, a = CPU_FREQ_MIN_HZ, f

Подробнее здесь: https://stackoverflow.com/questions/798 ... n-feasible