Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Choose which functions to include in precompilation #220

Closed
matbesancon opened this issue Jul 19, 2021 · 2 comments
Closed

Choose which functions to include in precompilation #220

matbesancon opened this issue Jul 19, 2021 · 2 comments

Comments

@matbesancon
Copy link
Member

The precompilation might be a bit heavy to do systematically.
@odow what criteria did you pick to choose what to precompile and what not on MOI?
@odow
Copy link

odow commented Jul 19, 2021

SnoopCompile: look at the times. Pick the largest. Then try and come up with some systematic way to choose which functions. So not very helpful...

e.g.,

FrankWolfe.jl/src/precompile.jl

Lines 61 to 63 in dfba2f6

precompile(Tuple{typeof(Base.:(+)), Array{Float64, 1}, FrankWolfe.ScaledHotVector{Base.MPFR.BigFloat}})
precompile(Tuple{typeof(Base.:(+)), Array{Float64, 1}, FrankWolfe.ScaledHotVector{Float64}})
precompile(Tuple{typeof(Base.:(*)), Array{Float64, 2}, FrankWolfe.ScaledHotVector{Float64}}) 

for T in [Float64, Base.MPFR.BigFloat]
    precompile(Tuple{typeof(Base.:(+)), Array{Float64, 1}, FrankWolfe.ScaledHotVector{T}})
    precompile(Tuple{typeof(Base.:(*)), Array{Float64, 2}, FrankWolfe.ScaledHotVector{T}})
end

Some of these you may be better of @nospecializeing

FrankWolfe.jl/src/precompile.jl

Lines 22 to 59 in dfba2f6

precompile(Tuple{Type{NamedTuple{(:epsilon, :max_iteration, :line_search, :print_iter, :emphasis, :L, :verbose, :trajectory, :K, :weight_purge_threshold), T} where T<:Tuple}, Tuple{Float64, Int64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Float64, Bool, Bool, Float64, Float64}})
precompile(Tuple{Type{NamedTuple{(:epsilon, :max_iteration, :line_search, :print_iter, :hessian, :emphasis, :L, :accelerated, :verbose, :trajectory, :K, :weight_purge_threshold), T} where T<:Tuple}, Tuple{Float64, Int64, FrankWolfe.Adaptive, Float64, Array{Float64, 2}, FrankWolfe.Emphasis, Float64, Bool, Bool, Bool, Float64, Float64}})
precompile(Tuple{Type{NamedTuple{(:L, :verbose, :line_search, :max_iteration, :print_iter, :trajectory), T} where T<:Tuple}, Tuple{Int64, Bool, FrankWolfe.Adaptive, Int64, Float64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :epsilon, :line_search, :print_iter, :emphasis, :trajectory, :verbose), T} where T<:Tuple}, Tuple{Int64, Float64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :L, :print_iter, :emphasis, :verbose, :epsilon, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Int64, Float64, FrankWolfe.Emphasis, Bool, Float64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :L, :print_iter, :emphasis, :verbose, :epsilon, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Agnostic, Int64, Float64, FrankWolfe.Emphasis, Bool, Float64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :L, :print_iter, :emphasis, :verbose, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Shortstep, Int64, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :L, :print_iter, :epsilon, :emphasis, :verbose, :away_steps, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Int64, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :L, :print_iter, :epsilon, :momentum, :emphasis, :verbose, :away_steps, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Int64, Float64, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :L, :print_iter, :verbose, :emphasis), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.RationalShortstep, Int64, Float64, Bool, FrankWolfe.Emphasis}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :emphasis, :verbose, :epsilon, :trajectory, :away_steps), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Bool, Float64, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :emphasis, :verbose, :epsilon, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Bool, Float64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :emphasis, :verbose, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :emphasis, :verbose, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Agnostic, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :emphasis, :verbose), T} where T<:Tuple}, Tuple{Float64, FrankWolfe.Agnostic, Float64, FrankWolfe.Emphasis, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :emphasis, :verbose), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Agnostic, Float64, FrankWolfe.Emphasis, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :epsilon, :emphasis, :trajectory, :cache_size, :verbose), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, FrankWolfe.Emphasis, Bool, Int64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :epsilon, :emphasis, :trajectory, :verbose), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :epsilon, :emphasis, :verbose, :away_steps, :trajectory), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :epsilon, :emphasis, :verbose, :trajectory, :lazy), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :epsilon, :linesearch_tol, :emphasis, :trajectory, :verbose), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :linesearch_tol, :epsilon, :emphasis, :lazy, :trajectory, :verbose), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :linesearch_tol, :epsilon, :emphasis, :trajectory, :verbose), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Adaptive, Float64, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :verbose, :emphasis), T} where T<:Tuple}, Tuple{Int64, FrankWolfe.Agnostic, Float64, Bool, FrankWolfe.Emphasis}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :line_search, :print_iter, :verbose), T} where T<:Tuple}, Tuple{Float64, FrankWolfe.Nonconvex, Float64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :L, :line_search, :print_iter, :emphasis, :cache_size, :verbose), T} where T<:Tuple}, Tuple{Int64, Int64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Int64, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :L, :line_search, :print_iter, :emphasis, :verbose), T} where T<:Tuple}, Tuple{Int64, Int64, FrankWolfe.Adaptive, Float64, FrankWolfe.Emphasis, Bool}})
precompile(Tuple{Type{NamedTuple{(:max_iteration, :L, :line_search, :print_iter, :linesearch_tol, :emphasis, :trajectory, :verbose), T} where T<:Tuple}, Tuple{Int64, Int64, FrankWolfe.Adaptive, Float64, Float64, FrankWolfe.Emphasis, Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:momentum, :verbose, :rng, :line_search, :max_iteration, :print_iter, :batch_size, :trajectory), T} where T<:Tuple}, Tuple{Float64, Bool, Random._GLOBAL_RNG, FrankWolfe.Nonconvex, Int64, Float64, Int64, Bool}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :cache_size, :x, :v), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 2}, FrankWolfe.RankOneMatrix{Float64, Array{Float64, 1}, Array{Float64, 1}}}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v, :active_set_length, :non_simplex_iter), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, SparseArrays.SparseVector{Float64, Int64}, FrankWolfe.ScaledHotVector{Float64}, Int64, Int64}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v, :active_set_length), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, SparseArrays.SparseVector{Float64, Int64}, FrankWolfe.ScaledHotVector{Float64}, Int64}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, Array{Float64, 1}, FrankWolfe.ScaledHotVector{Float64}}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, Array{Float64, 2}, FrankWolfe.RankOneMatrix{Float64, Array{Float64, 1}, Array{Float64, 1}}}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, FrankWolfe.ScaledHotVector{Float64}, Array{Float64, 1}}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, FrankWolfe.ScaledHotVector{Float64}, FrankWolfe.ScaledHotVector{Float64}}})
precompile(Tuple{Type{NamedTuple{(:t, :primal, :dual, :dual_gap, :time, :x, :v), T} where T<:Tuple}, Tuple{Int64, Float64, Float64, Float64, Float64, SparseArrays.SparseVector{Float64, Int64}, FrankWolfe.ScaledHotVector{Float64}}})
precompile(Tuple{Type{NamedTuple{(:verbose, :rng, :line_search, :max_iteration, :print_iter, :batch_size, :trajectory), T} where T<:Tuple}, Tuple{Bool, Random._GLOBAL_RNG, FrankWolfe.Nonconvex, Int64, Float64, Int64, Bool}})

Or make a single struct.

These suggest type instabilities somewhere:

FrankWolfe.jl/src/precompile.jl

Lines 1 to 17 in dfba2f6

precompile(Tuple{Type{Array{T, 2} where T}, FrankWolfe.RankOneMatrix{Float64, Array{Float64, 1}, Array{Float64, 1}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(+)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.:(-)), Tuple{Int64, Float64}}, Array{Float64, 1}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, FrankWolfe.ScaledHotVector{Base.Rational{Base.GMP.BigInt}}}}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(+)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.:(-)), Tuple{Int64, Float64}}, Array{Float64, 1}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, FrankWolfe.ScaledHotVector{Float64}}}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(-)), Tuple{FrankWolfe.ScaledHotVector{Float64}, Array{Float64, 1}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(*)), Tuple{Int64, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(-)), Tuple{FrankWolfe.ScaledHotVector{Float64}, Array{Float64, 1}}}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(-)), Tuple{Array{Float64, 2}, FrankWolfe.RankOneMatrix{Float64, Array{Float64, 1}, Array{Float64, 1}}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(+)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(*)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.:(-)), Tuple{Int64, Float64}}, Array{Float64, 2}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(*)), Tuple{Float64, FrankWolfe.RankOneMatrix{Float64, Array{Float64, 1}, Array{Float64, 1}}}}}})
precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Axes, F, Args} where Args<:Tuple where F where Axes}, typeof(Base.:(*)), Tuple{Float64, FrankWolfe.RankOneMatrix{Float64, Array{Float64, 1}, Array{Float64, 1}}}})
precompile(Tuple{Type{FrankWolfe.KSparseLMO{T} where T}, Int64, Float64})
precompile(Tuple{Type{FrankWolfe.LpNormLMO{2, p} where p}, Float64})
precompile(Tuple{Type{FrankWolfe.LpNormLMO{Float64, 1}}, Float64})
precompile(Tuple{Type{FrankWolfe.MultiCacheLMO{500, FrankWolfe.BirkhoffPolytopeLMO, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, FrankWolfe.BirkhoffPolytopeLMO})
precompile(Tuple{Type{FrankWolfe.MultiCacheLMO{500, FrankWolfe.KSparseLMO{Float64}, SparseArrays.SparseVector{Float64, Int64}}}, FrankWolfe.KSparseLMO{Float64}})
precompile(Tuple{Type{FrankWolfe.NuclearNormLMO{T} where T}, Float64})
precompile(Tuple{Type{FrankWolfe.ProbabilitySimplexOracle{Base.Rational{Base.GMP.BigInt}}}, Int64})
precompile(Tuple{Type{FrankWolfe.ProbabilitySimplexOracle{T} where T}, Float64})
precompile(Tuple{Type{FrankWolfe.ProbabilitySimplexOracle{T} where T}, Int64})

@hannahtro
Copy link
Collaborator

Here is a list of functions called in FrankWolfe.jl/examples/. I used @snoopi_deep to collect the data and created flamegraphs of functions that the compiler is compiling. The functions highlighted in gray are not precompilable and correspond to the red flames in the graph.

approximate_caratheodory

  • logging.jl:477, MethodInstance for current_logger_for_env(::Base.CoreLogging.LogLevel, ::Symbol, ::Module)

  • FrankWolfe.jl/src/utils.jl:9, MethodInstance for line_search_wrapper(::Main.FrankWolfe.RationalShortstep, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::Matrix{Float64}, ::Any, ::Int64, ::Int64, ::Float64, ::Int64, ::Float64)

  • intfuncs.jl:761, MethodInstance for string(::Int64)

  • FrankWolfe.jl/src/utils.jl:9, MethodInstance for line_search_wrapper(::Main.FrankWolfe.RationalShortstep, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::Matrix{Float64}, ::Any, ::Int64, ::Int64, ::Float64, ::Int64, ::Float64) ```

  • FrankWolfe.jl/src/utils.jl:779, MethodInstance for print(::IOBuffer, ::Main.FrankWolfe.RationalShortstep)

    strings/io.jl:174, MethodInstance for string(::String, ::Main.FrankWolfe.Emphasis, ::String, ::Main.FrankWolfe.RationalShortstep, ::String, ::Float64, ::String, ::Int64, ::String, ::Type{Float64})

away_step_cg

InferenceTimingNode: 7.708753/11.124768 on Core.Compiler.Timings.ROOT() with 25 direct children

image

  • FrankWolfe.jl/src/polytope_oracles.jl:18, MethodInstance for compute_extreme_point(::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    julia/stdlib/v1.6/SparseArrays/src/sparsevector.jl:855, MethodInstance for getindex(::SparseArrays.SparseVector{Float64, Int64}, ::Vector{Int64})

  • FrankWolfe.jl/src/polytope_oracles.jl:18, MethodInstance for compute_extreme_point(::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    sort.jl:899, MethodInstance for (::Base.var"#sortperm##kw")(::NamedTuple{(:by, :rev), Tuple{typeof(abs), Bool}}, ::typeof(sortperm), ::SparseArrays.SparseVector{Float64, Int64})

  • FrankWolfe.jl/src/polytope_oracles.jl:18, MethodInstance for compute_extreme_point(::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    broadcast.jl:890, MethodInstance for materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{UnitRange{Int64}}})

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Adaptive, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::Float64, ::Int64, ::Int64, ::Float64, ::Int64, ::Float64)

  • broadcast.jl:890, MethodInstance for materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{UnitRange{Int64}}})

  • FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::Float64, ::Int64, ::Int64, ::Float64, ::Int64, ::Float64)

    FrankWolfe.jl/src/utils.jl:68, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max,), Tuple{Float64}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::Int64)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

  • broadcast.jl:890, MethodInstance for materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{UnitRange{Int64}}})

birkhoff_polytope

FrankWolfe.blended_conditional_gradient(...)
InferenceTimingNode: 56.631782/60.467541 on Core.Compiler.Timings.ROOT() with 46 direct children

image

  • FrankWolfe.jl/src/blended_cg.jl:12, MethodInstance for var"#blended_conditional_gradient#66"(::Main.FrankWolfe.Adaptive, ::Main.FrankWolfe.Adaptive, ::Int64, ::Int64, ::Nothing, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Bool, ::Float64, ::Float64, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, ::typeof(Main.FrankWolfe.blended_conditional_gradient), ::Function, ::Function, ::Main.FrankWolfe.BirkhoffPolytopeLMO, ::SparseArrays.SparseMatrixCSC{Float64, Int64})

    FrankWolfe.jl/src/blended_cg.jl:311, MethodInstance for (::Main.FrankWolfe.var"#minimize_over_convex_hull!##kw")(::NamedTuple{(:line_search_inner, :verbose, :print_iter, :hessian, :accelerated, :max_iteration, :callback, :timeout, :print_callback, :format_string), _A} where _A<:Tuple{Main.FrankWolfe.Adaptive, Bool, Float64, Nothing, Bool, Int64, Union{Nothing, Main.FrankWolfe.var"#push_trajectory![Low] add basic readme #9"{Vector{Any}}}, Float64, typeof(Main.FrankWolfe.print_callback), String}, ::typeof(Main.FrankWolfe.minimize_over_convex_hull!), ::Function, ::Function, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{SparseArrays.SparseMatrixCSC{Float64, Int64}, Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:783, MethodInstance for (::Main.FrankWolfe.var"#simplex_gradient_descent_over_convex_hull##kw")(::NamedTuple{(:line_search_inner, :verbose, :print_iter, :linesearch_tol, :step_lim, :weight_purge_threshold, :max_iteration, :callback, :timeout, :print_callback, :format_string), Tuple{Main.FrankWolfe.Adaptive, Bool, Float64, Float64, Int64, Float64, Int64, Nothing, Float64, typeof(Main.FrankWolfe.print_callback), String}}, ::typeof(Main.FrankWolfe.simplex_gradient_descent_over_convex_hull), ::Function, ::Function, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{SparseArrays.SparseMatrixCSC{Float64, Int64}, Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/utils.jl:68, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max, :upgrade_accuracy), Tuple{Float64, Bool}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::Nothing)

  • FrankWolfe.jl/src/blended_cg.jl:12, MethodInstance for var"#blended_conditional_gradient#66"(::Main.FrankWolfe.Adaptive, ::Main.FrankWolfe.Adaptive, ::Int64, ::Int64, ::Nothing, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Bool, ::Float64, ::Float64, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, ::typeof(Main.FrankWolfe.blended_conditional_gradient), ::Function, ::Function, ::Main.FrankWolfe.BirkhoffPolytopeLMO, ::SparseArrays.SparseMatrixCSC{Float64, Int64})

    FrankWolfe.jl/src/blended_cg.jl:311, MethodInstance for (::Main.FrankWolfe.var"#minimize_over_convex_hull!##kw")(::NamedTuple{(:line_search_inner, :verbose, :print_iter, :hessian, :accelerated, :max_iteration, :callback, :timeout, :print_callback, :format_string), _A} where _A<:Tuple{Main.FrankWolfe.Adaptive, Bool, Float64, Nothing, Bool, Int64, Union{Nothing, Main.FrankWolfe.var"#push_trajectory!#9"{Vector{Any}}}, Float64, typeof(Main.FrankWolfe.print_callback), String}, ::typeof(Main.FrankWolfe.minimize_over_convex_hull!), ::Function, ::Function, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{SparseArrays.SparseMatrixCSC{Float64, Int64}, Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

blended_cg

FrankWolfe.blended_conditional_gradient(...)
InferenceTimingNode: 6.991364/11.824437 on Core.Compiler.Timings.ROOT() with 44 direct children

image

  • FrankWolfe.jl/src/blended_cg.jl:12, MethodInstance for var"#blended_conditional_gradient#66"(::Main.FrankWolfe.Adaptive, ::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Matrix{Float64}, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Bool, ::Float64, ::Float64, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, ::typeof(Main.FrankWolfe.blended_conditional_gradient), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Main.FrankWolfe.ScaledHotVector{Float64})

    FrankWolfe.jl/src/blended_cg.jl:311, MethodInstance for (::Main.FrankWolfe.var"#minimize_over_convex_hull!##kw")(::NamedTuple{(:line_search_inner, :verbose, :print_iter, :hessian, :accelerated, :max_iteration, :callback, :timeout, :print_callback, :format_string), _A} where _A<:Tuple{Main.FrankWolfe.Adaptive, Bool, Float64, Matrix{Float64}, Bool, Int64, Union{Nothing, Main.FrankWolfe.var"#push_trajectory![Low] add basic readme #9"{Vector{Any}}}, Float64, typeof(Main.FrankWolfe.print_callback), String}, ::typeof(Main.FrankWolfe.minimize_over_convex_hull!), ::Function, ::Function, ::SparseVector{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{Main.FrankWolfe.ScaledHotVector{Float64}, Float64, SparseVector{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:311, MethodInstance for var"#minimize_over_convex_hull!Implement the core of FW methods as iterators #67"(::Main.FrankWolfe.Adaptive, ::Bool, ::Float64, ::Matrix{Float64}, ::Float64, ::Int64, ::Float64, ::Nothing, ::Bool, ::Int64, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::String, ::typeof(Main.FrankWolfe.minimize_over_convex_hull!), ::Function, ::Function, ::SparseVector{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{Main.FrankWolfe.ScaledHotVector{Float64}, Float64, SparseVector{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:555, MethodInstance for (::Main.FrankWolfe.var"#accelerated_simplex_gradient_descent_over_probability_simplex##kw")(::NamedTuple{(:verbose, :print_iter, :L, :mu, :max_iteration, :callback, :timeout, :print_callback, :format_string), _A} where _A<:Tuple{Bool, Float64, Union{Float64, ComplexF64}, Union{Float64, ComplexF64}, Int64, Nothing, Float64, typeof(Main.FrankWolfe.print_callback), String}, ::typeof(Main.FrankWolfe.accelerated_simplex_gradient_descent_over_probability_simplex), ::Vector{Float64}, ::Main.FrankWolfe.var"#reduced_f#68"{Matrix{Float64}, _A, SparseVector{Float64, Int64}, _B, _C, SparseVector{Float64, Int64}} where {_A, _B, _C}, ::Main.FrankWolfe.var"#reduced_grad!BCG #69"{_A, _B} where {_A, _B}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:555, MethodInstance for var"#accelerated_simplex_gradient_descent_over_probability_simplex#76"(::Bool, ::Float64, ::ComplexF64, ::ComplexF64, ::Int64, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::String, ::typeof(Main.FrankWolfe.accelerated_simplex_gradient_descent_over_probability_simplex), ::Vector{Float64}, ::Main.FrankWolfe.var"#reduced_f#68"{Matrix{Float64}, _A, SparseVector{Float64, Int64}, _B, _C, SparseVector{Float64, Int64}} where {_A, _B, _C}, ::Main.FrankWolfe.var"#reduced_grad!BCG #69"{_A, _B} where {_A, _B}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:738, MethodInstance for projection_simplex_sort(::Vector{ComplexF64})

  • FrankWolfe.jl/src/blended_cg.jl:12, MethodInstance for var"#blended_conditional_gradient#66"(::Main.FrankWolfe.Adaptive, ::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Matrix{Float64}, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Bool, ::Float64, ::Float64, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, ::typeof(Main.FrankWolfe.blended_conditional_gradient), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Main.FrankWolfe.ScaledHotVector{Float64})

    FrankWolfe.jl/src/active_set.jl:83, MethodInstance for active_set_update!(::Main.FrankWolfe.ActiveSet{Main.FrankWolfe.ScaledHotVector{Float64}, Float64, SparseVector{Float64, Int64}}, ::Float64, ::Main.FrankWolfe.ScaledHotVector{Float64})

    broadcast.jl:890, MethodInstance for materialize!(::SparseVector{Float64, Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(identity), Tuple{Int64}})

  • FrankWolfe.jl/src/blended_cg.jl:12, MethodInstance for var"#blended_conditional_gradient#66"(::Main.FrankWolfe.Adaptive, ::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Matrix{Float64}, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Bool, ::Float64, ::Float64, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, ::typeof(Main.FrankWolfe.blended_conditional_gradient), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Main.FrankWolfe.ScaledHotVector{Float64})

    FrankWolfe.jl/src/blended_cg.jl:311, MethodInstance for (::Main.FrankWolfe.var"#minimize_over_convex_hull!##kw")(::NamedTuple{(:line_search_inner, :verbose, :print_iter, :hessian, :accelerated, :max_iteration, :callback, :timeout, :print_callback, :format_string), _A} where _A<:Tuple{Main.FrankWolfe.Adaptive, Bool, Float64, Matrix{Float64}, Bool, Int64, Union{Nothing, Main.FrankWolfe.var"#push_trajectory!#9"{Vector{Any}}}, Float64, typeof(Main.FrankWolfe.print_callback), String}, ::typeof(Main.FrankWolfe.minimize_over_convex_hull!), ::Function, ::Function, ::SparseVector{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{Main.FrankWolfe.ScaledHotVector{Float64}, Float64, SparseVector{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:311, MethodInstance for var"#minimize_over_convex_hull!#67"(::Main.FrankWolfe.Adaptive, ::Bool, ::Float64, ::Matrix{Float64}, ::Float64, ::Int64, ::Float64, ::Nothing, ::Bool, ::Int64, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::String, ::typeof(Main.FrankWolfe.minimize_over_convex_hull!), ::Function, ::Function, ::SparseVector{Float64, Int64}, ::Main.FrankWolfe.ActiveSet{Main.FrankWolfe.ScaledHotVector{Float64}, Float64, SparseVector{Float64, Int64}}, ::Float64, ::Int64, ::UInt64, ::Int64)

    FrankWolfe.jl/src/blended_cg.jl:656, MethodInstance for (::Main.FrankWolfe.var"#simplex_gradient_descent_over_probability_simplex##kw")(::NamedTuple{(:verbose, :print_iter, :L, :max_iteration, :callback, :timeout, :print_callback, :format_string), _A} where _A<:Tuple{Bool, Float64, Union{Float64, ComplexF64}, Int64, Nothing, Float64, typeof(Main.FrankWolfe.print_callback), String}, ::typeof(Main.FrankWolfe.simplex_gradient_descent_over_probability_simplex), ::Vector{Float64}, ::Main.FrankWolfe.var"#reduced_f#68"{Matrix{Float64}, _A, SparseVector{Float64, Int64}, _B, _C, SparseVector{Float64, Int64}} where {_A, _B, _C}, ::Main.FrankWolfe.var"#reduced_grad!#69"{_A, _B} where {_A, _B}, ::Float64, ::Int64, ::UInt64, ::Int64)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)
    julia/stdlib/v1.6/Printf/src/Printf.jl:702, MethodInstance for format(::Vector{UInt8}, ::Int64, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

lazy_away_step_cg-sparsity

InferenceTimingNode: 5.231079/6.858725 on Core.Compiler.Timings.ROOT() with 19 direct children

image

  • MethodInstance for compute_extreme_point(::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    julia/stdlib/v1.6/SparseArrays/src/sparsevector.jl:855, MethodInstance for getindex(::SparseArrays.SparseVector{Float64, Int64}, ::Vector{Int64})

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Shortstep, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    broadcast.jl:1212, MethodInstance for dotview(::SparseArrays.SparseVector{Float64, Int64}, ::UnitRange{Int64})

  • REPL[18]:1, MethodInstance for grad!(::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64})

    broadcast.jl:890, MethodInstance for materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{UnitRange{Int64}}})

  • show.jl:812, MethodInstance for show(::IOBuffer, ::Type{Main.FrankWolfe.Shortstep})

  • julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

    julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

lazy_away_step_cg

FrankWolfe.away_frank_wolfe(...)

image

  • FrankWolfe.jl/src/afw.jl:10, MethodInstance for var"#away_frank_wolfe#85"(::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Nothing, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Int64, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.away_frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::Vector{Float64}, ::SparseArrays.SparseVector{Float64, Int64}, ::Float64, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

    FrankWolfe.jl/src/utils.jl:68, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max,), Tuple{Float64}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::Vector{Float64}, ::Float64)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:702, MethodInstance for format(::Vector{UInt8}, ::Int64, ::Printf.Format{Base.CodeUnits{UInt8, String}, NTuple{8, Printf.Spec{Val{'s'}}}}, ::String, ::String, ::Vararg{String, N} where N)

lcg_cache_size

FrankWolfe.lazified_conditional_gradient(...)

image

  • FrankWolfe.jl/src/fw_algorithms.jl:235, MethodInstance for var"#lazified_conditional_gradient#88"(::Main.FrankWolfe.Adaptive, ::Int64, ::Int64, ::Float64, ::Float64, ::Bool, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Int64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Type{SparseArrays.SparseVector{Float64, Int64}}, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.lazified_conditional_gradient), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::Any, ::SparseArrays.SparseVector{Float64, Int64}, ::Any, ::Int64, ::Int64, ::Float64, ::Int64, ::Float64)

    FrankWolfe.jl/src/utils.jl:68, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max,), Tuple{Float64}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64}, ::Any, ::Int64)

lcg_expensive_LMO

InferenceTimingNode: 989.028872/992.284185 on Core.Compiler.Timings.ROOT() with 31 direct children

image

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.BirkhoffPolytopeLMO, ::SparseArrays.SparseMatrixCSC{Float64, Int64})

    FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::SparseArrays.SparseMatrixCSC{Float64, Int64}, ::Float64, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

linear_regression

FrankWolfe.compute_gradient(..)

root node has no children

lowerbound

image

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Agnostic, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    broadcast.jl:890, MethodInstance for materialize!(::SparseArrays.SparseVector{Float64, Int64}, ::Base.Broadcast.Broadcasted{SparseArrays.HigherOrderFns.SparseVecStyle, Nothing, typeof(-), Tuple{SparseArrays.SparseVector{Float64, Int64}, Base.Broadcast.Broadcasted{SparseArrays.HigherOrderFns.SparseVecStyle, Nothing, typeof(*), Tuple{Rational{Int64}, SparseArrays.SparseVector{Float64, Int64}}}}})

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Agnostic, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    julia/stdlib/v1.6/SparseArrays/src/sparsevector.jl:1449, MethodInstance for *(::Rational{Int64}, ::SparseArrays.SparseVector{Float64, Int64})

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Agnostic, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    Enums.jl:26, MethodInstance for Symbol(::Main.FrankWolfe.StepType)

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Agnostic, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    REPL[128]:2, MethodInstance for grad!(::SparseArrays.SparseVector{Float64, Int64}, ::SparseArrays.SparseVector{Float64, Int64})

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Agnostic, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.KSparseLMO{Float64}, ::SparseArrays.SparseVector{Float64, Int64})

    broadcast.jl:890, MethodInstance for materialize!(::SparseArrays.SparseVector{Float64, Int64}, ::Base.Broadcast.Broadcasted{SparseArrays.HigherOrderFns.SparseVecStyle, Nothing, typeof(-), Tuple{SparseArrays.SparseVector{Float64, Int64}, Base.Broadcast.Broadcasted{SparseArrays.HigherOrderFns.SparseVecStyle, Nothing, typeof(*), Tuple{Rational{Int64}, SparseArrays.SparseVector{Float64, Int64}}}}})

  • FrankWolfe.jl/src/utils.jl:368, MethodInstance for print(::IOBuffer, ::Main.FrankWolfe.Agnostic)

moi_optimizer

InferenceTimingNode: 2.410960/3.811841 on Core.Compiler.Timings.ROOT() with 18 direct children

image

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Shortstep, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Vector{Float64})

    FrankWolfe.jl/src/utils.jl:457, MethodInstance for (::Main.FrankWolfe.var"#print_callback##kw")(::NamedTuple{(:print_header,), Tuple{Bool}}, ::typeof(Main.FrankWolfe.print_callback), ::Vector{String}, ::String)

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Shortstep, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Vector{Float64})

    broadcast.jl:890, MethodInstance for materialize!(::Vector{Float64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Main.FrankWolfe.ScaledHotVector{Float64}}})

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Shortstep, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Vector{Float64})

    REPL[21]:1, MethodInstance for grad!(::Vector{Float64}, ::Vector{Float64})

    broadcast.jl:890, MethodInstance for materialize!(::Vector{Float64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Float64}, Main.FrankWolfe.ScaledHotVector{Float64}}})

  • show.jl:812, MethodInstance for show(::IOBuffer, ::Type{Main.FrankWolfe.Shortstep})

    show.jl:749, MethodInstance for show_unionaliases(::IOBuffer, ::Union)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

    julia/stdlib/v1.6/Printf/src/Printf.jl:702, MethodInstance for format(::Vector{UInt8}, ::Int64, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

movielens

InferenceTimingNode: 109.150781/112.783031 on Core.Compiler.Timings.ROOT() with 29 direct children

image

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for (::Main.FrankWolfe.var"#frank_wolfe##kw")(::NamedTuple{(:epsilon, :max_iteration, :print_iter, :verbose, :linesearch_tol, :line_search, :emphasis, :gradient, :callback), Tuple{Float64, Int64, Float64, Bool, Float64, Main.FrankWolfe.Adaptive, Main.FrankWolfe.Emphasis, SparseMatrixCSC{Float64, Int64}, var"#callback#12"{Vector{Tuple{Int64, Float64, Float64, Float64, Float64, Float64}}}}}, ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.NuclearNormLMO{Float64}, ::Main.FrankWolfe.RankOneMatrix{Float64, Vector{Float64}, Vector{Float64}})

    FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::SparseMatrixCSC{Float64, Int64}, ::Any, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::SparseMatrixCSC{Float64, Int64}, ::var"#callback#12"{Vector{Tuple{Int64, Float64, Float64, Float64, Float64, Float64}}}, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.NuclearNormLMO{Float64}, ::Main.FrankWolfe.RankOneMatrix{Float64, Vector{Float64}, Vector{Float64}})

    FrankWolfe.jl/src/utils.jl:7, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::SparseMatrixCSC{Float64, Int64}, ::Any, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

nonconvex_lasso

image

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Nonconvex, ::Float64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Float64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.ProbabilitySimplexOracle{Float64}, ::Vector{Float64})

    intfuncs.jl:761, MethodInstance for string(::Int64)

nuclear_norm

image

  • FrankWolfe.jl/src/norm_oracles.jl:151, MethodInstance for compute_extreme_point(::Main.FrankWolfe.NuclearNormLMO{Float64}, ::SparseMatrixCSC{Float64, Int64})

    .julia/packages/Arpack/pLziT/src/Arpack.jl:309, MethodInstance for (::Arpack.var"#svds##kw")(::NamedTuple{(:nsv, :tol), Tuple{Int64, Float64}}, ::typeof(Arpack.svds), ::SparseMatrixCSC{Float64, Int64})

  • FrankWolfe.jl/src/utils.jl:9, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::SparseMatrixCSC{Float64, Int64}, ::Any, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

    FrankWolfe.jl/src/utils.jl:70, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max,), Tuple{Float64}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseMatrixCSC{Float64, Int64}, ::Matrix{Float64}, ::Any, ::Float64)
    broadcast.jl:883, MethodInstance for materialize(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(-), Tuple{Arpack.AtA_or_AAt{Float64, SparseMatrixCSC{Float64, Int64}}}})

  • FrankWolfe.jl/src/utils.jl:9, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::SparseMatrixCSC{Float64, Int64}, ::Any, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

    FrankWolfe.jl/src/utils.jl:70, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max,), Tuple{Float64}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseMatrixCSC{Float64, Int64}, ::Matrix{Float64}, ::Any, ::Float64)

  • FrankWolfe.jl/src/utils.jl:9, MethodInstance for line_search_wrapper(::Main.FrankWolfe.Adaptive, ::Int64, ::Function, ::Function, ::Matrix{Float64}, ::Any, ::SparseMatrixCSC{Float64, Int64}, ::Any, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64)

    FrankWolfe.jl/src/utils.jl:70, MethodInstance for (::Main.FrankWolfe.var"#adaptive_step_size##kw")(::NamedTuple{(:gamma_max,), Tuple{Float64}}, ::typeof(Main.FrankWolfe.adaptive_step_size), ::Function, ::Function, ::SparseMatrixCSC{Float64, Int64}, ::Matrix{Float64}, ::Any, ::Float64)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:800, MethodInstance for format(::IO, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

polynomials

image

  • FrankWolfe.jl/src/afw.jl:10, MethodInstance for var"#away_frank_wolfe#85"(::Main.FrankWolfe.Adaptive, ::Float64, ::Int64, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Nothing, ::Int64, ::Int64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Vector{Float64}, ::Int64, ::var"#callback#30"{Vector{Any}}, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.away_frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.LpNormLMO{Float64, 1}, ::Main.FrankWolfe.ScaledHotVector{Float64})

    FrankWolfe.jl/src/active_set.jl:83, MethodInstance for active_set_update!(::Main.FrankWolfe.ActiveSet{Main.FrankWolfe.ScaledHotVector{Float64}, Float64, SparseArrays.SparseVector{Float64, Int64}}, ::Float64, ::Main.FrankWolfe.ScaledHotVector{Float64}, ::Bool, ::Nothing)

    broadcast.jl:890, MethodInstance for materialize!(::SparseArrays.SparseVector{Float64, Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(identity), Tuple{Int64}})

trajectory_comparison

InferenceTimingNode: 63.832704/65.261917 on Core.Compiler.Timings.ROOT() with 16 direct children

image

  • FrankWolfe.jl/src/fw_algorithms.jl:13, MethodInstance for var"#frank_wolfe#87"(::Main.FrankWolfe.Shortstep, ::Int64, ::Int64, ::Int64, ::Nothing, ::Float64, ::Int64, ::Float64, ::Bool, ::Bool, ::Float64, ::Main.FrankWolfe.Emphasis, ::Nothing, ::Nothing, ::Float64, ::typeof(Main.FrankWolfe.print_callback), ::typeof(Main.FrankWolfe.frank_wolfe), ::Function, ::Function, ::Main.FrankWolfe.LpNormLMO{Float64, 1}, ::SparseArrays.SparseVector{Float64, Int64})

    Enums.jl:26, MethodInstance for Symbol(::Main.FrankWolfe.Emphasis)

  • julia/stdlib/v1.6/Printf/src/Printf.jl:702, MethodInstance for format(::Vector{UInt8}, ::Int64, ::Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'s'}}}}, ::String)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
3 participants
@matbesancon @odow @hannahtro