Exemplo n.º 1
0
def reconstruct(data_matrix, missing_matrix):
    """
    Reconstructs the data_matrix after the pixels indicated in the
    missing_matrix have been removed.
    """
    flipped = (data_matrix.shape[0] < data_matrix.shape[1])
    if flipped:
        data_matrix = data_matrix.T
        missing_matrix = missing_matrix.T

    unknown_indices = nonzero(ravel(missing_matrix, order='F'))[0]
    known = matrix(data_matrix, dtype=float)
    known[nonzero(missing_matrix)] = 0.0
    u = len(unknown_indices)
    A = spmatrix(1.0, unknown_indices, range(u), (data_matrix.size, u))
    B = cvxmat(known)

    x = nrmapp(A, B)['x']
    if x is not None:
        Ax = reshape(array(A*cvxmat(x)), data_matrix.shape, order='F')
        retval = array(Ax + B, dtype=data_matrix.dtype)
        if flipped:
            retval = retval.T
        return retval
    else:
        raise Exception("Error during optimization.")
Exemplo n.º 2
0
def reconstruct(data_matrix, missing_matrix):
    """
    Reconstructs the data_matrix after the pixels indicated in the
    missing_matrix have been removed.
    """
    flipped = (data_matrix.shape[0] < data_matrix.shape[1])
    if flipped:
        data_matrix = data_matrix.T
        missing_matrix = missing_matrix.T

    unknown_indices = nonzero(ravel(missing_matrix, order='F'))[0]
    known = matrix(data_matrix, dtype=float)
    known[nonzero(missing_matrix)] = 0.0
    u = len(unknown_indices)
    A = spmatrix(1.0, unknown_indices, range(u), (data_matrix.size, u))
    B = cvxmat(known)

    x = nrmapp(A, B)['x']
    if x is not None:
        Ax = reshape(array(A * cvxmat(x)), data_matrix.shape, order='F')
        retval = array(Ax + B, dtype=data_matrix.dtype)
        if flipped:
            retval = retval.T
        return retval
    else:
        raise Exception("Error during optimization.")
Exemplo n.º 3
0
    def fit(self, X, y):
        y = (2.0*(np.asarray(y) == 1) - 1.0)
        X = np.asarray(X)
        self.data = X
        self.gram_matrix = self.kernel(X, X)

        n = len(X)
        if self.scale_C:
            C = self.C / float(n)
        else:
            C = self.C

        Y = np.diag(y)
        YK = sparse(cvxmat(np.dot(Y, self.gram_matrix)))
        Y1 = sparse(cvxmat(np.dot(Y, np.ones((n, 1)))))
        YI = sparse(cvxmat(np.dot(Y, np.eye(n))))

        c = cvxmat(sparse([spo(n), spz(n + 1), spo(n, v=C)]))
        G = sparse(t([[spz(n, n),  YK,        Y1,     YI       ],
                      [spz(n, n),  spz(n, n), spz(n), spI(n)   ],
                      [spI(n),    -spI(n),    spz(n), spz(n, n)],
                      [spI(n),     spI(n),    spz(n), spz(n, n)],
                      [spI(n),     spz(n, n), spz(n), spz(n, n)]]))
        h = cvxmat(sparse([spo(n), spz(4*n)]))

        # We want Gx >= h, but solver uses Gx <= h, so negate:
        xstar, _ = linprog(c, -G, -h, verbose=self.verbose)

        try:
            self.w = xstar[n:2*n + 1].reshape((-1,))
        except ValueError as e:
            print e
            self.w = np.zeros(n + 1)
Exemplo n.º 4
0
Arquivo: mica.py Projeto: DiNAi/misvm
            def iterate(cself, alphas, upsilon, svm):
                V = to_V(upsilon)
                cself.mention('Update QP...')
                qp.update_H(D * V * K * V.T * D)
                cself.mention('Solve QP...')
                alphas, obj = qp.solve(self.verbose)
                svm = MICA(kernel=self.kernel, gamma=self.gamma, p=self.p,
                           verbose=self.verbose, sv_cutoff=self.sv_cutoff)
                svm._X = self._X
                svm._y = self._y
                svm._V = V
                svm._alphas = alphas
                svm._objective = obj
                svm._compute_separator(K)
                svm._K = K

                cself.mention('Update LP...')
                for row, (i, j) in enumerate(slices(bs.pos_groups)):
                    G[row, i:j] = cvxmat(-svm._dotprods[Ln + i: Ln + j].T)
                h[Xp: Xp + Ln] = cvxmat(-(1 + svm._dotprods[:Ln]))

                cself.mention('Solve LP...')
                sol, _ = linprog(c, G, h, A, b, verbose=self.verbose)
                new_upsilon = sol[:Lp]

                if cself.check_tolerance(np.linalg.norm(upsilon - new_upsilon)):
                    return None, svm

                return {'alphas': alphas, 'upsilon': new_upsilon, 'svm': svm}, None
Exemplo n.º 5
0
def solve_lp(c, G, h, A=None, b=None, solver=__default_solver):
    """
    Solve a Linear Program defined by:

        minimize
            c.T * x

        subject to
            G * x <= h
            A * x == b  (optional)

    using CVXOPT <http://cvxopt.org/userguide/coneprog.html#linear-programming>.

    INPUT:

    - ``c`` -- cost vector
    - ``G`` -- inequality matrix
    - ``h`` -- inequality vector
    - ``A`` -- (optional) equality matrix
    - ``b`` -- (optional) equality vector
    - ``solver`` -- (optional) solver to use, defaults to GLPK if available
    """
    args = [cvxmat(c), cvxmat(G), cvxmat(h)]
    if A is not None:
        args.extend([cvxmat(A), cvxmat(b)])
    sol = cvxopt_lp(*args, solver=solver)
    if 'optimal' not in sol['status']:
        return None
    return array(sol['x']).reshape((c.shape[0],))
Exemplo n.º 6
0
def lp_emd(X,
           Y,
           X_weights=None,
           Y_weights=None,
           distance='euclidean',
           D=None,
           verbose=False):
    if distance != 'precomputed':
        n = len(X)
        m = len(Y)
        D = cdist(X, Y, distance)
        if X_weights is None:
            X_weights = np.ones(n) / n
        elif n != len(X_weights):
            raise ValueError('Size mismatch of X and X_weights')
        if Y_weights is None:
            Y_weights = np.ones(m) / m
        elif m != len(Y_weights):
            raise ValueError('Size mismatch of Y and Y_weights')
    else:
        if D is None:
            raise ValueError("D must be supplied when distance='precomputed'")
        n, m = D.shape
        if X_weights is None:
            X_weights = np.ones(n) / n
        elif n != len(X_weights):
            raise ValueError('Size mismatch of D and X_weights')
        if Y_weights is None:
            Y_weights = np.ones(m) / m
        elif m != len(Y_weights):
            raise ValueError('Size mismatch of D and Y_weights')

    vecD = D.reshape((-1, 1))

    # Set up objective function
    C = cvxmat(vecD)

    # Set up inequality constraints
    G = -spI(n * m)
    h = cvxmat(np.zeros((n * m, 1)))

    # Set up equality constraints
    Aeq = np.zeros((n + m - 1, n * m))

    # Sum of rows
    for r in range(n):
        Aeq[r, r * m:(r + 1) * m] = 1

    # Sum of columns
    # (Exclude final column, since contraint is determined by others)
    for c in range(m - 1):
        for r in range(n):
            Aeq[c + n, r * m + c] = 1

    sparseAeq = sparse(cvxmat(Aeq))
    b = np.vstack(
        [X_weights.reshape((-1, 1)), Y_weights[:-1].reshape((-1, 1))])
    sparseb = cvxmat(b)
    _, dist = linprog(C, G, h, sparseAeq, sparseb, verbose=verbose)
    return dist
Exemplo n.º 7
0
Arquivo: mica.py Projeto: zhaijj/misvm
            def iterate(cself, alphas, upsilon, svm):
                V = to_V(upsilon)
                cself.mention('Update QP...')
                qp.update_H(D * V * K * V.T * D)
                cself.mention('Solve QP...')
                alphas, obj = qp.solve(self.verbose)
                svm = MICA(kernel=self.kernel, gamma=self.gamma, p=self.p,
                           verbose=self.verbose, sv_cutoff=self.sv_cutoff)
                svm._X = self._X
                svm._y = self._y
                svm._V = V
                svm._alphas = alphas
                svm._objective = obj
                svm._compute_separator(K)
                svm._K = K

                cself.mention('Update LP...')
                for row, (i, j) in enumerate(slices(bs.pos_groups)):
                    G[row, i:j] = cvxmat(-svm._dotprods[Ln + i: Ln + j].T)
                h[Xp: Xp + Ln] = cvxmat(-(1 + svm._dotprods[:Ln]))

                cself.mention('Solve LP...')
                sol, _ = linprog(c, G, h, A, b, verbose=self.verbose)
                new_upsilon = sol[:Lp]

                if cself.check_tolerance(np.linalg.norm(upsilon - new_upsilon)):
                    return None, svm

                return {'alphas': alphas, 'upsilon': new_upsilon, 'svm': svm}, None
def _convert(H, f, A, b, Aeq, beq, lb, ub):
    """
    Convert everything to                                                                                              
    cvxopt-style matrices                                                                                              
    """
    P = cvxmat(H)
    q = cvxmat(f)
    if Aeq is None:
        A_ = None
    else:
        A_ = cvxmat(Aeq)
    if beq is None:
        b_ = None
    else:
        b_ = cvxmat(beq)

    if lb is None and ub is None:
        if A is None:
            G = None
            h = None
        else:
            G = cvxmat(A)
            h = cvxmat(b)
    else:
        n = len(lb)
        if A is None:
            G = sparse([-speye(n), speye(n)])
            h = cvxmat(np.vstack([-lb, ub]))
        else:
            G = sparse([cvxmat(A), -speye(n), speye(n)])
            h = cvxmat(np.vstack([b, -lb, ub]))

    return P, q, G, h, A_, b_
Exemplo n.º 9
0
def lp_emd(X, Y, X_weights=None, Y_weights=None, distance='euclidean', D=None, verbose=False):
    if distance != 'precomputed':
        n = len(X)
        m = len(Y)
        D = cdist(X, Y, distance)
        if X_weights is None:
            X_weights = np.ones(n)/n
        elif n != len(X_weights):
            raise ValueError('Size mismatch of X and X_weights')
        if Y_weights is None:
            Y_weights = np.ones(m)/m
        elif m != len(Y_weights):
            raise ValueError('Size mismatch of Y and Y_weights')
    else:
        if D is None:
            raise ValueError("D must be supplied when distance='precomputed'")
        n, m = D.shape
        if X_weights is None:
            X_weights = np.ones(n)/n
        elif n != len(X_weights):
            raise ValueError('Size mismatch of D and X_weights')
        if Y_weights is None:
            Y_weights = np.ones(m)/m
        elif m != len(Y_weights):
            raise ValueError('Size mismatch of D and Y_weights')

    vecD = D.reshape((-1, 1))

    # Set up objective function
    C = cvxmat(vecD)

    # Set up inequality constraints
    G = -spI(n*m)
    h = cvxmat(np.zeros((n*m, 1)))

    # Set up equality constraints
    Aeq = np.zeros((n+m-1, n*m))

    # Sum of rows
    for r in range(n):
        Aeq[r, r*m:(r+1)*m] = 1

    # Sum of columns
    # (Exclude final column, since contraint is determined by others)
    for c in range(m-1):
        for r in range(n):
            Aeq[c+n, r*m + c] = 1

    sparseAeq = sparse(cvxmat(Aeq))
    b = np.vstack([X_weights.reshape((-1, 1)), Y_weights[:-1].reshape((-1, 1))])
    sparseb = cvxmat(b)
    _, dist = linprog(C, G, h, sparseAeq, sparseb, verbose=verbose)
    return dist
def _convert(H, f, Aeq, beq, lb, ub):
    P = cvxmat(H)
    q = cvxmat(f)
    if Aeq is None:
        A = None
    else:
        A = cvxmat(Aeq)
    if beq is None:
        b = None
    else:
        b = cvxmat(beq)
    n = lb.size
    G = sparse([-speye(n), speye(n)])
    h = cvxmat(np.vstack([-lb, ub]))
    return P, q, G, h, A, b
Exemplo n.º 11
0
def problem_data_prep(problem_data):
    '''
    'Touch up' the problem data in the following ways:
      - Make sure the matrix elements aren't integers
      - Make sure they're dense matrices rather than sparse ones, otherwise
        there seem to be difficulties constructing block matrices
      - Transpose c to be a row vector, which matches the organization of A, b, G, h
        (rows are for constraints, columns are for variables)
    '''
    problem_data['A'] = cvxmat(1. * problem_data['A'])
    problem_data['b'] = cvxmat(1. * problem_data['b'])
    problem_data['G'] = cvxmat(1. * problem_data['G'])
    problem_data['h'] = cvxmat(1. * problem_data['h'])
    problem_data['c'] = cvxmat(1. * problem_data['c']).T
    return problem_data
Exemplo n.º 12
0
def problem_data_prep(problem_data):
    '''
    'Touch up' the problem data in the following ways:
      - Make sure the matrix elements aren't integers
      - Make sure they're dense matrices rather than sparse ones, otherwise
        there seem to be difficulties constructing block matrices
      - Transpose c to be a row vector, which matches the organization of A, b, G, h
        (rows are for constraints, columns are for variables)
    '''
    problem_data['A'] = cvxmat(1. * problem_data['A'])
    problem_data['b'] = cvxmat(1. * problem_data['b'])
    problem_data['G'] = cvxmat(1. * problem_data['G'])
    problem_data['h'] = cvxmat(1. * problem_data['h'])
    problem_data['c'] = cvxmat(1. * problem_data['c']).T
    return problem_data
Exemplo n.º 13
0
def solve_lp(c, G, h, A=None, b=None, solver=GLPK_IF_AVAILABLE):
    """
    Solve a linear program defined by:

    .. math::

        \\begin{eqnarray}
        \\mathrm{minimize} & & c^T x \\\\
        \\mathrm{subject\\ to} & & G x \\leq h \\\\
            & & A x = b
        \\end{eqnarray}

    using the `CVXOPT
    <http://cvxopt.org/userguide/coneprog.html#linear-programming>`_ interface
    to LP solvers.

    Parameters
    ----------
    c : array, shape=(n,)
        Linear-cost vector.
    G : array, shape=(m, n)
        Linear inequality constraint matrix.
    h : array, shape=(m,)
        Linear inequality constraint vector.
    A : array, shape=(meq, n), optional
        Linear equality constraint matrix.
    b : array, shape=(meq,), optional
        Linear equality constraint vector.
    solver : string, optional
        Solver to use, default is GLPK if available

    Returns
    -------
    x : array, shape=(n,)
        Optimal solution to the LP, if found, otherwise ``None``.

    Raises
    ------
    ValueError
        If the LP is not feasible.
    """
    args = [cvxmat(c), cvxmat(G), cvxmat(h)]
    if A is not None:
        args.extend([cvxmat(A), cvxmat(b)])
    sol = lp(*args, solver=solver)
    if 'optimal' not in sol['status']:
        raise ValueError("LP optimum not found: %s" % sol['status'])
    return array(sol['x']).reshape((c.shape[0], ))
Exemplo n.º 14
0
 def update_Aeq(self, Aeq):
     if Aeq is None:
         self.A = None
     else:
         self.A = cvxmat(Aeq)
     # Old results no longer valid
     self.last_results = None
Exemplo n.º 15
0
 def _ensure_pd(self, epsilon):
     """
     Add epsilon times identity matrix
     to P to ensure numerically it is P.D.
     """
     n = self.P.size[0]
     self.P = self.P + cvxmat(epsilon * eye(n))
Exemplo n.º 16
0
 def update_Aeq(self, Aeq):
     if Aeq is None:
         self.A = None
     else:
         self.A = cvxmat(Aeq)
     # Old results no longer valid
     self.last_results = None
Exemplo n.º 17
0
 def _ensure_pd(self, epsilon):
     """
     Add epsilon times identity matrix
     to P to ensure numerically it is P.D.
     """
     n = self.P.size[0]
     self.P = self.P + cvxmat(epsilon * eye(n))
Exemplo n.º 18
0
def _convert(H, f, Aeq, beq, lb, ub):
    """
    Convert everything to
    cvxopt-style matrices
    """
    P = cvxmat(H)
    q = cvxmat(f)
    if Aeq is None:
        A = None
    else:
        A = cvxmat(Aeq)
    if beq is None:
        b = None
    else:
        b = cvxmat(beq)

    n = lb.size
    G = sparse([-speye(n), speye(n)])
    h = cvxmat(vstack([-lb, ub]))
    return P, q, G, h, A, b
Exemplo n.º 19
0
def _convert(H, f, Aeq, beq, lb, ub):
    """
    Convert everything to                                                                                              
    cvxopt-style matrices                                                                                              
    """
    P = cvxmat(H)
    q = cvxmat(f)
    if Aeq is None:
        A = None
    else:
        A = cvxmat(Aeq)
    if beq is None:
        b = None
    else:
        b = cvxmat(beq)

    n = lb.size
    G = sparse([-speye(n), speye(n)])
    h = cvxmat(np.vstack([-lb, ub]))
    return P, q, G, h, A, b
Exemplo n.º 20
0
    def cvxopt_solve_qp(P, q, G, h, A=None, b=None, initvals=None):
        """
        Solve a Quadratic Program defined as:

            minimize
                (1/2) * x.T * P * x + q.T * x

            subject to
                G * x <= h
                A * x == b  (optional)

        using CVXOPT
        <http://cvxopt.org/userguide/coneprog.html#quadratic-programming>.
        """
        # CVXOPT only considers the lower entries of P so we project on its
        # symmetric part beforehand
        P = .5 * (P + P.T)
        args = [cvxmat(P), cvxmat(q), cvxmat(G), cvxmat(h)]
        if A is not None:
            args.extend([cvxmat(A), cvxmat(b)])
        sol = cvxopt_qp(*args, initvals=initvals)
        if not ('optimal' in sol['status']):
            warn("QP optimum not found: %s" % sol['status'])
            return None
        return array(sol['x']).reshape((P.shape[1],))
Exemplo n.º 21
0
def create_param_for_soft_margin(K, H, L, C):
    """    
    P, q, G, h, A, b = _convert(H, f, Aeq, beq, lb, ub)
    return P, q, G, h, A, b 
    results = qp(P, q, G, h, A, b)

    P = cvxmat(H)
    q = cvxmat(f)
    if Aeq is None:
        A = None
    else:
        A = cvxmat(Aeq)
    if beq is None:
        b = None
    else:
        b = cvxmat(beq)
    n = lb.size
    G = sparse([-matrix.eye(n), matrix.eye(n)])
    h = cvxmat(vstack([-lb, ub]))
    """

    # To calculate the threshold using a convex quadratic programming
    N = len(H)
    Q = cvxmat(H)
    p = cvxmat(-ones(N))
    G = cvxmat(vstack((diag([-1.0] * N), identity(N))))
    h = cvxmat(hstack((zeros(N), (ones(N) * C))))
    A = cvxmat(array(L), (1, N))
    b = cvxmat(0.0)

    sol = cvxopt.qp(Q, p, G, h, A, b)
    alpha = array(sol['x']).reshape(N)

    return alpha
Exemplo n.º 22
0
def fit_one_class_svm(delta_X, weights, v, mt_feat_types_):

    mt_feat_types = np.asarray(mt_feat_types_, dtype=np.int32)
    N = delta_X.shape[0]
    p = delta_X.shape[1]
    mt_feats = np.arange(p)[
        mt_feat_types != 0]  #np.asarray(list(incr_feats) + list(decr_feats))
    nmt_feats = np.arange(p)[mt_feat_types == 0]  #np.asarray(
    solvers.options['show_progress'] = False
    if N == 0:
        return np.zeros(delta_X.shape[1])  #[-99]
    else:
        # Build QP matrices
        # Minimize     1/2 x^T P x + q^T x
        # Subject to   G x <= h
        #             A x = b
        if weights is None:
            weights = np.ones(N)
        P = np.zeros([p + 2 * N, p + 2 * N])
        lambda_ = N
        for ip in nmt_feats:
            P[ip, ip] = lambda_ * 0.01
        for ip in mt_feats:
            P[ip, ip] = lambda_ * 0.0001  # 0.01
        q = np.zeros(p + 2 * N)
        q[p:p + N] = v
        q[p + N:] = (1. - v)
        G1a = np.zeros([p, p])
        for ip in np.arange(p):
            G1a[ip, ip] = -1 if ip in mt_feats else 1
        G1 = np.hstack([G1a, np.zeros([p, 2 * N])])
        G2 = np.hstack([np.zeros([2 * N, p]), -np.eye(2 * N)])
        G3 = np.hstack([-delta_X, -np.eye(N), np.zeros([N, N])])
        G4 = np.hstack([delta_X, np.zeros([N, N]), -np.eye(N)])
        G = np.vstack([G1, G2, G3, G4])
        h = np.zeros([p + 4 * N])
        A = np.zeros([1, p + 2 * N])
        for ip in np.arange(p):
            A[0, ip] = 1 if ip in mt_feats else -1
        b = np.asarray([1.])
        P = cvxmat(P)
        q = cvxmat(q)
        A = cvxmat(A)
        b = cvxmat(b)
        # options['abstol']=1e-20 #(default: 1e-7).
        # options['reltol']=1e-11 #(default: 1e-6)
        sol = solvers.qp(P, q, cvxmat(G), cvxmat(h), A, b)

        if sol['status'] != 'optimal':
            print('****** NOT OPTIMAL ' + sol['status'] + ' ******* [N=' +
                  str(N) + ', p=' + str(p) + ']')
            return np.zeros(delta_X.shape[1]) - 99  #[-99]
        else:
            soln = sol['x']
            w = np.ravel(soln[0:p, :])
            if np.sum(np.abs(w)) == 0.:
                print('what the?')
            # err = np.asarray(soln[-N:, :])
            return w
Exemplo n.º 23
0
def solve_qp(P, q, G, h, A=None, b=None, solver=None, sym_proj=False):
    """
    Solve a quadratic program defined as:

    .. math::

        \\begin{eqnarray}
        \\mathrm{minimize} & & (1/2) x^T P x + q^T x \\\\
        \\mathrm{subject\\ to} & & G x \\leq h \\\\
            & & A x = b
        \\end{eqnarray}

    using CVXOPT
    <http://cvxopt.org/userguide/coneprog.html#quadratic-programming>.

    Parameters
    ----------
    P : array, shape=(n, n)
        Symmetric quadratic-cost matrix.
    q : array, shape=(n,)
        Quadratic-cost vector.
    G : array, shape=(m, n)
        Linear inequality matrix.
    h : array, shape=(m,)
        Linear inequality vector.
    A : array, shape=(meq, n), optional
        Linear equality matrix.
    b : array, shape=(meq,), optional
        Linear equality vector.
    solver : string, optional
        Set to 'mosek' to run MOSEK rather than CVXOPT.
    sym_proj : bool, optional
        Set to `True` when the `P` matrix provided is not symmetric.

    Returns
    -------
    x : array, shape=(n,)
        Solution to the QP, if found, otherwise ``None``.

    Note
    ----
    CVXOPT only considers the lower entries of `P`, assuming it is symmetric. If
    that is not the case, set `sym_proj=True` to project it on its symmetric
    part beforehand.
    """
    if sym_proj:
        P = .5 * (P + P.T)
    args = [cvxmat(P), cvxmat(q), cvxmat(G), cvxmat(h)]
    if A is not None:
        args.extend([cvxmat(A), cvxmat(b)])
    sol = qp(*args, solver=solver)
    if not ('optimal' in sol['status']):
        raise ValueError("QP optimum not found: %s" % sol['status'])
    return array(sol['x']).reshape((P.shape[1], ))
Exemplo n.º 24
0
def fit_one_class_svm_pub(delta_X, delta_y, weights, v, mt_feat_types):

    N = delta_X.shape[0]
    p = delta_X.shape[1]
    mt_feats = np.arange(p)[
        mt_feat_types != 0]  #np.asarray(list(incr_feats) + list(decr_feats))
    nmt_feats = np.arange(p)[mt_feat_types == 0]  #np.asarray(
    solvers.options['show_progress'] = False
    if N == 0:
        return np.zeros(delta_X.shape[1])  #[-99]
    else:
        # Build QP matrices
        # Minimize     1/2 x^T P x + q^T x
        # Subject to   G x <= h
        #             A x = b
        if weights is None:
            weights = np.ones(N)
        P = np.zeros([p + N, p + N])
        for ip in nmt_feats:
            P[ip, ip] = 1
        #for ip in mt_feats :
        #    P[ip, ip] = 1
        q = 1 / (N * v) * np.ones((N + p, 1))
        q[0:p, 0] = 0
        q[p:, 0] = q[p:, 0] * weights
        G1a = np.zeros([p, p])
        for ip in np.arange(p):
            G1a[ip, ip] = -1 if ip in mt_feats else 1
        G1 = np.hstack([G1a, np.zeros([p, N])])
        G2 = np.hstack([np.zeros([N, p]), -np.eye(N)])
        G3 = np.hstack([delta_X, -np.eye(N)])
        G = np.vstack([G1, G2, G3])
        h = np.zeros([p + 2 * N])
        A = np.zeros([1, p + N])
        for ip in np.arange(p):
            A[0, ip] = 1 if ip in mt_feats else -1
        b = np.asarray([1.])
        #b = np.asarray([0.])
        P = cvxmat(P)
        q = cvxmat(q)
        A = cvxmat(A)
        b = cvxmat(b)
        # options['abstol']=1e-20 #(default: 1e-7).
        # options['reltol']=1e-11 #(default: 1e-6)
        sol = solvers.qp(P, q, cvxmat(G), cvxmat(h), A, b)
        if sol['status'] != 'optimal':
            print('****** NOT OPTIMAL ' + sol['status'] + ' ******* [N=' +
                  str(N) + ', p=' + str(p) + ']')
            return np.zeros(delta_X.shape[1])  #[-99]
        else:
            soln = sol['x']
            w = np.ravel(soln[0:p, :])
            # err = np.asarray(soln[-N:, :])
            return w
Exemplo n.º 25
0
 def _convert(H, f, Aeq, beq, lb, ub, x0):
     """ Convert everything to cvxopt-style matrices """
     P = cvxmat(H)
     print H[0]
     print P[0]
     raw_input()
     q = cvxmat(f)
     A = cvxmat(Aeq)
     b = cvxmat(beq)
     n = lb.size
     G = sparse([-speye(n),speye(n)])
     h = cvxmat(np.vstack[-lb,ub])
     x0 = cvxmat(x0)
     return P, q, G, h, A, b, x0
Exemplo n.º 26
0
def cvxopt_solve_qp(P, q, G, h, A=None, b=None, solver=None, initvals=None):
    """
    Solve a Quadratic Program defined as:

    .. math::

        \\begin{eqnarray}
        \\mathrm{minimize} & & (1/2) x^T P x + q^T x \\\\
        \\mathrm{subject\\ to} & & G x \leq h \\\\
            & & A x = b
        \\end{eqnarray}

    using CVXOPT
    <http://cvxopt.org/userguide/coneprog.html#quadratic-programming>.

    Parameters
    ----------
    P : array, shape=(n, n)
        Primal quadratic cost matrix.
    q : array, shape=(n,)
        Primal quadratic cost vector.
    G : array, shape=(m, n)
        Linear inequality constraint matrix.
    h : array, shape=(m,)
        Linear inequality constraint vector.
    A : array, shape=(meq, n), optional
        Linear equality constraint matrix.
    b : array, shape=(meq,), optional
        Linear equality constraint vector.
    solver : string, optional
        Set to 'mosek' to run MOSEK rather than CVXOPT.
    initvals : array, shape=(n,), optional
        Warm-start guess vector.

    Returns
    -------
    x : array, shape=(n,)
        Solution to the QP, if found, otherwise ``None``.
    """
    # CVXOPT only considers the lower entries of P so we project on its
    # symmetric part beforehand
    P = .5 * (P + P.T)
    args = [cvxmat(P), cvxmat(q), cvxmat(G), cvxmat(h)]
    if A is not None:
        args.extend([cvxmat(A), cvxmat(b)])
    sol = cvxopt_qp(*args, solver=solver, initvals=initvals)
    if not ('optimal' in sol['status']):
        raise ValueError("QP optimum not found: %s" % sol['status'])
    return array(sol['x']).reshape((P.shape[1], ))
Exemplo n.º 27
0
 def update_ub(self, ub):
     self.h = cvxmat(vstack([-self.lb, ub]))
     # Old results no longer valid
     self.last_results = None
Exemplo n.º 28
0
Arquivo: mica.py Projeto: DiNAi/misvm
    def fit(self, bags, y):
        """
        @param bags : a sequence of n bags; each bag is an m-by-k array-like
                      object containing m instances with k features
        @param y : an array-like object of length n containing -1/+1 labels
        """
        self._bags = map(np.asmatrix, bags)
        bs = BagSplitter(self._bags,
                         np.asmatrix(y).reshape((-1, 1)))
        self._X = bs.instances
        Ln = bs.L_n
        Lp = bs.L_p
        Xp = bs.X_p
        m = Ln + Xp
        if self.scale_C:
            C = self.C / float(len(self._bags))
        else:
            C = self.C

        K = kernel_by_name(self.kernel, gamma=self.gamma, p=self.p)(self._X, self._X)
        new_classes = np.matrix(np.vstack([-np.ones((Ln, 1)),
                                           np.ones((Xp, 1))]))
        self._y = new_classes
        D = spdiag(new_classes)
        setup = list(self._setup_svm(new_classes, new_classes, C))[1:]
        setup[0] = np.matrix([0])
        qp = IterativeQP(*setup)

        c = cvxmat(np.hstack([np.zeros(Lp + 1),
                              np.ones(Xp + Ln)]))
        b = cvxmat(np.ones((Xp, 1)))
        A = spz(Xp, Lp + 1 + Xp + Ln)
        for row, (i, j) in enumerate(slices(bs.pos_groups)):
            A[row, i:j] = 1.0

        bottom_left = sparse(t([[-spI(Lp), spz(Lp)],
                                [spz(m, Lp), spz(m)]]))
        bottom_right = sparse([spz(Lp, m), -spI(m)])
        inst_cons = sparse(t([[spz(Xp, Lp), -spo(Xp)],
                              [spz(Ln, Lp), spo(Ln)]]))
        G = sparse(t([[inst_cons, -spI(m)],
                      [bottom_left, bottom_right]]))
        h = cvxmat(np.vstack([-np.ones((Xp, 1)),
                              np.zeros((Ln + Lp + m, 1))]))

        def to_V(upsilon):
            bot = np.zeros((Xp, Lp))
            for row, (i, j) in enumerate(slices(bs.pos_groups)):
                bot[row, i:j] = upsilon.flat[i:j]
            return sp.bmat([[sp.eye(Ln, Ln), None],
                            [None, sp.coo_matrix(bot)]])

        class MICACCCP(CCCP):

            def bailout(cself, alphas, upsilon, svm):
                return svm

            def iterate(cself, alphas, upsilon, svm):
                V = to_V(upsilon)
                cself.mention('Update QP...')
                qp.update_H(D * V * K * V.T * D)
                cself.mention('Solve QP...')
                alphas, obj = qp.solve(self.verbose)
                svm = MICA(kernel=self.kernel, gamma=self.gamma, p=self.p,
                           verbose=self.verbose, sv_cutoff=self.sv_cutoff)
                svm._X = self._X
                svm._y = self._y
                svm._V = V
                svm._alphas = alphas
                svm._objective = obj
                svm._compute_separator(K)
                svm._K = K

                cself.mention('Update LP...')
                for row, (i, j) in enumerate(slices(bs.pos_groups)):
                    G[row, i:j] = cvxmat(-svm._dotprods[Ln + i: Ln + j].T)
                h[Xp: Xp + Ln] = cvxmat(-(1 + svm._dotprods[:Ln]))

                cself.mention('Solve LP...')
                sol, _ = linprog(c, G, h, A, b, verbose=self.verbose)
                new_upsilon = sol[:Lp]

                if cself.check_tolerance(np.linalg.norm(upsilon - new_upsilon)):
                    return None, svm

                return {'alphas': alphas, 'upsilon': new_upsilon, 'svm': svm}, None

        best_obj = float('inf')
        best_svm = None
        for rr in range(self.restarts + 1):
            if rr == 0:
                if self.verbose:
                    print 'Non-random start...'
                upsilon0 = np.matrix(np.vstack([np.ones((size, 1)) / float(size)
                                                for size in bs.pos_groups]))
            else:
                if self.verbose:
                    print 'Random restart %d of %d...' % (rr, self.restarts)
                upsilon0 = np.matrix(np.vstack([rand_convex(size).T
                                                for size in bs.pos_groups]))
            cccp = MICACCCP(verbose=self.verbose, alphas=None, upsilon=upsilon0,
                            svm=None, max_iters=self.max_iters)
            svm = cccp.solve()
            if svm is not None:
                obj = float(svm._objective)
                if obj < best_obj:
                    best_svm = svm
                    best_obj = obj

        if best_svm is not None:
            self._V = best_svm._V
            self._alphas = best_svm._alphas
            self._objective = best_svm._objective
            self._compute_separator(best_svm._K)
            self._bag_predictions = self.predict(self._bags)
Exemplo n.º 29
0
 def update_H(self, H):
     self.P = cvxmat(H)
Exemplo n.º 30
0
    def fit(self, bags, y):
        """
        @param bags : a sequence of n bags; each bag is an m-by-k array-like
                      object containing m instances with k features
        @param y : an array-like object of length n containing -1/+1 labels
        """
        def transform(mx):
            """
            Transform into np.matrix if array/list
            ignore scipy.sparse matrix
            """
            if issparse(mx):
                return mx.todense()
            return np.asmatrix(mx)

        self._bags = [transform(bag) for bag in bags]
        y = np.asmatrix(y).reshape((-1, 1))

        bs = BagSplitter(self._bags, y)
        best_obj = float('inf')
        best_svm = None
        for rr in range(self.restarts + 1):
            if rr == 0:
                if self.verbose:
                    print('Non-random start...')
                pos_bag_avgs = np.vstack(
                    [np.average(bag, axis=0) for bag in bs.pos_bags])
            else:
                if self.verbose:
                    print('Random restart %d of %d...' % (rr, self.restarts))
                pos_bag_avgs = np.vstack(
                    [rand_convex(len(bag)) * bag for bag in bs.pos_bags])

            intial_instances = np.vstack([bs.neg_instances, pos_bag_avgs])
            classes = np.vstack([-np.ones((bs.L_n, 1)), np.ones((bs.X_p, 1))])

            # Setup SVM and QP
            if self.scale_C:
                C = self.C / float(len(intial_instances))
            else:
                C = self.C
            setup = self._setup_svm(intial_instances, classes, C)
            K = setup[0]
            qp = IterativeQP(*setup[1:])

            # Fix Gx <= h
            neg_cons = spzeros(bs.X_n, bs.L_n)
            for b, (l, u) in enumerate(slices(bs.neg_groups)):
                neg_cons[b, l:u] = 1.0
            pos_cons = speye(bs.X_p)
            bot_left = spzeros(bs.X_p, bs.L_n)
            top_right = spzeros(bs.X_n, bs.X_p)
            half_cons = sparse([[neg_cons, bot_left], [top_right, pos_cons]])
            qp.G = sparse([-speye(bs.X_p + bs.L_n), half_cons])
            qp.h = cvxmat(
                np.vstack([
                    np.zeros((bs.X_p + bs.L_n, 1)), C * np.ones(
                        (bs.X_p + bs.X_n, 1))
                ]))

            # Precompute kernel for all positive instances
            kernel = kernel_by_name(self.kernel, gamma=self.gamma, p=self.p)
            K_all = kernel(bs.instances, bs.instances)

            neg_selectors = np.array(range(bs.L_n))

            class MISVMCCCP(CCCP):
                def bailout(cself, svm, selectors, instances, K):
                    return svm

                def iterate(cself, svm, selectors, instances, K):
                    cself.mention('Training SVM...')
                    alphas, obj = qp.solve(cself.verbose)

                    # Construct SVM from solution
                    svm = SVM(kernel=self.kernel,
                              gamma=self.gamma,
                              p=self.p,
                              verbose=self.verbose,
                              sv_cutoff=self.sv_cutoff)
                    svm._X = instances
                    svm._y = classes
                    svm._alphas = alphas
                    svm._objective = obj
                    svm._compute_separator(K)
                    svm._K = K

                    cself.mention('Recomputing classes...')
                    p_confs = svm.predict(bs.pos_instances)
                    pos_selectors = bs.L_n + np.array([
                        l + np.argmax(p_confs[l:u])
                        for l, u in slices(bs.pos_groups)
                    ])
                    new_selectors = np.hstack([neg_selectors, pos_selectors])

                    if selectors is None:
                        sel_diff = len(new_selectors)
                    else:
                        sel_diff = np.nonzero(new_selectors -
                                              selectors)[0].size

                    cself.mention('Selector differences: %d' % sel_diff)
                    if sel_diff == 0:
                        return None, svm
                    elif sel_diff > 5:
                        # Clear results to avoid a
                        # bad starting point in
                        # the next iteration
                        qp.clear_results()

                    cself.mention('Updating QP...')
                    indices = (new_selectors, )
                    K = K_all[indices].T[indices].T
                    D = spdiag(classes)
                    qp.update_H(D * K * D)
                    return {
                        'svm': svm,
                        'selectors': new_selectors,
                        'instances': bs.instances[indices],
                        'K': K
                    }, None

            cccp = MISVMCCCP(verbose=self.verbose,
                             svm=None,
                             selectors=None,
                             instances=intial_instances,
                             K=K,
                             max_iters=self.max_iters)
            svm = cccp.solve()
            if svm is not None:
                obj = float(svm._objective)
                if obj < best_obj:
                    best_svm = svm
                    best_obj = obj

        if best_svm is not None:
            self._X = best_svm._X
            self._y = best_svm._y
            self._alphas = best_svm._alphas
            self._objective = best_svm._objective
            self._compute_separator(best_svm._K)
Exemplo n.º 31
0
Arquivo: mica.py Projeto: zhaijj/misvm
    def fit(self, bags, y):
        """
        @param bags : a sequence of n bags; each bag is an m-by-k array-like
                      object containing m instances with k features
        @param y : an array-like object of length n containing -1/+1 labels
        """
        self._bags = map(np.asmatrix, bags)
        bs = BagSplitter(self._bags,
                         np.asmatrix(y).reshape((-1, 1)))
        self._X = bs.instances
        Ln = bs.L_n
        Lp = bs.L_p
        Xp = bs.X_p
        m = Ln + Xp
        if self.scale_C:
            C = self.C / float(len(self._bags))
        else:
            C = self.C

        K = kernel_by_name(self.kernel, gamma=self.gamma, p=self.p)(self._X, self._X)
        new_classes = np.matrix(np.vstack([-np.ones((Ln, 1)),
                                           np.ones((Xp, 1))]))
        self._y = new_classes
        D = spdiag(new_classes)
        setup = list(self._setup_svm(new_classes, new_classes, C))[1:]
        setup[0] = np.matrix([0])
        qp = IterativeQP(*setup)

        c = cvxmat(np.hstack([np.zeros(Lp + 1),
                              np.ones(Xp + Ln)]))
        b = cvxmat(np.ones((Xp, 1)))
        A = spz(Xp, Lp + 1 + Xp + Ln)
        for row, (i, j) in enumerate(slices(bs.pos_groups)):
            A[row, i:j] = 1.0

        bottom_left = sparse(t([[-spI(Lp), spz(Lp)],
                                [spz(m, Lp), spz(m)]]))
        bottom_right = sparse([spz(Lp, m), -spI(m)])
        inst_cons = sparse(t([[spz(Xp, Lp), -spo(Xp)],
                              [spz(Ln, Lp), spo(Ln)]]))
        G = sparse(t([[inst_cons, -spI(m)],
                      [bottom_left, bottom_right]]))
        h = cvxmat(np.vstack([-np.ones((Xp, 1)),
                              np.zeros((Ln + Lp + m, 1))]))

        def to_V(upsilon):
            bot = np.zeros((Xp, Lp))
            for row, (i, j) in enumerate(slices(bs.pos_groups)):
                bot[row, i:j] = upsilon.flat[i:j]
            return sp.bmat([[sp.eye(Ln, Ln), None],
                            [None, sp.coo_matrix(bot)]])

        class MICACCCP(CCCP):

            def bailout(cself, alphas, upsilon, svm):
                return svm

            def iterate(cself, alphas, upsilon, svm):
                V = to_V(upsilon)
                cself.mention('Update QP...')
                qp.update_H(D * V * K * V.T * D)
                cself.mention('Solve QP...')
                alphas, obj = qp.solve(self.verbose)
                svm = MICA(kernel=self.kernel, gamma=self.gamma, p=self.p,
                           verbose=self.verbose, sv_cutoff=self.sv_cutoff)
                svm._X = self._X
                svm._y = self._y
                svm._V = V
                svm._alphas = alphas
                svm._objective = obj
                svm._compute_separator(K)
                svm._K = K

                cself.mention('Update LP...')
                for row, (i, j) in enumerate(slices(bs.pos_groups)):
                    G[row, i:j] = cvxmat(-svm._dotprods[Ln + i: Ln + j].T)
                h[Xp: Xp + Ln] = cvxmat(-(1 + svm._dotprods[:Ln]))

                cself.mention('Solve LP...')
                sol, _ = linprog(c, G, h, A, b, verbose=self.verbose)
                new_upsilon = sol[:Lp]

                if cself.check_tolerance(np.linalg.norm(upsilon - new_upsilon)):
                    return None, svm

                return {'alphas': alphas, 'upsilon': new_upsilon, 'svm': svm}, None

        best_obj = float('inf')
        best_svm = None
        for rr in range(self.restarts + 1):
            if rr == 0:
                if self.verbose:
                    print('Non-random start...')
                upsilon0 = np.matrix(np.vstack([np.ones((size, 1)) / float(size)
                                                for size in bs.pos_groups]))
            else:
                if self.verbose:
                    print('Random restart %d of %d...' % (rr, self.restarts))
                upsilon0 = np.matrix(np.vstack([rand_convex(size).T
                                                for size in bs.pos_groups]))
            cccp = MICACCCP(verbose=self.verbose, alphas=None, upsilon=upsilon0,
                            svm=None, max_iters=self.max_iters)
            svm = cccp.solve()
            if svm is not None:
                obj = float(svm._objective)
                if obj < best_obj:
                    best_svm = svm
                    best_obj = obj

        if best_svm is not None:
            self._V = best_svm._V
            self._alphas = best_svm._alphas
            self._objective = best_svm._objective
            self._compute_separator(best_svm._K)
            self._bag_predictions = self.predict(self._bags)
Exemplo n.º 32
0
def solve_qp(P, q, G, h,
             A=None, b=None, sym_proj=False,
             solver='cvxopt'):
    if sym_proj:
        P = .5 * (P + P.T)
    cvxmat(P)
    cvxmat(q)
    cvxmat(G)
    cvxmat(h)
    args = [cvxmat(P), cvxmat(q), cvxmat(G), cvxmat(h)]
    if A is not None:
        args.extend([cvxmat(A), cvxmat(b)])
    sol = qp(*args, solver=solver)
    if not ('optimal' in sol['status']):
        raise ValueError('QP optimum not found: %s' % sol['status'])
    return np.array(sol['x']).reshape((P.shape[1],))
Exemplo n.º 33
0
Arquivo: misvm.py Projeto: DiNAi/misvm
    def fit(self, bags, y):
        """
        @param bags : a sequence of n bags; each bag is an m-by-k array-like
                      object containing m instances with k features
        @param y : an array-like object of length n containing -1/+1 labels
        """
        def transform(mx):
            """
            Transform into np.matrix if array/list
            ignore scipy.sparse matrix
            """
            if issparse(mx):
                return mx.todense()
            return np.asmatrix(mx)

        self._bags = [transform(bag) for bag in bags]
        y = np.asmatrix(y).reshape((-1, 1))

        bs = BagSplitter(self._bags, y)
        best_obj = float('inf')
        best_svm = None
        for rr in range(self.restarts + 1):
            if rr == 0:
                if self.verbose:
                    print 'Non-random start...'
                pos_bag_avgs = np.vstack([np.average(bag, axis=0) for bag in bs.pos_bags])
            else:
                if self.verbose:
                    print 'Random restart %d of %d...' % (rr, self.restarts)
                pos_bag_avgs = np.vstack([rand_convex(len(bag)) * bag for bag in bs.pos_bags])

            intial_instances = np.vstack([bs.neg_instances, pos_bag_avgs])
            classes = np.vstack([-np.ones((bs.L_n, 1)),
                                 np.ones((bs.X_p, 1))])

            # Setup SVM and QP
            if self.scale_C:
                C = self.C / float(len(intial_instances))
            else:
                C = self.C
            setup = self._setup_svm(intial_instances, classes, C)
            K = setup[0]
            qp = IterativeQP(*setup[1:])

            # Fix Gx <= h
            neg_cons = spzeros(bs.X_n, bs.L_n)
            for b, (l, u) in enumerate(slices(bs.neg_groups)):
                neg_cons[b, l:u] = 1.0
            pos_cons = speye(bs.X_p)
            bot_left = spzeros(bs.X_p, bs.L_n)
            top_right = spzeros(bs.X_n, bs.X_p)
            half_cons = sparse([[neg_cons, bot_left],
                                [top_right, pos_cons]])
            qp.G = sparse([-speye(bs.X_p + bs.L_n), half_cons])
            qp.h = cvxmat(np.vstack([np.zeros((bs.X_p + bs.L_n, 1)),
                                     C * np.ones((bs.X_p + bs.X_n, 1))]))

            # Precompute kernel for all positive instances
            kernel = kernel_by_name(self.kernel, gamma=self.gamma, p=self.p)
            K_all = kernel(bs.instances, bs.instances)

            neg_selectors = np.array(range(bs.L_n))

            class MISVMCCCP(CCCP):

                def bailout(cself, svm, selectors, instances, K):
                    return svm

                def iterate(cself, svm, selectors, instances, K):
                    cself.mention('Training SVM...')
                    alphas, obj = qp.solve(cself.verbose)

                    # Construct SVM from solution
                    svm = SVM(kernel=self.kernel, gamma=self.gamma, p=self.p,
                              verbose=self.verbose, sv_cutoff=self.sv_cutoff)
                    svm._X = instances
                    svm._y = classes
                    svm._alphas = alphas
                    svm._objective = obj
                    svm._compute_separator(K)
                    svm._K = K

                    cself.mention('Recomputing classes...')
                    p_confs = svm.predict(bs.pos_instances)
                    pos_selectors = bs.L_n + np.array([l + np.argmax(p_confs[l:u])
                                                       for l, u in slices(bs.pos_groups)])
                    new_selectors = np.hstack([neg_selectors, pos_selectors])

                    if selectors is None:
                        sel_diff = len(new_selectors)
                    else:
                        sel_diff = np.nonzero(new_selectors - selectors)[0].size

                    cself.mention('Selector differences: %d' % sel_diff)
                    if sel_diff == 0:
                        return None, svm
                    elif sel_diff > 5:
                        # Clear results to avoid a
                        # bad starting point in
                        # the next iteration
                        qp.clear_results()

                    cself.mention('Updating QP...')
                    indices = (new_selectors,)
                    K = K_all[indices].T[indices].T
                    D = spdiag(classes)
                    qp.update_H(D * K * D)
                    return {'svm': svm, 'selectors': new_selectors,
                            'instances': bs.instances[indices], 'K': K}, None

            cccp = MISVMCCCP(verbose=self.verbose, svm=None, selectors=None,
                             instances=intial_instances, K=K, max_iters=self.max_iters)
            svm = cccp.solve()
            if svm is not None:
                obj = float(svm._objective)
                if obj < best_obj:
                    best_svm = svm
                    best_obj = obj

        if best_svm is not None:
            self._X = best_svm._X
            self._y = best_svm._y
            self._alphas = best_svm._alphas
            self._objective = best_svm._objective
            self._compute_separator(best_svm._K)
Exemplo n.º 34
0
 def update_H(self, H):
     self.P = cvxmat(H)
Exemplo n.º 35
0
 def update_ub(self, ub):
     self.h = cvxmat(vstack([-self.lb, ub]))
     # Old results no longer valid
     self.last_results = None