Support blmo type and passed test for Cube polytope

examples/experiments/examples

@@ -0,0 +1 @@
+read

src/Boscia.jl

@@ -3,6 +3,14 @@ module Boscia
 using FrankWolfe
 import FrankWolfe: compute_extreme_point
 export compute_extreme_point
+import FrankWolfe: is_decomposition_invariant_oracle
+export is_decomposition_invariant_oracle
+
+import FrankWolfe: compute_inface_extreme_point
+export compute_inface_extreme_point
+
+import FrankWolfe: dicg_maximum_step
+export dicg_maximum_step
 using Random
 import Bonobo
 using Printf

src/MOI_bounded_oracle.jl

@@ -1,12 +1,25 @@
 """
     BoundedLinearMinimizationOracle for solvers supporting MathOptInterface.
 """
+
+# Store extra information of solving inface extrem points.
+# The keys of MOI_attribute should correspond to specific MOI_attribute names.
+mutable struct Inface_point_solve_data
+    MOI_attribute::Dict
+    function Inface_point_solve_data()
+        MOI_attribute = Dict()
+        return new(MOI_attribute)
+    end
+end
+
 struct MathOptBLMO{OT<:MOI.AbstractOptimizer} <: BoundedLinearMinimizationOracle
     o::OT
     use_modify::Bool
+    inface_point_solve_data::Inface_point_solve_data
     function MathOptBLMO(o, use_modify=true)
         MOI.set(o, MOI.ObjectiveSense(), MOI.MIN_SENSE)
-        return new{typeof(o)}(o, use_modify)
+        inface_point_solve_data = Inface_point_solve_data()
+        return new{typeof(o)}(o, use_modify, inface_point_solve_data)
     end
 end
 
@@ -342,9 +355,16 @@ end
 Get solve time, number of nodes and number of simplex iterations.
 """
 function get_BLMO_solve_data(blmo::MathOptBLMO)
-    opt_times = MOI.get(blmo.o, MOI.SolveTimeSec())
-    numberofnodes = MOI.get(blmo.o, MOI.NodeCount())
-    simplex_iterations = MOI.get(blmo.o, MOI.SimplexIterations())
+    if !isempty(blmo.inface_point_solve_data.MOI_attribute)
+        opt_times = blmo.inface_point_solve_data.MOI_attribute[MOI.SolveTimeSec()]
+        numberofnodes = blmo.inface_point_solve_data.MOI_attribute[MOI.NodeCount()]
+        simplex_iterations = blmo.inface_point_solve_data.MOI_attribute[MOI.SimplexIterations()]
+        empty!(blmo.inface_point_solve_data.MOI_attribute)
+    else
+        opt_times = MOI.get(blmo.o, MOI.SolveTimeSec())
+        numberofnodes = MOI.get(blmo.o, MOI.NodeCount())
+        simplex_iterations = MOI.get(blmo.o, MOI.SimplexIterations())
+    end
     return opt_times, numberofnodes, simplex_iterations
 end
 
@@ -599,6 +619,50 @@ function Bonobo.get_branching_variable(
     return max_idx
 end
 
+
+function is_decomposition_invariant_oracle(blmo::MathOptBLMO)
+    true
+end
+
+function compute_inface_extreme_point(blmo::MathOptBLMO, direction, x; kwargs...)
+    MOI_attribute = Dict()
+    MOI_attribute[MOI.SolveTimeSec()] = 0.0
+    MOI_attribute[MOI.NodeCount()] = 0.0
+    MOI_attribute[MOI.SimplexIterations()] = 0.0
+    blmo.inface_point_solve_data.MOI_attribute = MOI_attribute
+    lmo = convert(FrankWolfe.MathOptLMO, blmo)
+    a = FrankWolfe.compute_inface_extreme_point(lmo,
+        direction,
+        x;
+        solve_data=blmo.inface_point_solve_data.MOI_attribute,
+        kwargs,
+    )
+    @assert blmo isa MathOptBLMO
+    return a
+end
+
+function dicg_maximum_step(blmo::MathOptBLMO, x, direction; kwargs...)
+    lmo = convert(FrankWolfe.MathOptLMO, blmo)
+    return FrankWolfe.dicg_maximum_step(
+        lmo,
+        x,
+        direction;
+        kwargs...,
+    )
+end
+
+# Provide specific active_set split method for MathOptBLMO in DICG.
+function dicg_split_vertices_set!(blmo::MathOptBLMO, active_set::FrankWolfe.ActiveSet{T,R}, tree, vidx::Int;kwargs...)where {T,R}
+    x = FrankWolfe.get_active_set_iterate(active_set)
+    x0_left = copy(x)
+    x0_right = copy(x)
+    x0_left[vidx] = floor(x[vidx])
+    x0_right[vidx] = ceil(x[vidx])
+    as_left = FrankWolfe.ActiveSet([(1.0, x0_left)])
+    as_right = FrankWolfe.ActiveSet([(1.0, x0_right)])
+    return as_left, as_right
+end
+
 """
 Solve function in case of MathOptLMO. 
 Converts the lmo into a MathOptBLMO and calls the solve function below.

src/blmo_interface.jl

@@ -185,6 +185,13 @@ function get_variables_pointers(blmo::BoundedLinearMinimizationOracle, tree)
     return collect(1:N)
 end
 
+"""
+Given split variable index, return corresponding active sets for DICG as a warm start.
+"""
+function dicg_split_vertices_set!(blmo::BoundedLinearMinimizationOracle, active_set::FrankWolfe.ActiveSet{T,R}, tree, vidx::Int;kwargs...)where {T,R}
+    error("Not implemented yet")
+end
+
 
 ## Logs
 """

src/callbacks.jl

@@ -13,82 +13,158 @@ function build_FW_callback(
     fw_iterations,
     min_fw_iterations,
     time_ref,
-    time_limit,
+    time_limit;
+    use_DICG=false,
 )
     vars = get_variables_pointers(tree.root.problem.tlmo.blmo, tree)
     # variable to only fetch heuristics when the counter increases
     ncalls = -1
-    return function fw_callback(state, active_set, kwargs...)
-        @assert isapprox(sum(active_set.weights), 1.0)
-        @assert sum(active_set.weights .< 0) == 0
-        # TODO deal with vertices becoming infeasible with conflicts
-        @debug begin
-            if !is_linear_feasible(tree.root.problem.tlmo, state.v)
-                @info "$(state.v)"
-                check_infeasible_vertex(tree.root.problem.tlmo.blmo, tree)
-                @assert is_linear_feasible(tree.root.problem.tlmo, state.v)
-            end  
-            if state.step_type != FrankWolfe.ST_SIMPLEXDESCENT && !is_integer_feasible(tree, state.v)
-                @info "Vertex not integer feasible! Here are the integer variables: $(state.v[tree.root.problem.integer_variables])"
-                @assert is_integer_feasible(tree, state.v)
-            end    
-        end
-        push!(fw_iterations, state.t)
+    if !use_DICG
+        return function fw_callback(state, active_set, kwargs...)
+            @assert isapprox(sum(active_set.weights), 1.0)
+            @assert sum(active_set.weights .< 0) == 0
+            # TODO deal with vertices becoming infeasible with conflicts
+            @debug begin
+                if !is_linear_feasible(tree.root.problem.tlmo, state.v)
+                    @info "$(state.v)"
+                    check_infeasible_vertex(tree.root.problem.tlmo.blmo, tree)
+                    @assert is_linear_feasible(tree.root.problem.tlmo, state.v)
+                end
+                if state.step_type != FrankWolfe.ST_SIMPLEXDESCENT && !is_integer_feasible(tree, state.v)
+                    @info "Vertex not integer feasible! Here are the integer variables: $(state.v[tree.root.problem.integer_variables])"
+                    @assert is_integer_feasible(tree, state.v)
+                end
+            end
+            push!(fw_iterations, state.t)
 
-        if state.lmo !== nothing  # can happen with using Blended Conditional Gradient
-            if ncalls != state.lmo.ncalls
-                ncalls = state.lmo.ncalls
-                (best_v, best_val) = find_best_solution(
-                    tree.root.problem.f,
-                    tree.root.problem.tlmo.blmo,
-                    vars,
-                    tree.root.options[:domain_oracle],
-                )
-                if best_val < tree.incumbent
+            if state.lmo !== nothing  # can happen with using Blended Conditional Gradient
+                if ncalls != state.lmo.ncalls
+                    ncalls = state.lmo.ncalls
+                    (best_v, best_val) = find_best_solution(
+                        tree.root.problem.f,
+                        tree.root.problem.tlmo.blmo,
+                        vars,
+                        tree.root.options[:domain_oracle],
+                    )
+                    if best_val < tree.incumbent
+                        node = tree.nodes[tree.root.current_node_id[]]
+                        add_new_solution!(tree, node, best_val, best_v, :Solver)
+                        Bonobo.bound!(tree, node.id)
+                    end
+                end
+            end
+
+            if (state.primal - state.dual_gap > tree.incumbent + 1e-2) &&
+               tree.num_nodes != 1 &&
+               state.t > min_fw_iterations
+                return false
+            end
+
+            if tree.root.options[:domain_oracle](state.v) && state.step_type != FrankWolfe.ST_SIMPLEXDESCENT
+                val = tree.root.problem.f(state.v)
+                if val < tree.incumbent
+                    #TODO: update solution without adding node
                     node = tree.nodes[tree.root.current_node_id[]]
-                    add_new_solution!(tree, node, best_val, best_v, :Solver)
+                    add_new_solution!(tree, node, val, copy(state.v), :vertex)
                     Bonobo.bound!(tree, node.id)
                 end
             end
-        end
 
-        if (state.primal - state.dual_gap > tree.incumbent + 1e-2) &&
-           tree.num_nodes != 1 &&
-           state.t > min_fw_iterations
-            return false
-        end
+            node = tree.nodes[tree.root.current_node_id[]]
+            if length(node.active_set) > 1 &&
+               !isempty(tree.nodes) &&
+               min_number_lower <= length(values(tree.nodes))
+                counter = 0
+                for n in values(tree.nodes)
+                    if n.lb < val
+                        counter += 1
+                    end
+                    if counter > min_number_lower
+                        return false
+                    end
+                end
+            end
 
-        if tree.root.options[:domain_oracle](state.v) && state.step_type != FrankWolfe.ST_SIMPLEXDESCENT
-            val = tree.root.problem.f(state.v)
-            if val < tree.incumbent
-                #TODO: update solution without adding node
-                node = tree.nodes[tree.root.current_node_id[]]
-                add_new_solution!(tree, node, val, copy(state.v), :vertex)
-                Bonobo.bound!(tree, node.id)
+            # check for time limit
+            if isfinite(time_limit) && Dates.now() >= time_ref + Dates.Second(time_limit)
+                return false
             end
+
+            return true
         end
+    else
+        return function (state, kwargs...)
+            # TODO deal with vertices becoming infeasible with conflicts
+            @debug begin
+                if !is_linear_feasible(tree.root.problem.tlmo, state.v)
+                    @info "$(state.v)"
+                    check_infeasible_vertex(tree.root.problem.tlmo.blmo, tree)
+                    @assert is_linear_feasible(tree.root.problem.tlmo, state.v)
+                end
+                if state.step_type != FrankWolfe.ST_SIMPLEXDESCENT && !is_integer_feasible(tree, state.v)
+                    @info "Vertex not integer feasible! Here are the integer variables: $(state.v[tree.root.problem.integer_variables])"
+                    @assert is_integer_feasible(tree, state.v)
+                end
+            end
+            push!(fw_iterations, state.t)
 
-        node = tree.nodes[tree.root.current_node_id[]]
-        if length(node.active_set) > 1 &&
-           !isempty(tree.nodes) &&
-           min_number_lower <= length(values(tree.nodes))
-            counter = 0
-            for n in values(tree.nodes)
-                if n.lb < val
-                    counter += 1
+            if state.lmo !== nothing  # can happen with using Blended Conditional Gradient
+                if ncalls != state.lmo.ncalls
+                    ncalls = state.lmo.ncalls
+                    (best_v, best_val) = find_best_solution(
+                        tree.root.problem.f,
+                        tree.root.problem.tlmo.blmo,
+                        vars,
+                        tree.root.options[:domain_oracle],
+                    )
+                    if best_val < tree.incumbent
+                        node = tree.nodes[tree.root.current_node_id[]]
+                        add_new_solution!(tree, node, best_val, best_v, :Solver)
+                        Bonobo.bound!(tree, node.id)
+                    end
                 end
-                if counter > min_number_lower
-                    return false
+            end
+
+            if (state.primal - state.dual_gap > tree.incumbent + 1e-2) &&
+               tree.num_nodes != 1 &&
+               state.t > min_fw_iterations
+                return false
+            end
+
+            if tree.root.options[:domain_oracle](state.v)
+                val = tree.root.problem.f(state.v)
+                if val < tree.incumbent
+                    #TODO: update solution without adding node
+                    node = tree.nodes[tree.root.current_node_id[]]
+                    add_new_solution!(tree, node, val, copy(state.v), :vertex)
+                    Bonobo.bound!(tree, node.id)
+                end
+            end
+
+            node = tree.nodes[tree.root.current_node_id[]]
+            if length(node.active_set) > 1 &&
+               !isempty(tree.nodes) &&
+               min_number_lower <= length(values(tree.nodes))
+                counter = 0
+                for n in values(tree.nodes)
+                    if n.lb < val
+                        counter += 1
+                    end
+                    if counter > min_number_lower
+                        return false
+                    end
                 end
             end
-        end
 
-        # check for time limit
-        if isfinite(time_limit) && Dates.now() >= time_ref + Dates.Second(time_limit)
-            return false
+            # check for time limit
+            if isfinite(time_limit) && Dates.now() >= time_ref + Dates.Second(time_limit)
+                return false
+            end
+
+            return true
         end
 
-        return true
+
     end
 end