二次规划使用什么方法求解！论文中就这么写！

实操中如果不想写代码，那就调用CVXPY工具箱吧！

QP问题 的求解貌似还是要明确的写出P,q,G,h,A,b的。

尝试过cvxpy的常规优化写法，总是报错：说优化问题不符合DCP rules

import matlab
import matlab.engine
import numpy as np
import pandas as pd
import xlwt
from pathlib import Path
from copy import deepcopy
from mord import LogisticAT
from collections import OrderedDict
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import accuracy_score,mean_absolute_error,f1_score,recall_score
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics.pairwise import rbf_kernel
import cvxpy as cp
import cvxopt as opt

class KDLAOR():
    def __init__(self,X_train,y_train):
        self.X_train = X_train
        self.y_train = y_train
        self.nSample, self.nAtt = self.X_train.shape
        self.labels = np.sort(np.unique(self.y_train))
        self.nClass = len(self.labels)
        # print("cClass",self.nClass)
        self.nEachClass = []
        self.Mean = self.get_Mean()
        self.totalMean = np.mean(self.X_train,axis=0)
        self.Sw = self.get_Sw()
        self.Sb = self.get_Sb()
        self.subMean = self.get_subMean()
        self.invSw = np.linalg.inv(self.Sw)
        self.C = 1

    def get_Mean(self):
        Mean = np.zeros((self.nClass,self.nAtt))
        for i, lab in enumerate(self.labels):
            idx_list = np.where(self.y_train == lab)
            Mean[i] = np.mean(self.X_train[idx_list],axis=0)
            self.nEachClass.append(len(idx_list))
        return Mean


    def get_Sw(self):
        Sw = np.zeros((self.nAtt,self.nAtt))
        for i, lab in enumerate(self.labels):
            X_i = self.X_train[np.where(self.y_train == lab)] - self.Mean[i]
            Sw += (self.nEachClass[i] / self.nSample) * X_i.T @ X_i
        return Sw

    def get_Sb(self):
        Sb = np.zeros((self.nAtt,self.nAtt))
        for i, lab in enumerate(self.labels):
            A = self.Mean[i] - self.totalMean
            Sb += (self.nEachClass[i] / self.nSample) * np.outer(A,A)
        return Sb

    def get_subMean(self):
        subMean = np.ones((self.nClass-1,self.nAtt))
        for k in range(self.nClass-1):
            subMean[k] = self.Mean[k+1] - self.Mean[k]
        return subMean

    def Optimal(self):
        alpha = cp.Variable((self.nClass-1,1))
        print("K-1:",self.nClass-1)
        print("alpha::",alpha.shape)
        print("subMean::",self.subMean.shape)
        print("invSw::",self.invSw.shape)
        Mid = self.subMean @ self.invSw @ self.subMean.T

        # obj = cp.Minimize(alpha.T @ Mid @ alpha)
        # constraint = [alpha >=0, cp.sum(alpha) == 10]
        # cp.Problem(obj,constraint).solve()
        # print(Mid)


        P = Mid * 2
        x = cp.Variable(self.nClass-1)
        q = np.zeros(self.nClass-1)
        A = np.ones(self.nClass-1)
        b = 10
        G = -1 * np.eye(self.nClass-1)
        h = np.zeros(self.nClass-1)
        prob = cp.Problem(cp.Minimize((1 / 2) * cp.quad_form(x, P) + q.T @ x),[G @ x <= h, A @ x ==b])
        prob.solve()
        print(prob.value)
        print(x.value)







if __name__ == '__main__':
    path0 = r"D:\OCdata\balance-scale.csv"
    path1 = r"D:\OCdata\car.csv"
    path2 = r"D:\OCdata\ERA.csv"
    path3 = r"D:\OCdata\ESL.csv"
    path4 = r"D:\OCdata\eucalyptus.csv"
    path5 = r"D:\OCdata\LEV.csv"
    path6 = r"D:\OCdata\newthyroid.csv"
    path7 = r"D:\OCdata\SWD.csv"
    path8 = r"D:\OCdata\toy.csv"
    path9 = r"D:\OCdata\winequality-red.csv"
    path10 = r"D:\OCdata\regression\abalone15-5bin.csv"
    path11 = r"D:\OCdata\regression\bank15-5bin.csv"
    path12 = r"D:\OCdata\regression\census15-5bin.csv"
    path13 = r"D:\OCdata\regression\computer15-5bin.csv"
    path14 = r"D:\OCdata\regression\housing-5bin.csv"
    path15 = r"D:\OCdata\regression\machine-5bin.csv"
    data = np.array(pd.read_csv(path9, header=None))
    X = data[:, :-1]
    y = data[:, -1].astype(np.int)
    print("数据类别：",np.unique(y))
    print("类别个数：",len(np.unique(y)))
    print("阈值个数:",len(np.unique(y))-1)

    # X,y = load_iris(return_X_y=True)
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=10)
    clf = KDLAOR(X_train=X_train,y_train=y_train)
    clf.Optimal()