Support blmo type and passed test for Cube polytope

src/Boscia.jl

@@ -3,6 +3,16 @@ 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/frank_wolfe_variants.jl

@@ -171,12 +171,65 @@ end
 
 Base.print(io::IO, ::BPCG) = print(io, "Blended Pairwise Conditional Gradient")
 
+#===============================================================================================#
 """
-    Vanilla-Frank-Wolfe
+   DICG-Frank-Wolfe
+
+The Decomposition-invariant Frank-Wolfe. 
+
+"""
+struct DICG <: FrankWolfeVariant end
+
+function solve_frank_wolfe(
+    frank_wolfe_variant::DICG,
+    f,
+    grad!,
+    lmo,
+    active_set;
+    line_search::FrankWolfe.LineSearchMethod=FrankWolfe.Adaptive(),
+    epsilon=1e-7,
+    max_iteration=10000,
+    add_dropped_vertices=false,
+    use_extra_vertex_storage=false,
+    extra_vertex_storage=nothing,
+    callback=nothing,
+    lazy=false,
+    lazy_tolerance=2.0,
+    timeout=Inf,
+    verbose=false,
+    workspace=nothing,
+)
+    x0 = FrankWolfe.compute_active_set_iterate!(active_set)
+    println("lmo:")
+    println(lmo.blmo.lower_bounds)
+    println(lmo.blmo.upper_bounds)
+
+    # Observe that the lazy flag is only observed if away_steps is set to true, so it can neglected. 
+    x, _, primal, dual_gap, _ = FrankWolfe.decomposition_invariant_conditional_gradient(
+        f,
+        grad!,
+        lmo,
+        x0;
+        line_search=line_search,
+        epsilon=epsilon,
+        max_iteration=max_iteration,
+        verbose=verbose,
+        timeout=timeout,
+        lazy=lazy,
+        linesearch_workspace=workspace,
+        lazy_tolerance=lazy_tolerance,
+    )
+    println("x solution:")
+    println(x)
+    active_set = FrankWolfe.ActiveSet([(1.0, x)])
+    return x, primal, dual_gap, active_set
+end
+
+Base.print(io::IO, ::DICG) = print(io, "Decompostion-Invariant-Frank-Wolfe")
 
-The standard variant of Frank-Wolfe. In each iteration, the vertex v minimizing ∇f * (x-v) is computed. 
+"""
+    Vanilla-Frank-Wolfe
 
-Lazification cannot be used in this setting.
 """
 struct VanillaFrankWolfe <: FrankWolfeVariant end
 
@@ -199,26 +252,24 @@ function solve_frank_wolfe(
     verbose=false,
     workspace=nothing,
 )
-    # If the flag away_steps is set to false, away_frank_wolfe performs Vanilla.
+    x0 = FrankWolfe.compute_active_set_iterate!(active_set)
+
     # Observe that the lazy flag is only observed if away_steps is set to true, so it can neglected. 
-    x, _, primal, dual_gap, _, active_set = FrankWolfe.away_frank_wolfe(
+    x, _, primal, dual_gap, _ = FrankWolfe.frank_wolfe(
         f,
         grad!,
         lmo,
-        active_set,
-        away_steps=false,
+        x0;
+        line_search=line_search,
         epsilon=epsilon,
         max_iteration=max_iteration,
-        line_search=line_search,
-        callback=callback,
-        timeout=timeout,
-        add_dropped_vertices=add_dropped_vertices,
-        use_extra_vertex_storage=use_extra_vertex_storage,
-        extra_vertex_storage=extra_vertex_storage,
         verbose=verbose,
+        timeout=timeout,
+        linesearch_workspace=workspace,
     )
-
+    active_set = FrankWolfe.ActiveSet([(1.0, x)])
     return x, primal, dual_gap, active_set
 end
 
 Base.print(io::IO, ::VanillaFrankWolfe) = print(io, "Vanilla-Frank-Wolfe")
+#==========================================================================================#

src/interface.jl

@@ -107,6 +107,8 @@ function solve(
         println("\t Additional kwargs: ", join(keys(kwargs), ","))
     end
 
+
+    println("Boscia-version")
     n, _ = get_list_of_variables(blmo)
 
     integer_variables = Vector{Int}()

src/managed_blmo.jl

@@ -69,6 +69,40 @@ function compute_extreme_point(blmo::ManagedBoundedLMO, d; kwargs...)
     return v
 end
 
+#================================================================================================================#
+function is_decomposition_invariant_oracle(blmo::ManagedBoundedLMO)
+    return is_decomposition_invariant_oracle_simple(blmo.simple_lmo)
+end
+
+# Provide FrankWolfe.compute_inface_extreme_point
+function compute_inface_extreme_point(blmo::ManagedBoundedLMO, direction, x; kwargs...)
+    time_ref = Dates.now()
+    a = bounded_compute_inface_extreme_point(
+                blmo.simple_lmo,
+                direction,
+                x,
+                blmo.lower_bounds,
+                blmo.upper_bounds,
+                blmo.int_vars,
+                )
+
+    blmo.solving_time = float(Dates.value(Dates.now() - time_ref))
+    return a
+end
+
+#Provide FrankWolfe.dicg_maximum_step
+function dicg_maximum_step(blmo::ManagedBoundedLMO, x, direction; kwargs...)
+    return bounded_dicg_maximum_step(
+                blmo.simple_lmo,
+                x,
+                direction,
+                blmo.lower_bounds, 
+                blmo.upper_bounds, 
+                blmo.int_vars,
+                )
+end
+#================================================================================================================#
+
 # Read global bounds from the problem.
 function build_global_bounds(blmo::ManagedBoundedLMO, integer_variables)
     global_bounds = IntegerBounds()

src/node.jl

@@ -59,7 +59,6 @@ mutable struct FrankWolfeNode{
     local_potential_tightenings::Int
     dual_gap::Float64
 end
-
 """
 Create the information of the new branching nodes 
 based on their parent and the index of the branching variable
@@ -69,6 +68,9 @@ function Bonobo.get_branching_nodes_info(tree::Bonobo.BnBTree, node::FrankWolfeN
         error("Splitting on the same index as parent! Abort!")
     end
 
+    println("Splitted Variable idx:")
+    println(vidx)
+
     # get iterate, primal and lower bound
     x = Bonobo.get_relaxed_values(tree, node)
     primal = tree.root.problem.f(x)
@@ -77,12 +79,23 @@ function Bonobo.get_branching_nodes_info(tree::Bonobo.BnBTree, node::FrankWolfeN
 
     # In case of strong convexity, check if a child can be pruned
     prune_left, prune_right = prune_children(tree, node, lower_bound_base, x, vidx)
+    #================================================================================#
+    #different ways to split active set
+    if !(tree.root.options[:variant] == DICG() || tree.root.options[:variant] == VanillaFrankWolfe() )
+        # Split active set
+        active_set_left, active_set_right =
+          split_vertices_set!(node.active_set, tree, vidx, node.local_bounds)
+    else
+        if (typeof(tlmo.blmo.sblmo) == CubeSimpleBLMO)
+          lb, ub = build_node_bounds_all_idx(sblmo, node.local_bounds, tlmo.blmo.n)
+        end
+        active_set_left, active_set_right = 
+          dicg_split_vertices_set!(x, lb, ub, vidx)
+    end
+  #================================================================================#
 
-    # Split active set
-    active_set_left, active_set_right =
-        split_vertices_set!(node.active_set, tree, vidx, node.local_bounds)
     discarded_set_left, discarded_set_right =
-        split_vertices_set!(node.discarded_vertices, tree, vidx, x, node.local_bounds)
+          split_vertices_set!(node.discarded_vertices, tree, vidx, x, node.local_bounds)
 
     # Sanity check
     @assert isapprox(sum(active_set_left.weights), 1.0)
@@ -266,6 +279,8 @@ function Bonobo.evaluate_node!(tree::Bonobo.BnBTree, node::FrankWolfeNode)
     # Check feasibility of the iterate
     active_set = node.active_set
     x = FrankWolfe.compute_active_set_iterate!(node.active_set)
+    println("Active set:")
+    println(node.active_set)
     @assert is_linear_feasible(tree.root.problem.tlmo, x)
     for (_, v) in node.active_set
         @assert is_linear_feasible(tree.root.problem.tlmo, v)