def create_rows_CG(depth, segments_set):

    global TARGETS
    global constraint_indicators

    constraint_indicators = []

    row_value = 0

    row_names = []

    row_values = []

    row_right_sides = []

    row_senses = ""

    num_features = get_num_features()

    data_size = get_data_size()

    num_leafs = 2**depth

    num_nodes = num_leafs - 1

    big_M = get_max_value() - get_min_value()

    constraint_indicators.append(row_value)

    for i in range(num_features):  #constraint (15), indicator 0

        for j in range(num_nodes):

            for l in get_left_leafs(j, num_nodes):

                col_names = [
                    "segment_leaf_" + str(s) + "_" + str(l)
                    for s in range(len(segments_set[l]))
                ]  #x_{l,s}

                col_values = [
                    max([get_feature_value(r, i) for r in s])
                    for s in segments_set[l]
                ]  #mu^{i,s} max

                col_names.extend([
                    "node_feature_" + str(j) + "_" + str(i),
                    "node_constant_" + str(j)
                ])

                col_values.extend([big_M, -1])

                row_names.append("constraint_15_" + str(i) + "_" + str(j) +
                                 "_" + str(l))

                row_values.append([col_names, col_values])

                row_right_sides.append(big_M)

                row_senses = row_senses + "L"

                row_value = row_value + 1

    constraint_indicators.append(row_value)

    for i in range(num_features):  #constraint (16), indicator 1

        for j in range(num_nodes):

            for l in get_right_leafs(j, num_nodes):

                col_names = [
                    "segment_leaf_" + str(s) + "_" + str(l)
                    for s in range(len(segments_set[l]))
                ]  #x_{l,s}

                col_values = [
                    -min([get_feature_value(r, i) for r in s])
                    for s in segments_set[l]
                ]  #mu^{i,s} min

                col_names.extend([
                    "node_feature_" + str(j) + "_" + str(i),
                    "node_constant_" + str(j)
                ])

                col_values.extend([big_M, 1])

                row_names.append("constraint_16_" + str(i) + "_" + str(j) +
                                 "_" + str(l))

                row_values.append([col_names, col_values])

                row_right_sides.append(big_M + 0.01)

                row_senses = row_senses + "L"

                row_value = row_value + 1

    constraint_indicators.append(row_value)

    for r in range(data_size):  #constraint (17), indicator 2

        col_names, col_values = [], []

        for l in range(num_leafs):

            for s in range(len(segments_set[l])):

                if r in segments_set[l][s]:

                    col_names.extend(["segment_leaf_" + str(s) + "_" + str(l)
                                      ])  #x_{l,s}

                    col_values.extend([1])

        row_names.append("constraint_17_" + str(r))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    constraint_indicators.append(row_value)

    for l in range(num_leafs):  #constraint (18), indicator 3

        col_names = [
            "segment_leaf_" + str(s) + "_" + str(l)
            for s in range(len(segments_set[l]))
        ]  #x_{l,s}

        col_values = [1 for s in range(len(segments_set[l]))]  #x_{l,s}

        row_names.append("constraint_18_" + str(l))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    constraint_indicators.append(row_value)

    for r in range(data_size):  #constraint (19), indicator 4

        for l in range(num_leafs):

            col_names, col_values = [], []

            for s in range(len(segments_set[l])):

                if r in segments_set[l][s]:

                    col_names.extend(["segment_leaf_" + str(s) + "_" + str(l)
                                      ])  #x_{l,s}

                    col_values.extend([1])

            for t in range(get_num_targets()):

                if TARGETS[t] != get_target(r):

                    col_names.extend(
                        ["prediction_type_" + str(t) + "_" + str(l)])

                    col_values.extend([1])

            col_names.extend(["row_error_" + str(r)])

            col_values.extend([-1])

            row_names.append("constraint_19_" + str(r) + "_" + str(l))

            row_values.append([col_names, col_values])

            row_right_sides.append(1)

            row_senses = row_senses + "L"

            row_value = row_value + 1

    constraint_indicators.append(row_value)

    for l in range(num_leafs):  #constraint (20), indicator 5

        col_names = [
            "prediction_type_" + str(s) + "_" + str(l)
            for s in range(get_num_targets())
        ]

        col_values = [1 for s in range(get_num_targets())]

        row_names.append("constraint_20_" + str(l))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    constraint_indicators.append(row_value)

    for j in range(num_nodes):  #constraint (21), indicator 6

        col_names = [
            "node_feature_" + str(j) + "_" + str(i)
            for i in range(num_features)
        ]

        col_values = [1 for i in range(num_features)]

        row_names.append("constraint_21_" + str(j))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    return row_names, row_values, row_right_sides, row_senses
Exemplo n.º 2
0
def create_variables(depth, prob):

    global VARS

    var_value = 0

    var_names = []

    var_types = ""

    var_lb = []

    var_ub = []

    var_obj = []

    num_features = get_num_features()

    data_size = get_data_size()

    num_leafs = 2**depth

    num_nodes = num_leafs - 1

    # node n had a boolean test on feature f, boolean. On the paper: f_{i,j}

    for j in range(num_nodes):

        for i in range(num_features):

            VARS["node_feature_" + str(j) + "_" + str(i)] = var_value

            var_names.append("#" + str(var_value))

            var_types = var_types + "B"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

    # value used in the boolean test in node n, integer. On the paper: c_{j}

    for j in range(num_nodes):

        VARS["node_constant_" + str(j)] = var_value

        var_names.append("#" + str(var_value))

        if continuousconstant == 1:

            var_types = var_types + "C"

        else:

            var_types = var_types + "I"

        var_lb.append(get_min_value())

        var_ub.append(get_max_value())

        var_obj.append(0)

        var_value = var_value + 1

    # leaf l predicts type t, boolean. On the paper: p_{l,t}

    for l in range(num_leafs):

        for t in range(get_num_targets()):

            VARS["prediction_type_" + str(t) + "_" + str(l)] = var_value

            var_names.append("#" + str(var_value))

            var_types = var_types + "B"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

    # row error, variables to minimize. On the paper: e_{r}

    for r in range(data_size):

        VARS["row_error_" + str(r)] = var_value

        var_names.append("#" + str(var_value))

        var_types = var_types + "C"

        var_lb.append(0)

        var_ub.append(1)

        var_obj.append(1)

        var_value = var_value + 1

    # indicates that data row r passes node j when executed in decision tree. Careful, leafs are included. On the paper: pt_{r,j}

    for r in range(data_size):

        for j in range(num_nodes):

            VARS["path_node_" + str(j) + "_" + str(r)] = var_value

            var_names.append("#" + str(var_value))

            var_types = var_types + "B"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

        for l in range(num_leafs):

            VARS["path_leaf_" + str(l) + "_" + str(r)] = var_value

            var_names.append("#" + str(var_value))

            var_types = var_types + "B"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

    return var_names, var_types, var_lb, var_ub, var_obj
def create_variables_CG(depth, segments_set):

    var_value = 0

    var_names = []

    var_types = ""

    var_lb = []

    var_ub = []

    var_obj = []

    num_features = get_num_features()

    data_size = get_data_size()

    num_leafs = 2**depth

    num_nodes = num_leafs - 1

    # node n had a boolean test on feature f, boolean. On the paper: f_{i,j}

    for j in range(num_nodes):

        for i in range(num_features):

            var_names.append("node_feature_" + str(j) + "_" + str(i))

            var_types = var_types + "C"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

    # value used in the boolean test in node n, integer. On the paper: c_{j}

    for j in range(num_nodes):

        var_names.append("node_constant_" + str(j))

        var_types = var_types + "C"

        var_lb.append(get_min_value())

        var_ub.append(get_max_value())

        var_obj.append(0)

        var_value = var_value + 1

    # leaf l predicts type t, boolean. On the paper: p_{l,t}

    for l in range(num_leafs):

        for t in range(get_num_targets()):

            var_names.append("prediction_type_" + str(t) + "_" + str(l))

            var_types = var_types + "C"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

    # row error, variables to minimize. On the paper: e_{r}

    for r in range(data_size):

        var_names.append("row_error_" + str(r))

        var_types = var_types + "C"

        var_lb.append(0)

        var_ub.append(1)

        var_obj.append(1)

        var_value = var_value + 1

    for l in range(num_leafs):  # x_{l,s}

        for s in range(len(segments_set[l])):

            var_names.append("segment_leaf_" + str(s) + "_" + str(l))

            var_types = var_types + "C"

            var_lb.append(0)

            var_ub.append(1)

            var_obj.append(0)

            var_value = var_value + 1

    return var_names, var_types, var_lb, var_ub, var_obj
Exemplo n.º 4
0
def create_rows(depth):

    global VARS
    global TARGETS

    row_value = 0

    row_names = []

    row_values = []

    row_right_sides = []

    row_senses = ""

    num_features = get_num_features()

    data_size = get_data_size()

    num_leafs = 2**depth

    num_nodes = num_leafs - 1

    big_M = get_max_value() - get_min_value()

    big_M = 10 * big_M + 10

    for r in range(data_size):  #constraint (2)

        for j in range(num_nodes):

            col_names = [
                VARS["node_feature_" + str(j) + "_" + str(i)]
                for i in range(num_features)
            ]  #f_{i,j}

            col_values = [
                get_feature_value(r, i) for i in range(num_features)
            ]  #mu^{i,r}

            left_node = get_left_node(j, num_nodes)

            if int(left_node) != -1:  #if not a leaf

                col_names.extend(
                    [
                        VARS["path_node_" + str(j) + "_" + str(r)],
                        VARS["path_node_" + str(left_node) + "_" + str(r)]
                    ]
                )  #VARS["depth_true_" + str(r) + "_" + str(get_depth(j,num_nodes)-1)]])

            else:

                col_names.extend([
                    VARS["path_node_" + str(j) + "_" + str(r)],
                    VARS["path_leaf_" + str(j) + "_" + str(r)]
                ])

            col_values.extend([big_M, big_M])

            col_names.extend([VARS["node_constant_" + str(j)]])

            col_values.extend([-1])

            row_names.append("#" + str(row_value))

            row_values.append([col_names, col_values])

            row_right_sides.append(2 * big_M)

            row_senses = row_senses + "L"

            row_value = row_value + 1

    for r in range(data_size):  #constraint (3)

        for j in range(num_nodes):

            col_names = [
                VARS["node_feature_" + str(j) + "_" + str(i)]
                for i in range(num_features)
            ]  #f_{i,j}

            col_values = [
                -get_feature_value(r, i) for i in range(num_features)
            ]  #mu^{i,r}

            right_node = get_right_node(j, num_nodes)

            if int(right_node) != -1:  #if not a leaf

                col_names.extend(
                    [
                        VARS["path_node_" + str(j) + "_" + str(r)],
                        VARS["path_node_" + str(right_node) + "_" + str(r)]
                    ]
                )  #VARS["depth_true_" + str(r) + "_" + str(get_depth(j,num_nodes)-1)]])

            else:

                col_names.extend([
                    VARS["path_node_" + str(j) + "_" + str(r)],
                    VARS["path_leaf_" + str(j + 1) + "_" + str(r)]
                ])

            #col_names.extend([VARS["path_node_" + str(j) + "_" + str(r)], VARS["depth_true_" + str(r) + "_" + str(get_depth(j,num_nodes)-1)]])

            col_values.extend([big_M, big_M])

            col_names.extend([VARS["node_constant_" + str(j)]])

            col_values.extend([1])

            row_names.append("#" + str(row_value))

            row_values.append([col_names, col_values])

            row_right_sides.append(2 * big_M - eps)

            row_senses = row_senses + "L"

            row_value = row_value + 1

    for l in range(num_leafs):  #constraint (4)

        col_names = [
            VARS["prediction_type_" + str(s) + "_" + str(l)]
            for s in range(get_num_targets())
        ]

        col_values = [1 for s in range(get_num_targets())]

        row_names.append("#" + str(row_value))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    for j in range(num_nodes):  #constraint (5)

        col_names = [
            VARS["node_feature_" + str(j) + "_" + str(i)]
            for i in range(num_features)
        ]

        col_values = [1 for i in range(num_features)]

        row_names.append("#" + str(row_value))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    for r in range(data_size):  # constraint (6)

        col_names = [
            VARS["path_leaf_" + str(l) + "_" + str(r)]
            for l in range(num_leafs)
        ]

        col_values = [1 for l in range(num_leafs)]

        col_names.extend([
            VARS["path_node_" + str(j) + "_" + str(r)]
            for j in range(num_nodes)
        ])

        col_values.extend([1 for j in range(num_nodes)])

        row_names.append("#" + str(row_value))

        row_values.append([col_names, col_values])

        row_right_sides.append(depth + 1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    for r in range(data_size):  # contraint (7)

        col_names = []

        col_values = []

        for l in range(num_leafs):

            col_names.extend([VARS["path_leaf_" + str(l) + "_" + str(r)]])

            col_values.extend([1])

        row_names.append("#" + str(row_value))

        row_values.append([col_names, col_values])

        row_right_sides.append(1)

        row_senses = row_senses + "E"

        row_value = row_value + 1

    for r in range(data_size):  # constraint (8) for internal nodes

        for j in range(num_nodes):

            if j != (num_nodes - 1) / 2:

                col_names = [VARS["path_node_" + str(j) + "_" + str(r)]]

                col_values = [1]

                col_names.extend([
                    VARS["path_node_" + str(get_parent(j, depth)) + "_" +
                         str(r)]
                ])

                col_values.extend([-1])

                row_names.append("#" + str(row_value))

                row_values.append([col_names, col_values])

                row_right_sides.append(0)

                row_senses = row_senses + "L"

                row_value = row_value + 1

    for r in range(data_size):  # constraint (8) for leaves

        for l in range(num_leafs):

            col_names = [VARS["path_leaf_" + str(l) + "_" + str(r)]]

            col_values = [1]

            col_names.extend(
                [VARS["path_node_" + str(l - l % 2) + "_" + str(r)]])

            col_values.extend([-1])

            row_names.append("#" + str(row_value))

            row_values.append([col_names, col_values])

            row_right_sides.append(0)

            row_senses = row_senses + "L"

            row_value = row_value + 1

    for r in range(data_size):  #constraint (9)

        for l in range(num_leafs):

            col_names = [VARS["path_leaf_" + str(l) + "_" + str(r)]]

            col_values = [1]

            for s in range(get_num_targets()):

                if TARGETS[s] != get_target(r):

                    col_names.extend(
                        [VARS["prediction_type_" + str(s) + "_" + str(l)]])

                    col_values.extend([1])

            col_names.extend([VARS["row_error_" + str(r)]])

            col_values.extend([-1])

            row_names.append("#" + str(row_value))

            row_values.append([col_names, col_values])

            row_right_sides.append(1)

            row_senses = row_senses + "L"

            row_value = row_value + 1

    if inputsym == 1:  #valid inequalties ?

        for n in range(num_nodes):

            left_leaf = get_left_leafs(n, num_nodes)

            right_leaf = get_right_leafs(n, num_nodes)

            if len(left_leaf) != 1:

                continue

            for s in range(get_num_targets()):

                col_names = [
                    VARS["prediction_type_" + str(s) + "_" + str(left_leaf[0])]
                ]

                col_values = [1]

                col_names.extend([
                    VARS["prediction_type_" + str(s) + "_" +
                         str(right_leaf[0])]
                ])

                col_values.extend([1])

                row_names.append("#" + str(row_value))

                row_values.append([col_names, col_values])

                row_right_sides.append(1)

                row_senses = row_senses + "L"

                row_value = row_value + 1

    return row_names, row_values, row_right_sides, row_senses