Пример #1
0
 def __init__(self, m, k, formulation='penalizedl1', nonnegative=False):
     if not cvx_available:
         raise RuntimeError(
             'Cannot initialize when cvxpy is not available.')
     # Initialize parameters and variables
     A = cvx.Parameter((m, k))
     b = cvx.Parameter((m, 1))
     l = cvx.Parameter(nonneg=True)
     x = cvx.Variable((k, 1))
     # Create the problem
     if formulation == 'penalizedl1':
         obj_func = 0.5 * cvx.sum_squares(cvx.matmul(A, x) -
                                          b) + l * cvx.norm1(x)
         constraints = []
     elif formulation == 'constrainedl1':
         obj_func = cvx.sum_squares(cvx.matmul(A, x) - b)
         constraints = [cvx.norm1(x) <= l]
     elif formulation == 'constrainedl2':
         obj_func = cvx.norm1(x)
         constraints = [cvx.norm(cvx.matmul(A, x) - b) <= l]
     else:
         raise ValueError("Unknown formulation '{0}'.".format(formulation))
     if nonnegative:
         constraints.append(x >= 0)
     problem = cvx.Problem(cvx.Minimize(obj_func), constraints)
     self._formulation = formulation
     self._A = A
     self._b = b
     self._l = l
     self._x = x
     self._obj_func = obj_func
     self._constraints = constraints
     self._problem = problem
    def findPiercingNumber(self):
        # Finding piercing number using an integer linear program (ILP) formulation
        # (a linear program (LP) that is constrained to have integer solutions)

        # First, find constraint matrix/data for LP used to find piercing number
        # Candidate piercing points are the endpoints of the intervals
        _, orderedendpts = self.listSetEndpoints()
        N = self.numVoters
        M = 2 * N
        Mat = np.empty([N, M])
        for i in np.arange(0, N):
            for j, p in enumerate(orderedendpts):
                A = self.approvalSets[i]
                Mat[i, j] = A.isPointInSet(p)

        # Next, vector of coefficients of objective function
        c = np.ones(M)

        ## Solve ILP using cvxpy
        x = cp.Variable(M, integer=True)
        objective = cp.Minimize(cp.matmul(c, x))
        constraints = [cp.matmul(Mat, x) >= np.ones(N), 0 <= x, x <= 1]
        prob = cp.Problem(objective, constraints)
        val = prob.solve(solver='GLPK_MI')
        piercingNumber = int(np.round(val))
        piercingSet = np.transpose(orderedendpts)[np.round(x.value) > 0]

        return piercingNumber, piercingSet, x.value, Mat
Пример #3
0
def estimate_parameters(y, mat1, mat2, gamma=0.1, beta=0.1):
    th1 = cvx.Variable(mat1.shape[1])
    th2 = cvx.Variable(mat2.shape[1])
    if gamma is None:
        gamma = 2 * np.sqrt(2 * np.log(len(y)))
    cost = (cvx.sum_squares(y - cvx.matmul(mat1, th1) - cvx.matmul(mat2, th2))
            + gamma * cvx.norm1(th2) + beta * cvx.norm(th1[1:]))
    problem = cvx.Problem(cvx.Minimize(cost))
    problem.solve()
    # th1.value[np.abs(th1.value) <= 1e-2 * th1.value[0]] = 0
    # th2.value[np.abs(th2.value) <= 1e-2 * np.max(th2.value)] = 0
    # sparsity_pattern_1 = np.abs(th1.value) <= 1e-2
    sparsity_pattern_2 = np.abs(th2.value) <= 1e-2
    cost = (cvx.sum_squares(y - cvx.matmul(mat1, th1) - cvx.matmul(mat2, th2))
            + beta * cvx.norm(th1[1:]))
    constraints = []
    # if np.sum(sparsity_pattern_1) > 0:
    #     constraints.append(th1[sparsity_pattern_1] == 0)
    if np.sum(sparsity_pattern_2) > 0:
        constraints.append(th2[sparsity_pattern_2] == 0)
    problem = cvx.Problem(cvx.Minimize(cost), constraints)
    problem.solve()
    # th1.value[np.abs(th1.value) < 1e-4] = 0
    th2.value[np.abs(th2.value) < 1e-4] = 0
    return th1.value, th2.value
def LinProg(A, alpha, r):
    x = cp.Variable(shape=(len(state_action_pairs), 1), name="x")

    constraints = [cp.matmul(A, x) == alpha, x >= 0]
    objective = cp.Maximize(cp.matmul(r, x))
    problem = cp.Problem(objective, constraints)

    return x, problem.solve()
Пример #5
0
def find_X_sol_agent(Y_s, Q, num_tasks, total_num_agents):
    X_sol = cp.Variable((num_tasks, total_num_agents), boolean=True)
    mismatch = Y_s - cp.matmul(X_sol, Q)
    obj = cp.Minimize(cp.pnorm(mismatch, 2))
    constraints = [cp.matmul(X_sol.T, np.ones([num_tasks, 1])) <= np.ones([total_num_agents , 1]), 
                    cp.matmul(X_sol, np.ones([total_num_agents, 1])) == 3*np.ones([num_tasks, 1])]
    opt_prob = cp.Problem(obj, constraints)
    opt_prob.solve()
    X_candidate = np.round(X_sol.value)
    return X_candidate
Пример #6
0
 def __init__(self, nb_measure, alpha=0.95):
     self.h = cp.Variable(nb_measure, nonneg=True)
     self.p = cp.Parameter(nb_measure, nonneg=True)
     self.v = cp.Parameter(nb_measure)
     objective = cp.Maximize(cp.matmul(self.v, cp.multiply(self.h, self.p)))
     constraints = [
         self.h <= 1 / (1 - alpha),
         cp.matmul(self.h, self.p) == 1
     ]
     self.problem = cp.Problem(objective, constraints)
Пример #7
0
 def __init__(self, u):
     self.u = u
     self.v = np.array([1.0 / (np.log(2 + i)) for i, _ in enumerate(u)])
     self.v[range(10, len(self.v))] = 0
     self.P = cp.Variable((len(u), len(u)))
     self.I = np.ones((len(u),))
     self.constraints = [cp.matmul(self.I.transpose(), self.P) == self.I.transpose(),
                         cp.matmul(self.P, self.I) == self.I,
                         0 <= self.P, self.P <= 1
                         ]
     self.all_constraints = None
Пример #8
0
 def __init__(self, nb_measure, q=2, c=1):
     self.h = cp.Variable(nb_measure, nonneg=True)
     self.p = cp.Parameter(nb_measure, nonneg=True)
     self.v = cp.Parameter(nb_measure)
     self.g = cp.multiply(self.p, 1 + self.h - cp.matmul(self.h, self.p))
     objective = cp.Maximize(cp.matmul(self.v, self.g))
     constraints = [
         self.g >= 0,
         cp.matmul(cp.power(self.h, q), self.p) <= c**q
     ]
     self.problem = cp.Problem(objective, constraints)
Пример #9
0
def get_output(r, alpha):
    r = np.array(r)
    alpha = np.array(alpha)
    x = cp.Variable(shape=(100, 1), name="x")
    constraints = [cp.matmul(A, x) == alpha, x >= 0]
    objective = cp.Maximize(cp.matmul(r, x))
    problem = cp.Problem(objective, constraints)
    solution = problem.solve()
    for i in range(len(x.value)):
        solutionx.append(x.value[i][0])

    return solution
Пример #10
0
 def __init__(self, nb_measure, alpha=0.95):
     self.alpha = alpha
     self.z = cp.Variable(nb_measure, nonneg=True)
     self.p = cp.Parameter(nb_measure, nonneg=True)
     self.v = cp.Parameter(nb_measure)
     dkl = cp.matmul(self.p, -cp.entr(self.z))
     objective = cp.Maximize(cp.matmul(self.p, cp.multiply(self.v, self.z)))
     constraints = [
         dkl <= np.log(1 / (1 - self.alpha)),
         cp.matmul(self.p, self.z) == 1
     ]
     self.problem = cp.Problem(objective, constraints)