Conversion issue from Py to Float64 using juliacall

[victorthouvenot]

I am currently working on a python wrapper for a julia package called FrankWolfe.jl (https://github.com/ZIB-IOL/FrankWolfe.jl)
I am using juliacall to call function of FrankWolfe, however i get an error when i set verbose to true on the function "frank_wolfe" ( https://github.com/ZIB-IOL/FrankWolfe.jl/blob/master/src/fw_algorithms.jl )

At line 41 : Float64(state.primal)
where state.primal is the output of the python function f of format <Py 0.12345 >

error :

"File "/home/victor/.julia/packages/PythonCall/wXfah/src/jlwrap/any.jl", line 208, in __call__
    return self._jl_callmethod($(pyjl_methodnum(pyjlany_call)), args, kwargs)
juliacall.JuliaError: MethodError: no method matching Float64(::Py)"

stacktrace

[1] (::FrankWolfe.var"#format_state#110")(state::FrankWolfe.CallbackState{Py, Py, Float64, SparseArrays.SparseVector{Float64, Int64}, FrankWolfe.ScaledHotVector{Float64}, SparseArrays.SparseVector{Float64, Int64}, Float64, Py, Py, FrankWolfe.ProbabilitySimplexOracle{Float64}, Vector{Float64}})
   @ FrankWolfe ~/.julia/packages/FrankWolfe/8HGAG/src/fw_algorithms.jl:38
 [2] (::FrankWolfe.var"#callback_with_prints#206"{Nothing, Int64, Vector{String}, String, FrankWolfe.var"#format_state#110"})(::FrankWolfe.CallbackState{Py, Py, Float64, SparseArrays.SparseVector{Float64, Int64}, FrankWolfe.ScaledHotVector{Float64}, SparseArrays.SparseVector{Float64, Int64}, Float64, Py, Py, FrankWolfe.ProbabilitySimplexOracle{Float64}, Vector{Float64}})
   @ FrankWolfe ~/.julia/packages/FrankWolfe/8HGAG/src/callback.jl:69
 [3] frank_wolfe(f::Py, grad!::Py, lmo::FrankWolfe.ProbabilitySimplexOracle{Float64}, x0::FrankWolfe.ScaledHotVector{Float64}; line_search::FrankWolfe.Agnostic{Float64}, momentum::Nothing, epsilon::Float64, max_iteration::Int64, print_iter::Int64, trajectory::Bool, verbose::Bool, memory_mode::FrankWolfe.InplaceEmphasis, gradient::Nothing, callback::Nothing, traj_data::Vector{Any}, timeout::Float64, linesearch_workspace::Nothing, dual_gap_compute_frequency::Int64)
   @ FrankWolfe ~/.julia/packages/FrankWolfe/8HGAG/src/fw_algorithms.jl:192
 [4] pyjlany_call(self::typeof(FrankWolfe.frank_wolfe), args_::Py, kwargs_::Py)
   @ PythonCall ~/.julia/packages/PythonCall/wXfah/src/jlwrap/any.jl:34
 [5] _pyjl_callmethod(f::Any, self_::Ptr{PythonCall.C.PyObject}, args_::Ptr{PythonCall.C.PyObject}, nargs::Int64)
   @ PythonCall ~/.julia/packages/PythonCall/wXfah/src/jlwrap/base.jl:69
 [6] _pyjl_callmethod(o::Ptr{PythonCall.C.PyObject}, args::Ptr{PythonCall.C.PyObject})
   @ PythonCall.C ~/.julia/packages/PythonCall/wXfah/src/cpython/jlwrap.jl:47

Here is the python code that calls the julia function :

def  test_simple_frankwolfe():

	def  f(x):
		return frankwolfe.norm(x)**2

	def  grad(storage,x):
		for i in  range(len(x)):
		storage[i] = x[i]

	lmo_prob = frankwolfe.ProbabilitySimplexOracle(1)

	x0 = frankwolfe.compute_extreme_point(lmo_prob,np.zeros(5))

	print(frankwolfe.frank_wolfe(f,grad,lmo_prob,x0,max_iteration=1000,line_search=frankwolfe.Agnostic(),verbose=True,))

Is there any way to convert the python function to a julia function before sending it to the frank_wolfe algorithm ?
Do you have any other idea to overcome this issue ?

[cjdoris]

I'm assuming the issue is in passing the Python function f to the Julia function frank_wolfe? So it becomes a Py Julia-side, which when called returns a Py not a Float64 as desired?

Here are some ways you can convert the function into a Julia one which returns a Float64:

# define it as a Julia function in the first place
f = jl.seval("x -> FrankWolfe.norm(x)^2")
# wrap it into a Julia function which converts the result
f = jl.seval("f -> x -> pyconvert(Float64, f(x))")(f)
# wrap it into a Python function which converts the result
f = (lambda f: lambda x: juliacall.convert(jl.Float64, f(x)))(f)