Exemple #1
0
 def __Update_Z_Constr(pure_model: Model, constr_z: Dict[int,
                                                         int]) -> Model:
     Z = pure_model.getVariable('Z')
     if len(constr_z) == 1:
         for key, value in constr_z.items():  # only one iteration
             pure_model.constraint('BB', Z.index(key),
                                   Domain.equalsTo(value))
     if len(constr_z) >= 2:
         expression = Expr.vstack([Z.index(key) for key in constr_z.keys()])
         values = [value for key, value in constr_z.items()]
         pure_model.constraint('BB', expression, Domain.equalsTo(values))
     return pure_model
Exemple #2
0
 def __init__(self, model: Model, mu, sigma, graph, bb_params):
     self.model = model
     self.pure_model = model.clone()
     self.m, self.n = model.getVariable(
         'I').getShape()[0], model.getVariable('Xi').getShape()[0]
     self.mu, self.sigma = mu, sigma
     self.graph = graph
     self.roads = [(i, j) for i in range(self.m) for j in range(self.n)
                   if graph[i][j] == 1]
     self.bb_params = bb_params
     self.node_explored = 0
     self.best_model = None
     self.obj_ub = None
Exemple #3
0
def solve(x0,
          risk_alphas,
          loadings,
          srisk,
          cost_per_trade=DEFAULT_COST,
          max_risk=0.01):
    N = len(x0)
    #  don't hold no risk data (likely dead)
    lim = np.where(srisk.isnull(), 0.0, 1.0)
    loadings = loadings.fillna(0)
    srisk = srisk.fillna(0)
    risk_alphas = risk_alphas.fillna(0)

    with Model() as m:
        w = m.variable(N, Domain.inRange(-lim, lim))
        longs = m.variable(N, Domain.greaterThan(0))
        shorts = m.variable(N, Domain.greaterThan(0))
        gross = m.variable(N, Domain.greaterThan(0))

        m.constraint(
            "leverage_consistent",
            Expr.sub(gross, Expr.add(longs, shorts)),
            Domain.equalsTo(0),
        )

        m.constraint("net_consistent", Expr.sub(w, Expr.sub(longs, shorts)),
                     Domain.equalsTo(0.0))

        m.constraint("leverage_long", Expr.sum(longs), Domain.lessThan(1.0))

        m.constraint("leverage_short", Expr.sum(shorts), Domain.lessThan(1.0))

        buys = m.variable(N, Domain.greaterThan(0))
        sells = m.variable(N, Domain.greaterThan(0))

        gross_trade = Expr.add(buys, sells)
        net_trade = Expr.sub(buys, sells)
        total_gross_trade = Expr.sum(gross_trade)

        m.constraint(
            "net_trade",
            Expr.sub(w, net_trade),
            Domain.equalsTo(np.asarray(x0)),  #  cannot handle series
        )

        #  add risk constraint
        vol = m.variable(1, Domain.lessThan(max_risk))
        stacked = Expr.vstack(vol.asExpr(), Expr.mulElm(w, srisk.values))
        stacked = Expr.vstack(stacked, Expr.mul(loadings.values.T, w))
        m.constraint("vol-cons", stacked, Domain.inQCone())

        alphas = risk_alphas.dot(np.vstack([loadings.T, np.diag(srisk)]))

        gain = Expr.dot(alphas, net_trade)
        loss = Expr.mul(cost_per_trade, total_gross_trade)
        m.objective(ObjectiveSense.Maximize, Expr.sub(gain, loss))

        m.solve()
        result = pd.Series(w.level(), srisk.index)
        return result
Exemple #4
0
def solve_sdp_program(A):
    assert A.ndim == 2
    assert A.shape[0] == A.shape[1]
    A = A.copy()
    n = A.shape[0]
    with Model('theta_2') as M:
        # variable
        X = M.variable('X', Domain.inPSDCone(n + 1))
        t = M.variable()
        # objective function
        M.objective(ObjectiveSense.Maximize, t)
        # constraints
        for i in range(n + 1):
            M.constraint(f'c{i}{i}', X.index(i, i), Domain.equalsTo(1.))
            if i == 0:
                continue
            M.constraint(f'c0,{i}', Expr.sub(X.index(0, i), t),
                         Domain.greaterThan(0.))
            for j in range(i + 1, n + 1):
                if A[i - 1, j - 1] == 0:
                    M.constraint(f'c{i},{j}', X.index(i, j),
                                 Domain.equalsTo(0.))
        # solution
        M.solve()
        X_sol = X.level()
        t_sol = t.level()
    t_sol = t_sol[0]
    theta = 1. / t_sol**2
    return theta
Exemple #5
0
def solve_sdp_program(W):
    assert W.ndim == 2
    assert W.shape[0] == W.shape[1]
    W = W.copy()
    n = W.shape[0]
    W = expand_matrix(W)
    with Model('gw_max_3_cut') as M:
        W = Matrix.dense(W / 3.)
        J = Matrix.ones(3*n, 3*n)
        # variable
        Y = M.variable('Y', Domain.inPSDCone(3*n))
        # objective function
        M.objective(ObjectiveSense.Maximize, Expr.dot(W, Expr.sub(J, Y)))
        # constraints
        for i in range(3*n):
            M.constraint(f'c_{i}{i}', Y.index(i, i), Domain.equalsTo(1.))
        for i in range(n):
            M.constraint(f'c_{i}^01', Y.index(i*3,   i*3+1), Domain.equalsTo(-1/2.))
            M.constraint(f'c_{i}^02', Y.index(i*3,   i*3+2), Domain.equalsTo(-1/2.))
            M.constraint(f'c_{i}^12', Y.index(i*3+1, i*3+2), Domain.equalsTo(-1/2.))
            for j in range(i+1, n):
                for a, b in product(range(3), repeat=2):
                    M.constraint(f'c_{i}{j}^{a}{b}-0', Y.index(i*3 + a, j*3 + b), Domain.greaterThan(-1/2.))
                    M.constraint(f'c_{i}{j}^{a}{b}-1', Expr.sub(Y.index(i*3 + a, j*3 + b), Y.index(i*3 + (a + 1) % 3, j*3 + (b + 1) % 3)), Domain.equalsTo(0.))
                    M.constraint(f'c_{i}{j}^{a}{b}-2', Expr.sub(Y.index(i*3 + a, j*3 + b), Y.index(i*3 + (a + 2) % 3, j*3 + (b + 2) % 3)), Domain.equalsTo(0.))
        # solution
        M.solve()
        Y_opt = Y.level()
    return np.reshape(Y_opt, (3*n,3*n))
Exemple #6
0
def lsq_pos(matrix, rhs):
    """
    min 2-norm (matrix*w - rhs)^2
    s.t. e'w = 1
           w >= 0
    """
    # define model
    with Model('lsqPos') as model:
        # introduce n non-negative weight variables
        weights = model.variable("weights", matrix.shape[1],
                                 Domain.inRange(0.0, +np.infty))

        # e'*w = 1
        model.constraint(Expr.sum(weights), Domain.equalsTo(1.0))

        v = __l2_norm(model,
                      "2-norm(res)",
                      expr=__residual(matrix, rhs, weights))

        # minimization of the residual
        model.objective(ObjectiveSense.Minimize, v)
        # solve the problem
        model.solve()

        return np.array(weights.level())
Exemple #7
0
def lsq_pos_l1_penalty(matrix, rhs, cost_multiplier, weights_0):
    """
    min 2-norm (matrix*w - rhs)** + 1-norm(cost_multiplier*(w-w0))
    s.t. e'w = 1
           w >= 0
    """
    # define model
    with Model('lsqSparse') as model:
        # introduce n non-negative weight variables
        weights = model.variable("weights", matrix.shape[1],
                                 Domain.inRange(0.0, +np.infty))

        # e'*w = 1
        model.constraint(Expr.sum(weights), Domain.equalsTo(1.0))

        # sum of squared residuals
        v = __l2_norm_squared(model, "2-norm(res)**",
                              __residual(matrix, rhs, weights))

        # \Gamma*(w - w0), p is an expression
        p = Expr.mulElm(cost_multiplier, Expr.sub(weights, weights_0))

        cost = model.variable("cost", matrix.shape[1], Domain.unbounded())
        model.constraint(Expr.sub(cost, p), Domain.equalsTo(0.0))

        t = __l1_norm(model, 'abs(weights)', cost)

        # Minimise v + t
        model.objective(ObjectiveSense.Minimize,
                        __sum_weighted(1.0, v, 1.0, t))
        # solve the problem
        model.solve()

        return np.array(weights.level())
Exemple #8
0
def minimum_variance(matrix):
    # Given the matrix of returns a (each column is a series of returns) this method
    # computes the weights for a minimum variance portfolio, e.g.

    # min   2-Norm[a*w]^2
    # s.t.
    #         w >= 0
    #     sum[w] = 1

    # This is the left-most point on the efficiency frontier in the classic Markowitz theory

    # build the model
    with Model("Minimum Variance") as model:
        # introduce the weight variable

        weights = model.variable("weights", matrix.shape[1],
                                 Domain.inRange(0.0, 1.0))
        # sum of weights has to be 1
        model.constraint(Expr.sum(weights), Domain.equalsTo(1.0))
        # returns
        r = Expr.mul(Matrix.dense(matrix), weights)
        # compute l2_norm squared of those returns
        # minimize this l2_norm
        model.objective(ObjectiveSense.Minimize,
                        __l2_norm_squared(model, "2-norm^2(r)", expr=r))
        # solve the problem
        model.solve()
        # return the series of weights
        return np.array(weights.level())
Exemple #9
0
    def __Select_Branching_Pos(self, solved_model: Model,
                               constr_z: Dict[int, int]) -> int:
        """
        Ideally, branching position should come from a pricing problem
        v1: randomly select one position from remaining branching position.
        v2: argmax weighted average alpha_r (r: (i,j)\in roads) for each location i
        :param node:
        """
        from random import choice
        r = len(self.roads)

        if self.bb_params['select_branching_pos'] == 'v1':
            # v1: randomly select one position from remaining branching position.
            candidates = list(set(range(self.m)) - set(constr_z.keys()))
            pos = choice(candidates)

        if self.bb_params['select_branching_pos'] == 'v2':
            # v2: argmax weighted average alpha_r (r: (i,j)\in roads) for each location i
            sum_alpha_is = []
            alpha = solved_model.getVariable('Alpha').level()[:r]
            for i in set(range(self.m)) - set(constr_z.keys()):
                sum_alpha_i = sum([
                    alpha[k] if x == i else 0
                    for k, (x, y) in enumerate(self.roads)
                ])
                sum_alpha_is.append([i, sum_alpha_i])
            pos = sorted(sum_alpha_is, key=lambda x: x[1], reverse=True)[0][0]

        return pos
 def __init__(self, model: Model, constr: Dict[int, int]):
     self.model = model
     self.pure_model = model.clone()
     self.left = None
     self.right = None
     self.val = float('inf')
     self.sol = None
     self.constr = constr
Exemple #11
0
    def solve(self, problem, saver):
        # Construct model.
        self.problem = problem

        # Do recursive maximal clique detection.
        self.clique_data = clique_data = problem.cliques()
        self.model = model = Model()
        if self.time is not None:
            model.setSolverParam('mioMaxTime', 60.0 * int(self.time))

        # Each image needs to run all its commands. This keep track of
        # what variables run each command for each image.
        self.by_img_cmd = by_img_cmd = defaultdict(list)

        # Objective is the total cost of all the commands we run.
        self._obj = []

        # x[i,c] = 1 if image i incurs the cost of command c directly
        self.x = x = {}
        for img, cmds in problem.images.items():
            for cmd in cmds:
                name = 'x[%s,%s]' % (img, cmd)
                x[name] = v = self.model.variable(name,
                                                  Domain.inRange(0.0, 1.0),
                                                  Domain.isInteger())
                self._obj.append(Expr.mul(float(problem.commands[cmd]), v))
                by_img_cmd[img, cmd].append(v)

        # cliques[i] = 1 if clique i is used, 0 otherwise
        self.cliques = {}
        self._inter = 1
        self._update(clique_data)

        # Each image has to run each of its commands.
        for img_cmd, vlist in by_img_cmd.items():
            name = 'img-cmd-%s-%s' % img_cmd
            self.model.constraint(name, Expr.add(vlist), Domain.equalsTo(1.0))

        model.objective('z', ObjectiveSense.Minimize, Expr.add(self._obj))
        model.setLogHandler(sys.stdout)
        model.acceptedSolutionStatus(AccSolutionStatus.Feasible)
        model.solve()

        # Translate the output of this to a schedule.
        schedule = defaultdict(list)
        self._translate(schedule, clique_data)
        for name, v in x.items():
            img, cmd = name.replace('x[', '').replace(']', '').split(',')
            if v.level()[0] > 0.5:
                schedule[img].append(cmd)
        saver(schedule)
Exemple #12
0
    def optimize_with_mosek(self, predicted, today):
        """
        使用Mosek来优化构建组合。在测试中Mosek比scipy的单纯形法快约18倍,如果可能请尽量使用Mosek。
        但是Mosek是一个商业软件,因此你需要一份授权。如果没有授权的话请使用scipy或optlang。
        """
        from mosek.fusion import Expr, Model, ObjectiveSense, Domain, SolutionError
        index_weight = self.index_weights.loc[today].fillna(0)
        index_weight = index_weight / index_weight.sum()
        stocks = list(predicted.index)

        with Model("portfolio") as M:
            x = M.variable("x", len(stocks),
                           Domain.inRange(0, self.constraint_config['stocks']))

            # 权重总和等于一
            M.constraint("sum", Expr.sum(x), Domain.equalsTo(1.0))

            # 控制风格暴露
            for factor_name, limit in self.constraint_config['factors'].items(
            ):
                factor_data = self.factor_data[factor_name].loc[today]
                factor_data = factor_data.fillna(factor_data.mean())
                index_exposure = (index_weight * factor_data).sum()
                stocks_exposure = factor_data.loc[stocks].values
                M.constraint(
                    factor_name, Expr.dot(stocks_exposure.tolist(), x),
                    Domain.inRange(index_exposure - limit,
                                   index_exposure + limit))

            # 控制行业暴露
            for industry_name, limit in self.constraint_config[
                    'industries'].items():
                industry_data = self.industry_data[industry_name].loc[
                    today].fillna(0)
                index_exposure = (index_weight * industry_data).sum()
                stocks_exposure = industry_data.loc[stocks].values
                M.constraint(
                    industry_name, Expr.dot(stocks_exposure.tolist(), x),
                    Domain.inRange(index_exposure - limit,
                                   index_exposure + limit))

            # 最大化期望收益率
            M.objective("MaxRtn", ObjectiveSense.Maximize,
                        Expr.dot(predicted.tolist(), x))
            M.solve()
            weights = pd.Series(list(x.level()), index=stocks)
            # try:
            #     weights = pd.Series(list(x.level()), index=stocks)
            # except SolutionError:
            #     raise RuntimeError("Mosek fail to find a feasible solution @ {}".format(str(today)))
        return weights[weights > 0]
Exemple #13
0
    def __init__(self,name, 
                 foods, 
                 nutrients,
                 daily_allowance,
                 nutritive_value):
        Model.__init__(self,name)
        finished = False
        try:
          self.foods     = [ str(f) for f in foods ]
          self.nutrients = [ str(n) for n in nutrients ]
          self.dailyAllowance = array.array(daily_allowance, float)
          self.nutrientValue = DenseMatrix(nutritive_value).transpose()

          M = len(self.foods)
          N = len(self.nutrients)
          if len(self.dailyAllowance) != N:
              raise ValueError("Length of daily_allowance does not match "
                               "the number of nutrients")
          if self.nutrientValue.numColumns() != M:
              raise ValueError("Number of rows in nutrient_value does not "
                               "match the number of foods")
          if self.nutrientValue.numRows() != N:
              raise ValueError("Number of columns in nutrient_value does "
                               "not match the number of nutrients")
          
          self.__dailyPurchase = self.variable('Daily Purchase', 
                                               StringSet(self.foods), 
                                               Domain.greaterThan(0.0))
          self.__dailyNutrients = \
              self.constraint('Nutrient Balance',
                              StringSet(nutrients),
                              Expr.mul(self.nutrientValue,self.__dailyPurchase),
                              Domain.greaterThan(self.dailyAllowance))
          self.objective(ObjectiveSense.Minimize, Expr.sum(self.__dailyPurchase))
          finished = True
        finally:
          if not finished:
            self.__del__()
Exemple #14
0
    def __init__(self,name, 
                 foods, 
                 nutrients,
                 daily_allowance,
                 nutritive_value):
        Model.__init__(self,name)
        finished = False
        try:
          self.foods     = [ str(f) for f in foods ]
          self.nutrients = [ str(n) for n in nutrients ]
          self.dailyAllowance = numpy.array(daily_allowance, float)
          self.nutrientValue = Matrix.dense(nutritive_value).transpose()

          M = len(self.foods)
          N = len(self.nutrients)
          if len(self.dailyAllowance) != N:
              raise ValueError("Length of daily_allowance does not match "
                               "the number of nutrients")
          if self.nutrientValue.numColumns() != M:
              raise ValueError("Number of rows in nutrient_value does not "
                               "match the number of foods")
          if self.nutrientValue.numRows() != N:
              raise ValueError("Number of columns in nutrient_value does "
                               "not match the number of nutrients")
          
          self.__dailyPurchase = self.variable('Daily Purchase', 
                                               StringSet(self.foods), 
                                               Domain.greaterThan(0.0))
          self.__dailyNutrients = \
              self.constraint('Nutrient Balance',
                              StringSet(nutrients),
                              Expr.mul(self.nutrientValue,self.__dailyPurchase),
                              Domain.greaterThan(self.dailyAllowance))
          self.objective(ObjectiveSense.Minimize, Expr.sum(self.__dailyPurchase))
          finished = True
        finally:
          if not finished:
            self.__del__()
Exemple #15
0
def markowitz(exp_ret, covariance_mat, aversion):
    # define model
    with Model("mean var") as model:
        # set of n weights (unconstrained)
        weights = model.variable("weights", len(exp_ret),
                                 Domain.inRange(-np.infty, +np.infty))

        model.constraint(Expr.sum(weights), Domain.equalsTo(1.0))

        # standard deviation induced by covariance matrix
        var = __variance(model, "var", weights, covariance_mat)

        model.objective(
            ObjectiveSense.Maximize,
            Expr.sub(Expr.dot(exp_ret, weights), Expr.mul(aversion, var)))
        model.solve()
        #mModel.maximise(model=model, expr=Expr.sub(Expr.dot(exp_ret, weights), Expr.mul(aversion, var)))
        return np.array(weights.level())
Exemple #16
0
def markowitz_riskobjective(exp_ret, covariance_mat, bound):
    # define model
    with Model("mean var") as model:
        # set of n weights (unconstrained)
        weights = model.variable("weights", len(exp_ret),
                                 Domain.inRange(0.0, 1.0))

        # standard deviation induced by covariance matrix
        stdev = __stdev(model, "std", weights, covariance_mat)

        # impose a bound on this standard deviation
        #mBound.upper(model, stdev, bound)
        model.constraint(stdev, Domain.lessThan(bound))

        #mModel.maximise(model=model, expr=Expr.dot(exp_ret, weights))
        model.objective(ObjectiveSense.Maximize, Expr.dot(exp_ret, weights))
        # solve the problem
        model.solve()

        return np.array(weights.level())
Exemple #17
0
def solve_sdp_program(A):
    assert A.ndim == 2
    assert A.shape[0] == A.shape[1]
    A = A.copy()
    n = A.shape[0]
    with Model('theta_1') as M:
        A = Matrix.dense(A)
        # variable
        X = M.variable('X', Domain.inPSDCone(n))
        # objective function
        M.objective(ObjectiveSense.Maximize,
                    Expr.sum(Expr.dot(Matrix.ones(n, n), X)))
        # constraints
        M.constraint(f'c1', Expr.sum(Expr.dot(X, A)), Domain.equalsTo(0.))
        M.constraint(f'c2', Expr.sum(Expr.dot(X, Matrix.eye(n))),
                     Domain.equalsTo(1.))
        # solution
        M.solve()
        sol = X.level()
    return sum(sol)
Exemple #18
0
def solve_sdp_program(W):
    assert W.ndim == 2
    assert W.shape[0] == W.shape[1]
    W = W.copy()
    n = W.shape[0]
    with Model('gw_max_cut') as M:
        W = Matrix.dense(W / 4.)
        J = Matrix.ones(n, n)
        # variable
        Y = M.variable('Y', Domain.inPSDCone(n))
        # objective function
        M.objective(ObjectiveSense.Maximize, Expr.dot(W, Expr.sub(J, Y)))
        # constraints
        for i in range(n):
            M.constraint(f'c_{i}', Y.index(i, i), Domain.equalsTo(1.))
        # solve
        M.solve()
        # solution
        Y_opt = Y.level()
    return np.reshape(Y_opt, (n, n))
Exemple #19
0
def lasso(matrix, rhs, lamb):
    """
    min 2-norm (matrix*w - rhs)^2 + lamb * 1-norm(w)
    """
    # define model
    with Model("lasso") as model:
        weights = model.variable(
            "weights",
            matrix.shape[1])  #, Domain.inRange(-np.infty, +np.infty))
        # introduce variables and constraints

        v = __l2_norm_squared(model, "2-norm(res)**",
                              __residual(matrix, rhs, weights))
        t = __l1_norm(model, "1-norm(w)", weights)

        model.objective(ObjectiveSense.Minimize,
                        __sum_weighted(c1=1.0, expr1=v, c2=lamb, expr2=t))
        # solve the problem
        model.solve()

        return np.array(weights.level())
Exemple #20
0
def solve_sdp_program(W, k):
    assert W.ndim == 2
    assert W.shape[0] == W.shape[1]
    W = W.copy()
    n = W.shape[0]
    with Model('fj_max_k_cut') as M:
        W = Matrix.dense((k - 1) / (2 * k) * W)
        J = Matrix.ones(n, n)
        # variable
        Y = M.variable('Y', Domain.inPSDCone(n))
        # objective function
        M.objective(ObjectiveSense.Maximize, Expr.dot(W, Expr.sub(J, Y)))
        # constraints
        for i in range(n):
            M.constraint(f'c_{i}', Y.index(i, i), Domain.equalsTo(1.))
            for j in range(i + 1, n):
                M.constraint(f'c_{i},{j}', Y.index(i, j),
                             Domain.greaterThan(-1 / (k - 1)))
        # solution
        M.solve()
        Y_opt = Y.level()
    return np.reshape(Y_opt, (n, n))
#        x_2_d = 0
#
#    Image 3:
#        x_3_b = 0
#        x_3_c = 0
#        x_3_d = 0
#
#    Cliques:
#        x_23_bcd = 0
#        x_123_b = 1
#        x_123_b_23_cd = 1
#        x_12_a = 0

r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0}

m = Model()
binary = (Domain.inRange(0.0, 1.0), Domain.isInteger())

# Provide a variable for each image and command. This is 1 if the command
# is not run as part of a clique for the image.
x_1_a = m.variable('x_1_a', *binary)
x_1_b = m.variable('x_1_b', *binary)

x_2_a = m.variable('x_2_a', *binary)
x_2_b = m.variable('x_2_b', *binary)
x_2_c = m.variable('x_2_c', *binary)
x_2_d = m.variable('x_2_d', *binary)

x_3_b = m.variable('x_3_b', *binary)
x_3_c = m.variable('x_3_c', *binary)
x_3_d = m.variable('x_3_d', *binary)
#        x_2_c = 0
#        x_2_d = 0
#
#    Image 3:
#        x_3_b = 0
#        x_3_c = 0
#        x_3_d = 0
#
#    Cliques:
#        x_23_bcd = 0
#        x_123_b = 1
#        x_123_b_23_cd = 1

r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0}

m = Model()
binary = (Domain.inRange(0.0, 1.0), Domain.isInteger())

# Provide a variable for each image and command. This is 1 if the command
# is not run as part of a clique for the image.
x_1_a = m.variable('x_1_a', *binary)
x_1_b = m.variable('x_1_b', *binary)

x_2_a = m.variable('x_2_a', *binary)
x_2_b = m.variable('x_2_b', *binary)
x_2_c = m.variable('x_2_c', *binary)
x_2_d = m.variable('x_2_d', *binary)

x_3_b = m.variable('x_3_b', *binary)
x_3_c = m.variable('x_3_c', *binary)
x_3_d = m.variable('x_3_d', *binary)
Exemple #23
0
#        x_1_b = 1
#
#    Image 2:
#        x_2_a = 1
#        x_2_b = 1
#        x_2_c = 1
#        x_2_d = 1
#
#    Image 3:
#        x_3_b = 1
#        x_3_c = 1
#        x_3_d = 1

r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0}

m = Model()
binary = (Domain.inRange(0.0, 1.0), Domain.isInteger())

# Provide a variable for each image and command. This is 1 if the command
# is not run as part of a clique for the image.
x_1_a = m.variable('x_1_a', *binary)
x_1_b = m.variable('x_1_b', *binary)

x_2_a = m.variable('x_2_a', *binary)
x_2_b = m.variable('x_2_b', *binary)
x_2_c = m.variable('x_2_c', *binary)
x_2_d = m.variable('x_2_d', *binary)

x_3_b = m.variable('x_3_b', *binary)
x_3_c = m.variable('x_3_c', *binary)
x_3_d = m.variable('x_3_d', *binary)
# Output:
#
#    Images:
#        w_1 = 0
#        w_2 = 1
#        w_3 = 1
#
#    Commands:
#        y_a = 0
#        y_b = 1
#        y_c = 1
#        y_d = 1

r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0}

m = Model()
binary = (Domain.inRange(0.0, 1.0), Domain.isInteger())

# Variables to determine if we include commands in the clique.
y_a = m.variable('y_a', *binary)
y_b = m.variable('y_b', *binary)
y_c = m.variable('y_c', *binary)
y_d = m.variable('y_d', *binary)

# Variables to determine if we include images in the clique.
w_1 = m.variable('w_1', *binary)
w_2 = m.variable('w_2', *binary)
w_3 = m.variable('w_3', *binary)

# Variables to enforce relationships between y and w decisions.
z_1_a = m.variable('z_1_a', *binary)
    def solve(self, problem, saver):
        # Construct model.
        self.problem = problem
        self.model = model = Model()
        if self.time is not None:
            model.setSolverParam('mioMaxTime', 60.0  * int(self.time))

        # x[i,s,c] = 1 if image i runs command c during stage s, 0 otherwise.
        self.x = x = {}
        for i, cmds in problem.images.items():
            for s, c in product(problem.stages[i], cmds):
                x[i,s,c] = model.variable(
                    'x[%s,%s,%s]' % (i,s,c), 1,
                    Domain.inRange(0.0, 1.0),
                    Domain.isInteger()
                )

        # y[ip,iq,s,c] = 1 if images ip & iq have a shared path through stage
        #                s by running command c during s, 0 otherwise.
        y = {}
        for (ip, iq), cmds in problem.shared_cmds.items():
            for s, c in product(problem.shared_stages[ip, iq], cmds):
                y[ip,iq,s,c] = model.variable(
                    'y[%s,%s,%s,%s]' % (ip,iq,s,c), 1,
                    Domain.inRange(0.0, 1.0),
                    Domain.isInteger()
                    # Domain.inRange(0.0, 1.0)
                )

        # TODO: need to remove presolved commands so the heuristic doesn't try them.
        # TODO: Add a heuristic initial solution.
        # TODO: Presolving

        # Each image one command per stage, and each command once.
        for i in problem.images:
            for s in problem.stages[i]:
                model.constraint('c1[%s,%s]' % (i,s),
                    Expr.add([x[i,s,c] for c in problem.images[i]]),
                    Domain.equalsTo(1.0)
                )
            for c in problem.images[i]:
                model.constraint('c2[%s,%s]' % (i,c),
                    Expr.add([x[i,s,c] for s in problem.stages[i]]),
                    Domain.equalsTo(1.0)
                )

        # Find shared paths among image pairs.
        for (ip, iq), cmds in problem.shared_cmds.items():
            for s in problem.shared_stages[ip,iq]:
                for c in cmds:
                    model.constraint('c3[%s,%s,%s,%s]' % (ip,iq,s,c),
                        Expr.sub(y[ip,iq,s,c], x[ip,s,c]),
                        Domain.lessThan(0.0)
                    )
                    model.constraint('c4[%s,%s,%s,%s]' % (ip,iq,s,c),
                        Expr.sub(y[ip,iq,s,c], x[iq,s,c]),
                        Domain.lessThan(0.0)
                    )
                if s > 1:
                    lhs = Expr.add([y[ip,iq,s,c] for c in cmds])
                    rhs = Expr.add([y[ip,iq,s-1,c] for c in cmds])
                    model.constraint('c5[%s,%s,%s,%s]' % (ip,iq,s,c),
                        Expr.sub(lhs, rhs), Domain.lessThan(0.0)
                    )

        if y:
            obj = Expr.add(y.values())
        else:
            obj = 0.0
        model.objective('z', ObjectiveSense.Maximize, obj)
        model.setLogHandler(sys.stdout)
        model.acceptedSolutionStatus(AccSolutionStatus.Feasible)
        model.solve()

        # Create optimal schedule.
        schedule = defaultdict(list)
        for i, stages in problem.stages.items():
            for s in stages:
                for c in problem.images[i]:
                    if x[i,s,c].level()[0] > 0.5:
                        schedule[i].append(c)
                        break

        saver(schedule)
Exemple #26
0
import json
import numpy as np
from mosek.fusion import Model, Domain, Expr, ObjectiveSense


A = np.array([[-1., 3.], [4., -1.]])
b = np.array([4., 6.])
c = np.array([1., 1.])


with Model('ex1') as M:
    # variable x
    x = M.variable('x', 2, Domain.greaterThan(0.))
    # constraints
    M.constraint('c1', Expr.dot(A[0, :], x), Domain.lessThan(b[0]))
    M.constraint('c2', Expr.dot(A[1, :], x), Domain.lessThan(b[1]))
    # objective function
    M.objective('obj', ObjectiveSense.Maximize, Expr.dot(c, x))
    # solve
    M.solve()
    # solution
    sol = x.level()

# report to json
with open('ex1_output.json', 'w') as f:
    json.dump({
        'solution': {f'x[{i+1}]': xi for i, xi in enumerate(sol)},
        'cost': np.dot(sol, c),
    }, f)
#    Commands:
#        y_a = 0
#        y_b = 1
#        y_c = 0
#        y_d = 0
#
#    Interactions:
#        m_2 = 0
#        m_3 = 0
#        n_b = 1
#        n_c = 0
#        n_d = 0

r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0}

m = Model()
binary = (Domain.inRange(0.0, 1.0), Domain.isInteger())

# Variables to determine if we include commands in the clique.
y_a = m.variable('y_a', *binary)
y_b = m.variable('y_b', *binary)
y_c = m.variable('y_c', *binary)
y_d = m.variable('y_d', *binary)

# Variables to determine if we include images in the clique.
w_1 = m.variable('w_1', *binary)
w_2 = m.variable('w_2', *binary)
w_3 = m.variable('w_3', *binary)

# Variables to enforce relationships between y and w decisions.
z_1_a = m.variable('z_1_a', *binary)
Exemple #28
0
    def solve(self, problem, saver):
        # Construct model.
        self.problem = problem
        self.model = model = Model()
        if self.time is not None:
            model.setSolverParam('mioMaxTime', 60.0 * int(self.time))

        # x[1,c] = 1 if the master schedule has (null, c) in its first stage
        # x[s,c1,c2] = 1 if the master schedule has (c1, c2) in stage s > 1
        x = {}
        for s in problem.all_stages:
            if s == 1:
                # First arc in the individual image path.
                for c in problem.commands:
                    x[1, c] = model.variable('x[1,%s]' % c, 1,
                                             Domain.inRange(0.0, 1.0),
                                             Domain.isInteger())

            else:
                # Other arcs.
                for c1, c2 in product(problem.commands, problem.commands):
                    if c1 == c2:
                        continue
                    x[s, c1, c2] = model.variable('x[%s,%s,%s]' % (s, c1, c2),
                                                  1, Domain.inRange(0.0, 1.0),
                                                  Domain.isInteger())

        smax = max(problem.all_stages)
        obj = [0.0]

        # TODO: deal with images that do not have the same number of commands.
        # t[s,c] is the total time incurred at command c in stage s
        t = {}
        for s in problem.all_stages:
            for c in problem.commands:
                t[s, c] = model.variable('t[%s,%s]' % (c, s), 1,
                                         Domain.greaterThan(0.0))
                if s == 1:
                    model.constraint(
                        't[1,%s]' % c,
                        Expr.sub(t[1, c],
                                 Expr.mul(float(problem.commands[c]), x[1,
                                                                        c])),
                        Domain.greaterThan(0.0))
                else:
                    rhs = [0.0]
                    for c1, coeff in problem.commands.items():
                        if c1 == c:
                            continue
                        else:
                            rhs = Expr.add(
                                rhs, Expr.mulElm(t[s - 1, c1], x[s, c1, c]))
                    model.constraint('t[%s,%s]' % (s, c),
                                     Expr.sub(t[1, c], rhs),
                                     Domain.greaterThan(0.0))

                    # Objective function = sum of aggregate  comand times
                    if s == smax:
                        obj = Expr.add(obj, t[s, c])

        # y[i,1,c] = 1 if image i starts by going to c
        # y[i,s,c1,c2] = 1 if image i goes from command c1 to c2 in stage s > 1
        y = {}
        for i, cmds in problem.images.items():
            for s in problem.stages[i]:
                if s == 1:
                    # First arc in the individual image path.
                    for c in cmds:
                        y[i, 1, c] = model.variable('y[%s,1,%s]' % (i, c), 1,
                                                    Domain.inRange(0.0, 1.0),
                                                    Domain.isInteger())
                        model.constraint('x_y[i%s,1,c%s]' % (i, c),
                                         Expr.sub(x[1, c], y[i, 1, c]),
                                         Domain.greaterThan(0.0))

                else:
                    # Other arcs.
                    for c1, c2 in product(cmds, cmds):
                        if c1 == c2:
                            continue
                        y[i, s, c1, c2] = model.variable(
                            'y[%s,%s,%s,%s]' % (i, s, c1, c2), 1,
                            Domain.inRange(0.0, 1.0), Domain.isInteger())
                        model.constraint(
                            'x_y[i%s,s%s,c%s,c%s]' % (i, s, c1, c2),
                            Expr.sub(x[s, c1, c2], y[i, s, c1, c2]),
                            Domain.greaterThan(0.0))

            for c in cmds:
                # Each command is an arc destination exactly once.
                arcs = [y[i, 1, c]]
                for c1 in cmds:
                    if c1 == c:
                        continue
                    arcs.extend(
                        [y[i, s, c1, c] for s in problem.stages[i][1:]])

                model.constraint('y[i%s,c%s]' % (i, c), Expr.add(arcs),
                                 Domain.equalsTo(1.0))

                # Network balance equations (stages 2 to |stages|-1).
                # Sum of arcs in = sum of arcs out.
                for s in problem.stages[i][:len(problem.stages[i]) - 1]:
                    if s == 1:
                        arcs_in = [y[i, 1, c]]
                    else:
                        arcs_in = [y[i, s, c1, c] for c1 in cmds if c1 != c]

                    arcs_out = [y[i, s + 1, c, c2] for c2 in cmds if c2 != c]

                    model.constraint(
                        'y[i%s,s%s,c%s]' % (i, s, c),
                        Expr.sub(Expr.add(arcs_in), Expr.add(arcs_out)),
                        Domain.equalsTo(0.0))

        model.objective('z', ObjectiveSense.Minimize, Expr.add(x.values()))
        #        model.objective('z', ObjectiveSense.Minimize, obj)
        model.setLogHandler(sys.stdout)
        model.acceptedSolutionStatus(AccSolutionStatus.Feasible)
        model.solve()

        # Create optimal schedule.
        schedule = defaultdict(list)
        for i, cmds in problem.images.items():
            for s in problem.stages[i]:
                if s == 1:
                    # First stage starts our walk.
                    for c in cmds:
                        if y[i, s, c].level()[0] > 0.5:
                            schedule[i].append(c)
                            break
                else:
                    # After that we know what our starting point is.
                    for c2 in cmds:
                        if c2 == c:
                            continue
                        if y[i, s, c, c2].level()[0] > 0.5:
                            schedule[i].append(c2)
                            c = c2
                            break

        saver(schedule)
Exemple #29
0
import json
import numpy as np
from mosek.fusion import Model, Domain, Expr, ObjectiveSense

A = np.array([[-1., 3.], [4., -1.]])
b = np.array([4., 6.])
c = np.array([1., 1.])

with Model('ex2') as M:
    # variable y
    y = M.variable('y', 2, Domain.greaterThan(0.))
    # constraints
    M.constraint('c1', Expr.dot(A.T[0, :], y), Domain.greaterThan(c[0]))
    M.constraint('c2', Expr.dot(A.T[1, :], y), Domain.greaterThan(c[1]))
    # objective function
    M.objective('obj', ObjectiveSense.Minimize, Expr.dot(b, y))
    # solve
    M.solve()
    # solution
    sol = y.level()

# report to json
with open('ex2_output.json', 'w') as f:
    json.dump(
        {
            'solution': {f'y[{i+1}]': yi
                         for i, yi in enumerate(sol)},
            'cost': np.dot(b, sol),
        }, f)
#        x_1_b = 1
#
#    Image 2:
#        x_2_a = 1
#        x_2_b = 1
#        x_2_c = 1
#        x_2_d = 1
#
#    Image 3:
#        x_3_b = 1
#        x_3_c = 1
#        x_3_d = 1

r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0}

m = Model()
binary = (Domain.inRange(0.0, 1.0), Domain.isInteger())

# Provide a variable for each image and command. This is 1 if the command
# is not run as part of a clique for the image.
x_1_a = m.variable('x_1_a', *binary)
x_1_b = m.variable('x_1_b', *binary)

x_2_a = m.variable('x_2_a', *binary)
x_2_b = m.variable('x_2_b', *binary)
x_2_c = m.variable('x_2_c', *binary)
x_2_d = m.variable('x_2_d', *binary)

x_3_b = m.variable('x_3_b', *binary)
x_3_c = m.variable('x_3_c', *binary)
x_3_d = m.variable('x_3_d', *binary)
Exemple #31
0
    def Build_Co_Model(self):
        r = len(self.roads)
        mu, sigma = self.mu, self.sigma
        m, n, r = self.m, self.n, len(self.roads)
        f, h = self.f, self.h
        M, N = m + n + r, 2 * m + 2 * n + r
        A = self.__Construct_A_Matrix()
        A_Mat = Matrix.dense(A)
        b = self.__Construct_b_vector()

        # ---- build Mosek Model
        COModel = Model()

        # -- Decision Variable
        Z = COModel.variable('Z', m, Domain.inRange(0.0, 1.0))
        I = COModel.variable('I', m, Domain.greaterThan(0.0))
        Alpha = COModel.variable('Alpha', M,
                                 Domain.unbounded())  # M by 1 vector
        Beta = COModel.variable('Beta', M, Domain.unbounded())  # M by 1 vector
        Theta = COModel.variable('Theta', N,
                                 Domain.unbounded())  # N by 1 vector
        # M1_matrix related decision variables
        '''
            [tau, xi^T, phi^T
        M1 = xi, eta,   psi^t
             phi, psi,   w  ]
        '''
        # no-need speedup variables
        Psi = COModel.variable('Psi', [N, n], Domain.unbounded())
        Xi = COModel.variable('Xi', n, Domain.unbounded())  # n by 1 vector
        Phi = COModel.variable('Phi', N, Domain.unbounded())  # N by 1 vector
        # has the potential to speedup
        Tau, Eta, W = self.__Declare_SpeedUp_Vars(COModel)

        # M2 matrix decision variables
        '''
            [a, b^T, c^T
        M2 = b, e,   d^t
             c, d,   f  ]
        '''
        a_M2 = COModel.variable('a_M2', 1, Domain.greaterThan(0.0))
        b_M2 = COModel.variable('b_M2', n, Domain.greaterThan(0.0))
        c_M2 = COModel.variable('c_M2', N, Domain.greaterThan(0.0))
        e_M2 = COModel.variable('e_M2', [n, n], Domain.greaterThan(0.0))
        d_M2 = COModel.variable('d_M2', [N, n], Domain.greaterThan(0.0))
        f_M2 = COModel.variable('f_M2', [N, N], Domain.greaterThan(0.0))

        # -- Objective Function
        obj_1 = Expr.dot(f, Z)
        obj_2 = Expr.dot(h, I)
        obj_3 = Expr.dot(b, Alpha)
        obj_4 = Expr.dot(b, Beta)
        obj_5 = Expr.dot([1], Expr.add(Tau, a_M2))
        obj_6 = Expr.dot([2 * mean for mean in mu], Expr.add(Xi, b_M2))
        obj_7 = Expr.dot(sigma, Expr.add(Eta, e_M2))
        COModel.objective(
            ObjectiveSense.Minimize,
            Expr.add([obj_1, obj_2, obj_3, obj_4, obj_5, obj_6, obj_7]))

        # Constraint 1
        _expr = Expr.sub(Expr.mul(A_Mat.transpose(), Alpha), Theta)
        _expr = Expr.sub(_expr, Expr.mul(2, Expr.add(Phi, c_M2)))
        _expr_rhs = Expr.vstack(Expr.constTerm([0.0] * n), Expr.mul(-1, I),
                                Expr.constTerm([0.0] * M))
        COModel.constraint('constr1', Expr.sub(_expr, _expr_rhs),
                           Domain.equalsTo(0.0))
        del _expr, _expr_rhs

        # Constraint 2
        _first_term = Expr.add([
            Expr.mul(Beta.index(row),
                     np.outer(A[row], A[row]).tolist()) for row in range(M)
        ])
        _second_term = Expr.add([
            Expr.mul(Theta.index(k), Matrix.sparse(N, N, [k], [k], [1]))
            for k in range(N)
        ])
        _third_term = Expr.add(W, f_M2)
        _expr = Expr.sub(Expr.add(_first_term, _second_term), _third_term)
        COModel.constraint('constr2', _expr, Domain.equalsTo(0.0))
        del _expr, _first_term, _second_term, _third_term

        # Constraint 3
        _expr = Expr.mul(-2, Expr.add(Psi, d_M2))
        _expr_rhs = Matrix.sparse([[Matrix.eye(n)], [Matrix.sparse(N - n, n)]])
        COModel.constraint('constr3', Expr.sub(_expr, _expr_rhs),
                           Domain.equalsTo(0))
        del _expr, _expr_rhs

        # Constraint 4: I <= M*Z
        COModel.constraint('constr4', Expr.sub(Expr.mul(20000.0, Z), I),
                           Domain.greaterThan(0.0))

        # Constraint 5: M1 is SDP
        COModel.constraint(
            'constr5',
            Expr.vstack(Expr.hstack(Tau, Xi.transpose(), Phi.transpose()),
                        Expr.hstack(Xi, Eta, Psi.transpose()),
                        Expr.hstack(Phi, Psi, W)), Domain.inPSDCone(1 + n + N))

        return COModel